From 27de683019b37a6b4c3f62099ecd125112f2ba86 Mon Sep 17 00:00:00 2001 From: Cahz Date: Wed, 20 May 2020 20:37:46 -0700 Subject: [PATCH] Add files via upload --- zomb++ (UPDATE)/main.gsc | 126 +++ zomb++ (UPDATE)/zm_custom_easteregg.gsc | 174 +++++ zomb++ (UPDATE)/zm_custom_perks.gsc | 296 +++++++ zomb++ (UPDATE)/zm_custom_powerups.gsc | 194 +++++ zomb++ (UPDATE)/zm_server_functions.gsc | 987 ++++++++++++++++++++++++ 5 files changed, 1777 insertions(+) create mode 100644 zomb++ (UPDATE)/main.gsc create mode 100644 zomb++ (UPDATE)/zm_custom_easteregg.gsc create mode 100644 zomb++ (UPDATE)/zm_custom_perks.gsc create mode 100644 zomb++ (UPDATE)/zm_custom_powerups.gsc create mode 100644 zomb++ (UPDATE)/zm_server_functions.gsc diff --git a/zomb++ (UPDATE)/main.gsc b/zomb++ (UPDATE)/main.gsc new file mode 100644 index 0000000..40dc1cf --- /dev/null +++ b/zomb++ (UPDATE)/main.gsc @@ -0,0 +1,126 @@ +#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; +#include maps/mp/zombies/_zm_spawner; +#include maps/mp/zombies/_zm_transit; + + +init() +{ + startInit(); //precaching models + level thread onPlayerConnect(); //on connect + thread initCustomPowerups(); //initilize custom powerups + thread initServerDvars(); //initilize server dvars (credit JezuzLizard) + level.playerDamageStub = level.callbackplayerdamage; //damage callback for phd flopper + level.callbackplayerdamage = ::phd_flopper_dmg_check; //more damage callback stuff. everybody do the flop + isTown(); //jezuzlizard's fix for tombstone :) + //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 +} +onPlayerConnect() +{ + level endon( "end_game" ); + self endon( "disconnect" ); + for (;;) + { + level waittill( "connected", player ); + + player thread [[level.givecustomcharacters]](); + player thread onPlayerSpawned(); + player thread spawnIfRoundOne(); //force spawns if round 1. no more spectating one player on round 1 + player thread startCustomPowerups(); //start custom powerups - Credit _Ox. just edited and added more powerups. + player thread startCustomPerkMachines(); //spawns custom perk machines on the map + player thread startCustomBank(); //custom bank (this doesnt fix the bank,it just emulates it) + player thread customEasterEgg(); //not optimized code tbh + } +} +onPlayerSpawned() +{ + level endon( "end_game" ); + self endon( "disconnect" ); + for(;;) + { + self waittill( "spawned_player" ); + + if( level.enableDebugMode == 1) + { + self notify("reset_debug_binds"); + self thread debugButtonMonitor(); + self.score = 500000; + } + if(level.round_number >= 5 && self.score < 2500) //in case players have low score and die or players join late (Helps to aid the high round, cant afford jug or gun situation) + self.score = 2500; + else if(level.round_number >= 15 && self.score < 5000) + self.score = 5000; + wait 5; + //self EnableInvulnerability(); + self giveWeapon("ray_gun_zm"); + self SwitchToWeapon("ray_gun_zm"); + //self thread ConnectMessages(); //just does the connect messages when you spawn in + self thread initCustomPerksOnPlayer(); //checks mapname and if it should give PHD flopper automatically + } +} +ConnectMessages() +{ + wait 5; + self connectMessage( "Welcome to ^1ZOMBIES++^7! \nDeveloped by ^5@ItsCahz" , false ); + wait 5; + self connectMessage( "Your ^2Perk Limit ^7is ^2"+level.perk_purchase_limit+" ^7perks!" , false ); + wait 5; + if(getDvar("mapname") == "zm_prison" || getDvar("mapname") == "zm_highrise" || getDvar("mapname") == "zm_buried" || getDvar("mapname") == "zm_nuked" || getDvar("mapname") == "zm_transit") + { + if(level.disableAllCustomPerks == 0) //if the perks are enabled, send the next messages + { + if(isDefined(level.customPerksAreSpawned)) //this just checks to make sure there's actually custom perk machines within the map before sending the print msg + self connectMessage( "There are extra perk machines located within the map!" , false ); + if(isDefined(self.customPerkNum) && self.customPerkNum == 4) //if there's 4 custom perk machines loaded, wait 5 seconds so the player can read the print msg in the killfeed before + wait 5; + if(getDvar("mapname") == "zm_highrise") + { + if(level.enablePHDFlopper == 1) + self connectMessage( "-^6PHD Flopper" , false ); + if(level.enableDeadShot == 1) + self connectMessage( "-^8Deadshot Daiquiari" , false ); + if(level.enableStaminUp == 1) + self connectMessage( "-^3Stamin-Up" , false ); + } + else if(getDvar("mapname") == "zm_buried") + { + if(level.enablePHDFlopper == 1) + self connectMessage( "-^6PHD Flopper" , false ); + if(level.enableDeadShot == 1) + self connectMessage( "-^8Deadshot Daiquiari" , false ); + } + else if(getDvar("mapname") == "zm_prison") + { + if(level.enablePHDFlopper == 1) + self connectMessage( "-^6PHD Flopper" , false ); + if(level.enableStaminUp == 1) + self connectMessage( "-^3Stamin-Up" , false ); + } + else if(getDvar("mapname") == "zm_nuked" || getDvar("mapname") == "zm_transit") + { + if(level.enablePHDFlopper == 1) + self connectMessage( "-^6PHD Flopper" , false ); + if(level.enableDeadShot == 1) + self connectMessage( "-^8Deadshot Daiquiari" , false ); + if(level.enableStaminUp == 1) + self connectMessage( "-^3Stamin-Up" , false ); + if(level.enableMuleKick == 1) + self connectMessage( "-^2Mule Kick" , false ); + } + } + } + else if(getDvar("mapname") != "zm_tomb" && level.disableAllCustomPerks == 0 && level.enablePHDFlopper == 1) + self connectMessage( "^6PHD Flopper ^7is ^2Enabled ^7Automatically On This Map!" , false ); //pretty sure this would work on maps like town or farm. never tested +} + diff --git a/zomb++ (UPDATE)/zm_custom_easteregg.gsc b/zomb++ (UPDATE)/zm_custom_easteregg.gsc new file mode 100644 index 0000000..36fa7d0 --- /dev/null +++ b/zomb++ (UPDATE)/zm_custom_easteregg.gsc @@ -0,0 +1,174 @@ +CustomWeaponSystem(string, origin, weapon) +{ + level thread LowerMessage( "Secret Room Weapons", string ); + RoomWeapons = spawn("trigger_radius", origin, 1, 20, 20); + RoomWeapons rotateTo((0, 90, 0), .1); + RoomWeapons SetCursorHint( "HINT_NOICON" ); + RoomWeapons setLowerMessage( RoomWeapons, "Secret Room Weapons" ); + for(;;) + { + RoomWeapons waittill("trigger", i); + if(isDefined(self.staffgrabbed)) + { + RoomWeapons delete(); + } + if(i useButtonPressed() && distance(i.origin, origin) < 40) + { + wait .3; + if(i useButtonPressed()) + { + if(!isDefined(self.staffgrabbed)) + { + self.staffgrabbed = true; + w = i GetWeaponsListPrimaries(); + i playsound( "zmb_cha_ching" ); + playerCurrent = i getCurrentWeapon(); + if(w.size > 1)i takeWeapon(playerCurrent); + i giveweapon( "knife_zm" ); + i giveWeapon( weapon ); + i givemaxammo( weapon ); + i switchToWeapon( weapon ); + i play_weapon_vo( weapon ); + wait 1; + RoomWeapons delete(); + } + } + } + } +} +CustomEventTrigger( origin ) +{ + self endon( "disconnect" ); + level endon( "end_game" ); + if(!isDefined(self.totalskulls)) + self.totalskulls = 1; + else + self.totalskulls += 1; + trig = spawn("trigger_radius", origin, 1, 25, 25); + for(;;) + { + trig waittill("trigger", self); + if(self useButtonPressed()) + { + wait .25; + if(self useButtonPressed()) + { + if(!isDefined(self.skulls)) + self.skulls = 1; + else + self.skulls += 1; + wait 0.05; + if(self.skulls != self.totalskulls) + { + self playsound("zmb_insta_kill"); + return; + } + else + { + self playsound("zmb_cha_ching"); + self thread getAllPerks(); + if(level.script == "zm_tomb") + { + self thread CustomWeaponSystem("Hold ^3F ^7for Lightning Staff", (54, 230.5, -752), "staff_lightning_zm"); + self thread CustomWeaponSystem("Hold ^3F ^7for Fire Staff", (139.4, 189, -752), "staff_fire_zm"); + self thread CustomWeaponSystem("Hold ^3F ^7for Water Staff", (-57.5, 230, -752), "staff_water_zm"); + self thread CustomWeaponSystem("Hold ^3F ^7for Wind Staff", (-142, 187, -752), "staff_lightning_zm"); + } + else if(level.script == "zm_prison") + { + self playsound( "zmb_buildable_complete" ); + w = self GetWeaponsListPrimaries(); + if(w.size > 1) + self takeWeapon(self getCurrentWeapon()); + self giveWeapon("blundergat_zm"); + self SwitchToWeapon("blundergat_zm"); + } + else + self playsoundtoplayer( level.zmb_laugh_alias, self ); + self iprintln("Congratulations! You completed the easter egg!"); + return; + } + } + } + } +} +customEasterEgg() +{ + if(level.script == "zm_tranzit") + { + self thread CustomEventTrigger( (10411, 7326, -570) ); + self thread CustomEventTrigger( (-7622, 4903, -54) ); + self thread CustomEventTrigger( (452, -384, -62) ); + } + else if(level.script == "zm_buried") + { + self thread CustomEventTrigger( (2596, 34.5, 88) ); + self thread CustomEventTrigger( (1333, 1391, 200) ); + self thread CustomEventTrigger( (3281, 430, 240) ); + } + else if(level.script == "zm_highrise") + { + self thread CustomEventTrigger( (3448, 1347, 3032) ); + self thread CustomEventTrigger( (2843.5, 1228.5, 2711) ); + self thread CustomEventTrigger( (2105, 103, 1120) ); + } + else if(level.script == "zm_nuked") + { + self thread CustomEventTrigger( (184, 664, -61.5) ); + self thread CustomEventTrigger( (795, 373, 88) ); + self thread CustomEventTrigger( (-485, 554, 85) ); + } + else if(level.script == "zm_prison") + { + self thread CustomEventTrigger( (436, 10264, 1337) ); + self thread CustomEventTrigger( (2503, 9440, 1528) ); + self thread CustomEventTrigger( (4.5, 7610, 64) ); + } + else if(level.script == "zm_tomb") + { + self thread CustomEventTrigger( (-446, 3976, -352) ); + self thread CustomEventTrigger( (-479, 2952, -256) ); + self thread CustomEventTrigger( (2095, 4567, -304) ); + } +} +getAllPerks() +{ + self endon("disconnect"); + level endon("end_game"); + + for(;;) + { + wait 0.5; + if (isDefined(level.zombiemode_using_juggernaut_perk) && level.zombiemode_using_juggernaut_perk) + self doGivePerk("specialty_armorvest"); + if (isDefined(level.zombiemode_using_sleightofhand_perk) && level.zombiemode_using_sleightofhand_perk) + self doGivePerk("specialty_fastreload"); + if (isDefined(level.zombiemode_using_revive_perk) && level.zombiemode_using_revive_perk) + self doGivePerk("specialty_quickrevive"); + if (isDefined(level.zombiemode_using_doubletap_perk) && level.zombiemode_using_doubletap_perk) + self doGivePerk("specialty_rof"); + if (isDefined(level.zombiemode_using_marathon_perk) && level.zombiemode_using_marathon_perk) + self doGivePerk("specialty_longersprint"); + if(isDefined(level.zombiemode_using_additionalprimaryweapon_perk) && level.zombiemode_using_additionalprimaryweapon_perk) + self doGivePerk("specialty_additionalprimaryweapon"); + if (isDefined(level.zombiemode_using_deadshot_perk) && level.zombiemode_using_deadshot_perk) + self doGivePerk("specialty_deadshot"); + if (isDefined(level.zombiemode_using_tombstone_perk) && level.zombiemode_using_tombstone_perk) + self doGivePerk("specialty_scavenger"); + if (isDefined(level._custom_perks) && isDefined(level._custom_perks["specialty_flakjacket"]) && (level.script != "zm_buried")) + self doGivePerk("specialty_flakjacket"); + if (isDefined(level._custom_perks) && isDefined(level._custom_perks["specialty_nomotionsensor"])) + self doGivePerk("specialty_nomotionsensor"); + if (isDefined(level._custom_perks) && isDefined(level._custom_perks["specialty_grenadepulldeath"])) + self doGivePerk("specialty_grenadepulldeath"); + //if (isDefined(level.zombiemode_using_chugabud_perk) && level.zombiemode_using_chugabud_perk) + //self doGivePerk("specialty_finalstand"); + } +} +doGivePerk(perk) +{ + if (!(self hasperk(perk))) + self thread maps/mp/zombies/_zm_perks::give_perk(perk, 1); +} + + diff --git a/zomb++ (UPDATE)/zm_custom_perks.gsc b/zomb++ (UPDATE)/zm_custom_perks.gsc new file mode 100644 index 0000000..521f654 --- /dev/null +++ b/zomb++ (UPDATE)/zm_custom_perks.gsc @@ -0,0 +1,296 @@ +onPlayerDowned() +{ + self endon("disconnect"); + self endon("death"); + 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 + } +} +initCustomPerksOnPlayer() +{ + self.hasPHD = undefined; //also resets phd flopper when a player dies and respawns + if(getDvar("mapname") == "zm_nuked" || getDvar("mapname") == "zm_transit" || getDvar("mapname") == "zm_buried" || getDvar("mapname") == "zm_highrise" || getDvar("mapname") == "zm_prison") + { + self thread onPlayerDowned(); //takes perks and perk icons when you go down + } + else if(getDvar("mapname") != "zm_tomb" && level.disableAllCustomPerks == 0 && level.enablePHDFlopper == 1) + { + self.hasPHD = true; //gives phd on maps like town (i think. i actually never tested on any maps besides the ones provided) + self thread drawCustomPerkHUD("specialty_doubletap_zombies", 0, (1, 0.25, 1)); + } +} +startCustomPerkMachines() +{ + if(level.disableAllCustomPerks == 0) + { + self thread doPHDdive(); //self.hasPHD needs to be defined in order for this to work (after you pickup perk) + if(getDvar("mapname") == "zm_prison") //mob of the dead + { + if(level.enablePHDFlopper == 1) + self 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) + self 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) + self 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) + self 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) + self 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) + self 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) + self 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) + self thread CustomPerkMachine( "zombie_perk_bottle_revive", "zombie_vending_jugg", "PHD Flopper", 3000, (683, 727, -56), "PHD_FLOPPER", (5, 250, 0) ); + if(level.enableDeadshot == 1) + self thread CustomPerkMachine( "zombie_perk_bottle_jugg", "zombie_vending_revive", "Deadshot Daiquiri", 1500, (747, 356, 91), "specialty_deadshot", (0, 330, 0) ); + if(level.enableStaminUp == 1) + self thread CustomPerkMachine( "zombie_perk_bottle_revive", "zombie_vending_doubletap2", "Stamin-Up", 2000, (-638, 268, -54), "specialty_longersprint", (0, 165, 0) ); + if(level.enableMuleKick == 1) + self 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) + self thread CustomPerkMachine( "zombie_perk_bottle_revive", "zombie_vending_jugg", "PHD Flopper", 3000, (-6304, 5430, -55), "PHD_FLOPPER", (0, 90, 0) ); + if(level.enableDeadshot == 1) + self thread CustomPerkMachine( "zombie_perk_bottle_jugg", "zombie_vending_revive", "Deadshot Daiquiri", 1500, (-6088, -7419, 0), "specialty_deadshot", (0, 90, 0) ); + if(level.enableMuleKick == 1) + self thread CustomPerkMachine( "zombie_perk_bottle_jugg", "zombie_vending_sleight", "Mule Kick", 3000, (1149, -215, -304), "specialty_additionalprimaryweapon", (0, 180, 0) ); + } + } +} +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 +{ + self endon( "disconnect" ); + level endon( "end_game" ); + if ( 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 +{ + self endon( "disconnect" ); + level endon( "end_game" ); + if(!isDefined(level.customPerksAreSpawned)) + level.customPerksAreSpawned = true; + if(!isDefined(self.customPerkNum)) + self.customPerkNum = 1; + else + self.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", self); + if(self useButtonPressed() && self.score >= cost) + { + wait .25; + if(self useButtonPressed()) + { + if(perk != "PHD_FLOPPER" && !self hasPerk(perk) || perk == "PHD_FLOPPER" && !isDefined(self.hasPHD)) + { + self playsound( "zmb_cha_ching" ); //money shot + self.score -= cost; //take points + level.trig hide(); + self thread GivePerk( bottle, perk, perkname ); //give perk + wait 2; + level.trig show(); + } + else + self 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 ) ); +} + + + diff --git a/zomb++ (UPDATE)/zm_custom_powerups.gsc b/zomb++ (UPDATE)/zm_custom_powerups.gsc new file mode 100644 index 0000000..ca690c7 --- /dev/null +++ b/zomb++ (UPDATE)/zm_custom_powerups.gsc @@ -0,0 +1,194 @@ +startCustomPowerups() +{ + if(!isDefined(level.custompowerupinit)) + { + level.custompowerupinit = true; + wait 2; + level._zombiemode_powerup_grab = ::custom_powerup_grab; + } +} +initCustomPowerups() //credit goes to _Ox for the original code <3 +{ + level.unlimited_ammo_duration = 20; + //unlimited ammo drop "bottomless clip" credit to _Ox + 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") + { + //fast feet - speed potion, basically you run fast for 15 seconds + 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); + //pack a punch - pack a punches your current gun credit Knight + 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); + //couldn't find a better model for this money drop, if you find a better one pls let me know haha + 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 + { + 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); + } +} +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; +} +custom_powerup_grab(powerup, player) //credit to _Ox much thx for powerup functions +{ + if(powerup.powerup_name == "money_drop") + player thread doRandomScore(); //some cash money + else if(powerup.powerup_name == "pack_a_punch") + player thread doPackAPunchWeapon(); //i dont even use this one, its so OP lmao. If we could edit drop rate for this drop only it'd be better + else if(powerup.powerup_name == "unlimited_ammo") + player thread doUnlimitedAmmo(); //credit to _Ox for this one baby. its so good + else if(powerup.powerup_name == "fast_feet") + player thread doFastFeet(); //go fast as fuck boi +} +doFastFeet() //gotta go fast! +{ + self thread poweruptext("Fast Feet!"); //thanks to _Ox again for the powerup pickup string + self playsound("zmb_cha_ching"); //m-m-m-m-m-money shot + self setmovespeedscale(3); //super sonic speed + wait 15; + self setmovespeedscale(1); + self playsound("zmb_insta_kill"); //less happy sound than before +} +doUnlimitedAmmo() //unlimited ammo powerup function credit _Ox +{ + foreach(player in level.players) + { + player notify("end_unlimited_ammo"); + player playsound("zmb_cha_ching"); + player thread poweruptext("Bottomless Clip"); + player thread monitorUnlimitedAmmo(); //bottomless clip + player thread notifyUnlimitedAmmoEnd(); //notify when it ends + } +} +monitorUnlimitedAmmo() //credit to _Ox +{ + level endon("end_game"); + self endon("disonnect"); + self endon("end_unlimited_ammo"); + for(;;) + { + self setWeaponAmmoClip(self GetCurrentWeapon(), 150); + wait .05; + } +} +notifyUnlimitedAmmoEnd() //credit to _Ox +{ + 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() //pack a punch function credit Knight +{ + 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() //this is a bad way of doing this but i couldnt get the array to work before and did this out of frustration +{ + x = randomInt(9); //picks a number 0-9 + self playsound("zmb_cha_ching"); + if(x==1) + self.score += 50; //+50 + else if(x==2) + self.score += 100; //+100 + else if(x==3) + self.score += 250; //+250 I think you get the idea + 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) //credit to _Ox for base string hud +{ + 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() //credit to _Ox for base string hud +{ + wait .5; + self fadeovertime(1.5); + self moveovertime(1.5); + self.y = 270; + self.alpha = 0; + wait 1.5; + self destroy(); +} + + + diff --git a/zomb++ (UPDATE)/zm_server_functions.gsc b/zomb++ (UPDATE)/zm_server_functions.gsc new file mode 100644 index 0000000..e95b5d0 --- /dev/null +++ b/zomb++ (UPDATE)/zm_server_functions.gsc @@ -0,0 +1,987 @@ +//EVERYTHING CAN BE TOGGLED ON/OFF IN THE DEDICATED_ZM.CFG FILE +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 + //level.no_end_game_check = 1; + 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; + //custom bank + level.customBankEnabled = getDvarIntDefault( "customBankEnabled", 1 ); + level.zombie_vars[ "customBankEnabled" ] = level.customBankEnabled; + //custom bank amount + level.customBankTotal = getDvarIntDefault( "customBankTotal", 10000 ); + level.zombie_vars[ "customBankTotal" ] = level.customBankTotal; + //custom anti kiting + level.antiKitingEnabled = getDvarIntDefault( "antiKitingEnabled", 0 ); + level.zombie_vars[ "antiKitingEnabled" ] = level.antiKitingEnabled; + //anti kiting waittime (how long before zombies get auto killed) + level.antiKitingWaittime = getDvarIntDefault( "antiKitingWaittime", 45 ); + level.zombie_vars[ "antiKitingWaittime" ] = level.antiKitingWaittime; + //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; + //debug mode + level.enableDebugMode = getDvarIntDefault( "enableDebugMode", 0 ); + level.zombie_vars[ "enableDebugMode" ] = level.enableDebugMode; + 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(); + thread doTimer(); +} +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.antiKitingEnabled == 1 ) //custom anti kiting credit @itscahz big brain + { + level thread antiKiting(); //checks if zombie count is below 3 and waits set time to all kill zombies + } + 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 ); + } + } + } +} +connectMessage( string , bold ) //connect message +{ + if ( !isDefined ( self.pers[string] ) ) + { + self.pers[string] = true; + + if ( !isDefined ( bold ) || bold != true ) + self iPrintln ( string ); + else + self iPrintlnBold( string ); + } +} +drawZombiesCounter() //credit carbonmodding, edited to use setValue instead of SetText & colors +{ + level.zombiesCounter = createServerFontString("hudsmall" , 1.9); + level.zombiesCounter setPoint("CENTER", "CENTER", "CENTER", 190); + level thread updateZombiesCounter(); +} +updateZombiesCounter() //credit carbonmodding +{ + oldZombiesCount = get_current_zombie_count(); + while(true) + { + newZombiesCount = get_current_zombie_count(); + wait 0.05; + if(oldZombiesCount != newZombiesCount) + { + level thread updateZombiesCounter(); + return; + } + else + { + if(newZombiesCount != 0) + level.zombiesCounter.label = &"Zombies: ^1"; + else + level.zombiesCounter.label = &"Zombies: ^6"; + level.zombiesCounter setValue(newZombiesCount); + } + } +} +antiKiting() //credit @ItsCahz +{ + level endon("end_game"); + for(;;) + { + if(level.round_number >= 3 && oldZombCount <= 3) + { + wait level.antiKitingWaittime; + if(get_current_zombie_count() <= 3) + { + enemy = getaiarray( level.zombie_team ); + foreach( zombie in enemy ) + zombie dodamage( zombie.health * 2, zombie.origin ); + } + } + wait 1; + } +} +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(); + } +} +drawHealth() //credit carbonmodding, edited to use setValue instead of SetText & colors +{ + self.healthBar = createFontString("hudsmall" , 1.25); + self.healthBar setPoint("CENTER", "CENTER", "CENTER", 173); + self.healthBar.label = &"^1Health: ^7"; + while(true) + { + self.healthBar setValue(self.health); + wait 0.1; + } +} +startCustomBank() +{ + if( level.customBankEnabled == 1) + { + self.AmountInBank = level.customBankTotal; + if( getDvar("mapname") == "zm_buried" ) + self thread CustomBank((-276, -315, 11)); + if( getDvar("mapname") == "zm_highrise" ) + self thread CustomBank((2262, 623, 1296)); + if( getDvar("mapname") == "zm_transit" ) + self thread CustomBank((587, 504, -35)); + } +} +CustomBank(origin) //custom bank +{ + self endon("disconnect"); + level endon("end_game"); + level thread LowerMessage( "Custom Perks", "Hold ^3F ^7to withdraw 1000" ); + trig = spawn("trigger_radius", (origin), 1, 25, 25); + trig SetCursorHint( "HINT_NOICON" ); + trig setLowerMessage( trig, "Custom Perks" ); + for(;;) + { + trig waittill("trigger", self); + if(self useButtonPressed()) + { + wait .2; + if(self useButtonPressed()) + { + if(self.AmountInBank != 0) + { + self connectMessage( "You can withdraw money, but depositing will not save!" , false ); + self iprintln( "Money Available: "+self.AmountInBank ); + self playsound( "zmb_cha_ching" ); //money shot + self.score += 1000; + self.score -= 100; + self.AmountInBank -= 1000; + } + else + self connectMessage( "Your Bank is Empty!" , false ); + } + } + } +} +doTimer() +{ + level endon("end_game"); + level endon("timer_started"); + for(;;) + { + level waittill("start_of_round"); + if(level.round_number == 1 && level.players.size > 0 && !isDefined(level.timerStarted)) + { + level.timerStarted = true; + level thread startTimer(); + level thread notifyTimeOnEndGame(); + wait 0.1; + level notify("timer_started"); + } + } +} +startTimer() +{ + level.minutesPlayed = 0; + level.hoursPlayed = 0; + for(;;) + { + wait 59; + level.minutesPlayed += 1; + wait 1; + if(level.minutesPlayed == 60) + { + level.hoursPlayed += 1; + level.minutesPlayed = 0; + } + } +} +notifyTimeOnEndGame() +{ + level endon("time_displayed"); + for(;;) + { + level waittill("end_game"); + foreach(player in level.players) + { + if(level.hoursPlayed > 0) + { + if(level.hoursPlayed == 1) + { + if(level.minutesPlayed == 1) + player iprintln("That game lasted "+level.hoursPlayed+" hour and "+level.minutesPlayed+" minute!"); + else + player iprintln("That game lasted "+level.hoursPlayed+" hour and "+level.minutesPlayed+" minutes!"); + } + else + { + if(level.minutesPlayed == 1) + player iprintln("That game lasted "+level.hoursPlayed+" hours and "+level.minutesPlayed+" minute!"); + else + player iprintln("That game lasted "+level.hoursPlayed+" hours and "+level.minutesPlayed+" minutes!"); + } + } + else + { + if(level.minutesPlayed == 1) + player iprintln("That game lasted "+level.minutesPlayed+" minute!"); + else + player iprintln("That game lasted "+level.minutesPlayed+" minutes!"); + } + } + wait 2; + level notify("time_displayed"); + } +} +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(); + } +} + +