INSANEMODE/Public-BO2-Mods
1
0
Fork 0
mirror of https://github.com/JezuzLizard/Public-BO2-Mods.git synced 2025-06-07 18:47:59 -05:00
Code Issues Packages Projects Releases Wiki Activity

Configuration Mod has been updated with a few new features

Browse Source 
See the readme for the patch notes.
This commit is contained in:
JezuzLizard 2020-05-09 22:42:28 -07:00
parent adf15a9736
commit d2583fb9e7
5 changed files with 3359 additions and 285 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

486
Configuration Mod/_clientids.gsc
View File

@ -8,208 +8,231 @@ init()
//level thread onplayerconnect(); //level thread onplayerconnect();
//Useful zombie_vars, vars, and dvars: //Useful zombie_vars, vars, and dvars:
//Variables: //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 //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 //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 //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 //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 //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 //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 //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 //disables walkers
level.disableWalkers = getDvarIntDefault( "disableWalkers", 0 ); level.cmZombieDisableWalkers = getDvarIntDefault( "cmZombieDisableWalkers", 0 );
if ( level.disableWalkers ) if ( level.cmZombieDisableWalkers )
{ {
level.speed_change_round = undefined; 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 //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 ); level.cmLevelSoloModeDisabled = getDvarIntDefault( "cmLevelSoloModeDisabled", 0 );
if ( level.disableSoloMode ) if ( level.cmLevelSoloModeDisabled )
{ {
level.is_forever_solo_game = undefined; level.is_forever_solo_game = undefined;
} }
//disables all drops //disables all drops
level.zmPowerupsNoPowerupDrops = getDvarIntDefault( "zmPowerupsNoPowerupDrops", 0 ); level.cmPowerupNoPowerupDrops = getDvarIntDefault( "cmPowerupNoPowerupDrops", 0 );
//Zombie_Vars: //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 //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 //sets the maximum number of drops per round
level.maxPowerupsPerRound = getDvarIntDefault( "maxPowerupsPerRound", 4 ); level.cmPowerupMaxPerRound = getDvarIntDefault( "cmPowerupMaxPerRound", 4 );
level.zombie_vars["zombie_powerup_drop_max_per_round"] = level.maxPowerupsPerRound; level.zombie_vars["zombie_powerup_drop_max_per_round"] = level.cmPowerupMaxPerRound;
//sets the powerup drop rate lower is better //sets the powerup drop rate lower is better
level.powerupDropRate = getDvarIntDefault( "powerupDropRate", 2000 ); level.cmPowerupDropRate = getDvarIntDefault( "cmPowerupDropRate", 2000 );
level.zombie_vars["zombie_powerup_drop_increment"] = level.powerupDropRate; level.zombie_vars["zombie_powerup_drop_increment"] = level.cmPowerupDropRate;
//makes every zombie drop a powerup //makes every zombie drop a powerup
level.zombiesAlwaysDropPowerups = getDvarIntDefault( "zombiesAlwaysDropPowerups", 0 ); level.cmPowerupAlwaysDrop = getDvarIntDefault( "cmPowerupAlwaysDrop", 0 );
level.zombie_vars[ "zombie_drop_item" ] = level.zombiesAlwaysDropPowerups; level.zombie_vars[ "zombie_drop_item" ] = level.cmPowerupAlwaysDrop;
//increase these below vars to increase drop rate //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"] //points to the powerup increment to a powerup drop related to level.zombie_vars["zombie_powerup_drop_increment"]
level.fourPlayerPowerupScore = getDvarIntDefault( "fourPlayerPowerupScore", 50 ); level.cmPowerupFourPlayerScore = getDvarIntDefault( "cmPowerupFourPlayerScore", 50 );
level.zombie_vars[ "zombie_score_kill_4p_team" ] = level.fourPlayerPowerupScore; 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"] //points to the powerup increment to a powerup drop related to level.zombie_vars["zombie_powerup_drop_increment"]
level.threePlayerPowerupScore = getDvarIntDefault( "threePlayerPowerupScore", 50 ); level.cmPowerupThreePlayerScore = getDvarIntDefault( "cmPowerupThreePlayerScore", 50 );
level.zombie_vars[ "zombie_score_kill_3p_team" ] = level.threePlayerPowerupScore; 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"] //points to the powerup increment to a powerup drop related to level.zombie_vars["zombie_powerup_drop_increment"]
level.twoPlayerPowerupScore = getDvarIntDefault( "twoPlayerPowerupScore", 50 ); level.cmPowerupTwoPlayerScore = getDvarIntDefault( "cmPowerupTwoPlayerScore", 50 );
level.zombie_vars[ "zombie_score_kill_2p_team" ] = level.twoPlayerPowerupScore; 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"] //points to the powerup increment to a powerup drop related to level.zombie_vars["zombie_powerup_drop_increment"]
level.onePlayerPowerupScore = getDvarIntDefault( "onePlayerPowerupScore", 50 ); level.cmPowerupOnePlayerScore = getDvarIntDefault( "cmPowerupOnePlayerScore", 50 );
level.zombie_vars[ "zombie_score_kill_1p_team" ] = level.onePlayerPowerupScore; level.zombie_vars[ "zombie_score_kill_1p_team" ] = level.cmPowerupOnePlayerScore;
//points for melee kills to the powerup increment to a powerup drop //points for melee kills to the powerup increment to a powerup drop
level.powerupScoreMeleeKill = getDvarIntDefault( "powerupScoreMeleeKill", 80 ); level.cmPowerupScoreMeleeKill = getDvarIntDefault( "cmPowerupScoreMeleeKill", 80 );
level.zombie_vars[ "zombie_score_bonus_melee" ] = level.powerupScoreMeleeKill; level.zombie_vars[ "zombie_score_bonus_melee" ] = level.cmPowerupScoreMeleeKill;
//points for headshot kills to the powerup increment to a powerup drop //points for headshot kills to the powerup increment to a powerup drop
level.powerupScoreHeadshotKill = getDvarIntDefault( "powerupScoreHeadshotKill", 50 ); level.cmPowerupScoreHeadshotKill = getDvarIntDefault( "cmPowerupScoreHeadshotKill", 50 );
level.zombie_vars[ "zombie_score_bonus_head" ] = level.powerupScoreHeadshotKill; level.zombie_vars[ "zombie_score_bonus_head" ] = level.cmPowerupScoreHeadshotKill;
//points for neck kills to the powerup increment to a powerup drop //points for neck kills to the powerup increment to a powerup drop
level.powerupScoreNeckKill = getDvarIntDefault( "powerupScoreNeckKill", 20 ); level.cmPowerupScoreNeckKill = getDvarIntDefault( "cmPowerupScoreNeckKill", 20 );
level.zombie_vars[ "zombie_score_bonus_neck" ] = level.powerupScoreNeckKill; level.zombie_vars[ "zombie_score_bonus_neck" ] = level.cmPowerupScoreNeckKill;
//points for torso kills to the powerup increment to a powerup drop //points for torso kills to the powerup increment to a powerup drop
level.powerupScoreTorsoKill = getDvarIntDefault( "powerupScoreTorsoKill", 10 ); level.cmPowerupScoreTorsoKill = getDvarIntDefault( "cmPowerupScoreTorsoKill", 10 );
level.zombie_vars[ "zombie_score_bonus_torso" ] = level.powerupScoreTorsoKill; level.zombie_vars[ "zombie_score_bonus_torso" ] = level.cmPowerupScoreTorsoKill;
//sets the zombie spawnrate; max is 0.08 this is in seconds //sets the zombie spawnrate; max is 0.08 this is in seconds
level.zombieSpawnRate = getDvarFloatDefault( "zombieSpawnRate", 2 ); level.cmZombieSpawnRate = getDvarFloatDefault( "cmZombieSpawnRate", 2 );
level.zombie_vars[ "zombie_spawn_delay" ] = level.zombieSpawnRate; level.zombie_vars[ "zombie_spawn_delay" ] = level.cmZombieSpawnRate;
//sets the zombie spawnrate multiplier increase //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 //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 //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 //ie half as many zombies per player is half as many zombies per round
level.zombiesPerPlayer = getDvarIntDefault( "zombiesPerPlayer", 6 ); level.cmZombiePerPlayer = getDvarIntDefault( "cmZombiePerPlayer", 6 );
level.zombie_vars["zombie_ai_per_player"] = level.zombiesPerPlayer; 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 //sets the flat amount of hp the zombies gain per round not used after round 10
level.zombieHealthIncreaseFlat = getDvarIntDefault( "zombieHealthIncreaseFlat", 100 ); level.cmZombieHealthIncreaseFlat = getDvarIntDefault( "cmZombieHealthIncreaseFlat", 100 );
level.zombie_vars[ "zombie_health_increase" ] = level.zombieHealthIncreaseFlat; level.zombie_vars[ "zombie_health_increase" ] = level.cmZombieHealthIncreaseFlat;
//multiplies zombie health by this value every round after round 10 //multiplies zombie health by this value every round after round 10
level.zombieHealthIncreaseMultiplier = getDvarFloatDefault( "zombieHealthIncreaseMultiplier", 0.1 ); level.cmZombieHealthIncreaseMultiplier = getDvarFloatDefault( "cmZombieHealthIncreaseMultiplier", 0.1 );
level.zombie_vars[ "zombie_health_increase_multiplier" ] = level.zombieHealthIncreaseMultiplier; level.zombie_vars[ "zombie_health_increase_multiplier" ] = level.cmZombieHealthIncreaseMultiplier;
//base zombie health before any multipliers or additions //base zombie health before any multipliers or additions
level.zombieHealthStart = getDvarIntDefault( "zombieHealthStart", 150 ); level.cmZombieHealthStart = getDvarIntDefault( "cmZombieHealthStart", 150 );
level.zombie_vars[ "zombie_health_start" ] = level.zombieHealthStart; level.zombie_vars[ "zombie_health_start" ] = level.cmZombieHealthStart;
//time before new runners spawn on early rounds //time before new runners spawn on early rounds
level.zombieNewRunnerInterval = getDvarIntDefault( "zombieNewRunnerInterval", 10 ); level.cmZombieNewRunnerInterval = getDvarIntDefault( "cmZombieNewRunnerInterval", 10 );
level.zombie_vars[ "zombie_new_runner_interval" ] = level.zombieNewRunnerInterval; level.zombie_vars[ "zombie_new_runner_interval" ] = level.cmZombieNewRunnerInterval;
//determines level.zombie_move_speed on original //determines level.zombie_move_speed on original
level.zombieMoveSpeedMultiplier = getDvarIntDefault( "zombieMoveSpeedMultiplier", 10 ); level.cmZombieMoveSpeedMultiplier = getDvarIntDefault( "cmZombieMoveSpeedMultiplier", 10 );
level.zombie_vars[ "zombie_move_speed_multiplier" ] = level.zombieMoveSpeedMultiplier; level.zombie_vars[ "zombie_move_speed_multiplier" ] = level.cmZombieMoveSpeedMultiplier;
//determines level.zombie_move_speed on easy //determines level.zombie_move_speed on easy
level.zombieMoveSpeedMultiplierEasy = getDvarIntDefault( "zombieMoveSpeedMultiplierEasy", 8 ); level.cmZombieMoveSpeedMultiplierEasy = getDvarIntDefault( "cmZombieMoveSpeedMultiplierEasy", 8 );
level.zombie_vars[ "zombie_move_speed_multiplier_easy"] = level.zombieMoveSpeedMultiplierEasy; level.zombie_vars[ "zombie_move_speed_multiplier_easy"] = level.cmZombieMoveSpeedMultiplierEasy;
//affects the number of zombies per round formula //affects the number of zombies per round formula
level.zombieMaxAi = getDvarIntDefault( "zombieMaxAi", 24 ); level.cmZombieMaxAi = getDvarIntDefault( "cmZombieMaxAi", 24 );
level.zombie_vars[ "zombie_max_ai" ] = level.zombieMaxAi; level.zombie_vars[ "zombie_max_ai" ] = level.cmZombieMaxAi;
//affects the check for zombies that have fallen thru the map //affects the check for zombies that have fallen thru the map
level.belowWorldCheck = getDvarIntDefault( "belowWorldCheck", -1000 ); level.cmZombieBelowWorldCheck = getDvarIntDefault( "cmZombieBelowWorldCheck", -1000 );
level.zombie_vars[ "below_world_check" ] = level.belowWorldCheck; level.zombie_vars[ "below_world_check" ] = level.cmZombieBelowWorldCheck;
//sets whether spectators respawn at the end of the round //sets whether spectators respawn at the end of the round
level.customSpectatorsRespawn = getDvarIntDefault( "customSpectatorsRespawn", 1 ); level.cmLevelDoSpectatorsRespawn = getDvarIntDefault( "cmLevelDoSpectatorsRespawn", 1 );
level.zombie_vars[ "spectators_respawn" ] = level.customSpectatorsRespawn; level.zombie_vars[ "spectators_respawn" ] = level.cmLevelDoSpectatorsRespawn;
//sets the time that the game takes during the end game intermission //sets the time that the game takes during the end game intermission
level.zombieIntermissionTime = getDvarIntDefault( "zombieIntermissionTime", 20 ); level.cmLevelIntermissionTime = getDvarIntDefault( "cmLevelIntermissionTime", 20 );
level.zombie_vars["zombie_intermission_time"] = level.zombieIntermissionTime; level.zombie_vars["zombie_intermission_time"] = level.cmLevelIntermissionTime;
//the time between rounds //the time between rounds
level.zombieBetweenRoundTime = getDvarIntDefault( "zombieBetweenRoundTime", 15 ); level.cmLevelBetweenRoundTime = getDvarIntDefault( "cmLevelBetweenRoundTime", 15 );
level.zombie_vars["zombie_between_round_time"] = level.zombieBetweenRoundTime; level.zombie_vars["zombie_between_round_time"] = level.cmLevelBetweenRoundTime;
//time before the game starts //time before the game starts
level.roundStartDelay = getDvarIntDefault( "roundStartDelay", 0 ); level.cmLevelGameStartDelay = getDvarIntDefault( "cmLevelGameStartDelay", 0 );
level.zombie_vars[ "game_start_delay" ] = level.roundStartDelay; level.zombie_vars[ "game_start_delay" ] = level.cmLevelGameStartDelay;
//points all players lose when a player bleeds out %10 default //points all players lose when a player bleeds out %10 default
level.bleedoutPointsLostAllPlayers = getDvarFloatDefault( "bleedoutPointsLostAllPlayers", 0.1 ); level.cmPlayerBleedoutPointsLostAllPlayers = getDvarFloatDefault( "cmPlayerBleedoutPointsLostAllPlayers", 0.1 );
level.zombie_vars[ "penalty_no_revive" ] = level.bleedoutPointsLostAllPlayers; level.zombie_vars[ "penalty_no_revive" ] = level.cmPlayerBleedoutPointsLostAllPlayers;
//penalty to the player who died 10% of points by default //penalty to the player who died 10% of points by default
level.bleedoutPointsLostSelf = getDvarFloatDefault( "bleedoutPointsLostSelf", 0.1 ); level.cmPlayerBleedoutPointsLostSelf = getDvarFloatDefault( "cmPlayerBleedoutPointsLostSelf", 0.1 );
level.zombie_vars[ "penalty_died" ] = level.bleedoutPointsLostSelf; level.zombie_vars[ "penalty_died" ] = level.cmPlayerBleedoutPointsLostSelf;
//points players lose on down %5 by default //points players lose on down %5 by default
level.downedPointsLostSelf = getDvarFloatDefault( "downedPointsLostSelf", 0.05 ); level.cmPlayerDownedPointsLostSelf = getDvarFloatDefault( "cmPlayerDownedPointsLostSelf", 0.05 );
level.zombie_vars[ "penalty_downed" ] = level.downedPointsLostSelf; level.zombie_vars[ "penalty_downed" ] = level.cmPlayerDownedPointsLostSelf;
//unknown //unknown
level.playerStartingLives = getDvarIntDefault( "playerStartingLives", 1 ); level.cmPlayerStartingLives = getDvarIntDefault( "cmPlayerStartingLives", 1 );
level.zombie_vars[ "starting_lives" ] = level.playerStartingLives; level.zombie_vars[ "starting_lives" ] = level.cmPlayerStartingLives;
//points earned per zombie kill in a 4 player game //points earned per zombie kill in a 4 player game
level.fourPlayerScorePerZombieKill = getDvarIntDefault( "fourPlayerScorePerZombieKill", 50 ); level.cmPlayerFourPlayerScorePerZombieKill = getDvarIntDefault( "cmPlayerFourPlayerScorePerZombieKill", 50 );
level.zombie_vars[ "zombie_score_kill_4player" ] = level.fourPlayerScorePerZombieKill; level.zombie_vars[ "zombie_score_kill_4player" ] = level.cmPlayerFourPlayerScorePerZombieKill;
//points earned per zombie kill in a 3 player game //points earned per zombie kill in a 3 player game
level.threePlayerScorePerZombieKill = getDvarIntDefault( "threePlayerScorePerZombieKill", 50 ); level.cmPlayerThreePlayerScorePerZombieKill = getDvarIntDefault( "cmPlayerThreePlayerScorePerZombieKill", 50 );
level.zombie_vars[ "zombie_score_kill_3player" ] = level.threePlayerScorePerZombieKill; level.zombie_vars[ "zombie_score_kill_3player" ] = level.cmPlayerThreePlayerScorePerZombieKill;
//points earned per zombie kill in a 2 player game //points earned per zombie kill in a 2 player game
level.twoPlayerScorePerZombieKill = getDvarIntDefault( "twoPlayerScorePerZombieKill", 50 ); level.cmPlayerTwoPlayerScorePerZombieKill = getDvarIntDefault( "cmPlayerTwoPlayerScorePerZombieKill", 50 );
level.zombie_vars[ "zombie_score_kill_2player" ] = level.twoPlayerScorePerZombieKill; level.zombie_vars[ "zombie_score_kill_2player" ] = level.cmPlayerTwoPlayerScorePerZombieKill;
//points earned per zombie kill in a 1 player game //points earned per zombie kill in a 1 player game
level.onePlayerScorePerZombieKill = getDvarIntDefault( "onePlayerScorePerZombieKill", 50 ); level.cmPlayerOnePlayerScorePerZombieKill = getDvarIntDefault( "cmPlayerOnePlayerScorePerZombieKill", 50 );
level.zombie_vars[ "zombie_score_kill_1player" ] = level.onePlayerScorePerZombieKill; level.zombie_vars[ "zombie_score_kill_1player" ] = level.cmPlayerOnePlayerScorePerZombieKill;
//points given for a normal attack //points given for a normal attack
level.pointsPerNormalAttack = getDvarIntDefault( "pointsPerNormalAttack", 10 ); level.cmPlayerPointsPerNormalAttack = getDvarIntDefault( "cmPlayerPointsPerNormalAttack", 10 );
level.zombie_vars[ "zombie_score_damage_normal" ] = level.pointsPerNormalAttack; level.zombie_vars[ "zombie_score_damage_normal" ] = level.cmPlayerPointsPerNormalAttack;
//points given for a light attack //points given for a light attack
level.pointsPerLightAttack = getDvarIntDefault( "pointsPerLightAttack", 10 ); level.cmPlayerPointsPerLightAttack = getDvarIntDefault( "cmPlayerPointsPerLightAttack", 10 );
level.zombie_vars[ "zombie_score_damage_light" ] = level.pointsPerLightAttack; 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 //players turn into a zombie on death WARNING: buggy as can be and is missing assets
level.shouldZombifyPlayer = getDvarIntDefault( "shouldZombifyPlayer", 0 ); level.cmPlayerShouldZombify = getDvarIntDefault( "cmPlayerShouldZombify", 0 );
level.zombie_vars[ "zombify_player" ] = level.shouldZombifyPlayer; level.zombie_vars[ "zombify_player" ] = level.cmPlayerShouldZombify;
//points scalar for allies team //points scalar for allies team
level.alliesPointsMultiplier = getDvarIntDefault( "alliesPointsMultiplier", 1 ); level.cmTeamAlliesPointsMultiplier = getDvarIntDefault( "cmTeamAlliesPointsMultiplier", 1 );
level.zombie_vars[ "allies" ][ "zombie_point_scalar" ] = level.alliesPointsMultiplier; level.zombie_vars[ "allies" ][ "zombie_point_scalar" ] = level.cmTeamAlliesPointsMultiplier;
//points scalar for axis team //points scalar for axis team
level.axisPointsMultiplier = getDvarIntDefault( "axisPointsMultiplier", 1 ); level.cmTeamAxisPointsMultiplier = getDvarIntDefault( "cmTeamAxisPointsMultiplier", 1 );
level.zombie_vars[ "axis" ][ "zombie_point_scalar" ] = level.axisPointsMultiplier; level.zombie_vars[ "axis" ][ "zombie_point_scalar" ] = level.cmTeamAxisPointsMultiplier;
//sets the radius of emps explosion lower this to 1 to render emps useless //sets the radius of emps explosion lower this to 1 to render emps useless
level.empPerkExplosionRadius = getDvarIntDefault( "empPerkExplosionRadius", 420 ); level.cmWeaponEmpPerkExplosionRadius = getDvarIntDefault( "cmWeaponEmpPerkExplosionRadius", 420 );
level.zombie_vars[ "emp_perk_off_range" ] = level.empPerkExplosionRadius; level.zombie_vars[ "emp_perk_off_range" ] = level.cmWeaponEmpPerkExplosionRadius;
//sets the duration of emps on perks set to 0 for infiinite emps //sets the duration of emps on perks set to 0 for infiinite duration
level.empPerkOffDuration = getDvarIntDefault( "empPerkOffDuration", 90 ); level.cmWeaponEmpPerkOffDuration = getDvarIntDefault( "cmWeaponEmpPerkOffDuration", 90 );
level.zombie_vars[ "emp_perk_off_time" ] = level.empPerkOffDuration; level.zombie_vars[ "emp_perk_off_time" ] = level.cmWeaponEmpPerkOffDuration;
//riotshield health //riotshield health
level.riotshieldHitPoints = getDvarIntDefault( "riotshieldHitPoints", 2250 ); level.cmEquipmentRiotshieldHitPoints = getDvarIntDefault( "cmEquipmentRiotshieldHitPoints", 2250 );
level.zombie_vars[ "riotshield_hit_points" ] = level.riotshieldHitPoints; level.zombie_vars[ "riotshield_hit_points" ] = level.cmEquipmentRiotshieldHitPoints;
//jugg health bonus //jugg health bonus
level.juggHealthBonus = getDvarIntDefault( "juggHealthBonus", 160 ); level.cmPerkJuggHealthBonus = getDvarIntDefault( "cmPerkJuggHealthBonus", 160 );
level.zombie_vars[ "zombie_perk_juggernaut_health" ] = level.juggHealthBonus; level.zombie_vars[ "zombie_perk_juggernaut_health" ] = level.cmPerkJuggHealthBonus;
//perma jugg health bonus //perma jugg health bonus
level.permaJuggHealthBonus = getDvarIntDefault( "permaJuggHealthBonus", 190 ); level.cmPerkPermaJuggHealthBonus = getDvarIntDefault( "cmPerkPermaJuggHealthBonus", 90 );
level.zombie_vars[ "zombie_perk_juggernaut_health_upgrade" ] = level.permaJuggHealthBonus; level.zombie_vars[ "zombie_perk_juggernaut_health_upgrade" ] = level.cmPerkPermaJuggHealthBonus;
//phd min explosion damage //phd min explosion damage
level.minPhdExplosionDamage = getDvarIntDefault( "minPhdExplosionDamage", 1000 ); level.cmPerkMinPhdExplosionDamage = getDvarIntDefault( "cmPerkMinPhdExplosionDamage", 2000 );
level.zombie_vars[ "zombie_perk_divetonuke_min_damage" ] = level.minPhdExplosionDamage; level.zombie_vars[ "zombie_perk_divetonuke_min_damage" ] = level.cmPerkMinPhdExplosionDamage;
//phd max explosion damage //phd max explosion damage
level.maxPhdExplosionDamage = getDvarIntDefault( "maxPhdExplosionDamage", 5000 ); level.cmPerkMaxPhdExplosionDamage = getDvarIntDefault( "cmPerkMaxPhdExplosionDamage", 5000 );
level.zombie_vars[ "zombie_perk_divetonuke_max_damage" ] = level.maxPhdExplosionDamage; level.zombie_vars[ "zombie_perk_divetonuke_max_damage" ] = level.cmPerkMaxPhdExplosionDamage;
//phd explosion radius //phd explosion radius
level.phdDamageRadius = getDvarIntDefault( "phdDamageRadius", 300 ); level.cmPerkPhdDamageRadius = getDvarIntDefault( "cmPerkPhdDamageRadius", 300 );
level.zombie_vars[ "zombie_perk_divetonuke_radius" ] = level.phdDamageRadius; 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(); disable_specific_powerups();
checks(); checks();
thread zombies_always_drop_powerups(); thread zombies_always_drop_powerups();
@ -218,18 +241,30 @@ init()
thread zombie_health_cap_override(); thread zombie_health_cap_override();
thread zombie_spawn_delay_fix(); thread zombie_spawn_delay_fix();
thread zombie_speed_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() checks()
{ {
if ( level.mixed_rounds_enabled ) 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; level.mixed_rounds_enabled = 0;
} }
} }
if ( level.start_weapon == "" || level.start_weapon== "m1911_zm" ) if ( level.start_weapon == "" || level.start_weapon== "m1911_zm" )
{ {
level.start_weapon = "m1911_zm"; level.start_weapon = "m1911_zm";
@ -259,50 +294,50 @@ checks()
disable_specific_powerups() disable_specific_powerups()
{ {
level.powerupNames = array( "nuke", "insta_kill", "full_ammo", "double_points", "fire_sale", "free_perk", "carpenter", "zombie_blood" ); level.cmPowerupNames = array( "nuke", "insta_kill", "full_ammo", "double_points", "fire_sale", "free_perk", "carpenter", "zombie_blood" );
array = level.powerupNames; array = level.cmPowerupNames;
//all powerups are enabled by default disable them manually //all powerups are enabled by default disable them manually
//remove nukes from the drop cycle and special drops //remove nukes from the drop cycle and special drops
level.zmPowerupsEnabled = []; level.cmPowerupEnabled = [];
level.zmPowerupsEnabled[ "nuke" ] = spawnstruct(); level.cmPowerupEnabled[ "nuke" ] = spawnstruct();
level.zmPowerupsEnabled[ "nuke" ].name = "nuke"; level.cmPowerupEnabled[ "nuke" ].name = "nuke";
level.zmPowerupsEnabled[ "nuke" ].active = getDvarIntDefault( "zmPowerupsNukeEnabled", 1 ); level.cmPowerupEnabled[ "nuke" ].active = getDvarIntDefault( "cmPowerupNukeEnabled", 1 );
//remove insta kills from the drop cycle and special drops //remove insta kills from the drop cycle and special drops
level.zmPowerupsEnabled[ "insta_kill" ] = spawnstruct(); level.cmPowerupEnabled[ "insta_kill" ] = spawnstruct();
level.zmPowerupsEnabled[ "insta_kill" ].name = "insta_kill"; level.cmPowerupEnabled[ "insta_kill" ].name = "insta_kill";
level.zmPowerupsEnabled[ "insta_kill" ].active = getDvarIntDefault( "zmPowerupsInstaKillEnabled", 1 ); level.cmPowerupEnabled[ "insta_kill" ].active = getDvarIntDefault( "cmPowerupInstaKillEnabled", 1 );
//remove max ammos from the drop cycle and special drops //remove max ammos from the drop cycle and special drops
level.zmPowerupsEnabled[ "full_ammo" ] = spawnstruct(); level.cmPowerupEnabled[ "full_ammo" ] = spawnstruct();
level.zmPowerupsEnabled[ "full_ammo" ].name = "full_ammo"; level.cmPowerupEnabled[ "full_ammo" ].name = "full_ammo";
level.zmPowerupsEnabled[ "full_ammo" ].active = getDvarIntDefault( "zmPowerupsMaxAmmoEnabled", 1 ); level.cmPowerupEnabled[ "full_ammo" ].active = getDvarIntDefault( "cmPowerupMaxAmmoEnabled", 1 );
//remove carpenter from the drop cycle and special drops //remove carpenter from the drop cycle and special drops
level.zmPowerupsEnabled[ "double_points" ] = spawnstruct(); level.cmPowerupEnabled[ "double_points" ] = spawnstruct();
level.zmPowerupsEnabled[ "double_points" ].name = "double_points"; level.cmPowerupEnabled[ "double_points" ].name = "double_points";
level.zmPowerupsEnabled[ "double_points" ].active = getDvarIntDefault( "zmPowerupsDoublePointsEnabled", 1 ); 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 //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.cmPowerupEnabled[ "fire_sale" ] = spawnstruct();
level.zmPowerupsEnabled[ "fire_sale" ].name = "fire_sale"; level.cmPowerupEnabled[ "fire_sale" ].name = "fire_sale";
level.zmPowerupsEnabled[ "fire_sale" ].active = getDvarIntDefault( "zmPowerupsFireSaleEnabled", 1 ); level.cmPowerupEnabled[ "fire_sale" ].active = getDvarIntDefault( "cmPowerupFireSaleEnabled", 1 );
//remove the perk bottle from the drop cycle and special drops //remove the perk bottle from the drop cycle and special drops
level.zmPowerupsEnabled[ "free_perk" ] = spawnstruct(); level.cmPowerupEnabled[ "free_perk" ] = spawnstruct();
level.zmPowerupsEnabled[ "free_perk" ].name = "free_perk"; level.cmPowerupEnabled[ "free_perk" ].name = "free_perk";
level.zmPowerupsEnabled[ "free_perk" ].active = getDvarIntDefault( "zmPowerupsPerkBottleEnabled", 1 ); level.cmPowerupEnabled[ "free_perk" ].active = getDvarIntDefault( "cmPowerupPerkBottleEnabled", 1 );
//removes carpenter from the drop cycle and special drops //removes carpenter from the drop cycle and special drops
level.zmPowerupsEnabled[ "carpenter" ] = spawnstruct(); level.cmPowerupEnabled[ "carpenter" ] = spawnstruct();
level.zmPowerupsEnabled[ "carpenter" ].name = "carpenter"; level.cmPowerupEnabled[ "carpenter" ].name = "carpenter";
level.zmPowerupsEnabled[ "carpenter" ].active = getDvarIntDefault( "zmPowerupsCarpenterEnabled", 1 ); level.cmPowerupEnabled[ "carpenter" ].active = getDvarIntDefault( "cmPowerupCarpenterEnabled", 1 );
//removes zombie blood from the drop cycle and special drops //removes zombie blood from the drop cycle and special drops
level.zmPowerupsEnabled[ "zombie_blood" ] = spawnstruct(); level.cmPowerupEnabled[ "zombie_blood" ] = spawnstruct();
level.zmPowerupsEnabled[ "zombie_blood" ].name = "zombie_blood"; level.cmPowerupEnabled[ "zombie_blood" ].name = "zombie_blood";
level.zmPowerupsEnabled[ "zombie_blood" ].active = getDvarIntDefault( "zmPowerupsZombieBloodEnabled", 1 ); 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 //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++ ) 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 ) ) if ( isInArray( level.zombie_include_powerups, name ) )
{ {
arrayremovevalue( level.zombie_include_powerups, name ); arrayremovevalue( level.zombie_include_powerups, name );
@ -321,7 +356,7 @@ disable_specific_powerups()
disable_all_powerups() disable_all_powerups()
{ {
if ( level.zmPowerupsNoPowerupDrops ) if ( level.cmPowerupNoPowerupDrops )
{ {
flag_clear( "zombie_drop_powerups" ); flag_clear( "zombie_drop_powerups" );
} }
@ -329,13 +364,13 @@ disable_all_powerups()
zombies_always_drop_powerups() zombies_always_drop_powerups()
{ {
if ( !level.zombiesAlwaysDropPowerups ) if ( !level.cmPowerupAlwaysDrop )
{ {
return; return;
} }
while ( 1 ) while ( 1 )
{ {
level.zombie_vars[ "zombie_drop_item" ] = level.zombiesAlwaysDropPowerups; level.zombie_vars[ "zombie_drop_item" ] = level.cmPowerupAlwaysDrop;
wait 0.05; wait 0.05;
} }
} }
@ -356,65 +391,65 @@ onplayerspawned()
zombies_per_round_override() zombies_per_round_override()
{ {
if ( !level.overrideZombieTotalPermanently ) if ( !level.cmZombieTotalPermanentOverride )
{ {
return; return;
} }
while ( 1 ) while ( 1 )
{ {
level waittill( "start_of_round" ); level waittill( "start_of_round" );
level.zombie_total = getDvarIntDefault( "overrideZombieTotalPermanentlyValue", 6 ); level.zombie_total = level.cmZombieTotalPermanentOverrideValue;
} }
} }
zombie_health_override() zombie_health_override()
{ {
if ( !level.overrideZombieHealthPermanently ) if ( !level.cmZombieHealthPermanentOverride )
{ {
return; return;
} }
while ( 1 ) while ( 1 )
{ {
level waittill( "start_of_round" ); level waittill( "start_of_round" );
level.zombie_health = getDvarIntDefault( "overrideZombieHealthPermanentlyValue", 150 ); level.zombie_health = level.cmZombieHealthPermanentOverrideValue;
} }
} }
zombie_health_cap_override() zombie_health_cap_override()
{ {
if ( !level.overrideZombieMaxHealth ) if ( !level.cmZombieMaxHealthOverride )
{ {
return; return;
} }
while ( 1 ) while ( 1 )
{ {
level waittill( "start_of_round" ); 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() zombie_spawn_delay_fix()
{ {
if ( level.zombieSpawnRateLocked ) if ( level.cmZombieSpawnRateLocked )
{ {
return; return;
} }
i = 1; i = 1;
while ( i <= level.round_number ) while ( i <= level.round_number )
{ {
timer = level.zombieSpawnRate; timer = level.cmZombieSpawnRate;
if ( timer > 0.08 ) if ( timer > 0.08 )
{ {
level.zombieSpawnRate = timer * level.zombieSpawnRateMultiplier; level.cmZombieSpawnRate = timer * level.cmZombieSpawnRateMultiplier;
i++; i++;
continue; continue;
} }
else if ( timer < 0.08 ) if ( timer < 0.08 )
{ {
level.zombieSpawnRate = 0.08; level.cmZombieSpawnRate = 0.08;
break; break;
} }
i++; i++;
@ -422,17 +457,17 @@ zombie_spawn_delay_fix()
while ( 1 ) while ( 1 )
{ {
level waittill( "start_of_round" ); 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() zombie_speed_fix()
{ {
if ( level.zombieMoveSpeedLocked ) if ( level.cmZombieMoveSpeedLocked )
{ {
return; return;
} }
@ -448,29 +483,104 @@ zombie_speed_fix()
zombie_speed_override() zombie_speed_override()
{ {
if ( !level.zombieMoveSpeedLocked ) if ( !level.cmZombieMoveSpeedLocked )
{ {
return; return;
} }
while ( 1 ) while ( 1 )
{ {
level waittill( "start_of_round" ); level waittill( "start_of_round" );
level.zombie_move_speed = getDvarIntDefault( "zombieMoveSpeed", 1 ); level.zombie_move_speed = getDvarIntDefault( "cmZombieMoveSpeed", 1 );
} }
} }
zombie_speed_cap_override() zombie_speed_cap_override()
{ {
if ( !level.zombieMoveSpeedCap ) if ( !level.cmZombieMoveSpeedCap )
{ {
return; return;
} }
while ( 1 ) while ( 1 )
{ {
level waittill( "start_of_round" ); 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 );
}

2883
Configuration Mod/_zm_powerups.gsc Normal file
View File

File diff suppressed because it is too large Load Diff

12
Configuration Mod/black ops 2 weapon names.md
View File

@ -35,6 +35,8 @@ m32_upgraded_zm
m32_zm //war machine m32_zm //war machine
python_upgraded_zm python_upgraded_zm
python_zm //python python_zm //python
qcw05_upgraded_zm
qcw05_zm //chicom
sf_qcw05_upgraded_zm sf_qcw05_upgraded_zm
riotshield_zm //zombie shield riotshield_zm //zombie shield
rottweil72_upgraded_zm rottweil72_upgraded_zm
@ -100,6 +102,8 @@ mp5k_upgraded_zm
mp5k_zm mp5k_zm
python_upgraded_zm python_upgraded_zm
python_zm python_zm
qcw05_upgraded_zm
qcw05_zm //chicom
sf_qcw05_upgraded_zm sf_qcw05_upgraded_zm
rpd_upgraded_zm rpd_upgraded_zm
rpd_zm rpd_zm
@ -160,6 +164,8 @@ pdw57_upgraded_zm
pdw57_zm pdw57_zm
python_upgraded_zm python_upgraded_zm
python_zm python_zm
qcw05_upgraded_zm
qcw05_zm //chicom
sf_qcw05_upgraded_zm sf_qcw05_upgraded_zm
rpd_upgraded_zm rpd_upgraded_zm
rpd_zm rpd_zm
@ -220,6 +226,8 @@ m32_upgraded_zm
m32_zm m32_zm
pdw57_upgraded_zm pdw57_upgraded_zm
pdw57_zm pdw57_zm
qcw05_upgraded_zm
qcw05_zm //chicom
sf_qcw05_upgraded_zm sf_qcw05_upgraded_zm
rnma_upgraded_zm rnma_upgraded_zm
rnma_zm rnma_zm
@ -333,6 +341,8 @@ one_inch_punch_upgraded_zm
one_inch_punch_zm one_inch_punch_zm
python_upgraded_zm python_upgraded_zm
python_zm python_zm
qcw05_upgraded_zm
qcw05_zm //chicom
sf_qcw05_upgraded_zm sf_qcw05_upgraded_zm
scar_upgraded_zm scar_upgraded_zm
scar_zm scar_zm
@ -391,8 +401,6 @@ galil_upgraded_zm
galil_zm //galil galil_zm //galil
m14_upgraded_zm m14_upgraded_zm
m14_zm m14_zm
qcw05_upgraded_zm
qcw05_zm //chicom
ray_gun_upgraded_zm ray_gun_upgraded_zm
ray_gun_zm ray_gun_zm
raygun_mark2_upgraded_zm raygun_mark2_upgraded_zm

203
Configuration Mod/dedicated_zm.cfg
View File

@ -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! //gts cleansedLoadout "1" // Allow players to choose their Loadout? Only Turned has this option!
//set g_loadScripts "0" //set g_loadScripts "0"
set playerStartingPoints 500 //level properties
set perkLimit 4 set cmLevelNoEndGameCheck 0
set zombieAiLimit 24 set cmLevelRoundNumber 1
set zombieActorLimit 32 set cmLevelSoloModeDisabled 0
set midroundDogs 0 set cmLevelDoSpectatorsRespawn 1
set noEndGameCheck 0 set cmLevelIntermissionTime 20
set soloLaststandWeapon "m1911_upgraded_zm" set cmLevelBetweenRoundTime 15
set coopLaststandWeapon "m1911_zm" set cmLevelGameStartDelay 0
set startWeaponZm "m1911_zm"
set disableWalkers 0
set roundNumber 1
set soloModeDisabled 0
//powerups properties //powerups properties
set maxPowerupsPerRound 4 set cmPowerupMaxPerRound 4
set powerupDropRate 2000 set cmPowerupDropRate 2000
set zombiesAlwaysDropPowerups 0 set cmPowerupAlwaysDrop 0
set fourPlayerPowerupScore 50 set cmPowerupFourPlayerScore 50
set threePlayerPowerupScore 50 set cmPowerupThreePlayerScore 50
set twoPlayerPowerupScore 50 set cmPowerupTwoPlayerScore 50
set onePlayerPowerupScore 50 set cmPowerupOnePlayerScore 50
set powerupScoreMeleeKill 80 set cmPowerupScoreMeleeKill 80
set powerupScoreHeadshotKill 50 set cmPowerupScoreHeadshotKill 50
set powerupScoreNeckKill 20 set cmPowerupScoreNeckKill 20
set powerupScoreTorsoKill 10 set cmPowerupScoreTorsoKill 10
set zmPowerupsNukeEnabled 1 set cmPowerupNukeEnabled 1
set zmPowerupsInstaKillEnabled 1 set cmPowerupInstaKillEnabled 1
set zmPowerupsMaxAmmoEnabled 1 set cmPowerupMaxAmmoEnabled 1
set zmPowerupsDoublePointsEnabled 1 set cmPowerupDoublePointsEnabled 1
set zmPowerupsCarpenterEnabled 1 set cmPowerupCarpenterEnabled 1
set zmPowerupsFireSaleEnabled 1 set cmPowerupFireSaleEnabled 1
set zmPowerupsPerkBottleEnabled 1 set cmPowerupPerkBottleEnabled 1
set zmPowerupsCarpenterEnabled 1 set cmPowerupCarpenterEnabled 1
set zmPowerupsZombieBloodEnabled 1 set cmPowerupZombieBloodEnabled 1
set zmPowerupsNoPowerupDrops 0 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 //zombie properties dvars
set overrideZombieTotalPermanently 0 set cmZombieAiLimit 24
set overrideZombieTotalPermanentlyValue 100 set cmZombieActorLimit 32
set overrideZombieHealthPermanently 0 set cmZombieMidroundDogs 0
set overrideZombieHealthPermanentlyValue 150 set cmZombieDisableWalkers 0
set overrideZombieMaxHealth 0 set cmZombieTotalPermanentOverride 0
set overrideZombieMaxHealthValue 150 set cmZombieTotalPermanentOverrideValue 100
set zombieSpawnRate 2 set cmZombieHealthPermanentOverride 0
set zombieSpawnRateMultiplier 0.95 set cmZombieHealthPermanentOverrideValue 150
set zombieSpawnRateLocked 0 set cmZombieMaxHealthOverride 0
set zombiesPerPlayer 6 set cmZombieMaxHealthOverrideValue 150
set zombieHealthIncreaseFlat 100 set cmZombieSpawnRate 2
set zombieHealthIncreaseMultiplier 0.1 set cmZombieSpawnRateMultiplier 0.95
set zombieHealthStart 150 set cmZombieSpawnRateLocked 0
set zombieNewRunnerInterval 10 set cmZombiePerPlayer 6
set zombieMoveSpeed 1 set cmZombieHealthIncreaseFlat 100
set zombieMoveSpeedLocked 1 set cmZombieHealthIncreaseMultiplier 0.1
set zombieMoveSpeedCap 0 set cmZombieHealthStart 150
set zombieMoveSpeedCapValue 1 set cmZombieNewRunnerInterval 10
set zombieMoveSpeedMultiplier 10 set cmZombieMoveSpeed 1
set zombieMoveSpeedMultiplierEasy 8 set cmZombieMoveSpeedLocked 1
set zombieMaxAi 24 set cmZombieMoveSpeedCap 0
set belowWorldCheck -1000 set cmZombieMoveSpeedCapValue 1
set cmZombieMoveSpeedMultiplier 10
//round properties set cmZombieMoveSpeedMultiplierEasy 8
set customSpectatorsRespawn 1 set cmZombieMoveAnimation ""
set zombieIntermissionTime 20 set cmZombieMaxAi 24
set zombieBetweenRoundTime 15 set cmZombieBelowWorldCheck -1000
set roundStartDelay 0
//player properties //player properties
set bleedoutPointsLostAllPlayers 0.1 set cmPlayerMaxHealth 100
set bleedoutPointsLostSelf 0.1 set cmPlayerPerkLimit 4
set downedPointsLostSelf 0.05 set cmPlayerRetainPerks 0
set playerStartingLives 1 set cmPlayerStartingPoints 500
set fourPlayerScorePerZombieKill 50 set cmPlayerStartingLives 1
set threePlayerScorePerZombieKill 50 set cmPlayerFourPlayerScorePerZombieKill 50
set twoPlayerScorePerZombieKill 50 set cmPlayerThreePlayerScorePerZombieKill 50
set onePlayerScorePerZombieKill 50 set cmPlayerTwoPlayerScorePerZombieKill 50
set pointsPerNormalAttack 10 set cmPlayerOnePlayerScorePerZombieKill 50
set pointsPerLightAttack 10 set cmPlayerPointsPerNormalAttack 10
set shouldZombifyPlayer 0 set cmPlayerPointsPerLightAttack 10
set alliesPointsMultiplier 1 set cmPlayerShouldZombify 0
set axisPointsMultiplier 1 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 //perk properties
set empPerkExplosionRadius 420 set cmPerkJuggHealthBonus 160
set empPerkOffDuration 90 set cmPerkPermaJuggHealthBonus 190
set riotshieldHitPoints 2250 set cmPerkMinPhdExplosionDamage 2000
set juggHealthBonus 160 set cmPerkMaxPhdExplosionDamage 5000
set permaJuggHealthBonus 190 set cmPerkPhdDamageRadius 300
set minPhdExplosionDamage 1000 set cmPerkSpeedColaReloadSpeed 0.5
set maxPhdExplosionDamage 5000 set cmPerkDoubleTapFireRate 0.75
set phdDamageRadius 300 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 //sets whether the mystery box moves ever
set magic_chest_movable 1 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
////////////////////////////////////////////////// //////////////////////////////////////////////////

60
Configuration Mod/readme.md
View File

@ -1,15 +1,26 @@
# Configuration Mod # Configuration Mod
*** Instructions ***
Merge inits with your current mod or compile as _clientids.gsc. 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. 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. 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. 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 #### New dvars
@ -47,3 +58,48 @@ Added tha ability to lock the zombie health
Added the ability to lock the zombies per round 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