Advertisement
Guest User

_zm_powerups.gsc

a guest
Dec 31st, 2020
68
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 91.70 KB | None | 0 0
  1. #include maps/mp/zombies/_zm_melee_weapon;
  2. #include maps/mp/zombies/_zm_weapons;
  3. #include maps/mp/zombies/_zm_perks;
  4. #include maps/mp/gametypes_zm/_hud_util;
  5. #include maps/mp/zombies/_zm_pers_upgrades_functions;
  6. #include maps/mp/zombies/_zm_spawner;
  7. #include maps/mp/animscripts/zm_death;
  8. #include maps/mp/zombies/_zm_score;
  9. #include maps/mp/zombies/_zm_powerups;
  10. #include maps/mp/zombies/_zm_blockers;
  11. #include maps/mp/zombies/_zm_audio_announcer;
  12. #include maps/mp/zombies/_zm_stats;
  13. #include maps/mp/zombies/_zm_pers_upgrades;
  14. #include maps/mp/zombies/_zm_laststand;
  15. #include maps/mp/_demo;
  16. #include maps/mp/zombies/_zm_magicbox;
  17. #include maps/mp/zombies/_zm_audio;
  18. #include maps/mp/zombies/_zm_net;
  19. #include maps/mp/zombies/_zm_utility;
  20. #include maps/mp/_utility;
  21. #include common_scripts/utility;
  22. #include maps/mp/zombies/_zm;
  23. #include maps/mp/gametypes_zm/_hud_message;
  24. #include maps/mp/zombies/_zm_audio;
  25. #include maps/mp/zombies/_zm_score;
  26.  
  27. init()
  28. {
  29. precacheshader( "specialty_doublepoints_zombies" );
  30. precacheshader( "specialty_instakill_zombies" );
  31. precacheshader( "specialty_firesale_zombies" );
  32. precacheshader( "zom_icon_bonfire" );
  33. precacheshader( "zom_icon_minigun" );
  34. precacheshader( "black" );
  35. set_zombie_var( "zombie_insta_kill", 0, undefined, undefined, 1 );
  36. set_zombie_var( "zombie_point_scalar", 1, undefined, undefined, 1 );
  37. set_zombie_var( "zombie_drop_item", 0 );
  38. set_zombie_var( "zombie_timer_offset", 350 );
  39. set_zombie_var( "zombie_timer_offset_interval", 30 );
  40. set_zombie_var( "zombie_powerup_fire_sale_on", 0 );
  41. set_zombie_var( "zombie_powerup_fire_sale_time", 30 );
  42. set_zombie_var( "zombie_powerup_bonfire_sale_on", 0 );
  43. set_zombie_var( "zombie_powerup_bonfire_sale_time", 30 );
  44. set_zombie_var( "zombie_powerup_insta_kill_on", 0, undefined, undefined, 1 );
  45. set_zombie_var( "zombie_powerup_insta_kill_time", 30, undefined, undefined, 1 );
  46. set_zombie_var( "zombie_powerup_point_doubler_on", 0, undefined, undefined, 1 );
  47. set_zombie_var( "zombie_powerup_point_doubler_time", 30, undefined, undefined, 1 );
  48. set_zombie_var( "zombie_powerup_drop_increment", 2000 );
  49. set_zombie_var( "zombie_powerup_drop_max_per_round", 4 );
  50. if ( level.debugLogging_zm_powerups )
  51. {
  52. level.maxPowerupsPerRound = getDvarIntDefault( "maxPowerupsPerRound", 4 );
  53. level.zombie_vars["zombie_powerup_drop_max_per_round"] = level.maxPowerupsPerRound;
  54. }
  55. onplayerconnect_callback( ::init_player_zombie_vars );
  56. level._effect[ "powerup_on" ] = loadfx( "misc/fx_zombie_powerup_on" );
  57. level._effect[ "powerup_off" ] = loadfx( "misc/fx_zombie_powerup_off" );
  58. level._effect[ "powerup_grabbed" ] = loadfx( "misc/fx_zombie_powerup_grab" );
  59. level._effect[ "powerup_grabbed_wave" ] = loadfx( "misc/fx_zombie_powerup_wave" );
  60. if ( isDefined( level.using_zombie_powerups ) && level.using_zombie_powerups )
  61. {
  62. level._effect[ "powerup_on_red" ] = loadfx( "misc/fx_zombie_powerup_on_red" );
  63. level._effect[ "powerup_grabbed_red" ] = loadfx( "misc/fx_zombie_powerup_red_grab" );
  64. level._effect[ "powerup_grabbed_wave_red" ] = loadfx( "misc/fx_zombie_powerup_red_wave" );
  65. }
  66. level._effect[ "powerup_on_solo" ] = loadfx( "misc/fx_zombie_powerup_solo_on" );
  67. level._effect[ "powerup_grabbed_solo" ] = loadfx( "misc/fx_zombie_powerup_solo_grab" );
  68. level._effect[ "powerup_grabbed_wave_solo" ] = loadfx( "misc/fx_zombie_powerup_solo_wave" );
  69. level._effect[ "powerup_on_caution" ] = loadfx( "misc/fx_zombie_powerup_caution_on" );
  70. level._effect[ "powerup_grabbed_caution" ] = loadfx( "misc/fx_zombie_powerup_caution_grab" );
  71. level._effect[ "powerup_grabbed_wave_caution" ] = loadfx( "misc/fx_zombie_powerup_caution_wave" );
  72. init_powerups();
  73. init_custom_powerups();
  74. if ( !level.enable_magic )
  75. {
  76. return;
  77. }
  78. thread watch_for_drop();
  79. thread setup_firesale_audio();
  80. thread setup_bonfiresale_audio();
  81. level.use_new_carpenter_func = ::start_carpenter_new;
  82. level.board_repair_distance_squared = 562500;
  83. level thread track_pack_a_punch_drops();
  84. level thread onplayerconnecting_powerups();
  85. }
  86.  
  87. onplayerconnecting_powerups()
  88. {
  89. for(;;)
  90. {
  91. level waittill( "connecting", player );
  92. player thread startCustomPowerups();
  93. }
  94. }
  95.  
  96. custom_powerup_grab(powerup, player) //credit to _Ox much thx for powerup functions
  97. {
  98. if(powerup.powerup_name == "money_drop")
  99. player thread doRandomScore();
  100. else if(powerup.powerup_name == "pack_a_punch")
  101. player thread doPackAPunchWeapon();
  102. else if(powerup.powerup_name == "unlimited_ammo")
  103. player thread doUnlimitedAmmo();
  104. else if(powerup.powerup_name == "fast_feet")
  105. player thread doFastFeet();
  106. else if (isDefined(level.original_zombiemode_powerup_grab))
  107. level thread [[level.original_zombiemode_powerup_grab]](powerup, player);
  108. }
  109.  
  110. startCustomPowerups()
  111. {
  112. if(!isDefined(level.custompowerupinit))
  113. {
  114. level.custompowerupinit = true;
  115. wait 2;
  116. if(isDefined(level._zombiemode_powerup_grab))
  117. level.original_zombiemode_powerup_grab = level._zombiemode_powerup_grab;
  118. wait 2;
  119. level._zombiemode_powerup_grab = ::custom_powerup_grab;
  120. }
  121. }
  122.  
  123. init_custom_powerups() //credit goes to _Ox for most code
  124. {
  125. level.unlimited_ammo_duration = 20;
  126. include_zombie_powerup("unlimited_ammo");
  127. add_zombie_powerup("unlimited_ammo", "T6_WPN_AR_GALIL_WORLD", &"ZOMBIE_POWERUP_UNLIMITED_AMMO", ::func_should_always_drop, 0, 0, 0);
  128. powerup_set_can_pick_up_in_last_stand("unlimited_ammo", 1);
  129. if(getDvar("mapname") == "zm_prison")
  130. {
  131.  
  132. include_zombie_powerup("fast_feet");
  133. add_zombie_powerup("fast_feet", "bottle_whisky_01", &"ZOMBIE_POWERUP_FAST_FEET", ::func_should_always_drop, 0, 0, 0);
  134. powerup_set_can_pick_up_in_last_stand("fast_feet", 1);
  135.  
  136. include_zombie_powerup("pack_a_punch");
  137. add_zombie_powerup("pack_a_punch", "p6_zm_al_vending_pap_on", &"ZOMBIE_POWERUP_PACK_A_PUNCH", ::func_should_drop_pack_a_punch, 0, 0, 0);
  138. powerup_set_can_pick_up_in_last_stand("pack_a_punch", 0);
  139.  
  140. include_zombie_powerup("money_drop");
  141. add_zombie_powerup("money_drop", "p6_anim_zm_al_magic_box_lock_red", &"ZOMBIE_POWERUP_MONEY_DROP", ::func_should_always_drop, 0, 0, 0);
  142. powerup_set_can_pick_up_in_last_stand("money_drop", 1);
  143. }
  144. else if ( level.script == "zm_nuked" )
  145. {
  146. include_zombie_powerup("fast_feet");
  147. add_zombie_powerup("fast_feet", "t6_wpn_zmb_perk_bottle_doubletap_world", &"ZOMBIE_POWERUP_FAST_FEET", ::func_should_always_drop, 0, 0, 0);
  148. powerup_set_can_pick_up_in_last_stand("fast_feet", 1);
  149.  
  150. include_zombie_powerup("pack_a_punch");
  151. add_zombie_powerup("pack_a_punch", "p6_anim_zm_buildable_pap", &"ZOMBIE_POWERUP_PACK_A_PUNCH", ::func_should_drop_pack_a_punch, 0, 0, 0);
  152. powerup_set_can_pick_up_in_last_stand("pack_a_punch", 0);
  153.  
  154. include_zombie_powerup("money_drop");
  155. add_zombie_powerup("money_drop", "zombie_teddybear", &"ZOMBIE_POWERUP_MONEY_DROP", ::func_should_always_drop, 0, 0, 0);
  156. powerup_set_can_pick_up_in_last_stand("money_drop", 1);
  157. }
  158. else
  159. {
  160. include_zombie_powerup("fast_feet");
  161. add_zombie_powerup("fast_feet", "zombie_pickup_perk_bottle", &"ZOMBIE_POWERUP_FAST_FEET", ::func_should_always_drop, 0, 0, 0);
  162. powerup_set_can_pick_up_in_last_stand("fast_feet", 1);
  163.  
  164. include_zombie_powerup("pack_a_punch");
  165. add_zombie_powerup("pack_a_punch", "p6_anim_zm_buildable_pap", &"ZOMBIE_POWERUP_PACK_A_PUNCH", ::func_should_drop_pack_a_punch, 0, 0, 0);
  166. powerup_set_can_pick_up_in_last_stand("pack_a_punch", 0);
  167.  
  168. include_zombie_powerup("money_drop");
  169. add_zombie_powerup("money_drop", "zombie_teddybear", &"ZOMBIE_POWERUP_MONEY_DROP", ::func_should_always_drop, 0, 0, 0);
  170. powerup_set_can_pick_up_in_last_stand("money_drop", 1);
  171. }
  172. }
  173.  
  174. init_powerups()
  175. {
  176. flag_init( "zombie_drop_powerups" );
  177. level.unlimited_ammo_duration = 20;
  178. if ( isDefined( level.enable_magic ) && level.enable_magic )
  179. {
  180. flag_set( "zombie_drop_powerups" );
  181. }
  182. if ( !isDefined( level.active_powerups ) )
  183. {
  184. level.active_powerups = [];
  185. }
  186. if ( !isDefined( level.zombie_powerup_array ) )
  187. {
  188. level.zombie_powerup_array = [];
  189. }
  190. if ( !isDefined( level.zombie_special_drop_array ) )
  191. {
  192. level.zombie_special_drop_array = [];
  193. }
  194. add_zombie_powerup( "nuke", "zombie_bomb", &"ZOMBIE_POWERUP_NUKE", ::func_should_always_drop, 0, 0, 0, "misc/fx_zombie_mini_nuke_hotness" );
  195. add_zombie_powerup( "insta_kill", "zombie_skull", &"ZOMBIE_POWERUP_INSTA_KILL", ::func_should_always_drop, 0, 0, 0, undefined, "powerup_instant_kill", "zombie_powerup_insta_kill_time", "zombie_powerup_insta_kill_on" );
  196. add_zombie_powerup( "full_ammo", "zombie_ammocan", &"ZOMBIE_POWERUP_MAX_AMMO", ::func_should_always_drop, 0, 0, 0 );
  197. add_zombie_powerup( "double_points", "zombie_x2_icon", &"ZOMBIE_POWERUP_DOUBLE_POINTS", ::func_should_always_drop, 0, 0, 0, undefined, "powerup_double_points", "zombie_powerup_point_doubler_time", "zombie_powerup_point_doubler_on" );
  198. add_zombie_powerup( "carpenter", "zombie_carpenter", &"ZOMBIE_POWERUP_MAX_AMMO", ::func_should_drop_carpenter, 0, 0, 0 );
  199. add_zombie_powerup( "fire_sale", "zombie_firesale", &"ZOMBIE_POWERUP_MAX_AMMO", ::func_should_drop_fire_sale, 0, 0, 0, undefined, "powerup_fire_sale", "zombie_powerup_fire_sale_time", "zombie_powerup_fire_sale_on" );
  200. add_zombie_powerup( "bonfire_sale", "zombie_pickup_bonfire", &"ZOMBIE_POWERUP_MAX_AMMO", ::func_should_never_drop, 0, 0, 0, undefined, "powerup_bon_fire", "zombie_powerup_bonfire_sale_time", "zombie_powerup_bonfire_sale_on" );
  201. add_zombie_powerup( "minigun", "zombie_pickup_minigun", &"ZOMBIE_POWERUP_MINIGUN", ::func_should_drop_minigun, 1, 0, 0, undefined, "powerup_mini_gun", "zombie_powerup_minigun_time", "zombie_powerup_minigun_on" );
  202. add_zombie_powerup( "free_perk", "zombie_pickup_perk_bottle", &"ZOMBIE_POWERUP_FREE_PERK", ::func_should_never_drop, 0, 0, 0 );
  203. add_zombie_powerup( "tesla", "zombie_pickup_minigun", &"ZOMBIE_POWERUP_MINIGUN", ::func_should_never_drop, 1, 0, 0, undefined, "powerup_tesla", "zombie_powerup_tesla_time", "zombie_powerup_tesla_on" );
  204. add_zombie_powerup( "random_weapon", "zombie_pickup_minigun", &"ZOMBIE_POWERUP_MAX_AMMO", ::func_should_never_drop, 1, 0, 0 );
  205. add_zombie_powerup( "bonus_points_player", "zombie_z_money_icon", &"ZOMBIE_POWERUP_BONUS_POINTS", ::func_should_never_drop, 1, 0, 0 );
  206. add_zombie_powerup( "bonus_points_team", "zombie_z_money_icon", &"ZOMBIE_POWERUP_BONUS_POINTS", ::func_should_never_drop, 0, 0, 0 );
  207. add_zombie_powerup( "lose_points_team", "zombie_z_money_icon", &"ZOMBIE_POWERUP_LOSE_POINTS", ::func_should_never_drop, 0, 0, 1 );
  208. add_zombie_powerup( "lose_perk", "zombie_pickup_perk_bottle", &"ZOMBIE_POWERUP_MAX_AMMO", ::func_should_never_drop, 0, 0, 1 );
  209. add_zombie_powerup( "empty_clip", "zombie_ammocan", &"ZOMBIE_POWERUP_MAX_AMMO", ::func_should_never_drop, 0, 0, 1 );
  210. add_zombie_powerup( "insta_kill_ug", "zombie_skull", &"ZOMBIE_POWERUP_INSTA_KILL", ::func_should_never_drop, 1, 0, 0, undefined, "powerup_instant_kill_ug", "zombie_powerup_insta_kill_ug_time", "zombie_powerup_insta_kill_ug_on", 5000 );
  211. if ( isDefined( level.level_specific_init_powerups ) )
  212. {
  213. [[ level.level_specific_init_powerups ]]();
  214. }
  215. randomize_powerups();
  216. level.zombie_powerup_index = 0;
  217. randomize_powerups();
  218. level.rare_powerups_active = 0;
  219. level.firesale_vox_firstime = 0;
  220. level thread powerup_hud_monitor();
  221. if ( isDefined( level.quantum_bomb_register_result_func ) )
  222. {
  223. [[ level.quantum_bomb_register_result_func ]]( "random_powerup", ::quantum_bomb_random_powerup_result, 5, level.quantum_bomb_in_playable_area_validation_func );
  224. [[ level.quantum_bomb_register_result_func ]]( "random_zombie_grab_powerup", ::quantum_bomb_random_zombie_grab_powerup_result, 5, level.quantum_bomb_in_playable_area_validation_func );
  225. [[ level.quantum_bomb_register_result_func ]]( "random_weapon_powerup", ::quantum_bomb_random_weapon_powerup_result, 60, level.quantum_bomb_in_playable_area_validation_func );
  226. [[ level.quantum_bomb_register_result_func ]]( "random_bonus_or_lose_points_powerup", ::quantum_bomb_random_bonus_or_lose_points_powerup_result, 25, level.quantum_bomb_in_playable_area_validation_func );
  227. }
  228. registerclientfield( "scriptmover", "powerup_fx", 1000, 3, "int" );
  229. }
  230.  
  231. init_player_zombie_vars() //checked matches cerberus output
  232. {
  233. self.zombie_vars[ "zombie_powerup_minigun_on" ] = 0;
  234. self.zombie_vars[ "zombie_powerup_minigun_time" ] = 0;
  235. self.zombie_vars[ "zombie_powerup_tesla_on" ] = 0;
  236. self.zombie_vars[ "zombie_powerup_tesla_time" ] = 0;
  237. self.zombie_vars[ "zombie_powerup_insta_kill_ug_on" ] = 0;
  238. self.zombie_vars[ "zombie_powerup_insta_kill_ug_time" ] = 18;
  239. }
  240.  
  241. set_weapon_ignore_max_ammo( str_weapon ) //checked matches cerberus output
  242. {
  243. if ( !isDefined( level.zombie_weapons_no_max_ammo ) )
  244. {
  245. level.zombie_weapons_no_max_ammo = [];
  246. }
  247. level.zombie_weapons_no_max_ammo[ str_weapon ] = 1;
  248. }
  249.  
  250. powerup_hud_monitor() //checked partially changed to match cerberus output
  251. {
  252. flag_wait( "start_zombie_round_logic" );
  253. if ( isDefined( level.current_game_module ) && level.current_game_module == 2 )
  254. {
  255. return;
  256. }
  257. flashing_timers = [];
  258. flashing_values = [];
  259. flashing_timer = 10;
  260. flashing_delta_time = 0;
  261. flashing_is_on = 0;
  262. flashing_value = 3;
  263. flashing_min_timer = 0.15;
  264. while ( flashing_timer >= flashing_min_timer )
  265. {
  266. if ( flashing_timer < 5 )
  267. {
  268. flashing_delta_time = 0.1;
  269. }
  270. else
  271. {
  272. flashing_delta_time = 0.2;
  273. }
  274. if ( flashing_is_on )
  275. {
  276. flashing_timer = flashing_timer - flashing_delta_time - 0.05;
  277. flashing_value = 2;
  278. }
  279. else
  280. {
  281. flashing_timer -= flashing_delta_time;
  282. flashing_value = 3;
  283. }
  284. flashing_timers[ flashing_timers.size ] = flashing_timer;
  285. flashing_values[ flashing_values.size ] = flashing_value;
  286. flashing_is_on = !flashing_is_on;
  287. }
  288. client_fields = [];
  289. powerup_keys = getarraykeys( level.zombie_powerups );
  290. for ( powerup_key_index = 0; powerup_key_index < powerup_keys.size; powerup_key_index++ )
  291. {
  292. if ( isDefined( level.zombie_powerups[ powerup_keys[ powerup_key_index ] ].client_field_name ) )
  293. {
  294. powerup_name = powerup_keys[ powerup_key_index ];
  295. client_fields[ powerup_name ] = spawnstruct();
  296. client_fields[ powerup_name ].client_field_name = level.zombie_powerups[ powerup_name ].client_field_name;
  297. client_fields[ powerup_name ].solo = level.zombie_powerups[ powerup_name ].solo;
  298. client_fields[ powerup_name ].time_name = level.zombie_powerups[ powerup_name ].time_name;
  299. client_fields[ powerup_name ].on_name = level.zombie_powerups[ powerup_name ].on_name;
  300. }
  301. }
  302. client_field_keys = getarraykeys( client_fields );
  303.  
  304. while ( 1 )
  305. {
  306. wait 0.05;
  307. waittillframeend;
  308. players = get_players();
  309.  
  310. for ( playerindex = 0; playerindex < players.size; playerindex++ )
  311. {
  312. client_field_key_index = 0;
  313. while ( client_field_key_index < client_field_keys.size )
  314. {
  315.  
  316. player = players[ playerindex ];
  317. if ( isdefined(level.powerup_player_valid ) )
  318. {
  319. if ( ![[ level.powerup_player_valid ]]( player ) )
  320. {
  321. client_field_key_index++;
  322. continue;
  323. }
  324. }
  325.  
  326. client_field_name = client_fields[ client_field_keys[ client_field_key_index ] ].client_field_name;
  327. time_name = client_fields[ client_field_keys[ client_field_key_index ] ].time_name;
  328. on_name = client_fields[ client_field_keys[ client_field_key_index ] ].on_name;
  329. powerup_timer = undefined;
  330. powerup_on = undefined;
  331. if ( client_fields[ client_field_keys[ client_field_key_index ] ].solo )
  332. {
  333. if ( isdefined( player._show_solo_hud ) && player._show_solo_hud == 1 )
  334. {
  335. powerup_timer = player.zombie_vars[ time_name ];
  336. powerup_on = player.zombie_vars[ on_name ];
  337. }
  338. }
  339.  
  340. else if ( isdefined( level.zombie_vars[ player.team ][ time_name ] ) )
  341. {
  342. powerup_timer = level.zombie_vars[ player.team ][ time_name ];
  343. powerup_on = level.zombie_vars[ player.team ][on_name ];
  344. }
  345. else if ( isdefined( level.zombie_vars[ time_name ] ) )
  346. {
  347. powerup_timer = level.zombie_vars[ time_name ];
  348. powerup_on = level.zombie_vars[ on_name ];
  349. }
  350.  
  351. if ( isdefined( powerup_timer ) && isdefined( powerup_on ) )
  352. {
  353. player set_clientfield_powerups( client_field_name, powerup_timer, powerup_on, flashing_timers, flashing_values );
  354. }
  355. else
  356. {
  357. player setclientfieldtoplayer( client_field_name, 0 );
  358. }
  359. client_field_key_index++;
  360. }
  361. }
  362.  
  363. }
  364. }
  365.  
  366. set_clientfield_powerups( clientfield_name, powerup_timer, powerup_on, flashing_timers, flashing_values ) //checked changed to match cerberus output
  367. {
  368. if ( powerup_on )
  369. {
  370. if ( powerup_timer < 10 )
  371. {
  372. flashing_value = 3;
  373. for ( i = flashing_timers.size - 1; i > 0; i-- )
  374. {
  375. if ( powerup_timer < flashing_timers[ i ] )
  376. {
  377. flashing_value = flashing_values[ i ];
  378. break;
  379. }
  380. }
  381. self setclientfieldtoplayer( clientfield_name, flashing_value );
  382. }
  383. else
  384. {
  385. self setclientfieldtoplayer( clientfield_name, 1 );
  386. }
  387. }
  388. else
  389. {
  390. self setclientfieldtoplayer( clientfield_name, 0 );
  391. }
  392. }
  393.  
  394. randomize_powerups() //checked matches cerberus output
  395. {
  396. level.zombie_powerup_array = array_randomize( level.zombie_powerup_array );
  397. }
  398.  
  399. get_next_powerup() //checked matches cerberus output
  400. {
  401. powerup = level.zombie_powerup_array[ level.zombie_powerup_index ];
  402. level.zombie_powerup_index++;
  403. if ( level.zombie_powerup_index >= level.zombie_powerup_array.size )
  404. {
  405. level.zombie_powerup_index = 0;
  406. randomize_powerups();
  407. }
  408. return powerup;
  409. }
  410.  
  411. get_valid_powerup() //checked partially matches cerberus output did not change
  412. {
  413. if ( isDefined( level.zombie_powerup_boss ) )
  414. {
  415. i = level.zombie_powerup_boss;
  416. level.zombie_powerup_boss = undefined;
  417. return level.zombie_powerup_array[ i ];
  418. }
  419. if ( isDefined( level.zombie_powerup_ape ) )
  420. {
  421. powerup = level.zombie_powerup_ape;
  422. level.zombie_powerup_ape = undefined;
  423. return powerup;
  424. }
  425. powerup = get_next_powerup();
  426. while ( 1 )
  427. {
  428. while ( !( [[ level.zombie_powerups[ powerup ].func_should_drop_with_regular_powerups ]]() ) )
  429. {
  430. powerup = get_next_powerup();
  431. }
  432. return powerup;
  433. }
  434. }
  435.  
  436. minigun_no_drop() //checked matches cerberus output
  437. {
  438. players = get_players();
  439. i = 0;
  440. while ( i < players.size )
  441. {
  442. if ( players[ i ].zombie_vars[ "zombie_powerup_minigun_on" ] == 1 )
  443. {
  444. return 1;
  445. }
  446. i++;
  447. }
  448. if ( !flag( "power_on" ) )
  449. {
  450. if ( flag( "solo_game" ) )
  451. {
  452. if ( level.solo_lives_given == 0 )
  453. {
  454. return 1;
  455. }
  456. }
  457. else
  458. {
  459. return 1;
  460. }
  461. }
  462. return 0;
  463. }
  464.  
  465. get_num_window_destroyed() //checked partially matches cerberus output did not change
  466. {
  467. num = 0;
  468. for ( i = 0; i < level.exterior_goals.size; i++ )
  469. {
  470. if ( all_chunks_destroyed( level.exterior_goals[ i ], level.exterior_goals[ i ].barrier_chunks ) )
  471. {
  472. num += 1;
  473. }
  474. }
  475. return num;
  476. }
  477.  
  478. watch_for_drop() //checked partially matches cerberus output did not change
  479. {
  480. flag_wait( "start_zombie_round_logic" );
  481. flag_wait( "begin_spawning" );
  482. players = get_players();
  483. score_to_drop = ( players.size * level.zombie_vars[ "zombie_score_start_" + players.size + "p" ] ) + level.zombie_vars[ "zombie_powerup_drop_increment" ];
  484. while ( 1 )
  485. {
  486. flag_wait( "zombie_drop_powerups" );
  487. players = get_players();
  488. curr_total_score = 0;
  489. for ( i = 0; i < players.size; i++ )
  490. {
  491. if ( isDefined( players[ i ].score_total ) )
  492. {
  493. curr_total_score += players[ i ].score_total;
  494. }
  495. }
  496. if ( curr_total_score > score_to_drop )
  497. {
  498. level.zombie_vars[ "zombie_powerup_drop_increment" ] *= 1.14;
  499. score_to_drop = curr_total_score + level.zombie_vars[ "zombie_powerup_drop_increment" ];
  500. level.zombie_vars[ "zombie_drop_item" ] = 1;
  501. }
  502. wait 0.5;
  503. }
  504.  
  505. }
  506.  
  507. add_zombie_powerup( powerup_name, model_name, hint, func_should_drop_with_regular_powerups, solo, caution, zombie_grabbable, fx, client_field_name, time_name, on_name, clientfield_version ) //checked matches cerberus output
  508. {
  509. if ( !isDefined( clientfield_version ) )
  510. {
  511. clientfield_version = 1;
  512. }
  513. if ( isDefined( level.zombie_include_powerups ) && !isDefined( level.zombie_include_powerups[ powerup_name ] ) )
  514. {
  515. return;
  516. }
  517. precachemodel( model_name );
  518. precachestring( hint );
  519. struct = spawnstruct();
  520. if ( !isDefined( level.zombie_powerups ) )
  521. {
  522. level.zombie_powerups = [];
  523. }
  524. struct.powerup_name = powerup_name;
  525. struct.model_name = model_name;
  526. struct.weapon_classname = "script_model";
  527. struct.hint = hint;
  528. struct.func_should_drop_with_regular_powerups = func_should_drop_with_regular_powerups;
  529. struct.solo = solo;
  530. struct.caution = caution;
  531. struct.zombie_grabbable = zombie_grabbable;
  532. if ( isDefined( fx ) )
  533. {
  534. struct.fx = loadfx( fx );
  535. }
  536. level.zombie_powerups[ powerup_name ] = struct;
  537. level.zombie_powerup_array[ level.zombie_powerup_array.size ] = powerup_name;
  538. add_zombie_special_drop( powerup_name );
  539. if ( !level.createfx_enabled )
  540. {
  541. if ( isDefined( client_field_name ) )
  542. {
  543. registerclientfield( "toplayer", client_field_name, clientfield_version, 2, "int" );
  544. struct.client_field_name = client_field_name;
  545. struct.time_name = time_name;
  546. struct.on_name = on_name;
  547. }
  548. }
  549. }
  550.  
  551. powerup_set_can_pick_up_in_last_stand( powerup_name, b_can_pick_up ) //checked matches cerberus output
  552. {
  553. level.zombie_powerups[ powerup_name ].can_pick_up_in_last_stand = b_can_pick_up;
  554. }
  555.  
  556. add_zombie_special_drop( powerup_name ) //checked matches cerberus output
  557. {
  558. level.zombie_special_drop_array[ level.zombie_special_drop_array.size ] = powerup_name;
  559. }
  560.  
  561. include_zombie_powerup( powerup_name ) //checked matches cerberus output
  562. {
  563. if ( !isDefined( level.zombie_include_powerups ) )
  564. {
  565. level.zombie_include_powerups = [];
  566. }
  567. level.zombie_include_powerups[ powerup_name ] = 1;
  568. }
  569.  
  570. powerup_round_start() //checked matches cerberus output
  571. {
  572. level.powerup_drop_count = 0;
  573. }
  574.  
  575. powerup_drop( drop_point ) //modified function
  576. {
  577. if ( level.powerup_drop_count >= level.zombie_vars[ "zombie_powerup_drop_max_per_round" ] )
  578. {
  579. return;
  580. }
  581. if ( !isDefined( level.zombie_include_powerups ) || level.zombie_include_powerups.size == 0 )
  582. {
  583. return;
  584. }
  585. rand_drop = randomint( 100 );
  586. if ( rand_drop > 2 )
  587. {
  588. if ( !level.zombie_vars[ "zombie_drop_item" ] )
  589. {
  590. return;
  591. }
  592. debug = "score";
  593. }
  594. else
  595. {
  596. debug = "random";
  597. }
  598. playable_area = getentarray( "player_volume", "script_noteworthy" );
  599. level.powerup_drop_count++;
  600. powerup = maps/mp/zombies/_zm_net::network_safe_spawn( "powerup", 1, "script_model", drop_point + vectorScale( ( 0, 0, 1 ), 40 ) );
  601. valid_drop = 0;
  602. for ( i = 0; i < playable_area.size; i++ )
  603. {
  604. if ( powerup istouching( playable_area[ i ] ) )
  605. {
  606. valid_drop = 1;
  607. break;
  608. }
  609. }
  610. if ( valid_drop && level.rare_powerups_active )
  611. {
  612. pos = ( drop_point[ 0 ], drop_point[ 1 ], drop_point[ 2 ] + 42 );
  613. if ( check_for_rare_drop_override( pos ) )
  614. {
  615. level.zombie_vars[ "zombie_drop_item" ] = 0;
  616. valid_drop = 0;
  617. }
  618. }
  619. if ( !valid_drop )
  620. {
  621. level.powerup_drop_count--;
  622.  
  623. powerup delete();
  624. return;
  625. }
  626. powerup powerup_setup();
  627. print_powerup_drop( powerup.powerup_name, debug );
  628. powerup thread powerup_timeout();
  629. powerup thread powerup_wobble();
  630. powerup thread powerup_grab();
  631. powerup thread powerup_move();
  632. powerup thread powerup_emp();
  633. level.zombie_vars[ "zombie_drop_item" ] = 0;
  634. level notify( "powerup_dropped" );
  635. }
  636.  
  637. specific_powerup_drop( powerup_name, drop_spot, powerup_team, powerup_location ) //checked partially changed to match cerberus output
  638. {
  639. powerup = maps/mp/zombies/_zm_net::network_safe_spawn( "powerup", 1, "script_model", drop_spot + vectorScale( ( 0, 0, 1 ), 40 ) );
  640. level notify( "powerup_dropped" );
  641. if ( isDefined( powerup ) )
  642. {
  643. powerup powerup_setup( powerup_name, powerup_team, powerup_location );
  644. powerup thread powerup_timeout();
  645. powerup thread powerup_wobble();
  646. powerup thread powerup_grab( powerup_team );
  647. powerup thread powerup_move();
  648. powerup thread powerup_emp();
  649. return powerup;
  650. }
  651. }
  652.  
  653. quantum_bomb_random_powerup_result( position ) //changed to match cerberus output
  654. {
  655. if ( !isDefined( level.zombie_include_powerups ) || !level.zombie_include_powerups.size )
  656. {
  657. return;
  658. }
  659. keys = getarraykeys( level.zombie_include_powerups );
  660. while ( keys.size )
  661. {
  662. index = randomint( keys.size );
  663. if ( !level.zombie_powerups[ keys[ index ] ].zombie_grabbable )
  664. {
  665. skip = 0;
  666. switch( keys[ index ] )
  667. {
  668. case "bonus_points_player":
  669. case "bonus_points_team":
  670. case "random_weapon":
  671. skip = 1;
  672. break;
  673. case "fire_sale":
  674. case "full_ammo":
  675. case "insta_kill":
  676. case "minigun":
  677. if ( randomint( 4 ) )
  678. {
  679. skip = 1;
  680. }
  681. break;
  682. case "bonfire_sale":
  683. case "free_perk":
  684. case "tesla":
  685. if ( randomint( 20 ) )
  686. {
  687. skip = 1;
  688. }
  689. break;
  690. default:
  691. }
  692. if ( skip )
  693. {
  694. arrayremovevalue( keys, keys[ index ] );
  695. continue;
  696. }
  697. self thread maps/mp/zombies/_zm_audio::create_and_play_dialog( "kill", "quant_good" );
  698. [[ level.quantum_bomb_play_player_effect_at_position_func ]]( position );
  699. level specific_powerup_drop( keys[ index ], position );
  700. return;
  701. }
  702. else
  703. {
  704. arrayremovevalue( keys, keys[ index ] );
  705. }
  706. }
  707. }
  708.  
  709. quantum_bomb_random_zombie_grab_powerup_result( position ) //changed to match cerberus output
  710. {
  711. if ( !isDefined( level.zombie_include_powerups ) || !level.zombie_include_powerups.size )
  712. {
  713. return;
  714. }
  715. keys = getarraykeys( level.zombie_include_powerups );
  716. while ( keys.size )
  717. {
  718. index = randomint( keys.size );
  719. if ( level.zombie_powerups[ keys[ index ] ].zombie_grabbable )
  720. {
  721. self thread maps/mp/zombies/_zm_audio::create_and_play_dialog( "kill", "quant_bad" );
  722. [[ level.quantum_bomb_play_player_effect_at_position_func ]]( position );
  723. level specific_powerup_drop( keys[ index ], position );
  724. return;
  725. }
  726. else
  727. {
  728. arrayremovevalue( keys, keys[ index ] );
  729. }
  730. }
  731. }
  732.  
  733. quantum_bomb_random_weapon_powerup_result( position ) //checked matches cerberus output
  734. {
  735. self thread maps/mp/zombies/_zm_audio::create_and_play_dialog( "kill", "quant_good" );
  736. [[ level.quantum_bomb_play_player_effect_at_position_func ]]( position );
  737. level specific_powerup_drop( "random_weapon", position );
  738. }
  739.  
  740. quantum_bomb_random_bonus_or_lose_points_powerup_result( position ) //checked matches cerberus output
  741. {
  742. rand = randomint( 10 );
  743. powerup = "bonus_points_team";
  744. switch( rand )
  745. {
  746. case 0:
  747. case 1:
  748. powerup = "lose_points_team";
  749. if ( isDefined( level.zombie_include_powerups[ powerup ] ) )
  750. {
  751. self thread maps/mp/zombies/_zm_audio::create_and_play_dialog( "kill", "quant_bad" );
  752. break;
  753. }
  754. case 2:
  755. case 3:
  756. case 4:
  757. powerup = "bonus_points_player";
  758. if ( isDefined( level.zombie_include_powerups[ powerup ] ) )
  759. {
  760. break;
  761. }
  762. default:
  763. powerup = "bonus_points_team";
  764. break;
  765. }
  766. [[ level.quantum_bomb_play_player_effect_at_position_func ]]( position );
  767. level specific_powerup_drop( powerup, position );
  768. }
  769.  
  770. special_powerup_drop( drop_point ) //checked changed to match cerberus output
  771. {
  772. if ( !isDefined( level.zombie_include_powerups ) || level.zombie_include_powerups.size == 0 )
  773. {
  774. return;
  775. }
  776. powerup = spawn( "script_model", drop_point + vectorScale( ( 0, 0, 1 ), 40 ) );
  777. playable_area = getentarray( "player_volume", "script_noteworthy" );
  778. valid_drop = 0;
  779. for ( i = 0; i < playable_area.size; i++ )
  780. {
  781. if ( powerup istouching( playable_area[ i ] ) )
  782. {
  783. valid_drop = 1;
  784. break;
  785. }
  786. }
  787. if ( !valid_drop )
  788. {
  789. powerup delete();
  790. return;
  791. }
  792. powerup special_drop_setup();
  793. }
  794.  
  795. cleanup_random_weapon_list() //checked matches cerberus output
  796. {
  797. self waittill( "death" );
  798. arrayremovevalue( level.random_weapon_powerups, self );
  799. }
  800.  
  801. powerup_setup( powerup_override, powerup_team, powerup_location ) //checked partially changed to match cerberus output
  802. {
  803. powerup = undefined;
  804. if ( !isDefined( powerup_override ) )
  805. {
  806. powerup = get_valid_powerup();
  807. }
  808. else
  809. {
  810. powerup = powerup_override;
  811. if ( powerup == "tesla" && tesla_powerup_active() )
  812. {
  813. powerup = "minigun";
  814. }
  815. }
  816. struct = level.zombie_powerups[ powerup ];
  817. if ( powerup == "random_weapon" )
  818. {
  819. players = get_players();
  820. self.weapon = maps/mp/zombies/_zm_magicbox::treasure_chest_chooseweightedrandomweapon( players[ 0 ] );
  821. self.base_weapon = self.weapon;
  822. if ( !isDefined( level.random_weapon_powerups ) )
  823. {
  824. level.random_weapon_powerups = [];
  825. }
  826. level.random_weapon_powerups[ level.random_weapon_powerups.size ] = self;
  827. self thread cleanup_random_weapon_list();
  828. if ( isDefined( level.zombie_weapons[ self.weapon ].upgrade_name ) && !randomint( 4 ) )
  829. {
  830. self.weapon = level.zombie_weapons[ self.weapon ].upgrade_name;
  831. }
  832. self setmodel( getweaponmodel( self.weapon ) );
  833. self useweaponhidetags( self.weapon );
  834. offsetdw = vectorScale( ( 1, 1, 1 ), 3 );
  835. self.worldgundw = undefined;
  836. if ( maps/mp/zombies/_zm_magicbox::weapon_is_dual_wield( self.weapon ) )
  837. {
  838. self.worldgundw = spawn( "script_model", self.origin + offsetdw );
  839. self.worldgundw.angles = self.angles;
  840. self.worldgundw setmodel( maps/mp/zombies/_zm_magicbox::get_left_hand_weapon_model_name( self.weapon ) );
  841. self.worldgundw useweaponhidetags( self.weapon );
  842. self.worldgundw linkto( self, "tag_weapon", offsetdw, ( 0, 0, 0 ) );
  843. }
  844. }
  845. else
  846. {
  847. self setmodel( struct.model_name );
  848. }
  849. maps/mp/_demo::bookmark( "zm_powerup_dropped", getTime(), undefined, undefined, 1 );
  850. playsoundatposition( "zmb_spawn_powerup", self.origin );
  851. if ( isDefined( powerup_team ) )
  852. {
  853. self.powerup_team = powerup_team;
  854. }
  855. if ( isDefined( powerup_location ) )
  856. {
  857. self.powerup_location = powerup_location;
  858. }
  859. self.powerup_name = struct.powerup_name;
  860. self.hint = struct.hint;
  861. self.solo = struct.solo;
  862. self.caution = struct.caution;
  863. self.zombie_grabbable = struct.zombie_grabbable;
  864. self.func_should_drop_with_regular_powerups = struct.func_should_drop_with_regular_powerups;
  865. if ( isDefined( struct.fx ) )
  866. {
  867. self.fx = struct.fx;
  868. }
  869. if ( isDefined( struct.can_pick_up_in_last_stand ) )
  870. {
  871. self.can_pick_up_in_last_stand = struct.can_pick_up_in_last_stand;
  872. }
  873. self playloopsound( "zmb_spawn_powerup_loop" );
  874. level.active_powerups[ level.active_powerups.size ] = self;
  875. }
  876.  
  877. special_drop_setup() //checked matches cerberus output
  878. {
  879. powerup = undefined;
  880. is_powerup = 1;
  881. if ( level.round_number <= 10 )
  882. {
  883. powerup = get_valid_powerup();
  884. }
  885. else
  886. {
  887. powerup = level.zombie_special_drop_array[ randomint( level.zombie_special_drop_array.size ) ];
  888. if ( level.round_number > 15 && randomint( 100 ) < ( ( level.round_number - 15 ) * 5 ) )
  889. {
  890. powerup = "nothing";
  891. }
  892. }
  893. switch( powerup )
  894. {
  895. case "all_revive":
  896. case "bonfire_sale":
  897. case "bonus_points_player":
  898. case "bonus_points_team":
  899. case "carpenter":
  900. case "double_points":
  901. case "empty_clip":
  902. case "fire_sale":
  903. case "free_perk":
  904. case "insta_kill":
  905. case "lose_perk":
  906. case "lose_points_team":
  907. case "minigun":
  908. case "nuke":
  909. case "random_weapon":
  910. case "tesla":
  911. case "zombie_blood":
  912. break;
  913. case "full_ammo":
  914. if ( level.round_number > 10 && randomint( 100 ) < ( ( level.round_number - 10 ) * 5 ) )
  915. {
  916. powerup = level.zombie_powerup_array[ randomint( level.zombie_powerup_array.size ) ];
  917. }
  918. break;
  919. case "dog":
  920. if ( level.round_number >= 15 )
  921. {
  922. is_powerup = 0;
  923. dog_spawners = getentarray( "special_dog_spawner", "targetname" );
  924. thread play_sound_2d( "sam_nospawn" );
  925. }
  926. else
  927. {
  928. powerup = get_valid_powerup();
  929. }
  930. break;
  931. default:
  932. if ( isDefined( level._zombiemode_special_drop_setup ) )
  933. {
  934. is_powerup = [[ level._zombiemode_special_drop_setup ]]( powerup );
  935. }
  936. else
  937. {
  938. is_powerup = 0;
  939. playfx( level._effect[ "lightning_dog_spawn" ], self.origin );
  940. playsoundatposition( "pre_spawn", self.origin );
  941. wait 1.5;
  942. playsoundatposition( "zmb_bolt", self.origin );
  943. earthquake( 0.5, 0.75, self.origin, 1000 );
  944. playrumbleonposition( "explosion_generic", self.origin );
  945. playsoundatposition( "spawn", self.origin );
  946. wait 1;
  947. thread play_sound_2d( "sam_nospawn" );
  948. self delete();
  949. }
  950. }
  951. if ( is_powerup )
  952. {
  953. playfx( level._effect[ "lightning_dog_spawn" ], self.origin );
  954. playsoundatposition( "pre_spawn", self.origin );
  955. wait 1.5;
  956. playsoundatposition( "zmb_bolt", self.origin );
  957. earthquake( 0.5, 0.75, self.origin, 1000 );
  958. playrumbleonposition( "explosion_generic", self.origin );
  959. playsoundatposition( "spawn", self.origin );
  960. self powerup_setup( powerup );
  961. self thread powerup_timeout();
  962. self thread powerup_wobble();
  963. self thread powerup_grab();
  964. self thread powerup_move();
  965. self thread powerup_emp();
  966. }
  967. }
  968.  
  969. powerup_zombie_grab_trigger_cleanup( trigger ) //checked matches cerberus output
  970. {
  971. self waittill_any( "powerup_timedout", "powerup_grabbed", "hacked" );
  972. trigger delete();
  973. }
  974.  
  975. powerup_zombie_grab( powerup_team ) //checked changed to match cerberus output
  976. {
  977. self endon( "powerup_timedout" );
  978. self endon( "powerup_grabbed" );
  979. self endon( "hacked" );
  980. zombie_grab_trigger = spawn( "trigger_radius", self.origin - vectorScale( ( 0, 0, 1 ), 40 ), 4, 32, 72 );
  981. zombie_grab_trigger enablelinkto();
  982. zombie_grab_trigger linkto( self );
  983. zombie_grab_trigger setteamfortrigger( level.zombie_team );
  984. self thread powerup_zombie_grab_trigger_cleanup( zombie_grab_trigger );
  985. poi_dist = 300;
  986. if ( isDefined( level._zombie_grabbable_poi_distance_override ) )
  987. {
  988. poi_dist = level._zombie_grabbable_poi_distance_override;
  989. }
  990. zombie_grab_trigger create_zombie_point_of_interest( poi_dist, 2, 0, 1, undefined, undefined, powerup_team );
  991. while ( isDefined( self ) )
  992. {
  993. zombie_grab_trigger waittill( "trigger", who );
  994. if ( isDefined( level._powerup_grab_check ) )
  995. {
  996. if ( !self [[ level._powerup_grab_check ]]( who ) )
  997. {
  998. continue;
  999. }
  1000. }
  1001. else if ( !isDefined( who ) || !isai( who ) )
  1002. {
  1003. continue;
  1004. }
  1005. playfx( level._effect[ "powerup_grabbed_red" ], self.origin );
  1006. playfx( level._effect[ "powerup_grabbed_wave_red" ], self.origin );
  1007. switch( self.powerup_name )
  1008. {
  1009. case "lose_points_team":
  1010. level thread lose_points_team_powerup( self );
  1011. players = get_players();
  1012. players[ randomintrange( 0, players.size ) ] thread powerup_vo( "lose_points" );
  1013. break;
  1014. case "lose_perk":
  1015. level thread lose_perk_powerup( self );
  1016. break;
  1017. case "empty_clip":
  1018. level thread empty_clip_powerup( self );
  1019. break;
  1020. default:
  1021. if ( isDefined( level._zombiemode_powerup_zombie_grab ) )
  1022. {
  1023. level thread [[ level._zombiemode_powerup_zombie_grab ]]( self );
  1024. }
  1025. if ( isDefined( level._game_mode_powerup_zombie_grab ) )
  1026. {
  1027. level thread [[ level._game_mode_powerup_zombie_grab ]]( self, who );
  1028. }
  1029. break;
  1030. }
  1031. level thread maps/mp/zombies/_zm_audio::do_announcer_playvox( "powerup", self.powerup_name );
  1032. wait 0.1;
  1033. playsoundatposition( "zmb_powerup_grabbed", self.origin );
  1034. self stoploopsound();
  1035. self powerup_delete();
  1036. self notify( "powerup_grabbed" );
  1037. }
  1038. }
  1039.  
  1040. powerup_grab(powerup_team) //checked partially changed to match cerberus output
  1041. {
  1042. if ( isdefined( self ) && self.zombie_grabbable )
  1043. {
  1044. self thread powerup_zombie_grab( powerup_team );
  1045. return;
  1046. }
  1047.  
  1048. self endon ( "powerup_timedout" );
  1049. self endon ( "powerup_grabbed" );
  1050.  
  1051. range_squared = 4096;
  1052. while ( isdefined( self ) )
  1053. {
  1054. players = get_players();
  1055. i = 0;
  1056. while ( i < players.size )
  1057. {
  1058. if ( ( self.powerup_name == "minigun" || self.powerup_name == "tesla" ) && players[ i ] maps/mp/zombies/_zm_laststand::player_is_in_laststand() || players[ i ] maps/mp/zombies/_zm_laststand::player_is_in_laststand() && ( self.powerup_name == "random_weapon" || self.powerup_name == "meat_stink" ) || players[ i ] usebuttonpressed() && players[ i ] in_revive_trigger() )
  1059. {
  1060. i++;
  1061. continue;
  1062. }
  1063. if ( isdefined( self.can_pick_up_in_last_stand ) && !self.can_pick_up_in_last_stand && players[ i ] maps/mp/zombies/_zm_laststand::player_is_in_laststand() )
  1064. {
  1065. i++;
  1066. continue;
  1067. }
  1068. ignore_range = 0;
  1069. if ( isdefined( players[ i ].ignore_range_powerup ) && players[ i ].ignore_range_powerup == self )
  1070. {
  1071. players[ i ].ignore_range_powerup = undefined;
  1072. ignore_range = 1;
  1073. }
  1074. if ( DistanceSquared( players[ i ].origin, self.origin ) < range_squared || ignore_range )
  1075. {
  1076. if ( isdefined(level._powerup_grab_check ) )
  1077. {
  1078. if ( !self [[ level._powerup_grab_check ]]( players[ i ] ) )
  1079. {
  1080. i++;
  1081. continue;
  1082. }
  1083. }
  1084. else if ( isdefined( level.zombie_powerup_grab_func ) )
  1085. {
  1086. level thread [[ level.zombie_powerup_grab_func ]]();
  1087. break;
  1088. }
  1089. switch ( self.powerup_name )
  1090. {
  1091. case "nuke":
  1092. level thread nuke_powerup( self, players[ i ].team );
  1093. players[ i ] thread powerup_vo( "nuke" );
  1094. zombies = getaiarray( level.zombie_team );
  1095. players[ i ].zombie_nuked = arraysort( zombies, self.origin );
  1096. players[ i ] notify( "nuke_triggered" );
  1097. break;
  1098. case "full_ammo":
  1099. level thread full_ammo_powerup( self ,players[ i ] );
  1100. players[ i ] thread powerup_vo( "full_ammo" );
  1101. break;
  1102. case "double_points":
  1103. level thread double_points_powerup( self, players[ i ] );
  1104. players[ i ] thread powerup_vo( "double_points" );
  1105. break;
  1106. case "insta_kill":
  1107. level thread insta_kill_powerup( self,players[ i ] );
  1108. players[ i ] thread powerup_vo( "insta_kill" );
  1109. break;
  1110. case "carpenter":
  1111. if ( is_classic() )
  1112. {
  1113. players[ i ] thread maps/mp/zombies/_zm_pers_upgrades::persistent_carpenter_ability_check();
  1114. }
  1115. if ( isdefined( level.use_new_carpenter_func ) )
  1116. {
  1117. level thread [[ level.use_new_carpenter_func ]]( self.origin );
  1118. }
  1119. else
  1120. {
  1121. level thread start_carpenter( self.origin );
  1122. }
  1123. players[ i ] thread powerup_vo( "carpenter" );
  1124. break;
  1125. case "fire_sale":
  1126. level thread start_fire_sale( self );
  1127. players[ i ] thread powerup_vo( "firesale" );
  1128. break;
  1129. case "bonfire_sale":
  1130. level thread start_bonfire_sale( self );
  1131. players[ i ] thread powerup_vo( "firesale" );
  1132. break;
  1133. case "minigun":
  1134. level thread minigun_weapon_powerup( players[ i ] );
  1135. players[ i ] thread powerup_vo( "minigun" );
  1136. break;
  1137. case "free_perk":
  1138. level thread free_perk_powerup( self );
  1139. break;
  1140. case "tesla":
  1141. level thread tesla_weapon_powerup( players[ i ] );
  1142. players[ i ] thread powerup_vo( "tesla" );
  1143. break;
  1144. case "random_weapon":
  1145. if ( !level random_weapon_powerup( self, players[ i ] ) )
  1146. {
  1147. i++;
  1148. continue;
  1149. }
  1150. break;
  1151. case "bonus_points_player":
  1152. level thread bonus_points_player_powerup( self, players[ i ] );
  1153. players[ i ] thread powerup_vo( "bonus_points_solo" );
  1154. break;
  1155. case "bonus_points_team":
  1156. level thread bonus_points_team_powerup( self );
  1157. players[ i ] thread powerup_vo( "bonus_points_team" );
  1158. break;
  1159. case "teller_withdrawl":
  1160. level thread teller_withdrawl( self ,players[ i ] );
  1161. break;
  1162. default:
  1163. if ( IsDefined( level._zombiemode_powerup_grab ) )
  1164. {
  1165. level thread [[ level._zombiemode_powerup_grab ]]( self, players[ i ] );
  1166. }
  1167. break;
  1168. }
  1169.  
  1170. maps\mp\_demo::bookmark( "zm_player_powerup_grabbed", gettime(), players[ i ] );
  1171.  
  1172. if( should_award_stat ( self.powerup_name )) //don't do this for things that aren't really a powerup
  1173. {
  1174. //track # of picked up powerups/drops for the player
  1175. players[i] maps/mp/zombies/_zm_stats::increment_client_stat( "drops" );
  1176. players[i] maps/mp/zombies/_zm_stats::increment_player_stat( "drops" );
  1177. players[i] maps/mp/zombies/_zm_stats::increment_client_stat( self.powerup_name + "_pickedup" );
  1178. players[i] maps/mp/zombies/_zm_stats::increment_player_stat( self.powerup_name + "_pickedup" );
  1179. }
  1180.  
  1181. if ( self.solo )
  1182. {
  1183. playfx( level._effect[ "powerup_grabbed_solo" ], self.origin );
  1184. playfx( level._effect[ "powerup_grabbed_wave_solo" ], self.origin );
  1185. }
  1186. else if ( self.caution )
  1187. {
  1188. playfx( level._effect[ "powerup_grabbed_caution" ], self.origin );
  1189. playfx( level._effect[ "powerup_grabbed_wave_caution" ], self.origin );
  1190. }
  1191. else
  1192. {
  1193. playfx( level._effect[ "powerup_grabbed" ], self.origin );
  1194. playfx( level._effect[ "powerup_grabbed_wave" ], self.origin );
  1195. }
  1196.  
  1197. if ( isdefined( self.stolen ) && self.stolen )
  1198. {
  1199. level notify( "monkey_see_monkey_dont_achieved" );
  1200. }
  1201. if ( isdefined( self.grabbed_level_notify ) )
  1202. {
  1203. level notify( self.grabbed_level_notify );
  1204. }
  1205.  
  1206. self.claimed = true;
  1207. self.power_up_grab_player = players[ i ]; //Player who grabbed the power up
  1208.  
  1209. wait 0.1 ;
  1210.  
  1211. playsoundatposition("zmb_powerup_grabbed", self.origin);
  1212. self stoploopsound();
  1213. self hide();
  1214.  
  1215. if ( self.powerup_name != "fire_sale" )
  1216. {
  1217. if ( isdefined( self.power_up_grab_player ) )
  1218. {
  1219. if ( isdefined( level.powerup_intro_vox ) )
  1220. {
  1221. level thread [[ level.powerup_intro_vox ]]( self );
  1222. return;
  1223. }
  1224. else if ( isdefined( level.powerup_vo_available ) )
  1225. {
  1226. can_say_vo = [[ level.powerup_vo_available ]]();
  1227. if ( !can_say_vo )
  1228. {
  1229. self powerup_delete();
  1230. self notify( "powerup_grabbed" );
  1231. return;
  1232. }
  1233. }
  1234. }
  1235. }
  1236. level thread maps/mp/zombies/_zm_audio_announcer::leaderdialog( self.powerup_name, self.power_up_grab_player.pers[ "team" ] );
  1237. self powerup_delete();
  1238. self notify( "powerup_grabbed" );
  1239. }
  1240. i++;
  1241. }
  1242. wait 0.1;
  1243. }
  1244. }
  1245.  
  1246.  
  1247. start_fire_sale( item ) //checked matches cerberus output
  1248. {
  1249. if ( level.zombie_vars[ "zombie_powerup_fire_sale_time" ] > 0 && is_true( level.zombie_vars[ "zombie_powerup_fire_sale_on" ] ) )
  1250. {
  1251. level.zombie_vars[ "zombie_powerup_fire_sale_time" ] += 30;
  1252. return;
  1253. }
  1254. level notify( "powerup fire sale" );
  1255. level endon( "powerup fire sale" );
  1256. level thread maps/mp/zombies/_zm_audio_announcer::leaderdialog( "fire_sale" );
  1257. level.zombie_vars[ "zombie_powerup_fire_sale_on" ] = 1;
  1258. level thread toggle_fire_sale_on();
  1259. level.zombie_vars[ "zombie_powerup_fire_sale_time" ] = 30;
  1260. while ( level.zombie_vars[ "zombie_powerup_fire_sale_time" ] > 0 )
  1261. {
  1262. wait 0.05;
  1263. level.zombie_vars[ "zombie_powerup_fire_sale_time" ] -= 0.05;
  1264. }
  1265. level.zombie_vars[ "zombie_powerup_fire_sale_on" ] = 0;
  1266. level notify( "fire_sale_off" );
  1267. }
  1268.  
  1269. start_bonfire_sale( item ) //checked matches cerberus output
  1270. {
  1271. level notify( "powerup bonfire sale" );
  1272. level endon( "powerup bonfire sale" );
  1273. temp_ent = spawn( "script_origin", ( 0, 0, 0 ) );
  1274. temp_ent playloopsound( "zmb_double_point_loop" );
  1275. level.zombie_vars[ "zombie_powerup_bonfire_sale_on" ] = 1;
  1276. level thread toggle_bonfire_sale_on();
  1277. level.zombie_vars[ "zombie_powerup_bonfire_sale_time" ] = 30;
  1278. while ( level.zombie_vars[ "zombie_powerup_bonfire_sale_time" ] > 0 )
  1279. {
  1280. wait 0.05;
  1281. level.zombie_vars[ "zombie_powerup_bonfire_sale_time" ] -= 0.05;
  1282. }
  1283. level.zombie_vars[ "zombie_powerup_bonfire_sale_on" ] = 0;
  1284. level notify( "bonfire_sale_off" );
  1285. players = get_players();
  1286. i = 0;
  1287. while ( i < players.size )
  1288. {
  1289. players[ i ] playsound( "zmb_points_loop_off" );
  1290. i++;
  1291. }
  1292. temp_ent delete();
  1293. }
  1294.  
  1295. start_carpenter( origin ) //checked partially changed to match cerberus output
  1296. {
  1297. window_boards = getstructarray( "exterior_goal", "targetname" );
  1298. total = level.exterior_goals.size;
  1299. carp_ent = spawn( "script_origin", ( 0, 0, 0 ) );
  1300. carp_ent playloopsound( "evt_carpenter" );
  1301. while ( 1 )
  1302. {
  1303. windows = get_closest_window_repair( window_boards, origin );
  1304. if ( !isDefined( windows ) )
  1305. {
  1306. carp_ent stoploopsound( 1 );
  1307. carp_ent playsoundwithnotify( "evt_carpenter_end", "sound_done" );
  1308. carp_ent waittill( "sound_done" );
  1309. break;
  1310. }
  1311. else arrayremovevalue( window_boards, windows );
  1312. while ( 1 )
  1313. {
  1314. if ( all_chunks_intact( windows, windows.barrier_chunks ) )
  1315. {
  1316. break;
  1317. }
  1318. else chunk = get_random_destroyed_chunk( windows, windows.barrier_chunks );
  1319. if ( !isDefined( chunk ) )
  1320. {
  1321. break;
  1322. }
  1323. windows thread maps/mp/zombies/_zm_blockers::replace_chunk( windows, chunk, undefined, maps/mp/zombies/_zm_powerups::is_carpenter_boards_upgraded(), 1 );
  1324. if ( isDefined( windows.clip ) )
  1325. {
  1326. windows.clip enable_trigger();
  1327. windows.clip disconnectpaths();
  1328. }
  1329. else
  1330. {
  1331. blocker_disconnect_paths( windows.neg_start, windows.neg_end );
  1332. }
  1333. wait_network_frame();
  1334. wait 0.05;
  1335. }
  1336. wait_network_frame();
  1337. }
  1338. players = get_players();
  1339. i = 0;
  1340. while ( i < players.size )
  1341. {
  1342. players[ i ] maps/mp/zombies/_zm_score::player_add_points( "carpenter_powerup", 200 );
  1343. i++;
  1344. }
  1345. carp_ent delete();
  1346. }
  1347.  
  1348. get_closest_window_repair( windows, origin ) //checked partially changed to match cerberus output
  1349. {
  1350. current_window = undefined;
  1351. shortest_distance = undefined;
  1352. i = 0;
  1353. while ( i < windows.size )
  1354. {
  1355. if ( all_chunks_intact( windows, windows[ i ].barrier_chunks ) )
  1356. {
  1357. i++;
  1358. continue;
  1359. }
  1360. if ( !isDefined( current_window ) )
  1361. {
  1362. current_window = windows[ i ];
  1363. shortest_distance = distancesquared( current_window.origin, origin );
  1364. i++;
  1365. continue;
  1366. }
  1367. if ( distancesquared( windows[ i ].origin, origin ) < shortest_distance )
  1368. {
  1369. current_window = windows[ i ];
  1370. shortest_distance = distancesquared( windows[ i ].origin, origin );
  1371. }
  1372. i++;
  1373. }
  1374. return current_window;
  1375. }
  1376.  
  1377. powerup_vo( type ) //checked matches cerberus output
  1378. {
  1379. self endon( "death" );
  1380. self endon( "disconnect" );
  1381. if ( isDefined( level.powerup_vo_available ) )
  1382. {
  1383. if ( ![[ level.powerup_vo_available ]]() )
  1384. {
  1385. return;
  1386. }
  1387. }
  1388. wait randomfloatrange( 2, 2.5 );
  1389. if ( type == "tesla" )
  1390. {
  1391. self maps/mp/zombies/_zm_audio::create_and_play_dialog( "weapon_pickup", type );
  1392. }
  1393. else
  1394. {
  1395. self maps/mp/zombies/_zm_audio::create_and_play_dialog( "powerup", type );
  1396. }
  1397. if ( isDefined( level.custom_powerup_vo_response ) )
  1398. {
  1399. level [[ level.custom_powerup_vo_response ]]( self, type );
  1400. }
  1401. }
  1402.  
  1403. powerup_wobble_fx() //checked matches cerberus output
  1404. {
  1405. self endon( "death" );
  1406. if ( !isDefined( self ) )
  1407. {
  1408. return;
  1409. }
  1410. if ( isDefined( level.powerup_fx_func ) )
  1411. {
  1412. self thread [[ level.powerup_fx_func ]]();
  1413. return;
  1414. }
  1415. if ( self.solo )
  1416. {
  1417. self setclientfield( "powerup_fx", 2 );
  1418. }
  1419. else if ( self.caution )
  1420. {
  1421. self setclientfield( "powerup_fx", 4 );
  1422. }
  1423. else if ( self.zombie_grabbable )
  1424. {
  1425. self setclientfield( "powerup_fx", 3 );
  1426. }
  1427. else
  1428. {
  1429. self setclientfield( "powerup_fx", 1 );
  1430. }
  1431. }
  1432.  
  1433. powerup_wobble() //checked matches cerberus output
  1434. {
  1435. self endon( "powerup_grabbed" );
  1436. self endon( "powerup_timedout" );
  1437. self thread powerup_wobble_fx();
  1438. while ( isDefined( self ) )
  1439. {
  1440. waittime = randomfloatrange( 2.5, 5 );
  1441. yaw = randomint( 360 );
  1442. if ( yaw > 300 )
  1443. {
  1444. yaw = 300;
  1445. }
  1446. else
  1447. {
  1448. if ( yaw < 60 )
  1449. {
  1450. yaw = 60;
  1451. }
  1452. }
  1453. yaw = self.angles[ 1 ] + yaw;
  1454. new_angles = ( -60 + randomint( 120 ), yaw, -45 + randomint( 90 ) );
  1455. self rotateto( new_angles, waittime, waittime * 0.5, waittime * 0.5 );
  1456. if ( isDefined( self.worldgundw ) )
  1457. {
  1458. self.worldgundw rotateto( new_angles, waittime, waittime * 0.5, waittime * 0.5 );
  1459. }
  1460. wait randomfloat( waittime - 0.1 );
  1461. }
  1462. }
  1463.  
  1464. powerup_timeout() //checked partially changed to match cerberus output
  1465. {
  1466. if ( isDefined( level._powerup_timeout_override ) && !isDefined( self.powerup_team ) )
  1467. {
  1468. self thread [[ level._powerup_timeout_override ]]();
  1469. return;
  1470. }
  1471. self endon( "powerup_grabbed" );
  1472. self endon( "death" );
  1473. self endon( "powerup_reset" );
  1474. self show();
  1475. wait_time = 15;
  1476. if ( isDefined( level._powerup_timeout_custom_time ) )
  1477. {
  1478. time = [[ level._powerup_timeout_custom_time ]]( self );
  1479. if ( time == 0 )
  1480. {
  1481. return;
  1482. }
  1483. wait_time = time;
  1484. }
  1485. wait wait_time;
  1486. i = 0;
  1487. while ( i < 40 )
  1488. {
  1489. if ( i % 2 )
  1490. {
  1491. self ghost();
  1492. if ( isDefined( self.worldgundw ) )
  1493. {
  1494. self.worldgundw ghost();
  1495. }
  1496. }
  1497. else
  1498. {
  1499. self show();
  1500. if ( isDefined( self.worldgundw ) )
  1501. {
  1502. self.worldgundw show();
  1503. }
  1504. }
  1505. if ( i < 15 )
  1506. {
  1507. wait 0.5;
  1508. i++;
  1509. continue;
  1510. }
  1511. else if ( i < 25 )
  1512. {
  1513. wait 0.25;
  1514. i++;
  1515. continue;
  1516. }
  1517. wait 0.1;
  1518. i++;
  1519. }
  1520. self notify( "powerup_timedout" );
  1521. self powerup_delete();
  1522. }
  1523.  
  1524. powerup_delete() //checked matches cerberus output
  1525. {
  1526. arrayremovevalue( level.active_powerups, self, 0 );
  1527. if ( isDefined( self.worldgundw ) )
  1528. {
  1529. self.worldgundw delete();
  1530. }
  1531. self delete();
  1532. }
  1533.  
  1534. powerup_delete_delayed( time ) //checked matches cerberus output
  1535. {
  1536. if ( isDefined( time ) )
  1537. {
  1538. wait time;
  1539. }
  1540. else
  1541. {
  1542. wait 0.01;
  1543. }
  1544. self powerup_delete();
  1545. }
  1546.  
  1547. nuke_powerup( drop_item, player_team ) //checked changed to match cerberus output
  1548. {
  1549. location = drop_item.origin;
  1550. playfx( drop_item.fx, location );
  1551. level thread nuke_flash( player_team );
  1552. wait 0.5;
  1553. zombies = getaiarray( level.zombie_team );
  1554. zombies = arraysort( zombies, location );
  1555. zombies_nuked = [];
  1556. i = 0;
  1557. while ( i < zombies.size )
  1558. {
  1559. if ( isdefined( zombies[ i ].ignore_nuke ) && zombies[ i ].ignore_nuke )
  1560. {
  1561. i++;
  1562. continue;
  1563. }
  1564. if ( isdefined( zombies[ i ].marked_for_death ) && zombies[ i ].marked_for_death )
  1565. {
  1566. i++;
  1567. continue;
  1568. }
  1569. if ( isdefined( zombies[ i ].nuke_damage_func ) )
  1570. {
  1571. zombies[ i ] thread [[ zombies[ i ].nuke_damage_func ]]();
  1572. i++;
  1573. continue;
  1574. }
  1575. if ( is_magic_bullet_shield_enabled( zombies[ i ] ) )
  1576. {
  1577. i++;
  1578. continue;
  1579. }
  1580. zombies[ i ].marked_for_death = 1;
  1581. //imported from bo3 _zm_powerup_nuke.gsc
  1582. if ( !zombies[ i ].nuked && !is_magic_bullet_shield_enabled( zombies[ i ] ) )
  1583. {
  1584. zombies[ i ].nuked = 1;
  1585. zombies_nuked[ zombies_nuked.size ] = zombies[ i ];
  1586. }
  1587. i++;
  1588. }
  1589. i = 0;
  1590. while ( i < zombies_nuked.size )
  1591. {
  1592. wait randomfloatrange( 0.1, 0.7 );
  1593. if ( !isdefined( zombies_nuked[ i ] ) )
  1594. {
  1595. i++;
  1596. continue;
  1597. }
  1598. if ( is_magic_bullet_shield_enabled( zombies_nuked[ i ] ) )
  1599. {
  1600. i++;
  1601. continue;
  1602. }
  1603. if ( i < 5 && !zombies_nuked[ i ].isdog )
  1604. {
  1605. zombies_nuked[ i ] thread maps/mp/animscripts/zm_death::flame_death_fx();
  1606. }
  1607. if ( !zombies_nuked[ i ].isdog )
  1608. {
  1609. if ( isdefined( zombies_nuked[ i ].no_gib ) && !zombies_nuked[ i ].no_gib )
  1610. {
  1611. zombies_nuked[ i ] maps/mp/zombies/_zm_spawner::zombie_head_gib();
  1612. }
  1613. zombies_nuked[ i ] playsound("evt_nuked");
  1614. }
  1615. zombies_nuked[ i ] dodamage(zombies_nuked[i].health + 666, zombies_nuked[ i ].origin );
  1616. i++;
  1617. }
  1618. players = get_players( player_team );
  1619. for ( i = 0; i < players.size; i++ )
  1620. {
  1621. players[ i ] maps/mp/zombies/_zm_score::player_add_points( "nuke_powerup", 400 );
  1622. }
  1623. }
  1624.  
  1625. nuke_flash( team ) //checked matches cerberus output
  1626. {
  1627. if ( isDefined( team ) )
  1628. {
  1629. get_players()[ 0 ] playsoundtoteam( "evt_nuke_flash", team );
  1630. }
  1631. else
  1632. {
  1633. get_players()[ 0 ] playsound( "evt_nuke_flash" );
  1634. }
  1635. fadetowhite = newhudelem();
  1636. fadetowhite.x = 0;
  1637. fadetowhite.y = 0;
  1638. fadetowhite.alpha = 0;
  1639. fadetowhite.horzalign = "fullscreen";
  1640. fadetowhite.vertalign = "fullscreen";
  1641. fadetowhite.foreground = 1;
  1642. fadetowhite setshader( "white", 640, 480 );
  1643. fadetowhite fadeovertime( 0.2 );
  1644. fadetowhite.alpha = 0.8;
  1645. wait 0.5;
  1646. fadetowhite fadeovertime( 1 );
  1647. fadetowhite.alpha = 0;
  1648. wait 1.1;
  1649. fadetowhite destroy();
  1650. }
  1651.  
  1652. double_points_powerup( drop_item, player ) //checked partially matches cerberus output did not change
  1653. {
  1654. level notify( "powerup points scaled_" + player.team );
  1655. level endon( "powerup points scaled_" + player.team );
  1656. team = player.team;
  1657. level thread point_doubler_on_hud( drop_item, team );
  1658. if ( isDefined( level.pers_upgrade_double_points ) && level.pers_upgrade_double_points )
  1659. {
  1660. player thread maps/mp/zombies/_zm_pers_upgrades_functions::pers_upgrade_double_points_pickup_start();
  1661. }
  1662. if ( isDefined( level.current_game_module ) && level.current_game_module == 2 )
  1663. {
  1664. if ( isDefined( player._race_team ) )
  1665. {
  1666. if ( player._race_team == 1 )
  1667. {
  1668. level._race_team_double_points = 1;
  1669. }
  1670. else
  1671. {
  1672. level._race_team_double_points = 2;
  1673. }
  1674. }
  1675. }
  1676. level.zombie_vars[ team ][ "zombie_point_scalar" ] = 2;
  1677. players = get_players();
  1678. for ( player_index = 0; player_index < players.size; player_index++ )
  1679. {
  1680. if ( team == players[ player_index ].team )
  1681. {
  1682. players[ player_index ] setclientfield( "score_cf_double_points_active", 1 );
  1683. }
  1684. }
  1685. wait 30;
  1686. level.zombie_vars[ team ][ "zombie_point_scalar" ] = 1;
  1687. level._race_team_double_points = undefined;
  1688. players = get_players();
  1689. for ( player_index = 0; player_index < players.size; player_index++ )
  1690. {
  1691. if ( team == players[ player_index ].team )
  1692. {
  1693. players[ player_index ] setclientfield( "score_cf_double_points_active", 0 );
  1694. }
  1695. }
  1696. }
  1697.  
  1698. full_ammo_powerup( drop_item, player ) //checked changed to match cerberus output
  1699. {
  1700. players = get_players( player.team );
  1701. if ( isdefined( level._get_game_module_players ) )
  1702. {
  1703. players = [[ level._get_game_module_players ]]( player );
  1704. }
  1705. i = 0;
  1706. while ( i < players.size )
  1707. {
  1708. if ( players[ i ] maps/mp/zombies/_zm_laststand::player_is_in_laststand() )
  1709. {
  1710. i++;
  1711. continue;
  1712. }
  1713. primary_weapons = players[ i ] getweaponslist( 1 );
  1714. players[ i ] notify( "zmb_max_ammo" );
  1715. players[ i ] notify( "zmb_lost_knife" );
  1716. players[ i ] notify( "zmb_disable_claymore_prompt" );
  1717. players[ i ] notify( "zmb_disable_spikemore_prompt" );
  1718. x = 0;
  1719. while ( x < primary_weapons.size )
  1720. {
  1721. if ( level.headshots_only && is_lethal_grenade(primary_weapons[ x ] ) )
  1722. {
  1723. x++;
  1724. continue;
  1725. }
  1726. if ( isdefined( level.zombie_include_equipment ) && isdefined( level.zombie_include_equipment[ primary_weapons[ x ] ] ) )
  1727. {
  1728. x++;
  1729. continue;
  1730. }
  1731. if ( isdefined( level.zombie_weapons_no_max_ammo ) && isdefined( level.zombie_weapons_no_max_ammo[ primary_weapons[ x ] ] ) )
  1732. {
  1733. x++;
  1734. continue;
  1735. }
  1736. if ( players[ i ] hasweapon( primary_weapons[ x ] ) )
  1737. {
  1738. players[ i ] givemaxammo( primary_weapons[ x ] );
  1739. }
  1740. x++;
  1741. }
  1742. i++;
  1743. }
  1744. level thread full_ammo_on_hud( drop_item, player.team );
  1745. }
  1746.  
  1747. insta_kill_powerup( drop_item, player ) //checked matches cerberus output
  1748. {
  1749. level notify( "powerup instakill_" + player.team );
  1750. level endon( "powerup instakill_" + player.team );
  1751. if ( isDefined( level.insta_kill_powerup_override ) )
  1752. {
  1753. level thread [[ level.insta_kill_powerup_override ]]( drop_item, player );
  1754. return;
  1755. }
  1756. if ( is_classic() )
  1757. {
  1758. player thread maps/mp/zombies/_zm_pers_upgrades_functions::pers_upgrade_insta_kill_upgrade_check();
  1759. }
  1760. team = player.team;
  1761. level thread insta_kill_on_hud( drop_item, team );
  1762. level.zombie_vars[ team ][ "zombie_insta_kill" ] = 1;
  1763. wait 30;
  1764. level.zombie_vars[ team ][ "zombie_insta_kill" ] = 0;
  1765. players = get_players( team );
  1766. i = 0;
  1767. while ( i < players.size )
  1768. {
  1769. if ( isDefined( players[ i ] ) )
  1770. {
  1771. players[ i ] notify( "insta_kill_over" );
  1772. }
  1773. i++;
  1774. }
  1775. }
  1776.  
  1777. is_insta_kill_active() //checked matches cerberus output
  1778. {
  1779. return level.zombie_vars[ self.team ][ "zombie_insta_kill" ];
  1780. }
  1781.  
  1782. check_for_instakill( player, mod, hit_location ) //checked changed to match cerberus output
  1783. {
  1784. if ( isDefined( player ) && isalive( player ) && isDefined( level.check_for_instakill_override ) )
  1785. {
  1786. if ( !self [[ level.check_for_instakill_override ]]( player ) )
  1787. {
  1788. return;
  1789. }
  1790. if ( player.use_weapon_type == "MOD_MELEE" )
  1791. {
  1792. player.last_kill_method = "MOD_MELEE";
  1793. }
  1794. else
  1795. {
  1796. player.last_kill_method = "MOD_UNKNOWN";
  1797. }
  1798. modname = remove_mod_from_methodofdeath( mod );
  1799. if ( isDefined( self.no_gib ) && self.no_gib )
  1800. {
  1801. self maps/mp/zombies/_zm_spawner::zombie_head_gib();
  1802. }
  1803. self.health = 1;
  1804. self dodamage( self.health + 666, self.origin, player, self, hit_location, modname );
  1805. player notify( "zombie_killed" );
  1806. }
  1807. if ( isDefined( player ) && isalive( player ) && level.zombie_vars[ player.team ][ "zombie_insta_kill" ] || isDefined( player.personal_instakill ) && player.personal_instakill )
  1808. {
  1809. if ( is_magic_bullet_shield_enabled( self ) )
  1810. {
  1811. return;
  1812. }
  1813. if ( isDefined( self.instakill_func ) )
  1814. {
  1815. self thread [[ self.instakill_func ]]();
  1816. return;
  1817. }
  1818. if ( player.use_weapon_type == "MOD_MELEE" )
  1819. {
  1820. player.last_kill_method = "MOD_MELEE";
  1821. }
  1822. else
  1823. {
  1824. player.last_kill_method = "MOD_UNKNOWN";
  1825. }
  1826. modname = remove_mod_from_methodofdeath( mod );
  1827. if ( flag( "dog_round" ) )
  1828. {
  1829. self.health = 1;
  1830. self dodamage( self.health + 666, self.origin, player, self, hit_location, modname );
  1831. player notify( "zombie_killed" );
  1832. }
  1833. else if ( isdefined( self.no_gib ) && !self.no_gib )
  1834. {
  1835. self maps/mp/zombies/_zm_spawner::zombie_head_gib();
  1836. }
  1837. self.health = 1;
  1838. self dodamage( self.health + 666, self.origin, player, self, hit_location, modname );
  1839. player notify( "zombie_killed" );
  1840. }
  1841. }
  1842.  
  1843. insta_kill_on_hud( drop_item, player_team ) //checked matches cerberus output
  1844. {
  1845. if ( level.zombie_vars[ player_team ][ "zombie_powerup_insta_kill_on" ] )
  1846. {
  1847. level.zombie_vars[ player_team ][ "zombie_powerup_insta_kill_time" ] = 30;
  1848. return;
  1849. }
  1850. level.zombie_vars[ player_team ][ "zombie_powerup_insta_kill_on" ] = 1;
  1851. level thread time_remaning_on_insta_kill_powerup( player_team );
  1852. }
  1853.  
  1854. time_remaning_on_insta_kill_powerup( player_team ) //checked matches cerberus output
  1855. {
  1856. temp_enta = spawn( "script_origin", ( 0, 0, 0 ) );
  1857. temp_enta playloopsound( "zmb_insta_kill_loop" );
  1858. while ( level.zombie_vars[ player_team ][ "zombie_powerup_insta_kill_time" ] >= 0 )
  1859. {
  1860. wait 0.05;
  1861. level.zombie_vars[ player_team ][ "zombie_powerup_insta_kill_time" ] -= 0.05;
  1862. }
  1863. get_players()[ 0 ] playsoundtoteam( "zmb_insta_kill", player_team );
  1864. temp_enta stoploopsound( 2 );
  1865. level.zombie_vars[ player_team ][ "zombie_powerup_insta_kill_on" ] = 0;
  1866. level.zombie_vars[ player_team ][ "zombie_powerup_insta_kill_time" ] = 30;
  1867. temp_enta delete();
  1868. }
  1869.  
  1870. point_doubler_on_hud( drop_item, player_team ) //checked matches cerberus output
  1871. {
  1872. self endon( "disconnect" );
  1873. if ( level.zombie_vars[ player_team ][ "zombie_powerup_point_doubler_on" ] )
  1874. {
  1875. level.zombie_vars[ player_team ][ "zombie_powerup_point_doubler_time" ] = 30;
  1876. return;
  1877. }
  1878. level.zombie_vars[ player_team ][ "zombie_powerup_point_doubler_on" ] = 1;
  1879. level thread time_remaining_on_point_doubler_powerup( player_team );
  1880. }
  1881.  
  1882. time_remaining_on_point_doubler_powerup( player_team ) //checked partially matches cerberus output did not change
  1883. {
  1884. temp_ent = spawn( "script_origin", ( 0, 0, 0 ) );
  1885. temp_ent playloopsound( "zmb_double_point_loop" );
  1886. while ( level.zombie_vars[ player_team ][ "zombie_powerup_point_doubler_time" ] >= 0 )
  1887. {
  1888. wait 0.05;
  1889. level.zombie_vars[ player_team ][ "zombie_powerup_point_doubler_time" ] -= 0.05;
  1890. }
  1891. level.zombie_vars[ player_team ][ "zombie_powerup_point_doubler_on" ] = 0;
  1892. players = get_players( player_team );
  1893. for ( i = 0; i < players.size; i++ )
  1894. {
  1895. players[ i ] playsound( "zmb_points_loop_off" );
  1896. }
  1897. temp_ent stoploopsound( 2 );
  1898. level.zombie_vars[ player_team ][ "zombie_powerup_point_doubler_time" ] = 30;
  1899. temp_ent delete();
  1900. }
  1901.  
  1902. toggle_bonfire_sale_on() //checked matches cerberus output
  1903. {
  1904. level endon( "powerup bonfire sale" );
  1905. if ( !isDefined( level.zombie_vars[ "zombie_powerup_bonfire_sale_on" ] ) )
  1906. {
  1907. return;
  1908. }
  1909. if ( level.zombie_vars[ "zombie_powerup_bonfire_sale_on" ] )
  1910. {
  1911. if ( isDefined( level.bonfire_init_func ) )
  1912. {
  1913. level thread [[ level.bonfire_init_func ]]();
  1914. }
  1915. level waittill( "bonfire_sale_off" );
  1916. }
  1917. }
  1918.  
  1919. toggle_fire_sale_on() //checked partially matches cerberus output did not change
  1920. {
  1921. level endon( "powerup fire sale" );
  1922. if ( !isDefined( level.zombie_vars[ "zombie_powerup_fire_sale_on" ] ) )
  1923. {
  1924. return;
  1925. }
  1926. while ( level.zombie_vars[ "zombie_powerup_fire_sale_on" ] )
  1927. {
  1928. for ( i = 0; i < level.chests.size; i++ )
  1929. {
  1930. show_firesale_box = level.chests[ i ] [[ level._zombiemode_check_firesale_loc_valid_func ]]();
  1931. if ( show_firesale_box )
  1932. {
  1933. level.chests[ i ].zombie_cost = 10;
  1934. if ( level.chest_index != i )
  1935. {
  1936. level.chests[ i ].was_temp = 1;
  1937. if ( is_true( level.chests[ i ].hidden ) )
  1938. {
  1939. level.chests[ i ] thread maps/mp/zombies/_zm_magicbox::show_chest();
  1940. }
  1941. wait_network_frame();
  1942. }
  1943. }
  1944. }
  1945. level waittill( "fire_sale_off" );
  1946. waittillframeend;
  1947. for ( i = 0; i < level.chests.size; i++ )
  1948. {
  1949. show_firesale_box = level.chests[ i ] [[ level._zombiemode_check_firesale_loc_valid_func ]]();
  1950. if ( show_firesale_box )
  1951. {
  1952. if ( level.chest_index != i && isDefined( level.chests[ i ].was_temp ) )
  1953. {
  1954. level.chests[ i ].was_temp = undefined;
  1955. level thread remove_temp_chest( i );
  1956. }
  1957. level.chests[ i ].zombie_cost = level.chests[ i ].old_cost;
  1958. }
  1959. }
  1960. }
  1961. }
  1962.  
  1963. fire_sale_weapon_wait() //checked matches cerberus output
  1964. {
  1965. self.zombie_cost = self.old_cost;
  1966. while ( isDefined( self.chest_user ) )
  1967. {
  1968. wait_network_frame();
  1969. }
  1970. self set_hint_string( self, "default_treasure_chest", self.zombie_cost );
  1971. }
  1972.  
  1973. remove_temp_chest( chest_index ) //checked partially matches cerberus output did not change
  1974. {
  1975. while ( isDefined( level.chests[ chest_index ].chest_user ) || isDefined( level.chests[ chest_index ]._box_open ) && level.chests[ chest_index ]._box_open == 1 )
  1976. {
  1977. wait_network_frame();
  1978. }
  1979. if ( level.zombie_vars[ "zombie_powerup_fire_sale_on" ] )
  1980. {
  1981. level.chests[ chest_index ].was_temp = 1;
  1982. level.chests[ chest_index ].zombie_cost = 10;
  1983. return;
  1984. }
  1985. for ( i = 0; i < chest_index; i++ )
  1986. {
  1987. wait_network_frame();
  1988. }
  1989. playfx( level._effect[ "poltergeist" ], level.chests[ chest_index ].orig_origin );
  1990. level.chests[ chest_index ].zbarrier playsound( "zmb_box_poof_land" );
  1991. level.chests[ chest_index ].zbarrier playsound( "zmb_couch_slam" );
  1992. wait_network_frame();
  1993. level.chests[ chest_index ] maps/mp/zombies/_zm_magicbox::hide_chest();
  1994. }
  1995.  
  1996. devil_dialog_delay() //checked matches cerberus output
  1997. {
  1998. wait 1;
  1999. }
  2000.  
  2001. full_ammo_on_hud( drop_item, player_team ) //checked matches cerberus output
  2002. {
  2003. self endon( "disconnect" );
  2004. hudelem = maps/mp/gametypes_zm/_hud_util::createserverfontstring( "objective", 2, player_team );
  2005. hudelem maps/mp/gametypes_zm/_hud_util::setpoint( "TOP", undefined, 0, level.zombie_vars[ "zombie_timer_offset" ] - ( level.zombie_vars[ "zombie_timer_offset_interval" ] * 2 ) );
  2006. hudelem.sort = 0.5;
  2007. hudelem.alpha = 0;
  2008. hudelem fadeovertime( 0.5 );
  2009. hudelem.alpha = 1;
  2010. if ( isDefined( drop_item ) )
  2011. {
  2012. hudelem.label = drop_item.hint;
  2013. }
  2014. hudelem thread full_ammo_move_hud( player_team );
  2015. }
  2016.  
  2017. full_ammo_move_hud( player_team ) //checked matches cerberus output
  2018. {
  2019. players = get_players( player_team );
  2020. players[ 0 ] playsoundtoteam( "zmb_full_ammo", player_team );
  2021. wait 0.5;
  2022. move_fade_time = 1.5;
  2023. self fadeovertime( move_fade_time );
  2024. self moveovertime( move_fade_time );
  2025. self.y = 270;
  2026. self.alpha = 0;
  2027. wait move_fade_time;
  2028. self destroy();
  2029. }
  2030.  
  2031. check_for_rare_drop_override( pos ) //checked matches cerberus output
  2032. {
  2033. if ( isDefined( flag( "ape_round" ) ) && flag( "ape_round" ) )
  2034. {
  2035. return 0;
  2036. }
  2037. return 0;
  2038. }
  2039.  
  2040. setup_firesale_audio() //checked changed to match cerberus output
  2041. {
  2042. wait 2;
  2043. intercom = getentarray( "intercom", "targetname" );
  2044. while ( 1 )
  2045. {
  2046. while ( level.zombie_vars[ "zombie_powerup_fire_sale_on" ] == 0 )
  2047. {
  2048. wait 0.2;
  2049. }
  2050. for ( i = 0; i < intercom.size; i++ )
  2051. {
  2052. intercom [i ] thread play_firesale_audio();
  2053. }
  2054. while ( level.zombie_vars[ "zombie_powerup_fire_sale_on" ] == 1 )
  2055. {
  2056. wait 0.1;
  2057. }
  2058. level notify( "firesale_over" );
  2059. }
  2060. }
  2061.  
  2062. play_firesale_audio() //checked matches cerberus output
  2063. {
  2064. if ( isDefined( level.sndfiresalemusoff ) && level.sndfiresalemusoff )
  2065. {
  2066. return;
  2067. }
  2068. if ( isDefined( level.sndannouncerisrich ) && level.sndannouncerisrich )
  2069. {
  2070. self playloopsound( "mus_fire_sale_rich" );
  2071. }
  2072. else
  2073. {
  2074. self playloopsound( "mus_fire_sale" );
  2075. }
  2076. level waittill( "firesale_over" );
  2077. self stoploopsound();
  2078. }
  2079.  
  2080. setup_bonfiresale_audio() //checked changed to match cerberus output
  2081. {
  2082. wait 2;
  2083. intercom = getentarray( "intercom", "targetname" );
  2084. while ( 1 )
  2085. {
  2086. while ( level.zombie_vars[ "zombie_powerup_fire_sale_on" ] == 0 )
  2087. {
  2088. wait 0.2;
  2089. }
  2090. for ( i = 0; i < intercom.size; i++ )
  2091. {
  2092. intercom[ i ] thread play_bonfiresale_audio();
  2093. }
  2094. while ( level.zombie_vars[ "zombie_powerup_fire_sale_on" ] == 1 )
  2095. {
  2096. wait 0.1;
  2097. }
  2098. level notify( "firesale_over" );
  2099. }
  2100. }
  2101.  
  2102. play_bonfiresale_audio() //checked matches cerberus output
  2103. {
  2104. if ( isDefined( level.sndfiresalemusoff ) && level.sndfiresalemusoff )
  2105. {
  2106. return;
  2107. }
  2108. if ( isDefined( level.sndannouncerisrich ) && level.sndannouncerisrich )
  2109. {
  2110. self playloopsound( "mus_fire_sale_rich" );
  2111. }
  2112. else
  2113. {
  2114. self playloopsound( "mus_fire_sale" );
  2115. }
  2116. level waittill( "firesale_over" );
  2117. self stoploopsound();
  2118. }
  2119.  
  2120. free_perk_powerup( item ) //checked changed to match cerberus output
  2121. {
  2122. players = get_players();
  2123. for ( i = 0; i < players.size; i++ )
  2124. {
  2125. if ( !players[ i ] maps/mp/zombies/_zm_laststand::player_is_in_laststand() && players[ i ].sessionstate != "spectator" )
  2126. {
  2127. player = players[ i ];
  2128. if ( isDefined( item.ghost_powerup ) )
  2129. {
  2130. player maps/mp/zombies/_zm_stats::increment_client_stat( "buried_ghost_perk_acquired", 0 );
  2131. player maps/mp/zombies/_zm_stats::increment_player_stat( "buried_ghost_perk_acquired" );
  2132. player notify( "player_received_ghost_round_free_perk" );
  2133. }
  2134. free_perk = player maps/mp/zombies/_zm_perks::give_random_perk();
  2135. if ( isDefined( level.disable_free_perks_before_power ) && level.disable_free_perks_before_power )
  2136. {
  2137. player thread disable_perk_before_power( free_perk );
  2138. }
  2139. }
  2140. }
  2141. }
  2142.  
  2143. disable_perk_before_power( perk ) //checked matches cerberus output
  2144. {
  2145. self endon( "disconnect" );
  2146. if ( isDefined( perk ) )
  2147. {
  2148. wait 0.1;
  2149. if ( !flag( "power_on" ) )
  2150. {
  2151. a_players = get_players();
  2152. if ( isDefined( a_players ) && a_players.size == 1 && perk == "specialty_quickrevive" )
  2153. {
  2154. return;
  2155. }
  2156. self perk_pause( perk );
  2157. flag_wait( "power_on" );
  2158. self perk_unpause( perk );
  2159. }
  2160. }
  2161. }
  2162.  
  2163. random_weapon_powerup_throttle() //checked matches cerberus output
  2164. {
  2165. self.random_weapon_powerup_throttle = 1;
  2166. wait 0.25;
  2167. self.random_weapon_powerup_throttle = 0;
  2168. }
  2169.  
  2170. random_weapon_powerup( item, player ) //checked partially matches cerberus output did not change
  2171. {
  2172. if ( player.sessionstate == "spectator" || player maps/mp/zombies/_zm_laststand::player_is_in_laststand() )
  2173. {
  2174. return 0;
  2175. }
  2176. if ( isDefined( player.random_weapon_powerup_throttle ) && !player.random_weapon_powerup_throttle || player isswitchingweapons() && player.is_drinking > 0 )
  2177. {
  2178. return 0;
  2179. }
  2180. current_weapon = player getcurrentweapon();
  2181. current_weapon_type = weaponinventorytype( current_weapon );
  2182. if ( !is_tactical_grenade( item.weapon ) )
  2183. {
  2184. if ( current_weapon_type != "primary" && current_weapon_type != "altmode" )
  2185. {
  2186. return 0;
  2187. }
  2188. if ( !isDefined( level.zombie_weapons[ current_weapon ] ) && !maps/mp/zombies/_zm_weapons::is_weapon_upgraded( current_weapon ) && current_weapon_type != "altmode" )
  2189. {
  2190. return 0;
  2191. }
  2192. }
  2193. player thread random_weapon_powerup_throttle();
  2194. weapon_string = item.weapon;
  2195. if ( weapon_string == "knife_ballistic_zm" )
  2196. {
  2197. weapon = player maps/mp/zombies/_zm_melee_weapon::give_ballistic_knife( weapon_string, 0 );
  2198. }
  2199. else
  2200. {
  2201. if ( weapon_string == "knife_ballistic_upgraded_zm" )
  2202. {
  2203. weapon = player maps/mp/zombies/_zm_melee_weapon::give_ballistic_knife( weapon_string, 1 );
  2204. }
  2205. }
  2206. player thread maps/mp/zombies/_zm_weapons::weapon_give( weapon_string );
  2207. return 1;
  2208. }
  2209.  
  2210. bonus_points_player_powerup( item, player ) //checked matches cerberus output
  2211. {
  2212. points = randomintrange( 1, 25 ) * 100;
  2213. if ( isDefined( level.bonus_points_powerup_override ) )
  2214. {
  2215. points = [[ level.bonus_points_powerup_override ]]();
  2216. }
  2217. if ( !player maps/mp/zombies/_zm_laststand::player_is_in_laststand() && player.sessionstate != "spectator" )
  2218. {
  2219. player maps/mp/zombies/_zm_score::player_add_points( "bonus_points_powerup", points );
  2220. }
  2221. }
  2222.  
  2223. bonus_points_team_powerup( item ) //checked changed to match cerberus output
  2224. {
  2225. points = randomintrange( 1, 25 ) * 100;
  2226. if ( isDefined( level.bonus_points_powerup_override ) )
  2227. {
  2228. points = [[ level.bonus_points_powerup_override ]]();
  2229. }
  2230. players = get_players();
  2231. for ( i = 0; i < players.size; i++ )
  2232. {
  2233. if ( !players[ i ] maps/mp/zombies/_zm_laststand::player_is_in_laststand() && players[ i ].sessionstate != "spectator" )
  2234. {
  2235. players[ i ] maps/mp/zombies/_zm_score::player_add_points( "bonus_points_powerup", points );
  2236. }
  2237. }
  2238. }
  2239.  
  2240. lose_points_team_powerup( item ) //checked partially changed to match cerberus output
  2241. {
  2242. points = randomintrange( 1, 25 ) * 100;
  2243. players = get_players();
  2244. i = 0;
  2245. while ( i < players.size )
  2246. {
  2247. if ( !players[ i ] maps/mp/zombies/_zm_laststand::player_is_in_laststand() && players[ i ].sessionstate != "spectator" )
  2248. {
  2249. if ( ( players[ i ].score - points ) <= 0 )
  2250. {
  2251. players[ i ] maps/mp/zombies/_zm_score::minus_to_player_score( players[ i ].score );
  2252. i++;
  2253. continue;
  2254. }
  2255. else
  2256. {
  2257. players[ i ] maps/mp/zombies/_zm_score::minus_to_player_score( points );
  2258. }
  2259. }
  2260. i++;
  2261. }
  2262. }
  2263.  
  2264. lose_perk_powerup( item ) //checked partially matches cerberus output
  2265. {
  2266. players = get_players();
  2267. for ( i = 0; i < players.size; i++ )
  2268. {
  2269. player = players[ i ];
  2270. if ( !player maps/mp/zombies/_zm_laststand::player_is_in_laststand() && player.sessionstate != "spectator" )
  2271. {
  2272. player maps/mp/zombies/_zm_perks::lose_random_perk();
  2273. }
  2274. }
  2275. }
  2276.  
  2277. empty_clip_powerup( item ) //checked partially matches cerberus output
  2278. {
  2279. players = get_players();
  2280. for ( i = 0; i < players.size; i++ )
  2281. {
  2282. player = players[ i ];
  2283. if ( !player maps/mp/zombies/_zm_laststand::player_is_in_laststand() && player.sessionstate != "spectator" )
  2284. {
  2285. weapon = player getcurrentweapon();
  2286. player setweaponammoclip( weapon, 0 );
  2287. }
  2288. }
  2289. }
  2290.  
  2291. minigun_weapon_powerup( ent_player, time ) //checked matches cerberus output
  2292. {
  2293. ent_player endon( "disconnect" );
  2294. ent_player endon( "death" );
  2295. ent_player endon( "player_downed" );
  2296. if ( !isDefined( time ) )
  2297. {
  2298. time = 30;
  2299. }
  2300. if ( isDefined( level._minigun_time_override ) )
  2301. {
  2302. time = level._minigun_time_override;
  2303. }
  2304. if ( ent_player.zombie_vars[ "zombie_powerup_minigun_on" ] || ent_player getcurrentweapon() == "minigun_zm" && isDefined( ent_player.has_minigun ) && ent_player.has_minigun )
  2305. {
  2306. if ( ent_player.zombie_vars[ "zombie_powerup_minigun_time" ] < time )
  2307. {
  2308. ent_player.zombie_vars[ "zombie_powerup_minigun_time" ] = time;
  2309. }
  2310. return;
  2311. }
  2312. ent_player notify( "replace_weapon_powerup" );
  2313. ent_player._show_solo_hud = 1;
  2314. level._zombie_minigun_powerup_last_stand_func = ::minigun_watch_gunner_downed;
  2315. ent_player.has_minigun = 1;
  2316. ent_player.has_powerup_weapon = 1;
  2317. ent_player increment_is_drinking();
  2318. ent_player._zombie_gun_before_minigun = ent_player getcurrentweapon();
  2319. ent_player giveweapon( "minigun_zm" );
  2320. ent_player switchtoweapon( "minigun_zm" );
  2321. ent_player.zombie_vars[ "zombie_powerup_minigun_on" ] = 1;
  2322. level thread minigun_weapon_powerup_countdown( ent_player, "minigun_time_over", time );
  2323. level thread minigun_weapon_powerup_replace( ent_player, "minigun_time_over" );
  2324. }
  2325.  
  2326. minigun_weapon_powerup_countdown( ent_player, str_gun_return_notify, time ) //checked matches cerberus output
  2327. {
  2328. ent_player endon( "death" );
  2329. ent_player endon( "disconnect" );
  2330. ent_player endon( "player_downed" );
  2331. ent_player endon( str_gun_return_notify );
  2332. ent_player endon( "replace_weapon_powerup" );
  2333. setclientsysstate( "levelNotify", "minis", ent_player );
  2334. ent_player.zombie_vars[ "zombie_powerup_minigun_time" ] = time;
  2335. while ( ent_player.zombie_vars[ "zombie_powerup_minigun_time" ] > 0 )
  2336. {
  2337. wait 0.05;
  2338. ent_player.zombie_vars[ "zombie_powerup_minigun_time" ] -= 0.05;
  2339. }
  2340. setclientsysstate( "levelNotify", "minie", ent_player );
  2341. level thread minigun_weapon_powerup_remove( ent_player, str_gun_return_notify );
  2342. }
  2343.  
  2344. minigun_weapon_powerup_replace( ent_player, str_gun_return_notify ) //checked matches cerberus output
  2345. {
  2346. ent_player endon( "death" );
  2347. ent_player endon( "disconnect" );
  2348. ent_player endon( "player_downed" );
  2349. ent_player endon( str_gun_return_notify );
  2350. ent_player waittill( "replace_weapon_powerup" );
  2351. ent_player takeweapon( "minigun_zm" );
  2352. ent_player.zombie_vars[ "zombie_powerup_minigun_on" ] = 0;
  2353. ent_player.has_minigun = 0;
  2354. ent_player decrement_is_drinking();
  2355. }
  2356.  
  2357. minigun_weapon_powerup_remove( ent_player, str_gun_return_notify ) //checked partially matches cerberus output did not change
  2358. {
  2359. ent_player endon( "death" );
  2360. ent_player endon( "player_downed" );
  2361. ent_player takeweapon( "minigun_zm" );
  2362. ent_player.zombie_vars[ "zombie_powerup_minigun_on" ] = 0;
  2363. ent_player._show_solo_hud = 0;
  2364. ent_player.has_minigun = 0;
  2365. ent_player.has_powerup_weapon = 0;
  2366. ent_player notify( str_gun_return_notify );
  2367. ent_player decrement_is_drinking();
  2368. while ( isDefined( ent_player._zombie_gun_before_minigun ) )
  2369. {
  2370. player_weapons = ent_player getweaponslistprimaries();
  2371.  
  2372. for ( i = 0; i < player_weapons.size; i++ )
  2373. {
  2374. if ( player_weapons[ i ] == ent_player._zombie_gun_before_minigun )
  2375. {
  2376. ent_player switchtoweapon( ent_player._zombie_gun_before_minigun );
  2377. return;
  2378. }
  2379. }
  2380. }
  2381. primaryweapons = ent_player getweaponslistprimaries();
  2382. if ( primaryweapons.size > 0 )
  2383. {
  2384. ent_player switchtoweapon( primaryweapons[ 0 ] );
  2385. }
  2386. else
  2387. {
  2388. allweapons = ent_player getweaponslist( 1 );
  2389. for ( i = 0; i < allweapons.size; i++ )
  2390. {
  2391. if ( is_melee_weapon( allweapons[ i ] ) )
  2392. {
  2393. ent_player switchtoweapon( allweapons[ i ] );
  2394. return;
  2395. }
  2396. }
  2397. }
  2398. }
  2399.  
  2400. minigun_weapon_powerup_off() //checked matches cerberus output
  2401. {
  2402. self.zombie_vars[ "zombie_powerup_minigun_time" ] = 0;
  2403. }
  2404.  
  2405. minigun_watch_gunner_downed() //checked partially matches cerberus output did not change
  2406. {
  2407. if ( isDefined( self.has_minigun ) && !self.has_minigun )
  2408. {
  2409. return;
  2410. }
  2411. primaryweapons = self getweaponslistprimaries();
  2412. for ( i = 0; i < primaryweapons.size; i++ )
  2413. {
  2414. if ( primaryweapons[ i ] == "minigun_zm" )
  2415. {
  2416. self takeweapon( "minigun_zm" );
  2417. }
  2418. }
  2419. self notify( "minigun_time_over" );
  2420. self.zombie_vars[ "zombie_powerup_minigun_on" ] = 0;
  2421. self._show_solo_hud = 0;
  2422. wait 0.05;
  2423. self.has_minigun = 0;
  2424. self.has_powerup_weapon = 0;
  2425. }
  2426.  
  2427. tesla_weapon_powerup( ent_player, time ) //checked changed to match cerberus output
  2428. {
  2429. ent_player endon( "disconnect" );
  2430. ent_player endon( "death" );
  2431. ent_player endon( "player_downed" );
  2432. if ( !isDefined( time ) )
  2433. {
  2434. time = 11;
  2435. }
  2436. if ( ent_player.zombie_vars[ "zombie_powerup_tesla_on" ] && ent_player getcurrentweapon() == "tesla_gun_zm" || isDefined( ent_player.has_tesla ) && ent_player.has_tesla )
  2437. {
  2438. ent_player givemaxammo( "tesla_gun_zm" );
  2439. if ( ent_player.zombie_vars[ "zombie_powerup_tesla_time" ] < time )
  2440. {
  2441. ent_player.zombie_vars[ "zombie_powerup_tesla_time" ] = time;
  2442. }
  2443. return;
  2444. }
  2445. ent_player notify( "replace_weapon_powerup" );
  2446. ent_player._show_solo_hud = 1;
  2447. level._zombie_tesla_powerup_last_stand_func = ::tesla_watch_gunner_downed;
  2448. ent_player.has_tesla = 1;
  2449. ent_player.has_powerup_weapon = 1;
  2450. ent_player increment_is_drinking();
  2451. ent_player._zombie_gun_before_tesla = ent_player getcurrentweapon();
  2452. ent_player giveweapon( "tesla_gun_zm" );
  2453. ent_player givemaxammo( "tesla_gun_zm" );
  2454. ent_player switchtoweapon( "tesla_gun_zm" );
  2455. ent_player.zombie_vars[ "zombie_powerup_tesla_on" ] = 1;
  2456. level thread tesla_weapon_powerup_countdown( ent_player, "tesla_time_over", time );
  2457. level thread tesla_weapon_powerup_replace( ent_player, "tesla_time_over" );
  2458. }
  2459.  
  2460. tesla_weapon_powerup_countdown( ent_player, str_gun_return_notify, time ) //checked changed to match cerberus output
  2461. {
  2462. ent_player endon( "death" );
  2463. ent_player endon( "player_downed" );
  2464. ent_player endon( str_gun_return_notify );
  2465. ent_player endon( "replace_weapon_powerup" );
  2466. setclientsysstate( "levelNotify", "minis", ent_player );
  2467. ent_player.zombie_vars[ "zombie_powerup_tesla_time" ] = time;
  2468. while ( 1 )
  2469. {
  2470. ent_player waittill_any( "weapon_fired", "reload", "zmb_max_ammo" );
  2471. if ( !ent_player getweaponammostock( "tesla_gun_zm" ) )
  2472. {
  2473. clip_count = ent_player getweaponammoclip( "tesla_gun_zm" );
  2474. if ( !clip_count )
  2475. {
  2476. break;
  2477. }
  2478. else if ( clip_count == 1 )
  2479. {
  2480. ent_player.zombie_vars[ "zombie_powerup_tesla_time" ] = 1;
  2481. }
  2482. else if ( clip_count == 3 )
  2483. {
  2484. ent_player.zombie_vars[ "zombie_powerup_tesla_time" ] = 6;
  2485. }
  2486. }
  2487. else
  2488. {
  2489. ent_player.zombie_vars[ "zombie_powerup_tesla_time" ] = 11;
  2490. }
  2491. }
  2492. setclientsysstate( "levelNotify", "minie", ent_player );
  2493. level thread tesla_weapon_powerup_remove( ent_player, str_gun_return_notify );
  2494. }
  2495.  
  2496. tesla_weapon_powerup_replace( ent_player, str_gun_return_notify ) //checked matches cerberus output
  2497. {
  2498. ent_player endon( "death" );
  2499. ent_player endon( "disconnect" );
  2500. ent_player endon( "player_downed" );
  2501. ent_player endon( str_gun_return_notify );
  2502. ent_player waittill( "replace_weapon_powerup" );
  2503. ent_player takeweapon( "tesla_gun_zm" );
  2504. ent_player.zombie_vars[ "zombie_powerup_tesla_on" ] = 0;
  2505. ent_player.has_tesla = 0;
  2506. ent_player decrement_is_drinking();
  2507. }
  2508.  
  2509. tesla_weapon_powerup_remove( ent_player, str_gun_return_notify ) //checked changed to match cerberus output
  2510. {
  2511. ent_player endon( "death" );
  2512. ent_player endon( "player_downed" );
  2513. ent_player takeweapon( "tesla_gun_zm" );
  2514. ent_player.zombie_vars[ "zombie_powerup_tesla_on" ] = 0;
  2515. ent_player._show_solo_hud = 0;
  2516. ent_player.has_tesla = 0;
  2517. ent_player.has_powerup_weapon = 0;
  2518. ent_player notify( str_gun_return_notify );
  2519. ent_player decrement_is_drinking();
  2520. if ( isDefined( ent_player._zombie_gun_before_tesla ) )
  2521. {
  2522. player_weapons = ent_player getweaponslistprimaries();
  2523. for ( i = 0; i < player_weapons.size; i++ )
  2524. {
  2525. if ( player_weapons[ i ] == ent_player._zombie_gun_before_tesla )
  2526. {
  2527. ent_player switchtoweapon( ent_player._zombie_gun_before_tesla );
  2528. return;
  2529. }
  2530. }
  2531. }
  2532. primaryweapons = ent_player getweaponslistprimaries();
  2533. if ( primaryweapons.size > 0 )
  2534. {
  2535. ent_player switchtoweapon( primaryweapons[ 0 ] );
  2536. }
  2537. allweapons = ent_player getweaponslist( 1 );
  2538. for ( i = 0; i < allweapons.size; i++ )
  2539. {
  2540. if ( is_melee_weapon( allweapons[ i ] ) )
  2541. {
  2542. ent_player switchtoweapon( allweapons[ i ] );
  2543. return;
  2544. }
  2545. }
  2546. }
  2547.  
  2548. tesla_weapon_powerup_off() //checked matches cerberus output
  2549. {
  2550. self.zombie_vars[ "zombie_powerup_tesla_time" ] = 0;
  2551. }
  2552.  
  2553. tesla_watch_gunner_downed() //checked changed to match cerberus output
  2554. {
  2555. if ( isDefined( self.has_tesla ) && !self.has_tesla )
  2556. {
  2557. return;
  2558. }
  2559. primaryweapons = self getweaponslistprimaries();
  2560. for ( i = 0; i < primaryweapons.size; i++ )
  2561. {
  2562. if ( primaryweapons[ i ] == "tesla_gun_zm" )
  2563. {
  2564. self takeweapon( "tesla_gun_zm" );
  2565. }
  2566. }
  2567. self notify( "tesla_time_over" );
  2568. self.zombie_vars[ "zombie_powerup_tesla_on" ] = 0;
  2569. self._show_solo_hud = 0;
  2570. wait 0.05;
  2571. self.has_tesla = 0;
  2572. self.has_powerup_weapon = 0;
  2573. }
  2574.  
  2575. tesla_powerup_active() //checked changed to match cerberus output
  2576. {
  2577. players = get_players();
  2578. for ( i = 0; i < players.size; i++ )
  2579. {
  2580. if ( players[ i ].zombie_vars[ "zombie_powerup_tesla_on" ] )
  2581. {
  2582. return 1;
  2583. }
  2584. }
  2585. return 0;
  2586. }
  2587.  
  2588. print_powerup_drop( powerup, type ) //devcall only, deleted
  2589. {
  2590. /*
  2591. /#
  2592. if(!isdefined(level.powerup_drop_time))
  2593. {
  2594. level.powerup_drop_time = 0;
  2595. level.powerup_random_count = 0;
  2596. level.powerup_score_count = 0;
  2597. }
  2598. time = GetTime() - level.powerup_drop_time * 0.001;
  2599. level.powerup_drop_time = GetTime();
  2600. if(type == "random")
  2601. {
  2602. level.powerup_random_count++;
  2603. }
  2604. else
  2605. {
  2606. level.powerup_score_count++;
  2607. }
  2608. println("========== POWER UP DROPPED ==========");
  2609. println("DROPPED: " + powerup);
  2610. println("HOW IT DROPPED: " + type);
  2611. println("--------------------");
  2612. println("Drop Time: " + time);
  2613. println("Random Powerup Count: " + level.powerup_random_count);
  2614. println("Random Powerup Count: " + level.powerup_score_count);
  2615. println("======================================");
  2616. #/
  2617. */
  2618. }
  2619.  
  2620. register_carpenter_node( node, callback ) //checked matches cerberus output
  2621. {
  2622. if ( !isDefined( level._additional_carpenter_nodes ) )
  2623. {
  2624. level._additional_carpenter_nodes = [];
  2625. }
  2626. node._post_carpenter_callback = callback;
  2627. level._additional_carpenter_nodes[ level._additional_carpenter_nodes.size ] = node;
  2628. }
  2629.  
  2630. start_carpenter_new( origin ) //checked partially changed to match cerberus output
  2631. {
  2632. level.carpenter_powerup_active = 1;
  2633. window_boards = getstructarray( "exterior_goal", "targetname" );
  2634. if ( isDefined( level._additional_carpenter_nodes ) )
  2635. {
  2636. window_boards = arraycombine( window_boards, level._additional_carpenter_nodes, 0, 0 );
  2637. }
  2638. carp_ent = spawn( "script_origin", ( 0, 0, 0 ) );
  2639. carp_ent playloopsound( "evt_carpenter" );
  2640. boards_near_players = get_near_boards( window_boards );
  2641. boards_far_from_players = get_far_boards( window_boards );
  2642. level repair_far_boards( boards_far_from_players, maps/mp/zombies/_zm_powerups::is_carpenter_boards_upgraded() );
  2643.  
  2644. i = 0;
  2645. while ( i < boards_near_players.size )
  2646. {
  2647. window = boards_near_players[ i ];
  2648. num_chunks_checked = 0;
  2649. last_repaired_chunk = undefined;
  2650. while ( 1 )
  2651. {
  2652. if ( all_chunks_intact( window, window.barrier_chunks ) )
  2653. {
  2654. break;
  2655. }
  2656. chunk = get_random_destroyed_chunk( window, window.barrier_chunks );
  2657. if ( !isDefined( chunk ) )
  2658. {
  2659. break;
  2660. }
  2661. window thread maps/mp/zombies/_zm_blockers::replace_chunk( window, chunk, undefined, maps/mp/zombies/_zm_powerups::is_carpenter_boards_upgraded(), 1 );
  2662. last_repaired_chunk = chunk;
  2663. if ( isDefined( window.clip ) )
  2664. {
  2665. window.clip enable_trigger();
  2666. window.clip disconnectpaths();
  2667. }
  2668. else
  2669. {
  2670. blocker_disconnect_paths( window.neg_start, window.neg_end );
  2671. }
  2672. wait_network_frame();
  2673. num_chunks_checked++;
  2674. if ( num_chunks_checked >= 20 )
  2675. {
  2676. break;
  2677. }
  2678. }
  2679. if ( isDefined( window.zbarrier ) )
  2680. {
  2681. if ( isDefined( last_repaired_chunk ) )
  2682. {
  2683. while ( window.zbarrier getzbarrierpiecestate( last_repaired_chunk ) == "closing" )
  2684. {
  2685. wait 0.05;
  2686. }
  2687. if ( isDefined( window._post_carpenter_callback ) )
  2688. {
  2689. window [[ window._post_carpenter_callback ]]();
  2690. }
  2691. }
  2692. i++;
  2693. continue;
  2694. }
  2695. while ( isDefined( last_repaired_chunk ) && last_repaired_chunk.state == "mid_repair" )
  2696. {
  2697. wait 0.05;
  2698. }
  2699. i++;
  2700. }
  2701. carp_ent stoploopsound( 1 );
  2702. carp_ent playsoundwithnotify( "evt_carpenter_end", "sound_done" );
  2703. carp_ent waittill( "sound_done" );
  2704. players = get_players();
  2705. for ( i = 0; i < players.size; i++ )
  2706. {
  2707. players[ i ] maps/mp/zombies/_zm_score::player_add_points( "carpenter_powerup", 200 );
  2708. }
  2709. carp_ent delete();
  2710. level notify( "carpenter_finished" );
  2711. level.carpenter_powerup_active = undefined;
  2712. }
  2713.  
  2714. is_carpenter_boards_upgraded() //checked matches cerberus output
  2715. {
  2716. if ( isDefined( level.pers_carpenter_boards_active ) && level.pers_carpenter_boards_active == 1 )
  2717. {
  2718. return 1;
  2719. }
  2720. return 0;
  2721. }
  2722.  
  2723. get_near_boards( windows ) //checked changed to match cerberus output
  2724. {
  2725. players = get_players();
  2726. boards_near_players = [];
  2727. for ( j = 0; j < windows.size; j++ )
  2728. {
  2729. close = 0;
  2730. for ( i = 0; i < players.size; i++ )
  2731. {
  2732. origin = undefined;
  2733. if ( isdefined( windows[ j ].zbarrier ) )
  2734. {
  2735. origin = windows[ j ].zbarrier.origin;
  2736. }
  2737. else
  2738. {
  2739. origin = windows[ j ].origin;
  2740. }
  2741. if ( distancesquared( players[ i ].origin, origin ) <= level.board_repair_distance_squared )
  2742. {
  2743. close = 1;
  2744. break;
  2745. }
  2746. }
  2747. if ( close )
  2748. {
  2749. boards_near_players[ boards_near_players.size ] = windows[ j ];
  2750. }
  2751. }
  2752. return boards_near_players;
  2753. }
  2754.  
  2755. get_far_boards( windows ) //checked changed to match cerberus output
  2756. {
  2757. players = get_players();
  2758. boards_far_from_players = [];
  2759. for ( j = 0; j < windows.size; j++ )
  2760. {
  2761. close = 0;
  2762. for ( i = 0; i < players.size; i++ )
  2763. {
  2764. origin = undefined;
  2765. if ( isdefined( windows[ j ].zbarrier ) )
  2766. {
  2767. origin = windows[ j ].zbarrier.origin;
  2768. }
  2769. else
  2770. {
  2771. origin = windows[ j ].origin;
  2772. }
  2773. if ( distancesquared( players[ i ].origin, origin ) >= level.board_repair_distance_squared )
  2774. {
  2775. close = 1;
  2776. break;
  2777. }
  2778. }
  2779. if ( close )
  2780. {
  2781. boards_far_from_players[ boards_far_from_players.size ] = windows[ j ];
  2782. }
  2783. }
  2784. return boards_far_from_players;
  2785. }
  2786.  
  2787. repair_far_boards( barriers, upgrade ) //checked changed to match cerberus output
  2788. {
  2789. i = 0;
  2790. while ( i < barriers.size )
  2791. {
  2792. barrier = barriers[ i ];
  2793. if ( all_chunks_intact( barrier, barrier.barrier_chunks ) )
  2794. {
  2795. i++;
  2796. continue;
  2797. }
  2798. if ( isdefined( barrier.zbarrier ) )
  2799. {
  2800. a_pieces = barrier.zbarrier getzbarrierpieceindicesinstate( "open" );
  2801. if ( isdefined( a_pieces ) )
  2802. {
  2803. xx = 0;
  2804. while ( xx < a_pieces.size )
  2805. {
  2806. chunk = a_pieces[ xx ];
  2807. if ( upgrade )
  2808. {
  2809. barrier.zbarrier zbarrierpieceuseupgradedmodel( chunk );
  2810. barrier.zbarrier.chunk_health[ chunk ] = barrier.zbarrier getupgradedpiecenumlives( chunk );
  2811. xx++;
  2812. continue;
  2813. }
  2814. barrier.zbarrier zbarrierpieceusedefaultmodel( chunk );
  2815. barrier.zbarrier.chunk_health[ chunk ] = 0;
  2816. xx++;
  2817. }
  2818. }
  2819. for ( x = 0; x < barrier.zbarrier getnumzbarrierpieces(); x++ )
  2820. {
  2821. barrier.zbarrier setzbarrierpiecestate( x, "closed" );
  2822. barrier.zbarrier showzbarrierpiece( x );
  2823. }
  2824. }
  2825. else if ( isdefined( barrier.clip ) )
  2826. {
  2827. barrier.clip enable_trigger();
  2828. barrier.clip disconnectpaths();
  2829. }
  2830. else
  2831. {
  2832. blocker_disconnect_paths( barrier.neg_start, barrier.neg_end );
  2833. }
  2834. if ( i % 4 == 0 )
  2835. {
  2836. wait_network_frame();
  2837. }
  2838. i++;
  2839. }
  2840. }
  2841.  
  2842. track_pack_a_punch_drops()
  2843. {
  2844. level endon("end_game");
  2845. level.rounds_since_last_pack_a_punch = 0;
  2846. for(;;)
  2847. {
  2848. level waittill("start_of_round");
  2849. level.rounds_since_last_pack_a_punch_drop += 1;
  2850. wait 0.5;
  2851. }
  2852. }
  2853.  
  2854. func_should_drop_pack_a_punch()
  2855. {
  2856. if ( level.zmPowerupsEnabled[ "pack_a_punch" ].active != 1 || level.round_number < 12 || isDefined( level.rounds_since_last_pack_a_punch_drop ) && level.rounds_since_last_pack_a_punch_drop < 5 )
  2857. {
  2858. return 0;
  2859. }
  2860. return 1;
  2861. }
  2862.  
  2863. func_should_never_drop() //checked matches cerberus output
  2864. {
  2865. return 0;
  2866. }
  2867.  
  2868. func_should_always_drop() //checked matches cerberus output
  2869. {
  2870. return 1;
  2871. }
  2872.  
  2873. func_should_drop_minigun()
  2874. {
  2875. if ( minigun_no_drop() )
  2876. {
  2877. return 0;
  2878. }
  2879. return 1;
  2880. }
  2881.  
  2882. func_should_drop_carpenter()
  2883. {
  2884. if ( get_num_window_destroyed() < 5 )
  2885. {
  2886. return 0;
  2887. }
  2888. return 1;
  2889. }
  2890.  
  2891. func_should_drop_fire_sale()
  2892. {
  2893. if ( level.zombie_vars[ "zombie_powerup_fire_sale_on" ] == 1 || level.chest_moves < 1 || isDefined( level.disable_firesale_drop ) && level.disable_firesale_drop )
  2894. {
  2895. return 0;
  2896. }
  2897. return 1;
  2898. }
  2899.  
  2900. powerup_move()
  2901. {
  2902. self endon( "powerup_timedout" );
  2903. self endon( "powerup_grabbed" );
  2904. drag_speed = 75;
  2905. while ( 1 )
  2906. {
  2907. self waittill( "move_powerup", moveto, distance );
  2908. drag_vector = moveto - self.origin;
  2909. range_squared = lengthsquared( drag_vector );
  2910. if ( range_squared > distance * distance )
  2911. {
  2912. drag_vector = vectornormalize( drag_vector );
  2913. drag_vector = distance * drag_vector;
  2914. moveto = self.origin + drag_vector;
  2915. }
  2916. self.origin = moveto;
  2917. }
  2918. }
  2919.  
  2920. powerup_emp()
  2921. {
  2922. self endon( "powerup_timedout" );
  2923. self endon( "powerup_grabbed" );
  2924. if ( !should_watch_for_emp() )
  2925. {
  2926. return;
  2927. }
  2928. while ( 1 )
  2929. {
  2930. level waittill( "emp_detonate", origin, radius );
  2931. if ( distancesquared( origin, self.origin ) < ( radius * radius ) )
  2932. {
  2933. playfx( level._effect[ "powerup_off" ], self.origin );
  2934. self thread powerup_delete_delayed();
  2935. self notify( "powerup_timedout" );
  2936. }
  2937. }
  2938. }
  2939.  
  2940. get_powerups( origin, radius )
  2941. {
  2942. if ( isDefined( origin ) && isDefined( radius ) )
  2943. {
  2944. powerups = [];
  2945. foreach ( powerup in level.active_powerups )
  2946. {
  2947. if ( distancesquared( origin, powerup.origin ) < radius * radius )
  2948. {
  2949. powerups[ powerups.size ] = powerup;
  2950. }
  2951. }
  2952. return powerups;
  2953. }
  2954. return level.active_powerups;
  2955. }
  2956.  
  2957. should_award_stat( powerup_name )
  2958. {
  2959. if ( powerup_name == "teller_withdrawl" || powerup_name == "blue_monkey" || powerup_name == "free_perk" || powerup_name == "bonus_points_player" )
  2960. {
  2961. return 0;
  2962. }
  2963. if ( isDefined( level.statless_powerups ) && isDefined( level.statless_powerups[ powerup_name ] ) )
  2964. {
  2965. return 0;
  2966. }
  2967. return 1;
  2968. }
  2969.  
  2970. teller_withdrawl( powerup, player )
  2971. {
  2972. player maps/mp/zombies/_zm_score::add_to_player_score( powerup.value );
  2973. }
  2974.  
  2975. zombies_always_drop_powerups()
  2976. {
  2977. if ( !level.zombiesAlwaysDropPowerups )
  2978. {
  2979. return;
  2980. }
  2981. while ( 1 )
  2982. {
  2983. level.zombie_vars[ "zombie_drop_item" ] = level.zombiesAlwaysDropPowerups;
  2984. wait 0.05;
  2985. }
  2986. }
  2987.  
  2988. doFastFeet()
  2989. {
  2990. level endon("end_game");
  2991. self endon( "disconnect" );
  2992. self thread poweruptext("Fast Feet!");
  2993. self playsound("zmb_cha_ching");
  2994. self setmovespeedscale(3);
  2995. wait 15;
  2996. self setmovespeedscale(1);
  2997. self playsound("zmb_insta_kill");
  2998. }
  2999.  
  3000. doUnlimitedAmmo()
  3001. {
  3002. level endon("end_game");
  3003. foreach(player in level.players)
  3004. {
  3005. player notify("end_unlimited_ammo");
  3006. player playsound("zmb_cha_ching");
  3007. player thread poweruptext("Bottomless Clip");
  3008. player thread monitorUnlimitedAmmo();
  3009. player thread notifyUnlimitedAmmoEnd();
  3010. }
  3011. }
  3012.  
  3013. monitorUnlimitedAmmo()
  3014. {
  3015. level endon("end_game");
  3016. self endon("disonnect");
  3017. self endon("end_unlimited_ammo");
  3018. for(;;)
  3019. {
  3020. self setWeaponAmmoClip(self GetCurrentWeapon(), 150);
  3021. wait .05;
  3022. }
  3023. }
  3024.  
  3025. notifyUnlimitedAmmoEnd()
  3026. {
  3027. level endon("end_game");
  3028. self endon("disonnect");
  3029. self endon("end_unlimited_ammo");
  3030. wait level.unlimited_ammo_duration;
  3031. self playsound("zmb_insta_kill");
  3032. self notify("end_unlimited_ammo");
  3033. }
  3034.  
  3035. doPackAPunchWeapon()
  3036. {
  3037. baseweapon = get_base_name(self getcurrentweapon());
  3038. weapon = get_upgrade(baseweapon);
  3039. if(IsDefined(weapon) && isDefined(self.packapunching))
  3040. {
  3041. level.rounds_since_last_pack_a_punch_drop = 0;
  3042. self.packapunching = undefined;
  3043. self takeweapon(baseweapon);
  3044. self giveweapon(weapon, 0, self get_pack_a_punch_weapon_options(weapon));
  3045. self switchtoweapon(weapon);
  3046. self givemaxammo(weapon);
  3047. }
  3048. else
  3049. self playsoundtoplayer( level.zmb_laugh_alias, self );
  3050. }
  3051.  
  3052. get_upgrade(weapon)
  3053. {
  3054. if(IsDefined(level.zombie_weapons[weapon].upgrade_name) && IsDefined(level.zombie_weapons[weapon]))
  3055. {
  3056. self.packapunching = true;
  3057. return get_upgrade_weapon(weapon, 0 );
  3058. }
  3059. else
  3060. return get_upgrade_weapon(weapon, 1 );
  3061. }
  3062.  
  3063. doRandomScore()
  3064. {
  3065. x = randomInt(9);
  3066. self playsound("zmb_cha_ching");
  3067. if(x==1)
  3068. self.score += 50;
  3069. else if(x==2)
  3070. self.score += 100;
  3071. else if(x==3)
  3072. self.score += 250;
  3073. else if(x==4)
  3074. self.score += 500;
  3075. else if(x==5)
  3076. self.score += 750;
  3077. else if(x==6)
  3078. self.score += 1000;
  3079. else if(x==7)
  3080. self.score += 2500;
  3081. else if(x==8)
  3082. self.score += 5000;
  3083. else if(x==9)
  3084. self.score += 7500;
  3085. else
  3086. self.score += 10000;
  3087. }
  3088.  
  3089. poweruptext(text)
  3090. {
  3091. self endon("disconnect");
  3092. level endon("end_game");
  3093. hud_string = newclienthudelem(self);
  3094. hud_string.elemtype = "font";
  3095. hud_string.font = "objective";
  3096. hud_string.fontscale = 2;
  3097. hud_string.x = 0;
  3098. hud_string.y = 0;
  3099. hud_string.width = 0;
  3100. hud_string.height = int( level.fontheight * 2 );
  3101. hud_string.xoffset = 0;
  3102. hud_string.yoffset = 0;
  3103. hud_string.children = [];
  3104. hud_string setparent(level.uiparent);
  3105. hud_string.hidden = 0;
  3106. hud_string maps/mp/gametypes_zm/_hud_util::setpoint("TOP", undefined, 0, level.zombie_vars["zombie_timer_offset"] - (level.zombie_vars["zombie_timer_offset_interval"] * 2));
  3107. hud_string.sort = .5;
  3108. hud_string.alpha = 0;
  3109. hud_string fadeovertime(.5);
  3110. hud_string.alpha = 1;
  3111. hud_string setText(text);
  3112. hud_string thread poweruptextmove();
  3113. }
  3114.  
  3115. poweruptextmove()
  3116. {
  3117. wait .5;
  3118. self fadeovertime(1.5);
  3119. self moveovertime(1.5);
  3120. self.y = 270;
  3121. self.alpha = 0;
  3122. wait 1.5;
  3123. self destroy();
  3124. }
  3125.  
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement