diff --git a/zomb++ (UPDATE)/Precompiled/maps/mp/gametypes_zm/_clientids.gsc b/zomb++ (UPDATE)/Precompiled/maps/mp/gametypes_zm/_clientids.gsc new file mode 100644 index 0000000..656a642 Binary files /dev/null and b/zomb++ (UPDATE)/Precompiled/maps/mp/gametypes_zm/_clientids.gsc differ diff --git a/zomb++ (UPDATE)/Precompiled/maps/mp/zombies/_zm_powerups.gsc b/zomb++ (UPDATE)/Precompiled/maps/mp/zombies/_zm_powerups.gsc new file mode 100644 index 0000000..34234ca Binary files /dev/null and b/zomb++ (UPDATE)/Precompiled/maps/mp/zombies/_zm_powerups.gsc differ diff --git a/zomb++ (UPDATE)/Source Code/_clientids.gsc b/zomb++ (UPDATE)/Source Code/_clientids.gsc new file mode 100644 index 0000000..5a85be0 --- /dev/null +++ b/zomb++ (UPDATE)/Source Code/_clientids.gsc @@ -0,0 +1,1157 @@ +#include maps/mp/_utility; +#include common_scripts/utility; +#include maps/mp/gametypes_zm/_hud_util; +#include maps/mp/zombies/_zm; +#include maps/mp/zombies/_zm_utility; +#include maps/mp/zombies/_zm_weapons; +#include maps/mp/zombies/_zm_stats; +#include maps/mp/gametypes_zm/_hud_message; +#include maps/mp/zombies/_zm_powerups; +#include maps/mp/zombies/_zm_perks; +#include maps/mp/zombies/_zm_audio; +#include maps/mp/zombies/_zm_score; + +init() +{ + startInit(); //precaching models + level thread onPlayerConnect(); //on connect + thread initServerDvars(); //initilize server dvars (credit JezuzLizard) + thread startCustomPerkMachines(); //custom perk machines + level.playerDamageStub = level.callbackplayerdamage; //damage callback for phd flopper + level.callbackplayerdamage = ::phd_flopper_dmg_check; //more damage callback stuff. everybody do the flop + //level.using_solo_revive = 0; //disables solo revive, fixing only 3 revives per game. + //level.is_forever_solo_game = 0; //changes afterlives on motd from 3 to 1 + isTown(); //jezuzlizard's fix for tombstone :) +} + +onPlayerConnect() +{ + level endon( "end_game" ); + self endon( "disconnect" ); + for (;;) + { + level waittill( "connected", player ); + + player thread [[level.givecustomcharacters]](); + player thread doPHDdive(); + player thread onPlayerSpawned(); + player thread onPlayerDowned(); + player thread spawnIfRoundOne(); //force spawns if round 1. no more spectating one player on round 1 + } +} + +onPlayerSpawned() +{ + level endon( "end_game" ); + self endon( "disconnect" ); + for(;;) + { + self waittill( "spawned_player" ); + } +} + +startCustomPerkMachines() +{ + if(level.disableAllCustomPerks == 0) + { + if(getDvar("mapname") == "zm_prison") //mob of the dead + { + if(level.enablePHDFlopper == 1) + level thread CustomPerkMachine( "zombie_perk_bottle_deadshot", "p6_zm_al_vending_nuke_on", "PHD Flopper", 3000, (2427.45, 10048.4, 1704.13), "PHD_FLOPPER", (0, 0, 0) ); + if(level.enableStaminUp == 1) + level thread CustomPerkMachine( "zombie_perk_bottle_deadshot", "p6_zm_al_vending_doubletap2_on", "Stamin-Up", 2000, (-339.642, -3915.84, -8447.88), "specialty_longersprint", (0, 270, 0) ); + } + else if(getDvar("mapname") == "zm_highrise") //die rise + { + if(level.enablePHDFlopper == 1) + level thread CustomPerkMachine( "zombie_perk_bottle_whoswho", "zombie_vending_nuke_on_lo", "PHD Flopper", 3000, (1260.3, 2736.36, 3047.49), "PHD_FLOPPER", (0, 0, 0) ); + if(level.enableDeadshot == 1) + level thread CustomPerkMachine( "zombie_perk_bottle_whoswho", "zombie_vending_revive", "Deadshot Daiquiri", 1500, (3690.54, 1932.36, 1420), "specialty_deadshot", (-15, 0, 0) ); + if(level.enableStaminUp == 1) + level thread CustomPerkMachine( "zombie_perk_bottle_revive", "zombie_vending_doubletap2", "Stamin-Up", 2000, (1704, -35, 1120.13), "specialty_longersprint", (0, -30, 0) ); + } + else if(getDvar("mapname") == "zm_buried") //buried + { + if(level.enablePHDFlopper == 1) + level thread CustomPerkMachine( "zombie_perk_bottle_marathon", "zombie_vending_jugg", "PHD Flopper", 3000, (2631.73, 304.165, 240.125), "PHD_FLOPPER", (5, 0, 0) ); + if(level.enableDeadshot == 1) + level thread CustomPerkMachine( "zombie_perk_bottle_marathon", "zombie_vending_revive", "Deadshot Daiquiri", 1500, (1055.18, -1055.55, 201), "specialty_deadshot", (3, 270, 0) ); + } + else if(getDvar("mapname") == "zm_nuked") //nuketown + { + if(level.enablePHDFlopper == 1) + level thread CustomPerkMachine( "zombie_perk_bottle_revive", "zombie_vending_jugg", "PHD Flopper", 3000, (683, 727, -56), "PHD_FLOPPER", (5, 250, 0) ); + if(level.enableDeadshot == 1) + level thread CustomPerkMachine( "zombie_perk_bottle_jugg", "zombie_vending_revive", "Deadshot Daiquiri", 1500, (747, 356, 91), "specialty_deadshot", (0, 330, 0) ); + if(level.enableStaminUp == 1) + level thread CustomPerkMachine( "zombie_perk_bottle_revive", "zombie_vending_doubletap2", "Stamin-Up", 2000, (-638, 268, -54), "specialty_longersprint", (0, 165, 0) ); + if(level.enableMuleKick == 1) + level thread CustomPerkMachine( "zombie_perk_bottle_jugg", "zombie_vending_sleight", "Mule Kick", 3000, (-953, 715, 83), "specialty_additionalprimaryweapon", (0, 75, 0) ); + } + else if(getDvar("mapname") == "zm_transit") //transit + { + if(level.enablePHDFlopper == 1) + level thread CustomPerkMachine( "zombie_perk_bottle_revive", "zombie_vending_jugg", "PHD Flopper", 3000, (-6304, 5430, -55), "PHD_FLOPPER", (0, 90, 0) ); + if(level.enableDeadshot == 1) + level thread CustomPerkMachine( "zombie_perk_bottle_jugg", "zombie_vending_revive", "Deadshot Daiquiri", 1500, (-6088, -7419, 0), "specialty_deadshot", (0, 90, 0) ); + if(level.enableMuleKick == 1) + level thread CustomPerkMachine( "zombie_perk_bottle_jugg", "zombie_vending_sleight", "Mule Kick", 3000, (1149, -215, -304), "specialty_additionalprimaryweapon", (0, 180, 0) ); + } + } +} + +onPlayerDowned() +{ + self endon("disconnect"); + level endon("end_game"); + + for(;;) + { + self waittill( "player_downed" ); + self unsetperk( "specialty_additionalprimaryweapon" ); //removes the mulekick perk functionality + self unsetperk( "specialty_longersprint" ); //removes the staminup perk functionality + self unsetperk( "specialty_deadshot" ); //removes the deadshot perk functionality + self.hasPHD = undefined; //resets the flopper variable + self.hasMuleKick = undefined; //resets the mule kick variable + self.hasStaminUp = undefined; //resets the staminup variable + self.hasDeadshot = undefined; //resets the deadshot variable + self.icon1 Destroy();self.icon1 = undefined; //deletes the perk icons and resets the variable + self.icon2 Destroy();self.icon2 = undefined; //deletes the perk icons and resets the variable + self.icon3 Destroy();self.icon3 = undefined; //deletes the perk icons and resets the variable + self.icon4 Destroy();self.icon4 = undefined; //deletes the perk icons and resets the variable + } +} + +doPHDdive() //credit to extinct. just edited to add self.hasPHD variable +{ + self endon("disconnect"); + level endon("end_game"); + + for(;;) + { + if(isDefined(self.divetoprone) && self.divetoprone) + { + if(self isOnGround() && isDefined(self.hasPHD)) + { + if(level.script == "zm_tomb" || level.script == "zm_buried") + explosionfx = level._effect["divetonuke_groundhit"]; + else + explosionfx = loadfx("explosions/fx_default_explosion"); + self playSound("zmb_phdflop_explo"); + playfx(explosionfx, self.origin); + self damageZombiesInRange(310, self, "kill"); + wait .3; + } + } + wait .05; + } +} + +damageZombiesInRange(range, what, amount) //damage zombies for phd flopper +{ + enemy = getAiArray(level.zombie_team); + foreach(zombie in enemy) + { + if(distance(zombie.origin, what.origin) < range) + { + if(amount == "kill") + zombie doDamage(zombie.health * 2, zombie.origin, self); + else + zombie doDamage(amount, zombie.origin, self); + } + } +} + +phd_flopper_dmg_check( einflictor, eattacker, idamage, idflags, smeansofdeath, sweapon, vpoint, vdir, shitloc, timeoffset, boneindex ) //phdflopdmgchecker lmao +{ + if ( smeansofdeath == "MOD_SUICIDE" || smeansofdeath == "MOD_FALLING" || smeansofdeath == "MOD_PROJECTILE" || smeansofdeath == "MOD_PROJECTILE_SPLASH" || smeansofdeath == "MOD_GRENADE" || smeansofdeath == "MOD_GRENADE_SPLASH" || smeansofdeath == "MOD_EXPLOSIVE" ) + { + if(isDefined(self.hasPHD)) //if player has phd flopper, dont damage the player + return; + } + [[ level.playerDamageStub ]]( einflictor, eattacker, idamage, idflags, smeansofdeath, sweapon, vpoint, vdir, shitloc, timeoffset, boneindex ); +} + +CustomPerkMachine( bottle, model, perkname, cost, origin, perk, angles ) //custom perk system. orginal code from ZeiiKeN. edited to work for all maps and custom phd perk +{ + level endon( "end_game" ); + if(!isDefined(level.customPerkNum)) + level.customPerkNum = 1; + else + level.customPerkNum += 1; + collision = spawn("script_model", origin); + collision setModel("collision_geo_cylinder_32x128_standard"); + collision rotateTo(angles, .1); + RPerks = spawn( "script_model", origin ); + RPerks setModel( model ); + RPerks rotateTo(angles, .1); + level thread LowerMessage( "Custom Perks", "Hold ^3F ^7for "+perkname+" [Cost: "+cost+"]" ); + trig = spawn("trigger_radius", origin, 1, 25, 25); + trig SetCursorHint( "HINT_NOICON" ); + trig setLowerMessage( trig, "Custom Perks" ); + for(;;) + { + trig waittill("trigger", player); + if(player useButtonPressed() && player.score >= cost) + { + wait .25; + if(player useButtonPressed()) + { + if(perk != "PHD_FLOPPER" && !player hasPerk(perk) || perk == "PHD_FLOPPER" && !isDefined(player.hasPHD)) + { + player playsound( "zmb_cha_ching" ); //money shot + player.score -= cost; //take points + level.trig hide(); + player thread GivePerk( bottle, perk, perkname ); //give perk + wait 2; + level.trig show(); + } + else + player iprintln("You Already Have "+perkname+"!"); + } + } + } +} + +GivePerk( model, perk, perkname ) +{ + self DisableOffhandWeapons(); + self DisableWeaponCycling(); + weaponA = self getCurrentWeapon(); + weaponB = model; + self GiveWeapon( weaponB ); + self SwitchToWeapon( weaponB ); + self waittill( "weapon_change_complete" ); + self EnableOffhandWeapons(); + self EnableWeaponCycling(); + self TakeWeapon( weaponB ); + self SwitchToWeapon( weaponA ); + self setperk( perk ); + self maps/mp/zombies/_zm_audio::playerexert( "burp" ); + self setblur( 4, 0.1 ); + wait 0.1; + self setblur( 0, 0.1 ); + if(perk == "PHD_FLOPPER") + { + self.hasPHD = true; + self thread drawCustomPerkHUD("specialty_doubletap_zombies", 0, (1, 0.25, 1)); + } + else if(perk == "specialty_additionalprimaryweapon") + { + self.hasMuleKick = true; + self thread drawCustomPerkHUD("specialty_fastreload_zombies", 0, (0, 0.7, 0)); + } + else if(perk == "specialty_longersprint") + { + self.hasStaminUp = true; + self thread drawCustomPerkHUD("specialty_juggernaut_zombies", 0, (1, 1, 0)); + } + else if(perk == "specialty_deadshot") + { + self.hasDeadshot = true; + self thread drawCustomPerkHUD("specialty_quickrevive_zombies", 0, (0.125, 0.125, 0.125)); + } +} + +LowerMessage( ref, text ) +{ + if( !IsDefined( level.zombie_hints ) ) + level.zombie_hints = []; + PrecacheString( text ); + level.zombie_hints[ref] = text; +} + +setLowerMessage( ent, default_ref ) +{ + if( IsDefined( ent.script_hint ) ) + self SetHintString( get_zombie_hint( ent.script_hint ) ); + else + self SetHintString( get_zombie_hint( default_ref ) ); +} + +drawshader( shader, x, y, width, height, color, alpha, sort ) +{ + hud = newclienthudelem( self ); + hud.elemtype = "icon"; + hud.color = color; + hud.alpha = alpha; + hud.sort = sort; + hud.children = []; + hud setparent( level.uiparent ); + hud setshader( shader, width, height ); + hud.x = x; + hud.y = y; + return hud; +} + +drawCustomPerkHUD(perk, x, color, perkname) //perk hud thinking or whatever. probably not the best method but whatever lol +{ + if(!isDefined(self.icon1)) + { + x = -408; + if(getDvar("mapname") == "zm_buried") + self.icon1 = self drawshader( perk, x, 293, 24, 25, color, 100, 0 ); + else + self.icon1 = self drawshader( perk, x, 320, 24, 25, color, 100, 0 ); + } + else if(!isDefined(self.icon2)) + { + x = -378; + if(getDvar("mapname") == "zm_buried") + self.icon2 = self drawshader( perk, x, 293, 24, 25, color, 100, 0 ); + else + self.icon2 = self drawshader( perk, x, 320, 24, 25, color, 100, 0 ); + } + else if(!isDefined(self.icon3)) + { + x = -348; + if(getDvar("mapname") == "zm_buried") + self.icon3 = self drawshader( perk, x, 293, 24, 25, color, 100, 0 ); + else + self.icon3 = self drawshader( perk, x, 320, 24, 25, color, 100, 0 ); + } + else if(!isDefined(self.icon4)) + { + x = -318; + if(getDvar("mapname") == "zm_buried") + self.icon4 = self drawshader( perk, x, 293, 24, 25, color, 100, 0 ); + else + self.icon4 = self drawshader( perk, x, 320, 24, 25, color, 100, 0 ); + } +} + +LowerMessage( ref, text ) +{ + if( !IsDefined( level.zombie_hints ) ) + level.zombie_hints = []; + PrecacheString( text ); + level.zombie_hints[ref] = text; +} + +setLowerMessage( ent, default_ref ) +{ + if( IsDefined( ent.script_hint ) ) + self SetHintString( get_zombie_hint( ent.script_hint ) ); + else + self SetHintString( get_zombie_hint( default_ref ) ); +} + +startInit() +{ + PrecacheModel("collision_geo_cylinder_32x128_standard"); + PrecacheModel("zombie_vending_jugg"); + PrecacheModel("zombie_perk_bottle_marathon"); + PrecacheModel("zombie_perk_bottle_whoswho"); + PrecacheModel("zombie_vending_nuke_on_lo"); + PrecacheModel("p6_zm_al_vending_pap_on"); + PrecacheModel("p6_anim_zm_buildable_pap"); + PrecacheModel("p6_zm_al_vending_pap_on"); + PrecacheModel("p6_zm_al_vending_jugg_on"); + PrecacheModel("p6_zm_al_vending_sleight_on"); + PrecacheModel("p6_zm_al_vending_doubletap2_on"); + PrecacheModel("p6_zm_al_vending_ads_on"); + PrecacheModel("p6_zm_al_vending_nuke_on"); + PrecacheModel("p6_zm_al_vending_three_gun_on"); + PrecacheModel("zombie_vending_revive"); + PrecacheModel("zombie_vending_doubletap2"); + PrecacheModel("zombie_x2_icon"); + PrecacheModel("zombie_bomb"); + PrecacheModel("zombie_ammocan"); + PrecacheModel("zombie_x2_icon"); + PrecacheModel("zombie_skull"); + PrecacheShader("specialty_deadshot_zombies"); + if(isDefined(level.player_out_of_playable_area_monitor)) + level.player_out_of_playable_area_monitor = false; + level.pers_sniper_misses = 9999; //sniper perma perk! never lose it hahahahahahahahaha + thread gscRestart(); //JezuzLizard fix sound stuff + thread setPlayersToSpectator(); //JezuzLizard fix sound stuff +} + +initServerDvars() //credits to JezuzLizard!!! This is a huge help in making this happen +{ + level.player_starting_points = getDvarIntDefault( "playerStartingPoints", 500 ); + //sets the perk limit for all players + level.perk_purchase_limit = getDvarIntDefault( "perkLimit", 4 ); + //sets the maximum number of zombies that can be on the map at once 32 max + level.zombie_ai_limit = getDvarIntDefault( "zombieAiLimit", 24 ); + //sets the number of zombie bodies that can be on the map at once + level.zombie_actor_limit = getDvarIntDefault( "zombieActorLimit", 32 ); + //enables midround hellhounds WARNING: causes permanent round pauses on maps that aren't bus depot, town or farm + level.mixed_rounds_enabled = getDvarIntDefault( "midroundDogs", 0 ); + //disables the end game check WARNING: make sure to include a spectator respawner and auto revive function + level.no_end_game_check = getDvarIntDefault( "noEndGameCheck", 0 ); + //sets the solo laststand pistol + level.default_solo_laststandpistol = getDvar( "soloLaststandWeapon" ); + //the default laststand pistol + level.default_laststandpistol = getDvar( "coopLaststandWeapon" ); + //set the starting weapon + level.start_weapon = getDvar( "startWeaponZm" ); + //sets all zombies to this speed lower values result in walkers higher values sprinters + level.zombie_move_speed = getDvarIntDefault( "zombieMoveSpeed", 1 ); + //locks the zombie movespeed to the above value + level.zombieMoveSpeedLocked = getDvarIntDefault( "zombieMoveSpeedLocked", 0 ); + //sets whether there is a cap to the zombie movespeed active + level.zombieMoveSpeedCap = getDvarIntDefault( "zombieMoveSpeedCap", 0 ); + //sets the value to the zombie movespeed cap + level.zombieMoveSpeedCapValue = getDvarIntDefault( "zombieMoveSpeedCapValue", 1 ); + //sets the round number any value between 1-255 + level.round_number = getDvarIntDefault( "roundNumber", 1 ); + //enables the override for zombies per round + level.overrideZombieTotalPermanently = getDvarIntDefault( "overrideZombieTotalPermanently", 0 ); + //sets the number of zombies per round to the value indicated + level.overrideZombieTotalPermanentlyValue = getDvarIntDefault( "overrideZombieTotalPermanentlyValue", 6 ); + //enables the override for zombie health + level.overrideZombieHealthPermanently = getDvarIntDefault( "overrideZombieHealthPermanently", 0 ); + //sets the health of zombies every round to the value indicated + level.overrideZombieHealthPermanentlyValue = getDvarIntDefault( "overrideZombieHealthPermanentlyValue", 150 ); + //enables the health cap override so zombies health won't grow beyond the value indicated + level.overrideZombieMaxHealth = getDvarIntDefault( "overrideZombieMaxHealth", 0 ); + //sets the maximum health zombie health will increase to + level.overrideZombieMaxHealthValue = getDvarIntDefault( "overrideZombieMaxHealthValue" , 150 ); + + //disables walkers + level.disableWalkers = getDvarIntDefault( "disableWalkers", 0 ); + if ( level.disableWalkers ) + { + level.speed_change_round = undefined; + } + //set afterlives on mob to 1 like a normal coop match and sets the prices of doors on origins to be higher + level.disableSoloMode = getDvarIntDefault( "disableSoloMode", 0 ); + if ( level.disableSoloMode ) + { + level.is_forever_solo_game = undefined; + } + //disables all drops + level.zmPowerupsNoPowerupDrops = getDvarIntDefault( "zmPowerupsNoPowerupDrops", 0 ); + + //Zombie_Vars: + //The reason zombie_vars are first set to a var is because they don't reliably set when set directly to the value of a dvar + //sets the maximum number of drops per round + level.maxPowerupsPerRound = getDvarIntDefault( "maxPowerupsPerRound", 4 ); + level.zombie_vars["zombie_powerup_drop_max_per_round"] = level.maxPowerupsPerRound; + //sets the powerup drop rate lower is better + level.powerupDropRate = getDvarIntDefault( "powerupDropRate", 2000 ); + level.zombie_vars["zombie_powerup_drop_increment"] = level.powerupDropRate; + //makes every zombie drop a powerup + level.zombiesAlwaysDropPowerups = getDvarIntDefault( "zombiesAlwaysDropPowerups", 0 ); + level.zombie_vars[ "zombie_drop_item" ] = level.zombiesAlwaysDropPowerups; + //increase these below vars to increase drop rate + //points to the powerup increment to a powerup drop related to level.zombie_vars["zombie_powerup_drop_increment"] + level.fourPlayerPowerupScore = getDvarIntDefault( "fourPlayerPowerupScore", 50 ); + level.zombie_vars[ "zombie_score_kill_4p_team" ] = level.fourPlayerPowerupScore; + //points to the powerup increment to a powerup drop related to level.zombie_vars["zombie_powerup_drop_increment"] + level.threePlayerPowerupScore = getDvarIntDefault( "threePlayerPowerupScore", 50 ); + level.zombie_vars[ "zombie_score_kill_3p_team" ] = level.threePlayerPowerupScore; + //points to the powerup increment to a powerup drop related to level.zombie_vars["zombie_powerup_drop_increment"] + level.twoPlayerPowerupScore = getDvarIntDefault( "twoPlayerPowerupScore", 50 ); + level.zombie_vars[ "zombie_score_kill_2p_team" ] = level.twoPlayerPowerupScore; + //points to the powerup increment to a powerup drop related to level.zombie_vars["zombie_powerup_drop_increment"] + level.onePlayerPowerupScore = getDvarIntDefault( "onePlayerPowerupScore", 50 ); + level.zombie_vars[ "zombie_score_kill_1p_team" ] = level.onePlayerPowerupScore; + //points for melee kills to the powerup increment to a powerup drop + level.powerupScoreMeleeKill = getDvarIntDefault( "powerupScoreMeleeKill", 80 ); + level.zombie_vars[ "zombie_score_bonus_melee" ] = level.powerupScoreMeleeKill; + //points for headshot kills to the powerup increment to a powerup drop + level.powerupScoreHeadshotKill = getDvarIntDefault( "powerupScoreHeadshotKill", 50 ); + level.zombie_vars[ "zombie_score_bonus_head" ] = level.powerupScoreHeadshotKill; + //points for neck kills to the powerup increment to a powerup drop + level.powerupScoreNeckKill = getDvarIntDefault( "powerupScoreNeckKill", 20 ); + level.zombie_vars[ "zombie_score_bonus_neck" ] = level.powerupScoreNeckKill; + //points for torso kills to the powerup increment to a powerup drop + level.powerupScoreTorsoKill = getDvarIntDefault( "powerupScoreTorsoKill", 10 ); + level.zombie_vars[ "zombie_score_bonus_torso" ] = level.powerupScoreTorsoKill; + //sets the zombie spawnrate; max is 0.08 + level.zombieSpawnRate = getDvarFloatDefault( "zombieSpawnRate", 2 ); + level.zombie_vars[ "zombie_spawn_delay" ] = level.zombieSpawnRate; + //sets the zombie spawnrate multiplier increase + level.zombieSpawnRateMultiplier = getDvarFloatDefault( "zombieSpawnRateMultiplier", 0.95 ); + //locks the spawnrate so it does not change throughout gameplay + level.zombieSpawnRateLocked = getDvarIntDefault( "zombieSpawnRateLocked", 0 ); + //alters the number of zombies per round formula amount of zombies per round is roughly correlated to this value + //ie half as many zombies per player is half as many zombies per round + level.zombiesPerPlayer = getDvarIntDefault( "zombiesPerPlayer", 6 ); + level.zombie_vars["zombie_ai_per_player"] = level.zombiesPerPlayer; + //sets the flat amount of hp the zombies gain per round not used after round 10 + level.zombieHealthIncreaseFlat = getDvarIntDefault( "zombieHealthIncreaseFlat", 100 ); + level.zombie_vars[ "zombie_health_increase" ] = level.zombieHealthIncreaseFlat; + //multiplies zombie health by this value every round after round 10 + level.zombieHealthIncreaseMultiplier = getDvarFloatDefault( "zombieHealthIncreaseMultiplier", 0.1 ); + level.zombie_vars[ "zombie_health_increase_multiplier" ] = level.zombieHealthIncreaseMultiplier; + //base zombie health before any multipliers or additions + level.zombieHealthStart = getDvarIntDefault( "zombieHealthStart", 150 ); + level.zombie_vars[ "zombie_health_start" ] = level.zombieHealthStart; + //time before new runners spawn on early rounds + level.zombieNewRunnerInterval = getDvarIntDefault( "zombieNewRunnerInterval", 10 ); + level.zombie_vars[ "zombie_new_runner_interval" ] = level.zombieNewRunnerInterval; + //determines level.zombie_move_speed on original + level.zombieMoveSpeedMultiplier = getDvarIntDefault( "zombieMoveSpeedMultiplier", 10 ); + level.zombie_vars[ "zombie_move_speed_multiplier" ] = level.zombieMoveSpeedMultiplier; + //determines level.zombie_move_speed on easy + level.zombieMoveSpeedMultiplierEasy = getDvarIntDefault( "zombieMoveSpeedMultiplierEasy", 8 ); + level.zombie_vars[ "zombie_move_speed_multiplier_easy"] = level.zombieMoveSpeedMultiplierEasy; + //affects the number of zombies per round formula + level.zombieMaxAi = getDvarIntDefault( "zombieMaxAi", 24 ); + level.zombie_vars[ "zombie_max_ai" ] = level.zombieMaxAi; + //affects the check for zombies that have fallen thru the map + level.belowWorldCheck = getDvarIntDefault( "belowWorldCheck", -1000 ); + level.zombie_vars[ "below_world_check" ] = level.belowWorldCheck; + //sets whether spectators respawn at the end of the round + level.customSpectatorsRespawn = getDvarIntDefault( "customSpectatorsRespawn", 1 ); + level.zombie_vars[ "spectators_respawn" ] = level.customSpectatorsRespawn; + //sets the time that the game takes during the end game intermission + level.zombieIntermissionTime = getDvarIntDefault( "zombieIntermissionTime", 20 ); + level.zombie_vars["zombie_intermission_time"] = level.zombieIntermissionTime; + //the time between rounds + level.zombieBetweenRoundTime = getDvarIntDefault( "zombieBetweenRoundTime", 15 ); + level.zombie_vars["zombie_between_round_time"] = level.zombieBetweenRoundTime; + //time before the game starts + level.roundStartDelay = getDvarIntDefault( "roundStartDelay", 0 ); + level.zombie_vars[ "game_start_delay" ] = level.roundStartDelay; + //points all players lose when a player bleeds out %10 default + level.bleedoutPointsLostAllPlayers = getDvarFloatDefault( "bleedoutPointsLostAllPlayers", 0.1 ); + level.zombie_vars[ "penalty_no_revive" ] = level.bleedoutPointsLostAllPlayers; + //penalty to the player who died 10% of points by default + level.bleedoutPointsLostSelf = getDvarFloatDefault( "bleedoutPointsLostSelf", 0.1 ); + level.zombie_vars[ "penalty_died" ] = level.bleedoutPointsLostSelf; + //points players lose on down %5 by default + level.downedPointsLostSelf = getDvarFloatDefault( "downedPointsLostSelf", 0.05 ); + level.zombie_vars[ "penalty_downed" ] = level.downedPointsLostSelf; + //unknown + level.playerStartingLives = getDvarIntDefault( "playerStartingLives", 1 ); + level.zombie_vars[ "starting_lives" ] = level.playerStartingLives; + //points earned per zombie kill in a 4 player game + level.fourPlayerScorePerZombieKill = getDvarIntDefault( "fourPlayerScorePerZombieKill", 50 ); + level.zombie_vars[ "zombie_score_kill_4player" ] = level.fourPlayerScorePerZombieKill; + //points earned per zombie kill in a 3 player game + level.threePlayerScorePerZombieKill = getDvarIntDefault( "threePlayerScorePerZombieKill", 50 ); + level.zombie_vars[ "zombie_score_kill_3player" ] = level.threePlayerScorePerZombieKill; + //points earned per zombie kill in a 2 player game + level.twoPlayerScorePerZombieKill = getDvarIntDefault( "twoPlayerScorePerZombieKill", 50 ); + level.zombie_vars[ "zombie_score_kill_2player" ] = level.twoPlayerScorePerZombieKill; + //points earned per zombie kill in a 1 player game + level.onePlayerScorePerZombieKill = getDvarIntDefault( "onePlayerScorePerZombieKill", 50 ); + level.zombie_vars[ "zombie_score_kill_1player" ] = level.onePlayerScorePerZombieKill; + //points given for a normal attack + level.pointsPerNormalAttack = getDvarIntDefault( "pointsPerNormalAttack", 10 ); + level.zombie_vars[ "zombie_score_damage_normal" ] = level.pointsPerNormalAttack; + //points given for a light attack + level.pointsPerLightAttack = getDvarIntDefault( "pointsPerLightAttack", 10 ); + level.zombie_vars[ "zombie_score_damage_light" ] = level.pointsPerLightAttack; + //players turn into a zombie on death WARNING: buggy as can be and is missing assets + level.shouldZombifyPlayer = getDvarIntDefault( "shouldZombifyPlayer", 0 ); + level.zombie_vars[ "zombify_player" ] = level.shouldZombifyPlayer; + //points scalar for allies team + level.alliesPointsMultiplier = getDvarIntDefault( "alliesPointsMultiplier", 1 ); + level.zombie_vars[ "allies" ][ "zombie_point_scalar" ] = level.alliesPointsMultiplier; + //points scalar for axis team + level.axisPointsMultiplier = getDvarIntDefault( "axisPointsMultiplier", 1 ); + level.zombie_vars[ "axis" ][ "zombie_point_scalar" ] = level.axisPointsMultiplier; + //sets the radius of emps explosion lower this to 1 to render emps useless + level.empPerkExplosionRadius = getDvarIntDefault( "empPerkExplosionRadius", 420 ); + level.zombie_vars[ "emp_perk_off_range" ] = level.empPerkExplosionRadius; + //sets the duration of emps on perks set to 0 for infiinite emps + level.empPerkOffDuration = getDvarIntDefault( "empPerkOffDuration", 90 ); + level.zombie_vars[ "emp_perk_off_time" ] = level.empPerkOffDuration; + //riotshield health + level.riotshieldHitPoints = getDvarIntDefault( "riotshieldHitPoints", 2250 ); + level.zombie_vars[ "riotshield_hit_points" ] = level.riotshieldHitPoints; + //jugg health bonus + level.juggHealthBonus = getDvarIntDefault( "juggHealthBonus", 160 ); + level.zombie_vars[ "zombie_perk_juggernaut_health" ] = level.juggHealthBonus; + //perma jugg health bonus + level.permaJuggHealthBonus = getDvarIntDefault( "permaJuggHealthBonus", 190 ); + level.zombie_vars[ "zombie_perk_juggernaut_health_upgrade" ] = level.permaJuggHealthBonus; + //phd min explosion damage + level.minPhdExplosionDamage = getDvarIntDefault( "minPhdExplosionDamage", 1000 ); + level.zombie_vars[ "zombie_perk_divetonuke_min_damage" ] = level.minPhdExplosionDamage; + //phd max explosion damage + level.maxPhdExplosionDamage = getDvarIntDefault( "maxPhdExplosionDamage", 5000 ); + level.zombie_vars[ "zombie_perk_divetonuke_max_damage" ] = level.maxPhdExplosionDamage; + //phd explosion radius + level.phdDamageRadius = getDvarIntDefault( "phdDamageRadius", 300 ); + level.zombie_vars[ "zombie_perk_divetonuke_radius" ] = level.phdDamageRadius; + //zombie counter onscreen + level.enableZombieCounter = getDvarIntDefault( "enableZombieCounter", 1 ); + level.zombie_vars[ "enableZombieCounter" ] = level.enableZombieCounter; + //change mystery box price + level.customMysteryBoxPriceEnabled = getDvarIntDefault( "customMysteryBoxPriceEnabled", 0 ); + level.zombie_vars[ "customMysteryBoxPriceEnabled" ] = level.customMysteryBoxPriceEnabled; + //set mystery box price + level.customMysteryBoxPrice = getDvarIntDefault( "customMysteryBoxPrice", 500 ); + level.zombie_vars[ "customMysteryBoxPrice" ] = level.customMysteryBoxPrice; + //disable custom perks + level.disableAllCustomPerks = getDvarIntDefault( "disableAllCustomPerks", 0 ); + level.zombie_vars[ "disableAllCustomPerks" ] = level.disableAllCustomPerks; + //enable custom phdflopper + level.enablePHDFlopper = getDvarIntDefault( "enablePHDFlopper", 1 ); + level.zombie_vars[ "enablePHDFlopper" ] = level.enablePHDFlopper; + //enable custom staminup + level.enableStaminUp = getDvarIntDefault( "enableStaminUp", 1 ); + level.zombie_vars[ "enableStaminUp" ] = level.enableStaminUp; + //enable custom deadshot + level.enableDeadshot = getDvarIntDefault( "enableDeadshot", 1 ); + level.zombie_vars[ "enableDeadshot" ] = level.enableDeadshot; + //enable custom mule kick + level.enableMuleKick = getDvarIntDefault( "enableMuleKick", 1 ); + level.zombie_vars[ "enableMuleKick" ] = level.enableMuleKick; + disable_specific_powerups(); + checks(); + thread zombies_always_drop_powerups(); + thread zombies_per_round_override(); + thread zombie_health_override(); + thread zombie_health_cap_override(); + thread zombie_spawn_delay_fix(); + thread zombie_speed_fix(); +} + +trackPackAPunchDrops() +{ + level endon("end_game"); + level.rounds_since_last_pack_a_punch = 0; + for(;;) + { + level waittill("start_of_round"); + level.rounds_since_last_pack_a_punch_drop += 1; + wait 0.5; + } +} + +gscRestart() +{ + level waittill( "end_game" ); + wait 15; + map_restart( false ); +} + +setPlayersToSpectator() +{ + level.no_end_game_check = 1; + wait 3; + players = get_players(); + i = 0; + while ( i < players.size ) + { + if ( i == 0 ) + { + i++; + } + players[ i ] setToSpectator(); + i++; + } + wait 5; + spawnAllPlayers(); +} + +setToSpectator() +{ + self.sessionstate = "spectator"; + if (isDefined(self.is_playing)) + { + self.is_playing = false; + } +} + +spawnAllPlayers() +{ + players = get_players(); + i = 0; + while ( i < players.size ) + { + if ( players[ i ].sessionstate == "spectator" && isDefined( players[ i ].spectator_respawn ) ) + { + players[ i ] [[ level.spawnplayer ]](); + if ( level.script != "zm_tomb" || level.script != "zm_prison" || !is_classic() ) + { + thread maps\mp\zombies\_zm::refresh_player_navcard_hud(); + } + } + i++; + } + level.no_end_game_check = 0; +} + +disable_all_powerups() +{ + if ( level.zmPowerupsNoPowerupDrops ) + { + flag_clear( "zombie_drop_powerups" ); + } +} + +zombies_always_drop_powerups() +{ + if ( !level.zombiesAlwaysDropPowerups ) + { + return; + } + while ( 1 ) + { + level.zombie_vars[ "zombie_drop_item" ] = level.zombiesAlwaysDropPowerups; + wait 0.05; + } +} + +zombies_per_round_override() +{ + if ( !level.overrideZombieTotalPermanently ) + { + return; + } + while ( 1 ) + { + level waittill( "start_of_round" ); + level.zombie_total = getDvarIntDefault( "overrideZombieTotalPermanentlyValue", 6 ); + } +} + +zombie_health_override() +{ + if ( !level.overrideZombieHealthPermanently ) + { + return; + } + while ( 1 ) + { + level waittill( "start_of_round" ); + level.zombie_health = getDvarIntDefault( "overrideZombieHealthPermanentlyValue", 150 ); + } +} + +zombie_health_cap_override() +{ + if ( !level.overrideZombieMaxHealth ) + { + return; + } + while ( 1 ) + { + level waittill( "start_of_round" ); + if ( level.zombie_health > level.overrideZombieMaxHealthValue ) + { + level.zombie_health = getDvarIntDefault( "overrideZombieHealthMaxHealthValue", 150 ); + } + } +} + +zombie_spawn_delay_fix() +{ + if ( level.zombieSpawnRateLocked ) + { + return; + } + i = 1; + while ( i <= level.round_number ) + { + timer = level.zombieSpawnRate; + if ( timer > 0.08 ) + { + level.zombieSpawnRate = timer * level.zombieSpawnRateMultiplier; + i++; + continue; + } + else if ( timer < 0.08 ) + { + level.zombieSpawnRate = 0.08; + break; + } + i++; + } + while ( 1 ) + { + level waittill( "start_of_round" ); + if ( level.zombieSpawnRate > 0.08 ) + { + level.zombieSpawnRate = level.zombieSpawnRate * level.zombieSpawnRateMultiplier; + } + level.zombie_vars[ "zombie_spawn_delay" ] = level.zombieSpawnRate; + } +} + +zombie_speed_fix() +{ + if ( level.zombieMoveSpeedLocked ) + { + return; + } + if ( level.gamedifficulty == 0 ) + { + level.zombie_move_speed = level.round_number * level.zombie_vars[ "zombie_move_speed_multiplier_easy" ]; + } + else + { + level.zombie_move_speed = level.round_number * level.zombie_vars[ "zombie_move_speed_multiplier" ]; + } +} + +zombie_speed_override() +{ + if ( !level.zombieMoveSpeedLocked ) + { + return; + } + while ( 1 ) + { + level waittill( "start_of_round" ); + level.zombie_move_speed = getDvarIntDefault( "zombieMoveSpeed", 1 ); + } +} + +zombie_speed_cap_override() +{ + if ( !level.zombieMoveSpeedCap ) + { + return; + } + while ( 1 ) + { + level waittill( "start_of_round" ); + if ( level.zombie_move_speed > level.zombieMoveSpeedCapValue ) + { + level.zombie_move_speed = level.zombieMoveSpeedCapValue; + } + } +} + +checks() +{ + if( level.customMysteryBoxPriceEnabled == 1) //custom mystery box price + { + level thread setMysteryBoxPrice(); + } + if( level.enableZombieCounter == 1 ) //draw zombie counter + { + level thread drawZombiesCounter(); //credit carbonmodding + } + if ( level.mixed_rounds_enabled ) + { + if ( level.script != "zm_transit" || is_classic() || level.scr_zm_ui_gametype == "zgrief" ) + { + level.mixed_rounds_enabled = 0; + } + } + + if ( level.start_weapon == "" || level.start_weapon== "m1911_zm" ) + { + level.start_weapon = "m1911_zm"; + if ( level.script == "zm_tomb" ) + { + level.start_weapon = "c96_zm"; + } + } + if ( level.default_laststandpistol == "" || level.default_laststandpistol == "m1911_zm" ) + { + level.default_laststandpistol = "m1911_zm"; + if ( level.script == "zm_tomb" ) + { + level.default_laststandpistol = "c96_zm"; + } + } + if ( level.default_solo_laststandpistol == "" || level.default_solo_laststandpistol == "m1911_upgraded_zm" ) + { + level.default_solo_laststandpistol = "m1911_upgraded_zm"; + if ( level.script == "zm_tomb" ) + { + level.default_solo_laststandpistol = "c96_upgraded_zm"; + } + } + +} + +disable_specific_powerups() +{ + level.powerupNames = array( "fast_feet", "unlimited_ammo", "pack_a_punch", "money_drop", "nuke", "insta_kill", "full_ammo", "double_points", "fire_sale", "free_perk", "carpenter" ); + array = level.powerupNames; + //custom powerups and regular powerups + level.zmPowerupsEnabled = []; + //fast feet custom drop + level.zmPowerupsEnabled[ "fast_feet" ] = spawnstruct(); + level.zmPowerupsEnabled[ "fast_feet" ].name = "fast_feet"; + level.zmPowerupsEnabled[ "fast_feet" ].active = getDvarIntDefault( "zmPowerupsFastFeetEnabled", 1 ); + //custom unlimited ammo drop + level.zmPowerupsEnabled[ "unlimited_ammo" ] = spawnstruct(); + level.zmPowerupsEnabled[ "unlimited_ammo" ].name = "unlimited_ammo"; + level.zmPowerupsEnabled[ "unlimited_ammo" ].active = getDvarIntDefault( "zmPowerupsUnlimitedAmmoEnabled", 1 ); + //custom pack a punch drop + level.zmPowerupsEnabled[ "pack_a_punch" ] = spawnstruct(); + level.zmPowerupsEnabled[ "pack_a_punch" ].name = "pack_a_punch"; + level.zmPowerupsEnabled[ "pack_a_punch" ].active = getDvarIntDefault( "zmPowerupsPackAPunchEnabled", 1 ); + //custom money drop + level.zmPowerupsEnabled[ "money_drop" ] = spawnstruct(); + level.zmPowerupsEnabled[ "money_drop" ].name = "money_drop"; + level.zmPowerupsEnabled[ "money_drop" ].active = getDvarIntDefault( "zmPowerupsMoneyDropEnabled", 1 ); + //nuke + level.zmPowerupsEnabled[ "nuke" ] = spawnstruct(); + level.zmPowerupsEnabled[ "nuke" ].name = "nuke"; + level.zmPowerupsEnabled[ "nuke" ].active = getDvarIntDefault( "zmPowerupsNukeEnabled", 1 ); + //remove insta kills from the drop cycle and special drops + level.zmPowerupsEnabled[ "insta_kill" ] = spawnstruct(); + level.zmPowerupsEnabled[ "insta_kill" ].name = "insta_kill"; + level.zmPowerupsEnabled[ "insta_kill" ].active = getDvarIntDefault( "zmPowerupsInstaKillEnabled", 1 ); + //remove max ammos from the drop cycle and special drops + level.zmPowerupsEnabled[ "full_ammo" ] = spawnstruct(); + level.zmPowerupsEnabled[ "full_ammo" ].name = "full_ammo"; + level.zmPowerupsEnabled[ "full_ammo" ].active = getDvarIntDefault( "zmPowerupsMaxAmmoEnabled", 1 ); + //remove carpenter from the drop cycle and special drops + level.zmPowerupsEnabled[ "double_points" ] = spawnstruct(); + level.zmPowerupsEnabled[ "double_points" ].name = "double_points"; + level.zmPowerupsEnabled[ "double_points" ].active = getDvarIntDefault( "zmPowerupsDoublePointsEnabled", 1 ); + //remove fire sale from the drop cycle and special drops NOTE: fire sale isn't on all maps already this being enabled won't make it spawn + level.zmPowerupsEnabled[ "fire_sale" ] = spawnstruct(); + level.zmPowerupsEnabled[ "fire_sale" ].name = "fire_sale"; + level.zmPowerupsEnabled[ "fire_sale" ].active = getDvarIntDefault( "zmPowerupsFireSaleEnabled", 1 ); + //remove the perk bottle from the drop cycle and special drops + level.zmPowerupsEnabled[ "free_perk" ] = spawnstruct(); + level.zmPowerupsEnabled[ "free_perk" ].name = "free_perk"; + level.zmPowerupsEnabled[ "free_perk" ].active = getDvarIntDefault( "zmPowerupsPerkBottleEnabled", 1 ); + //removes carpenter from the drop cycle and special drops + level.zmPowerupsEnabled[ "carpenter" ] = spawnstruct(); + level.zmPowerupsEnabled[ "carpenter" ].name = "carpenter"; + level.zmPowerupsEnabled[ "carpenter" ].active = getDvarIntDefault( "zmPowerupsCarpenterEnabled", 1 ); + //removes zombie blood from the drop cycle and special drops + level.zmPowerupsEnabled[ "zombie_blood" ] = spawnstruct(); + level.zmPowerupsEnabled[ "zombie_blood" ].name = "zombie_blood"; + level.zmPowerupsEnabled[ "zombie_blood" ].active = getDvarIntDefault( "zmPowerupsZombieBloodEnabled", 1 ); + + //you can expand this list with custom powerups if you'd like just add a new spawnstruct() and add to the array at the top + + for ( i = 0; i < array.size; i++ ) + { + if ( !level.zmPowerupsEnabled[ array[ i ] ].active ) + { + name = level.zmPowerupsEnabled[ array[ i ] ].name; + if ( isInArray( level.zombie_include_powerups, name ) ) + { + arrayremovevalue( level.zombie_include_powerups, name ); + } + if ( isInArray( level.zombie_powerups, name ) ) + { + arrayremovevalue( level.zombie_powerups, name ); + } + if ( isInArray( level.zombie_powerup_array, name ) ) + { + arrayremovevalue( level.zombie_powerup_array, name ); + } + } + } +} + +drawZombiesCounter() +{ + level.zombiesCounter = createServerFontString("hudsmall" , 1.9); + level.zombiesCounter setPoint("CENTER", "CENTER", "CENTER", 190); + while(true) + { + enemies = get_round_enemy_array().size + level.zombie_total; + if( enemies != 0 ) + level.zombiesCounter.label = &"Zombies: ^1"; + else + level.zombiesCounter.label = &"Zombies: ^6"; + level.zombiesCounter setValue( enemies ); + wait 0.05; + } +} + +setMysteryBoxPrice() //mystery box price +{ + i = 0; + while (i < level.chests.size) + { + level.chests[ i ].zombie_cost = level.customMysteryBoxPrice; + level.chests[ i ].old_cost = level.customMysteryBoxPrice; + i++; + } +} + +spawnIfRoundOne() //spawn player +{ + wait 3; + if ( self.sessionstate == "spectator" && level.round_number == 1 ) + self iprintln("Get ready to be spawned!"); + wait 5; + if ( self.sessionstate == "spectator" && level.round_number == 1 ) + { + self [[ level.spawnplayer ]](); + if ( level.script != "zm_tomb" || level.script != "zm_prison" || !is_classic() ) + thread maps\mp\zombies\_zm::refresh_player_navcard_hud(); + } +} + +solo_tombstone_removal() +{ + notify( "tombstone_on" ); +} + +turn_tombstone_on() +{ + while ( 1 ) + { + machine = getentarray( "vending_tombstone", "targetname" ); + machine_triggers = getentarray( "vending_tombstone", "target" ); + i = 0; + while ( i < machine.size ) + { + machine[ i ] setmodel( level.machine_assets[ "tombstone" ].off_model ); + i++; + } + level thread do_initial_power_off_callback( machine, "tombstone" ); + array_thread( machine_triggers, ::set_power_on, 0 ); + level waittill( "tombstone_on" ); + i = 0; + while ( i < machine.size ) + { + machine[ i ] setmodel( level.machine_assets[ "tombstone" ].on_model ); + machine[ i ] vibrate( vectorScale( ( 0, -1, 0 ), 100 ), 0,3, 0,4, 3 ); + machine[ i ] playsound( "zmb_perks_power_on" ); + machine[ i ] thread perk_fx( "tombstone_light" ); + machine[ i ] thread play_loop_on_machine(); + i++; + } + level notify( "specialty_scavenger_power_on" ); + array_thread( machine_triggers, ::set_power_on, 1 ); + if ( isDefined( level.machine_assets[ "tombstone" ].power_on_callback ) ) + { + array_thread( machine, level.machine_assets[ "tombstone" ].power_on_callback ); + } + level waittill( "tombstone_off" ); + if ( isDefined( level.machine_assets[ "tombstone" ].power_off_callback ) ) + { + array_thread( machine, level.machine_assets[ "tombstone" ].power_off_callback ); + } + array_thread( machine, ::turn_perk_off ); + players = get_players(); + _a1718 = players; + _k1718 = getFirstArrayKey( _a1718 ); + while ( isDefined( _k1718 ) ) + { + player = _a1718[ _k1718 ]; + player.hasperkspecialtytombstone = undefined; + _k1718 = getNextArrayKey( _a1718, _k1718 ); + } + } +} + +perk_machine_spawn_init() +{ + match_string = ""; + location = level.scr_zm_map_start_location; + if ( location != "default" && location == "" && isDefined( level.default_start_location ) ) + { + location = level.default_start_location; + } + match_string = ( level.scr_zm_ui_gametype + "_perks_" ) + location; + pos = []; + if ( isDefined( level.override_perk_targetname ) ) + { + structs = getstructarray( level.override_perk_targetname, "targetname" ); + } + else + { + structs = getstructarray( "zm_perk_machine", "targetname" ); + } + _a3578 = structs; + _k3578 = getFirstArrayKey( _a3578 ); + while ( isDefined( _k3578 ) ) + { + struct = _a3578[ _k3578 ]; + if ( isDefined( struct.script_string ) ) + { + tokens = strtok( struct.script_string, " " ); + _a3583 = tokens; + _k3583 = getFirstArrayKey( _a3583 ); + while ( isDefined( _k3583 ) ) + { + token = _a3583[ _k3583 ]; + if ( token == match_string ) + { + pos[ pos.size ] = struct; + } + _k3583 = getNextArrayKey( _a3583, _k3583 ); + } + } + else pos[ pos.size ] = struct; + _k3578 = getNextArrayKey( _a3578, _k3578 ); + } + if ( !isDefined( pos ) || pos.size == 0 ) + { + return; + } + precachemodel( "zm_collision_perks1" ); + i = 0; + while ( i < pos.size ) + { + perk = pos[ i ].script_noteworthy; + if ( isDefined( perk ) && isDefined( pos[ i ].model ) ) + { + use_trigger = spawn( "trigger_radius_use", pos[ i ].origin + vectorScale( ( 0, -1, 0 ), 30 ), 0, 40, 70 ); + use_trigger.targetname = "zombie_vending"; + use_trigger.script_noteworthy = perk; + use_trigger triggerignoreteam(); + perk_machine = spawn( "script_model", pos[ i ].origin ); + perk_machine.angles = pos[ i ].angles; + perk_machine setmodel( pos[ i ].model ); + if ( isDefined( level._no_vending_machine_bump_trigs ) && level._no_vending_machine_bump_trigs ) + { + bump_trigger = undefined; + } + else + { + bump_trigger = spawn( "trigger_radius", pos[ i ].origin, 0, 35, 64 ); + bump_trigger.script_activated = 1; + bump_trigger.script_sound = "zmb_perks_bump_bottle"; + bump_trigger.targetname = "audio_bump_trigger"; + if ( perk != "specialty_weapupgrade" ) + { + bump_trigger thread thread_bump_trigger(); + } + } + collision = spawn( "script_model", pos[ i ].origin, 1 ); + collision.angles = pos[ i ].angles; + collision setmodel( "zm_collision_perks1" ); + collision.script_noteworthy = "clip"; + collision disconnectpaths(); + use_trigger.clip = collision; + use_trigger.machine = perk_machine; + use_trigger.bump = bump_trigger; + if ( isDefined( pos[ i ].blocker_model ) ) + { + use_trigger.blocker_model = pos[ i ].blocker_model; + } + if ( isDefined( pos[ i ].script_int ) ) + { + perk_machine.script_int = pos[ i ].script_int; + } + if ( isDefined( pos[ i ].turn_on_notify ) ) + { + perk_machine.turn_on_notify = pos[ i ].turn_on_notify; + } + if ( perk == "specialty_scavenger" || perk == "specialty_scavenger_upgrade" ) + { + use_trigger.script_sound = "mus_perks_tombstone_jingle"; + use_trigger.script_string = "tombstone_perk"; + use_trigger.script_label = "mus_perks_tombstone_sting"; + use_trigger.target = "vending_tombstone"; + perk_machine.script_string = "tombstone_perk"; + perk_machine.targetname = "vending_tombstone"; + if ( isDefined( bump_trigger ) ) + { + bump_trigger.script_string = "tombstone_perk"; + } + } + if ( isDefined( level._custom_perks[ perk ] ) && isDefined( level._custom_perks[ perk ].perk_machine_set_kvps ) ) + { + [[ level._custom_perks[ perk ].perk_machine_set_kvps ]]( use_trigger, perk_machine, bump_trigger, collision ); + } + } + i++; + } +} + +isTown() +{ + if (isDefined(level.zombiemode_using_tombstone_perk) && level.zombiemode_using_tombstone_perk) + { + level thread perk_machine_spawn_init(); + thread solo_tombstone_removal(); + thread turn_tombstone_on(); + } +} diff --git a/zomb++ (UPDATE)/Source Code/_zm_powerups.gsc b/zomb++ (UPDATE)/Source Code/_zm_powerups.gsc new file mode 100644 index 0000000..efcfc21 --- /dev/null +++ b/zomb++ (UPDATE)/Source Code/_zm_powerups.gsc @@ -0,0 +1,3124 @@ +#include maps/mp/zombies/_zm_melee_weapon; +#include maps/mp/zombies/_zm_weapons; +#include maps/mp/zombies/_zm_perks; +#include maps/mp/gametypes_zm/_hud_util; +#include maps/mp/zombies/_zm_pers_upgrades_functions; +#include maps/mp/zombies/_zm_spawner; +#include maps/mp/animscripts/zm_death; +#include maps/mp/zombies/_zm_score; +#include maps/mp/zombies/_zm_powerups; +#include maps/mp/zombies/_zm_blockers; +#include maps/mp/zombies/_zm_audio_announcer; +#include maps/mp/zombies/_zm_stats; +#include maps/mp/zombies/_zm_pers_upgrades; +#include maps/mp/zombies/_zm_laststand; +#include maps/mp/_demo; +#include maps/mp/zombies/_zm_magicbox; +#include maps/mp/zombies/_zm_audio; +#include maps/mp/zombies/_zm_net; +#include maps/mp/zombies/_zm_utility; +#include maps/mp/_utility; +#include common_scripts/utility; +#include maps/mp/zombies/_zm; +#include maps/mp/gametypes_zm/_hud_message; +#include maps/mp/zombies/_zm_audio; +#include maps/mp/zombies/_zm_score; + +init() +{ + precacheshader( "specialty_doublepoints_zombies" ); + precacheshader( "specialty_instakill_zombies" ); + precacheshader( "specialty_firesale_zombies" ); + precacheshader( "zom_icon_bonfire" ); + precacheshader( "zom_icon_minigun" ); + precacheshader( "black" ); + set_zombie_var( "zombie_insta_kill", 0, undefined, undefined, 1 ); + set_zombie_var( "zombie_point_scalar", 1, undefined, undefined, 1 ); + set_zombie_var( "zombie_drop_item", 0 ); + set_zombie_var( "zombie_timer_offset", 350 ); + set_zombie_var( "zombie_timer_offset_interval", 30 ); + set_zombie_var( "zombie_powerup_fire_sale_on", 0 ); + set_zombie_var( "zombie_powerup_fire_sale_time", 30 ); + set_zombie_var( "zombie_powerup_bonfire_sale_on", 0 ); + set_zombie_var( "zombie_powerup_bonfire_sale_time", 30 ); + set_zombie_var( "zombie_powerup_insta_kill_on", 0, undefined, undefined, 1 ); + set_zombie_var( "zombie_powerup_insta_kill_time", 30, undefined, undefined, 1 ); + set_zombie_var( "zombie_powerup_point_doubler_on", 0, undefined, undefined, 1 ); + set_zombie_var( "zombie_powerup_point_doubler_time", 30, undefined, undefined, 1 ); + set_zombie_var( "zombie_powerup_drop_increment", 2000 ); + set_zombie_var( "zombie_powerup_drop_max_per_round", 4 ); + if ( level.debugLogging_zm_powerups ) + { + level.maxPowerupsPerRound = getDvarIntDefault( "maxPowerupsPerRound", 4 ); + level.zombie_vars["zombie_powerup_drop_max_per_round"] = level.maxPowerupsPerRound; + } + onplayerconnect_callback( ::init_player_zombie_vars ); + level._effect[ "powerup_on" ] = loadfx( "misc/fx_zombie_powerup_on" ); + level._effect[ "powerup_off" ] = loadfx( "misc/fx_zombie_powerup_off" ); + level._effect[ "powerup_grabbed" ] = loadfx( "misc/fx_zombie_powerup_grab" ); + level._effect[ "powerup_grabbed_wave" ] = loadfx( "misc/fx_zombie_powerup_wave" ); + if ( isDefined( level.using_zombie_powerups ) && level.using_zombie_powerups ) + { + level._effect[ "powerup_on_red" ] = loadfx( "misc/fx_zombie_powerup_on_red" ); + level._effect[ "powerup_grabbed_red" ] = loadfx( "misc/fx_zombie_powerup_red_grab" ); + level._effect[ "powerup_grabbed_wave_red" ] = loadfx( "misc/fx_zombie_powerup_red_wave" ); + } + level._effect[ "powerup_on_solo" ] = loadfx( "misc/fx_zombie_powerup_solo_on" ); + level._effect[ "powerup_grabbed_solo" ] = loadfx( "misc/fx_zombie_powerup_solo_grab" ); + level._effect[ "powerup_grabbed_wave_solo" ] = loadfx( "misc/fx_zombie_powerup_solo_wave" ); + level._effect[ "powerup_on_caution" ] = loadfx( "misc/fx_zombie_powerup_caution_on" ); + level._effect[ "powerup_grabbed_caution" ] = loadfx( "misc/fx_zombie_powerup_caution_grab" ); + level._effect[ "powerup_grabbed_wave_caution" ] = loadfx( "misc/fx_zombie_powerup_caution_wave" ); + init_powerups(); + init_custom_powerups(); + if ( !level.enable_magic ) + { + return; + } + thread watch_for_drop(); + thread setup_firesale_audio(); + thread setup_bonfiresale_audio(); + level.use_new_carpenter_func = ::start_carpenter_new; + level.board_repair_distance_squared = 562500; + level thread track_pack_a_punch_drops(); + level thread onplayerconnecting_powerups(); +} + +onplayerconnecting_powerups() +{ + for(;;) + { + level waittill( "connecting", player ); + player thread startCustomPowerups(); + } +} + +custom_powerup_grab(powerup, player) //credit to _Ox much thx for powerup functions +{ + if(powerup.powerup_name == "money_drop") + player thread doRandomScore(); + else if(powerup.powerup_name == "pack_a_punch") + player thread doPackAPunchWeapon(); + else if(powerup.powerup_name == "unlimited_ammo") + player thread doUnlimitedAmmo(); + else if(powerup.powerup_name == "fast_feet") + player thread doFastFeet(); + else if (isDefined(level.original_zombiemode_powerup_grab)) + level thread [[level.original_zombiemode_powerup_grab]](powerup, player); +} + +startCustomPowerups() +{ + if(!isDefined(level.custompowerupinit)) + { + level.custompowerupinit = true; + wait 2; + if(isDefined(level._zombiemode_powerup_grab)) + level.original_zombiemode_powerup_grab = level._zombiemode_powerup_grab; + wait 2; + level._zombiemode_powerup_grab = ::custom_powerup_grab; + } +} + +init_custom_powerups() //credit goes to _Ox for most code +{ + level.unlimited_ammo_duration = 20; + include_zombie_powerup("unlimited_ammo"); + add_zombie_powerup("unlimited_ammo", "T6_WPN_AR_GALIL_WORLD", &"ZOMBIE_POWERUP_UNLIMITED_AMMO", ::func_should_always_drop, 0, 0, 0); + powerup_set_can_pick_up_in_last_stand("unlimited_ammo", 1); + if(getDvar("mapname") == "zm_prison") + { + + include_zombie_powerup("fast_feet"); + add_zombie_powerup("fast_feet", "bottle_whisky_01", &"ZOMBIE_POWERUP_FAST_FEET", ::func_should_always_drop, 0, 0, 0); + powerup_set_can_pick_up_in_last_stand("fast_feet", 1); + + include_zombie_powerup("pack_a_punch"); + 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); + powerup_set_can_pick_up_in_last_stand("pack_a_punch", 0); + + include_zombie_powerup("money_drop"); + add_zombie_powerup("money_drop", "p6_anim_zm_al_magic_box_lock_red", &"ZOMBIE_POWERUP_MONEY_DROP", ::func_should_always_drop, 0, 0, 0); + powerup_set_can_pick_up_in_last_stand("money_drop", 1); + } + else if ( level.script == "zm_nuked" ) + { + include_zombie_powerup("fast_feet"); + add_zombie_powerup("fast_feet", "t6_wpn_zmb_perk_bottle_doubletap_world", &"ZOMBIE_POWERUP_FAST_FEET", ::func_should_always_drop, 0, 0, 0); + powerup_set_can_pick_up_in_last_stand("fast_feet", 1); + + include_zombie_powerup("pack_a_punch"); + 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); + powerup_set_can_pick_up_in_last_stand("pack_a_punch", 0); + + include_zombie_powerup("money_drop"); + add_zombie_powerup("money_drop", "zombie_teddybear", &"ZOMBIE_POWERUP_MONEY_DROP", ::func_should_always_drop, 0, 0, 0); + powerup_set_can_pick_up_in_last_stand("money_drop", 1); + } + else + { + include_zombie_powerup("fast_feet"); + add_zombie_powerup("fast_feet", "zombie_pickup_perk_bottle", &"ZOMBIE_POWERUP_FAST_FEET", ::func_should_always_drop, 0, 0, 0); + powerup_set_can_pick_up_in_last_stand("fast_feet", 1); + + include_zombie_powerup("pack_a_punch"); + 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); + powerup_set_can_pick_up_in_last_stand("pack_a_punch", 0); + + include_zombie_powerup("money_drop"); + add_zombie_powerup("money_drop", "zombie_teddybear", &"ZOMBIE_POWERUP_MONEY_DROP", ::func_should_always_drop, 0, 0, 0); + powerup_set_can_pick_up_in_last_stand("money_drop", 1); + } +} + +init_powerups() +{ + flag_init( "zombie_drop_powerups" ); + level.unlimited_ammo_duration = 20; + if ( isDefined( level.enable_magic ) && level.enable_magic ) + { + flag_set( "zombie_drop_powerups" ); + } + if ( !isDefined( level.active_powerups ) ) + { + level.active_powerups = []; + } + if ( !isDefined( level.zombie_powerup_array ) ) + { + level.zombie_powerup_array = []; + } + if ( !isDefined( level.zombie_special_drop_array ) ) + { + level.zombie_special_drop_array = []; + } + add_zombie_powerup( "nuke", "zombie_bomb", &"ZOMBIE_POWERUP_NUKE", ::func_should_always_drop, 0, 0, 0, "misc/fx_zombie_mini_nuke_hotness" ); + 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" ); + add_zombie_powerup( "full_ammo", "zombie_ammocan", &"ZOMBIE_POWERUP_MAX_AMMO", ::func_should_always_drop, 0, 0, 0 ); + 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" ); + add_zombie_powerup( "carpenter", "zombie_carpenter", &"ZOMBIE_POWERUP_MAX_AMMO", ::func_should_drop_carpenter, 0, 0, 0 ); + 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" ); + 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" ); + 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" ); + add_zombie_powerup( "free_perk", "zombie_pickup_perk_bottle", &"ZOMBIE_POWERUP_FREE_PERK", ::func_should_never_drop, 0, 0, 0 ); + 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" ); + add_zombie_powerup( "random_weapon", "zombie_pickup_minigun", &"ZOMBIE_POWERUP_MAX_AMMO", ::func_should_never_drop, 1, 0, 0 ); + add_zombie_powerup( "bonus_points_player", "zombie_z_money_icon", &"ZOMBIE_POWERUP_BONUS_POINTS", ::func_should_never_drop, 1, 0, 0 ); + add_zombie_powerup( "bonus_points_team", "zombie_z_money_icon", &"ZOMBIE_POWERUP_BONUS_POINTS", ::func_should_never_drop, 0, 0, 0 ); + add_zombie_powerup( "lose_points_team", "zombie_z_money_icon", &"ZOMBIE_POWERUP_LOSE_POINTS", ::func_should_never_drop, 0, 0, 1 ); + add_zombie_powerup( "lose_perk", "zombie_pickup_perk_bottle", &"ZOMBIE_POWERUP_MAX_AMMO", ::func_should_never_drop, 0, 0, 1 ); + add_zombie_powerup( "empty_clip", "zombie_ammocan", &"ZOMBIE_POWERUP_MAX_AMMO", ::func_should_never_drop, 0, 0, 1 ); + 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 ); + if ( isDefined( level.level_specific_init_powerups ) ) + { + [[ level.level_specific_init_powerups ]](); + } + randomize_powerups(); + level.zombie_powerup_index = 0; + randomize_powerups(); + level.rare_powerups_active = 0; + level.firesale_vox_firstime = 0; + level thread powerup_hud_monitor(); + if ( isDefined( level.quantum_bomb_register_result_func ) ) + { + [[ level.quantum_bomb_register_result_func ]]( "random_powerup", ::quantum_bomb_random_powerup_result, 5, level.quantum_bomb_in_playable_area_validation_func ); + [[ 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 ); + [[ level.quantum_bomb_register_result_func ]]( "random_weapon_powerup", ::quantum_bomb_random_weapon_powerup_result, 60, level.quantum_bomb_in_playable_area_validation_func ); + [[ 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 ); + } + registerclientfield( "scriptmover", "powerup_fx", 1000, 3, "int" ); +} + +init_player_zombie_vars() //checked matches cerberus output +{ + self.zombie_vars[ "zombie_powerup_minigun_on" ] = 0; + self.zombie_vars[ "zombie_powerup_minigun_time" ] = 0; + self.zombie_vars[ "zombie_powerup_tesla_on" ] = 0; + self.zombie_vars[ "zombie_powerup_tesla_time" ] = 0; + self.zombie_vars[ "zombie_powerup_insta_kill_ug_on" ] = 0; + self.zombie_vars[ "zombie_powerup_insta_kill_ug_time" ] = 18; +} + +set_weapon_ignore_max_ammo( str_weapon ) //checked matches cerberus output +{ + if ( !isDefined( level.zombie_weapons_no_max_ammo ) ) + { + level.zombie_weapons_no_max_ammo = []; + } + level.zombie_weapons_no_max_ammo[ str_weapon ] = 1; +} + +powerup_hud_monitor() //checked partially changed to match cerberus output +{ + flag_wait( "start_zombie_round_logic" ); + if ( isDefined( level.current_game_module ) && level.current_game_module == 2 ) + { + return; + } + flashing_timers = []; + flashing_values = []; + flashing_timer = 10; + flashing_delta_time = 0; + flashing_is_on = 0; + flashing_value = 3; + flashing_min_timer = 0.15; + while ( flashing_timer >= flashing_min_timer ) + { + if ( flashing_timer < 5 ) + { + flashing_delta_time = 0.1; + } + else + { + flashing_delta_time = 0.2; + } + if ( flashing_is_on ) + { + flashing_timer = flashing_timer - flashing_delta_time - 0.05; + flashing_value = 2; + } + else + { + flashing_timer -= flashing_delta_time; + flashing_value = 3; + } + flashing_timers[ flashing_timers.size ] = flashing_timer; + flashing_values[ flashing_values.size ] = flashing_value; + flashing_is_on = !flashing_is_on; + } + client_fields = []; + powerup_keys = getarraykeys( level.zombie_powerups ); + for ( powerup_key_index = 0; powerup_key_index < powerup_keys.size; powerup_key_index++ ) + { + if ( isDefined( level.zombie_powerups[ powerup_keys[ powerup_key_index ] ].client_field_name ) ) + { + powerup_name = powerup_keys[ powerup_key_index ]; + client_fields[ powerup_name ] = spawnstruct(); + client_fields[ powerup_name ].client_field_name = level.zombie_powerups[ powerup_name ].client_field_name; + client_fields[ powerup_name ].solo = level.zombie_powerups[ powerup_name ].solo; + client_fields[ powerup_name ].time_name = level.zombie_powerups[ powerup_name ].time_name; + client_fields[ powerup_name ].on_name = level.zombie_powerups[ powerup_name ].on_name; + } + } + client_field_keys = getarraykeys( client_fields ); + + while ( 1 ) + { + wait 0.05; + waittillframeend; + players = get_players(); + + for ( playerindex = 0; playerindex < players.size; playerindex++ ) + { + client_field_key_index = 0; + while ( client_field_key_index < client_field_keys.size ) + { + + player = players[ playerindex ]; + if ( isdefined(level.powerup_player_valid ) ) + { + if ( ![[ level.powerup_player_valid ]]( player ) ) + { + client_field_key_index++; + continue; + } + } + + client_field_name = client_fields[ client_field_keys[ client_field_key_index ] ].client_field_name; + time_name = client_fields[ client_field_keys[ client_field_key_index ] ].time_name; + on_name = client_fields[ client_field_keys[ client_field_key_index ] ].on_name; + powerup_timer = undefined; + powerup_on = undefined; + if ( client_fields[ client_field_keys[ client_field_key_index ] ].solo ) + { + if ( isdefined( player._show_solo_hud ) && player._show_solo_hud == 1 ) + { + powerup_timer = player.zombie_vars[ time_name ]; + powerup_on = player.zombie_vars[ on_name ]; + } + } + + else if ( isdefined( level.zombie_vars[ player.team ][ time_name ] ) ) + { + powerup_timer = level.zombie_vars[ player.team ][ time_name ]; + powerup_on = level.zombie_vars[ player.team ][on_name ]; + } + else if ( isdefined( level.zombie_vars[ time_name ] ) ) + { + powerup_timer = level.zombie_vars[ time_name ]; + powerup_on = level.zombie_vars[ on_name ]; + } + + if ( isdefined( powerup_timer ) && isdefined( powerup_on ) ) + { + player set_clientfield_powerups( client_field_name, powerup_timer, powerup_on, flashing_timers, flashing_values ); + } + else + { + player setclientfieldtoplayer( client_field_name, 0 ); + } + client_field_key_index++; + } + } + + } +} + +set_clientfield_powerups( clientfield_name, powerup_timer, powerup_on, flashing_timers, flashing_values ) //checked changed to match cerberus output +{ + if ( powerup_on ) + { + if ( powerup_timer < 10 ) + { + flashing_value = 3; + for ( i = flashing_timers.size - 1; i > 0; i-- ) + { + if ( powerup_timer < flashing_timers[ i ] ) + { + flashing_value = flashing_values[ i ]; + break; + } + } + self setclientfieldtoplayer( clientfield_name, flashing_value ); + } + else + { + self setclientfieldtoplayer( clientfield_name, 1 ); + } + } + else + { + self setclientfieldtoplayer( clientfield_name, 0 ); + } +} + +randomize_powerups() //checked matches cerberus output +{ + level.zombie_powerup_array = array_randomize( level.zombie_powerup_array ); +} + +get_next_powerup() //checked matches cerberus output +{ + powerup = level.zombie_powerup_array[ level.zombie_powerup_index ]; + level.zombie_powerup_index++; + if ( level.zombie_powerup_index >= level.zombie_powerup_array.size ) + { + level.zombie_powerup_index = 0; + randomize_powerups(); + } + return powerup; +} + +get_valid_powerup() //checked partially matches cerberus output did not change +{ + if ( isDefined( level.zombie_powerup_boss ) ) + { + i = level.zombie_powerup_boss; + level.zombie_powerup_boss = undefined; + return level.zombie_powerup_array[ i ]; + } + if ( isDefined( level.zombie_powerup_ape ) ) + { + powerup = level.zombie_powerup_ape; + level.zombie_powerup_ape = undefined; + return powerup; + } + powerup = get_next_powerup(); + while ( 1 ) + { + while ( !( [[ level.zombie_powerups[ powerup ].func_should_drop_with_regular_powerups ]]() ) ) + { + powerup = get_next_powerup(); + } + return powerup; + } +} + +minigun_no_drop() //checked matches cerberus output +{ + players = get_players(); + i = 0; + while ( i < players.size ) + { + if ( players[ i ].zombie_vars[ "zombie_powerup_minigun_on" ] == 1 ) + { + return 1; + } + i++; + } + if ( !flag( "power_on" ) ) + { + if ( flag( "solo_game" ) ) + { + if ( level.solo_lives_given == 0 ) + { + return 1; + } + } + else + { + return 1; + } + } + return 0; +} + +get_num_window_destroyed() //checked partially matches cerberus output did not change +{ + num = 0; + for ( i = 0; i < level.exterior_goals.size; i++ ) + { + if ( all_chunks_destroyed( level.exterior_goals[ i ], level.exterior_goals[ i ].barrier_chunks ) ) + { + num += 1; + } + } + return num; +} + +watch_for_drop() //checked partially matches cerberus output did not change +{ + flag_wait( "start_zombie_round_logic" ); + flag_wait( "begin_spawning" ); + players = get_players(); + score_to_drop = ( players.size * level.zombie_vars[ "zombie_score_start_" + players.size + "p" ] ) + level.zombie_vars[ "zombie_powerup_drop_increment" ]; + while ( 1 ) + { + flag_wait( "zombie_drop_powerups" ); + players = get_players(); + curr_total_score = 0; + for ( i = 0; i < players.size; i++ ) + { + if ( isDefined( players[ i ].score_total ) ) + { + curr_total_score += players[ i ].score_total; + } + } + if ( curr_total_score > score_to_drop ) + { + level.zombie_vars[ "zombie_powerup_drop_increment" ] *= 1.14; + score_to_drop = curr_total_score + level.zombie_vars[ "zombie_powerup_drop_increment" ]; + level.zombie_vars[ "zombie_drop_item" ] = 1; + } + wait 0.5; + } + +} + +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 +{ + if ( !isDefined( clientfield_version ) ) + { + clientfield_version = 1; + } + if ( isDefined( level.zombie_include_powerups ) && !isDefined( level.zombie_include_powerups[ powerup_name ] ) ) + { + return; + } + precachemodel( model_name ); + precachestring( hint ); + struct = spawnstruct(); + if ( !isDefined( level.zombie_powerups ) ) + { + level.zombie_powerups = []; + } + struct.powerup_name = powerup_name; + struct.model_name = model_name; + struct.weapon_classname = "script_model"; + struct.hint = hint; + struct.func_should_drop_with_regular_powerups = func_should_drop_with_regular_powerups; + struct.solo = solo; + struct.caution = caution; + struct.zombie_grabbable = zombie_grabbable; + if ( isDefined( fx ) ) + { + struct.fx = loadfx( fx ); + } + level.zombie_powerups[ powerup_name ] = struct; + level.zombie_powerup_array[ level.zombie_powerup_array.size ] = powerup_name; + add_zombie_special_drop( powerup_name ); + if ( !level.createfx_enabled ) + { + if ( isDefined( client_field_name ) ) + { + registerclientfield( "toplayer", client_field_name, clientfield_version, 2, "int" ); + struct.client_field_name = client_field_name; + struct.time_name = time_name; + struct.on_name = on_name; + } + } +} + +powerup_set_can_pick_up_in_last_stand( powerup_name, b_can_pick_up ) //checked matches cerberus output +{ + level.zombie_powerups[ powerup_name ].can_pick_up_in_last_stand = b_can_pick_up; +} + +add_zombie_special_drop( powerup_name ) //checked matches cerberus output +{ + level.zombie_special_drop_array[ level.zombie_special_drop_array.size ] = powerup_name; +} + +include_zombie_powerup( powerup_name ) //checked matches cerberus output +{ + if ( !isDefined( level.zombie_include_powerups ) ) + { + level.zombie_include_powerups = []; + } + level.zombie_include_powerups[ powerup_name ] = 1; +} + +powerup_round_start() //checked matches cerberus output +{ + level.powerup_drop_count = 0; +} + +powerup_drop( drop_point ) //modified function +{ + if ( level.powerup_drop_count >= level.zombie_vars[ "zombie_powerup_drop_max_per_round" ] ) + { + return; + } + if ( !isDefined( level.zombie_include_powerups ) || level.zombie_include_powerups.size == 0 ) + { + return; + } + rand_drop = randomint( 100 ); + if ( rand_drop > 2 ) + { + if ( !level.zombie_vars[ "zombie_drop_item" ] ) + { + return; + } + debug = "score"; + } + else + { + debug = "random"; + } + playable_area = getentarray( "player_volume", "script_noteworthy" ); + level.powerup_drop_count++; + powerup = maps/mp/zombies/_zm_net::network_safe_spawn( "powerup", 1, "script_model", drop_point + vectorScale( ( 0, 0, 1 ), 40 ) ); + valid_drop = 0; + for ( i = 0; i < playable_area.size; i++ ) + { + if ( powerup istouching( playable_area[ i ] ) ) + { + valid_drop = 1; + break; + } + } + if ( valid_drop && level.rare_powerups_active ) + { + pos = ( drop_point[ 0 ], drop_point[ 1 ], drop_point[ 2 ] + 42 ); + if ( check_for_rare_drop_override( pos ) ) + { + level.zombie_vars[ "zombie_drop_item" ] = 0; + valid_drop = 0; + } + } + if ( !valid_drop ) + { + level.powerup_drop_count--; + + powerup delete(); + return; + } + powerup powerup_setup(); + print_powerup_drop( powerup.powerup_name, debug ); + powerup thread powerup_timeout(); + powerup thread powerup_wobble(); + powerup thread powerup_grab(); + powerup thread powerup_move(); + powerup thread powerup_emp(); + level.zombie_vars[ "zombie_drop_item" ] = 0; + level notify( "powerup_dropped" ); +} + +specific_powerup_drop( powerup_name, drop_spot, powerup_team, powerup_location ) //checked partially changed to match cerberus output +{ + powerup = maps/mp/zombies/_zm_net::network_safe_spawn( "powerup", 1, "script_model", drop_spot + vectorScale( ( 0, 0, 1 ), 40 ) ); + level notify( "powerup_dropped" ); + if ( isDefined( powerup ) ) + { + powerup powerup_setup( powerup_name, powerup_team, powerup_location ); + powerup thread powerup_timeout(); + powerup thread powerup_wobble(); + powerup thread powerup_grab( powerup_team ); + powerup thread powerup_move(); + powerup thread powerup_emp(); + return powerup; + } +} + +quantum_bomb_random_powerup_result( position ) //changed to match cerberus output +{ + if ( !isDefined( level.zombie_include_powerups ) || !level.zombie_include_powerups.size ) + { + return; + } + keys = getarraykeys( level.zombie_include_powerups ); + while ( keys.size ) + { + index = randomint( keys.size ); + if ( !level.zombie_powerups[ keys[ index ] ].zombie_grabbable ) + { + skip = 0; + switch( keys[ index ] ) + { + case "bonus_points_player": + case "bonus_points_team": + case "random_weapon": + skip = 1; + break; + case "fire_sale": + case "full_ammo": + case "insta_kill": + case "minigun": + if ( randomint( 4 ) ) + { + skip = 1; + } + break; + case "bonfire_sale": + case "free_perk": + case "tesla": + if ( randomint( 20 ) ) + { + skip = 1; + } + break; + default: + } + if ( skip ) + { + arrayremovevalue( keys, keys[ index ] ); + continue; + } + self thread maps/mp/zombies/_zm_audio::create_and_play_dialog( "kill", "quant_good" ); + [[ level.quantum_bomb_play_player_effect_at_position_func ]]( position ); + level specific_powerup_drop( keys[ index ], position ); + return; + } + else + { + arrayremovevalue( keys, keys[ index ] ); + } + } +} + +quantum_bomb_random_zombie_grab_powerup_result( position ) //changed to match cerberus output +{ + if ( !isDefined( level.zombie_include_powerups ) || !level.zombie_include_powerups.size ) + { + return; + } + keys = getarraykeys( level.zombie_include_powerups ); + while ( keys.size ) + { + index = randomint( keys.size ); + if ( level.zombie_powerups[ keys[ index ] ].zombie_grabbable ) + { + self thread maps/mp/zombies/_zm_audio::create_and_play_dialog( "kill", "quant_bad" ); + [[ level.quantum_bomb_play_player_effect_at_position_func ]]( position ); + level specific_powerup_drop( keys[ index ], position ); + return; + } + else + { + arrayremovevalue( keys, keys[ index ] ); + } + } +} + +quantum_bomb_random_weapon_powerup_result( position ) //checked matches cerberus output +{ + self thread maps/mp/zombies/_zm_audio::create_and_play_dialog( "kill", "quant_good" ); + [[ level.quantum_bomb_play_player_effect_at_position_func ]]( position ); + level specific_powerup_drop( "random_weapon", position ); +} + +quantum_bomb_random_bonus_or_lose_points_powerup_result( position ) //checked matches cerberus output +{ + rand = randomint( 10 ); + powerup = "bonus_points_team"; + switch( rand ) + { + case 0: + case 1: + powerup = "lose_points_team"; + if ( isDefined( level.zombie_include_powerups[ powerup ] ) ) + { + self thread maps/mp/zombies/_zm_audio::create_and_play_dialog( "kill", "quant_bad" ); + break; + } + case 2: + case 3: + case 4: + powerup = "bonus_points_player"; + if ( isDefined( level.zombie_include_powerups[ powerup ] ) ) + { + break; + } + default: + powerup = "bonus_points_team"; + break; + } + [[ level.quantum_bomb_play_player_effect_at_position_func ]]( position ); + level specific_powerup_drop( powerup, position ); +} + +special_powerup_drop( drop_point ) //checked changed to match cerberus output +{ + if ( !isDefined( level.zombie_include_powerups ) || level.zombie_include_powerups.size == 0 ) + { + return; + } + powerup = spawn( "script_model", drop_point + vectorScale( ( 0, 0, 1 ), 40 ) ); + playable_area = getentarray( "player_volume", "script_noteworthy" ); + valid_drop = 0; + for ( i = 0; i < playable_area.size; i++ ) + { + if ( powerup istouching( playable_area[ i ] ) ) + { + valid_drop = 1; + break; + } + } + if ( !valid_drop ) + { + powerup delete(); + return; + } + powerup special_drop_setup(); +} + +cleanup_random_weapon_list() //checked matches cerberus output +{ + self waittill( "death" ); + arrayremovevalue( level.random_weapon_powerups, self ); +} + +powerup_setup( powerup_override, powerup_team, powerup_location ) //checked partially changed to match cerberus output +{ + powerup = undefined; + if ( !isDefined( powerup_override ) ) + { + powerup = get_valid_powerup(); + } + else + { + powerup = powerup_override; + if ( powerup == "tesla" && tesla_powerup_active() ) + { + powerup = "minigun"; + } + } + struct = level.zombie_powerups[ powerup ]; + if ( powerup == "random_weapon" ) + { + players = get_players(); + self.weapon = maps/mp/zombies/_zm_magicbox::treasure_chest_chooseweightedrandomweapon( players[ 0 ] ); + self.base_weapon = self.weapon; + if ( !isDefined( level.random_weapon_powerups ) ) + { + level.random_weapon_powerups = []; + } + level.random_weapon_powerups[ level.random_weapon_powerups.size ] = self; + self thread cleanup_random_weapon_list(); + if ( isDefined( level.zombie_weapons[ self.weapon ].upgrade_name ) && !randomint( 4 ) ) + { + self.weapon = level.zombie_weapons[ self.weapon ].upgrade_name; + } + self setmodel( getweaponmodel( self.weapon ) ); + self useweaponhidetags( self.weapon ); + offsetdw = vectorScale( ( 1, 1, 1 ), 3 ); + self.worldgundw = undefined; + if ( maps/mp/zombies/_zm_magicbox::weapon_is_dual_wield( self.weapon ) ) + { + self.worldgundw = spawn( "script_model", self.origin + offsetdw ); + self.worldgundw.angles = self.angles; + self.worldgundw setmodel( maps/mp/zombies/_zm_magicbox::get_left_hand_weapon_model_name( self.weapon ) ); + self.worldgundw useweaponhidetags( self.weapon ); + self.worldgundw linkto( self, "tag_weapon", offsetdw, ( 0, 0, 0 ) ); + } + } + else + { + self setmodel( struct.model_name ); + } + maps/mp/_demo::bookmark( "zm_powerup_dropped", getTime(), undefined, undefined, 1 ); + playsoundatposition( "zmb_spawn_powerup", self.origin ); + if ( isDefined( powerup_team ) ) + { + self.powerup_team = powerup_team; + } + if ( isDefined( powerup_location ) ) + { + self.powerup_location = powerup_location; + } + self.powerup_name = struct.powerup_name; + self.hint = struct.hint; + self.solo = struct.solo; + self.caution = struct.caution; + self.zombie_grabbable = struct.zombie_grabbable; + self.func_should_drop_with_regular_powerups = struct.func_should_drop_with_regular_powerups; + if ( isDefined( struct.fx ) ) + { + self.fx = struct.fx; + } + if ( isDefined( struct.can_pick_up_in_last_stand ) ) + { + self.can_pick_up_in_last_stand = struct.can_pick_up_in_last_stand; + } + self playloopsound( "zmb_spawn_powerup_loop" ); + level.active_powerups[ level.active_powerups.size ] = self; +} + +special_drop_setup() //checked matches cerberus output +{ + powerup = undefined; + is_powerup = 1; + if ( level.round_number <= 10 ) + { + powerup = get_valid_powerup(); + } + else + { + powerup = level.zombie_special_drop_array[ randomint( level.zombie_special_drop_array.size ) ]; + if ( level.round_number > 15 && randomint( 100 ) < ( ( level.round_number - 15 ) * 5 ) ) + { + powerup = "nothing"; + } + } + switch( powerup ) + { + case "all_revive": + case "bonfire_sale": + case "bonus_points_player": + case "bonus_points_team": + case "carpenter": + case "double_points": + case "empty_clip": + case "fire_sale": + case "free_perk": + case "insta_kill": + case "lose_perk": + case "lose_points_team": + case "minigun": + case "nuke": + case "random_weapon": + case "tesla": + case "zombie_blood": + break; + case "full_ammo": + if ( level.round_number > 10 && randomint( 100 ) < ( ( level.round_number - 10 ) * 5 ) ) + { + powerup = level.zombie_powerup_array[ randomint( level.zombie_powerup_array.size ) ]; + } + break; + case "dog": + if ( level.round_number >= 15 ) + { + is_powerup = 0; + dog_spawners = getentarray( "special_dog_spawner", "targetname" ); + thread play_sound_2d( "sam_nospawn" ); + } + else + { + powerup = get_valid_powerup(); + } + break; + default: + if ( isDefined( level._zombiemode_special_drop_setup ) ) + { + is_powerup = [[ level._zombiemode_special_drop_setup ]]( powerup ); + } + else + { + is_powerup = 0; + playfx( level._effect[ "lightning_dog_spawn" ], self.origin ); + playsoundatposition( "pre_spawn", self.origin ); + wait 1.5; + playsoundatposition( "zmb_bolt", self.origin ); + earthquake( 0.5, 0.75, self.origin, 1000 ); + playrumbleonposition( "explosion_generic", self.origin ); + playsoundatposition( "spawn", self.origin ); + wait 1; + thread play_sound_2d( "sam_nospawn" ); + self delete(); + } + } + if ( is_powerup ) + { + playfx( level._effect[ "lightning_dog_spawn" ], self.origin ); + playsoundatposition( "pre_spawn", self.origin ); + wait 1.5; + playsoundatposition( "zmb_bolt", self.origin ); + earthquake( 0.5, 0.75, self.origin, 1000 ); + playrumbleonposition( "explosion_generic", self.origin ); + playsoundatposition( "spawn", self.origin ); + self powerup_setup( powerup ); + self thread powerup_timeout(); + self thread powerup_wobble(); + self thread powerup_grab(); + self thread powerup_move(); + self thread powerup_emp(); + } +} + +powerup_zombie_grab_trigger_cleanup( trigger ) //checked matches cerberus output +{ + self waittill_any( "powerup_timedout", "powerup_grabbed", "hacked" ); + trigger delete(); +} + +powerup_zombie_grab( powerup_team ) //checked changed to match cerberus output +{ + self endon( "powerup_timedout" ); + self endon( "powerup_grabbed" ); + self endon( "hacked" ); + zombie_grab_trigger = spawn( "trigger_radius", self.origin - vectorScale( ( 0, 0, 1 ), 40 ), 4, 32, 72 ); + zombie_grab_trigger enablelinkto(); + zombie_grab_trigger linkto( self ); + zombie_grab_trigger setteamfortrigger( level.zombie_team ); + self thread powerup_zombie_grab_trigger_cleanup( zombie_grab_trigger ); + poi_dist = 300; + if ( isDefined( level._zombie_grabbable_poi_distance_override ) ) + { + poi_dist = level._zombie_grabbable_poi_distance_override; + } + zombie_grab_trigger create_zombie_point_of_interest( poi_dist, 2, 0, 1, undefined, undefined, powerup_team ); + while ( isDefined( self ) ) + { + zombie_grab_trigger waittill( "trigger", who ); + if ( isDefined( level._powerup_grab_check ) ) + { + if ( !self [[ level._powerup_grab_check ]]( who ) ) + { + continue; + } + } + else if ( !isDefined( who ) || !isai( who ) ) + { + continue; + } + playfx( level._effect[ "powerup_grabbed_red" ], self.origin ); + playfx( level._effect[ "powerup_grabbed_wave_red" ], self.origin ); + switch( self.powerup_name ) + { + case "lose_points_team": + level thread lose_points_team_powerup( self ); + players = get_players(); + players[ randomintrange( 0, players.size ) ] thread powerup_vo( "lose_points" ); + break; + case "lose_perk": + level thread lose_perk_powerup( self ); + break; + case "empty_clip": + level thread empty_clip_powerup( self ); + break; + default: + if ( isDefined( level._zombiemode_powerup_zombie_grab ) ) + { + level thread [[ level._zombiemode_powerup_zombie_grab ]]( self ); + } + if ( isDefined( level._game_mode_powerup_zombie_grab ) ) + { + level thread [[ level._game_mode_powerup_zombie_grab ]]( self, who ); + } + break; + } + level thread maps/mp/zombies/_zm_audio::do_announcer_playvox( "powerup", self.powerup_name ); + wait 0.1; + playsoundatposition( "zmb_powerup_grabbed", self.origin ); + self stoploopsound(); + self powerup_delete(); + self notify( "powerup_grabbed" ); + } +} + +powerup_grab(powerup_team) //checked partially changed to match cerberus output +{ + if ( isdefined( self ) && self.zombie_grabbable ) + { + self thread powerup_zombie_grab( powerup_team ); + return; + } + + self endon ( "powerup_timedout" ); + self endon ( "powerup_grabbed" ); + + range_squared = 4096; + while ( isdefined( self ) ) + { + players = get_players(); + i = 0; + while ( i < players.size ) + { + 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() ) + { + i++; + continue; + } + 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() ) + { + i++; + continue; + } + ignore_range = 0; + if ( isdefined( players[ i ].ignore_range_powerup ) && players[ i ].ignore_range_powerup == self ) + { + players[ i ].ignore_range_powerup = undefined; + ignore_range = 1; + } + if ( DistanceSquared( players[ i ].origin, self.origin ) < range_squared || ignore_range ) + { + if ( isdefined(level._powerup_grab_check ) ) + { + if ( !self [[ level._powerup_grab_check ]]( players[ i ] ) ) + { + i++; + continue; + } + } + else if ( isdefined( level.zombie_powerup_grab_func ) ) + { + level thread [[ level.zombie_powerup_grab_func ]](); + break; + } + switch ( self.powerup_name ) + { + case "nuke": + level thread nuke_powerup( self, players[ i ].team ); + players[ i ] thread powerup_vo( "nuke" ); + zombies = getaiarray( level.zombie_team ); + players[ i ].zombie_nuked = arraysort( zombies, self.origin ); + players[ i ] notify( "nuke_triggered" ); + break; + case "full_ammo": + level thread full_ammo_powerup( self ,players[ i ] ); + players[ i ] thread powerup_vo( "full_ammo" ); + break; + case "double_points": + level thread double_points_powerup( self, players[ i ] ); + players[ i ] thread powerup_vo( "double_points" ); + break; + case "insta_kill": + level thread insta_kill_powerup( self,players[ i ] ); + players[ i ] thread powerup_vo( "insta_kill" ); + break; + case "carpenter": + if ( is_classic() ) + { + players[ i ] thread maps/mp/zombies/_zm_pers_upgrades::persistent_carpenter_ability_check(); + } + if ( isdefined( level.use_new_carpenter_func ) ) + { + level thread [[ level.use_new_carpenter_func ]]( self.origin ); + } + else + { + level thread start_carpenter( self.origin ); + } + players[ i ] thread powerup_vo( "carpenter" ); + break; + case "fire_sale": + level thread start_fire_sale( self ); + players[ i ] thread powerup_vo( "firesale" ); + break; + case "bonfire_sale": + level thread start_bonfire_sale( self ); + players[ i ] thread powerup_vo( "firesale" ); + break; + case "minigun": + level thread minigun_weapon_powerup( players[ i ] ); + players[ i ] thread powerup_vo( "minigun" ); + break; + case "free_perk": + level thread free_perk_powerup( self ); + break; + case "tesla": + level thread tesla_weapon_powerup( players[ i ] ); + players[ i ] thread powerup_vo( "tesla" ); + break; + case "random_weapon": + if ( !level random_weapon_powerup( self, players[ i ] ) ) + { + i++; + continue; + } + break; + case "bonus_points_player": + level thread bonus_points_player_powerup( self, players[ i ] ); + players[ i ] thread powerup_vo( "bonus_points_solo" ); + break; + case "bonus_points_team": + level thread bonus_points_team_powerup( self ); + players[ i ] thread powerup_vo( "bonus_points_team" ); + break; + case "teller_withdrawl": + level thread teller_withdrawl( self ,players[ i ] ); + break; + default: + if ( IsDefined( level._zombiemode_powerup_grab ) ) + { + level thread [[ level._zombiemode_powerup_grab ]]( self, players[ i ] ); + } + break; + } + + maps\mp\_demo::bookmark( "zm_player_powerup_grabbed", gettime(), players[ i ] ); + + if( should_award_stat ( self.powerup_name )) //don't do this for things that aren't really a powerup + { + //track # of picked up powerups/drops for the player + players[i] maps/mp/zombies/_zm_stats::increment_client_stat( "drops" ); + players[i] maps/mp/zombies/_zm_stats::increment_player_stat( "drops" ); + players[i] maps/mp/zombies/_zm_stats::increment_client_stat( self.powerup_name + "_pickedup" ); + players[i] maps/mp/zombies/_zm_stats::increment_player_stat( self.powerup_name + "_pickedup" ); + } + + if ( self.solo ) + { + playfx( level._effect[ "powerup_grabbed_solo" ], self.origin ); + playfx( level._effect[ "powerup_grabbed_wave_solo" ], self.origin ); + } + else if ( self.caution ) + { + playfx( level._effect[ "powerup_grabbed_caution" ], self.origin ); + playfx( level._effect[ "powerup_grabbed_wave_caution" ], self.origin ); + } + else + { + playfx( level._effect[ "powerup_grabbed" ], self.origin ); + playfx( level._effect[ "powerup_grabbed_wave" ], self.origin ); + } + + if ( isdefined( self.stolen ) && self.stolen ) + { + level notify( "monkey_see_monkey_dont_achieved" ); + } + if ( isdefined( self.grabbed_level_notify ) ) + { + level notify( self.grabbed_level_notify ); + } + + self.claimed = true; + self.power_up_grab_player = players[ i ]; //Player who grabbed the power up + + wait 0.1 ; + + playsoundatposition("zmb_powerup_grabbed", self.origin); + self stoploopsound(); + self hide(); + + if ( self.powerup_name != "fire_sale" ) + { + if ( isdefined( self.power_up_grab_player ) ) + { + if ( isdefined( level.powerup_intro_vox ) ) + { + level thread [[ level.powerup_intro_vox ]]( self ); + return; + } + else if ( isdefined( level.powerup_vo_available ) ) + { + can_say_vo = [[ level.powerup_vo_available ]](); + if ( !can_say_vo ) + { + self powerup_delete(); + self notify( "powerup_grabbed" ); + return; + } + } + } + } + level thread maps/mp/zombies/_zm_audio_announcer::leaderdialog( self.powerup_name, self.power_up_grab_player.pers[ "team" ] ); + self powerup_delete(); + self notify( "powerup_grabbed" ); + } + i++; + } + wait 0.1; + } +} + + +start_fire_sale( item ) //checked matches cerberus output +{ + if ( level.zombie_vars[ "zombie_powerup_fire_sale_time" ] > 0 && is_true( level.zombie_vars[ "zombie_powerup_fire_sale_on" ] ) ) + { + level.zombie_vars[ "zombie_powerup_fire_sale_time" ] += 30; + return; + } + level notify( "powerup fire sale" ); + level endon( "powerup fire sale" ); + level thread maps/mp/zombies/_zm_audio_announcer::leaderdialog( "fire_sale" ); + level.zombie_vars[ "zombie_powerup_fire_sale_on" ] = 1; + level thread toggle_fire_sale_on(); + level.zombie_vars[ "zombie_powerup_fire_sale_time" ] = 30; + while ( level.zombie_vars[ "zombie_powerup_fire_sale_time" ] > 0 ) + { + wait 0.05; + level.zombie_vars[ "zombie_powerup_fire_sale_time" ] -= 0.05; + } + level.zombie_vars[ "zombie_powerup_fire_sale_on" ] = 0; + level notify( "fire_sale_off" ); +} + +start_bonfire_sale( item ) //checked matches cerberus output +{ + level notify( "powerup bonfire sale" ); + level endon( "powerup bonfire sale" ); + temp_ent = spawn( "script_origin", ( 0, 0, 0 ) ); + temp_ent playloopsound( "zmb_double_point_loop" ); + level.zombie_vars[ "zombie_powerup_bonfire_sale_on" ] = 1; + level thread toggle_bonfire_sale_on(); + level.zombie_vars[ "zombie_powerup_bonfire_sale_time" ] = 30; + while ( level.zombie_vars[ "zombie_powerup_bonfire_sale_time" ] > 0 ) + { + wait 0.05; + level.zombie_vars[ "zombie_powerup_bonfire_sale_time" ] -= 0.05; + } + level.zombie_vars[ "zombie_powerup_bonfire_sale_on" ] = 0; + level notify( "bonfire_sale_off" ); + players = get_players(); + i = 0; + while ( i < players.size ) + { + players[ i ] playsound( "zmb_points_loop_off" ); + i++; + } + temp_ent delete(); +} + +start_carpenter( origin ) //checked partially changed to match cerberus output +{ + window_boards = getstructarray( "exterior_goal", "targetname" ); + total = level.exterior_goals.size; + carp_ent = spawn( "script_origin", ( 0, 0, 0 ) ); + carp_ent playloopsound( "evt_carpenter" ); + while ( 1 ) + { + windows = get_closest_window_repair( window_boards, origin ); + if ( !isDefined( windows ) ) + { + carp_ent stoploopsound( 1 ); + carp_ent playsoundwithnotify( "evt_carpenter_end", "sound_done" ); + carp_ent waittill( "sound_done" ); + break; + } + else arrayremovevalue( window_boards, windows ); + while ( 1 ) + { + if ( all_chunks_intact( windows, windows.barrier_chunks ) ) + { + break; + } + else chunk = get_random_destroyed_chunk( windows, windows.barrier_chunks ); + if ( !isDefined( chunk ) ) + { + break; + } + windows thread maps/mp/zombies/_zm_blockers::replace_chunk( windows, chunk, undefined, maps/mp/zombies/_zm_powerups::is_carpenter_boards_upgraded(), 1 ); + if ( isDefined( windows.clip ) ) + { + windows.clip enable_trigger(); + windows.clip disconnectpaths(); + } + else + { + blocker_disconnect_paths( windows.neg_start, windows.neg_end ); + } + wait_network_frame(); + wait 0.05; + } + wait_network_frame(); + } + players = get_players(); + i = 0; + while ( i < players.size ) + { + players[ i ] maps/mp/zombies/_zm_score::player_add_points( "carpenter_powerup", 200 ); + i++; + } + carp_ent delete(); +} + +get_closest_window_repair( windows, origin ) //checked partially changed to match cerberus output +{ + current_window = undefined; + shortest_distance = undefined; + i = 0; + while ( i < windows.size ) + { + if ( all_chunks_intact( windows, windows[ i ].barrier_chunks ) ) + { + i++; + continue; + } + if ( !isDefined( current_window ) ) + { + current_window = windows[ i ]; + shortest_distance = distancesquared( current_window.origin, origin ); + i++; + continue; + } + if ( distancesquared( windows[ i ].origin, origin ) < shortest_distance ) + { + current_window = windows[ i ]; + shortest_distance = distancesquared( windows[ i ].origin, origin ); + } + i++; + } + return current_window; +} + +powerup_vo( type ) //checked matches cerberus output +{ + self endon( "death" ); + self endon( "disconnect" ); + if ( isDefined( level.powerup_vo_available ) ) + { + if ( ![[ level.powerup_vo_available ]]() ) + { + return; + } + } + wait randomfloatrange( 2, 2.5 ); + if ( type == "tesla" ) + { + self maps/mp/zombies/_zm_audio::create_and_play_dialog( "weapon_pickup", type ); + } + else + { + self maps/mp/zombies/_zm_audio::create_and_play_dialog( "powerup", type ); + } + if ( isDefined( level.custom_powerup_vo_response ) ) + { + level [[ level.custom_powerup_vo_response ]]( self, type ); + } +} + +powerup_wobble_fx() //checked matches cerberus output +{ + self endon( "death" ); + if ( !isDefined( self ) ) + { + return; + } + if ( isDefined( level.powerup_fx_func ) ) + { + self thread [[ level.powerup_fx_func ]](); + return; + } + if ( self.solo ) + { + self setclientfield( "powerup_fx", 2 ); + } + else if ( self.caution ) + { + self setclientfield( "powerup_fx", 4 ); + } + else if ( self.zombie_grabbable ) + { + self setclientfield( "powerup_fx", 3 ); + } + else + { + self setclientfield( "powerup_fx", 1 ); + } +} + +powerup_wobble() //checked matches cerberus output +{ + self endon( "powerup_grabbed" ); + self endon( "powerup_timedout" ); + self thread powerup_wobble_fx(); + while ( isDefined( self ) ) + { + waittime = randomfloatrange( 2.5, 5 ); + yaw = randomint( 360 ); + if ( yaw > 300 ) + { + yaw = 300; + } + else + { + if ( yaw < 60 ) + { + yaw = 60; + } + } + yaw = self.angles[ 1 ] + yaw; + new_angles = ( -60 + randomint( 120 ), yaw, -45 + randomint( 90 ) ); + self rotateto( new_angles, waittime, waittime * 0.5, waittime * 0.5 ); + if ( isDefined( self.worldgundw ) ) + { + self.worldgundw rotateto( new_angles, waittime, waittime * 0.5, waittime * 0.5 ); + } + wait randomfloat( waittime - 0.1 ); + } +} + +powerup_timeout() //checked partially changed to match cerberus output +{ + if ( isDefined( level._powerup_timeout_override ) && !isDefined( self.powerup_team ) ) + { + self thread [[ level._powerup_timeout_override ]](); + return; + } + self endon( "powerup_grabbed" ); + self endon( "death" ); + self endon( "powerup_reset" ); + self show(); + wait_time = 15; + if ( isDefined( level._powerup_timeout_custom_time ) ) + { + time = [[ level._powerup_timeout_custom_time ]]( self ); + if ( time == 0 ) + { + return; + } + wait_time = time; + } + wait wait_time; + i = 0; + while ( i < 40 ) + { + if ( i % 2 ) + { + self ghost(); + if ( isDefined( self.worldgundw ) ) + { + self.worldgundw ghost(); + } + } + else + { + self show(); + if ( isDefined( self.worldgundw ) ) + { + self.worldgundw show(); + } + } + if ( i < 15 ) + { + wait 0.5; + i++; + continue; + } + else if ( i < 25 ) + { + wait 0.25; + i++; + continue; + } + wait 0.1; + i++; + } + self notify( "powerup_timedout" ); + self powerup_delete(); +} + +powerup_delete() //checked matches cerberus output +{ + arrayremovevalue( level.active_powerups, self, 0 ); + if ( isDefined( self.worldgundw ) ) + { + self.worldgundw delete(); + } + self delete(); +} + +powerup_delete_delayed( time ) //checked matches cerberus output +{ + if ( isDefined( time ) ) + { + wait time; + } + else + { + wait 0.01; + } + self powerup_delete(); +} + +nuke_powerup( drop_item, player_team ) //checked changed to match cerberus output +{ + location = drop_item.origin; + playfx( drop_item.fx, location ); + level thread nuke_flash( player_team ); + wait 0.5; + zombies = getaiarray( level.zombie_team ); + zombies = arraysort( zombies, location ); + zombies_nuked = []; + i = 0; + while ( i < zombies.size ) + { + if ( isdefined( zombies[ i ].ignore_nuke ) && zombies[ i ].ignore_nuke ) + { + i++; + continue; + } + if ( isdefined( zombies[ i ].marked_for_death ) && zombies[ i ].marked_for_death ) + { + i++; + continue; + } + if ( isdefined( zombies[ i ].nuke_damage_func ) ) + { + zombies[ i ] thread [[ zombies[ i ].nuke_damage_func ]](); + i++; + continue; + } + if ( is_magic_bullet_shield_enabled( zombies[ i ] ) ) + { + i++; + continue; + } + zombies[ i ].marked_for_death = 1; + //imported from bo3 _zm_powerup_nuke.gsc + if ( !zombies[ i ].nuked && !is_magic_bullet_shield_enabled( zombies[ i ] ) ) + { + zombies[ i ].nuked = 1; + zombies_nuked[ zombies_nuked.size ] = zombies[ i ]; + } + i++; + } + i = 0; + while ( i < zombies_nuked.size ) + { + wait randomfloatrange( 0.1, 0.7 ); + if ( !isdefined( zombies_nuked[ i ] ) ) + { + i++; + continue; + } + if ( is_magic_bullet_shield_enabled( zombies_nuked[ i ] ) ) + { + i++; + continue; + } + if ( i < 5 && !zombies_nuked[ i ].isdog ) + { + zombies_nuked[ i ] thread maps/mp/animscripts/zm_death::flame_death_fx(); + } + if ( !zombies_nuked[ i ].isdog ) + { + if ( isdefined( zombies_nuked[ i ].no_gib ) && !zombies_nuked[ i ].no_gib ) + { + zombies_nuked[ i ] maps/mp/zombies/_zm_spawner::zombie_head_gib(); + } + zombies_nuked[ i ] playsound("evt_nuked"); + } + zombies_nuked[ i ] dodamage(zombies_nuked[i].health + 666, zombies_nuked[ i ].origin ); + i++; + } + players = get_players( player_team ); + for ( i = 0; i < players.size; i++ ) + { + players[ i ] maps/mp/zombies/_zm_score::player_add_points( "nuke_powerup", 400 ); + } +} + +nuke_flash( team ) //checked matches cerberus output +{ + if ( isDefined( team ) ) + { + get_players()[ 0 ] playsoundtoteam( "evt_nuke_flash", team ); + } + else + { + get_players()[ 0 ] playsound( "evt_nuke_flash" ); + } + fadetowhite = newhudelem(); + fadetowhite.x = 0; + fadetowhite.y = 0; + fadetowhite.alpha = 0; + fadetowhite.horzalign = "fullscreen"; + fadetowhite.vertalign = "fullscreen"; + fadetowhite.foreground = 1; + fadetowhite setshader( "white", 640, 480 ); + fadetowhite fadeovertime( 0.2 ); + fadetowhite.alpha = 0.8; + wait 0.5; + fadetowhite fadeovertime( 1 ); + fadetowhite.alpha = 0; + wait 1.1; + fadetowhite destroy(); +} + +double_points_powerup( drop_item, player ) //checked partially matches cerberus output did not change +{ + level notify( "powerup points scaled_" + player.team ); + level endon( "powerup points scaled_" + player.team ); + team = player.team; + level thread point_doubler_on_hud( drop_item, team ); + if ( isDefined( level.pers_upgrade_double_points ) && level.pers_upgrade_double_points ) + { + player thread maps/mp/zombies/_zm_pers_upgrades_functions::pers_upgrade_double_points_pickup_start(); + } + if ( isDefined( level.current_game_module ) && level.current_game_module == 2 ) + { + if ( isDefined( player._race_team ) ) + { + if ( player._race_team == 1 ) + { + level._race_team_double_points = 1; + } + else + { + level._race_team_double_points = 2; + } + } + } + level.zombie_vars[ team ][ "zombie_point_scalar" ] = 2; + players = get_players(); + for ( player_index = 0; player_index < players.size; player_index++ ) + { + if ( team == players[ player_index ].team ) + { + players[ player_index ] setclientfield( "score_cf_double_points_active", 1 ); + } + } + wait 30; + level.zombie_vars[ team ][ "zombie_point_scalar" ] = 1; + level._race_team_double_points = undefined; + players = get_players(); + for ( player_index = 0; player_index < players.size; player_index++ ) + { + if ( team == players[ player_index ].team ) + { + players[ player_index ] setclientfield( "score_cf_double_points_active", 0 ); + } + } +} + +full_ammo_powerup( drop_item, player ) //checked changed to match cerberus output +{ + players = get_players( player.team ); + if ( isdefined( level._get_game_module_players ) ) + { + players = [[ level._get_game_module_players ]]( player ); + } + i = 0; + while ( i < players.size ) + { + if ( players[ i ] maps/mp/zombies/_zm_laststand::player_is_in_laststand() ) + { + i++; + continue; + } + primary_weapons = players[ i ] getweaponslist( 1 ); + players[ i ] notify( "zmb_max_ammo" ); + players[ i ] notify( "zmb_lost_knife" ); + players[ i ] notify( "zmb_disable_claymore_prompt" ); + players[ i ] notify( "zmb_disable_spikemore_prompt" ); + x = 0; + while ( x < primary_weapons.size ) + { + if ( level.headshots_only && is_lethal_grenade(primary_weapons[ x ] ) ) + { + x++; + continue; + } + if ( isdefined( level.zombie_include_equipment ) && isdefined( level.zombie_include_equipment[ primary_weapons[ x ] ] ) ) + { + x++; + continue; + } + if ( isdefined( level.zombie_weapons_no_max_ammo ) && isdefined( level.zombie_weapons_no_max_ammo[ primary_weapons[ x ] ] ) ) + { + x++; + continue; + } + if ( players[ i ] hasweapon( primary_weapons[ x ] ) ) + { + players[ i ] givemaxammo( primary_weapons[ x ] ); + } + x++; + } + i++; + } + level thread full_ammo_on_hud( drop_item, player.team ); +} + +insta_kill_powerup( drop_item, player ) //checked matches cerberus output +{ + level notify( "powerup instakill_" + player.team ); + level endon( "powerup instakill_" + player.team ); + if ( isDefined( level.insta_kill_powerup_override ) ) + { + level thread [[ level.insta_kill_powerup_override ]]( drop_item, player ); + return; + } + if ( is_classic() ) + { + player thread maps/mp/zombies/_zm_pers_upgrades_functions::pers_upgrade_insta_kill_upgrade_check(); + } + team = player.team; + level thread insta_kill_on_hud( drop_item, team ); + level.zombie_vars[ team ][ "zombie_insta_kill" ] = 1; + wait 30; + level.zombie_vars[ team ][ "zombie_insta_kill" ] = 0; + players = get_players( team ); + i = 0; + while ( i < players.size ) + { + if ( isDefined( players[ i ] ) ) + { + players[ i ] notify( "insta_kill_over" ); + } + i++; + } +} + +is_insta_kill_active() //checked matches cerberus output +{ + return level.zombie_vars[ self.team ][ "zombie_insta_kill" ]; +} + +check_for_instakill( player, mod, hit_location ) //checked changed to match cerberus output +{ + if ( isDefined( player ) && isalive( player ) && isDefined( level.check_for_instakill_override ) ) + { + if ( !self [[ level.check_for_instakill_override ]]( player ) ) + { + return; + } + if ( player.use_weapon_type == "MOD_MELEE" ) + { + player.last_kill_method = "MOD_MELEE"; + } + else + { + player.last_kill_method = "MOD_UNKNOWN"; + } + modname = remove_mod_from_methodofdeath( mod ); + if ( isDefined( self.no_gib ) && self.no_gib ) + { + self maps/mp/zombies/_zm_spawner::zombie_head_gib(); + } + self.health = 1; + self dodamage( self.health + 666, self.origin, player, self, hit_location, modname ); + player notify( "zombie_killed" ); + } + if ( isDefined( player ) && isalive( player ) && level.zombie_vars[ player.team ][ "zombie_insta_kill" ] || isDefined( player.personal_instakill ) && player.personal_instakill ) + { + if ( is_magic_bullet_shield_enabled( self ) ) + { + return; + } + if ( isDefined( self.instakill_func ) ) + { + self thread [[ self.instakill_func ]](); + return; + } + if ( player.use_weapon_type == "MOD_MELEE" ) + { + player.last_kill_method = "MOD_MELEE"; + } + else + { + player.last_kill_method = "MOD_UNKNOWN"; + } + modname = remove_mod_from_methodofdeath( mod ); + if ( flag( "dog_round" ) ) + { + self.health = 1; + self dodamage( self.health + 666, self.origin, player, self, hit_location, modname ); + player notify( "zombie_killed" ); + } + else if ( isdefined( self.no_gib ) && !self.no_gib ) + { + self maps/mp/zombies/_zm_spawner::zombie_head_gib(); + } + self.health = 1; + self dodamage( self.health + 666, self.origin, player, self, hit_location, modname ); + player notify( "zombie_killed" ); + } +} + +insta_kill_on_hud( drop_item, player_team ) //checked matches cerberus output +{ + if ( level.zombie_vars[ player_team ][ "zombie_powerup_insta_kill_on" ] ) + { + level.zombie_vars[ player_team ][ "zombie_powerup_insta_kill_time" ] = 30; + return; + } + level.zombie_vars[ player_team ][ "zombie_powerup_insta_kill_on" ] = 1; + level thread time_remaning_on_insta_kill_powerup( player_team ); +} + +time_remaning_on_insta_kill_powerup( player_team ) //checked matches cerberus output +{ + temp_enta = spawn( "script_origin", ( 0, 0, 0 ) ); + temp_enta playloopsound( "zmb_insta_kill_loop" ); + while ( level.zombie_vars[ player_team ][ "zombie_powerup_insta_kill_time" ] >= 0 ) + { + wait 0.05; + level.zombie_vars[ player_team ][ "zombie_powerup_insta_kill_time" ] -= 0.05; + } + get_players()[ 0 ] playsoundtoteam( "zmb_insta_kill", player_team ); + temp_enta stoploopsound( 2 ); + level.zombie_vars[ player_team ][ "zombie_powerup_insta_kill_on" ] = 0; + level.zombie_vars[ player_team ][ "zombie_powerup_insta_kill_time" ] = 30; + temp_enta delete(); +} + +point_doubler_on_hud( drop_item, player_team ) //checked matches cerberus output +{ + self endon( "disconnect" ); + if ( level.zombie_vars[ player_team ][ "zombie_powerup_point_doubler_on" ] ) + { + level.zombie_vars[ player_team ][ "zombie_powerup_point_doubler_time" ] = 30; + return; + } + level.zombie_vars[ player_team ][ "zombie_powerup_point_doubler_on" ] = 1; + level thread time_remaining_on_point_doubler_powerup( player_team ); +} + +time_remaining_on_point_doubler_powerup( player_team ) //checked partially matches cerberus output did not change +{ + temp_ent = spawn( "script_origin", ( 0, 0, 0 ) ); + temp_ent playloopsound( "zmb_double_point_loop" ); + while ( level.zombie_vars[ player_team ][ "zombie_powerup_point_doubler_time" ] >= 0 ) + { + wait 0.05; + level.zombie_vars[ player_team ][ "zombie_powerup_point_doubler_time" ] -= 0.05; + } + level.zombie_vars[ player_team ][ "zombie_powerup_point_doubler_on" ] = 0; + players = get_players( player_team ); + for ( i = 0; i < players.size; i++ ) + { + players[ i ] playsound( "zmb_points_loop_off" ); + } + temp_ent stoploopsound( 2 ); + level.zombie_vars[ player_team ][ "zombie_powerup_point_doubler_time" ] = 30; + temp_ent delete(); +} + +toggle_bonfire_sale_on() //checked matches cerberus output +{ + level endon( "powerup bonfire sale" ); + if ( !isDefined( level.zombie_vars[ "zombie_powerup_bonfire_sale_on" ] ) ) + { + return; + } + if ( level.zombie_vars[ "zombie_powerup_bonfire_sale_on" ] ) + { + if ( isDefined( level.bonfire_init_func ) ) + { + level thread [[ level.bonfire_init_func ]](); + } + level waittill( "bonfire_sale_off" ); + } +} + +toggle_fire_sale_on() //checked partially matches cerberus output did not change +{ + level endon( "powerup fire sale" ); + if ( !isDefined( level.zombie_vars[ "zombie_powerup_fire_sale_on" ] ) ) + { + return; + } + while ( level.zombie_vars[ "zombie_powerup_fire_sale_on" ] ) + { + for ( i = 0; i < level.chests.size; i++ ) + { + show_firesale_box = level.chests[ i ] [[ level._zombiemode_check_firesale_loc_valid_func ]](); + if ( show_firesale_box ) + { + level.chests[ i ].zombie_cost = 10; + if ( level.chest_index != i ) + { + level.chests[ i ].was_temp = 1; + if ( is_true( level.chests[ i ].hidden ) ) + { + level.chests[ i ] thread maps/mp/zombies/_zm_magicbox::show_chest(); + } + wait_network_frame(); + } + } + } + level waittill( "fire_sale_off" ); + waittillframeend; + for ( i = 0; i < level.chests.size; i++ ) + { + show_firesale_box = level.chests[ i ] [[ level._zombiemode_check_firesale_loc_valid_func ]](); + if ( show_firesale_box ) + { + if ( level.chest_index != i && isDefined( level.chests[ i ].was_temp ) ) + { + level.chests[ i ].was_temp = undefined; + level thread remove_temp_chest( i ); + } + level.chests[ i ].zombie_cost = level.chests[ i ].old_cost; + } + } + } +} + +fire_sale_weapon_wait() //checked matches cerberus output +{ + self.zombie_cost = self.old_cost; + while ( isDefined( self.chest_user ) ) + { + wait_network_frame(); + } + self set_hint_string( self, "default_treasure_chest", self.zombie_cost ); +} + +remove_temp_chest( chest_index ) //checked partially matches cerberus output did not change +{ + while ( isDefined( level.chests[ chest_index ].chest_user ) || isDefined( level.chests[ chest_index ]._box_open ) && level.chests[ chest_index ]._box_open == 1 ) + { + wait_network_frame(); + } + if ( level.zombie_vars[ "zombie_powerup_fire_sale_on" ] ) + { + level.chests[ chest_index ].was_temp = 1; + level.chests[ chest_index ].zombie_cost = 10; + return; + } + for ( i = 0; i < chest_index; i++ ) + { + wait_network_frame(); + } + playfx( level._effect[ "poltergeist" ], level.chests[ chest_index ].orig_origin ); + level.chests[ chest_index ].zbarrier playsound( "zmb_box_poof_land" ); + level.chests[ chest_index ].zbarrier playsound( "zmb_couch_slam" ); + wait_network_frame(); + level.chests[ chest_index ] maps/mp/zombies/_zm_magicbox::hide_chest(); +} + +devil_dialog_delay() //checked matches cerberus output +{ + wait 1; +} + +full_ammo_on_hud( drop_item, player_team ) //checked matches cerberus output +{ + self endon( "disconnect" ); + hudelem = maps/mp/gametypes_zm/_hud_util::createserverfontstring( "objective", 2, player_team ); + 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 ) ); + hudelem.sort = 0.5; + hudelem.alpha = 0; + hudelem fadeovertime( 0.5 ); + hudelem.alpha = 1; + if ( isDefined( drop_item ) ) + { + hudelem.label = drop_item.hint; + } + hudelem thread full_ammo_move_hud( player_team ); +} + +full_ammo_move_hud( player_team ) //checked matches cerberus output +{ + players = get_players( player_team ); + players[ 0 ] playsoundtoteam( "zmb_full_ammo", player_team ); + wait 0.5; + move_fade_time = 1.5; + self fadeovertime( move_fade_time ); + self moveovertime( move_fade_time ); + self.y = 270; + self.alpha = 0; + wait move_fade_time; + self destroy(); +} + +check_for_rare_drop_override( pos ) //checked matches cerberus output +{ + if ( isDefined( flag( "ape_round" ) ) && flag( "ape_round" ) ) + { + return 0; + } + return 0; +} + +setup_firesale_audio() //checked changed to match cerberus output +{ + wait 2; + intercom = getentarray( "intercom", "targetname" ); + while ( 1 ) + { + while ( level.zombie_vars[ "zombie_powerup_fire_sale_on" ] == 0 ) + { + wait 0.2; + } + for ( i = 0; i < intercom.size; i++ ) + { + intercom [i ] thread play_firesale_audio(); + } + while ( level.zombie_vars[ "zombie_powerup_fire_sale_on" ] == 1 ) + { + wait 0.1; + } + level notify( "firesale_over" ); + } +} + +play_firesale_audio() //checked matches cerberus output +{ + if ( isDefined( level.sndfiresalemusoff ) && level.sndfiresalemusoff ) + { + return; + } + if ( isDefined( level.sndannouncerisrich ) && level.sndannouncerisrich ) + { + self playloopsound( "mus_fire_sale_rich" ); + } + else + { + self playloopsound( "mus_fire_sale" ); + } + level waittill( "firesale_over" ); + self stoploopsound(); +} + +setup_bonfiresale_audio() //checked changed to match cerberus output +{ + wait 2; + intercom = getentarray( "intercom", "targetname" ); + while ( 1 ) + { + while ( level.zombie_vars[ "zombie_powerup_fire_sale_on" ] == 0 ) + { + wait 0.2; + } + for ( i = 0; i < intercom.size; i++ ) + { + intercom[ i ] thread play_bonfiresale_audio(); + } + while ( level.zombie_vars[ "zombie_powerup_fire_sale_on" ] == 1 ) + { + wait 0.1; + } + level notify( "firesale_over" ); + } +} + +play_bonfiresale_audio() //checked matches cerberus output +{ + if ( isDefined( level.sndfiresalemusoff ) && level.sndfiresalemusoff ) + { + return; + } + if ( isDefined( level.sndannouncerisrich ) && level.sndannouncerisrich ) + { + self playloopsound( "mus_fire_sale_rich" ); + } + else + { + self playloopsound( "mus_fire_sale" ); + } + level waittill( "firesale_over" ); + self stoploopsound(); +} + +free_perk_powerup( item ) //checked changed to match cerberus output +{ + players = get_players(); + for ( i = 0; i < players.size; i++ ) + { + if ( !players[ i ] maps/mp/zombies/_zm_laststand::player_is_in_laststand() && players[ i ].sessionstate != "spectator" ) + { + player = players[ i ]; + if ( isDefined( item.ghost_powerup ) ) + { + player maps/mp/zombies/_zm_stats::increment_client_stat( "buried_ghost_perk_acquired", 0 ); + player maps/mp/zombies/_zm_stats::increment_player_stat( "buried_ghost_perk_acquired" ); + player notify( "player_received_ghost_round_free_perk" ); + } + free_perk = player maps/mp/zombies/_zm_perks::give_random_perk(); + if ( isDefined( level.disable_free_perks_before_power ) && level.disable_free_perks_before_power ) + { + player thread disable_perk_before_power( free_perk ); + } + } + } +} + +disable_perk_before_power( perk ) //checked matches cerberus output +{ + self endon( "disconnect" ); + if ( isDefined( perk ) ) + { + wait 0.1; + if ( !flag( "power_on" ) ) + { + a_players = get_players(); + if ( isDefined( a_players ) && a_players.size == 1 && perk == "specialty_quickrevive" ) + { + return; + } + self perk_pause( perk ); + flag_wait( "power_on" ); + self perk_unpause( perk ); + } + } +} + +random_weapon_powerup_throttle() //checked matches cerberus output +{ + self.random_weapon_powerup_throttle = 1; + wait 0.25; + self.random_weapon_powerup_throttle = 0; +} + +random_weapon_powerup( item, player ) //checked partially matches cerberus output did not change +{ + if ( player.sessionstate == "spectator" || player maps/mp/zombies/_zm_laststand::player_is_in_laststand() ) + { + return 0; + } + if ( isDefined( player.random_weapon_powerup_throttle ) && !player.random_weapon_powerup_throttle || player isswitchingweapons() && player.is_drinking > 0 ) + { + return 0; + } + current_weapon = player getcurrentweapon(); + current_weapon_type = weaponinventorytype( current_weapon ); + if ( !is_tactical_grenade( item.weapon ) ) + { + if ( current_weapon_type != "primary" && current_weapon_type != "altmode" ) + { + return 0; + } + if ( !isDefined( level.zombie_weapons[ current_weapon ] ) && !maps/mp/zombies/_zm_weapons::is_weapon_upgraded( current_weapon ) && current_weapon_type != "altmode" ) + { + return 0; + } + } + player thread random_weapon_powerup_throttle(); + weapon_string = item.weapon; + if ( weapon_string == "knife_ballistic_zm" ) + { + weapon = player maps/mp/zombies/_zm_melee_weapon::give_ballistic_knife( weapon_string, 0 ); + } + else + { + if ( weapon_string == "knife_ballistic_upgraded_zm" ) + { + weapon = player maps/mp/zombies/_zm_melee_weapon::give_ballistic_knife( weapon_string, 1 ); + } + } + player thread maps/mp/zombies/_zm_weapons::weapon_give( weapon_string ); + return 1; +} + +bonus_points_player_powerup( item, player ) //checked matches cerberus output +{ + points = randomintrange( 1, 25 ) * 100; + if ( isDefined( level.bonus_points_powerup_override ) ) + { + points = [[ level.bonus_points_powerup_override ]](); + } + if ( !player maps/mp/zombies/_zm_laststand::player_is_in_laststand() && player.sessionstate != "spectator" ) + { + player maps/mp/zombies/_zm_score::player_add_points( "bonus_points_powerup", points ); + } +} + +bonus_points_team_powerup( item ) //checked changed to match cerberus output +{ + points = randomintrange( 1, 25 ) * 100; + if ( isDefined( level.bonus_points_powerup_override ) ) + { + points = [[ level.bonus_points_powerup_override ]](); + } + players = get_players(); + for ( i = 0; i < players.size; i++ ) + { + if ( !players[ i ] maps/mp/zombies/_zm_laststand::player_is_in_laststand() && players[ i ].sessionstate != "spectator" ) + { + players[ i ] maps/mp/zombies/_zm_score::player_add_points( "bonus_points_powerup", points ); + } + } +} + +lose_points_team_powerup( item ) //checked partially changed to match cerberus output +{ + points = randomintrange( 1, 25 ) * 100; + players = get_players(); + i = 0; + while ( i < players.size ) + { + if ( !players[ i ] maps/mp/zombies/_zm_laststand::player_is_in_laststand() && players[ i ].sessionstate != "spectator" ) + { + if ( ( players[ i ].score - points ) <= 0 ) + { + players[ i ] maps/mp/zombies/_zm_score::minus_to_player_score( players[ i ].score ); + i++; + continue; + } + else + { + players[ i ] maps/mp/zombies/_zm_score::minus_to_player_score( points ); + } + } + i++; + } +} + +lose_perk_powerup( item ) //checked partially matches cerberus output +{ + players = get_players(); + for ( i = 0; i < players.size; i++ ) + { + player = players[ i ]; + if ( !player maps/mp/zombies/_zm_laststand::player_is_in_laststand() && player.sessionstate != "spectator" ) + { + player maps/mp/zombies/_zm_perks::lose_random_perk(); + } + } +} + +empty_clip_powerup( item ) //checked partially matches cerberus output +{ + players = get_players(); + for ( i = 0; i < players.size; i++ ) + { + player = players[ i ]; + if ( !player maps/mp/zombies/_zm_laststand::player_is_in_laststand() && player.sessionstate != "spectator" ) + { + weapon = player getcurrentweapon(); + player setweaponammoclip( weapon, 0 ); + } + } +} + +minigun_weapon_powerup( ent_player, time ) //checked matches cerberus output +{ + ent_player endon( "disconnect" ); + ent_player endon( "death" ); + ent_player endon( "player_downed" ); + if ( !isDefined( time ) ) + { + time = 30; + } + if ( isDefined( level._minigun_time_override ) ) + { + time = level._minigun_time_override; + } + if ( ent_player.zombie_vars[ "zombie_powerup_minigun_on" ] || ent_player getcurrentweapon() == "minigun_zm" && isDefined( ent_player.has_minigun ) && ent_player.has_minigun ) + { + if ( ent_player.zombie_vars[ "zombie_powerup_minigun_time" ] < time ) + { + ent_player.zombie_vars[ "zombie_powerup_minigun_time" ] = time; + } + return; + } + ent_player notify( "replace_weapon_powerup" ); + ent_player._show_solo_hud = 1; + level._zombie_minigun_powerup_last_stand_func = ::minigun_watch_gunner_downed; + ent_player.has_minigun = 1; + ent_player.has_powerup_weapon = 1; + ent_player increment_is_drinking(); + ent_player._zombie_gun_before_minigun = ent_player getcurrentweapon(); + ent_player giveweapon( "minigun_zm" ); + ent_player switchtoweapon( "minigun_zm" ); + ent_player.zombie_vars[ "zombie_powerup_minigun_on" ] = 1; + level thread minigun_weapon_powerup_countdown( ent_player, "minigun_time_over", time ); + level thread minigun_weapon_powerup_replace( ent_player, "minigun_time_over" ); +} + +minigun_weapon_powerup_countdown( ent_player, str_gun_return_notify, time ) //checked matches cerberus output +{ + ent_player endon( "death" ); + ent_player endon( "disconnect" ); + ent_player endon( "player_downed" ); + ent_player endon( str_gun_return_notify ); + ent_player endon( "replace_weapon_powerup" ); + setclientsysstate( "levelNotify", "minis", ent_player ); + ent_player.zombie_vars[ "zombie_powerup_minigun_time" ] = time; + while ( ent_player.zombie_vars[ "zombie_powerup_minigun_time" ] > 0 ) + { + wait 0.05; + ent_player.zombie_vars[ "zombie_powerup_minigun_time" ] -= 0.05; + } + setclientsysstate( "levelNotify", "minie", ent_player ); + level thread minigun_weapon_powerup_remove( ent_player, str_gun_return_notify ); +} + +minigun_weapon_powerup_replace( ent_player, str_gun_return_notify ) //checked matches cerberus output +{ + ent_player endon( "death" ); + ent_player endon( "disconnect" ); + ent_player endon( "player_downed" ); + ent_player endon( str_gun_return_notify ); + ent_player waittill( "replace_weapon_powerup" ); + ent_player takeweapon( "minigun_zm" ); + ent_player.zombie_vars[ "zombie_powerup_minigun_on" ] = 0; + ent_player.has_minigun = 0; + ent_player decrement_is_drinking(); +} + +minigun_weapon_powerup_remove( ent_player, str_gun_return_notify ) //checked partially matches cerberus output did not change +{ + ent_player endon( "death" ); + ent_player endon( "player_downed" ); + ent_player takeweapon( "minigun_zm" ); + ent_player.zombie_vars[ "zombie_powerup_minigun_on" ] = 0; + ent_player._show_solo_hud = 0; + ent_player.has_minigun = 0; + ent_player.has_powerup_weapon = 0; + ent_player notify( str_gun_return_notify ); + ent_player decrement_is_drinking(); + while ( isDefined( ent_player._zombie_gun_before_minigun ) ) + { + player_weapons = ent_player getweaponslistprimaries(); + + for ( i = 0; i < player_weapons.size; i++ ) + { + if ( player_weapons[ i ] == ent_player._zombie_gun_before_minigun ) + { + ent_player switchtoweapon( ent_player._zombie_gun_before_minigun ); + return; + } + } + } + primaryweapons = ent_player getweaponslistprimaries(); + if ( primaryweapons.size > 0 ) + { + ent_player switchtoweapon( primaryweapons[ 0 ] ); + } + else + { + allweapons = ent_player getweaponslist( 1 ); + for ( i = 0; i < allweapons.size; i++ ) + { + if ( is_melee_weapon( allweapons[ i ] ) ) + { + ent_player switchtoweapon( allweapons[ i ] ); + return; + } + } + } +} + +minigun_weapon_powerup_off() //checked matches cerberus output +{ + self.zombie_vars[ "zombie_powerup_minigun_time" ] = 0; +} + +minigun_watch_gunner_downed() //checked partially matches cerberus output did not change +{ + if ( isDefined( self.has_minigun ) && !self.has_minigun ) + { + return; + } + primaryweapons = self getweaponslistprimaries(); + for ( i = 0; i < primaryweapons.size; i++ ) + { + if ( primaryweapons[ i ] == "minigun_zm" ) + { + self takeweapon( "minigun_zm" ); + } + } + self notify( "minigun_time_over" ); + self.zombie_vars[ "zombie_powerup_minigun_on" ] = 0; + self._show_solo_hud = 0; + wait 0.05; + self.has_minigun = 0; + self.has_powerup_weapon = 0; +} + +tesla_weapon_powerup( ent_player, time ) //checked changed to match cerberus output +{ + ent_player endon( "disconnect" ); + ent_player endon( "death" ); + ent_player endon( "player_downed" ); + if ( !isDefined( time ) ) + { + time = 11; + } + if ( ent_player.zombie_vars[ "zombie_powerup_tesla_on" ] && ent_player getcurrentweapon() == "tesla_gun_zm" || isDefined( ent_player.has_tesla ) && ent_player.has_tesla ) + { + ent_player givemaxammo( "tesla_gun_zm" ); + if ( ent_player.zombie_vars[ "zombie_powerup_tesla_time" ] < time ) + { + ent_player.zombie_vars[ "zombie_powerup_tesla_time" ] = time; + } + return; + } + ent_player notify( "replace_weapon_powerup" ); + ent_player._show_solo_hud = 1; + level._zombie_tesla_powerup_last_stand_func = ::tesla_watch_gunner_downed; + ent_player.has_tesla = 1; + ent_player.has_powerup_weapon = 1; + ent_player increment_is_drinking(); + ent_player._zombie_gun_before_tesla = ent_player getcurrentweapon(); + ent_player giveweapon( "tesla_gun_zm" ); + ent_player givemaxammo( "tesla_gun_zm" ); + ent_player switchtoweapon( "tesla_gun_zm" ); + ent_player.zombie_vars[ "zombie_powerup_tesla_on" ] = 1; + level thread tesla_weapon_powerup_countdown( ent_player, "tesla_time_over", time ); + level thread tesla_weapon_powerup_replace( ent_player, "tesla_time_over" ); +} + +tesla_weapon_powerup_countdown( ent_player, str_gun_return_notify, time ) //checked changed to match cerberus output +{ + ent_player endon( "death" ); + ent_player endon( "player_downed" ); + ent_player endon( str_gun_return_notify ); + ent_player endon( "replace_weapon_powerup" ); + setclientsysstate( "levelNotify", "minis", ent_player ); + ent_player.zombie_vars[ "zombie_powerup_tesla_time" ] = time; + while ( 1 ) + { + ent_player waittill_any( "weapon_fired", "reload", "zmb_max_ammo" ); + if ( !ent_player getweaponammostock( "tesla_gun_zm" ) ) + { + clip_count = ent_player getweaponammoclip( "tesla_gun_zm" ); + if ( !clip_count ) + { + break; + } + else if ( clip_count == 1 ) + { + ent_player.zombie_vars[ "zombie_powerup_tesla_time" ] = 1; + } + else if ( clip_count == 3 ) + { + ent_player.zombie_vars[ "zombie_powerup_tesla_time" ] = 6; + } + } + else + { + ent_player.zombie_vars[ "zombie_powerup_tesla_time" ] = 11; + } + } + setclientsysstate( "levelNotify", "minie", ent_player ); + level thread tesla_weapon_powerup_remove( ent_player, str_gun_return_notify ); +} + +tesla_weapon_powerup_replace( ent_player, str_gun_return_notify ) //checked matches cerberus output +{ + ent_player endon( "death" ); + ent_player endon( "disconnect" ); + ent_player endon( "player_downed" ); + ent_player endon( str_gun_return_notify ); + ent_player waittill( "replace_weapon_powerup" ); + ent_player takeweapon( "tesla_gun_zm" ); + ent_player.zombie_vars[ "zombie_powerup_tesla_on" ] = 0; + ent_player.has_tesla = 0; + ent_player decrement_is_drinking(); +} + +tesla_weapon_powerup_remove( ent_player, str_gun_return_notify ) //checked changed to match cerberus output +{ + ent_player endon( "death" ); + ent_player endon( "player_downed" ); + ent_player takeweapon( "tesla_gun_zm" ); + ent_player.zombie_vars[ "zombie_powerup_tesla_on" ] = 0; + ent_player._show_solo_hud = 0; + ent_player.has_tesla = 0; + ent_player.has_powerup_weapon = 0; + ent_player notify( str_gun_return_notify ); + ent_player decrement_is_drinking(); + if ( isDefined( ent_player._zombie_gun_before_tesla ) ) + { + player_weapons = ent_player getweaponslistprimaries(); + for ( i = 0; i < player_weapons.size; i++ ) + { + if ( player_weapons[ i ] == ent_player._zombie_gun_before_tesla ) + { + ent_player switchtoweapon( ent_player._zombie_gun_before_tesla ); + return; + } + } + } + primaryweapons = ent_player getweaponslistprimaries(); + if ( primaryweapons.size > 0 ) + { + ent_player switchtoweapon( primaryweapons[ 0 ] ); + } + allweapons = ent_player getweaponslist( 1 ); + for ( i = 0; i < allweapons.size; i++ ) + { + if ( is_melee_weapon( allweapons[ i ] ) ) + { + ent_player switchtoweapon( allweapons[ i ] ); + return; + } + } +} + +tesla_weapon_powerup_off() //checked matches cerberus output +{ + self.zombie_vars[ "zombie_powerup_tesla_time" ] = 0; +} + +tesla_watch_gunner_downed() //checked changed to match cerberus output +{ + if ( isDefined( self.has_tesla ) && !self.has_tesla ) + { + return; + } + primaryweapons = self getweaponslistprimaries(); + for ( i = 0; i < primaryweapons.size; i++ ) + { + if ( primaryweapons[ i ] == "tesla_gun_zm" ) + { + self takeweapon( "tesla_gun_zm" ); + } + } + self notify( "tesla_time_over" ); + self.zombie_vars[ "zombie_powerup_tesla_on" ] = 0; + self._show_solo_hud = 0; + wait 0.05; + self.has_tesla = 0; + self.has_powerup_weapon = 0; +} + +tesla_powerup_active() //checked changed to match cerberus output +{ + players = get_players(); + for ( i = 0; i < players.size; i++ ) + { + if ( players[ i ].zombie_vars[ "zombie_powerup_tesla_on" ] ) + { + return 1; + } + } + return 0; +} + +print_powerup_drop( powerup, type ) //devcall only, deleted +{ + /* + /# + if(!isdefined(level.powerup_drop_time)) + { + level.powerup_drop_time = 0; + level.powerup_random_count = 0; + level.powerup_score_count = 0; + } + time = GetTime() - level.powerup_drop_time * 0.001; + level.powerup_drop_time = GetTime(); + if(type == "random") + { + level.powerup_random_count++; + } + else + { + level.powerup_score_count++; + } + println("========== POWER UP DROPPED =========="); + println("DROPPED: " + powerup); + println("HOW IT DROPPED: " + type); + println("--------------------"); + println("Drop Time: " + time); + println("Random Powerup Count: " + level.powerup_random_count); + println("Random Powerup Count: " + level.powerup_score_count); + println("======================================"); + #/ + */ +} + +register_carpenter_node( node, callback ) //checked matches cerberus output +{ + if ( !isDefined( level._additional_carpenter_nodes ) ) + { + level._additional_carpenter_nodes = []; + } + node._post_carpenter_callback = callback; + level._additional_carpenter_nodes[ level._additional_carpenter_nodes.size ] = node; +} + +start_carpenter_new( origin ) //checked partially changed to match cerberus output +{ + level.carpenter_powerup_active = 1; + window_boards = getstructarray( "exterior_goal", "targetname" ); + if ( isDefined( level._additional_carpenter_nodes ) ) + { + window_boards = arraycombine( window_boards, level._additional_carpenter_nodes, 0, 0 ); + } + carp_ent = spawn( "script_origin", ( 0, 0, 0 ) ); + carp_ent playloopsound( "evt_carpenter" ); + boards_near_players = get_near_boards( window_boards ); + boards_far_from_players = get_far_boards( window_boards ); + level repair_far_boards( boards_far_from_players, maps/mp/zombies/_zm_powerups::is_carpenter_boards_upgraded() ); + + i = 0; + while ( i < boards_near_players.size ) + { + window = boards_near_players[ i ]; + num_chunks_checked = 0; + last_repaired_chunk = undefined; + while ( 1 ) + { + if ( all_chunks_intact( window, window.barrier_chunks ) ) + { + break; + } + chunk = get_random_destroyed_chunk( window, window.barrier_chunks ); + if ( !isDefined( chunk ) ) + { + break; + } + window thread maps/mp/zombies/_zm_blockers::replace_chunk( window, chunk, undefined, maps/mp/zombies/_zm_powerups::is_carpenter_boards_upgraded(), 1 ); + last_repaired_chunk = chunk; + if ( isDefined( window.clip ) ) + { + window.clip enable_trigger(); + window.clip disconnectpaths(); + } + else + { + blocker_disconnect_paths( window.neg_start, window.neg_end ); + } + wait_network_frame(); + num_chunks_checked++; + if ( num_chunks_checked >= 20 ) + { + break; + } + } + if ( isDefined( window.zbarrier ) ) + { + if ( isDefined( last_repaired_chunk ) ) + { + while ( window.zbarrier getzbarrierpiecestate( last_repaired_chunk ) == "closing" ) + { + wait 0.05; + } + if ( isDefined( window._post_carpenter_callback ) ) + { + window [[ window._post_carpenter_callback ]](); + } + } + i++; + continue; + } + while ( isDefined( last_repaired_chunk ) && last_repaired_chunk.state == "mid_repair" ) + { + wait 0.05; + } + i++; + } + carp_ent stoploopsound( 1 ); + carp_ent playsoundwithnotify( "evt_carpenter_end", "sound_done" ); + carp_ent waittill( "sound_done" ); + players = get_players(); + for ( i = 0; i < players.size; i++ ) + { + players[ i ] maps/mp/zombies/_zm_score::player_add_points( "carpenter_powerup", 200 ); + } + carp_ent delete(); + level notify( "carpenter_finished" ); + level.carpenter_powerup_active = undefined; +} + +is_carpenter_boards_upgraded() //checked matches cerberus output +{ + if ( isDefined( level.pers_carpenter_boards_active ) && level.pers_carpenter_boards_active == 1 ) + { + return 1; + } + return 0; +} + +get_near_boards( windows ) //checked changed to match cerberus output +{ + players = get_players(); + boards_near_players = []; + for ( j = 0; j < windows.size; j++ ) + { + close = 0; + for ( i = 0; i < players.size; i++ ) + { + origin = undefined; + if ( isdefined( windows[ j ].zbarrier ) ) + { + origin = windows[ j ].zbarrier.origin; + } + else + { + origin = windows[ j ].origin; + } + if ( distancesquared( players[ i ].origin, origin ) <= level.board_repair_distance_squared ) + { + close = 1; + break; + } + } + if ( close ) + { + boards_near_players[ boards_near_players.size ] = windows[ j ]; + } + } + return boards_near_players; +} + +get_far_boards( windows ) //checked changed to match cerberus output +{ + players = get_players(); + boards_far_from_players = []; + for ( j = 0; j < windows.size; j++ ) + { + close = 0; + for ( i = 0; i < players.size; i++ ) + { + origin = undefined; + if ( isdefined( windows[ j ].zbarrier ) ) + { + origin = windows[ j ].zbarrier.origin; + } + else + { + origin = windows[ j ].origin; + } + if ( distancesquared( players[ i ].origin, origin ) >= level.board_repair_distance_squared ) + { + close = 1; + break; + } + } + if ( close ) + { + boards_far_from_players[ boards_far_from_players.size ] = windows[ j ]; + } + } + return boards_far_from_players; +} + +repair_far_boards( barriers, upgrade ) //checked changed to match cerberus output +{ + i = 0; + while ( i < barriers.size ) + { + barrier = barriers[ i ]; + if ( all_chunks_intact( barrier, barrier.barrier_chunks ) ) + { + i++; + continue; + } + if ( isdefined( barrier.zbarrier ) ) + { + a_pieces = barrier.zbarrier getzbarrierpieceindicesinstate( "open" ); + if ( isdefined( a_pieces ) ) + { + xx = 0; + while ( xx < a_pieces.size ) + { + chunk = a_pieces[ xx ]; + if ( upgrade ) + { + barrier.zbarrier zbarrierpieceuseupgradedmodel( chunk ); + barrier.zbarrier.chunk_health[ chunk ] = barrier.zbarrier getupgradedpiecenumlives( chunk ); + xx++; + continue; + } + barrier.zbarrier zbarrierpieceusedefaultmodel( chunk ); + barrier.zbarrier.chunk_health[ chunk ] = 0; + xx++; + } + } + for ( x = 0; x < barrier.zbarrier getnumzbarrierpieces(); x++ ) + { + barrier.zbarrier setzbarrierpiecestate( x, "closed" ); + barrier.zbarrier showzbarrierpiece( x ); + } + } + else if ( isdefined( barrier.clip ) ) + { + barrier.clip enable_trigger(); + barrier.clip disconnectpaths(); + } + else + { + blocker_disconnect_paths( barrier.neg_start, barrier.neg_end ); + } + if ( i % 4 == 0 ) + { + wait_network_frame(); + } + i++; + } +} + +track_pack_a_punch_drops() +{ + level endon("end_game"); + level.rounds_since_last_pack_a_punch = 0; + for(;;) + { + level waittill("start_of_round"); + level.rounds_since_last_pack_a_punch_drop += 1; + wait 0.5; + } +} + +func_should_drop_pack_a_punch() +{ + 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 ) + { + return 0; + } + return 1; +} + +func_should_never_drop() //checked matches cerberus output +{ + return 0; +} + +func_should_always_drop() //checked matches cerberus output +{ + return 1; +} + +func_should_drop_minigun() +{ + if ( minigun_no_drop() ) + { + return 0; + } + return 1; +} + +func_should_drop_carpenter() +{ + if ( get_num_window_destroyed() < 5 ) + { + return 0; + } + return 1; +} + +func_should_drop_fire_sale() +{ + if ( level.zombie_vars[ "zombie_powerup_fire_sale_on" ] == 1 || level.chest_moves < 1 || isDefined( level.disable_firesale_drop ) && level.disable_firesale_drop ) + { + return 0; + } + return 1; +} + +powerup_move() +{ + self endon( "powerup_timedout" ); + self endon( "powerup_grabbed" ); + drag_speed = 75; + while ( 1 ) + { + self waittill( "move_powerup", moveto, distance ); + drag_vector = moveto - self.origin; + range_squared = lengthsquared( drag_vector ); + if ( range_squared > distance * distance ) + { + drag_vector = vectornormalize( drag_vector ); + drag_vector = distance * drag_vector; + moveto = self.origin + drag_vector; + } + self.origin = moveto; + } +} + +powerup_emp() +{ + self endon( "powerup_timedout" ); + self endon( "powerup_grabbed" ); + if ( !should_watch_for_emp() ) + { + return; + } + while ( 1 ) + { + level waittill( "emp_detonate", origin, radius ); + if ( distancesquared( origin, self.origin ) < ( radius * radius ) ) + { + playfx( level._effect[ "powerup_off" ], self.origin ); + self thread powerup_delete_delayed(); + self notify( "powerup_timedout" ); + } + } +} + +get_powerups( origin, radius ) +{ + if ( isDefined( origin ) && isDefined( radius ) ) + { + powerups = []; + foreach ( powerup in level.active_powerups ) + { + if ( distancesquared( origin, powerup.origin ) < radius * radius ) + { + powerups[ powerups.size ] = powerup; + } + } + return powerups; + } + return level.active_powerups; +} + +should_award_stat( powerup_name ) +{ + if ( powerup_name == "teller_withdrawl" || powerup_name == "blue_monkey" || powerup_name == "free_perk" || powerup_name == "bonus_points_player" ) + { + return 0; + } + if ( isDefined( level.statless_powerups ) && isDefined( level.statless_powerups[ powerup_name ] ) ) + { + return 0; + } + return 1; +} + +teller_withdrawl( powerup, player ) +{ + player maps/mp/zombies/_zm_score::add_to_player_score( powerup.value ); +} + +zombies_always_drop_powerups() +{ + if ( !level.zombiesAlwaysDropPowerups ) + { + return; + } + while ( 1 ) + { + level.zombie_vars[ "zombie_drop_item" ] = level.zombiesAlwaysDropPowerups; + wait 0.05; + } +} + +doFastFeet() +{ + level endon("end_game"); + self endon( "disconnect" ); + self thread poweruptext("Fast Feet!"); + self playsound("zmb_cha_ching"); + self setmovespeedscale(3); + wait 15; + self setmovespeedscale(1); + self playsound("zmb_insta_kill"); +} + +doUnlimitedAmmo() +{ + level endon("end_game"); + foreach(player in level.players) + { + player notify("end_unlimited_ammo"); + player playsound("zmb_cha_ching"); + player thread poweruptext("Bottomless Clip"); + player thread monitorUnlimitedAmmo(); + player thread notifyUnlimitedAmmoEnd(); + } +} + +monitorUnlimitedAmmo() +{ + level endon("end_game"); + self endon("disonnect"); + self endon("end_unlimited_ammo"); + for(;;) + { + self setWeaponAmmoClip(self GetCurrentWeapon(), 150); + wait .05; + } +} + +notifyUnlimitedAmmoEnd() +{ + level endon("end_game"); + self endon("disonnect"); + self endon("end_unlimited_ammo"); + wait level.unlimited_ammo_duration; + self playsound("zmb_insta_kill"); + self notify("end_unlimited_ammo"); +} + +doPackAPunchWeapon() +{ + baseweapon = get_base_name(self getcurrentweapon()); + weapon = get_upgrade(baseweapon); + if(IsDefined(weapon) && isDefined(self.packapunching)) + { + level.rounds_since_last_pack_a_punch_drop = 0; + self.packapunching = undefined; + self takeweapon(baseweapon); + self giveweapon(weapon, 0, self get_pack_a_punch_weapon_options(weapon)); + self switchtoweapon(weapon); + self givemaxammo(weapon); + } + else + self playsoundtoplayer( level.zmb_laugh_alias, self ); +} + +get_upgrade(weapon) +{ + if(IsDefined(level.zombie_weapons[weapon].upgrade_name) && IsDefined(level.zombie_weapons[weapon])) + { + self.packapunching = true; + return get_upgrade_weapon(weapon, 0 ); + } + else + return get_upgrade_weapon(weapon, 1 ); +} + +doRandomScore() +{ + x = randomInt(9); + self playsound("zmb_cha_ching"); + if(x==1) + self.score += 50; + else if(x==2) + self.score += 100; + else if(x==3) + self.score += 250; + else if(x==4) + self.score += 500; + else if(x==5) + self.score += 750; + else if(x==6) + self.score += 1000; + else if(x==7) + self.score += 2500; + else if(x==8) + self.score += 5000; + else if(x==9) + self.score += 7500; + else + self.score += 10000; +} + +poweruptext(text) +{ + self endon("disconnect"); + level endon("end_game"); + hud_string = newclienthudelem(self); + hud_string.elemtype = "font"; + hud_string.font = "objective"; + hud_string.fontscale = 2; + hud_string.x = 0; + hud_string.y = 0; + hud_string.width = 0; + hud_string.height = int( level.fontheight * 2 ); + hud_string.xoffset = 0; + hud_string.yoffset = 0; + hud_string.children = []; + hud_string setparent(level.uiparent); + hud_string.hidden = 0; + 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)); + hud_string.sort = .5; + hud_string.alpha = 0; + hud_string fadeovertime(.5); + hud_string.alpha = 1; + hud_string setText(text); + hud_string thread poweruptextmove(); +} + +poweruptextmove() +{ + wait .5; + self fadeovertime(1.5); + self moveovertime(1.5); + self.y = 270; + self.alpha = 0; + wait 1.5; + self destroy(); +}