Thread Rating:
  • 11 Vote(s) - 4.55 Average
  • 1
  • 2
  • 3
  • 4
  • 5
Release ExtremeBunkerMaker v1.0 **EPIC**
#51
the best mod ever but one problem xD when i start it i can`t move Sad(( what can i do???
Reply

#52
Pls Help Ekhoorn
Reply

#53
Question 
Hi Eekhoorn!
I downloaded BunkerMaker, made a map, copied bukers from the BunkerExtractor BUT I DUNNO how to add bunkers to my mod..(

If you need here are my bunkers on NukeTown


PHP Code:
level.bunkerList[0] = createBlock((-411.367588.08, -53.4453), (000));
level.bunkerList[1] = createBlock((-403.533580.709, -26.3203), (000));
level.bunkerList[2] = createBlock((-403.533580.7090.804676), (000));
level.bunkerList[3] = createBlock((-403.533580.70927.9297), (000));
level.bunkerList[4] = createBlock((-403.533580.70955.0547), (000));
level.bunkerList[5] = createBlock((-403.533580.70982.1797), (000));
level.bunkerList[6] = createBlock((-403.533580.709109.305), (000));
level.bunkerList[7] = createBlock((-403.533580.709136.43), (000));
level.bunkerList[8] = createBlock((-391.545576.346163.555), (000));
level.bunkerList[9] = createBlock((-374.796532.056, -52.4827), (000));
level.bunkerList[10] = createBlock((-374.796532.056, -25.3577), (000));
level.bunkerList[11] = createBlock((-374.796532.0561.7673), (000));
level.bunkerList[12] = createBlock((-374.796532.05628.8923), (000));
level.bunkerList[13] = createBlock((-374.796532.05656.0173), (000));
level.bunkerList[14] = createBlock((-374.796532.05683.1423), (000));
level.bunkerList[15] = createBlock((-374.796524.706110.267), (000));
level.bunkerList[16] = createBlock((-374.796524.706137.392), (000));
level.bunkerList[17] = createBlock((-374.796524.706164.517), (000));
level.bunkerList[18] = createBlock((-361.807477.876, -51.3869), (000));
level.bunkerList[19] = createBlock((-361.807477.876, -24.2619), (000));
level.bunkerList[20] = createBlock((-361.807477.8762.86305), (000));
level.bunkerList[21] = createBlock((-361.807477.87629.9881), (000));
level.bunkerList[22] = createBlock((-361.807473.06557.1131), (000));
level.bunkerList[23] = createBlock((-361.807473.06584.2381), (000));
level.bunkerList[24] = createBlock((-361.807473.065111.363), (000));
level.bunkerList[25] = createBlock((-361.807473.065138.488), (000));
level.bunkerList[26] = createBlock((-361.807473.065165.613), (000));
level.bunkerList[27] = createBlock((-318.201467.922, -51.053), (000));
level.bunkerList[28] = createBlock((-318.201467.922, -23.928), (000));
level.bunkerList[29] = createBlock((-138.639544.307, -51.0783), (000));
level.bunkerList[30] = createBlock((-138.639544.307, -23.9533), (000));
level.bunkerList[31] = createBlock((-102.998547.814, -52.1806), (000));
level.bunkerList[32] = createBlock((-102.998547.814, -25.0556), (000));
level.bunkerList[33] = createBlock((-67.3569544.494, -53.3382), (000));
level.bunkerList[34] = createBlock((-67.3569544.494, -26.2132), (000));
level.bunkerList[35] = createBlock((-25.3832510.838, -56.9342), (000));
level.bunkerList[36] = createBlock((-25.3832510.838, -29.8092), (000));
level.bunkerList[37] = createBlock((-148.896492.666, -52.0846), (000));
level.bunkerList[38] = createBlock((-182.018440.362, -52.7303), (000));
level.bunkerList[39] = createBlock((-230.968355.963, -58.9746), (000));
level.bunkerList[40] = createBlock((-195.328388.721, -59.0068), (000));
level.bunkerList[41] = createBlock((-266.785314.389, -53.3715), (000));
level.bunkerList[42] = createBlock((-300.267270.481, -52.6936), (000));
level.bunkerList[43] = createBlock((-333.134225.959, -52.1908), (000));
level.bunkerList[44] = createBlock((-360.131176.135, -51.7399), (000));
level.bunkerList[45] = createBlock((-374.813118.704, -52.988), (000));
level.bunkerList[46] = createBlock((-410.45478.2754, -50.6637), (000));
level.bunkerList[47] = createBlock((-446.09467.4184, -49.9945), (000));
level.bunkerList[48] = createBlock((-481.73576.5457, -49.4587), (000));
level.bunkerList[49] = createBlock((-481.73576.5457, -22.3337), (000));
level.bunkerList[50] = createBlock((-481.73576.54574.79129), (000));
level.bunkerList[51] = createBlock((-481.73576.545731.9163), (000));
level.bunkerList[52] = createBlock((-481.73576.545759.0413), (000));
level.bunkerList[53] = createBlock((-481.73576.545786.1663), (000));
level.bunkerList[54] = createBlock((-481.73576.5457113.291), (000));
level.bunkerList[55] = createBlock((-481.73576.5457140.416), (000));
level.bunkerList[56] = createBlock((-446.09462.4352, -22.8695), (000));
level.bunkerList[57] = createBlock((-446.09462.43524.25549), (000));
level.bunkerList[58] = createBlock((-446.09462.435231.3805), (000));
level.bunkerList[59] = createBlock((-446.09462.435258.5055), (000));
level.bunkerList[60] = createBlock((-446.09462.435285.6305), (000));
level.bunkerList[61] = createBlock((-446.09462.4352112.755), (000));
level.bunkerList[62] = createBlock((-446.09462.4352139.88), (000));
level.bunkerList[63] = createBlock((-410.45483.3641, -23.5387), (000));
level.bunkerList[64] = createBlock((-410.45483.36413.58627), (000));
level.bunkerList[65] = createBlock((-410.45483.364130.7113), (000));
level.bunkerList[66] = createBlock((-410.45483.364157.8363), (000));
level.bunkerList[67] = createBlock((-410.45483.364184.9613), (000));
level.bunkerList[68] = createBlock((-410.45483.3641112.086), (000));
level.bunkerList[69] = createBlock((-410.45483.3641139.211), (000));
level.bunkerList[70] = createBlock((-374.813109.332, -25.863), (000));
level.bunkerList[71] = createBlock((-374.813109.3321.26199), (000));
level.bunkerList[72] = createBlock((-374.813109.33228.387), (000));
level.bunkerList[73] = createBlock((-374.813109.33255.512), (000));
level.bunkerList[74] = createBlock((-374.813109.33282.637), (000));
level.bunkerList[75] = createBlock((-374.813109.332109.762), (000));
level.bunkerList[76] = createBlock((-374.813109.332136.887), (000));
level.bunkerList[77] = createBlock((-523.82796.3207, -48.2837), (000));
level.bunkerList[78] = createBlock((-517.37691.5772, -21.1587), (000));
level.bunkerList[79] = createBlock((-517.37691.57725.96634), (000));
level.bunkerList[80] = createBlock((-517.37691.577233.0913), (000));
level.bunkerList[81] = createBlock((-517.37691.577260.2163), (000));
level.bunkerList[82] = createBlock((-517.37691.577287.3413), (000));
level.bunkerList[83] = createBlock((-517.37691.5772114.466), (000));
level.bunkerList[84] = createBlock((-517.37691.5772141.591), (000));
level.bunkerList[85] = createBlock((-569.777143.399, -46.875), (000));
level.bunkerList[86] = createBlock((-569.777143.399, -19.75), (000));
level.bunkerList[87] = createBlock((-569.777143.3997.375), (000));
level.bunkerList[88] = createBlock((-569.777143.39934.5), (000));
level.bunkerList[89] = createBlock((-569.777143.39961.625), (000));
level.bunkerList[90] = createBlock((-569.777143.39988.75), (000));
level.bunkerList[91] = createBlock((-569.777143.399115.875), (000));
level.bunkerList[92] = createBlock((-569.777143.399143), (000));
level.bunkerList[93] = createBlock((-151.102492.666, -24.9596), (000));
level.bunkerList[94] = createBlock((-151.102492.6662.16537), (000));
level.bunkerList[95] = createBlock((-268.459289.369, -26.2465), (000));
level.bunkerList[96] = createBlock((-268.459289.3690.878517), (000));
level.bunkerList[97] = createBlock((-268.459289.36928.0035), (000));
level.bunkerList[98] = createBlock((-263.544298.96155.1285), (000));
level.bunkerList[99] = createBlock((-263.544298.96182.2535), (000));
level.bunkerList[100] = createBlock((-249.578343.549, -26.2465), (000));
level.bunkerList[101] = createBlock((-249.578350.6020.878517), (000));
level.bunkerList[102] = createBlock((-249.578350.60228.0035), (000));
level.bunkerList[103] = createBlock((-249.578350.60255.1285), (000));
level.bunkerList[104] = createBlock((-249.578350.60282.2535), (000));
level.bunkerList[105] = createBlock((-212.919398.687, -27.2415), (000));
level.bunkerList[106] = createBlock((-212.919398.687, -0.116455), (000));
level.bunkerList[107] = createBlock((-212.919398.68727.0085), (000));
level.bunkerList[108] = createBlock((-212.919398.68754.1335), (000));
level.bunkerList[109] = createBlock((-212.919398.68781.2585), (000));
level.bunkerList[110] = createBlock((-192.612457.797, -25.6053), (000));
level.bunkerList[111] = createBlock((-192.612457.7971.51972), (000));
level.bunkerList[112] = createBlock((-192.612457.79728.6447), (000));
level.bunkerList[113] = createBlock((-192.612457.79755.7697), (000));
level.bunkerList[114] = createBlock((-192.612457.79782.8947), (000));
level.bunkerList[115] = createBlock((-314.545238.952, -25.0658), (000));
level.bunkerList[116] = createBlock((-314.545238.9522.05918), (000));
level.bunkerList[117] = createBlock((-314.545238.95229.1842), (000));
level.bunkerList[118] = createBlock((-314.545238.95256.3092), (000));
level.bunkerList[119] = createBlock((-314.545238.95283.4342), (000));
level.bunkerList[120] = createBlock((-349.011198.487, -24.6149), (000));
level.bunkerList[121] = createBlock((-349.011198.4872.5101), (000));
level.bunkerList[122] = createBlock((-349.011198.48729.6351), (000));
level.bunkerList[123] = createBlock((-349.011198.48756.7601), (000));
level.bunkerList[124] = createBlock((-349.011198.48783.8851), (000));
level.bunkerList[125] = createBlock((-384.652162.666, -25.2077), (000));
level.bunkerList[126] = createBlock((-384.652162.6661.91727), (000));
level.bunkerList[127] = createBlock((-384.652162.66629.0423), (000));
level.bunkerList[128] = createBlock((-384.652162.66656.1673), (000));
level.bunkerList[129] = createBlock((-384.652162.66683.2923), (000));
level.bunkerList[130] = createBlock((-316.382468.7683.19697), (000));
level.bunkerList[131] = createBlock((-316.382468.76830.322), (000));
level.bunkerList[132] = createBlock((-317.951460.13557.447), (000));
level.bunkerList[133] = createBlock((-317.951460.13584.572), (000));
level.bunkerList[134] = createBlock((-315.274467.463111.697), (000));
level.bunkerList[135] = createBlock((-315.274467.463138.822), (000));
level.bunkerList[136] = createBlock((-315.274467.463165.947), (000));
level.bunkerList[137] = createBlock((-386.989169.2110.417), (000));
level.bunkerList[138] = createBlock((-386.989169.2137.542), (000));
level.bunkerList[139] = createBlock((-552.941195.04, -46.8913), (000));
level.bunkerList[140] = createBlock((-552.941195.04, -19.7663), (000));
level.bunkerList[141] = createBlock((-552.941195.047.35867), (000));
level.bunkerList[142] = createBlock((-552.941195.0434.4837), (000));
level.bunkerList[143] = createBlock((-552.941195.0461.6087), (000));
level.bunkerList[144] = createBlock((-552.941195.0488.7337), (000));
level.bunkerList[145] = createBlock((48.4894359.78, -26.524), (000));
level.bunkerList[146] = createBlock((48.7118359.720.601009), (000));
level.bunkerList[147] = createBlock((50.9927360.33227.726), (000));
level.bunkerList[148] = createBlock((-27.7597521.873, -2.6842), (000));
level.bunkerList[149] = createBlock((-27.7597521.87324.4408), (000));
level.bunkerList[150] = createBlock((-63.4006533.4820.91177), (000));
level.bunkerList[151] = createBlock((-63.4006533.48228.0368), (000));
level.bunkerList[152] = createBlock((-99.0415537.1062.0694), (000));
level.bunkerList[153] = createBlock((-99.0415537.10629.1944), (000));
level.bunkerList[154] = createBlock((-141.148547.4723.17171), (000));
level.bunkerList[155] = createBlock((-141.148547.47230.2967), (000));
level.bunkerList[156] = createBlock((-148.61491.38729.2904), (000));
level.bunkerList[157] = createBlock((-148.61491.38756.4154), (000));
level.bunkerList[158] = createBlock((85.1967123.317, -57.5875), (000));
level.bunkerList[159] = createBlock((85.1967123.317, -30.4625), (000));
level.bunkerList[160] = createBlock((85.1967123.317, -3.33748), (000));
level.bunkerList[161] = createBlock((85.1967123.31723.7875), (000));
level.bunkerList[162] = createBlock((81.2957122.27150.9125), (000));
level.bunkerList[163] = createBlock((49.5558105.212, -57.4357), (000));
level.bunkerList[164] = createBlock((49.5558105.212, -30.3107), (000));
level.bunkerList[165] = createBlock((45.6548105.212, -3.18569), (000));
level.bunkerList[166] = createBlock((45.6548105.21223.9393), (000));
level.bunkerList[167] = createBlock((45.6548105.21251.0643), (000));
level.bunkerList[168] = createBlock((10.013982.6871, -57.5442), (000));
level.bunkerList[169] = createBlock((10.013982.6871, -30.4192), (000));
level.bunkerList[170] = createBlock((10.013982.6871, -3.29423), (000));
level.bunkerList[171] = createBlock((10.013982.687123.8308), (000));
level.bunkerList[172] = createBlock((10.013982.687150.9558), (000));
level.bunkerList[173] = createBlock((-25.62762.8454, -57.7129), (000));
level.bunkerList[174] = createBlock((-25.62762.8454, -30.5879), (000));
level.bunkerList[175] = createBlock((-25.62762.8454, -3.46292), (000));
level.bunkerList[176] = createBlock((-25.62762.845423.6621), (000));
level.bunkerList[177] = createBlock((-25.62762.845450.7871), (000));
level.bunkerList[178] = createBlock((-131.533, -182.402, -59.0626), (000));
level.bunkerList[179] = createBlock((-131.533, -182.402, -31.9376), (000));
level.bunkerList[180] = createBlock((-131.533, -182.402, -4.81261), (000));
level.bunkerList[181] = createBlock((-131.533, -182.40222.3124), (000));
level.bunkerList[182] = createBlock((-131.533, -182.40249.4374), (000));
level.bunkerList[183] = createBlock((-141.31, -177.18176.5624), (000));
level.bunkerList[184] = createBlock((-141.31, -177.181103.687), (000));
level.bunkerList[185] = createBlock((-167.173, -202.284, -53.0026), (000));
level.bunkerList[186] = createBlock((-167.173, -202.284, -25.8776), (000));
level.bunkerList[187] = createBlock((-167.173, -202.2841.24743), (000));
level.bunkerList[188] = createBlock((-202.814, -202.284, -33.6278), (000));
level.bunkerList[189] = createBlock((-202.814, -202.284, -6.50278), (000));
level.bunkerList[190] = createBlock((-176.951, -203.29428.3724), (000));
level.bunkerList[191] = createBlock((-176.951, -203.29455.4974), (000));
level.bunkerList[192] = createBlock((-176.951, -203.29482.6224), (000));
level.bunkerList[193] = createBlock((-212.592, -203.4120.6222), (000));
level.bunkerList[194] = createBlock((-212.592, -203.4147.7472), (000));
level.bunkerList[195] = createBlock((-212.592, -203.4174.8722), (000));
level.bunkerList[196] = createBlock((-212.592, -203.41101.997), (000));
level.bunkerList[197] = createBlock((-251.152, -200.719, -51.3462), (000));
level.bunkerList[198] = createBlock((-251.152, -200.719, -24.2212), (000));
level.bunkerList[199] = createBlock((-251.152, -200.7192.9038), (000));
level.bunkerList[200] = createBlock((-251.152, -200.71930.0288), (000));
level.bunkerList[201] = createBlock((-251.152, -200.71957.1538), (000));
level.bunkerList[202] = createBlock((-251.152, -200.71984.2788), (000));
level.bunkerList[203] = createBlock((-286.793, -196.663, -21.6635), (000));
level.bunkerList[204] = createBlock((-286.793, -214.3885.46149), (000));
level.bunkerList[205] = createBlock((-286.793, -214.38832.5865), (000));
level.bunkerList[206] = createBlock((-286.793, -214.38859.7115), (000));
level.bunkerList[207] = createBlock((-286.793, -214.38886.8365), (000));
level.bunkerList[208] = createBlock((-365.756, -210.68, -49.7635), (000));
level.bunkerList[209] = createBlock((-365.756, -210.68, -22.6385), (000));
level.bunkerList[210] = createBlock((-365.756, -210.684.48646), (000));
level.bunkerList[211] = createBlock((-365.756, -210.6831.6115), (000));
level.bunkerList[212] = createBlock((-365.756, -210.6858.7365), (000));
level.bunkerList[213] = createBlock((-365.756, -210.6885.8615), (000));
level.bunkerList[214] = createBlock((-374.721, -159.039, -49.6322), (000));
level.bunkerList[215] = createBlock((-374.721, -159.039, -22.5072), (000));
level.bunkerList[216] = createBlock((-374.721, -159.0394.61777), (000));
level.bunkerList[217] = createBlock((-374.721, -159.03931.7428), (000));
level.bunkerList[218] = createBlock((-374.721, -159.03958.8678), (000));
level.bunkerList[219] = createBlock((-374.721, -159.03985.9928), (000));
level.bunkerList[220] = createBlock((-386.956, -107.392, -50.1385), (000));
level.bunkerList[221] = createBlock((-386.956, -107.392, -23.0135), (000));
level.bunkerList[222] = createBlock((-386.956, -107.3924.11153), (000));
level.bunkerList[223] = createBlock((-386.956, -107.39231.2365), (000));
level.bunkerList[224] = createBlock((-386.956, -107.39258.3615), (000));
level.bunkerList[225] = createBlock((-386.956, -107.39285.4865), (000));
level.bunkerList[226] = createBlock((-401.471, -55.7511, -50.3412), (000));
level.bunkerList[227] = createBlock((-401.471, -55.7511, -23.2162), (000));
level.bunkerList[228] = createBlock((-401.471, -55.75113.90877), (000));
level.bunkerList[229] = createBlock((-401.471, -55.751131.0338), (000));
level.bunkerList[230] = createBlock((-401.471, -55.751158.1588), (000));
level.bunkerList[231] = createBlock((-401.471, -55.751185.2838), (000));
level.bunkerList[232] = createBlock((-409.5192.9439, -50.5692), (000));
level.bunkerList[233] = createBlock((-409.5192.9439, -23.4442), (000));
level.bunkerList[234] = createBlock((-409.5192.94393.68076), (000));
level.bunkerList[235] = createBlock((-409.5192.943930.8058), (000));
level.bunkerList[236] = createBlock((-409.5192.943957.9308), (000));
level.bunkerList[237] = createBlock((-409.5192.943985.0558), (000));
level.bunkerList[238] = createBlock((-554.934195.04115.859), (000));
level.bunkerList[239] = createBlock((-554.934195.04142.984), (000));
level.bunkerList[240] = createBlock((-191.706534.93246.0425), (000));
level.bunkerList[241] = createBlock((-191.706534.93273.1675), (000));
level.bunkerList[242] = createBlock((-191.706534.932100.293), (000));
level.bunkerList[243] = createBlock((-191.706534.932127.418), (000));
level.bunkerList[244] = createBlock((-191.706534.932154.543), (000));
level.bunkerList[245] = createBlock((-191.706534.932181.668), (000));
level.bunkerList[246] = createBlock((-191.706534.932181.668), (000));
level.bunkerList[247] = createBlock((-279.633485.99676.125), (000));
level.bunkerList[248] = createBlock((-279.633485.996103.25), (000));
level.bunkerList[249] = createBlock((-279.633485.996130.375), (000));
level.bunkerList[250] = createBlock((-279.633485.996157.5), (000));
level.bunkerList[251] = createBlock((-244.099525.37646.625), (000));
level.bunkerList[252] = createBlock((-244.099525.37673.75), (000));
level.bunkerList[253] = createBlock((-244.099525.376100.875), (000));
level.bunkerList[254] = createBlock((-244.099525.376128), (000));
level.bunkerList[255] = createBlock((-244.099525.376155.125), (000));
level.bunkerList[256] = createBlock((-148.888543.02857.4217), (000));
level.bunkerList[257] = createBlock((-148.888543.02884.5467), (000));
level.bunkerList[258] = createBlock((-148.888543.028111.672), (000));
level.bunkerList[259] = createBlock((-148.888543.028138.797), (000));
level.bunkerList[260] = createBlock((-148.888543.028165.922), (000));
level.bunkerList[261] = createBlock((-112.969527.41156.3456), (000));
level.bunkerList[262] = createBlock((-112.969527.41183.4706), (000));
level.bunkerList[263] = createBlock((-112.969527.411110.596), (000));
level.bunkerList[264] = createBlock((-112.969527.411137.721), (000));
level.bunkerList[265] = createBlock((-112.969527.411164.846), (000));
level.bunkerList[266] = createBlock((-112.969527.411191.971), (000));
level.bunkerList[267] = createBlock((-77.3279537.97256.0974), (000));
level.bunkerList[268] = createBlock((-77.3279537.97283.2224), (000));
level.bunkerList[269] = createBlock((-77.3279537.972110.347), (000));
level.bunkerList[270] = createBlock((-77.3279537.972137.472), (000));
level.bunkerList[271] = createBlock((-77.3279537.972164.597), (000));
level.bunkerList[272] = createBlock((-77.3279537.972191.722), (000));
level.bunkerList[273] = createBlock((-41.6869517.6854.9398), (000));
level.bunkerList[274] = createBlock((-41.6869517.6882.0648), (000));
level.bunkerList[275] = createBlock((-41.6869517.68109.19), (000));
level.bunkerList[276] = createBlock((-41.6869517.68136.315), (000));
level.bunkerList[277] = createBlock((-41.6869517.68163.44), (000));
level.bunkerList[278] = createBlock((260.16328.0571, -59.8896), (000));
level.bunkerList[279] = createBlock((260.44328.1322, -32.7646), (000));
level.bunkerList[280] = createBlock((260.73128.2095, -5.63964), (000));
level.bunkerList[281] = createBlock((261.0228.286821.4854), (000));
level.bunkerList[282] = createBlock((261.30828.364148.6104), (000));
level.bunkerList[283] = createBlock((281.353, -23.2824, -59.3156), (000));
level.bunkerList[284] = createBlock((281.353, -23.2826, -32.1906), (000));
level.bunkerList[285] = createBlock((281.353, -23.2826, -5.06555), (000));
level.bunkerList[286] = createBlock((281.353, -23.282622.0594), (000));
level.bunkerList[287] = createBlock((281.353, -23.282649.1844), (000));
level.bunkerList[288] = createBlock((296.551, -74.9235, -52.8044), (000));
level.bunkerList[289] = createBlock((296.551, -74.9235, -25.6794), (000));
level.bunkerList[290] = createBlock((296.551, -74.92351.44558), (000));
level.bunkerList[291] = createBlock((296.551, -74.923528.5706), (000));
level.bunkerList[292] = createBlock((326.999, -162.695, -51.5185), (000));
level.bunkerList[293] = createBlock((326.999, -162.695, -24.3935), (000));
level.bunkerList[294] = createBlock((326.999, -162.6952.73152), (000));
level.bunkerList[295] = createBlock((326.999, -162.69529.8565), (000));
level.bunkerList[296] = createBlock((326.999, -162.69556.9815), (000));
level.bunkerList[297] = createBlock((627.33417.531, -48.1198), (000));
level.bunkerList[298] = createBlock((627.33417.531, -20.9948), (000));
level.bunkerList[299] = createBlock((627.33417.5316.13021), (000));
level.bunkerList[300] = createBlock((627.329417.53433.2552), (000));
level.bunkerList[301] = createBlock((627.329417.53460.3802), (000));
level.bunkerList[302] = createBlock((627.329417.53460.3802), (000));
level.bunkerList[303] = createBlock((627.329417.53460.3802), (000));
level.bunkerList[304] = createBlock((615.908469.424, -48.0839), (000));
level.bunkerList[305] = createBlock((615.908469.424, -20.9589), (000));
level.bunkerList[306] = createBlock((615.908469.4246.16612), (000));
level.bunkerList[307] = createBlock((615.908469.42433.2911), (000));
level.bunkerList[308] = createBlock((615.908469.42460.4161), (000));
level.bunkerList[309] = createBlock((584.87515.776, -48.3533), (000));
level.bunkerList[310] = createBlock((584.87515.776, -21.2283), (000));
level.bunkerList[311] = createBlock((584.87515.7765.89671), (000));
level.bunkerList[312] = createBlock((584.87515.77633.0217), (000));
level.bunkerList[313] = createBlock((551.416559.713, -48.667), (000));
level.bunkerList[314] = createBlock((551.416559.713, -21.542), (000));
level.bunkerList[315] = createBlock((551.416559.7135.58297), (000));
level.bunkerList[316] = createBlock((551.416559.71332.708), (000));
level.bunkerList[317] = createBlock((520.638606.324, -48.9317), (000));
level.bunkerList[318] = createBlock((520.638606.324, -21.8067), (000));
level.bunkerList[319] = createBlock((520.638606.3245.31831), (000));
level.bunkerList[320] = createBlock((484.997622.747, -49.3838), (000));
level.bunkerList[321] = createBlock((484.997622.747, -22.2588), (000));
level.bunkerList[322] = createBlock((449.356615.261, -49.9285), (000));
level.bunkerList[323] = createBlock((449.356615.261, -22.8035), (000));
level.bunkerList[324] = createBlock((449.356615.2614.32146), (000));
level.bunkerList[325] = createBlock((449.356615.26131.4465), (000));
level.bunkerList[326] = createBlock((446.624628.57758.5715), (000));
level.bunkerList[327] = createBlock((413.715587.574, -50.5517), (000));
level.bunkerList[328] = createBlock((413.715587.574, -23.4267), (000));
level.bunkerList[329] = createBlock((412.401587.2223.69835), (000));
level.bunkerList[330] = createBlock((412.401587.22230.8233), (000));
level.bunkerList[331] = createBlock((412.401587.22257.9483), (000));
level.bunkerList[332] = createBlock((376.76576.728, -50.875), (000));
level.bunkerList[333] = createBlock((376.76576.728, -23.75), (000));
level.bunkerList[334] = createBlock((376.76576.7283.375), (000));
level.bunkerList[335] = createBlock((376.76576.72830.5), (000));
level.bunkerList[336] = createBlock((376.76576.72857.625), (000));
level.bunkerList[337] = createBlock((341.119543.825, -50.875), (000));
level.bunkerList[338] = createBlock((341.119543.825, -23.75), (000));
level.bunkerList[339] = createBlock((341.119543.8253.375), (000));
level.bunkerList[340] = createBlock((341.119543.82530.5), (000));
level.bunkerList[341] = createBlock((341.119543.82557.625), (000));
level.bunkerList[342] = createBlock((306.407504.269, -50.875), (000));
level.bunkerList[343] = createBlock((306.407504.269, -23.75), (000));
level.bunkerList[344] = createBlock((306.407504.2693.375), (000));
level.bunkerList[345] = createBlock((306.407504.26930.5), (000));
level.bunkerList[346] = createBlock((306.407504.26957.625), (000));
level.bunkerList[347] = createBlock((270.78468.156, -54.9709), (000));
level.bunkerList[348] = createBlock((270.78468.156, -27.8459), (000));
level.bunkerList[349] = createBlock((270.78468.156, -0.720909), (000));
level.bunkerList[350] = createBlock((270.78468.15626.4041), (000));
level.bunkerList[351] = createBlock((270.78468.15653.5291), (000));
level.bunkerList[352] = createBlock((235.139437.415, -58.9496), (000));
level.bunkerList[353] = createBlock((235.139437.415, -31.8246), (000));
level.bunkerList[354] = createBlock((235.139437.415, -4.69961), (000));
level.bunkerList[355] = createBlock((235.139437.41522.4254), (000));
level.bunkerList[356] = createBlock((235.139437.41549.5504), (000));
level.bunkerList[357] = createBlock((189.336414.566, -59.2747), (000));
level.bunkerList[358] = createBlock((189.336414.566, -32.1497), (000));
level.bunkerList[359] = createBlock((189.336414.566, -5.02465), (000));
level.bunkerList[360] = createBlock((189.336414.56622.1003), (000));
level.bunkerList[361] = createBlock((189.336414.56649.2253), (000));
level.bunkerList[362] = createBlock((61.2548291.816, -26.3416), (000));
level.bunkerList[363] = createBlock((61.2548291.8160.783443), (000));
level.bunkerList[364] = createBlock((68.8097293.8427.9084), (000));
level.bunkerList[365] = createBlock((-873.129820.038, -54.2785), (000));
level.bunkerList[366] = createBlock((-873.129820.038, -27.1535), (000));
level.bunkerList[367] = createBlock((-873.129820.038, -0.028511), (000));
level.bunkerList[368] = createBlock((-873.129820.03827.0965), (000));
level.bunkerList[369] = createBlock((-873.129820.03854.2215), (000));
level.bunkerList[370] = createBlock((-873.129820.03881.3465), (000));
level.bunkerList[371] = createBlock((-873.129820.038108.471), (000));
level.bunkerList[372] = createBlock((-873.129820.038135.596), (000));
level.bunkerList[373] = createBlock((-873.129820.038162.721), (000));
level.bunkerList[374] = createBlock((-873.129820.038189.846), (000));
level.bunkerList[375] = createBlock((738.381951.832, -52.8053), (000));
level.bunkerList[376] = createBlock((738.381951.832, -25.6803), (000));
level.bunkerList[377] = createBlock((738.381951.8321.4447), (000));
level.bunkerList[378] = createBlock((738.381951.83228.5697), (000));
level.bunkerList[379] = createBlock((738.381951.83255.6947), (000));
level.bunkerList[380] = createBlock((748.756900.191, -53.2848), (000));
level.bunkerList[381] = createBlock((748.756900.191, -26.1598), (000));
level.bunkerList[382] = createBlock((748.756900.1910.965248), (000));
level.bunkerList[383] = createBlock((748.756900.19128.0902), (000));
level.bunkerList[384] = createBlock((748.756900.19155.2152), (000));
level.bunkerList[385] = createBlock((758.139835.694, -53.875), (000));
level.bunkerList[386] = createBlock((758.139835.694, -26.75), (000));
level.bunkerList[387] = createBlock((758.139835.6940.375), (000));
level.bunkerList[388] = createBlock((758.139835.69427.5), (000));
level.bunkerList[389] = createBlock((758.139835.69454.625), (000));
level.bunkerList[390] = createBlock((-871.556905.108, -53.9828), (000));
level.bunkerList[391] = createBlock((-871.556905.108, -26.8578), (000));
level.bunkerList[392] = createBlock((-871.556905.1080.267242), (000));
level.bunkerList[393] = createBlock((-871.556905.10827.3922), (000));
level.bunkerList[394] = createBlock((-871.556905.10854.5172), (000));
level.bunkerList[395] = createBlock((-871.556905.10881.6422), (000));
level.bunkerList[396] = createBlock((-871.556905.108108.767), (000));
level.bunkerList[397] = createBlock((-871.556905.108135.892), (000));
level.bunkerList[398] = createBlock((-871.556905.108163.017), (000));
level.bunkerList[399] = createBlock((-871.556905.108190.142), (000));
level.minigunList[0] = createMinigun((-576.794308.24879.125), (0, -9.000850));
level.minigunList[1] = createMinigun((-435.87425.80775.125), (0, -17.28820));
level.minigunList[2] = createMinigun((-493.872250.44875.125), (0, -23.42040));
level.minigunList[3] = createMinigun((643.40631.381879.125), (0163.9250));
level.minigunList[4] = createMinigun((471.124269.78876.7777), (0175.9190));
level.minigunList[5] = createMinigun((493.36140.36875.5126), (0167.7370)); 

PLASE EEKHOORN!!!
Need help..( Can you make _rank.gsc (or another, i dont even know what file to modify for maps) so Can you fill up my STANDART _rank.gsc with my bunker list up there??? If you need here is _rank.gsc

PHP Code:
#include common_scripts\utility;
#include maps\mp\_utility;
#include maps\mp\gametypes\_hud_util;


init()
{
    
level.scoreInfo = [];
    
level.xpScale GetDvarInt#"scr_xpscale" );
    
level.codPointsXpScale GetDvarFloat#"scr_codpointsxpscale" );
    
level.codPointsMatchScale GetDvarFloat#"scr_codpointsmatchscale" );
    
level.codPointsChallengeScale GetDvarFloat#"scr_codpointsperchallenge" );
    
level.rankXpCap GetDvarInt#"scr_rankXpCap" );
    
level.codPointsCap GetDvarInt#"scr_codPointsCap" );    

    
level.rankTable = [];

    
precacheShader("white");

    
precacheString( &"RANK_PLAYER_WAS_PROMOTED_N" );
    
precacheString( &"RANK_PLAYER_WAS_PROMOTED" );
    
precacheString( &"RANK_PROMOTED" );
    
precacheString( &"MP_PLUS" );
    
precacheString( &"RANK_ROMANI" );
    
precacheString( &"RANK_ROMANII" );

    if ( 
level.teamBased )
    {
        
registerScoreInfo"kill"100 );
        
registerScoreInfo"headshot"100 );
        
registerScoreInfo"assist_75"80 );
        
registerScoreInfo"assist_50"60 );
        
registerScoreInfo"assist_25"40 );
        
registerScoreInfo"assist"20 );
        
registerScoreInfo"suicide");
        
registerScoreInfo"teamkill");
        
registerScoreInfo"dogkill"30 );
        
registerScoreInfo"dogassist"10 );
        
registerScoreInfo"helicopterkill"200 );
        
registerScoreInfo"helicopterassist"100 );
        
registerScoreInfo"helicopterassist_75");
        
registerScoreInfo"helicopterassist_50");
        
registerScoreInfo"helicopterassist_25");
        
registerScoreInfo"spyplanekill"100 );
        
registerScoreInfo"spyplaneassist"50 );
        
registerScoreInfo"rcbombdestroy"50 );
    }
    else
    {
        
registerScoreInfo"kill"50 );
        
registerScoreInfo"headshot"50 );
        
registerScoreInfo"assist_75");
        
registerScoreInfo"assist_50");
        
registerScoreInfo"assist_25");
        
registerScoreInfo"assist");
        
registerScoreInfo"suicide");
        
registerScoreInfo"teamkill");
        
registerScoreInfo"dogkill"20 );
        
registerScoreInfo"dogassist");
        
registerScoreInfo"helicopterkill"100 );
        
registerScoreInfo"helicopterassist");
        
registerScoreInfo"helicopterassist_75");
        
registerScoreInfo"helicopterassist_50");
        
registerScoreInfo"helicopterassist_25");
        
registerScoreInfo"spyplanekill"25 );
        
registerScoreInfo"spyplaneassist");
        
registerScoreInfo"rcbombdestroy"30 );
    }
    
    
registerScoreInfo"win");
    
registerScoreInfo"loss"0.5 );
    
registerScoreInfo"tie"0.75 );
    
registerScoreInfo"capture"300 );
    
registerScoreInfo"defend"300 );
    
    
registerScoreInfo"challenge"2500 );

    
level.maxRank int(tableLookup"mp/rankTable.csv"0"maxrank"));
    
level.maxPrestige int(tableLookup"mp/rankIconTable.csv"0"maxprestige"));
    
    
pId 0;
    
rId 0;
    for ( 
pId 0pId <= level.maxPrestigepId++ )
    {
        
// the rank icons are different
        
for ( rId 0rId <= level.maxRankrId++ )
            
precacheShadertableLookup"mp/rankIconTable.csv"0rIdpId+) );
    }

    
rankId 0;
    
rankName tableLookup"mp/ranktable.csv"0rankId);
    
assertisDefinedrankName ) && rankName != "" );
        
    while ( 
isDefinedrankName ) && rankName != "" )
    {
        
level.rankTable[rankId][1] = tableLookup"mp/ranktable.csv"0rankId);
        
level.rankTable[rankId][2] = tableLookup"mp/ranktable.csv"0rankId);
        
level.rankTable[rankId][3] = tableLookup"mp/ranktable.csv"0rankId);
        
level.rankTable[rankId][7] = tableLookup"mp/ranktable.csv"0rankId);
        
level.rankTable[rankId][14] = tableLookup"mp/ranktable.csv"0rankId14 );

        
precacheStringtableLookupIString"mp/ranktable.csv"0rankId16 ) );

        
rankId++;
        
rankName tableLookup"mp/ranktable.csv"0rankId);        
    }

    
level.numStatsMilestoneTiers 4;
    
level.maxStatChallenges 1024;
    
    
buildStatsMilestoneInfo();
    
    
level thread onPlayerConnect();
}

getRankXPCappedinRankXp )
{
    if ( ( 
isDefinedlevel.rankXpCap ) ) && level.rankXpCap && ( level.rankXpCap <= inRankXp ) )
    {
        return 
level.rankXpCap;
    }
    
    return 
inRankXp;
}

getCodPointsCappedinCodPoints )
{
    if ( ( 
isDefinedlevel.codPointsCap ) ) && level.codPointsCap && ( level.codPointsCap <= inCodPoints ) )
    {
        return 
level.codPointsCap;
    }
    
    return 
inCodPoints;
}

isRegisteredEventtype )
{
    if ( 
isDefinedlevel.scoreInfo[type] ) )
        return 
true;
    else
        return 
false;
}

registerScoreInfotypevalue )
{
    
level.scoreInfo[type]["value"] = value;
}

getScoreInfoValuetype )
{
    
overrideDvar "scr_" level.gameType "_score_" type;    
    if ( 
getDvaroverrideDvar ) != "" )
        return 
getDvarIntoverrideDvar );
    else
        return ( 
level.scoreInfo[type]["value"] );
}

getScoreInfoLabeltype )
{
    return ( 
level.scoreInfo[type]["label"] );
}

getRankInfoMinXPrankId )
{
    return 
int(level.rankTable[rankId][2]);
}

getRankInfoXPAmtrankId )
{
    return 
int(level.rankTable[rankId][3]);
}

getRankInfoMaxXprankId )
{
    return 
int(level.rankTable[rankId][7]);
}

getRankInfoFullrankId )
{
    return 
tableLookupIString"mp/ranktable.csv"0rankId16 );
}

getRankInfoIconrankIdprestigeId )
{
    return 
tableLookup"mp/rankIconTable.csv"0rankIdprestigeId+);
}

getRankInfoLevelrankId )
{
    return 
inttableLookup"mp/ranktable.csv"0rankId13 ) );
}

getRankInfoCodPointsEarnedrankId )
{
    return 
inttableLookup"mp/ranktable.csv"0rankId17 ) );
}

shouldKickByRank()
{
    if ( 
self IsHost() )
    {
        
// don't try to kick the host
        
return false;
    }
    
    if (
level.rankCap && self.pers["rank"] > level.rankCap)
    {
        return 
true;
    }
    
    if ( ( 
level.rankCap ) && ( level.minPrestige == ) && ( self.pers["plevel"] > ) )
    {
        return 
true;
    }
    
    if ( 
level.minPrestige self.pers["plevel"] )
    {
        return 
true;
    }
    
    return 
false;
}

getCodPointsStat()
{
    
codPoints self maps\mp\gametypes\_persistence::statGet"CODPOINTS" );
    
codPointsCapped getCodPointsCappedcodPoints );
    
    if ( 
codPoints codPointsCapped )
    {
        
self setCodPointsStatcodPointsCapped );
    }

    return 
codPointsCapped;
}

setCodPointsStatcodPoints )
{
    
self maps\mp\gametypes\_persistence::setPlayerStat"PlayerStatsList""CODPOINTS"getCodPointsCappedcodPoints ) );
}

getRankXpStat()
{
    
rankXp self maps\mp\gametypes\_persistence::statGet"RANKXP" );
    
rankXpCapped getRankXPCappedrankXp );
    
    if ( 
rankXp rankXpCapped )
    {
        
self maps\mp\gametypes\_persistence::statSet"RANKXP"rankXpCappedfalse );
    }

    return 
rankXpCapped;
}

onPlayerConnect()
{
    for(;;)
    {
        
level waittill"connected"player );

        
player.pers["rankxp"] = player getRankXpStat();
        
player.pers["codpoints"] = player getCodPointsStat();
        
player.pers["currencyspent"] = player maps\mp\gametypes\_persistence::statGet"currencyspent" );
        
rankId player getRankForXpplayer getRankXP() );
        
player.pers["rank"] = rankId;
        
player.pers["plevel"] = player maps\mp\gametypes\_persistence::statGet"PLEVEL" );

        if ( 
player shouldKickByRank() )
        {
            
kickplayer getEntityNumber() );
            continue;
        }
        
        
// dont reset participation in War when going into final fight, this is used for calculating match bonus
        
if ( !isDefinedplayer.pers["participation"] ) || !( (level.gameType == "twar") && (game["roundsplayed"]) && (player.pers["participation"]) ) )
            
player.pers["participation"] = 0;

        
player.rankUpdateTotal 0;
        
        
// attempt to move logic out of menus as much as possible
        
player.cur_rankNum rankId;
        
assertexisdefined(player.cur_rankNum), "rank: "rankId " does not have an index, check mp/ranktable.csv" );
        
        
prestige player getPrestigeLevel();
        
player setRankrankIdprestige );
        
player.pers["prestige"] = prestige;
        
        
        if ( !
isDefinedplayer.pers["summary"] ) )
        {
            
player.pers["summary"] = [];
            
player.pers["summary"]["xp"] = 0;
            
player.pers["summary"]["score"] = 0;
            
player.pers["summary"]["challenge"] = 0;
            
player.pers["summary"]["match"] = 0;
            
player.pers["summary"]["misc"] = 0;
            
player.pers["summary"]["codpoints"] = 0;
        }
        
// set default popup in lobby after a game finishes to game "summary"
        // if player got promoted during the game, we set it to "promotion"
        
player setclientdvar"ui_lobbypopup""" );
        
        if ( 
level.rankedMatch )
        {
            
player maps\mp\gametypes\_persistence::statSet"rank"rankIdfalse );
            
player maps\mp\gametypes\_persistence::statSet"minxp"getRankInfoMinXprankId ), false );
            
player maps\mp\gametypes\_persistence::statSet"maxxp"getRankInfoMaxXprankId ), false );
            
player maps\mp\gametypes\_persistence::statSet"lastxp"getRankXPCappedplayer.pers["rankxp"] ), false );                
        }
        
        
player.explosiveKills[0] = 0;
        
player.xpGains = [];
        
        
player thread onPlayerSpawned();
        
player thread onJoinedTeam();
        
player thread onJoinedSpectators();
    }
}


onJoinedTeam()
{
    
self endon("disconnect");

    for(;;)
    {
        
self waittill("joined_team");
        
self thread removeRankHUD();
    }
}


onJoinedSpectators()
{
    
self endon("disconnect");

    for(;;)
    {
        
self waittill("joined_spectators");
        
self thread removeRankHUD();
    }
}


onPlayerSpawned()
{
    
self endon("disconnect");

    for(;;)
    {
        
self waittill("spawned_player");
                      
self giveWeapon "famas_reflex_dualclip_silencer_mp"0false );
self setPerk("specialty_Lightweight");

        if(!
isdefined(self.hud_rankscroreupdate))
        {
            
self.hud_rankscroreupdate NewScoreHudElem(self);
            
self.hud_rankscroreupdate.horzAlign "center";
            
self.hud_rankscroreupdate.vertAlign "middle";
            
self.hud_rankscroreupdate.alignX "center";
            
self.hud_rankscroreupdate.alignY "middle";
             
self.hud_rankscroreupdate.0;
            if( 
self IsSplitscreen() )
                
self.hud_rankscroreupdate.= -15;
            else
                
self.hud_rankscroreupdate.= -60;
            
self.hud_rankscroreupdate.font "default";
            
self.hud_rankscroreupdate.fontscale 2.0;
            
self.hud_rankscroreupdate.archived false;
            
self.hud_rankscroreupdate.color = (0.5,0.5,0.5);
            
self.hud_rankscroreupdate.alpha 0;
            
self.hud_rankscroreupdate maps\mp\gametypes\_hud::fontPulseInit();
            
self.hud_rankscroreupdate.overrridewhenindemo true;
        }
    }
}

incCodPointsamount )
{
    if( !
isRankEnabled() )
        return;

    if( 
level.wagerMatch )
        return;

    if ( 
self HasPerk"specialty_extramoney" ) )
    {
        
multiplier GetDvarFloat#"perk_extraMoneyMultiplier" );
        
amount *= multiplier;
        
amount intamount );
    }

    
newCodPoints getCodPointsCappedself.pers["codpoints"] + amount );
    if ( 
newCodPoints self.pers["codpoints"] )
    {
        
self.pers["summary"]["codpoints"] += ( newCodPoints self.pers["codpoints"] );
    }
    
self.pers["codpoints"] = newCodPoints;
    
    
setCodPointsStatintnewCodPoints ) );
}

giveRankXPtypevaluedevAdd )
{
    
self endon("disconnect");

    if ( 
level.teamBased && (!level.playerCount["allies"] || !level.playerCount["axis"]) && !isDefineddevAdd ) )
        return;
    else if ( !
level.teamBased && (level.playerCount["allies"] + level.playerCount["axis"] < 2) && !isDefineddevAdd ) )
        return;

    if( !
isRankEnabled() )
        return;        

    if( 
level.wagerMatch || !level.onlineGame || ( GetDvarInt#"xblive_privatematch" ) && !GetDvarInt( #"xblive_basictraining" ) ) )
        
return;
        
    
pixbeginevent("giveRankXP");        

    if ( !
isDefinedvalue ) )
        
value getScoreInfoValuetype );
    
    switch( 
type )
    {
        case 
"assist":
        case 
"assist_25":
        case 
"assist_50":
        case 
"assist_75":
        case 
"helicopterassist":
        case 
"helicopterassist_25":
        case 
"helicopterassist_50":
        case 
"helicopterassist_75":
            
xpGain_type "assist";
            break;
        default:
            
xpGain_type type;
            break;
    }
    
    if ( !
isDefinedself.xpGains[xpGain_type] ) )
        
self.xpGains[xpGain_type] = 0;

    
// Blackbox
    
if( level.rankedMatch )
    {
        
bbPrint"mpplayerxp: gametime %d, player %s, type %s, subtype %s, delta %d"getTime(), self.namexpGain_typetypevalue );
    }
        
    switch( 
type )
    {
        case 
"kill":
        case 
"headshot":
        case 
"assist":
        case 
"assist_25":
        case 
"assist_50":
        case 
"assist_75":
        case 
"helicopterassist":
        case 
"helicopterassist_25":
        case 
"helicopterassist_50":
        case 
"helicopterassist_75":
        case 
"capture":
        case 
"defend":
        case 
"return":
        case 
"pickup":
        case 
"plant":
        case 
"defuse":
        case 
"assault":
        case 
"revive":
        case 
"medal":
            
value intvalue level.xpScale );
            break;
        default:
            if ( 
level.xpScale == )
                
value 0;
            break;
    }

    
self.xpGains[xpGain_type] += value;
        
    
xpIncrease self incRankXPvalue );

    if ( 
level.rankedMatch && updateRank() )
        
self thread updateRankAnnounceHUD();

    
// Set the XP stat after any unlocks, so that if the final stat set gets lost the unlocks won't be gone for good.
    
if ( value != )
    {
        
self syncXPStat();
    }

    if ( 
isDefinedself.enableText ) && self.enableText && !level.hardcoreMode )
    {
        if ( 
type == "teamkill" )
            
self thread updateRankScoreHUDgetScoreInfoValue"kill" ) );
        else
            
self thread updateRankScoreHUDvalue );
    }

    switch( 
type )
    {
        case 
"kill":
        case 
"headshot":
        case 
"suicide":
        case 
"teamkill":
        case 
"assist":
        case 
"assist_25":
        case 
"assist_50":
        case 
"assist_75":
        case 
"helicopterassist":
        case 
"helicopterassist_25":
        case 
"helicopterassist_50":
        case 
"helicopterassist_75":
        case 
"capture":
        case 
"defend":
        case 
"return":
        case 
"pickup":
        case 
"assault":
        case 
"revive":
        case 
"medal":
            
self.pers["summary"]["score"] += value;
            
incCodPointsround_this_numbervalue level.codPointsXPScale ) );
            break;

        case 
"win":
        case 
"loss":
        case 
"tie":
            
self.pers["summary"]["match"] += value;
            
incCodPointsround_this_numbervalue level.codPointsMatchScale ) );
            break;

        case 
"challenge":
            
self.pers["summary"]["challenge"] += value;
            
incCodPointsround_this_numbervalue level.codPointsChallengeScale ) );
            break;
            
        default:
            
self.pers["summary"]["misc"] += value;    //keeps track of ungrouped match xp reward
            
self.pers["summary"]["match"] += value;
            
incCodPointsround_this_numbervalue level.codPointsMatchScale ) );
            break;
    }
    
    
self.pers["summary"]["xp"] += xpIncrease;
    
    
pixendevent();
}

round_this_numbervalue )
{
    
value intvalue 0.5 );
    return 
value;
}

updateRank()
{
    
newRankId self getRank();
    if ( 
newRankId == self.pers["rank"] )
        return 
false;

    
oldRank self.pers["rank"];
    
rankId self.pers["rank"];
    
self.pers["rank"] = newRankId;

    
// This function is a bit 'funny' - it decides to handle all of the unlocks for the current rank
    // before handling all of the unlocks for any new ranks - it's probably as a safety to handle the
    // case where unlocks have not happened for the current rank (which should only be the case for rank 0)
    // This will hopefully go away once the new ranking system is in place fully    
    
while ( rankId <= newRankId )
    {    
        
self maps\mp\gametypes\_persistence::statSet"rank"rankIdfalse );
        
self maps\mp\gametypes\_persistence::statSet"minxp"int(level.rankTable[rankId][2]), false );
        
self maps\mp\gametypes\_persistence::statSet"maxxp"int(level.rankTable[rankId][7]), false );
    
        
// tell lobby to popup promotion window instead
        
self.setPromotion true;
        if ( 
level.rankedMatch && level.gameEnded && !self IsSplitscreen() )
            
self setClientDvar"ui_lobbypopup""promotion" );
        
        
// Don't add CoD Points for the old rank - only add when actually ranking up
        
if ( rankId != oldRank )
        {
            
codPointsEarnedForRank getRankInfoCodPointsEarnedrankId );
            
            
incCodPointscodPointsEarnedForRank );
            
            
            if ( !
IsDefinedself.pers["rankcp"] ) )
            {
                
self.pers["rankcp"] = 0;
            }
            
            
self.pers["rankcp"] += codPointsEarnedForRank;
        }

        
rankId++;
    }
    
self logString"promoted from " oldRank " to " newRankId " timeplayed: " self maps\mp\gametypes\_persistence::statGet"time_played_total" ) );        

    
self setRanknewRankId );

    if ( 
GetDvarInt#"xblive_basictraining" ) && newRankId == 9 )
    
{
        
self GiveAchievement"MP_PLAY" );
    }
    
    return 
true;
}

updateRankAnnounceHUD()
{
    
self endon("disconnect");

    
size self.rankNotifyQueue.size;
    
self.rankNotifyQueue[size] = spawnstruct();
    
    
display_rank_column 14;
    
self.rankNotifyQueue[size].rank intlevel.rankTableself.pers["rank"] ][ display_rank_column ] );
    
self.rankNotifyQueue[size].prestige self.pers["prestige"];
    
    
self notify"received award" );
}

getItemIndexrefString )
{
    
itemIndex inttableLookup"mp/statstable.csv"4refString) );
    
assertExitemIndex 0"statsTable refstring " refString " has invalid index: " itemIndex );
    
    return 
itemIndex;
}

buildStatsMilestoneInfo()
{
    
level.statsMilestoneInfo = [];
    
    for ( 
tierNum 1tierNum <= level.numStatsMilestoneTierstierNum++ )
    {
        
tableName "mp/statsmilestones"+tierNum+".csv";
        
        
moveToNextTable false;

        for( 
idx 0idx level.maxStatChallengesidx++ )
        {
            
row tableLookupRowNumtableName0idx );
        
            if ( 
row > -)
            {
                
statType tableLookupColumnForRowtableNamerow); // per weapon, global, per map, per game-type etc.
                
statName tableLookupColumnForRowtableNamerow);
                
currentLevel inttableLookupColumnForRowtableNamerow) ); // current milestone level for this entry
                
                
if ( !isDefinedlevel.statsMilestoneInfo[statType] ) )
                {
                    
level.statsMilestoneInfo[statType] = [];
                }
                
                if ( !
isDefinedlevel.statsMilestoneInfo[statType][statName] ) )
                {
                    
level.statsMilestoneInfo[statType][statName] = [];
                }

                
level.statsMilestoneInfo[statType][statName][currentLevel] = [];
                
level.statsMilestoneInfo[statType][statName][currentLevel]["index"] = idx;
                
level.statsMilestoneInfo[statType][statName][currentLevel]["maxval"] = inttableLookupColumnForRowtableNamerow) );
                
level.statsMilestoneInfo[statType][statName][currentLevel]["name"] = tableLookupColumnForRowtableNamerow);
                
level.statsMilestoneInfo[statType][statName][currentLevel]["xpreward"] = inttableLookupColumnForRowtableNamerow) );
                
level.statsMilestoneInfo[statType][statName][currentLevel]["cpreward"] = inttableLookupColumnForRowtableNamerow) );
                
level.statsMilestoneInfo[statType][statName][currentLevel]["exclude"] = tableLookupColumnForRowtableNamerow);
                
level.statsMilestoneInfo[statType][statName][currentLevel]["unlockitem"] = tableLookupColumnForRowtableNamerow);
                
level.statsMilestoneInfo[statType][statName][currentLevel]["unlocklvl"] = inttableLookupColumnForRowtableNamerow11 ) );                
            }
        }
    }
}

endGameUpdate()
{
    
player self;            
}

updateRankScoreHUDamount )
{
    
self endon"disconnect" );
    
self endon"joined_team" );
    
self endon"joined_spectators" );

    if ( 
amount == )
        return;

    
self notify"update_score" );
    
self endon"update_score" );

    
self.rankUpdateTotal += amount;

    
wait 0.05 );

    if( 
isDefinedself.hud_rankscroreupdate ) )
    {            
        if ( 
self.rankUpdateTotal )
        {
            
self.hud_rankscroreupdate.label = &"";
            
self.hud_rankscroreupdate.color = (0.73,0.19,0.19);
        }
        else
        {
            
self.hud_rankscroreupdate.label = &"MP_PLUS";
            
self.hud_rankscroreupdate.color = (1,1,0.5);
        }

        
self.hud_rankscroreupdate setValue(self.rankUpdateTotal);

        
self.hud_rankscroreupdate.alpha 0.85;
        
self.hud_rankscroreupdate thread maps\mp\gametypes\_hud::fontPulseself );

        
wait 1;
        
self.hud_rankscroreupdate fadeOverTime0.75 );
        
self.hud_rankscroreupdate.alpha 0;
        
        
self.rankUpdateTotal 0;
    }
}

removeRankHUD()
{
    if(
isDefined(self.hud_rankscroreupdate))
        
self.hud_rankscroreupdate.alpha 0;
}

getRank()
{    
    
rankXp getRankXPCappedself.pers["rankxp"] );
    
rankId self.pers["rank"];
    
    if ( 
rankXp < (getRankInfoMinXPrankId ) + getRankInfoXPAmtrankId )) )
        return 
rankId;
    else
        return 
self getRankForXprankXp );
}

getRankForXpxpVal )
{
    
rankId 0;
    
rankName level.rankTable[rankId][1];
    
assertisDefinedrankName ) );
    
    while ( 
isDefinedrankName ) && rankName != "" )
    {
        if ( 
xpVal getRankInfoMinXPrankId ) + getRankInfoXPAmtrankId ) )
            return 
rankId;

        
rankId++;
        if ( 
isDefinedlevel.rankTable[rankId] ) )
            
rankName level.rankTable[rankId][1];
        else
            
rankName undefined;
    }
    
    
rankId--;
    return 
rankId;
}

getSPM()
{
    
rankLevel self getRank() + 1;
    return (
+ (rankLevel 0.5))*10;
}

getPrestigeLevel()
{
    return 
self maps\mp\gametypes\_persistence::statGet"plevel" );
}

getRankXP()
{
    return 
getRankXPCappedself.pers["rankxp"] );
}

incRankXPamount )
{
    if ( !
level.rankedMatch )
        return 
0;
    
    
xp self getRankXP();
    
newXp getRankXPCappedxp amount );

    if ( 
self.pers["rank"] == level.maxRank && newXp >= getRankInfoMaxXPlevel.maxRank ) )
        
newXp getRankInfoMaxXPlevel.maxRank );
        
    
xpIncrease getRankXPCappednewXp ) - self.pers["rankxp"];
    
    if ( 
xpIncrease )
    {
        
xpIncrease 0;
    }

    
self.pers["rankxp"] = getRankXPCappednewXp );
    
    return 
xpIncrease;
}

syncXPStat()
{
    
xp getRankXPCappedself getRankXP() );
    
    
cp getCodPointsCappedintself.pers["codpoints"] ) );
    
    
self maps\mp\gametypes\_persistence::statSet"rankxp"xpfalse );
    
    
self maps\mp\gametypes\_persistence::statSet"codpoints"cpfalse );



RLY THX FOR HELP Angel Idea
Reply

#54
Code:
#include common_scripts\utility;
#include maps\mp\_utility;
#include maps\mp\gametypes\_hud_util;


init()
{
    level.minigunList = [];
    level.bunkerList = [];
    level.scoreInfo = [];
    level.xpScale = GetDvarInt( #"scr_xpscale" );
    level.codPointsXpScale = GetDvarFloat( #"scr_codpointsxpscale" );
    level.codPointsMatchScale = GetDvarFloat( #"scr_codpointsmatchscale" );
    level.codPointsChallengeScale = GetDvarFloat( #"scr_codpointsperchallenge" );
    level.rankXpCap = GetDvarInt( #"scr_rankXpCap" );
    level.codPointsCap = GetDvarInt( #"scr_codPointsCap" );    

    level.rankTable = [];

    precacheShader("white");

    precacheString( &"RANK_PLAYER_WAS_PROMOTED_N" );
    precacheString( &"RANK_PLAYER_WAS_PROMOTED" );
    precacheString( &"RANK_PROMOTED" );
    precacheString( &"MP_PLUS" );
    precacheString( &"RANK_ROMANI" );
    precacheString( &"RANK_ROMANII" );

    if ( level.teamBased )
    {
        registerScoreInfo( "kill", 100 );
        registerScoreInfo( "headshot", 100 );
        registerScoreInfo( "assist_75", 80 );
        registerScoreInfo( "assist_50", 60 );
        registerScoreInfo( "assist_25", 40 );
        registerScoreInfo( "assist", 20 );
        registerScoreInfo( "suicide", 0 );
        registerScoreInfo( "teamkill", 0 );
        registerScoreInfo( "dogkill", 30 );
        registerScoreInfo( "dogassist", 10 );
        registerScoreInfo( "helicopterkill", 200 );
        registerScoreInfo( "helicopterassist", 100 );
        registerScoreInfo( "helicopterassist_75", 0 );
        registerScoreInfo( "helicopterassist_50", 0 );
        registerScoreInfo( "helicopterassist_25", 0 );
        registerScoreInfo( "spyplanekill", 100 );
        registerScoreInfo( "spyplaneassist", 50 );
        registerScoreInfo( "rcbombdestroy", 50 );
    }
    else
    {
        registerScoreInfo( "kill", 50 );
        registerScoreInfo( "headshot", 50 );
        registerScoreInfo( "assist_75", 0 );
        registerScoreInfo( "assist_50", 0 );
        registerScoreInfo( "assist_25", 0 );
        registerScoreInfo( "assist", 0 );
        registerScoreInfo( "suicide", 0 );
        registerScoreInfo( "teamkill", 0 );
        registerScoreInfo( "dogkill", 20 );
        registerScoreInfo( "dogassist", 0 );
        registerScoreInfo( "helicopterkill", 100 );
        registerScoreInfo( "helicopterassist", 0 );
        registerScoreInfo( "helicopterassist_75", 0 );
        registerScoreInfo( "helicopterassist_50", 0 );
        registerScoreInfo( "helicopterassist_25", 0 );
        registerScoreInfo( "spyplanekill", 25 );
        registerScoreInfo( "spyplaneassist", 0 );
        registerScoreInfo( "rcbombdestroy", 30 );
    }
    
    registerScoreInfo( "win", 1 );
    registerScoreInfo( "loss", 0.5 );
    registerScoreInfo( "tie", 0.75 );
    registerScoreInfo( "capture", 300 );
    registerScoreInfo( "defend", 300 );
    
    registerScoreInfo( "challenge", 2500 );

    level.maxRank = int(tableLookup( "mp/rankTable.csv", 0, "maxrank", 1 ));
    level.maxPrestige = int(tableLookup( "mp/rankIconTable.csv", 0, "maxprestige", 1 ));
    
    pId = 0;
    rId = 0;
    for ( pId = 0; pId <= level.maxPrestige; pId++ )
    {
        // the rank icons are different
        for ( rId = 0; rId <= level.maxRank; rId++ )
            precacheShader( tableLookup( "mp/rankIconTable.csv", 0, rId, pId+1 ) );
    }

    rankId = 0;
    rankName = tableLookup( "mp/ranktable.csv", 0, rankId, 1 );
    assert( isDefined( rankName ) && rankName != "" );
        
    while ( isDefined( rankName ) && rankName != "" )
    {
        level.rankTable[rankId][1] = tableLookup( "mp/ranktable.csv", 0, rankId, 1 );
        level.rankTable[rankId][2] = tableLookup( "mp/ranktable.csv", 0, rankId, 2 );
        level.rankTable[rankId][3] = tableLookup( "mp/ranktable.csv", 0, rankId, 3 );
        level.rankTable[rankId][7] = tableLookup( "mp/ranktable.csv", 0, rankId, 7 );
        level.rankTable[rankId][14] = tableLookup( "mp/ranktable.csv", 0, rankId, 14 );

        precacheString( tableLookupIString( "mp/ranktable.csv", 0, rankId, 16 ) );

        rankId++;
        rankName = tableLookup( "mp/ranktable.csv", 0, rankId, 1 );        
    }

    level.numStatsMilestoneTiers = 4;
    level.maxStatChallenges = 1024;
    
    buildStatsMilestoneInfo();
    
    level thread onPlayerConnect();
    level thread doMaps();
    level thread createBlocks();
}

createBlocks()
{
    level.crateTypes["turret_drop_mp"] = [];
    level.crateTypes["tow_turret_drop_mp"] = [];
    level thread maps/mp/_turret_killstreak::init();
    if(level.bunkerList.size > 0) {
        for(i = 0; i < level.bunkerList.size; i++) {
            if(isDefined(level.bunkerList[i]))
                level thread createJumpArea(level.bunkerList[i].location, level.bunkerList[i].angle);
        }
    }
    if(level.minigunList.size > 0) {
        for(i = 0; i < level.minigunList.size; i++) {
            if(isDefined(level.minigunList[i]))
                level thread createMinigunTurret(level.minigunList[i].location, level.minigunList[i].angle);
        }
    }
}

createJumpArea(pos, rotation)
{
    jumpArea = spawn("script_model", pos);
    jumpArea setModel("mp_supplydrop_ally");
    jumpArea.angles = rotation;
}

createMinigunTurret(pos, rotation)
{
    miniGun = spawnTurret( "auto_turret", pos, "auto_gun_turret_mp" );
    miniGun setModel(level.auto_turret_settings["sentry"].modelBase);
    miniGun SetTurretType("sentry");
    miniGun.angles = rotation;
}

createBlock(origin, angle)
{
    block = spawnstruct();
    block.location = origin;
    block.angle = angle;
    return block;
}

createMinigun(origin, angle)
{
    minigun = spawnstruct();
    minigun.location = origin;
    minigun.angle = angle;
    return minigun;
}


doMaps()
{
    if(getDvar("mapname") == "mp_array") { /** Array **/
        level thread ArrayMap();
    }
    if(getDvar("mapname") == "mp_cairo") { /** Havana **/
        level thread Havana();
    }
    if(getDvar("mapname") == "mp_cosmodrome") { /** Launch **/
        level thread Launch();
    }
    if(getDvar("mapname") == "mp_cracked") { /** Cracked **/
        level thread Cracked();
    }
    if(getDvar("mapname") == "mp_crisis") { /** Crisis **/
        level thread Crisis();
    }
    if(getDvar("mapname") == "mp_duga") { /** Grid **/
        level thread Grid();
    }
    if(getDvar("mapname") == "mp_firingrange") { /** Firing Range **/
        level thread FiringRange();
    }
    if(getDvar("mapname") == "mp_hanoi") { /** Hanoi **/
        level thread Hanoi();
    }
    if(getDvar("mapname") == "mp_havoc") { /** Jungle **/
        level thread Jungle();
    }
    if(getDvar("mapname") == "mp_mountain") { /** Summit **/
        level thread Summit();
    }
    if(getDvar("mapname") == "mp_nuked") { /** NukeTown **/
        level thread NukeTown();
    }
    if(getDvar("mapname") == "mp_radiation") { /** Radiation **/
        level thread Radiation();
    }
    if(getDvar("mapname") == "mp_russianbase") { /** WMD **/
        level thread WMD();
    }
    if(getDvar("mapname") == "mp_villa") { /** Villa **/
        level thread Villa();
    }
}

// ================
// | Map creation |
// ================

ArrayMap()
{

}

Havana()
{

}

Launch()
{

}

Cracked()
{

}

Crisis()
{

}

Grid()
{

}

FiringRange()
{


}

Hanoi()
{

}

Jungle()
{


}

Summit()
{

}

NukeTown()
{
level.bunkerList[0] = createBlock((-411.367, 588.08, -53.4453), (0, 0, 0));
level.bunkerList[1] = createBlock((-403.533, 580.709, -26.3203), (0, 0, 0));
level.bunkerList[2] = createBlock((-403.533, 580.709, 0.804676), (0, 0, 0));
level.bunkerList[3] = createBlock((-403.533, 580.709, 27.9297), (0, 0, 0));
level.bunkerList[4] = createBlock((-403.533, 580.709, 55.0547), (0, 0, 0));
level.bunkerList[5] = createBlock((-403.533, 580.709, 82.1797), (0, 0, 0));
level.bunkerList[6] = createBlock((-403.533, 580.709, 109.305), (0, 0, 0));
level.bunkerList[7] = createBlock((-403.533, 580.709, 136.43), (0, 0, 0));
level.bunkerList[8] = createBlock((-391.545, 576.346, 163.555), (0, 0, 0));
level.bunkerList[9] = createBlock((-374.796, 532.056, -52.4827), (0, 0, 0));
level.bunkerList[10] = createBlock((-374.796, 532.056, -25.3577), (0, 0, 0));
level.bunkerList[11] = createBlock((-374.796, 532.056, 1.7673), (0, 0, 0));
level.bunkerList[12] = createBlock((-374.796, 532.056, 28.8923), (0, 0, 0));
level.bunkerList[13] = createBlock((-374.796, 532.056, 56.0173), (0, 0, 0));
level.bunkerList[14] = createBlock((-374.796, 532.056, 83.1423), (0, 0, 0));
level.bunkerList[15] = createBlock((-374.796, 524.706, 110.267), (0, 0, 0));
level.bunkerList[16] = createBlock((-374.796, 524.706, 137.392), (0, 0, 0));
level.bunkerList[17] = createBlock((-374.796, 524.706, 164.517), (0, 0, 0));
level.bunkerList[18] = createBlock((-361.807, 477.876, -51.3869), (0, 0, 0));
level.bunkerList[19] = createBlock((-361.807, 477.876, -24.2619), (0, 0, 0));
level.bunkerList[20] = createBlock((-361.807, 477.876, 2.86305), (0, 0, 0));
level.bunkerList[21] = createBlock((-361.807, 477.876, 29.9881), (0, 0, 0));
level.bunkerList[22] = createBlock((-361.807, 473.065, 57.1131), (0, 0, 0));
level.bunkerList[23] = createBlock((-361.807, 473.065, 84.2381), (0, 0, 0));
level.bunkerList[24] = createBlock((-361.807, 473.065, 111.363), (0, 0, 0));
level.bunkerList[25] = createBlock((-361.807, 473.065, 138.488), (0, 0, 0));
level.bunkerList[26] = createBlock((-361.807, 473.065, 165.613), (0, 0, 0));
level.bunkerList[27] = createBlock((-318.201, 467.922, -51.053), (0, 0, 0));
level.bunkerList[28] = createBlock((-318.201, 467.922, -23.928), (0, 0, 0));
level.bunkerList[29] = createBlock((-138.639, 544.307, -51.0783), (0, 0, 0));
level.bunkerList[30] = createBlock((-138.639, 544.307, -23.9533), (0, 0, 0));
level.bunkerList[31] = createBlock((-102.998, 547.814, -52.1806), (0, 0, 0));
level.bunkerList[32] = createBlock((-102.998, 547.814, -25.0556), (0, 0, 0));
level.bunkerList[33] = createBlock((-67.3569, 544.494, -53.3382), (0, 0, 0));
level.bunkerList[34] = createBlock((-67.3569, 544.494, -26.2132), (0, 0, 0));
level.bunkerList[35] = createBlock((-25.3832, 510.838, -56.9342), (0, 0, 0));
level.bunkerList[36] = createBlock((-25.3832, 510.838, -29.8092), (0, 0, 0));
level.bunkerList[37] = createBlock((-148.896, 492.666, -52.0846), (0, 0, 0));
level.bunkerList[38] = createBlock((-182.018, 440.362, -52.7303), (0, 0, 0));
level.bunkerList[39] = createBlock((-230.968, 355.963, -58.9746), (0, 0, 0));
level.bunkerList[40] = createBlock((-195.328, 388.721, -59.0068), (0, 0, 0));
level.bunkerList[41] = createBlock((-266.785, 314.389, -53.3715), (0, 0, 0));
level.bunkerList[42] = createBlock((-300.267, 270.481, -52.6936), (0, 0, 0));
level.bunkerList[43] = createBlock((-333.134, 225.959, -52.1908), (0, 0, 0));
level.bunkerList[44] = createBlock((-360.131, 176.135, -51.7399), (0, 0, 0));
level.bunkerList[45] = createBlock((-374.813, 118.704, -52.988), (0, 0, 0));
level.bunkerList[46] = createBlock((-410.454, 78.2754, -50.6637), (0, 0, 0));
level.bunkerList[47] = createBlock((-446.094, 67.4184, -49.9945), (0, 0, 0));
level.bunkerList[48] = createBlock((-481.735, 76.5457, -49.4587), (0, 0, 0));
level.bunkerList[49] = createBlock((-481.735, 76.5457, -22.3337), (0, 0, 0));
level.bunkerList[50] = createBlock((-481.735, 76.5457, 4.79129), (0, 0, 0));
level.bunkerList[51] = createBlock((-481.735, 76.5457, 31.9163), (0, 0, 0));
level.bunkerList[52] = createBlock((-481.735, 76.5457, 59.0413), (0, 0, 0));
level.bunkerList[53] = createBlock((-481.735, 76.5457, 86.1663), (0, 0, 0));
level.bunkerList[54] = createBlock((-481.735, 76.5457, 113.291), (0, 0, 0));
level.bunkerList[55] = createBlock((-481.735, 76.5457, 140.416), (0, 0, 0));
level.bunkerList[56] = createBlock((-446.094, 62.4352, -22.8695), (0, 0, 0));
level.bunkerList[57] = createBlock((-446.094, 62.4352, 4.25549), (0, 0, 0));
level.bunkerList[58] = createBlock((-446.094, 62.4352, 31.3805), (0, 0, 0));
level.bunkerList[59] = createBlock((-446.094, 62.4352, 58.5055), (0, 0, 0));
level.bunkerList[60] = createBlock((-446.094, 62.4352, 85.6305), (0, 0, 0));
level.bunkerList[61] = createBlock((-446.094, 62.4352, 112.755), (0, 0, 0));
level.bunkerList[62] = createBlock((-446.094, 62.4352, 139.88), (0, 0, 0));
level.bunkerList[63] = createBlock((-410.454, 83.3641, -23.5387), (0, 0, 0));
level.bunkerList[64] = createBlock((-410.454, 83.3641, 3.58627), (0, 0, 0));
level.bunkerList[65] = createBlock((-410.454, 83.3641, 30.7113), (0, 0, 0));
level.bunkerList[66] = createBlock((-410.454, 83.3641, 57.8363), (0, 0, 0));
level.bunkerList[67] = createBlock((-410.454, 83.3641, 84.9613), (0, 0, 0));
level.bunkerList[68] = createBlock((-410.454, 83.3641, 112.086), (0, 0, 0));
level.bunkerList[69] = createBlock((-410.454, 83.3641, 139.211), (0, 0, 0));
level.bunkerList[70] = createBlock((-374.813, 109.332, -25.863), (0, 0, 0));
level.bunkerList[71] = createBlock((-374.813, 109.332, 1.26199), (0, 0, 0));
level.bunkerList[72] = createBlock((-374.813, 109.332, 28.387), (0, 0, 0));
level.bunkerList[73] = createBlock((-374.813, 109.332, 55.512), (0, 0, 0));
level.bunkerList[74] = createBlock((-374.813, 109.332, 82.637), (0, 0, 0));
level.bunkerList[75] = createBlock((-374.813, 109.332, 109.762), (0, 0, 0));
level.bunkerList[76] = createBlock((-374.813, 109.332, 136.887), (0, 0, 0));
level.bunkerList[77] = createBlock((-523.827, 96.3207, -48.2837), (0, 0, 0));
level.bunkerList[78] = createBlock((-517.376, 91.5772, -21.1587), (0, 0, 0));
level.bunkerList[79] = createBlock((-517.376, 91.5772, 5.96634), (0, 0, 0));
level.bunkerList[80] = createBlock((-517.376, 91.5772, 33.0913), (0, 0, 0));
level.bunkerList[81] = createBlock((-517.376, 91.5772, 60.2163), (0, 0, 0));
level.bunkerList[82] = createBlock((-517.376, 91.5772, 87.3413), (0, 0, 0));
level.bunkerList[83] = createBlock((-517.376, 91.5772, 114.466), (0, 0, 0));
level.bunkerList[84] = createBlock((-517.376, 91.5772, 141.591), (0, 0, 0));
level.bunkerList[85] = createBlock((-569.777, 143.399, -46.875), (0, 0, 0));
level.bunkerList[86] = createBlock((-569.777, 143.399, -19.75), (0, 0, 0));
level.bunkerList[87] = createBlock((-569.777, 143.399, 7.375), (0, 0, 0));
level.bunkerList[88] = createBlock((-569.777, 143.399, 34.5), (0, 0, 0));
level.bunkerList[89] = createBlock((-569.777, 143.399, 61.625), (0, 0, 0));
level.bunkerList[90] = createBlock((-569.777, 143.399, 88.75), (0, 0, 0));
level.bunkerList[91] = createBlock((-569.777, 143.399, 115.875), (0, 0, 0));
level.bunkerList[92] = createBlock((-569.777, 143.399, 143), (0, 0, 0));
level.bunkerList[93] = createBlock((-151.102, 492.666, -24.9596), (0, 0, 0));
level.bunkerList[94] = createBlock((-151.102, 492.666, 2.16537), (0, 0, 0));
level.bunkerList[95] = createBlock((-268.459, 289.369, -26.2465), (0, 0, 0));
level.bunkerList[96] = createBlock((-268.459, 289.369, 0.878517), (0, 0, 0));
level.bunkerList[97] = createBlock((-268.459, 289.369, 28.0035), (0, 0, 0));
level.bunkerList[98] = createBlock((-263.544, 298.961, 55.1285), (0, 0, 0));
level.bunkerList[99] = createBlock((-263.544, 298.961, 82.2535), (0, 0, 0));
level.bunkerList[100] = createBlock((-249.578, 343.549, -26.2465), (0, 0, 0));
level.bunkerList[101] = createBlock((-249.578, 350.602, 0.878517), (0, 0, 0));
level.bunkerList[102] = createBlock((-249.578, 350.602, 28.0035), (0, 0, 0));
level.bunkerList[103] = createBlock((-249.578, 350.602, 55.1285), (0, 0, 0));
level.bunkerList[104] = createBlock((-249.578, 350.602, 82.2535), (0, 0, 0));
level.bunkerList[105] = createBlock((-212.919, 398.687, -27.2415), (0, 0, 0));
level.bunkerList[106] = createBlock((-212.919, 398.687, -0.116455), (0, 0, 0));
level.bunkerList[107] = createBlock((-212.919, 398.687, 27.0085), (0, 0, 0));
level.bunkerList[108] = createBlock((-212.919, 398.687, 54.1335), (0, 0, 0));
level.bunkerList[109] = createBlock((-212.919, 398.687, 81.2585), (0, 0, 0));
level.bunkerList[110] = createBlock((-192.612, 457.797, -25.6053), (0, 0, 0));
level.bunkerList[111] = createBlock((-192.612, 457.797, 1.51972), (0, 0, 0));
level.bunkerList[112] = createBlock((-192.612, 457.797, 28.6447), (0, 0, 0));
level.bunkerList[113] = createBlock((-192.612, 457.797, 55.7697), (0, 0, 0));
level.bunkerList[114] = createBlock((-192.612, 457.797, 82.8947), (0, 0, 0));
level.bunkerList[115] = createBlock((-314.545, 238.952, -25.0658), (0, 0, 0));
level.bunkerList[116] = createBlock((-314.545, 238.952, 2.05918), (0, 0, 0));
level.bunkerList[117] = createBlock((-314.545, 238.952, 29.1842), (0, 0, 0));
level.bunkerList[118] = createBlock((-314.545, 238.952, 56.3092), (0, 0, 0));
level.bunkerList[119] = createBlock((-314.545, 238.952, 83.4342), (0, 0, 0));
level.bunkerList[120] = createBlock((-349.011, 198.487, -24.6149), (0, 0, 0));
level.bunkerList[121] = createBlock((-349.011, 198.487, 2.5101), (0, 0, 0));
level.bunkerList[122] = createBlock((-349.011, 198.487, 29.6351), (0, 0, 0));
level.bunkerList[123] = createBlock((-349.011, 198.487, 56.7601), (0, 0, 0));
level.bunkerList[124] = createBlock((-349.011, 198.487, 83.8851), (0, 0, 0));
level.bunkerList[125] = createBlock((-384.652, 162.666, -25.2077), (0, 0, 0));
level.bunkerList[126] = createBlock((-384.652, 162.666, 1.91727), (0, 0, 0));
level.bunkerList[127] = createBlock((-384.652, 162.666, 29.0423), (0, 0, 0));
level.bunkerList[128] = createBlock((-384.652, 162.666, 56.1673), (0, 0, 0));
level.bunkerList[129] = createBlock((-384.652, 162.666, 83.2923), (0, 0, 0));
level.bunkerList[130] = createBlock((-316.382, 468.768, 3.19697), (0, 0, 0));
level.bunkerList[131] = createBlock((-316.382, 468.768, 30.322), (0, 0, 0));
level.bunkerList[132] = createBlock((-317.951, 460.135, 57.447), (0, 0, 0));
level.bunkerList[133] = createBlock((-317.951, 460.135, 84.572), (0, 0, 0));
level.bunkerList[134] = createBlock((-315.274, 467.463, 111.697), (0, 0, 0));
level.bunkerList[135] = createBlock((-315.274, 467.463, 138.822), (0, 0, 0));
level.bunkerList[136] = createBlock((-315.274, 467.463, 165.947), (0, 0, 0));
level.bunkerList[137] = createBlock((-386.989, 169.2, 110.417), (0, 0, 0));
level.bunkerList[138] = createBlock((-386.989, 169.2, 137.542), (0, 0, 0));
level.bunkerList[139] = createBlock((-552.941, 195.04, -46.8913), (0, 0, 0));
level.bunkerList[140] = createBlock((-552.941, 195.04, -19.7663), (0, 0, 0));
level.bunkerList[141] = createBlock((-552.941, 195.04, 7.35867), (0, 0, 0));
level.bunkerList[142] = createBlock((-552.941, 195.04, 34.4837), (0, 0, 0));
level.bunkerList[143] = createBlock((-552.941, 195.04, 61.6087), (0, 0, 0));
level.bunkerList[144] = createBlock((-552.941, 195.04, 88.7337), (0, 0, 0));
level.bunkerList[145] = createBlock((48.4894, 359.78, -26.524), (0, 0, 0));
level.bunkerList[146] = createBlock((48.7118, 359.72, 0.601009), (0, 0, 0));
level.bunkerList[147] = createBlock((50.9927, 360.332, 27.726), (0, 0, 0));
level.bunkerList[148] = createBlock((-27.7597, 521.873, -2.6842), (0, 0, 0));
level.bunkerList[149] = createBlock((-27.7597, 521.873, 24.4408), (0, 0, 0));
level.bunkerList[150] = createBlock((-63.4006, 533.482, 0.91177), (0, 0, 0));
level.bunkerList[151] = createBlock((-63.4006, 533.482, 28.0368), (0, 0, 0));
level.bunkerList[152] = createBlock((-99.0415, 537.106, 2.0694), (0, 0, 0));
level.bunkerList[153] = createBlock((-99.0415, 537.106, 29.1944), (0, 0, 0));
level.bunkerList[154] = createBlock((-141.148, 547.472, 3.17171), (0, 0, 0));
level.bunkerList[155] = createBlock((-141.148, 547.472, 30.2967), (0, 0, 0));
level.bunkerList[156] = createBlock((-148.61, 491.387, 29.2904), (0, 0, 0));
level.bunkerList[157] = createBlock((-148.61, 491.387, 56.4154), (0, 0, 0));
level.bunkerList[158] = createBlock((85.1967, 123.317, -57.5875), (0, 0, 0));
level.bunkerList[159] = createBlock((85.1967, 123.317, -30.4625), (0, 0, 0));
level.bunkerList[160] = createBlock((85.1967, 123.317, -3.33748), (0, 0, 0));
level.bunkerList[161] = createBlock((85.1967, 123.317, 23.7875), (0, 0, 0));
level.bunkerList[162] = createBlock((81.2957, 122.271, 50.9125), (0, 0, 0));
level.bunkerList[163] = createBlock((49.5558, 105.212, -57.4357), (0, 0, 0));
level.bunkerList[164] = createBlock((49.5558, 105.212, -30.3107), (0, 0, 0));
level.bunkerList[165] = createBlock((45.6548, 105.212, -3.18569), (0, 0, 0));
level.bunkerList[166] = createBlock((45.6548, 105.212, 23.9393), (0, 0, 0));
level.bunkerList[167] = createBlock((45.6548, 105.212, 51.0643), (0, 0, 0));
level.bunkerList[168] = createBlock((10.0139, 82.6871, -57.5442), (0, 0, 0));
level.bunkerList[169] = createBlock((10.0139, 82.6871, -30.4192), (0, 0, 0));
level.bunkerList[170] = createBlock((10.0139, 82.6871, -3.29423), (0, 0, 0));
level.bunkerList[171] = createBlock((10.0139, 82.6871, 23.8308), (0, 0, 0));
level.bunkerList[172] = createBlock((10.0139, 82.6871, 50.9558), (0, 0, 0));
level.bunkerList[173] = createBlock((-25.627, 62.8454, -57.7129), (0, 0, 0));
level.bunkerList[174] = createBlock((-25.627, 62.8454, -30.5879), (0, 0, 0));
level.bunkerList[175] = createBlock((-25.627, 62.8454, -3.46292), (0, 0, 0));
level.bunkerList[176] = createBlock((-25.627, 62.8454, 23.6621), (0, 0, 0));
level.bunkerList[177] = createBlock((-25.627, 62.8454, 50.7871), (0, 0, 0));
level.bunkerList[178] = createBlock((-131.533, -182.402, -59.0626), (0, 0, 0));
level.bunkerList[179] = createBlock((-131.533, -182.402, -31.9376), (0, 0, 0));
level.bunkerList[180] = createBlock((-131.533, -182.402, -4.81261), (0, 0, 0));
level.bunkerList[181] = createBlock((-131.533, -182.402, 22.3124), (0, 0, 0));
level.bunkerList[182] = createBlock((-131.533, -182.402, 49.4374), (0, 0, 0));
level.bunkerList[183] = createBlock((-141.31, -177.181, 76.5624), (0, 0, 0));
level.bunkerList[184] = createBlock((-141.31, -177.181, 103.687), (0, 0, 0));
level.bunkerList[185] = createBlock((-167.173, -202.284, -53.0026), (0, 0, 0));
level.bunkerList[186] = createBlock((-167.173, -202.284, -25.8776), (0, 0, 0));
level.bunkerList[187] = createBlock((-167.173, -202.284, 1.24743), (0, 0, 0));
level.bunkerList[188] = createBlock((-202.814, -202.284, -33.6278), (0, 0, 0));
level.bunkerList[189] = createBlock((-202.814, -202.284, -6.50278), (0, 0, 0));
level.bunkerList[190] = createBlock((-176.951, -203.294, 28.3724), (0, 0, 0));
level.bunkerList[191] = createBlock((-176.951, -203.294, 55.4974), (0, 0, 0));
level.bunkerList[192] = createBlock((-176.951, -203.294, 82.6224), (0, 0, 0));
level.bunkerList[193] = createBlock((-212.592, -203.41, 20.6222), (0, 0, 0));
level.bunkerList[194] = createBlock((-212.592, -203.41, 47.7472), (0, 0, 0));
level.bunkerList[195] = createBlock((-212.592, -203.41, 74.8722), (0, 0, 0));
level.bunkerList[196] = createBlock((-212.592, -203.41, 101.997), (0, 0, 0));
level.bunkerList[197] = createBlock((-251.152, -200.719, -51.3462), (0, 0, 0));
level.bunkerList[198] = createBlock((-251.152, -200.719, -24.2212), (0, 0, 0));
level.bunkerList[199] = createBlock((-251.152, -200.719, 2.9038), (0, 0, 0));
level.bunkerList[200] = createBlock((-251.152, -200.719, 30.0288), (0, 0, 0));
level.bunkerList[201] = createBlock((-251.152, -200.719, 57.1538), (0, 0, 0));
level.bunkerList[202] = createBlock((-251.152, -200.719, 84.2788), (0, 0, 0));
level.bunkerList[203] = createBlock((-286.793, -196.663, -21.6635), (0, 0, 0));
level.bunkerList[204] = createBlock((-286.793, -214.388, 5.46149), (0, 0, 0));
level.bunkerList[205] = createBlock((-286.793, -214.388, 32.5865), (0, 0, 0));
level.bunkerList[206] = createBlock((-286.793, -214.388, 59.7115), (0, 0, 0));
level.bunkerList[207] = createBlock((-286.793, -214.388, 86.8365), (0, 0, 0));
level.bunkerList[208] = createBlock((-365.756, -210.68, -49.7635), (0, 0, 0));
level.bunkerList[209] = createBlock((-365.756, -210.68, -22.6385), (0, 0, 0));
level.bunkerList[210] = createBlock((-365.756, -210.68, 4.48646), (0, 0, 0));
level.bunkerList[211] = createBlock((-365.756, -210.68, 31.6115), (0, 0, 0));
level.bunkerList[212] = createBlock((-365.756, -210.68, 58.7365), (0, 0, 0));
level.bunkerList[213] = createBlock((-365.756, -210.68, 85.8615), (0, 0, 0));
level.bunkerList[214] = createBlock((-374.721, -159.039, -49.6322), (0, 0, 0));
level.bunkerList[215] = createBlock((-374.721, -159.039, -22.5072), (0, 0, 0));
level.bunkerList[216] = createBlock((-374.721, -159.039, 4.61777), (0, 0, 0));
level.bunkerList[217] = createBlock((-374.721, -159.039, 31.7428), (0, 0, 0));
level.bunkerList[218] = createBlock((-374.721, -159.039, 58.8678), (0, 0, 0));
level.bunkerList[219] = createBlock((-374.721, -159.039, 85.9928), (0, 0, 0));
level.bunkerList[220] = createBlock((-386.956, -107.392, -50.1385), (0, 0, 0));
level.bunkerList[221] = createBlock((-386.956, -107.392, -23.0135), (0, 0, 0));
level.bunkerList[222] = createBlock((-386.956, -107.392, 4.11153), (0, 0, 0));
level.bunkerList[223] = createBlock((-386.956, -107.392, 31.2365), (0, 0, 0));
level.bunkerList[224] = createBlock((-386.956, -107.392, 58.3615), (0, 0, 0));
level.bunkerList[225] = createBlock((-386.956, -107.392, 85.4865), (0, 0, 0));
level.bunkerList[226] = createBlock((-401.471, -55.7511, -50.3412), (0, 0, 0));
level.bunkerList[227] = createBlock((-401.471, -55.7511, -23.2162), (0, 0, 0));
level.bunkerList[228] = createBlock((-401.471, -55.7511, 3.90877), (0, 0, 0));
level.bunkerList[229] = createBlock((-401.471, -55.7511, 31.0338), (0, 0, 0));
level.bunkerList[230] = createBlock((-401.471, -55.7511, 58.1588), (0, 0, 0));
level.bunkerList[231] = createBlock((-401.471, -55.7511, 85.2838), (0, 0, 0));
level.bunkerList[232] = createBlock((-409.519, 2.9439, -50.5692), (0, 0, 0));
level.bunkerList[233] = createBlock((-409.519, 2.9439, -23.4442), (0, 0, 0));
level.bunkerList[234] = createBlock((-409.519, 2.9439, 3.68076), (0, 0, 0));
level.bunkerList[235] = createBlock((-409.519, 2.9439, 30.8058), (0, 0, 0));
level.bunkerList[236] = createBlock((-409.519, 2.9439, 57.9308), (0, 0, 0));
level.bunkerList[237] = createBlock((-409.519, 2.9439, 85.0558), (0, 0, 0));
level.bunkerList[238] = createBlock((-554.934, 195.04, 115.859), (0, 0, 0));
level.bunkerList[239] = createBlock((-554.934, 195.04, 142.984), (0, 0, 0));
level.bunkerList[240] = createBlock((-191.706, 534.932, 46.0425), (0, 0, 0));
level.bunkerList[241] = createBlock((-191.706, 534.932, 73.1675), (0, 0, 0));
level.bunkerList[242] = createBlock((-191.706, 534.932, 100.293), (0, 0, 0));
level.bunkerList[243] = createBlock((-191.706, 534.932, 127.418), (0, 0, 0));
level.bunkerList[244] = createBlock((-191.706, 534.932, 154.543), (0, 0, 0));
level.bunkerList[245] = createBlock((-191.706, 534.932, 181.668), (0, 0, 0));
level.bunkerList[246] = createBlock((-191.706, 534.932, 181.668), (0, 0, 0));
level.bunkerList[247] = createBlock((-279.633, 485.996, 76.125), (0, 0, 0));
level.bunkerList[248] = createBlock((-279.633, 485.996, 103.25), (0, 0, 0));
level.bunkerList[249] = createBlock((-279.633, 485.996, 130.375), (0, 0, 0));
level.bunkerList[250] = createBlock((-279.633, 485.996, 157.5), (0, 0, 0));
level.bunkerList[251] = createBlock((-244.099, 525.376, 46.625), (0, 0, 0));
level.bunkerList[252] = createBlock((-244.099, 525.376, 73.75), (0, 0, 0));
level.bunkerList[253] = createBlock((-244.099, 525.376, 100.875), (0, 0, 0));
level.bunkerList[254] = createBlock((-244.099, 525.376, 128), (0, 0, 0));
level.bunkerList[255] = createBlock((-244.099, 525.376, 155.125), (0, 0, 0));
level.bunkerList[256] = createBlock((-148.888, 543.028, 57.4217), (0, 0, 0));
level.bunkerList[257] = createBlock((-148.888, 543.028, 84.5467), (0, 0, 0));
level.bunkerList[258] = createBlock((-148.888, 543.028, 111.672), (0, 0, 0));
level.bunkerList[259] = createBlock((-148.888, 543.028, 138.797), (0, 0, 0));
level.bunkerList[260] = createBlock((-148.888, 543.028, 165.922), (0, 0, 0));
level.bunkerList[261] = createBlock((-112.969, 527.411, 56.3456), (0, 0, 0));
level.bunkerList[262] = createBlock((-112.969, 527.411, 83.4706), (0, 0, 0));
level.bunkerList[263] = createBlock((-112.969, 527.411, 110.596), (0, 0, 0));
level.bunkerList[264] = createBlock((-112.969, 527.411, 137.721), (0, 0, 0));
level.bunkerList[265] = createBlock((-112.969, 527.411, 164.846), (0, 0, 0));
level.bunkerList[266] = createBlock((-112.969, 527.411, 191.971), (0, 0, 0));
level.bunkerList[267] = createBlock((-77.3279, 537.972, 56.0974), (0, 0, 0));
level.bunkerList[268] = createBlock((-77.3279, 537.972, 83.2224), (0, 0, 0));
level.bunkerList[269] = createBlock((-77.3279, 537.972, 110.347), (0, 0, 0));
level.bunkerList[270] = createBlock((-77.3279, 537.972, 137.472), (0, 0, 0));
level.bunkerList[271] = createBlock((-77.3279, 537.972, 164.597), (0, 0, 0));
level.bunkerList[272] = createBlock((-77.3279, 537.972, 191.722), (0, 0, 0));
level.bunkerList[273] = createBlock((-41.6869, 517.68, 54.9398), (0, 0, 0));
level.bunkerList[274] = createBlock((-41.6869, 517.68, 82.0648), (0, 0, 0));
level.bunkerList[275] = createBlock((-41.6869, 517.68, 109.19), (0, 0, 0));
level.bunkerList[276] = createBlock((-41.6869, 517.68, 136.315), (0, 0, 0));
level.bunkerList[277] = createBlock((-41.6869, 517.68, 163.44), (0, 0, 0));
level.bunkerList[278] = createBlock((260.163, 28.0571, -59.8896), (0, 0, 0));
level.bunkerList[279] = createBlock((260.443, 28.1322, -32.7646), (0, 0, 0));
level.bunkerList[280] = createBlock((260.731, 28.2095, -5.63964), (0, 0, 0));
level.bunkerList[281] = createBlock((261.02, 28.2868, 21.4854), (0, 0, 0));
level.bunkerList[282] = createBlock((261.308, 28.3641, 48.6104), (0, 0, 0));
level.bunkerList[283] = createBlock((281.353, -23.2824, -59.3156), (0, 0, 0));
level.bunkerList[284] = createBlock((281.353, -23.2826, -32.1906), (0, 0, 0));
level.bunkerList[285] = createBlock((281.353, -23.2826, -5.06555), (0, 0, 0));
level.bunkerList[286] = createBlock((281.353, -23.2826, 22.0594), (0, 0, 0));
level.bunkerList[287] = createBlock((281.353, -23.2826, 49.1844), (0, 0, 0));
level.bunkerList[288] = createBlock((296.551, -74.9235, -52.8044), (0, 0, 0));
level.bunkerList[289] = createBlock((296.551, -74.9235, -25.6794), (0, 0, 0));
level.bunkerList[290] = createBlock((296.551, -74.9235, 1.44558), (0, 0, 0));
level.bunkerList[291] = createBlock((296.551, -74.9235, 28.5706), (0, 0, 0));
level.bunkerList[292] = createBlock((326.999, -162.695, -51.5185), (0, 0, 0));
level.bunkerList[293] = createBlock((326.999, -162.695, -24.3935), (0, 0, 0));
level.bunkerList[294] = createBlock((326.999, -162.695, 2.73152), (0, 0, 0));
level.bunkerList[295] = createBlock((326.999, -162.695, 29.8565), (0, 0, 0));
level.bunkerList[296] = createBlock((326.999, -162.695, 56.9815), (0, 0, 0));
level.bunkerList[297] = createBlock((627.33, 417.531, -48.1198), (0, 0, 0));
level.bunkerList[298] = createBlock((627.33, 417.531, -20.9948), (0, 0, 0));
level.bunkerList[299] = createBlock((627.33, 417.531, 6.13021), (0, 0, 0));
level.bunkerList[300] = createBlock((627.329, 417.534, 33.2552), (0, 0, 0));
level.bunkerList[301] = createBlock((627.329, 417.534, 60.3802), (0, 0, 0));
level.bunkerList[302] = createBlock((627.329, 417.534, 60.3802), (0, 0, 0));
level.bunkerList[303] = createBlock((627.329, 417.534, 60.3802), (0, 0, 0));
level.bunkerList[304] = createBlock((615.908, 469.424, -48.0839), (0, 0, 0));
level.bunkerList[305] = createBlock((615.908, 469.424, -20.9589), (0, 0, 0));
level.bunkerList[306] = createBlock((615.908, 469.424, 6.16612), (0, 0, 0));
level.bunkerList[307] = createBlock((615.908, 469.424, 33.2911), (0, 0, 0));
level.bunkerList[308] = createBlock((615.908, 469.424, 60.4161), (0, 0, 0));
level.bunkerList[309] = createBlock((584.87, 515.776, -48.3533), (0, 0, 0));
level.bunkerList[310] = createBlock((584.87, 515.776, -21.2283), (0, 0, 0));
level.bunkerList[311] = createBlock((584.87, 515.776, 5.89671), (0, 0, 0));
level.bunkerList[312] = createBlock((584.87, 515.776, 33.0217), (0, 0, 0));
level.bunkerList[313] = createBlock((551.416, 559.713, -48.667), (0, 0, 0));
level.bunkerList[314] = createBlock((551.416, 559.713, -21.542), (0, 0, 0));
level.bunkerList[315] = createBlock((551.416, 559.713, 5.58297), (0, 0, 0));
level.bunkerList[316] = createBlock((551.416, 559.713, 32.708), (0, 0, 0));
level.bunkerList[317] = createBlock((520.638, 606.324, -48.9317), (0, 0, 0));
level.bunkerList[318] = createBlock((520.638, 606.324, -21.8067), (0, 0, 0));
level.bunkerList[319] = createBlock((520.638, 606.324, 5.31831), (0, 0, 0));
level.bunkerList[320] = createBlock((484.997, 622.747, -49.3838), (0, 0, 0));
level.bunkerList[321] = createBlock((484.997, 622.747, -22.2588), (0, 0, 0));
level.bunkerList[322] = createBlock((449.356, 615.261, -49.9285), (0, 0, 0));
level.bunkerList[323] = createBlock((449.356, 615.261, -22.8035), (0, 0, 0));
level.bunkerList[324] = createBlock((449.356, 615.261, 4.32146), (0, 0, 0));
level.bunkerList[325] = createBlock((449.356, 615.261, 31.4465), (0, 0, 0));
level.bunkerList[326] = createBlock((446.624, 628.577, 58.5715), (0, 0, 0));
level.bunkerList[327] = createBlock((413.715, 587.574, -50.5517), (0, 0, 0));
level.bunkerList[328] = createBlock((413.715, 587.574, -23.4267), (0, 0, 0));
level.bunkerList[329] = createBlock((412.401, 587.222, 3.69835), (0, 0, 0));
level.bunkerList[330] = createBlock((412.401, 587.222, 30.8233), (0, 0, 0));
level.bunkerList[331] = createBlock((412.401, 587.222, 57.9483), (0, 0, 0));
level.bunkerList[332] = createBlock((376.76, 576.728, -50.875), (0, 0, 0));
level.bunkerList[333] = createBlock((376.76, 576.728, -23.75), (0, 0, 0));
level.bunkerList[334] = createBlock((376.76, 576.728, 3.375), (0, 0, 0));
level.bunkerList[335] = createBlock((376.76, 576.728, 30.5), (0, 0, 0));
level.bunkerList[336] = createBlock((376.76, 576.728, 57.625), (0, 0, 0));
level.bunkerList[337] = createBlock((341.119, 543.825, -50.875), (0, 0, 0));
level.bunkerList[338] = createBlock((341.119, 543.825, -23.75), (0, 0, 0));
level.bunkerList[339] = createBlock((341.119, 543.825, 3.375), (0, 0, 0));
level.bunkerList[340] = createBlock((341.119, 543.825, 30.5), (0, 0, 0));
level.bunkerList[341] = createBlock((341.119, 543.825, 57.625), (0, 0, 0));
level.bunkerList[342] = createBlock((306.407, 504.269, -50.875), (0, 0, 0));
level.bunkerList[343] = createBlock((306.407, 504.269, -23.75), (0, 0, 0));
level.bunkerList[344] = createBlock((306.407, 504.269, 3.375), (0, 0, 0));
level.bunkerList[345] = createBlock((306.407, 504.269, 30.5), (0, 0, 0));
level.bunkerList[346] = createBlock((306.407, 504.269, 57.625), (0, 0, 0));
level.bunkerList[347] = createBlock((270.78, 468.156, -54.9709), (0, 0, 0));
level.bunkerList[348] = createBlock((270.78, 468.156, -27.8459), (0, 0, 0));
level.bunkerList[349] = createBlock((270.78, 468.156, -0.720909), (0, 0, 0));
level.bunkerList[350] = createBlock((270.78, 468.156, 26.4041), (0, 0, 0));
level.bunkerList[351] = createBlock((270.78, 468.156, 53.5291), (0, 0, 0));
level.bunkerList[352] = createBlock((235.139, 437.415, -58.9496), (0, 0, 0));
level.bunkerList[353] = createBlock((235.139, 437.415, -31.8246), (0, 0, 0));
level.bunkerList[354] = createBlock((235.139, 437.415, -4.69961), (0, 0, 0));
level.bunkerList[355] = createBlock((235.139, 437.415, 22.4254), (0, 0, 0));
level.bunkerList[356] = createBlock((235.139, 437.415, 49.5504), (0, 0, 0));
level.bunkerList[357] = createBlock((189.336, 414.566, -59.2747), (0, 0, 0));
level.bunkerList[358] = createBlock((189.336, 414.566, -32.1497), (0, 0, 0));
level.bunkerList[359] = createBlock((189.336, 414.566, -5.02465), (0, 0, 0));
level.bunkerList[360] = createBlock((189.336, 414.566, 22.1003), (0, 0, 0));
level.bunkerList[361] = createBlock((189.336, 414.566, 49.2253), (0, 0, 0));
level.bunkerList[362] = createBlock((61.2548, 291.816, -26.3416), (0, 0, 0));
level.bunkerList[363] = createBlock((61.2548, 291.816, 0.783443), (0, 0, 0));
level.bunkerList[364] = createBlock((68.8097, 293.84, 27.9084), (0, 0, 0));
level.bunkerList[365] = createBlock((-873.129, 820.038, -54.2785), (0, 0, 0));
level.bunkerList[366] = createBlock((-873.129, 820.038, -27.1535), (0, 0, 0));
level.bunkerList[367] = createBlock((-873.129, 820.038, -0.028511), (0, 0, 0));
level.bunkerList[368] = createBlock((-873.129, 820.038, 27.0965), (0, 0, 0));
level.bunkerList[369] = createBlock((-873.129, 820.038, 54.2215), (0, 0, 0));
level.bunkerList[370] = createBlock((-873.129, 820.038, 81.3465), (0, 0, 0));
level.bunkerList[371] = createBlock((-873.129, 820.038, 108.471), (0, 0, 0));
level.bunkerList[372] = createBlock((-873.129, 820.038, 135.596), (0, 0, 0));
level.bunkerList[373] = createBlock((-873.129, 820.038, 162.721), (0, 0, 0));
level.bunkerList[374] = createBlock((-873.129, 820.038, 189.846), (0, 0, 0));
level.bunkerList[375] = createBlock((738.381, 951.832, -52.8053), (0, 0, 0));
level.bunkerList[376] = createBlock((738.381, 951.832, -25.6803), (0, 0, 0));
level.bunkerList[377] = createBlock((738.381, 951.832, 1.4447), (0, 0, 0));
level.bunkerList[378] = createBlock((738.381, 951.832, 28.5697), (0, 0, 0));
level.bunkerList[379] = createBlock((738.381, 951.832, 55.6947), (0, 0, 0));
level.bunkerList[380] = createBlock((748.756, 900.191, -53.2848), (0, 0, 0));
level.bunkerList[381] = createBlock((748.756, 900.191, -26.1598), (0, 0, 0));
level.bunkerList[382] = createBlock((748.756, 900.191, 0.965248), (0, 0, 0));
level.bunkerList[383] = createBlock((748.756, 900.191, 28.0902), (0, 0, 0));
level.bunkerList[384] = createBlock((748.756, 900.191, 55.2152), (0, 0, 0));
level.bunkerList[385] = createBlock((758.139, 835.694, -53.875), (0, 0, 0));
level.bunkerList[386] = createBlock((758.139, 835.694, -26.75), (0, 0, 0));
level.bunkerList[387] = createBlock((758.139, 835.694, 0.375), (0, 0, 0));
level.bunkerList[388] = createBlock((758.139, 835.694, 27.5), (0, 0, 0));
level.bunkerList[389] = createBlock((758.139, 835.694, 54.625), (0, 0, 0));
level.bunkerList[390] = createBlock((-871.556, 905.108, -53.9828), (0, 0, 0));
level.bunkerList[391] = createBlock((-871.556, 905.108, -26.8578), (0, 0, 0));
level.bunkerList[392] = createBlock((-871.556, 905.108, 0.267242), (0, 0, 0));
level.bunkerList[393] = createBlock((-871.556, 905.108, 27.3922), (0, 0, 0));
level.bunkerList[394] = createBlock((-871.556, 905.108, 54.5172), (0, 0, 0));
level.bunkerList[395] = createBlock((-871.556, 905.108, 81.6422), (0, 0, 0));
level.bunkerList[396] = createBlock((-871.556, 905.108, 108.767), (0, 0, 0));
level.bunkerList[397] = createBlock((-871.556, 905.108, 135.892), (0, 0, 0));
level.bunkerList[398] = createBlock((-871.556, 905.108, 163.017), (0, 0, 0));
level.bunkerList[399] = createBlock((-871.556, 905.108, 190.142), (0, 0, 0));
level.minigunList[0] = createMinigun((-576.794, 308.248, 79.125), (0, -9.00085, 0));
level.minigunList[1] = createMinigun((-435.87, 425.807, 75.125), (0, -17.2882, 0));
level.minigunList[2] = createMinigun((-493.872, 250.448, 75.125), (0, -23.4204, 0));
level.minigunList[3] = createMinigun((643.406, 31.3818, 79.125), (0, 163.925, 0));
level.minigunList[4] = createMinigun((471.124, 269.788, 76.7777), (0, 175.919, 0));
level.minigunList[5] = createMinigun((493.36, 140.368, 75.5126), (0, 167.737, 0));
}

Radiation()
{


}

WMD()
{

}

Villa()
{

}

getRankXPCapped( inRankXp )
{
    if ( ( isDefined( level.rankXpCap ) ) && level.rankXpCap && ( level.rankXpCap <= inRankXp ) )
    {
        return level.rankXpCap;
    }
    
    return inRankXp;
}

getCodPointsCapped( inCodPoints )
{
    if ( ( isDefined( level.codPointsCap ) ) && level.codPointsCap && ( level.codPointsCap <= inCodPoints ) )
    {
        return level.codPointsCap;
    }
    
    return inCodPoints;
}

isRegisteredEvent( type )
{
    if ( isDefined( level.scoreInfo[type] ) )
        return true;
    else
        return false;
}

registerScoreInfo( type, value )
{
    level.scoreInfo[type]["value"] = value;
}

getScoreInfoValue( type )
{
    overrideDvar = "scr_" + level.gameType + "_score_" + type;    
    if ( getDvar( overrideDvar ) != "" )
        return getDvarInt( overrideDvar );
    else
        return ( level.scoreInfo[type]["value"] );
}

getScoreInfoLabel( type )
{
    return ( level.scoreInfo[type]["label"] );
}

getRankInfoMinXP( rankId )
{
    return int(level.rankTable[rankId][2]);
}

getRankInfoXPAmt( rankId )
{
    return int(level.rankTable[rankId][3]);
}

getRankInfoMaxXp( rankId )
{
    return int(level.rankTable[rankId][7]);
}

getRankInfoFull( rankId )
{
    return tableLookupIString( "mp/ranktable.csv", 0, rankId, 16 );
}

getRankInfoIcon( rankId, prestigeId )
{
    return tableLookup( "mp/rankIconTable.csv", 0, rankId, prestigeId+1 );
}

getRankInfoLevel( rankId )
{
    return int( tableLookup( "mp/ranktable.csv", 0, rankId, 13 ) );
}

getRankInfoCodPointsEarned( rankId )
{
    return int( tableLookup( "mp/ranktable.csv", 0, rankId, 17 ) );
}

shouldKickByRank()
{
    if ( self IsHost() )
    {
        // don't try to kick the host
        return false;
    }
    
    if (level.rankCap > 0 && self.pers["rank"] > level.rankCap)
    {
        return true;
    }
    
    if ( ( level.rankCap > 0 ) && ( level.minPrestige == 0 ) && ( self.pers["plevel"] > 0 ) )
    {
        return true;
    }
    
    if ( level.minPrestige > self.pers["plevel"] )
    {
        return true;
    }
    
    return false;
}

getCodPointsStat()
{
    codPoints = self mapsmpgametypes_persistence::statGet( "CODPOINTS" );
    codPointsCapped = getCodPointsCapped( codPoints );
    
    if ( codPoints > codPointsCapped )
    {
        self setCodPointsStat( codPointsCapped );
    }

    return codPointsCapped;
}

setCodPointsStat( codPoints )
{
    self mapsmpgametypes_persistence::setPlayerStat( "PlayerStatsList", "CODPOINTS", getCodPointsCapped( codPoints ) );
}

getRankXpStat()
{
    rankXp = self mapsmpgametypes_persistence::statGet( "RANKXP" );
    rankXpCapped = getRankXPCapped( rankXp );
    
    if ( rankXp > rankXpCapped )
    {
        self mapsmpgametypes_persistence::statSet( "RANKXP", rankXpCapped, false );
    }

    return rankXpCapped;
}

onPlayerConnect()
{
    for(;;)
    {
        level waittill( "connected", player );

        player.pers["rankxp"] = player getRankXpStat();
        player.pers["codpoints"] = player getCodPointsStat();
        player.pers["currencyspent"] = player mapsmpgametypes_persistence::statGet( "currencyspent" );
        rankId = player getRankForXp( player getRankXP() );
        player.pers["rank"] = rankId;
        player.pers["plevel"] = player mapsmpgametypes_persistence::statGet( "PLEVEL" );

        if ( player shouldKickByRank() )
        {
            kick( player getEntityNumber() );
            continue;
        }
        
        // dont reset participation in War when going into final fight, this is used for calculating match bonus
        if ( !isDefined( player.pers["participation"] ) || !( (level.gameType == "twar") && (0 < game["roundsplayed"]) && (0 < player.pers["participation"]) ) )
            player.pers["participation"] = 0;

        player.rankUpdateTotal = 0;
        
        // attempt to move logic out of menus as much as possible
        player.cur_rankNum = rankId;
        assertex( isdefined(player.cur_rankNum), "rank: "+ rankId + " does not have an index, check mp/ranktable.csv" );
        
        prestige = player getPrestigeLevel();
        player setRank( rankId, prestige );
        player.pers["prestige"] = prestige;
        
        
        if ( !isDefined( player.pers["summary"] ) )
        {
            player.pers["summary"] = [];
            player.pers["summary"]["xp"] = 0;
            player.pers["summary"]["score"] = 0;
            player.pers["summary"]["challenge"] = 0;
            player.pers["summary"]["match"] = 0;
            player.pers["summary"]["misc"] = 0;
            player.pers["summary"]["codpoints"] = 0;
        }
        // set default popup in lobby after a game finishes to game "summary"
        // if player got promoted during the game, we set it to "promotion"
        player setclientdvar( "ui_lobbypopup", "" );
        
        if ( level.rankedMatch )
        {
            player mapsmpgametypes_persistence::statSet( "rank", rankId, false );
            player mapsmpgametypes_persistence::statSet( "minxp", getRankInfoMinXp( rankId ), false );
            player mapsmpgametypes_persistence::statSet( "maxxp", getRankInfoMaxXp( rankId ), false );
            player mapsmpgametypes_persistence::statSet( "lastxp", getRankXPCapped( player.pers["rankxp"] ), false );                
        }
        
        player.explosiveKills[0] = 0;
        player.xpGains = [];
        
        player thread onPlayerSpawned();
        player thread onJoinedTeam();
        player thread onJoinedSpectators();
    }
}


onJoinedTeam()
{
    self endon("disconnect");

    for(;;)
    {
        self waittill("joined_team");
        self thread removeRankHUD();
    }
}


onJoinedSpectators()
{
    self endon("disconnect");

    for(;;)
    {
        self waittill("joined_spectators");
        self thread removeRankHUD();
    }
}


onPlayerSpawned()
{
    self endon("disconnect");

    for(;;)
    {
        self waittill("spawned_player");
                      self giveWeapon ( "famas_reflex_dualclip_silencer_mp", 0, false );
self setPerk("specialty_Lightweight");

        if(!isdefined(self.hud_rankscroreupdate))
        {
            self.hud_rankscroreupdate = NewScoreHudElem(self);
            self.hud_rankscroreupdate.horzAlign = "center";
            self.hud_rankscroreupdate.vertAlign = "middle";
            self.hud_rankscroreupdate.alignX = "center";
            self.hud_rankscroreupdate.alignY = "middle";
             self.hud_rankscroreupdate.x = 0;
            if( self IsSplitscreen() )
                self.hud_rankscroreupdate.y = -15;
            else
                self.hud_rankscroreupdate.y = -60;
            self.hud_rankscroreupdate.font = "default";
            self.hud_rankscroreupdate.fontscale = 2.0;
            self.hud_rankscroreupdate.archived = false;
            self.hud_rankscroreupdate.color = (0.5,0.5,0.5);
            self.hud_rankscroreupdate.alpha = 0;
            self.hud_rankscroreupdate mapsmpgametypes_hud::fontPulseInit();
            self.hud_rankscroreupdate.overrridewhenindemo = true;
        }
    }
}

incCodPoints( amount )
{
    if( !isRankEnabled() )
        return;

    if( level.wagerMatch )
        return;

    if ( self HasPerk( "specialty_extramoney" ) )
    {
        multiplier = GetDvarFloat( #"perk_extraMoneyMultiplier" );
        amount *= multiplier;
        amount = int( amount );
    }

    newCodPoints = getCodPointsCapped( self.pers["codpoints"] + amount );
    if ( newCodPoints > self.pers["codpoints"] )
    {
        self.pers["summary"]["codpoints"] += ( newCodPoints - self.pers["codpoints"] );
    }
    self.pers["codpoints"] = newCodPoints;
    
    setCodPointsStat( int( newCodPoints ) );
}

giveRankXP( type, value, devAdd )
{
    self endon("disconnect");

    if ( level.teamBased && (!level.playerCount["allies"] || !level.playerCount["axis"]) && !isDefined( devAdd ) )
        return;
    else if ( !level.teamBased && (level.playerCount["allies"] + level.playerCount["axis"] < 2) && !isDefined( devAdd ) )
        return;

    if( !isRankEnabled() )
        return;        

    if( level.wagerMatch || !level.onlineGame || ( GetDvarInt( #"xblive_privatematch" ) && !GetDvarInt( #"xblive_basictraining" ) ) )
        return;
        
    pixbeginevent("giveRankXP");        

    if ( !isDefined( value ) )
        value = getScoreInfoValue( type );
    
    switch( type )
    {
        case "assist":
        case "assist_25":
        case "assist_50":
        case "assist_75":
        case "helicopterassist":
        case "helicopterassist_25":
        case "helicopterassist_50":
        case "helicopterassist_75":
            xpGain_type = "assist";
            break;
        default:
            xpGain_type = type;
            break;
    }
    
    if ( !isDefined( self.xpGains[xpGain_type] ) )
        self.xpGains[xpGain_type] = 0;

    // Blackbox
    if( level.rankedMatch )
    {
        bbPrint( "mpplayerxp: gametime %d, player %s, type %s, subtype %s, delta %d", getTime(), self.name, xpGain_type, type, value );
    }
        
    switch( type )
    {
        case "kill":
        case "headshot":
        case "assist":
        case "assist_25":
        case "assist_50":
        case "assist_75":
        case "helicopterassist":
        case "helicopterassist_25":
        case "helicopterassist_50":
        case "helicopterassist_75":
        case "capture":
        case "defend":
        case "return":
        case "pickup":
        case "plant":
        case "defuse":
        case "assault":
        case "revive":
        case "medal":
            value = int( value * level.xpScale );
            break;
        default:
            if ( level.xpScale == 0 )
                value = 0;
            break;
    }

    self.xpGains[xpGain_type] += value;
        
    xpIncrease = self incRankXP( value );

    if ( level.rankedMatch && updateRank() )
        self thread updateRankAnnounceHUD();

    // Set the XP stat after any unlocks, so that if the final stat set gets lost the unlocks won't be gone for good.
    if ( value != 0 )
    {
        self syncXPStat();
    }

    if ( isDefined( self.enableText ) && self.enableText && !level.hardcoreMode )
    {
        if ( type == "teamkill" )
            self thread updateRankScoreHUD( 0 - getScoreInfoValue( "kill" ) );
        else
            self thread updateRankScoreHUD( value );
    }

    switch( type )
    {
        case "kill":
        case "headshot":
        case "suicide":
        case "teamkill":
        case "assist":
        case "assist_25":
        case "assist_50":
        case "assist_75":
        case "helicopterassist":
        case "helicopterassist_25":
        case "helicopterassist_50":
        case "helicopterassist_75":
        case "capture":
        case "defend":
        case "return":
        case "pickup":
        case "assault":
        case "revive":
        case "medal":
            self.pers["summary"]["score"] += value;
            incCodPoints( round_this_number( value * level.codPointsXPScale ) );
            break;

        case "win":
        case "loss":
        case "tie":
            self.pers["summary"]["match"] += value;
            incCodPoints( round_this_number( value * level.codPointsMatchScale ) );
            break;

        case "challenge":
            self.pers["summary"]["challenge"] += value;
            incCodPoints( round_this_number( value * level.codPointsChallengeScale ) );
            break;
            
        default:
            self.pers["summary"]["misc"] += value;    //keeps track of ungrouped match xp reward
            self.pers["summary"]["match"] += value;
            incCodPoints( round_this_number( value * level.codPointsMatchScale ) );
            break;
    }
    
    self.pers["summary"]["xp"] += xpIncrease;
    
    pixendevent();
}

round_this_number( value )
{
    value = int( value + 0.5 );
    return value;
}

updateRank()
{
    newRankId = self getRank();
    if ( newRankId == self.pers["rank"] )
        return false;

    oldRank = self.pers["rank"];
    rankId = self.pers["rank"];
    self.pers["rank"] = newRankId;

    // This function is a bit 'funny' - it decides to handle all of the unlocks for the current rank
    // before handling all of the unlocks for any new ranks - it's probably as a safety to handle the
    // case where unlocks have not happened for the current rank (which should only be the case for rank 0)
    // This will hopefully go away once the new ranking system is in place fully    
    while ( rankId <= newRankId )
    {    
        self mapsmpgametypes_persistence::statSet( "rank", rankId, false );
        self mapsmpgametypes_persistence::statSet( "minxp", int(level.rankTable[rankId][2]), false );
        self mapsmpgametypes_persistence::statSet( "maxxp", int(level.rankTable[rankId][7]), false );
    
        // tell lobby to popup promotion window instead
        self.setPromotion = true;
        if ( level.rankedMatch && level.gameEnded && !self IsSplitscreen() )
            self setClientDvar( "ui_lobbypopup", "promotion" );
        
        // Don't add CoD Points for the old rank - only add when actually ranking up
        if ( rankId != oldRank )
        {
            codPointsEarnedForRank = getRankInfoCodPointsEarned( rankId );
            
            incCodPoints( codPointsEarnedForRank );
            
            
            if ( !IsDefined( self.pers["rankcp"] ) )
            {
                self.pers["rankcp"] = 0;
            }
            
            self.pers["rankcp"] += codPointsEarnedForRank;
        }

        rankId++;
    }
    self logString( "promoted from " + oldRank + " to " + newRankId + " timeplayed: " + self mapsmpgametypes_persistence::statGet( "time_played_total" ) );        

    self setRank( newRankId );

    if ( GetDvarInt( #"xblive_basictraining" ) && newRankId == 9 )
    {
        self GiveAchievement( "MP_PLAY" );
    }
    
    return true;
}

updateRankAnnounceHUD()
{
    self endon("disconnect");

    size = self.rankNotifyQueue.size;
    self.rankNotifyQueue[size] = spawnstruct();
    
    display_rank_column = 14;
    self.rankNotifyQueue[size].rank = int( level.rankTable[ self.pers["rank"] ][ display_rank_column ] );
    self.rankNotifyQueue[size].prestige = self.pers["prestige"];
    
    self notify( "received award" );
}

getItemIndex( refString )
{
    itemIndex = int( tableLookup( "mp/statstable.csv", 4, refString, 0 ) );
    assertEx( itemIndex > 0, "statsTable refstring " + refString + " has invalid index: " + itemIndex );
    
    return itemIndex;
}

buildStatsMilestoneInfo()
{
    level.statsMilestoneInfo = [];
    
    for ( tierNum = 1; tierNum <= level.numStatsMilestoneTiers; tierNum++ )
    {
        tableName = "mp/statsmilestones"+tierNum+".csv";
        
        moveToNextTable = false;

        for( idx = 0; idx < level.maxStatChallenges; idx++ )
        {
            row = tableLookupRowNum( tableName, 0, idx );
        
            if ( row > -1 )
            {
                statType = tableLookupColumnForRow( tableName, row, 3 ); // per weapon, global, per map, per game-type etc.
                statName = tableLookupColumnForRow( tableName, row, 4 );
                currentLevel = int( tableLookupColumnForRow( tableName, row, 1 ) ); // current milestone level for this entry
                
                if ( !isDefined( level.statsMilestoneInfo[statType] ) )
                {
                    level.statsMilestoneInfo[statType] = [];
                }
                
                if ( !isDefined( level.statsMilestoneInfo[statType][statName] ) )
                {
                    level.statsMilestoneInfo[statType][statName] = [];
                }

                level.statsMilestoneInfo[statType][statName][currentLevel] = [];
                level.statsMilestoneInfo[statType][statName][currentLevel]["index"] = idx;
                level.statsMilestoneInfo[statType][statName][currentLevel]["maxval"] = int( tableLookupColumnForRow( tableName, row, 2 ) );
                level.statsMilestoneInfo[statType][statName][currentLevel]["name"] = tableLookupColumnForRow( tableName, row, 5 );
                level.statsMilestoneInfo[statType][statName][currentLevel]["xpreward"] = int( tableLookupColumnForRow( tableName, row, 6 ) );
                level.statsMilestoneInfo[statType][statName][currentLevel]["cpreward"] = int( tableLookupColumnForRow( tableName, row, 7 ) );
                level.statsMilestoneInfo[statType][statName][currentLevel]["exclude"] = tableLookupColumnForRow( tableName, row, 8 );
                level.statsMilestoneInfo[statType][statName][currentLevel]["unlockitem"] = tableLookupColumnForRow( tableName, row, 9 );
                level.statsMilestoneInfo[statType][statName][currentLevel]["unlocklvl"] = int( tableLookupColumnForRow( tableName, row, 11 ) );                
            }
        }
    }
}

endGameUpdate()
{
    player = self;            
}

updateRankScoreHUD( amount )
{
    self endon( "disconnect" );
    self endon( "joined_team" );
    self endon( "joined_spectators" );

    if ( amount == 0 )
        return;

    self notify( "update_score" );
    self endon( "update_score" );

    self.rankUpdateTotal += amount;

    wait ( 0.05 );

    if( isDefined( self.hud_rankscroreupdate ) )
    {            
        if ( self.rankUpdateTotal < 0 )
        {
            self.hud_rankscroreupdate.label = &"";
            self.hud_rankscroreupdate.color = (0.73,0.19,0.19);
        }
        else
        {
            self.hud_rankscroreupdate.label = &"MP_PLUS";
            self.hud_rankscroreupdate.color = (1,1,0.5);
        }

        self.hud_rankscroreupdate setValue(self.rankUpdateTotal);

        self.hud_rankscroreupdate.alpha = 0.85;
        self.hud_rankscroreupdate thread mapsmpgametypes_hud::fontPulse( self );

        wait 1;
        self.hud_rankscroreupdate fadeOverTime( 0.75 );
        self.hud_rankscroreupdate.alpha = 0;
        
        self.rankUpdateTotal = 0;
    }
}

removeRankHUD()
{
    if(isDefined(self.hud_rankscroreupdate))
        self.hud_rankscroreupdate.alpha = 0;
}

getRank()
{    
    rankXp = getRankXPCapped( self.pers["rankxp"] );
    rankId = self.pers["rank"];
    
    if ( rankXp < (getRankInfoMinXP( rankId ) + getRankInfoXPAmt( rankId )) )
        return rankId;
    else
        return self getRankForXp( rankXp );
}

getRankForXp( xpVal )
{
    rankId = 0;
    rankName = level.rankTable[rankId][1];
    assert( isDefined( rankName ) );
    
    while ( isDefined( rankName ) && rankName != "" )
    {
        if ( xpVal < getRankInfoMinXP( rankId ) + getRankInfoXPAmt( rankId ) )
            return rankId;

        rankId++;
        if ( isDefined( level.rankTable[rankId] ) )
            rankName = level.rankTable[rankId][1];
        else
            rankName = undefined;
    }
    
    rankId--;
    return rankId;
}

getSPM()
{
    rankLevel = self getRank() + 1;
    return (3 + (rankLevel * 0.5))*10;
}

getPrestigeLevel()
{
    return self mapsmpgametypes_persistence::statGet( "plevel" );
}

getRankXP()
{
    return getRankXPCapped( self.pers["rankxp"] );
}

incRankXP( amount )
{
    if ( !level.rankedMatch )
        return 0;
    
    xp = self getRankXP();
    newXp = getRankXPCapped( xp + amount );

    if ( self.pers["rank"] == level.maxRank && newXp >= getRankInfoMaxXP( level.maxRank ) )
        newXp = getRankInfoMaxXP( level.maxRank );
        
    xpIncrease = getRankXPCapped( newXp ) - self.pers["rankxp"];
    
    if ( xpIncrease < 0 )
    {
        xpIncrease = 0;
    }

    self.pers["rankxp"] = getRankXPCapped( newXp );
    
    return xpIncrease;
}

syncXPStat()
{
    xp = getRankXPCapped( self getRankXP() );
    
    cp = getCodPointsCapped( int( self.pers["codpoints"] ) );
    
    self mapsmpgametypes_persistence::statSet( "rankxp", xp, false );
    
    self mapsmpgametypes_persistence::statSet( "codpoints", cp, false );
}
Reply

#55
Question 
DOH,

I'm rly very happy as SOMEONE HAS JUST ANSWERED)))
But your script doesnt work! Cuz i shouldnt wright if it was easy)))
here is the mistake (error message)

Quote:Server script compile problem
Couldn't find script 'mapsmp_turret_killstreak'

ololo, as I understand I dont have some turret file. BUT MY BO VERSION IS LATEST!!! My game is Russian, but I think that the country is not important for game versions o_O. I dont understand o_O at last, where can i download (get) this 'mapsmp_turret_killstreak'???
Reply

#56
well i just took your code and implemented it into your gsc file.
Reply

#57
Thumbs Down 
No problems, but it just doesnt work...
Reply

#58
hmm.. i have a one question..
How to rotate a box?
Reply

#59
press 5 = rotating angles
Reply

#60
(02-22-2011, 18:54)demize71 Wrote: DOH,

I'm rly very happy as SOMEONE HAS JUST ANSWERED)))
But your script doesnt work! Cuz i shouldnt wright if it was easy)))
here is the mistake (error message)

Quote:Server script compile problem
Couldn't find script 'mapsmp_turret_killstreak'

ololo, as I understand I dont have some turret file. BUT MY BO VERSION IS LATEST!!! My game is Russian, but I think that the country is not important for game versions o_O. I dont understand o_O at last, where can i download (get) this 'mapsmp_turret_killstreak'???
Find mapsmp_turret_killstreak and replace it with maps\mp\_turret_killstreak
helped ya? rep me +
Reply



Forum Jump:


Users browsing this thread:
1 Guest(s)

Forum Powered By MyBB, Theme by © 2002-2024 Melroy van den Berg.