From d2583fb9e73f6e5ad5a1a7fe34063f9a9f9f47d1 Mon Sep 17 00:00:00 2001 From: JezuzLizard Date: Sat, 9 May 2020 22:42:28 -0700 Subject: [PATCH] Configuration Mod has been updated with a few new features See the readme for the patch notes. --- Configuration Mod/_clientids.gsc | 486 +-- Configuration Mod/_zm_powerups.gsc | 2883 +++++++++++++++++ Configuration Mod/black ops 2 weapon names.md | 12 +- Configuration Mod/dedicated_zm.cfg | 203 +- Configuration Mod/readme.md | 60 +- 5 files changed, 3359 insertions(+), 285 deletions(-) create mode 100644 Configuration Mod/_zm_powerups.gsc diff --git a/Configuration Mod/_clientids.gsc b/Configuration Mod/_clientids.gsc index 04aa09c..1a14e80 100644 --- a/Configuration Mod/_clientids.gsc +++ b/Configuration Mod/_clientids.gsc @@ -8,208 +8,231 @@ init() //level thread onplayerconnect(); //Useful zombie_vars, vars, and dvars: //Variables: - //sets the players starting points when first joining a server - 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 ); + level.round_number = getDvarIntDefault( "cmLevelRoundNumber", 1 ); + //sets the players starting points when first joining a server + level.player_starting_points = getDvarIntDefault( "cmPlayerStartingPoints", 500 ); + //sets the perk limit for all players + level.perk_purchase_limit = getDvarIntDefault( "cmPlayerPerkLimit", 4 ); + //sets the maximum number of zombies that can be on the map at once 32 max + level.zombie_ai_limit = getDvarIntDefault( "cmZombieAiLimit", 24 ); + //sets the number of zombie bodies that can be on the map at once + level.zombie_actor_limit = getDvarIntDefault( "cmZombieActorLimit", 32 ); + //enables midround hellhounds WARNING: causes permanent round pauses on maps that aren't bus depot, town or farm + level.mixed_rounds_enabled = getDvarIntDefault( "cmZombieMidroundDogs", 0 ); + //disables the end game check WARNING: make sure to include a spectator respawner and auto revive function + level.no_end_game_check = getDvarIntDefault( "cmLevelNoEndGameCheck", 0 ); + //sets the solo laststand pistol + level.default_solo_laststandpistol = getDvar( "cmPlayerSoloLaststandWeapon" ); + //the default laststand pistol + level.default_laststandpistol = getDvar( "cmPlayerCoopLaststandWeapon" ); + //set the starting weapon + level.start_weapon = getDvar( "cmPlayerStartWeapon" ); + //sets all zombies to this speed lower values result in walkers higher values sprinters + level.zombie_move_speed = getDvarIntDefault( "cmZombieMoveSpeed", 1 ); + //locks the zombie movespeed to the above value + level.cmZombieMoveSpeedLocked = getDvarIntDefault( "cmZombieMoveSpeedLocked", 0 ); + //sets whether there is a cap to the zombie movespeed active + level.cmZombieMoveSpeedCap = getDvarIntDefault( "cmZombieMoveSpeedCap", 0 ); + //sets the value to the zombie movespeed cap + level.cmZombieMoveSpeedCapValue = getDvarIntDefault( "cmZombieMoveSpeedCapValue", 1 ); + //sets the zombies move animation valid inputs are "walk", "run", "sprint", "super_sprint", and tranzit only "chase_bus" + level.cmZombieMoveAnimation = getDvar( "cmZombieMoveAnimation" ); //enables the override for zombies per round - level.overrideZombieTotalPermanently = getDvarIntDefault( "overrideZombieTotalPermanently", 0 ); + level.cmZombieTotalPermanentOverride = getDvarIntDefault( "cmZombieTotalPermanentOverride", 0 ); //sets the number of zombies per round to the value indicated - level.overrideZombieTotalPermanentlyValue = getDvarIntDefault( "overrideZombieTotalPermanentlyValue", 6 ); + level.cmZombieTotalPermanentOverrideValue = getDvarIntDefault( "cmZombieTotalPermanentOverrideValue", 6 ); //enables the override for zombie health - level.overrideZombieHealthPermanently = getDvarIntDefault( "overrideZombieHealthPermanently", 0 ); + level.cmZombieHealthPermanentOverride = getDvarIntDefault( "cmZombieHealthPermanentOverride", 0 ); //sets the health of zombies every round to the value indicated - level.overrideZombieHealthPermanentlyValue = getDvarIntDefault( "overrideZombieHealthPermanentlyValue", 150 ); + level.cmZombieHealthPermanentOverrideValue = getDvarIntDefault( "cmZombieHealthPermanentOverrideValue", 150 ); //enables the health cap override so zombies health won't grow beyond the value indicated - level.overrideZombieMaxHealth = getDvarIntDefault( "overrideZombieMaxHealth", 0 ); + level.cmZombieMaxHealthOverride = getDvarIntDefault( "cmZombieMaxHealthOverride", 0 ); //sets the maximum health zombie health will increase to - level.overrideZombieMaxHealthValue = getDvarIntDefault( "overrideZombieMaxHealthValue" , 150 ); + level.cmZombieMaxHealthOverrideValue = getDvarIntDefault( "cmZombieMaxHealthOverrideValue" , 150 ); + //sets the players maximum health zombies do 60 damage so 121 would be 3 hits 181 would be 4 and so on + level.cmPlayerMaxHealth = getDvarIntDefault( "cmPlayerMaxHealth", 100 ); + //disables walkers - level.disableWalkers = getDvarIntDefault( "disableWalkers", 0 ); - if ( level.disableWalkers ) + level.cmZombieDisableWalkers = getDvarIntDefault( "cmZombieDisableWalkers", 0 ); + if ( level.cmZombieDisableWalkers ) { 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.cmLevelSoloModeDisabled = getDvarIntDefault( "cmLevelSoloModeDisabled", 0 ); + if ( level.cmLevelSoloModeDisabled ) { level.is_forever_solo_game = undefined; } //disables all drops - level.zmPowerupsNoPowerupDrops = getDvarIntDefault( "zmPowerupsNoPowerupDrops", 0 ); + level.cmPowerupNoPowerupDrops = getDvarIntDefault( "cmPowerupNoPowerupDrops", 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; + level.cmPowerupMaxPerRound = getDvarIntDefault( "cmPowerupMaxPerRound", 4 ); + level.zombie_vars["zombie_powerup_drop_max_per_round"] = level.cmPowerupMaxPerRound; //sets the powerup drop rate lower is better - level.powerupDropRate = getDvarIntDefault( "powerupDropRate", 2000 ); - level.zombie_vars["zombie_powerup_drop_increment"] = level.powerupDropRate; + level.cmPowerupDropRate = getDvarIntDefault( "cmPowerupDropRate", 2000 ); + level.zombie_vars["zombie_powerup_drop_increment"] = level.cmPowerupDropRate; //makes every zombie drop a powerup - level.zombiesAlwaysDropPowerups = getDvarIntDefault( "zombiesAlwaysDropPowerups", 0 ); - level.zombie_vars[ "zombie_drop_item" ] = level.zombiesAlwaysDropPowerups; + level.cmPowerupAlwaysDrop = getDvarIntDefault( "cmPowerupAlwaysDrop", 0 ); + level.zombie_vars[ "zombie_drop_item" ] = level.cmPowerupAlwaysDrop; //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; + level.cmPowerupFourPlayerScore = getDvarIntDefault( "cmPowerupFourPlayerScore", 50 ); + level.zombie_vars[ "zombie_score_kill_4p_team" ] = level.cmPowerupFourPlayerScore; //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; + level.cmPowerupThreePlayerScore = getDvarIntDefault( "cmPowerupThreePlayerScore", 50 ); + level.zombie_vars[ "zombie_score_kill_3p_team" ] = level.cmPowerupThreePlayerScore; //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; + level.cmPowerupTwoPlayerScore = getDvarIntDefault( "cmPowerupTwoPlayerScore", 50 ); + level.zombie_vars[ "zombie_score_kill_2p_team" ] = level.cmPowerupTwoPlayerScore; //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; + level.cmPowerupOnePlayerScore = getDvarIntDefault( "cmPowerupOnePlayerScore", 50 ); + level.zombie_vars[ "zombie_score_kill_1p_team" ] = level.cmPowerupOnePlayerScore; //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; + level.cmPowerupScoreMeleeKill = getDvarIntDefault( "cmPowerupScoreMeleeKill", 80 ); + level.zombie_vars[ "zombie_score_bonus_melee" ] = level.cmPowerupScoreMeleeKill; //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; + level.cmPowerupScoreHeadshotKill = getDvarIntDefault( "cmPowerupScoreHeadshotKill", 50 ); + level.zombie_vars[ "zombie_score_bonus_head" ] = level.cmPowerupScoreHeadshotKill; //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; + level.cmPowerupScoreNeckKill = getDvarIntDefault( "cmPowerupScoreNeckKill", 20 ); + level.zombie_vars[ "zombie_score_bonus_neck" ] = level.cmPowerupScoreNeckKill; //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; + level.cmPowerupScoreTorsoKill = getDvarIntDefault( "cmPowerupScoreTorsoKill", 10 ); + level.zombie_vars[ "zombie_score_bonus_torso" ] = level.cmPowerupScoreTorsoKill; //sets the zombie spawnrate; max is 0.08 this is in seconds - level.zombieSpawnRate = getDvarFloatDefault( "zombieSpawnRate", 2 ); - level.zombie_vars[ "zombie_spawn_delay" ] = level.zombieSpawnRate; + level.cmZombieSpawnRate = getDvarFloatDefault( "cmZombieSpawnRate", 2 ); + level.zombie_vars[ "zombie_spawn_delay" ] = level.cmZombieSpawnRate; //sets the zombie spawnrate multiplier increase - level.zombieSpawnRateMultiplier = getDvarFloatDefault( "zombieSpawnRateMultiplier", 0.95 ); + level.cmZombieSpawnRateMultiplier = getDvarFloatDefault( "cmZombieSpawnRateMultiplier", 0.95 ); //locks the spawnrate so it does not change throughout gameplay - level.zombieSpawnRateLocked = getDvarIntDefault( "zombieSpawnRateLocked", 0 ); + level.cmZombieSpawnRateLocked = getDvarIntDefault( "cmZombieSpawnRateLocked", 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; + level.cmZombiePerPlayer = getDvarIntDefault( "cmZombiePerPlayer", 6 ); + level.zombie_vars["zombie_ai_per_player"] = level.cmZombiePerPlayer; //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; + level.cmZombieHealthIncreaseFlat = getDvarIntDefault( "cmZombieHealthIncreaseFlat", 100 ); + level.zombie_vars[ "zombie_health_increase" ] = level.cmZombieHealthIncreaseFlat; //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; + level.cmZombieHealthIncreaseMultiplier = getDvarFloatDefault( "cmZombieHealthIncreaseMultiplier", 0.1 ); + level.zombie_vars[ "zombie_health_increase_multiplier" ] = level.cmZombieHealthIncreaseMultiplier; //base zombie health before any multipliers or additions - level.zombieHealthStart = getDvarIntDefault( "zombieHealthStart", 150 ); - level.zombie_vars[ "zombie_health_start" ] = level.zombieHealthStart; + level.cmZombieHealthStart = getDvarIntDefault( "cmZombieHealthStart", 150 ); + level.zombie_vars[ "zombie_health_start" ] = level.cmZombieHealthStart; //time before new runners spawn on early rounds - level.zombieNewRunnerInterval = getDvarIntDefault( "zombieNewRunnerInterval", 10 ); - level.zombie_vars[ "zombie_new_runner_interval" ] = level.zombieNewRunnerInterval; + level.cmZombieNewRunnerInterval = getDvarIntDefault( "cmZombieNewRunnerInterval", 10 ); + level.zombie_vars[ "zombie_new_runner_interval" ] = level.cmZombieNewRunnerInterval; //determines level.zombie_move_speed on original - level.zombieMoveSpeedMultiplier = getDvarIntDefault( "zombieMoveSpeedMultiplier", 10 ); - level.zombie_vars[ "zombie_move_speed_multiplier" ] = level.zombieMoveSpeedMultiplier; + level.cmZombieMoveSpeedMultiplier = getDvarIntDefault( "cmZombieMoveSpeedMultiplier", 10 ); + level.zombie_vars[ "zombie_move_speed_multiplier" ] = level.cmZombieMoveSpeedMultiplier; //determines level.zombie_move_speed on easy - level.zombieMoveSpeedMultiplierEasy = getDvarIntDefault( "zombieMoveSpeedMultiplierEasy", 8 ); - level.zombie_vars[ "zombie_move_speed_multiplier_easy"] = level.zombieMoveSpeedMultiplierEasy; + level.cmZombieMoveSpeedMultiplierEasy = getDvarIntDefault( "cmZombieMoveSpeedMultiplierEasy", 8 ); + level.zombie_vars[ "zombie_move_speed_multiplier_easy"] = level.cmZombieMoveSpeedMultiplierEasy; //affects the number of zombies per round formula - level.zombieMaxAi = getDvarIntDefault( "zombieMaxAi", 24 ); - level.zombie_vars[ "zombie_max_ai" ] = level.zombieMaxAi; + level.cmZombieMaxAi = getDvarIntDefault( "cmZombieMaxAi", 24 ); + level.zombie_vars[ "zombie_max_ai" ] = level.cmZombieMaxAi; //affects the check for zombies that have fallen thru the map - level.belowWorldCheck = getDvarIntDefault( "belowWorldCheck", -1000 ); - level.zombie_vars[ "below_world_check" ] = level.belowWorldCheck; + level.cmZombieBelowWorldCheck = getDvarIntDefault( "cmZombieBelowWorldCheck", -1000 ); + level.zombie_vars[ "below_world_check" ] = level.cmZombieBelowWorldCheck; //sets whether spectators respawn at the end of the round - level.customSpectatorsRespawn = getDvarIntDefault( "customSpectatorsRespawn", 1 ); - level.zombie_vars[ "spectators_respawn" ] = level.customSpectatorsRespawn; + level.cmLevelDoSpectatorsRespawn = getDvarIntDefault( "cmLevelDoSpectatorsRespawn", 1 ); + level.zombie_vars[ "spectators_respawn" ] = level.cmLevelDoSpectatorsRespawn; //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; + level.cmLevelIntermissionTime = getDvarIntDefault( "cmLevelIntermissionTime", 20 ); + level.zombie_vars["zombie_intermission_time"] = level.cmLevelIntermissionTime; //the time between rounds - level.zombieBetweenRoundTime = getDvarIntDefault( "zombieBetweenRoundTime", 15 ); - level.zombie_vars["zombie_between_round_time"] = level.zombieBetweenRoundTime; + level.cmLevelBetweenRoundTime = getDvarIntDefault( "cmLevelBetweenRoundTime", 15 ); + level.zombie_vars["zombie_between_round_time"] = level.cmLevelBetweenRoundTime; //time before the game starts - level.roundStartDelay = getDvarIntDefault( "roundStartDelay", 0 ); - level.zombie_vars[ "game_start_delay" ] = level.roundStartDelay; + level.cmLevelGameStartDelay = getDvarIntDefault( "cmLevelGameStartDelay", 0 ); + level.zombie_vars[ "game_start_delay" ] = level.cmLevelGameStartDelay; //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; + level.cmPlayerBleedoutPointsLostAllPlayers = getDvarFloatDefault( "cmPlayerBleedoutPointsLostAllPlayers", 0.1 ); + level.zombie_vars[ "penalty_no_revive" ] = level.cmPlayerBleedoutPointsLostAllPlayers; //penalty to the player who died 10% of points by default - level.bleedoutPointsLostSelf = getDvarFloatDefault( "bleedoutPointsLostSelf", 0.1 ); - level.zombie_vars[ "penalty_died" ] = level.bleedoutPointsLostSelf; + level.cmPlayerBleedoutPointsLostSelf = getDvarFloatDefault( "cmPlayerBleedoutPointsLostSelf", 0.1 ); + level.zombie_vars[ "penalty_died" ] = level.cmPlayerBleedoutPointsLostSelf; //points players lose on down %5 by default - level.downedPointsLostSelf = getDvarFloatDefault( "downedPointsLostSelf", 0.05 ); - level.zombie_vars[ "penalty_downed" ] = level.downedPointsLostSelf; + level.cmPlayerDownedPointsLostSelf = getDvarFloatDefault( "cmPlayerDownedPointsLostSelf", 0.05 ); + level.zombie_vars[ "penalty_downed" ] = level.cmPlayerDownedPointsLostSelf; //unknown - level.playerStartingLives = getDvarIntDefault( "playerStartingLives", 1 ); - level.zombie_vars[ "starting_lives" ] = level.playerStartingLives; + level.cmPlayerStartingLives = getDvarIntDefault( "cmPlayerStartingLives", 1 ); + level.zombie_vars[ "starting_lives" ] = level.cmPlayerStartingLives; //points earned per zombie kill in a 4 player game - level.fourPlayerScorePerZombieKill = getDvarIntDefault( "fourPlayerScorePerZombieKill", 50 ); - level.zombie_vars[ "zombie_score_kill_4player" ] = level.fourPlayerScorePerZombieKill; + level.cmPlayerFourPlayerScorePerZombieKill = getDvarIntDefault( "cmPlayerFourPlayerScorePerZombieKill", 50 ); + level.zombie_vars[ "zombie_score_kill_4player" ] = level.cmPlayerFourPlayerScorePerZombieKill; //points earned per zombie kill in a 3 player game - level.threePlayerScorePerZombieKill = getDvarIntDefault( "threePlayerScorePerZombieKill", 50 ); - level.zombie_vars[ "zombie_score_kill_3player" ] = level.threePlayerScorePerZombieKill; + level.cmPlayerThreePlayerScorePerZombieKill = getDvarIntDefault( "cmPlayerThreePlayerScorePerZombieKill", 50 ); + level.zombie_vars[ "zombie_score_kill_3player" ] = level.cmPlayerThreePlayerScorePerZombieKill; //points earned per zombie kill in a 2 player game - level.twoPlayerScorePerZombieKill = getDvarIntDefault( "twoPlayerScorePerZombieKill", 50 ); - level.zombie_vars[ "zombie_score_kill_2player" ] = level.twoPlayerScorePerZombieKill; + level.cmPlayerTwoPlayerScorePerZombieKill = getDvarIntDefault( "cmPlayerTwoPlayerScorePerZombieKill", 50 ); + level.zombie_vars[ "zombie_score_kill_2player" ] = level.cmPlayerTwoPlayerScorePerZombieKill; //points earned per zombie kill in a 1 player game - level.onePlayerScorePerZombieKill = getDvarIntDefault( "onePlayerScorePerZombieKill", 50 ); - level.zombie_vars[ "zombie_score_kill_1player" ] = level.onePlayerScorePerZombieKill; + level.cmPlayerOnePlayerScorePerZombieKill = getDvarIntDefault( "cmPlayerOnePlayerScorePerZombieKill", 50 ); + level.zombie_vars[ "zombie_score_kill_1player" ] = level.cmPlayerOnePlayerScorePerZombieKill; //points given for a normal attack - level.pointsPerNormalAttack = getDvarIntDefault( "pointsPerNormalAttack", 10 ); - level.zombie_vars[ "zombie_score_damage_normal" ] = level.pointsPerNormalAttack; + level.cmPlayerPointsPerNormalAttack = getDvarIntDefault( "cmPlayerPointsPerNormalAttack", 10 ); + level.zombie_vars[ "zombie_score_damage_normal" ] = level.cmPlayerPointsPerNormalAttack; //points given for a light attack - level.pointsPerLightAttack = getDvarIntDefault( "pointsPerLightAttack", 10 ); - level.zombie_vars[ "zombie_score_damage_light" ] = level.pointsPerLightAttack; + level.cmPlayerPointsPerLightAttack = getDvarIntDefault( "cmPlayerPointsPerLightAttack", 10 ); + level.zombie_vars[ "zombie_score_damage_light" ] = level.cmPlayerPointsPerLightAttack; //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; + level.cmPlayerShouldZombify = getDvarIntDefault( "cmPlayerShouldZombify", 0 ); + level.zombie_vars[ "zombify_player" ] = level.cmPlayerShouldZombify; //points scalar for allies team - level.alliesPointsMultiplier = getDvarIntDefault( "alliesPointsMultiplier", 1 ); - level.zombie_vars[ "allies" ][ "zombie_point_scalar" ] = level.alliesPointsMultiplier; + level.cmTeamAlliesPointsMultiplier = getDvarIntDefault( "cmTeamAlliesPointsMultiplier", 1 ); + level.zombie_vars[ "allies" ][ "zombie_point_scalar" ] = level.cmTeamAlliesPointsMultiplier; //points scalar for axis team - level.axisPointsMultiplier = getDvarIntDefault( "axisPointsMultiplier", 1 ); - level.zombie_vars[ "axis" ][ "zombie_point_scalar" ] = level.axisPointsMultiplier; + level.cmTeamAxisPointsMultiplier = getDvarIntDefault( "cmTeamAxisPointsMultiplier", 1 ); + level.zombie_vars[ "axis" ][ "zombie_point_scalar" ] = level.cmTeamAxisPointsMultiplier; //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; + level.cmWeaponEmpPerkExplosionRadius = getDvarIntDefault( "cmWeaponEmpPerkExplosionRadius", 420 ); + level.zombie_vars[ "emp_perk_off_range" ] = level.cmWeaponEmpPerkExplosionRadius; + //sets the duration of emps on perks set to 0 for infiinite duration + level.cmWeaponEmpPerkOffDuration = getDvarIntDefault( "cmWeaponEmpPerkOffDuration", 90 ); + level.zombie_vars[ "emp_perk_off_time" ] = level.cmWeaponEmpPerkOffDuration; //riotshield health - level.riotshieldHitPoints = getDvarIntDefault( "riotshieldHitPoints", 2250 ); - level.zombie_vars[ "riotshield_hit_points" ] = level.riotshieldHitPoints; + level.cmEquipmentRiotshieldHitPoints = getDvarIntDefault( "cmEquipmentRiotshieldHitPoints", 2250 ); + level.zombie_vars[ "riotshield_hit_points" ] = level.cmEquipmentRiotshieldHitPoints; //jugg health bonus - level.juggHealthBonus = getDvarIntDefault( "juggHealthBonus", 160 ); - level.zombie_vars[ "zombie_perk_juggernaut_health" ] = level.juggHealthBonus; + level.cmPerkJuggHealthBonus = getDvarIntDefault( "cmPerkJuggHealthBonus", 160 ); + level.zombie_vars[ "zombie_perk_juggernaut_health" ] = level.cmPerkJuggHealthBonus; //perma jugg health bonus - level.permaJuggHealthBonus = getDvarIntDefault( "permaJuggHealthBonus", 190 ); - level.zombie_vars[ "zombie_perk_juggernaut_health_upgrade" ] = level.permaJuggHealthBonus; + level.cmPerkPermaJuggHealthBonus = getDvarIntDefault( "cmPerkPermaJuggHealthBonus", 90 ); + level.zombie_vars[ "zombie_perk_juggernaut_health_upgrade" ] = level.cmPerkPermaJuggHealthBonus; //phd min explosion damage - level.minPhdExplosionDamage = getDvarIntDefault( "minPhdExplosionDamage", 1000 ); - level.zombie_vars[ "zombie_perk_divetonuke_min_damage" ] = level.minPhdExplosionDamage; + level.cmPerkMinPhdExplosionDamage = getDvarIntDefault( "cmPerkMinPhdExplosionDamage", 2000 ); + level.zombie_vars[ "zombie_perk_divetonuke_min_damage" ] = level.cmPerkMinPhdExplosionDamage; //phd max explosion damage - level.maxPhdExplosionDamage = getDvarIntDefault( "maxPhdExplosionDamage", 5000 ); - level.zombie_vars[ "zombie_perk_divetonuke_max_damage" ] = level.maxPhdExplosionDamage; + level.cmPerkMaxPhdExplosionDamage = getDvarIntDefault( "cmPerkMaxPhdExplosionDamage", 5000 ); + level.zombie_vars[ "zombie_perk_divetonuke_max_damage" ] = level.cmPerkMaxPhdExplosionDamage; //phd explosion radius - level.phdDamageRadius = getDvarIntDefault( "phdDamageRadius", 300 ); - level.zombie_vars[ "zombie_perk_divetonuke_radius" ] = level.phdDamageRadius; + level.cmPerkPhdDamageRadius = getDvarIntDefault( "cmPerkPhdDamageRadius", 300 ); + level.zombie_vars[ "zombie_perk_divetonuke_radius" ] = level.cmPerkPhdDamageRadius; + //cheat protected dvars. these can only be set in gsc so we set the values with a different dvars + //sets speed colas reload multiplier lower is better WARNING: animation doesn't sync + level.cmPerkSpeedColaReloadSpeed = getDvarFloatDefault( "cmPerkSpeedColaReloadSpeed", 0.5 ); + setdvar( "perk_weapReloadMultiplier", level.cmPerkSpeedColaReloadSpeed ); + //sets double taps firing speed multiplier lower is better + level.cmPerkDoubleTapFireRate = getDvarFloatDefault( "cmPerkDoubleTapFireRate", 0.75 ); + setdvar( "perk_weapRateMultiplier", level.cmPerkDoubleTapFireRate ); + //sets deadshot crosshair size multiplier lower is better + level.cmPerkDeadshotAccuracyModifier = getDvarFloatDefault( "cmPerkDeadshotAccuracyModifier", 0.70 ); + setdvar( "perk_weapSpreadMultiplier", level.cmPerkDeadshotAccuracyModifier ); + //sets how close players have to be to revive another player + level.cmPlayerReviveTriggerRadius = getDvarIntDefault( "cmPlayerReviveTriggerRadius", 75 ); + setdvar( "revive_trigger_radius", level.cmPlayerReviveTriggerRadius ); + //sets the amount time before a player will bleedout after going down + level.cmPlayerLaststandBleedoutTime = getDvarIntDefault( "cmPlayerLaststandBleedoutTime", 45 ); + setdvar( "player_lastStandBleedoutTime", level.cmPlayerLaststandBleedoutTime ); + + init_custom_zm_powerups_gsc_exclusive_dvars(); disable_specific_powerups(); checks(); thread zombies_always_drop_powerups(); @@ -218,18 +241,30 @@ init() thread zombie_health_cap_override(); thread zombie_spawn_delay_fix(); thread zombie_speed_fix(); + level thread onplayerconnect(); +} + +onplayerconnect() +{ + level waittill( "connected", player ); + player thread onplayerspawned(); +} + +onplayerspawned() +{ + self waittill( "spawned_player" ); + self thread watch_for_respawn(); } checks() { if ( level.mixed_rounds_enabled ) { - if ( level.script != "zm_transit" || is_classic() || level.scr_zm_ui_gametype == "zgrief" ) + if ( level.script != "zm_transit" || maps/mp/zombies/_zm_utility::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"; @@ -259,50 +294,50 @@ checks() disable_specific_powerups() { - level.powerupNames = array( "nuke", "insta_kill", "full_ammo", "double_points", "fire_sale", "free_perk", "carpenter", "zombie_blood" ); - array = level.powerupNames; + level.cmPowerupNames = array( "nuke", "insta_kill", "full_ammo", "double_points", "fire_sale", "free_perk", "carpenter", "zombie_blood" ); + array = level.cmPowerupNames; //all powerups are enabled by default disable them manually //remove nukes from the drop cycle and special drops - level.zmPowerupsEnabled = []; - level.zmPowerupsEnabled[ "nuke" ] = spawnstruct(); - level.zmPowerupsEnabled[ "nuke" ].name = "nuke"; - level.zmPowerupsEnabled[ "nuke" ].active = getDvarIntDefault( "zmPowerupsNukeEnabled", 1 ); + level.cmPowerupEnabled = []; + level.cmPowerupEnabled[ "nuke" ] = spawnstruct(); + level.cmPowerupEnabled[ "nuke" ].name = "nuke"; + level.cmPowerupEnabled[ "nuke" ].active = getDvarIntDefault( "cmPowerupNukeEnabled", 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 ); + level.cmPowerupEnabled[ "insta_kill" ] = spawnstruct(); + level.cmPowerupEnabled[ "insta_kill" ].name = "insta_kill"; + level.cmPowerupEnabled[ "insta_kill" ].active = getDvarIntDefault( "cmPowerupInstaKillEnabled", 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 ); + level.cmPowerupEnabled[ "full_ammo" ] = spawnstruct(); + level.cmPowerupEnabled[ "full_ammo" ].name = "full_ammo"; + level.cmPowerupEnabled[ "full_ammo" ].active = getDvarIntDefault( "cmPowerupMaxAmmoEnabled", 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 ); + level.cmPowerupEnabled[ "double_points" ] = spawnstruct(); + level.cmPowerupEnabled[ "double_points" ].name = "double_points"; + level.cmPowerupEnabled[ "double_points" ].active = getDvarIntDefault( "cmPowerupDoublePointsEnabled", 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 ); + level.cmPowerupEnabled[ "fire_sale" ] = spawnstruct(); + level.cmPowerupEnabled[ "fire_sale" ].name = "fire_sale"; + level.cmPowerupEnabled[ "fire_sale" ].active = getDvarIntDefault( "cmPowerupFireSaleEnabled", 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 ); + level.cmPowerupEnabled[ "free_perk" ] = spawnstruct(); + level.cmPowerupEnabled[ "free_perk" ].name = "free_perk"; + level.cmPowerupEnabled[ "free_perk" ].active = getDvarIntDefault( "cmPowerupPerkBottleEnabled", 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 ); + level.cmPowerupEnabled[ "carpenter" ] = spawnstruct(); + level.cmPowerupEnabled[ "carpenter" ].name = "carpenter"; + level.cmPowerupEnabled[ "carpenter" ].active = getDvarIntDefault( "cmPowerupCarpenterEnabled", 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 ); + level.cmPowerupEnabled[ "zombie_blood" ] = spawnstruct(); + level.cmPowerupEnabled[ "zombie_blood" ].name = "zombie_blood"; + level.cmPowerupEnabled[ "zombie_blood" ].active = getDvarIntDefault( "cmPowerupZombieBloodEnabled", 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 ) + if ( !level.cmPowerupEnabled[ array[ i ] ].active ) { - name = level.zmPowerupsEnabled[ array[ i ] ].name; + name = level.cmPowerupEnabled[ array[ i ] ].name; if ( isInArray( level.zombie_include_powerups, name ) ) { arrayremovevalue( level.zombie_include_powerups, name ); @@ -321,7 +356,7 @@ disable_specific_powerups() disable_all_powerups() { - if ( level.zmPowerupsNoPowerupDrops ) + if ( level.cmPowerupNoPowerupDrops ) { flag_clear( "zombie_drop_powerups" ); } @@ -329,13 +364,13 @@ disable_all_powerups() zombies_always_drop_powerups() { - if ( !level.zombiesAlwaysDropPowerups ) + if ( !level.cmPowerupAlwaysDrop ) { return; } while ( 1 ) { - level.zombie_vars[ "zombie_drop_item" ] = level.zombiesAlwaysDropPowerups; + level.zombie_vars[ "zombie_drop_item" ] = level.cmPowerupAlwaysDrop; wait 0.05; } } @@ -356,65 +391,65 @@ onplayerspawned() zombies_per_round_override() { - if ( !level.overrideZombieTotalPermanently ) + if ( !level.cmZombieTotalPermanentOverride ) { return; } while ( 1 ) { level waittill( "start_of_round" ); - level.zombie_total = getDvarIntDefault( "overrideZombieTotalPermanentlyValue", 6 ); + level.zombie_total = level.cmZombieTotalPermanentOverrideValue; } } zombie_health_override() { - if ( !level.overrideZombieHealthPermanently ) + if ( !level.cmZombieHealthPermanentOverride ) { return; } while ( 1 ) { level waittill( "start_of_round" ); - level.zombie_health = getDvarIntDefault( "overrideZombieHealthPermanentlyValue", 150 ); + level.zombie_health = level.cmZombieHealthPermanentOverrideValue; } } zombie_health_cap_override() { - if ( !level.overrideZombieMaxHealth ) + if ( !level.cmZombieMaxHealthOverride ) { return; } while ( 1 ) { level waittill( "start_of_round" ); - if ( level.zombie_health > level.overrideZombieMaxHealthValue ) + if ( level.zombie_health > level.cmZombieMaxHealthOverrideValue ) { - level.zombie_health = getDvarIntDefault( "overrideZombieHealthMaxHealthValue", 150 ); + level.zombie_health = level.cmZombieMaxHealthOverrideValue; } } } zombie_spawn_delay_fix() { - if ( level.zombieSpawnRateLocked ) + if ( level.cmZombieSpawnRateLocked ) { return; } i = 1; while ( i <= level.round_number ) { - timer = level.zombieSpawnRate; + timer = level.cmZombieSpawnRate; if ( timer > 0.08 ) { - level.zombieSpawnRate = timer * level.zombieSpawnRateMultiplier; + level.cmZombieSpawnRate = timer * level.cmZombieSpawnRateMultiplier; i++; continue; } - else if ( timer < 0.08 ) + if ( timer < 0.08 ) { - level.zombieSpawnRate = 0.08; + level.cmZombieSpawnRate = 0.08; break; } i++; @@ -422,17 +457,17 @@ zombie_spawn_delay_fix() while ( 1 ) { level waittill( "start_of_round" ); - if ( level.zombieSpawnRate > 0.08 ) + if ( level.cmZombieSpawnRate > 0.08 ) { - level.zombieSpawnRate = level.zombieSpawnRate * level.zombieSpawnRateMultiplier; + level.cmZombieSpawnRate = level.cmZombieSpawnRate * level.cmZombieSpawnRateMultiplier; } - level.zombie_vars[ "zombie_spawn_delay" ] = level.zombieSpawnRate; + level.zombie_vars[ "zombie_spawn_delay" ] = level.cmZombieSpawnRate; } } zombie_speed_fix() { - if ( level.zombieMoveSpeedLocked ) + if ( level.cmZombieMoveSpeedLocked ) { return; } @@ -448,29 +483,104 @@ zombie_speed_fix() zombie_speed_override() { - if ( !level.zombieMoveSpeedLocked ) + if ( !level.cmZombieMoveSpeedLocked ) { return; } while ( 1 ) { level waittill( "start_of_round" ); - level.zombie_move_speed = getDvarIntDefault( "zombieMoveSpeed", 1 ); + level.zombie_move_speed = getDvarIntDefault( "cmZombieMoveSpeed", 1 ); } } zombie_speed_cap_override() { - if ( !level.zombieMoveSpeedCap ) + if ( !level.cmZombieMoveSpeedCap ) { return; } while ( 1 ) { level waittill( "start_of_round" ); - if ( level.zombie_move_speed > level.zombieMoveSpeedCapValue ) + if ( level.zombie_move_speed > level.cmZombieMoveSpeedCapValue ) { - level.zombie_move_speed = level.zombieMoveSpeedCapValue; + level.zombie_move_speed = level.cmZombieMoveSpeedCapValue; } } } + +zombie_move_animation_override() +{ + if ( level.cmZombieMoveAnimation == "" ) + { + return; + } + + while ( 1 ) + { + zombies = getAiArray( level.zombie_team ); + foreach( zombie in zombies ) + { + if ( zombie in_enabled_playable_area() ) + { + zombie maps/mp/zombies/_zm_utility::set_zombie_run_cycle( level.cmZombieMoveAnimation ); + } + } + wait 1; + } +} + +watch_for_respawn() +{ + self endon( "disconnect" ); + self._retain_perks = getDvarIntDefault( "cmPlayerRetainPerks", 0 ); + while ( 1 ) + { + self waittill_any( "spawned_player", "player_revived" ); + wait_network_frame(); + if ( self._retain_perks && self hasPerk( "specialty_armorvest" ) ) + { + self setMaxHealth( level.cmPerkJuggHealthBonus ); + } + else if ( self.pers_upgrades_awarded[ "jugg" ] ) + { + self setMaxHealth( level.cmPerkPermaJuggHealthBonus ); + } + else + { + self setMaxHealth( level.cmPlayerMaxHealth ); + } + } +} + +init_custom_zm_powerups_gsc_exclusive_dvars() +{ + //%chance that a powerup will drop everytime a zombie is killed + level.cmPowerupRandomDropChance = getDvarIntDefault( "cmPowerupRandomDropChance", 2 ); + //time before a powerup starts to blink and then disappear if not grabbed + level.cmPowerupFieldLifetime = getDvarIntDefault( "cmPowerupFieldLifetime", 15 ); + //duration of fire sale + level.cmPowerupFireSaleDuration = getDvarIntDefault( "cmPowerupFireSaleDuration", 30 ); + //duration of double points + level.cmPowerupDoublePointsDuration = getDvarIntDefault( "cmPowerupDoublePointsDuration", 30 ); + //double points points scalar + level.cmPowerupDoublePointsScalar = getDvarIntDefault( "cmPowerupDoublePointsScalar", 2 ); + //duration of insta kill + level.cmPowerupInstaKillDuration = getDvarIntDefault( "cmPowerupInstaKillDuration", 30 ); + + //points given by carpenter + level.cmPowerupCarpenterPoints = getDvarIntDefault( "cmPowerupCarpenterPoints", 200 ); + //points given by nuke + level.cmPowerupNukePoints = getDvarIntDefault( "cmPowerupCarpenterPoints", 400 ); + //whether nukes should take their time killing zombies off + level.cmPowerupNukeShouldWaitToKillZombies = getDvarIntDefault( "cmPowerupNukeShouldWaitToKillZombies", 1 ); + //minimum time before a nuked zombie dies + level.cmPowerupNukeMinTimeToKill = getDvarFloatDefault( "cmPowerupNukeMinTimeToKill", 0.1 ); + //maximum time before a nuked zombie dies + level.cmPowerupNukeMaxTimeToKill = getDvarFloatDefault( "cmPowerupNukeMaxTimeToKill", 0.7 ); + //should max ammo affect players in laststand + level.cmPowerupMaxAmmoAffectsLaststandPlayers = getDvarIntDefault( "cmPowerupMaxAmmoAffectsLastandPlayers", 0 ); +} + + diff --git a/Configuration Mod/_zm_powerups.gsc b/Configuration Mod/_zm_powerups.gsc new file mode 100644 index 0000000..b3285b3 --- /dev/null +++ b/Configuration Mod/_zm_powerups.gsc @@ -0,0 +1,2883 @@ +#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; + +init() //checked matches cerberus output +{ + //begin debug code + level.custom_zm_powerups_loaded = 1; + maps/mp/zombies/_zm_bot::init(); + if ( !isDefined( level.debugLogging_zm_powerups ) ) + { + level.debugLogging_zm_powerups = 0; + } + //end debug code + 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", level.cmPowerupFireSaleDuration ); + 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", level.cmPowerupInstaKillDuration, undefined, undefined, 1 ); + set_zombie_var( "zombie_powerup_point_doubler_on", 0, undefined, undefined, 1 ); + set_zombie_var( "zombie_powerup_point_doubler_time", level.cmPowerupDoublePointsDuration, undefined, undefined, 1 ); + set_zombie_var( "zombie_powerup_drop_increment", 2000 ); + set_zombie_var( "zombie_powerup_drop_max_per_round", 4 ); + 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(); + 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; +} + +init_powerups() //checked matches cerberus output +{ + flag_init( "zombie_drop_powerups" ); + 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 ) //checked partially changed to match cerberus output +{ + 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 > level.cmPowerupRandomDropChance ) + { + 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 ) + { + // Don't let them grab the minigun, tesla, or random weapon if they're downed or reviving + // due to weapon switching issues. + 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 ); + } + + // RAVEN BEGIN bhackbarth: since there is a wait here, flag the powerup as being taken + self.claimed = true; + self.power_up_grab_player = players[ i ]; //Player who grabbed the power up + // RAVEN END + + wait 0.1 ; + + playsoundatposition("zmb_powerup_grabbed", self.origin); + self stoploopsound(); + self hide(); + + //Preventing the line from playing AGAIN if fire sale becomes active before it runs out + 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" ] += level.cmPowerupFireSaleDuration; + 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" ] = level.cmPowerupFireSaleDuration; + 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(); + for ( i = 0; i < players.size; i++ ) + { + players[ i ] maps/mp/zombies/_zm_score::player_add_points( "carpenter_powerup", level.cmPowerupCarpenterPoints ); + } + 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 = level.cmPowerupFieldLifetime; + 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 ) + { + if ( isDefined( level.cmPowerupNukeShouldWaitToKillZombies ) && level.cmPowerupNukeShouldWaitToKillZombies ) + { + wait randomfloatrange( level.cmPowerupNukeMinTimeToKill, level.cmPowerupNukeMaxTimeToKill ); + } + 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", level.cmPowerupNukePoints ); + } +} + +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" ] = level.cmPowerupDoublePointsScalar; + 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 level.cmPowerupDoublePointsDuration; + level.zombie_vars[ team ][ "zombie_point_scalar" ] = 1; + if ( team == "allies" ) + { + level.zombie_vars[ "allies" ][ "zombie_point_scalar" ] = level.cmTeamAlliesPointsMultiplier; + } + if ( team == "axis" ) + { + level.zombie_vars[ "axis" ][ "zombie_point_scalar" ] = level.cmTeamAxisPointsMultiplier; + } + 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() && !level.cmPowerupMaxAmmoAffectsLaststandPlayers ) + { + 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 level.cmPowerupInstaKillDuration; + 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" ] = level.cmPowerupInstaKillDuration; + 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" ] = level.cmPowerupInstaKillDuration; + 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" ] = level.cmPowerupDoublePointsDuration; + 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" ] = level.cmPowerupDoublePointsDuration; + 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++; + } +} + +func_should_never_drop() //checked matches cerberus output +{ + return 0; +} + +func_should_always_drop() //checked matches cerberus output +{ + return 1; +} + +func_should_drop_minigun() //checked matches cerberus output +{ + if ( minigun_no_drop() ) + { + return 0; + } + return 1; +} + +func_should_drop_carpenter() //checked matches cerberus output +{ + if ( get_num_window_destroyed() < 5 ) + { + return 0; + } + return 1; +} + +func_should_drop_fire_sale() //checked partially changed to match cerberus output +{ + 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() //checked partially changed to match cerberus output +{ + 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() //checked matches cerberus output +{ + 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 ) //checked changed to match cerberus output +{ + 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 ) //checked changed to matched cerberus output +{ + 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 ) //checked matches cerberus output +{ + player maps/mp/zombies/_zm_score::add_to_player_score( powerup.value ); +} + + + + + + + + + diff --git a/Configuration Mod/black ops 2 weapon names.md b/Configuration Mod/black ops 2 weapon names.md index 4acf355..d84d4d1 100644 --- a/Configuration Mod/black ops 2 weapon names.md +++ b/Configuration Mod/black ops 2 weapon names.md @@ -35,6 +35,8 @@ m32_upgraded_zm m32_zm //war machine python_upgraded_zm python_zm //python +qcw05_upgraded_zm +qcw05_zm //chicom sf_qcw05_upgraded_zm riotshield_zm //zombie shield rottweil72_upgraded_zm @@ -100,6 +102,8 @@ mp5k_upgraded_zm mp5k_zm python_upgraded_zm python_zm +qcw05_upgraded_zm +qcw05_zm //chicom sf_qcw05_upgraded_zm rpd_upgraded_zm rpd_zm @@ -160,6 +164,8 @@ pdw57_upgraded_zm pdw57_zm python_upgraded_zm python_zm +qcw05_upgraded_zm +qcw05_zm //chicom sf_qcw05_upgraded_zm rpd_upgraded_zm rpd_zm @@ -220,6 +226,8 @@ m32_upgraded_zm m32_zm pdw57_upgraded_zm pdw57_zm +qcw05_upgraded_zm +qcw05_zm //chicom sf_qcw05_upgraded_zm rnma_upgraded_zm rnma_zm @@ -333,6 +341,8 @@ one_inch_punch_upgraded_zm one_inch_punch_zm python_upgraded_zm python_zm +qcw05_upgraded_zm +qcw05_zm //chicom sf_qcw05_upgraded_zm scar_upgraded_zm scar_zm @@ -391,8 +401,6 @@ galil_upgraded_zm galil_zm //galil m14_upgraded_zm m14_zm -qcw05_upgraded_zm -qcw05_zm //chicom ray_gun_upgraded_zm ray_gun_zm raygun_mark2_upgraded_zm diff --git a/Configuration Mod/dedicated_zm.cfg b/Configuration Mod/dedicated_zm.cfg index afdbbd8..54238bc 100644 --- a/Configuration Mod/dedicated_zm.cfg +++ b/Configuration Mod/dedicated_zm.cfg @@ -49,110 +49,127 @@ gts startRound "1" // Starting Round. Only Surviva //gts cleansedLoadout "1" // Allow players to choose their Loadout? Only Turned has this option! //set g_loadScripts "0" -set playerStartingPoints 500 -set perkLimit 4 -set zombieAiLimit 24 -set zombieActorLimit 32 -set midroundDogs 0 -set noEndGameCheck 0 -set soloLaststandWeapon "m1911_upgraded_zm" -set coopLaststandWeapon "m1911_zm" -set startWeaponZm "m1911_zm" -set disableWalkers 0 -set roundNumber 1 -set soloModeDisabled 0 +//level properties +set cmLevelNoEndGameCheck 0 +set cmLevelRoundNumber 1 +set cmLevelSoloModeDisabled 0 +set cmLevelDoSpectatorsRespawn 1 +set cmLevelIntermissionTime 20 +set cmLevelBetweenRoundTime 15 +set cmLevelGameStartDelay 0 //powerups properties -set maxPowerupsPerRound 4 -set powerupDropRate 2000 -set zombiesAlwaysDropPowerups 0 -set fourPlayerPowerupScore 50 -set threePlayerPowerupScore 50 -set twoPlayerPowerupScore 50 -set onePlayerPowerupScore 50 -set powerupScoreMeleeKill 80 -set powerupScoreHeadshotKill 50 -set powerupScoreNeckKill 20 -set powerupScoreTorsoKill 10 -set zmPowerupsNukeEnabled 1 -set zmPowerupsInstaKillEnabled 1 -set zmPowerupsMaxAmmoEnabled 1 -set zmPowerupsDoublePointsEnabled 1 -set zmPowerupsCarpenterEnabled 1 -set zmPowerupsFireSaleEnabled 1 -set zmPowerupsPerkBottleEnabled 1 -set zmPowerupsCarpenterEnabled 1 -set zmPowerupsZombieBloodEnabled 1 -set zmPowerupsNoPowerupDrops 0 +set cmPowerupMaxPerRound 4 +set cmPowerupDropRate 2000 +set cmPowerupAlwaysDrop 0 +set cmPowerupFourPlayerScore 50 +set cmPowerupThreePlayerScore 50 +set cmPowerupTwoPlayerScore 50 +set cmPowerupOnePlayerScore 50 +set cmPowerupScoreMeleeKill 80 +set cmPowerupScoreHeadshotKill 50 +set cmPowerupScoreNeckKill 20 +set cmPowerupScoreTorsoKill 10 +set cmPowerupNukeEnabled 1 +set cmPowerupInstaKillEnabled 1 +set cmPowerupMaxAmmoEnabled 1 +set cmPowerupDoublePointsEnabled 1 +set cmPowerupCarpenterEnabled 1 +set cmPowerupFireSaleEnabled 1 +set cmPowerupPerkBottleEnabled 1 +set cmPowerupCarpenterEnabled 1 +set cmPowerupZombieBloodEnabled 1 +set cmPowerupNoPowerupDrops 0 +//these require _zm_powerups to be installed to do anything +set cmPowerupRandomDropChance 2 +set cmPowerupFieldLifetime 15 +set cmPowerupFireSaleDuration 30 +set cmPowerupDoublePointsDuration 30 +set cmPowerupDoublePointsScalar 2 +set cmPowerupInstaKillDuration 30 +set cmPowerupCarpenterPoints 200 +set cmPowerupCarpenterPoints 400 +set cmPowerupNukeShouldWaitToKillZombies 1 +set cmPowerupNukeMinTimeToKill 0.1 +set cmPowerupNukeMaxTimeToKill 0.7 +set cmPowerupMaxAmmoAffectsLastandPlayers 0 + //zombie properties dvars -set overrideZombieTotalPermanently 0 -set overrideZombieTotalPermanentlyValue 100 -set overrideZombieHealthPermanently 0 -set overrideZombieHealthPermanentlyValue 150 -set overrideZombieMaxHealth 0 -set overrideZombieMaxHealthValue 150 -set zombieSpawnRate 2 -set zombieSpawnRateMultiplier 0.95 -set zombieSpawnRateLocked 0 -set zombiesPerPlayer 6 -set zombieHealthIncreaseFlat 100 -set zombieHealthIncreaseMultiplier 0.1 -set zombieHealthStart 150 -set zombieNewRunnerInterval 10 -set zombieMoveSpeed 1 -set zombieMoveSpeedLocked 1 -set zombieMoveSpeedCap 0 -set zombieMoveSpeedCapValue 1 -set zombieMoveSpeedMultiplier 10 -set zombieMoveSpeedMultiplierEasy 8 -set zombieMaxAi 24 -set belowWorldCheck -1000 - -//round properties -set customSpectatorsRespawn 1 -set zombieIntermissionTime 20 -set zombieBetweenRoundTime 15 -set roundStartDelay 0 +set cmZombieAiLimit 24 +set cmZombieActorLimit 32 +set cmZombieMidroundDogs 0 +set cmZombieDisableWalkers 0 +set cmZombieTotalPermanentOverride 0 +set cmZombieTotalPermanentOverrideValue 100 +set cmZombieHealthPermanentOverride 0 +set cmZombieHealthPermanentOverrideValue 150 +set cmZombieMaxHealthOverride 0 +set cmZombieMaxHealthOverrideValue 150 +set cmZombieSpawnRate 2 +set cmZombieSpawnRateMultiplier 0.95 +set cmZombieSpawnRateLocked 0 +set cmZombiePerPlayer 6 +set cmZombieHealthIncreaseFlat 100 +set cmZombieHealthIncreaseMultiplier 0.1 +set cmZombieHealthStart 150 +set cmZombieNewRunnerInterval 10 +set cmZombieMoveSpeed 1 +set cmZombieMoveSpeedLocked 1 +set cmZombieMoveSpeedCap 0 +set cmZombieMoveSpeedCapValue 1 +set cmZombieMoveSpeedMultiplier 10 +set cmZombieMoveSpeedMultiplierEasy 8 +set cmZombieMoveAnimation "" +set cmZombieMaxAi 24 +set cmZombieBelowWorldCheck -1000 //player properties -set bleedoutPointsLostAllPlayers 0.1 -set bleedoutPointsLostSelf 0.1 -set downedPointsLostSelf 0.05 -set playerStartingLives 1 -set fourPlayerScorePerZombieKill 50 -set threePlayerScorePerZombieKill 50 -set twoPlayerScorePerZombieKill 50 -set onePlayerScorePerZombieKill 50 -set pointsPerNormalAttack 10 -set pointsPerLightAttack 10 -set shouldZombifyPlayer 0 -set alliesPointsMultiplier 1 -set axisPointsMultiplier 1 +set cmPlayerMaxHealth 100 +set cmPlayerPerkLimit 4 +set cmPlayerRetainPerks 0 +set cmPlayerStartingPoints 500 +set cmPlayerStartingLives 1 +set cmPlayerFourPlayerScorePerZombieKill 50 +set cmPlayerThreePlayerScorePerZombieKill 50 +set cmPlayerTwoPlayerScorePerZombieKill 50 +set cmPlayerOnePlayerScorePerZombieKill 50 +set cmPlayerPointsPerNormalAttack 10 +set cmPlayerPointsPerLightAttack 10 +set cmPlayerShouldZombify 0 +set cmPlayerSoloLaststandWeapon "m1911_upgraded_zm" +set cmPlayerCoopLaststandWeapon "m1911_zm" +set cmPlayerStartWeapon "m1911_zm" +set cmPlayerBleedoutPointsLostAllPlayers 0.1 +set cmPlayerBleedoutPointsLostSelf 0.1 +set cmPlayerDownedPointsLostSelf 0.05 +set cmPlayerReviveTriggerRadius 75 +set cmPlayerLaststandBleedoutTime 45 + +//team properties +set cmTeamAlliesPointsMultiplier 1 +set cmTeamAxisPointsMultiplier 1 //perk properties -set empPerkExplosionRadius 420 -set empPerkOffDuration 90 -set riotshieldHitPoints 2250 -set juggHealthBonus 160 -set permaJuggHealthBonus 190 -set minPhdExplosionDamage 1000 -set maxPhdExplosionDamage 5000 -set phdDamageRadius 300 +set cmPerkJuggHealthBonus 160 +set cmPerkPermaJuggHealthBonus 190 +set cmPerkMinPhdExplosionDamage 2000 +set cmPerkMaxPhdExplosionDamage 5000 +set cmPerkPhdDamageRadius 300 +set cmPerkSpeedColaReloadSpeed 0.5 +set cmPerkDoubleTapFireRate 0.75 +set cmPerkDeadshotAccuracyModifier 0.70 -//builtin dvars +//equipment properties +set cmEquipmentRiotshieldHitPoints 2250 + +//weapon properties +set cmWeaponEmpPerkExplosionRadius 420 +set cmWeaponEmpPerkOffDuration 90 + +//mystery box properties //sets whether the mystery box moves ever set magic_chest_movable 1 -//sets how close players have to be to revive another player -set revive_trigger_radius 75 -//sets the amount time before a player will bleedout after going down -set player_lastStandBleedoutTime 45 -//sets speed colas reload multiplier lower is better WARNING: animation doesn't sync -set perk_weapReloadMultiplier 0.5 -//sets double taps firing speed multiplier lower is better -set perk_weapRateMultiplier 0.75 -//sets deadshot crosshair size multiplier lower is better -set perk_weapSpreadMultiplier 0.70 ////////////////////////////////////////////////// diff --git a/Configuration Mod/readme.md b/Configuration Mod/readme.md index bb07fc8..03d3636 100644 --- a/Configuration Mod/readme.md +++ b/Configuration Mod/readme.md @@ -1,15 +1,26 @@ # Configuration Mod + +*** Instructions *** + Merge inits with your current mod or compile as _clientids.gsc. +Install _clientids.gsc in maps/mp/gametypes_zm + All dvars are included in the config and descriptions are in the code itself. Added dvars should be working but not all have been tested, also dvar names should not conflict. Weapon names can be found in the included black ops 2 names. -### Updates: +*** Optional *** -4/10/20 +Compile _zm_powerups.gsc as _zm_powerups.gsc DO NOT ATTEMPT TO MERGE THEM INTO ONE FILE IT WILL DEFINITELY CRASH + +Install _zm_powerups.gsc in in maps/mp/zombies + +This will add support for changing a few aspects of the vanilla powerups + +# Update 4/10/20 #### New dvars @@ -47,3 +58,48 @@ Added tha ability to lock the zombie health Added the ability to lock the zombies per round +# Update 5/9/20 + +## Main Changes + +Refactored all the variables to standardize their naming + +Added support for _zm_powerups allowing you control more aspects for vanilla powerups + +### Zombie Dvars + +Added a new dvar to control the zombie move animation so you can force them to be super sprinters or bus sprinters + +### Player dvars + +Added a new dvar allowing you to control the players health + +Added a new dvar allowing you to control whether a player keeps their perks on down notes: does not work on MoTD + +### Cheat protected dvars + +Moved the cheat protected dvars in script so hopefully they can changed using other dvars + +### Powerups dvars - requires _zm_powerups to be installed + +Added a dvar allowing you to control the random drop chance of powerups + +Added a dvar allowing you to control length of time a powerup will last on the field before starting to blink + +Added a dvar allowing you to control the duration of fire sale + +Added a dvar allowing you to control the duration of double points + +Added a dvar allowing you to control the points multiplier granted by double points + +Added a dvar allowing you to control the duration of insta kill + +Added a dvar allowing you to control the amount of points granted by a carpenter + +Added a dvar allowing you to control the amount of points granted by a nuke + +Added a dvar allowing you to control whether nukes instantly kill zombies + +Added dvars which allow you to control the minimum and maximum time it takes for a zombie to die to a nuke + +Added a dvar that allows max ammo to apply to downed players \ No newline at end of file