moved project to its own repo

patch_zm/maps/mp/gametypes_zm/_clientids.gsc

@@ -0,0 +1,16 @@
+
+init()
+{
+	level.clientid = 0;
+	level thread onplayerconnect();
+}
+
+onplayerconnect()
+{
+	for ( ;; )
+	{
+		level waittill( "connecting", player );
+		player.clientid = level.clientid;
+		level.clientid++;
+	}
+}

patch_zm/maps/mp/gametypes_zm/_scoreboard.gsc

@@ -0,0 +1,25 @@
+
+init()
+{
+	setdvar( "g_ScoresColor_Spectator", ".25 .25 .25" );
+	setdvar( "g_ScoresColor_Free", ".76 .78 .10" );
+	setdvar( "g_teamColor_MyTeam", ".4 .7 .4" );
+	setdvar( "g_teamColor_EnemyTeam", "1 .315 0.35" );
+	setdvar( "g_teamColor_MyTeamAlt", ".35 1 1" );
+	setdvar( "g_teamColor_EnemyTeamAlt", "1 .5 0" );
+	setdvar( "g_teamColor_Squad", ".315 0.35 1" );
+	if ( level.createfx_enabled )
+	{
+		return;
+	}
+	if ( sessionmodeiszombiesgame() )
+	{
+		setdvar( "g_TeamIcon_Axis", "faction_cia" );
+		setdvar( "g_TeamIcon_Allies", "faction_cdc" );
+	}
+	else
+	{
+		setdvar( "g_TeamIcon_Axis", game[ "icons" ][ "axis" ] );
+		setdvar( "g_TeamIcon_Allies", game[ "icons" ][ "allies" ] );
+	}
+}

patch_zm/maps/mp/gametypes_zm/_shellshock.gsc

@@ -0,0 +1,65 @@
+#include common_scripts/utility;
+#include maps/mp/_utility;
+
+init()
+{
+	precacheshellshock( "frag_grenade_mp" );
+	precacheshellshock( "damage_mp" );
+	precacherumble( "artillery_rumble" );
+	precacherumble( "grenade_rumble" );
+}
+
+shellshockondamage( cause, damage )
+{
+	if ( cause != "MOD_EXPLOSIVE" && cause != "MOD_GRENADE" && cause != "MOD_GRENADE_SPLASH" || cause == "MOD_PROJECTILE" && cause == "MOD_PROJECTILE_SPLASH" )
+	{
+		time = 0;
+		if ( damage >= 90 )
+		{
+			time = 4;
+		}
+		else if ( damage >= 50 )
+		{
+			time = 3;
+		}
+		else if ( damage >= 25 )
+		{
+			time = 2;
+		}
+		else
+		{
+			if ( damage > 10 )
+			{
+				time = 2;
+			}
+		}
+		if ( time )
+		{
+			if ( self mayapplyscreeneffect() )
+			{
+				self shellshock( "frag_grenade_mp", 0.5 );
+			}
+		}
+	}
+}
+
+endondeath()
+{
+	self waittill( "death" );
+	waittillframeend;
+	self notify( "end_explode" );
+}
+
+endontimer( timer )
+{
+	self endon( "disconnect" );
+	wait timer;
+	self notify( "end_on_timer" );
+}
+
+rcbomb_earthquake( position )
+{
+	playrumbleonposition( "grenade_rumble", position );
+	earthquake( 0.5, 0.5, self.origin, 512 );
+}
+

patch_zm/maps/mp/gametypes_zm/zclassic.gsc

@@ -0,0 +1,31 @@
+#include maps/mp/zombies/_zm_stats;
+#include common_scripts/utility;
+#include maps/mp/gametypes_zm/_hud_util;
+#include maps/mp/_utility;
+#include maps/mp/gametypes_zm/_zm_gametype;
+#include maps/mp/zombies/_zm_stats;
+
+main()
+{
+	maps/mp/gametypes_zm/_zm_gametype::main();
+	level.onprecachegametype = ::onprecachegametype;
+	level.onstartgametype = ::onstartgametype;
+	level._game_module_custom_spawn_init_func = ::custom_spawn_init_func;
+	level._game_module_stat_update_func = ::survival_classic_custom_stat_update;
+	maps/mp/gametypes_zm/_zm_gametype::post_gametype_main( "zclassic" );
+}
+
+onprecachegametype()
+{
+	level.playersuicideallowed = 1;
+	level.canplayersuicide = ::canplayersuicide;
+	level.suicide_weapon = "death_self_zm";
+	precacheitem( "death_self_zm" );
+	maps/mp/gametypes_zm/_zm_gametype::rungametypeprecache( "zclassic" );
+}
+
+onstartgametype()
+{
+	maps/mp/gametypes_zm/_zm_gametype::rungametypemain( "zclassic", ::zclassic_main );
+}
+

patch_zm/maps/mp/zombies/NoKnownErrors/_zm_ai_basic.gsc

@@ -0,0 +1,571 @@
+#include maps/mp/animscripts/zm_shared;
+#include maps/mp/animscripts/zm_run;
+#include maps/mp/zombies/_zm_ai_basic;
+#include maps/mp/zombies/_zm_spawner;
+#include maps/mp/zombies/_zm_utility;
+#include maps/mp/_utility;
+#include common_scripts/utility;
+
+find_flesh()
+{
+	self endon( "death" );
+	level endon( "intermission" );
+	self endon( "stop_find_flesh" );
+	if ( level.intermission )
+	{
+		return;
+	}
+	self.ai_state = "find_flesh";
+	self.helitarget = 1;
+	self.ignoreme = 0;
+	self.nododgemove = 1;
+	self.ignore_player = [];
+	self maps/mp/zombies/_zm_spawner::zombie_history( "find flesh -> start" );
+	self.goalradius = 32;
+	if ( isDefined( self.custom_goalradius_override ) )
+	{
+		self.goalradius = self.custom_goalradius_override;
+	}
+	while ( 1 )
+	{
+		zombie_poi = undefined;
+		if ( isDefined( level.zombietheaterteleporterseeklogicfunc ) )
+		{
+			self [[ level.zombietheaterteleporterseeklogicfunc ]]();
+		}
+		if ( isDefined( level._poi_override ) )
+		{
+			zombie_poi = self [[ level._poi_override ]]();
+		}
+		if ( !isDefined( zombie_poi ) )
+		{
+			zombie_poi = self get_zombie_point_of_interest( self.origin );
+		}
+		players = get_players();
+		if ( !isDefined( self.ignore_player ) || players.size == 1 )
+		{
+			self.ignore_player = [];
+		}
+		else
+		{
+			while ( !isDefined( level._should_skip_ignore_player_logic ) || !( [[ level._should_skip_ignore_player_logic ]]() ) )
+			{
+				i = 0;
+				while ( i < self.ignore_player.size )
+				{
+					while ( isDefined( self.ignore_player[ i ] ) && isDefined( self.ignore_player[ i ].ignore_counter ) && self.ignore_player[ i ].ignore_counter > 3 )
+					{
+						self.ignore_player[ i ].ignore_counter = 0;
+						self.ignore_player = arrayremovevalue( self.ignore_player, self.ignore_player[ i ] );
+						if ( !isDefined( self.ignore_player ) )
+						{
+							self.ignore_player = [];
+						}
+						i = 0;
+					}
+					i++;
+				}
+			}
+		}
+		player = get_closest_valid_player( self.origin, self.ignore_player );
+		while ( !isDefined( player ) && !isDefined( zombie_poi ) )
+		{
+			self maps/mp/zombies/_zm_spawner::zombie_history( "find flesh -> can't find player, continue" );
+			if ( isDefined( self.ignore_player ) )
+			{
+				while ( isDefined( level._should_skip_ignore_player_logic ) && [[ level._should_skip_ignore_player_logic ]]() )
+				{
+					wait 1;
+				}
+				self.ignore_player = [];
+			}
+			wait 1;
+		}
+		if ( !isDefined( level.check_for_alternate_poi ) || !( [[ level.check_for_alternate_poi ]]() ) )
+		{
+			self.enemyoverride = zombie_poi;
+			self.favoriteenemy = player;
+		}
+		self thread zombie_pathing();
+		while ( players.size > 1 )
+		{
+			i = 0;
+			while ( i < self.ignore_player.size )
+			{
+				if ( isDefined( self.ignore_player[ i ] ) )
+				{
+					if ( !isDefined( self.ignore_player[ i ].ignore_counter ) )
+					{
+						self.ignore_player[ i ].ignore_counter = 0;
+						i++;
+						continue;
+					}
+					else
+					{
+						self.ignore_player[ i ].ignore_counter += 1;
+					}
+				}
+				i++;
+			}
+		}
+		self thread attractors_generated_listener();
+		if ( isDefined( level._zombie_path_timer_override ) )
+		{
+			self.zombie_path_timer = [[ level._zombie_path_timer_override ]]();
+		}
+		else
+		{
+			self.zombie_path_timer = getTime() + ( randomfloatrange( 1, 3 ) * 1000 );
+		}
+		while ( getTime() < self.zombie_path_timer )
+		{
+			wait 0.1;
+		}
+		self notify( "path_timer_done" );
+		self maps/mp/zombies/_zm_spawner::zombie_history( "find flesh -> bottom of loop" );
+		debug_print( "Zombie is re-acquiring enemy, ending breadcrumb search" );
+		self notify( "zombie_acquire_enemy" );
+	}
+}
+
+init_inert_zombies()
+{
+	level init_inert_substates();
+}
+
+init_inert_substates()
+{
+	level.inert_substates = [];
+	level.inert_substates[ level.inert_substates.size ] = "inert1";
+	level.inert_substates[ level.inert_substates.size ] = "inert2";
+	level.inert_substates[ level.inert_substates.size ] = "inert3";
+	level.inert_substates[ level.inert_substates.size ] = "inert4";
+	level.inert_substates[ level.inert_substates.size ] = "inert5";
+	level.inert_substates[ level.inert_substates.size ] = "inert6";
+	level.inert_substates[ level.inert_substates.size ] = "inert7";
+	level.inert_substates = array_randomize( level.inert_substates );
+	level.inert_substate_index = 0;
+	level.inert_trans_walk = [];
+	level.inert_trans_walk[ level.inert_trans_walk.size ] = "inert_2_walk_1";
+	level.inert_trans_walk[ level.inert_trans_walk.size ] = "inert_2_walk_2";
+	level.inert_trans_walk[ level.inert_trans_walk.size ] = "inert_2_walk_3";
+	level.inert_trans_walk[ level.inert_trans_walk.size ] = "inert_2_walk_4";
+	level.inert_trans_run = [];
+	level.inert_trans_run[ level.inert_trans_run.size ] = "inert_2_run_1";
+	level.inert_trans_run[ level.inert_trans_run.size ] = "inert_2_run_2";
+	level.inert_trans_sprint = [];
+	level.inert_trans_sprint[ level.inert_trans_sprint.size ] = "inert_2_sprint_1";
+	level.inert_trans_sprint[ level.inert_trans_sprint.size ] = "inert_2_sprint_2";
+	level.inert_crawl_substates = [];
+	level.inert_crawl_substates[ level.inert_crawl_substates.size ] = "inert1";
+	level.inert_crawl_substates[ level.inert_crawl_substates.size ] = "inert2";
+	level.inert_crawl_substates[ level.inert_crawl_substates.size ] = "inert3";
+	level.inert_crawl_substates[ level.inert_crawl_substates.size ] = "inert4";
+	level.inert_crawl_substates[ level.inert_crawl_substates.size ] = "inert5";
+	level.inert_crawl_substates[ level.inert_crawl_substates.size ] = "inert6";
+	level.inert_crawl_substates[ level.inert_crawl_substates.size ] = "inert7";
+	level.inert_crawl_trans_walk = [];
+	level.inert_crawl_trans_walk[ level.inert_crawl_trans_walk.size ] = "inert_2_walk_1";
+	level.inert_crawl_trans_run = [];
+	level.inert_crawl_trans_run[ level.inert_crawl_trans_run.size ] = "inert_2_run_1";
+	level.inert_crawl_trans_run[ level.inert_crawl_trans_run.size ] = "inert_2_run_2";
+	level.inert_crawl_trans_sprint = [];
+	level.inert_crawl_trans_sprint[ level.inert_crawl_trans_sprint.size ] = "inert_2_sprint_1";
+	level.inert_crawl_trans_sprint[ level.inert_crawl_trans_sprint.size ] = "inert_2_sprint_2";
+	level.inert_crawl_substates = array_randomize( level.inert_crawl_substates );
+	level.inert_crawl_substate_index = 0;
+}
+
+get_inert_substate()
+{
+	substate = level.inert_substates[ level.inert_substate_index ];
+	level.inert_substate_index++;
+	if ( level.inert_substate_index >= level.inert_substates.size )
+	{
+		level.inert_substates = array_randomize( level.inert_substates );
+		level.inert_substate_index = 0;
+	}
+	return substate;
+}
+
+get_inert_crawl_substate()
+{
+	substate = level.inert_crawl_substates[ level.inert_crawl_substate_index ];
+	level.inert_crawl_substate_index++;
+	if ( level.inert_crawl_substate_index >= level.inert_crawl_substates.size )
+	{
+		level.inert_crawl_substates = array_randomize( level.inert_crawl_substates );
+		level.inert_crawl_substate_index = 0;
+	}
+	return substate;
+}
+
+start_inert( in_place )
+{
+	self endon( "death" );
+	if ( isDefined( self.is_inert ) && self.is_inert )
+	{
+		self maps/mp/zombies/_zm_spawner::zombie_history( "is_inert already set " + getTime() );
+		return;
+	}
+	self.is_inert = 1;
+	self notify( "start_inert" );
+	self maps/mp/zombies/_zm_spawner::zombie_eye_glow_stop();
+	self maps/mp/zombies/_zm_spawner::zombie_history( "is_inert set " + getTime() );
+	self playsound( "zmb_zombie_go_inert" );
+	if ( isDefined( self.barricade_enter ) && self.barricade_enter )
+	{
+		while ( isDefined( self.barricade_enter ) && self.barricade_enter )
+		{
+			wait 0.1;
+		}
+	}
+	else if ( isDefined( self.ai_state ) && self.ai_state == "zombie_goto_entrance" )
+	{
+		self notify( "stop_zombie_goto_entrance" );
+		self maps/mp/zombies/_zm_spawner::reset_attack_spot();
+	}
+	if ( isDefined( self.completed_emerging_into_playable_area ) && self.completed_emerging_into_playable_area )
+	{
+		self notify( "stop_find_flesh" );
+		self notify( "zombie_acquire_enemy" );
+	}
+	else
+	{
+		in_place = 1;
+	}
+	if ( isDefined( self.in_the_ground ) && self.in_the_ground )
+	{
+		self waittill( "risen", find_flesh_struct_string );
+		if ( self maps/mp/zombies/_zm_spawner::should_skip_teardown( find_flesh_struct_string ) )
+		{
+			if ( isDefined( self.completed_emerging_into_playable_area ) && !self.completed_emerging_into_playable_area )
+			{
+				self waittill( "completed_emerging_into_playable_area" );
+			}
+			self notify( "stop_find_flesh" );
+			self notify( "zombie_acquire_enemy" );
+		}
+	}
+	while ( isDefined( self.is_traversing ) && self.is_traversing )
+	{
+		while ( self isinscriptedstate() )
+		{
+			wait 0,1;
+		}
+	}
+	if ( isDefined( self.doing_equipment_attack ) && self.doing_equipment_attack )
+	{
+		self stopanimscripted();
+	}
+	if ( isDefined( self.inert_delay ) )
+	{
+		self [[ self.inert_delay ]]();
+		self maps/mp/zombies/_zm_spawner::zombie_history( "inert_delay done " + getTime() );
+	}
+	self inert_think( in_place );
+}
+
+inert_think( in_place )
+{
+	self endon( "death" );
+	self.ignoreall = 1;
+	self animmode( "normal" );
+	if ( self.has_legs )
+	{
+		if ( isDefined( in_place ) && in_place )
+		{
+			self setgoalpos( self.origin );
+			if ( randomint( 100 ) > 50 )
+			{
+				self maps/mp/zombies/_zm_spawner::zombie_history( "inert 1 " + getTime() );
+				self setanimstatefromasd( "zm_inert", "inert1" );
+			}
+			else
+			{
+				self maps/mp/zombies/_zm_spawner::zombie_history( "inert 2 " + getTime() );
+				self setanimstatefromasd( "zm_inert", "inert2" );
+			}
+			self.in_place = 1;
+		}
+		else
+		{
+			substate = get_inert_substate();
+			if ( isDefined( level.inert_substate_override ) )
+			{
+				substate = self [[ level.inert_substate_override ]]( substate );
+			}
+			self setanimstatefromasd( "zm_inert", substate );
+			self maps/mp/zombies/_zm_spawner::zombie_history( "zm_inert ASD " + getTime() );
+			if ( substate != "inert3" && substate != "inert4" || substate == "inert5" && substate == "inert6" )
+			{
+				self thread inert_watch_goal();
+			}
+			else
+			{
+				self.in_place = 1;
+			}
+		}
+	}
+	else
+	{
+		self setanimstatefromasd( "zm_inert_crawl", get_inert_crawl_substate() );
+		self maps/mp/zombies/_zm_spawner::zombie_history( "zm_inert_crawl ASD " + getTime() );
+	}
+	self thread inert_wakeup();
+	self waittill( "stop_zombie_inert" );
+	self maps/mp/zombies/_zm_spawner::zombie_history( "stop_zombie_inert " + getTime() );
+	self playsound( "zmb_zombie_end_inert" );
+	self inert_transition();
+	self maps/mp/zombies/_zm_spawner::zombie_history( "inert transition done" );
+	if ( isDefined( self.ai_state ) && self.ai_state == "zombie_goto_entrance" )
+	{
+		self thread maps/mp/zombies/_zm_spawner::zombie_goto_entrance( self.first_node );
+	}
+	if ( isDefined( self.inert_wakeup_override ) )
+	{
+		self [[ self.inert_wakeup_override ]]();
+	}
+	else
+	{
+		if ( isDefined( self.completed_emerging_into_playable_area ) && self.completed_emerging_into_playable_area )
+		{
+			self.ignoreall = 0;
+			if ( isDefined( level.ignore_find_flesh ) && !( self [[ level.ignore_find_flesh ]]() ) )
+			{
+				self thread maps/mp/zombies/_zm_ai_basic::find_flesh();
+			}
+		}
+	}
+	self.becoming_inert = undefined;
+	self.is_inert = undefined;
+	self.in_place = undefined;
+	self maps/mp/animscripts/zm_run::needsupdate();
+	self maps/mp/zombies/_zm_spawner::zombie_history( "is_inert cleared " + getTime() );
+}
+
+inert_watch_goal()
+{
+	self endon( "death" );
+	self endon( "stop_zombie_inert" );
+	while ( 1 )
+	{
+		self waittill( "goal" );
+		locs = array_randomize( level.enemy_dog_locations );
+		_a481 = locs;
+		_k481 = getFirstArrayKey( _a481 );
+		while ( isDefined( _k481 ) )
+		{
+			loc = _a481[ _k481 ];
+			dist_sq = distancesquared( self.origin, loc.origin );
+			if ( dist_sq > 90000 )
+			{
+				self setgoalpos( loc.origin );
+				break;
+			}
+			_k481 = getNextArrayKey( _a481, _k481 );
+		}
+		if ( locs.size > 0 )
+		{
+			self setgoalpos( locs[ 0 ].origin );
+		}
+	}
+}
+
+inert_wakeup()
+{
+	self endon( "death" );
+	self endon( "stop_zombie_inert" );
+	wait 0.1;
+	self thread inert_damage();
+	self thread inert_bump();
+	while ( 1 )
+	{
+		current_time = getTime();
+		players = get_players();
+		_a522 = players;
+		_k522 = getFirstArrayKey( _a522 );
+		while ( isDefined( _k522 ) )
+		{
+			player = _a522[ _k522 ];
+			dist_sq = distancesquared( self.origin, player.origin );
+			if ( dist_sq < 4096 )
+			{
+				self stop_inert();
+				return;
+			}
+			if ( dist_sq < 360000 )
+			{
+				if ( player issprinting() )
+				{
+					self stop_inert();
+					return;
+				}
+			}
+			if ( dist_sq < 5760000 )
+			{
+				if ( ( current_time - player.lastfiretime ) < 100 )
+				{
+					self stop_inert();
+					return;
+				}
+			}
+			_k522 = getNextArrayKey( _a522, _k522 );
+		}
+		wait 0.1;
+	}
+}
+
+inert_bump()
+{
+	self endon( "death" );
+	self endon( "stop_zombie_inert" );
+	while ( 1 )
+	{
+		zombies = getaiarray( level.zombie_team );
+		_a562 = zombies;
+		_k562 = getFirstArrayKey( _a562 );
+		while ( isDefined( _k562 ) )
+		{
+			zombie = _a562[ _k562 ];
+			if ( zombie == self )
+			{
+			}
+			else if ( isDefined( zombie.is_inert ) && zombie.is_inert )
+			{
+			}
+			else
+			{
+				if ( isDefined( zombie.becoming_inert ) && zombie.becoming_inert )
+				{
+					break;
+				}
+				else
+				{
+					dist_sq = distancesquared( self.origin, zombie.origin );
+					if ( dist_sq < 1296 )
+					{
+						self stop_inert();
+						return;
+					}
+				}
+			}
+			_k562 = getNextArrayKey( _a562, _k562 );
+		}
+		wait 0.2;
+	}
+}
+
+inert_damage()
+{
+	self endon( "death" );
+	self endon( "stop_zombie_inert" );
+	while ( 1 )
+	{
+		self waittill( "damage", amount, inflictor, direction, point, type, tagname, modelname, partname, weaponname, idflags );
+		while ( weaponname == "emp_grenade_zm" )
+		{
+			continue;
+		}
+		while ( isDefined( inflictor ) )
+		{
+			if ( isDefined( inflictor._trap_type ) && inflictor._trap_type == "fire" )
+			{
+				continue;
+			}
+		}
+	}
+	self stop_inert();
+}
+
+grenade_watcher( grenade )
+{
+	grenade waittill( "explode", grenade_origin );
+	zombies = get_array_of_closest( grenade_origin, get_round_enemy_array(), undefined, undefined, 2400 );
+	if ( !isDefined( zombies ) )
+	{
+		return;
+	}
+	_a633 = zombies;
+	_k633 = getFirstArrayKey( _a633 );
+	while ( isDefined( _k633 ) )
+	{
+		zombie = _a633[ _k633 ];
+		zombie stop_inert();
+		_k633 = getNextArrayKey( _a633, _k633 );
+	}
+}
+
+stop_inert()
+{
+	self notify( "stop_zombie_inert" );
+}
+
+inert_transition()
+{
+	self endon( "death" );
+	self endon( "stop_zombie_inert_transition" );
+	trans_num = 4;
+	trans_set = level.inert_trans_walk;
+	animstate = "zm_inert_trans";
+	if ( !self.has_legs )
+	{
+		trans_num = 1;
+		trans_set = level.inert_crawl_trans_walk;
+		animstate = "zm_inert_crawl_trans";
+	}
+	if ( self.zombie_move_speed == "run" )
+	{
+		if ( self.has_legs )
+		{
+			trans_set = level.inert_trans_run;
+		}
+		else
+		{
+			trans_set = level.inert_crawl_trans_run;
+		}
+		trans_num = 2;
+	}
+	else
+	{
+		if ( self.zombie_move_speed == "sprint" )
+		{
+			if ( self.has_legs )
+			{
+				trans_set = level.inert_trans_sprint;
+			}
+			else
+			{
+				trans_set = level.inert_crawl_trans_sprint;
+			}
+			trans_num = 2;
+		}
+	}
+	self thread inert_eye_glow();
+	self setanimstatefromasd( animstate, trans_set[ randomint( trans_num ) ] );
+	self maps/mp/zombies/_zm_spawner::zombie_history( "inert_trans_anim " + getTime() );
+	maps/mp/animscripts/zm_shared::donotetracks( "inert_trans_anim" );
+}
+
+inert_eye_glow()
+{
+	self endon( "death" );
+	while ( 1 )
+	{
+		self waittill( "inert_trans_anim", note );
+		if ( note == "end" )
+		{
+			return;
+			continue;
+		}
+		else
+		{
+			if ( note == "zmb_awaken" )
+			{
+				self maps/mp/zombies/_zm_spawner::zombie_eye_glow();
+				return;
+			}
+		}
+	}
+}
+

patch_zm/maps/mp/zombies/NoKnownErrors/_zm_ai_dogs.gsc

@@ -0,0 +1,742 @@
+#include maps/mp/zombies/_zm_net;
+#include maps/mp/zombies/_zm_stats;
+#include maps/mp/zombies/_zm_score;
+#include maps/mp/zombies/_zm;
+#include maps/mp/zombies/_zm_powerups;
+#include maps/mp/zombies/_zm_audio;
+#include maps/mp/zombies/_zm_spawner;
+#include maps/mp/zombies/_zm_utility;
+#include maps/mp/_utility;
+#include common_scripts/utility;
+
+init()
+{
+	level.dogs_enabled = 1;
+	level.dog_rounds_enabled = 0;
+	level.dog_round_count = 1;
+	level.dog_spawners = [];
+	level.enemy_dog_spawns = [];
+	level.enemy_dog_locations = [];
+	flag_init( "dog_clips" );
+	precacherumble( "explosion_generic" );
+	precacheshellshock( "dog_bite" );
+	if ( getDvar( "zombie_dog_animset" ) == "" )
+	{
+		setdvar( "zombie_dog_animset", "zombie" );
+	}
+	if ( getDvar( "scr_dog_health_walk_multiplier" ) == "" )
+	{
+		setdvar( "scr_dog_health_walk_multiplier", "4.0" );
+	}
+	if ( getDvar( "scr_dog_run_distance" ) == "" )
+	{
+		setdvar( "scr_dog_run_distance", "500" );
+	}
+	level.melee_range_sav = getDvar( "ai_meleeRange" );
+	level.melee_width_sav = getDvar( "ai_meleeWidth" );
+	level.melee_height_sav = getDvar( "ai_meleeHeight" );
+	setdvar( "dog_MeleeDamage", "100" );
+	set_zombie_var( "dog_fire_trail_percent", 50 );
+	level._effect[ "lightning_dog_spawn" ] = loadfx( "maps/zombie/fx_zombie_dog_lightning_buildup" );
+	level._effect[ "dog_eye_glow" ] = loadfx( "maps/zombie/fx_zombie_dog_eyes" );
+	level._effect[ "dog_gib" ] = loadfx( "maps/zombie/fx_zombie_dog_explosion" );
+	level._effect[ "dog_trail_fire" ] = loadfx( "maps/zombie/fx_zombie_dog_fire_trail" );
+	level._effect[ "dog_trail_ash" ] = loadfx( "maps/zombie/fx_zombie_dog_ash_trail" );
+	dog_spawner_init();
+	level thread dog_clip_monitor();
+}
+
+enable_dog_rounds()
+{
+	level.dog_rounds_enabled = 1;
+	if ( !isDefined( level.dog_round_track_override ) )
+	{
+		level.dog_round_track_override = ::dog_round_tracker;
+	}
+	level thread [[ level.dog_round_track_override ]]();
+}
+
+dog_spawner_init()
+{
+	level.dog_spawners = getentarray( "zombie_dog_spawner", "script_noteworthy" );
+	later_dogs = getentarray( "later_round_dog_spawners", "script_noteworthy" );
+	level.dog_spawners = arraycombine( level.dog_spawners, later_dogs, 1, 0 );
+	if ( level.dog_spawners.size == 0 )
+	{
+		return;
+	}
+	i = 0;
+	while ( i < level.dog_spawners.size )
+	{
+		if ( maps/mp/zombies/_zm_spawner::is_spawner_targeted_by_blocker( level.dog_spawners[ i ] ) )
+		{
+			level.dog_spawners[ i ].is_enabled = 0;
+			i++;
+			continue;
+		}
+		else
+		{
+			level.dog_spawners[ i ].is_enabled = 1;
+			level.dog_spawners[ i ].script_forcespawn = 1;
+		}
+		i++;
+	}
+	level.dog_health = 100;
+	array_thread( level.dog_spawners, ::add_spawn_function, ::dog_init );
+	level.enemy_dog_spawns = getentarray( "zombie_spawner_dog_init", "targetname" );
+}
+
+dog_round_spawning()
+{
+	level endon( "intermission" );
+	level.dog_targets = getplayers();
+	i = 0;
+	while ( i < level.dog_targets.size )
+	{
+		level.dog_targets[ i ].hunted_by = 0;
+		i++;
+	}
+	if ( level.intermission )
+	{
+		return;
+	}
+	level.dog_intermission = 1;
+	level thread dog_round_aftermath();
+	players = get_players();
+	array_thread( players, ::play_dog_round );
+	wait 1;
+	playsoundatposition( "vox_zmba_event_dogstart_0", ( 0, 0, 0 ) );
+	wait 6;
+	if ( level.dog_round_count < 3 )
+	{
+		max = players.size * 6;
+	}
+	else
+	{
+		max = players.size * 8;
+	}
+	level.zombie_total = max;
+	dog_health_increase();
+	count = 0;
+	while ( count < max )
+	{
+		num_player_valid = get_number_of_valid_players();
+		while ( get_current_zombie_count() >= ( num_player_valid * 2 ) )
+		{
+			wait 2;
+			num_player_valid = get_number_of_valid_players();
+		}
+		players = get_players();
+		favorite_enemy = get_favorite_enemy();
+		if ( isDefined( level.dog_spawn_func ) )
+		{
+			spawn_loc = [[ level.dog_spawn_func ]]( level.dog_spawners, favorite_enemy );
+			ai = spawn_zombie( level.dog_spawners[ 0 ] );
+			if ( isDefined( ai ) )
+			{
+				ai.favoriteenemy = favorite_enemy;
+				spawn_loc thread dog_spawn_fx( ai, spawn_loc );
+				level.zombie_total--;
+
+				count++;
+			}
+		}
+		else
+		{
+			spawn_point = dog_spawn_factory_logic( level.enemy_dog_spawns, favorite_enemy );
+			ai = spawn_zombie( level.dog_spawners[ 0 ] );
+			if ( isDefined( ai ) )
+			{
+				ai.favoriteenemy = favorite_enemy;
+				spawn_point thread dog_spawn_fx( ai, spawn_point );
+				level.zombie_total--;
+
+				count++;
+				flag_set( "dog_clips" );
+			}
+		}
+		waiting_for_next_dog_spawn( count, max );
+	}
+}
+
+waiting_for_next_dog_spawn( count, max )
+{
+	default_wait = 1.5;
+	if ( level.dog_round_count == 1 )
+	{
+		default_wait = 3;
+	}
+	else if ( level.dog_round_count == 2 )
+	{
+		default_wait = 2.5;
+	}
+	else if ( level.dog_round_count == 3 )
+	{
+		default_wait = 2;
+	}
+	else
+	{
+		default_wait = 1.5;
+	}
+	default_wait -= count / max;
+	wait default_wait;
+}
+
+dog_round_aftermath()
+{
+	level waittill( "last_dog_down" );
+	level thread maps/mp/zombies/_zm_audio::change_zombie_music( "dog_end" );
+	power_up_origin = level.last_dog_origin;
+	if ( isDefined( power_up_origin ) )
+	{
+		level thread maps/mp/zombies/_zm_powerups::specific_powerup_drop( "full_ammo", power_up_origin );
+	}
+	wait 2;
+	clientnotify( "dog_stop" );
+	wait 6;
+	level.dog_intermission = 0;
+}
+
+dog_spawn_fx( ai, ent )
+{
+	ai endon( "death" );
+	ai setfreecameralockonallowed( 0 );
+	playfx( level._effect[ "lightning_dog_spawn" ], ent.origin );
+	playsoundatposition( "zmb_hellhound_prespawn", ent.origin );
+	wait 1.5;
+	playsoundatposition( "zmb_hellhound_bolt", ent.origin );
+	earthquake( 0.5, 0.75, ent.origin, 1000 );
+	playrumbleonposition( "explosion_generic", ent.origin );
+	playsoundatposition( "zmb_hellhound_spawn", ent.origin );
+	angle = vectorToAngles( ai.favoriteenemy.origin - ent.origin );
+	angles = ( ai.angles[ 0 ], angle[ 1 ], ai.angles[ 2 ] );
+	ai forceteleport( ent.origin, angles );
+	ai zombie_setup_attack_properties_dog();
+	ai stop_magic_bullet_shield();
+	wait 0.1;
+	ai show();
+	ai setfreecameralockonallowed( 1 );
+	ai.ignoreme = 0;
+	ai notify( "visible" );
+}
+
+dog_spawn_sumpf_logic( dog_array, favorite_enemy )
+{
+	dog_array = array_randomize( dog_array );
+	i = 0;
+	while ( i < dog_array.size )
+	{
+		if ( isDefined( level.old_dog_spawn ) && level.old_dog_spawn == dog_array[ i ] )
+		{
+			i++;
+			continue;
+		}
+		else
+		{
+			if ( distancesquared( dog_array[ i ].origin, favorite_enemy.origin ) > 160000 && distancesquared( dog_array[ i ].origin, favorite_enemy.origin ) < 640000 )
+			{
+				if ( distancesquared( ( 0, 0, dog_array[ i ].origin[ 2 ] ), ( 0, 0, favorite_enemy.origin[ 2 ] ) ) > 10000 )
+				{
+					i++;
+					continue;
+				}
+				else level.old_dog_spawn = dog_array[ i ];
+				return dog_array[ i ];
+			}
+		}
+		i++;
+	}
+	return dog_array[ 0 ];
+}
+
+dog_spawn_factory_logic( dog_array, favorite_enemy )
+{
+	dog_locs = array_randomize( level.enemy_dog_locations );
+	i = 0;
+	while ( i < dog_locs.size )
+	{
+		if ( isDefined( level.old_dog_spawn ) && level.old_dog_spawn == dog_locs[ i ] )
+		{
+			i++;
+			continue;
+		}
+		else
+		{
+			dist_squared = distancesquared( dog_locs[ i ].origin, favorite_enemy.origin );
+			if ( dist_squared > 160000 && dist_squared < 1000000 )
+			{
+				level.old_dog_spawn = dog_locs[ i ];
+				return dog_locs[ i ];
+			}
+		}
+		i++;
+	}
+	return dog_locs[ 0 ];
+}
+
+get_favorite_enemy()
+{
+	dog_targets = getplayers();
+	least_hunted = dog_targets[ 0 ];
+	i = 0;
+	while ( i < dog_targets.size )
+	{
+		if ( !isDefined( dog_targets[ i ].hunted_by ) )
+		{
+			dog_targets[ i ].hunted_by = 0;
+		}
+		if ( !is_player_valid( dog_targets[ i ] ) )
+		{
+			i++;
+			continue;
+		}
+		else
+		{
+			if ( !is_player_valid( least_hunted ) )
+			{
+				least_hunted = dog_targets[ i ];
+			}
+			if ( dog_targets[ i ].hunted_by < least_hunted.hunted_by )
+			{
+				least_hunted = dog_targets[ i ];
+			}
+		}
+		i++;
+	}
+	least_hunted.hunted_by += 1;
+	return least_hunted;
+}
+
+dog_health_increase()
+{
+	players = getplayers();
+	if ( level.dog_round_count == 1 )
+	{
+		level.dog_health = 400;
+	}
+	else if ( level.dog_round_count == 2 )
+	{
+		level.dog_health = 900;
+	}
+	else if ( level.dog_round_count == 3 )
+	{
+		level.dog_health = 1300;
+	}
+	else
+	{
+		if ( level.dog_round_count == 4 )
+		{
+			level.dog_health = 1600;
+		}
+	}
+	if ( level.dog_health > 1600 )
+	{
+		level.dog_health = 1600;
+	}
+}
+
+dog_round_tracker()
+{
+	level.dog_round_count = 1;
+	level.next_dog_round = level.round_number + randomintrange( 4, 7 );
+	old_spawn_func = level.round_spawn_func;
+	old_wait_func = level.round_wait_func;
+	while ( 1 )
+	{
+		level waittill( "between_round_over" );
+		if ( level.round_number == level.next_dog_round )
+		{
+			level.music_round_override = 1;
+			old_spawn_func = level.round_spawn_func;
+			old_wait_func = level.round_wait_func;
+			dog_round_start();
+			level.round_spawn_func = ::dog_round_spawning;
+			level.next_dog_round = level.round_number + randomintrange( 4, 6 );
+			continue;
+		}
+		else
+		{
+			if ( flag( "dog_round" ) )
+			{
+				dog_round_stop();
+				level.round_spawn_func = old_spawn_func;
+				level.round_wait_func = old_wait_func;
+				level.music_round_override = 0;
+				level.dog_round_count += 1;
+			}
+		}
+	}
+}
+
+dog_round_start()
+{
+	flag_set( "dog_round" );
+	flag_set( "dog_clips" );
+	level thread maps/mp/zombies/_zm_audio::change_zombie_music( "dog_start" );
+	if ( !isDefined( level.doground_nomusic ) )
+	{
+		level.doground_nomusic = 0;
+	}
+	level.doground_nomusic = 1;
+	level notify( "dog_round_starting" );
+	clientnotify( "dog_start" );
+	if ( isDefined( level.dog_melee_range ) )
+	{
+		setdvar( "ai_meleeRange", level.dog_melee_range );
+	}
+	else
+	{
+		setdvar( "ai_meleeRange", 100 );
+	}
+}
+
+dog_round_stop()
+{
+	flag_clear( "dog_round" );
+	flag_clear( "dog_clips" );
+	if ( !isDefined( level.doground_nomusic ) )
+	{
+		level.doground_nomusic = 0;
+	}
+	level.doground_nomusic = 0;
+	level notify( "dog_round_ending" );
+	clientnotify( "dog_stop" );
+	setdvar( "ai_meleeRange", level.melee_range_sav );
+	setdvar( "ai_meleeWidth", level.melee_width_sav );
+	setdvar( "ai_meleeHeight", level.melee_height_sav );
+}
+
+play_dog_round()
+{
+	self playlocalsound( "zmb_dog_round_start" );
+	variation_count = 5;
+	wait 4.5;
+	players = getplayers();
+	num = randomintrange( 0, players.size );
+	players[ num ] maps/mp/zombies/_zm_audio::create_and_play_dialog( "general", "dog_spawn" );
+}
+
+dog_init()
+{
+	self.targetname = "zombie_dog";
+	self.script_noteworthy = undefined;
+	self.animname = "zombie_dog";
+	self.ignoreall = 1;
+	self.ignoreme = 1;
+	self.allowdeath = 1;
+	self.allowpain = 0;
+	self.force_gib = 1;
+	self.is_zombie = 1;
+	self.has_legs = 1;
+	self.gibbed = 0;
+	self.head_gibbed = 0;
+	self.default_goalheight = 40;
+	self.ignore_inert = 1;
+	self.grenadeawareness = 0;
+	self.badplaceawareness = 0;
+	self.ignoresuppression = 1;
+	self.suppressionthreshold = 1;
+	self.nododgemove = 1;
+	self.dontshootwhilemoving = 1;
+	self.pathenemylookahead = 0;
+	self.badplaceawareness = 0;
+	self.chatinitialized = 0;
+	self.team = level.zombie_team;
+	health_multiplier = 1;
+	if ( getDvar( "scr_dog_health_walk_multiplier" ) != "" )
+	{
+		health_multiplier = getDvarFloat( "scr_dog_health_walk_multiplier" );
+	}
+	self.maxhealth = int( level.dog_health * health_multiplier );
+	self.health = int( level.dog_health * health_multiplier );
+	self.freezegun_damage = 0;
+	self.zombie_move_speed = "sprint";
+	self thread dog_run_think();
+	self thread dog_stalk_audio();
+	self thread maps/mp/zombies/_zm::round_spawn_failsafe();
+	self ghost();
+	self thread magic_bullet_shield();
+	self dog_fx_eye_glow();
+	self dog_fx_trail();
+	self thread dog_death();
+	level thread maps/mp/zombies/_zm_spawner::zombie_death_event( self );
+	self thread maps/mp/zombies/_zm_spawner::enemy_death_detection();
+	self.a.disablepain = 1;
+	self disable_react();
+	self clearenemy();
+	self cleargoalvolume();
+	self.flame_damage_time = 0;
+	self.meleedamage = 40;
+	self.thundergun_knockdown_func = ::dog_thundergun_knockdown;
+	self maps/mp/zombies/_zm_spawner::zombie_history( "zombie_dog_spawn_init -> Spawned = " + self.origin );
+	if ( isDefined( level.achievement_monitor_func ) )
+	{
+		self [[ level.achievement_monitor_func ]]();
+	}
+}
+
+dog_fx_eye_glow()
+{
+	self.fx_dog_eye = spawn( "script_model", self gettagorigin( "J_EyeBall_LE" ) );
+	self.fx_dog_eye.angles = self gettagangles( "J_EyeBall_LE" );
+	self.fx_dog_eye setmodel( "tag_origin" );
+	self.fx_dog_eye linkto( self, "J_EyeBall_LE" );
+}
+
+dog_fx_trail()
+{
+	if ( !is_mature() || randomint( 100 ) > level.zombie_vars[ "dog_fire_trail_percent" ] )
+	{
+		self.fx_dog_trail_type = level._effect[ "dog_trail_ash" ];
+		self.fx_dog_trail_sound = "zmb_hellhound_loop_breath";
+	}
+	else
+	{
+		self.a.nodeath = 1;
+		self.fx_dog_trail_type = level._effect[ "dog_trail_fire" ];
+		self.fx_dog_trail_sound = "zmb_hellhound_loop_fire";
+	}
+	self.fx_dog_trail = spawn( "script_model", self gettagorigin( "tag_origin" ) );
+	self.fx_dog_trail.angles = self gettagangles( "tag_origin" );
+	self.fx_dog_trail setmodel( "tag_origin" );
+	self.fx_dog_trail linkto( self, "tag_origin" );
+}
+
+dog_death()
+{
+	self waittill( "death" );
+	if ( get_current_zombie_count() == 0 && level.zombie_total == 0 )
+	{
+		level.last_dog_origin = self.origin;
+		level notify( "last_dog_down" );
+	}
+	if ( isplayer( self.attacker ) )
+	{
+		event = "death";
+		if ( issubstr( self.damageweapon, "knife_ballistic_" ) )
+		{
+			event = "ballistic_knife_death";
+		}
+		self.attacker maps/mp/zombies/_zm_score::player_add_points( event, self.damagemod, self.damagelocation, 1 );
+		if ( randomintrange( 0, 100 ) >= 80 )
+		{
+			self.attacker maps/mp/zombies/_zm_audio::create_and_play_dialog( "kill", "hellhound" );
+		}
+		self.attacker maps/mp/zombies/_zm_stats::increment_client_stat( "zdogs_killed" );
+		self.attacker maps/mp/zombies/_zm_stats::increment_player_stat( "zdogs_killed" );
+	}
+	if ( isDefined( self.attacker ) && isai( self.attacker ) )
+	{
+		self.attacker notify( "killed" );
+	}
+	self stoploopsound();
+	self.fx_dog_trail delete();
+	if ( isDefined( self.a.nodeath ) )
+	{
+		level thread dog_explode_fx( self.origin );
+		self delete();
+	}
+	else
+	{
+		self playsound( "zmb_hellhound_vocals_death" );
+	}
+}
+
+dog_explode_fx( origin )
+{
+	playfx( level._effect[ "dog_gib" ], origin );
+	playsoundatposition( "zmb_hellhound_explode", origin );
+}
+
+zombie_setup_attack_properties_dog()
+{
+	self maps/mp/zombies/_zm_spawner::zombie_history( "zombie_setup_attack_properties()" );
+	self thread dog_behind_audio();
+	self.ignoreall = 0;
+	self.pathenemyfightdist = 64;
+	self.meleeattackdist = 64;
+	self.disablearrivals = 1;
+	self.disableexits = 1;
+}
+
+stop_dog_sound_on_death()
+{
+	self waittill( "death" );
+	self stopsounds();
+}
+
+dog_behind_audio()
+{
+	self thread stop_dog_sound_on_death();
+	self endon( "death" );
+	self waittill_any( "dog_running", "dog_combat" );
+	self playsound( "zmb_hellhound_vocals_close" );
+	wait 3;
+	while ( 1 )
+	{
+		players = get_players();
+		i = 0;
+		while ( i < players.size )
+		{
+			vectorAngle = vectorToAngles( self.origin - players[ i ].origin );
+			dogangle = AbsAngleClamp180( vectorAngle[ 1 ] - players[ i ].angles[ 1 ] );
+			if ( isalive( players[ i ] ) && !isDefined( players[ i ].revivetrigger ) )
+			{
+				if ( Abs( dogangle ) > 90 && distance2d( self.origin, players[ i ].origin ) > 100 )
+				{
+					self playsound( "zmb_hellhound_vocals_close" );
+					wait 3;
+				}
+			}
+			i++;
+		}
+		wait 0.75;
+	}
+}
+
+dog_clip_monitor()
+{
+	clips_on = 0;
+	level.dog_clips = getentarray( "dog_clips", "targetname" );
+	while ( 1 )
+	{
+		i = 0;
+		while ( i < level.dog_clips.size )
+		{
+			level.dog_clips[ i ] trigger_off();
+			level.dog_clips[ i ] connectpaths();
+			i++;
+		}
+		flag_wait( "dog_clips" );
+		if ( isDefined( level.no_dog_clip ) && level.no_dog_clip == 1 )
+		{
+			return;
+		}
+		i = 0;
+		while ( i < level.dog_clips.size )
+		{
+			level.dog_clips[ i ] trigger_on();
+			level.dog_clips[ i ] disconnectpaths();
+			wait_network_frame();
+			i++;
+		}
+		dog_is_alive = 1;
+		while ( dog_is_alive || flag( "dog_round" ) )
+		{
+			dog_is_alive = 0;
+			dogs = getentarray( "zombie_dog", "targetname" );
+			i = 0;
+			while ( i < dogs.size )
+			{
+				if ( isalive( dogs[ i ] ) )
+				{
+					dog_is_alive = 1;
+				}
+				i++;
+			}
+			wait 1;
+		}
+		flag_clear( "dog_clips" );
+		wait 1;
+	}
+}
+
+special_dog_spawn( spawners, num_to_spawn )
+{
+	dogs = getaispeciesarray( "all", "zombie_dog" );
+	if ( isDefined( dogs ) && dogs.size >= 9 )
+	{
+		return 0;
+	}
+	if ( !isDefined( num_to_spawn ) )
+	{
+		num_to_spawn = 1;
+	}
+	spawn_point = undefined;
+	count = 0;
+	while ( count < num_to_spawn )
+	{
+		players = get_players();
+		favorite_enemy = get_favorite_enemy();
+		if ( isDefined( spawners ) )
+		{
+			spawn_point = spawners[ randomint( spawners.size ) ];
+			ai = spawn_zombie( spawn_point );
+			if ( isDefined( ai ) )
+			{
+				ai.favoriteenemy = favorite_enemy;
+				spawn_point thread dog_spawn_fx( ai );
+				count++;
+				flag_set( "dog_clips" );
+			}
+		}
+		else if ( isDefined( level.dog_spawn_func ) )
+		{
+			spawn_loc = [[ level.dog_spawn_func ]]( level.dog_spawners, favorite_enemy );
+			ai = spawn_zombie( level.dog_spawners[ 0 ] );
+			if ( isDefined( ai ) )
+			{
+				ai.favoriteenemy = favorite_enemy;
+				spawn_loc thread dog_spawn_fx( ai, spawn_loc );
+				count++;
+				flag_set( "dog_clips" );
+			}
+		}
+		else
+		{
+			spawn_point = dog_spawn_factory_logic( level.enemy_dog_spawns, favorite_enemy );
+			ai = spawn_zombie( level.dog_spawners[ 0 ] );
+			if ( isDefined( ai ) )
+			{
+				ai.favoriteenemy = favorite_enemy;
+				spawn_point thread dog_spawn_fx( ai, spawn_point );
+				count++;
+				flag_set( "dog_clips" );
+			}
+		}
+		waiting_for_next_dog_spawn( count, num_to_spawn );
+	}
+	return 1;
+}
+
+dog_run_think()
+{
+	self endon( "death" );
+	self waittill( "visible" );
+	if ( self.health > level.dog_health )
+	{
+		self.maxhealth = level.dog_health;
+		self.health = level.dog_health;
+	}
+	maps/mp/zombies/_zm_net::network_safe_play_fx_on_tag( "dog_fx", 2, self.fx_dog_trail_type, self.fx_dog_trail, "tag_origin" );
+	self playloopsound( self.fx_dog_trail_sound );
+	while ( 1 )
+	{
+		if ( !is_player_valid( self.favoriteenemy ) )
+		{
+			self.favoriteenemy = get_favorite_enemy();
+		}
+		wait 0.2;
+	}
+}
+
+dog_stalk_audio()
+{
+	self endon( "death" );
+	self endon( "dog_running" );
+	self endon( "dog_combat" );
+	while ( 1 )
+	{
+		self playsound( "zmb_hellhound_vocals_amb" );
+		wait randomfloatrange( 3, 6 );
+	}
+}
+
+dog_thundergun_knockdown( player, gib )
+{
+	self endon( "death" );
+	damage = int( self.maxhealth * 0.5 );
+	self dodamage( damage, player.origin, player );
+}
+
+

patch_zm/maps/mp/zombies/NoKnownErrors/_zm_ai_faller.gsc

@@ -0,0 +1,642 @@
+#include maps/mp/zombies/_zm_laststand;
+#include maps/mp/animscripts/zm_shared;
+#include maps/mp/zombies/_zm_spawner;
+#include maps/mp/zombies/_zm_utility;
+#include maps/mp/_utility;
+#include common_scripts/utility;
+
+zombie_faller_delete()
+{
+	level.zombie_total++;
+	self maps/mp/zombies/_zm_spawner::reset_attack_spot();
+	if ( isDefined( self.zombie_faller_location ) )
+	{
+		self.zombie_faller_location.is_enabled = 1;
+		self.zombie_faller_location = undefined;
+	}
+	self delete();
+}
+
+faller_script_parameters()
+{
+	while ( isDefined( self.script_parameters ) )
+	{
+		parms = strtok( self.script_parameters, ";" );
+		while ( isDefined( parms ) && parms.size > 0 )
+		{
+			i = 0;
+			while ( i < parms.size )
+			{
+				if ( parms[ i ] == "drop_now" )
+				{
+					self.drop_now = 1;
+				}
+				if ( parms[ i ] == "drop_not_occupied" )
+				{
+					self.drop_not_occupied = 1;
+				}
+				if ( parms[ i ] == "emerge_top" )
+				{
+					self.emerge_top = 1;
+				}
+				if ( parms[ i ] == "emerge_bottom" )
+				{
+					self.emerge_bottom = 1;
+				}
+				i++;
+			}
+		}
+	}
+}
+
+setup_deathfunc( func_name )
+{
+	self endon( "death" );
+	while ( isDefined( self.zombie_init_done ) && !self.zombie_init_done )
+	{
+		wait_network_frame();
+	}
+	if ( isDefined( func_name ) )
+	{
+		self.deathfunction = func_name;
+	}
+	else if ( isDefined( level.custom_faller_death ) )
+	{
+		self.deathfunction = level.custom_faller_death;
+	}
+	else
+	{
+		self.deathfunction = ::zombie_fall_death_func;
+	}
+}
+
+do_zombie_fall( spot )
+{
+	self endon( "death" );
+	self.zombie_faller_location = spot;
+	self.zombie_faller_location.is_enabled = 0;
+	self.zombie_faller_location faller_script_parameters();
+	if ( isDefined( self.zombie_faller_location.emerge_bottom ) || self.zombie_faller_location.emerge_bottom && isDefined( self.zombie_faller_location.emerge_top ) && self.zombie_faller_location.emerge_top )
+	{
+		self do_zombie_emerge( spot );
+		return;
+	}
+	self thread setup_deathfunc();
+	self.no_powerups = 1;
+	self.in_the_ceiling = 1;
+	self.anchor = spawn( "script_origin", self.origin );
+	self.anchor.angles = self.angles;
+	self linkto( self.anchor );
+	if ( !isDefined( spot.angles ) )
+	{
+		spot.angles = ( 0, 0, -1 );
+	}
+	anim_org = spot.origin;
+	anim_ang = spot.angles;
+	self ghost();
+	self.anchor moveto( anim_org, 0,05 );
+	self.anchor waittill( "movedone" );
+	target_org = get_desired_origin();
+	if ( isDefined( target_org ) )
+	{
+		anim_ang = vectorToAngles( target_org - self.origin );
+		self.anchor rotateto( ( 0, anim_ang[ 1 ], 0 ), 0,05 );
+		self.anchor waittill( "rotatedone" );
+	}
+	self unlink();
+	if ( isDefined( self.anchor ) )
+	{
+		self.anchor delete();
+	}
+	self thread maps/mp/zombies/_zm_spawner::hide_pop();
+	self thread zombie_fall_death( spot );
+	self thread zombie_fall_fx( spot );
+	self thread zombie_faller_death_wait();
+	self thread zombie_faller_do_fall();
+	self.no_powerups = 0;
+	self notify( "risen" );
+}
+
+zombie_faller_do_fall()
+{
+	self endon( "death" );
+	self animscripted( self.origin, self.zombie_faller_location.angles, "zm_faller_emerge" );
+	self maps/mp/animscripts/zm_shared::donotetracks( "emerge_anim", ::handle_fall_notetracks, self.zombie_faller_location );
+	self.zombie_faller_wait_start = getTime();
+	self.zombie_faller_should_drop = 0;
+	self thread zombie_fall_wait();
+	self thread zombie_faller_watch_all_players();
+	while ( !self.zombie_faller_should_drop )
+	{
+		if ( self zombie_fall_should_attack( self.zombie_faller_location ) )
+		{
+			self animscripted( self.origin, self.zombie_faller_location.angles, "zm_faller_attack" );
+			self maps/mp/animscripts/zm_shared::donotetracks( "attack_anim", ::handle_fall_notetracks, self.zombie_faller_location );
+			if ( !self zombie_faller_always_drop() && randomfloat( 1 ) > 0.5 )
+			{
+				self.zombie_faller_should_drop = 1;
+			}
+			continue;
+		}
+		else if ( self zombie_faller_always_drop() )
+		{
+			self.zombie_faller_should_drop = 1;
+			break;
+		}
+		else if ( getTime() >= ( self.zombie_faller_wait_start + 20000 ) )
+		{
+			self.zombie_faller_should_drop = 1;
+			break;
+		}
+		else if ( self zombie_faller_drop_not_occupied() )
+		{
+			self.zombie_faller_should_drop = 1;
+			break;
+		}
+		else self animscripted( self.origin, self.zombie_faller_location.angles, "zm_faller_attack" );
+		self maps/mp/animscripts/zm_shared::donotetracks( "attack_anim", ::handle_fall_notetracks, self.zombie_faller_location );
+	}
+	self notify( "falling" );
+	spot = self.zombie_faller_location;
+	self zombie_faller_enable_location();
+	self animscripted( self.origin, spot.angles, "zm_faller_fall" );
+	self maps/mp/animscripts/zm_shared::donotetracks( "fall_anim", ::handle_fall_notetracks, spot );
+	self.deathfunction = ::zombie_death_animscript;
+	self notify( "fall_anim_finished" );
+	spot notify( "stop_zombie_fall_fx" );
+	self stopanimscripted();
+	landanimdelta = 15;
+	ground_pos = groundpos_ignore_water_new( self.origin );
+	physdist = ( self.origin[ 2 ] - ground_pos[ 2 ] ) + landanimdelta;
+	if ( physdist > 0 )
+	{
+		self animcustom( ::zombie_fall_loop );
+		self waittill( "faller_on_ground" );
+		self animcustom( ::zombie_land );
+		self waittill( "zombie_land_done" );
+	}
+	self.in_the_ceiling = 0;
+	self traversemode( "gravity" );
+	self.no_powerups = 0;
+}
+
+zombie_fall_loop()
+{
+	self endon( "death" );
+	self setanimstatefromasd( "zm_faller_fall_loop" );
+	while ( 1 )
+	{
+		ground_pos = groundpos_ignore_water_new( self.origin );
+		if ( ( self.origin[ 2 ] - ground_pos[ 2 ] ) < 20 )
+		{
+			self notify( "faller_on_ground" );
+			return;
+		}
+		else
+		{
+			wait 0.05;
+		}
+	}
+}
+
+zombie_land()
+{
+	self setanimstatefromasd( "zm_faller_land" );
+	maps/mp/animscripts/zm_shared::donotetracks( "land_anim" );
+	self notify( "zombie_land_done" );
+}
+
+zombie_faller_always_drop()
+{
+	if ( isDefined( self.zombie_faller_location.drop_now ) && self.zombie_faller_location.drop_now )
+	{
+		return 1;
+	}
+	return 0;
+}
+
+zombie_faller_drop_not_occupied()
+{
+	if ( isDefined( self.zombie_faller_location.drop_not_occupied ) && self.zombie_faller_location.drop_not_occupied )
+	{
+		if ( isDefined( self.zone_name ) && isDefined( level.zones[ self.zone_name ] ) )
+		{
+			return !level.zones[ self.zone_name ].is_occupied;
+		}
+	}
+	return 0;
+}
+
+zombie_faller_watch_all_players()
+{
+	players = get_players();
+	i = 0;
+	while ( i < players.size )
+	{
+		self thread zombie_faller_watch_player( players[ i ] );
+		i++;
+	}
+}
+
+zombie_faller_watch_player( player )
+{
+	self endon( "falling" );
+	self endon( "death" );
+	player endon( "disconnect" );
+	range = 200;
+	rangesqr = range * range;
+	timer = 5000;
+	inrange = 0;
+	inrangetime = 0;
+	closerange = 60;
+	closerangesqr = closerange * closerange;
+	dirtoplayerenter = ( 0, 0, -1 );
+	incloserange = 0;
+	while ( 1 )
+	{
+		distsqr = distance2dsquared( self.origin, player.origin );
+		if ( distsqr < rangesqr )
+		{
+			if ( inrange )
+			{
+				if ( ( inrangetime + timer ) < getTime() )
+				{
+					self.zombie_faller_should_drop = 1;
+					return;
+				}
+			}
+			else
+			{
+				inrange = 1;
+				inrangetime = getTime();
+			}
+		}
+		else
+		{
+			inrange = 0;
+		}
+		if ( distsqr < closerangesqr )
+		{
+			if ( !incloserange )
+			{
+				dirtoplayerenter = player.origin - self.origin;
+				dirtoplayerenter = ( dirtoplayerenter[ 0 ], dirtoplayerenter[ 1 ], 0 );
+				dirtoplayerenter = vectornormalize( dirtoplayerenter );
+			}
+			incloserange = 1;
+		}
+		else
+		{
+			if ( incloserange )
+			{
+				dirtoplayerexit = player.origin - self.origin;
+				dirtoplayerexit = ( dirtoplayerexit[ 0 ], dirtoplayerexit[ 1 ], 0 );
+				dirtoplayerexit = vectornormalize( dirtoplayerexit );
+				if ( vectordot( dirtoplayerenter, dirtoplayerexit ) < 0 )
+				{
+					self.zombie_faller_should_drop = 1;
+					return;
+				}
+			}
+			else
+			{
+				incloserange = 0;
+			}
+			wait 0.1;
+		}
+	}
+}
+
+zombie_fall_wait()
+{
+	self endon( "falling" );
+	self endon( "death" );
+	while ( isDefined( self.zone_name ) )
+	{
+		while ( isDefined( level.zones ) && isDefined( level.zones[ self.zone_name ] ) )
+		{
+			zone = level.zones[ self.zone_name ];
+			while ( 1 )
+			{
+				if ( !zone.is_enabled || !zone.is_active )
+				{
+					if ( !self potentially_visible( 2250000 ) )
+					{
+						if ( self.health != level.zombie_health )
+						{
+							self.zombie_faller_should_drop = 1;
+							return;
+						}
+						else self zombie_faller_delete();
+						return;
+					}
+				}
+				wait 0.5;
+			}
+		}
+	}
+}
+
+zombie_fall_should_attack( spot )
+{
+	victims = zombie_fall_get_vicitims( spot );
+	return victims.size > 0;
+}
+
+zombie_fall_get_vicitims( spot )
+{
+	ret = [];
+	players = getplayers();
+	checkdist2 = 40;
+	checkdist2 *= checkdist2;
+	i = 0;
+	while ( i < players.size )
+	{
+		player = players[ i ];
+		if ( player maps/mp/zombies/_zm_laststand::player_is_in_laststand() )
+		{
+			i++;
+			continue;
+		}
+		else stance = player getstance();
+		if ( stance == "crouch" || stance == "prone" )
+		{
+			i++;
+			continue;
+		}
+		else
+		{
+			zcheck = self.origin[ 2 ] - player.origin[ 2 ];
+			if ( zcheck < 0 || zcheck > 120 )
+			{
+				i++;
+				continue;
+			}
+			else
+			{
+				dist2 = distance2dsquared( player.origin, self.origin );
+				if ( dist2 < checkdist2 )
+				{
+					ret[ ret.size ] = player;
+				}
+			}
+		}
+		i++;
+	}
+	return ret;
+}
+
+get_fall_anim( spot )
+{
+	return level._zombie_fall_anims[ self.animname ][ "fall" ];
+}
+
+zombie_faller_enable_location()
+{
+	if ( isDefined( self.zombie_faller_location ) )
+	{
+		self.zombie_faller_location.is_enabled = 1;
+		self.zombie_faller_location = undefined;
+	}
+}
+
+zombie_faller_death_wait( endon_notify )
+{
+	self endon( "falling" );
+	if ( isDefined( endon_notify ) )
+	{
+		self endon( endon_notify );
+	}
+	self waittill( "death" );
+	self zombie_faller_enable_location();
+}
+
+zombie_fall_death_func()
+{
+	self animmode( "noclip" );
+	self.deathanim = "zm_faller_emerge_death";
+	return self maps/mp/zombies/_zm_spawner::zombie_death_animscript();
+}
+
+zombie_fall_death( spot )
+{
+	self endon( "fall_anim_finished" );
+	while ( self.health > 1 )
+	{
+		self waittill( "damage", amount, attacker, dir, p, type );
+	}
+	self stopanimscripted();
+	spot notify( "stop_zombie_fall_fx" );
+}
+
+_damage_mod_to_damage_type( type )
+{
+	toks = strtok( type, "_" );
+	if ( toks.size < 2 )
+	{
+		return type;
+	}
+	returnstr = toks[ 1 ];
+	i = 2;
+	while ( i < toks.size )
+	{
+		returnstr += toks[ i ];
+		i++;
+	}
+	returnstr = tolower( returnstr );
+	return returnstr;
+}
+
+zombie_fall_fx( spot )
+{
+	spot thread zombie_fall_dust_fx( self );
+	spot thread zombie_fall_burst_fx();
+	playsoundatposition( "zmb_zombie_spawn", spot.origin );
+	self endon( "death" );
+	spot endon( "stop_zombie_fall_fx" );
+	wait 1;
+	if ( self.zombie_move_speed != "sprint" )
+	{
+		wait 1;
+	}
+}
+
+zombie_fall_burst_fx()
+{
+	self endon( "stop_zombie_fall_fx" );
+	self endon( "fall_anim_finished" );
+	playfx( level._effect[ "rise_burst" ], self.origin + ( 0, 0, randomintrange( 5, 10 ) ) );
+	wait 0.25;
+	playfx( level._effect[ "rise_billow" ], self.origin + ( randomintrange( -10, 10 ), randomintrange( -10, 10 ), randomintrange( 5, 10 ) ) );
+}
+
+zombie_fall_dust_fx( zombie )
+{
+	dust_tag = "J_SpineUpper";
+	self endon( "stop_zombie_fall_dust_fx" );
+	self thread stop_zombie_fall_dust_fx( zombie );
+	dust_time = 4.5;
+	dust_interval = 0.3;
+	t = 0;
+	while ( t < dust_time )
+	{
+		playfxontag( level._effect[ "rise_dust" ], zombie, dust_tag );
+		wait dust_interval;
+		t += dust_interval;
+	}
+}
+
+stop_zombie_fall_dust_fx( zombie )
+{
+	zombie waittill( "death" );
+	self notify( "stop_zombie_fall_dust_fx" );
+}
+
+handle_fall_notetracks( note, spot )
+{
+	if ( note == "deathout" )
+	{
+		self.deathfunction = ::faller_death_ragdoll;
+	}
+	else
+	{
+		while ( note == "fire" )
+		{
+			victims = zombie_fall_get_vicitims( spot );
+			i = 0;
+			while ( i < victims.size )
+			{
+				victims[ i ] dodamage( self.meleedamage, self.origin, self, self, "none", "MOD_MELEE" );
+				self.zombie_faller_should_drop = 1;
+				i++;
+			}
+		}
+	}
+}
+
+faller_death_ragdoll()
+{
+	self startragdoll();
+	self launchragdoll( ( 0, 0, -1 ) );
+	return self maps/mp/zombies/_zm_spawner::zombie_death_animscript();
+}
+
+in_player_fov( player )
+{
+	playerangles = player getplayerangles();
+	playerforwardvec = anglesToForward( playerangles );
+	playerunitforwardvec = vectornormalize( playerforwardvec );
+	banzaipos = self.origin;
+	playerpos = player getorigin();
+	playertobanzaivec = banzaipos - playerpos;
+	playertobanzaiunitvec = vectornormalize( playertobanzaivec );
+	forwarddotbanzai = vectordot( playerunitforwardvec, playertobanzaiunitvec );
+	anglefromcenter = acos( forwarddotbanzai );
+	playerfov = getDvarFloat( "cg_fov" );
+	banzaivsplayerfovbuffer = getDvarFloat( "g_banzai_player_fov_buffer" );
+	if ( banzaivsplayerfovbuffer <= 0 )
+	{
+		banzaivsplayerfovbuffer = 0.2;
+	}
+	inplayerfov = anglefromcenter <= ( ( playerfov * 0.5 ) * ( 1 - banzaivsplayerfovbuffer ) );
+	return inplayerfov;
+}
+
+potentially_visible( how_close )
+{
+	if ( !isDefined( how_close ) )
+	{
+		how_close = 1000000;
+	}
+	potentiallyvisible = 0;
+	players = getplayers();
+	i = 0;
+	while ( i < players.size )
+	{
+		dist = distancesquared( self.origin, players[ i ].origin );
+		if ( dist < how_close )
+		{
+			inplayerfov = self in_player_fov( players[ i ] );
+			if ( inplayerfov )
+			{
+				potentiallyvisible = 1;
+				break;
+			}
+		}
+		else
+		{
+			i++;
+		}
+	}
+	return potentiallyvisible;
+}
+
+do_zombie_emerge( spot )
+{
+	self endon( "death" );
+	self thread setup_deathfunc( ::faller_death_ragdoll );
+	self.no_powerups = 1;
+	self.in_the_ceiling = 1;
+	anim_org = spot.origin;
+	anim_ang = spot.angles;
+	self thread zombie_emerge_fx( spot );
+	self thread zombie_faller_death_wait( "risen" );
+	if ( isDefined( level.custom_faller_entrance_logic ) )
+	{
+		self thread [[ level.custom_faller_entrance_logic ]]();
+	}
+	self zombie_faller_emerge( spot );
+	self.create_eyes = 1;
+	wait 0.1;
+	self notify( "risen" );
+	self zombie_faller_enable_location();
+}
+
+zombie_faller_emerge( spot )
+{
+	self endon( "death" );
+	if ( isDefined( self.zombie_faller_location.emerge_bottom ) && self.zombie_faller_location.emerge_bottom )
+	{
+		self animscripted( self.zombie_faller_location.origin, self.zombie_faller_location.angles, "zombie_riser_elevator_from_floor" );
+	}
+	else
+	{
+		self animscripted( self.zombie_faller_location.origin, self.zombie_faller_location.angles, "zombie_riser_elevator_from_ceiling" );
+	}
+	self maps/mp/animscripts/zm_shared::donotetracks( "rise_anim" );
+	self.deathfunction = ::zombie_death_animscript;
+	self.in_the_ceiling = 0;
+	self.no_powerups = 0;
+}
+
+zombie_emerge_fx( spot )
+{
+	spot thread zombie_emerge_dust_fx( self );
+	playsoundatposition( "zmb_zombie_spawn", spot.origin );
+	self endon( "death" );
+	spot endon( "stop_zombie_fall_fx" );
+	wait 1;
+}
+
+zombie_emerge_dust_fx( zombie )
+{
+	dust_tag = "J_SpineUpper";
+	self endon( "stop_zombie_fall_dust_fx" );
+	self thread stop_zombie_fall_dust_fx( zombie );
+	dust_time = 3.5;
+	dust_interval = 0.5;
+	t = 0;
+	while ( t < dust_time )
+	{
+		playfxontag( level._effect[ "rise_dust" ], zombie, dust_tag );
+		wait dust_interval;
+		t += dust_interval;
+	}
+}
+
+stop_zombie_emerge_dust_fx( zombie )
+{
+	zombie waittill( "death" );
+	self notify( "stop_zombie_fall_dust_fx" );
+}
+

patch_zm/maps/mp/zombies/NoKnownErrors/_zm_bot.gsc

@@ -0,0 +1,10 @@
+#include maps/mp/zombies/_zm_utility;
+#include maps/mp/_utility;
+#include common_scripts/utility;
+
+init()
+{
+/#
+	println( "ZM >> Zombiemode Server Scripts Init (_zm_bot.gsc)" );
+#/
+}

patch_zm/maps/mp/zombies/NoKnownErrors/_zm_equip_hacker.gsc

@@ -0,0 +1,915 @@
+#include maps/mp/zombies/_zm_equip_hacker;
+#include maps/mp/zombies/_zm_audio;
+#include maps/mp/gametypes_zm/_hud_util;
+#include maps/mp/zombies/_zm_laststand;
+#include maps/mp/zombies/_zm_score;
+#include maps/mp/zombies/_zm_equipment;
+#include maps/mp/zombies/_zm_utility;
+#include maps/mp/_utility;
+#include common_scripts/utility;
+
+init()
+{
+	if ( !maps/mp/zombies/_zm_equipment::is_equipment_included( "equip_hacker_zm" ) )
+	{
+		return;
+	}
+	maps/mp/zombies/_zm_equipment::register_equipment( "equip_hacker_zm", &"ZOMBIE_EQUIP_HACKER_PICKUP_HINT_STRING", &"ZOMBIE_EQUIP_HACKER_HOWTO", undefined, "hacker" );
+	level._hackable_objects = [];
+	level._pooled_hackable_objects = [];
+	onplayerconnect_callback( ::hacker_on_player_connect );
+	level thread hack_trigger_think();
+	level thread hacker_trigger_pool_think();
+	level thread hacker_round_reward();
+	/*
+	if ( getDvarInt( #"53BD7080" ) == 1 )
+	{
+		level thread hacker_debug();
+	}
+	*/
+}
+
+hacker_round_reward()
+{
+	while ( 1 )
+	{
+		level waittill( "end_of_round" );
+		if ( !isDefined( level._from_nml ) )
+		{
+			players = get_players();
+			i = 0;
+			while ( i < players.size )
+			{
+				if ( isDefined( players[ i ] get_player_equipment() ) && players[ i ] get_player_equipment() == "equip_hacker_zm" )
+				{
+					if ( isDefined( players[ i ].equipment_got_in_round[ "equip_hacker_zm" ] ) )
+					{
+						got_in_round = players[ i ].equipment_got_in_round[ "equip_hacker_zm" ];
+						rounds_kept = level.round_number - got_in_round;
+						rounds_kept -= 1;
+						if ( rounds_kept > 0 )
+						{
+							rounds_kept = min( rounds_kept, 5 );
+							score = rounds_kept * 500;
+							players[ i ] maps/mp/zombies/_zm_score::add_to_player_score( int( score ) );
+						}
+					}
+				}
+				i++;
+			}
+		}
+		else level._from_nml = undefined;
+	}
+}
+
+hacker_debug()
+{
+	while ( 1 )
+	{
+		i = 0;
+		while ( i < level._hackable_objects.size )
+		{
+			hackable = level._hackable_objects[ i ];
+			if ( isDefined( hackable.pooled ) && hackable.pooled )
+			{
+				if ( isDefined( hackable._trigger ) )
+				{
+					col = vectorScale( ( 0, 0, 1 ), 255 );
+					if ( isDefined( hackable.custom_debug_color ) )
+					{
+						col = hackable.custom_debug_color;
+					}
+/#
+					print3d( hackable.origin, "+", col, 1, 1 );
+#/
+				}
+				else
+				{
+/#
+					print3d( hackable.origin, "+", vectorScale( ( 0, 0, 1 ), 255 ), 1, 1 );
+#/
+				}
+				i++;
+				continue;
+			}
+			else
+			{
+/#
+				print3d( hackable.origin, "+", vectorScale( ( 0, 0, 1 ), 255 ), 1, 1 );
+#/
+			}
+			i++;
+		}
+		wait 0.1;
+	}
+}
+
+hacker_trigger_pool_think()
+{
+	if ( !isDefined( level._zombie_hacker_trigger_pool_size ) )
+	{
+		level._zombie_hacker_trigger_pool_size = 8;
+	}
+	pool_active = 0;
+	level._hacker_pool = [];
+	while ( 1 )
+	{
+		if ( pool_active )
+		{
+			if ( !any_hackers_active() )
+			{
+				destroy_pooled_items();
+			}
+			else
+			{
+				sweep_pooled_items();
+				add_eligable_pooled_items();
+			}
+		}
+		else
+		{
+			if ( any_hackers_active() )
+			{
+				pool_active = 1;
+			}
+		}
+		wait 0.1;
+	}
+}
+
+destroy_pooled_items()
+{
+	pool_active = 0;
+	i = 0;
+	while ( i < level._hacker_pool.size )
+	{
+		level._hacker_pool[ i ]._trigger delete();
+		level._hacker_pool[ i ]._trigger = undefined;
+		i++;
+	}
+	level._hacker_pool = [];
+}
+
+sweep_pooled_items()
+{
+	new_hacker_pool = [];
+	i = 0;
+	while ( i < level._hacker_pool.size )
+	{
+		if ( level._hacker_pool[ i ] should_pooled_object_exist() )
+		{
+			new_hacker_pool[ new_hacker_pool.size ] = level._hacker_pool[ i ];
+			i++;
+			continue;
+		}
+		else
+		{
+			if ( isDefined( level._hacker_pool[ i ]._trigger ) )
+			{
+				level._hacker_pool[ i ]._trigger delete();
+			}
+			level._hacker_pool[ i ]._trigger = undefined;
+		}
+		i++;
+	}
+	level._hacker_pool = new_hacker_pool;
+}
+
+should_pooled_object_exist()
+{
+	players = get_players();
+	i = 0;
+	while ( i < players.size )
+	{
+		if ( players[ i ] hacker_active() )
+		{
+			if ( isDefined( self.entity ) )
+			{
+				if ( self.entity != players[ i ] )
+				{
+					if ( distance2dsquared( players[ i ].origin, self.entity.origin ) <= ( self.radius * self.radius ) )
+					{
+						return 1;
+					}
+				}
+			}
+			else
+			{
+				if ( distance2dsquared( players[ i ].origin, self.origin ) <= ( self.radius * self.radius ) )
+				{
+					return 1;
+				}
+			}
+		}
+		i++;
+	}
+	return 0;
+}
+
+add_eligable_pooled_items()
+{
+	candidates = [];
+	i = 0;
+	while ( i < level._hackable_objects.size )
+	{
+		hackable = level._hackable_objects[ i ];
+		if ( isDefined( hackable.pooled ) && hackable.pooled && !isDefined( hackable._trigger ) )
+		{
+			if ( !isinarray( level._hacker_pool, hackable ) )
+			{
+				if ( hackable should_pooled_object_exist() )
+				{
+					candidates[ candidates.size ] = hackable;
+				}
+			}
+		}
+		i++;
+	}
+	i = 0;
+	while ( i < candidates.size )
+	{
+		candidate = candidates[ i ];
+		height = 72;
+		radius = 32;
+		if ( isDefined( candidate.radius ) )
+		{
+			radius = candidate.radius;
+		}
+		if ( isDefined( candidate.height ) )
+		{
+			height = candidate.height;
+		}
+		trigger = spawn( "trigger_radius_use", candidate.origin, 0, radius, height );
+		trigger usetriggerrequirelookat();
+		trigger triggerignoreteam();
+		trigger setcursorhint( "HINT_NOICON" );
+		trigger.radius = radius;
+		trigger.height = height;
+		trigger.beinghacked = 0;
+		candidate._trigger = trigger;
+		level._hacker_pool[ level._hacker_pool.size ] = candidate;
+		i++;
+	}
+}
+
+get_hackable_trigger()
+{
+	if ( isDefined( self.door ) )
+	{
+		return self.door;
+	}
+	else
+	{
+		if ( isDefined( self.perk ) )
+		{
+			return self.perk;
+		}
+		else
+		{
+			if ( isDefined( self.window ) )
+			{
+				return self.window.unitrigger_stub.trigger;
+			}
+			else
+			{
+				if ( isDefined( self.classname ) && getsubstr( self.classname, 0, 7 ) == "trigger_" )
+				{
+					return self;
+				}
+			}
+		}
+	}
+}
+
+any_hackers_active()
+{
+	players = get_players();
+	i = 0;
+	while ( i < players.size )
+	{
+		if ( players[ i ] hacker_active() )
+		{
+			return 1;
+		}
+		i++;
+	}
+	return 0;
+}
+
+register_hackable( name, callback_func, qualifier_func )
+{
+	structs = getstructarray( name, "script_noteworthy" );
+	if ( !isDefined( structs ) )
+	{
+/#
+		println( "Error:  register_hackable called on script_noteworthy " + name + " but no such structs exist." );
+#/
+		return;
+	}
+	i = 0;
+	while ( i < structs.size )
+	{
+		if ( !isinarray( level._hackable_objects, structs[ i ] ) )
+		{
+			structs[ i ]._hack_callback_func = callback_func;
+			structs[ i ]._hack_qualifier_func = qualifier_func;
+			structs[ i ].pooled = level._hacker_pooled;
+			if ( isDefined( structs[ i ].targetname ) )
+			{
+				structs[ i ].hacker_target = getent( structs[ i ].targetname, "targetname" );
+			}
+			level._hackable_objects[ level._hackable_objects.size ] = structs[ i ];
+			if ( isDefined( level._hacker_pooled ) )
+			{
+				level._pooled_hackable_objects[ level._pooled_hackable_objects.size ] = structs[ i ];
+			}
+			structs[ i ] thread hackable_object_thread();
+			wait_network_frame();
+		}
+		i++;
+	}
+}
+
+register_hackable_struct( struct, callback_func, qualifier_func )
+{
+	if ( !isinarray( level._hackable_objects, struct ) )
+	{
+		struct._hack_callback_func = callback_func;
+		struct._hack_qualifier_func = qualifier_func;
+		struct.pooled = level._hacker_pooled;
+		if ( isDefined( struct.targetname ) )
+		{
+			struct.hacker_target = getent( struct.targetname, "targetname" );
+		}
+		level._hackable_objects[ level._hackable_objects.size ] = struct;
+		if ( isDefined( level._hacker_pooled ) )
+		{
+			level._pooled_hackable_objects[ level._pooled_hackable_objects.size ] = struct;
+		}
+		struct thread hackable_object_thread();
+	}
+}
+
+register_pooled_hackable_struct( struct, callback_func, qualifier_func )
+{
+	level._hacker_pooled = 1;
+	register_hackable_struct( struct, callback_func, qualifier_func );
+	level._hacker_pooled = undefined;
+}
+
+register_pooled_hackable( name, callback_func, qualifier_func )
+{
+	level._hacker_pooled = 1;
+	register_hackable( name, callback_func, qualifier_func );
+	level._hacker_pooled = undefined;
+}
+
+deregister_hackable_struct( struct )
+{
+	if ( isinarray( level._hackable_objects, struct ) )
+	{
+		new_list = [];
+		i = 0;
+		while ( i < level._hackable_objects.size )
+		{
+			if ( level._hackable_objects[ i ] != struct )
+			{
+				new_list[ new_list.size ] = level._hackable_objects[ i ];
+				i++;
+				continue;
+			}
+			else
+			{
+				level._hackable_objects[ i ] notify( "hackable_deregistered" );
+				if ( isDefined( level._hackable_objects[ i ]._trigger ) )
+				{
+					level._hackable_objects[ i ]._trigger delete();
+				}
+				if ( isDefined( level._hackable_objects[ i ].pooled ) && level._hackable_objects[ i ].pooled )
+				{
+					arrayremovevalue( level._hacker_pool, level._hackable_objects[ i ] );
+					arrayremovevalue( level._pooled_hackable_objects, level._hackable_objects[ i ] );
+				}
+			}
+			i++;
+		}
+		level._hackable_objects = new_list;
+	}
+}
+
+deregister_hackable( noteworthy )
+{
+	new_list = [];
+	i = 0;
+	while ( i < level._hackable_objects.size )
+	{
+		if ( !isDefined( level._hackable_objects[ i ].script_noteworthy ) || level._hackable_objects[ i ].script_noteworthy != noteworthy )
+		{
+			new_list[ new_list.size ] = level._hackable_objects[ i ];
+		}
+		else
+		{
+			level._hackable_objects[ i ] notify( "hackable_deregistered" );
+			if ( isDefined( level._hackable_objects[ i ]._trigger ) )
+			{
+				level._hackable_objects[ i ]._trigger delete();
+			}
+		}
+		if ( isDefined( level._hackable_objects[ i ].pooled ) && level._hackable_objects[ i ].pooled )
+		{
+			arrayremovevalue( level._hacker_pool, level._hackable_objects[ i ] );
+		}
+		i++;
+	}
+	level._hackable_objects = new_list;
+}
+
+hack_trigger_think()
+{
+	while ( 1 )
+	{
+		players = get_players();
+		i = 0;
+		while ( i < players.size )
+		{
+			player = players[ i ];
+			j = 0;
+			while ( j < level._hackable_objects.size )
+			{
+				hackable = level._hackable_objects[ j ];
+				if ( isDefined( hackable._trigger ) )
+				{
+					qualifier_passed = 1;
+					if ( isDefined( hackable._hack_qualifier_func ) )
+					{
+						qualifier_passed = hackable [[ hackable._hack_qualifier_func ]]( player );
+					}
+					if ( player hacker_active() && qualifier_passed && !hackable._trigger.beinghacked )
+					{
+						hackable._trigger setinvisibletoplayer( player, 0 );
+						j++;
+						continue;
+					}
+					else
+					{
+						hackable._trigger setinvisibletoplayer( player, 1 );
+					}
+				}
+				j++;
+			}
+			i++;
+		}
+		wait 0.1;
+	}
+}
+
+is_facing( facee )
+{
+	orientation = self getplayerangles();
+	forwardvec = anglesToForward( orientation );
+	forwardvec2d = ( forwardvec[ 0 ], forwardvec[ 1 ], 0 );
+	unitforwardvec2d = vectornormalize( forwardvec2d );
+	tofaceevec = facee.origin - self.origin;
+	tofaceevec2d = ( tofaceevec[ 0 ], tofaceevec[ 1 ], 0 );
+	unittofaceevec2d = vectornormalize( tofaceevec2d );
+	dotproduct = vectordot( unitforwardvec2d, unittofaceevec2d );
+	dot_limit = 0.8;
+	if ( isDefined( facee.dot_limit ) )
+	{
+		dot_limit = facee.dot_limit;
+	}
+	return dotproduct > dot_limit;
+}
+
+can_hack( hackable )
+{
+	if ( !isalive( self ) )
+	{
+		return 0;
+	}
+	if ( self maps/mp/zombies/_zm_laststand::player_is_in_laststand() )
+	{
+		return 0;
+	}
+	if ( !self hacker_active() )
+	{
+		return 0;
+	}
+	if ( !isDefined( hackable._trigger ) )
+	{
+		return 0;
+	}
+	if ( isDefined( hackable.player ) )
+	{
+		if ( hackable.player != self )
+		{
+			return 0;
+		}
+	}
+	if ( self throwbuttonpressed() )
+	{
+		return 0;
+	}
+	if ( self fragbuttonpressed() )
+	{
+		return 0;
+	}
+	if ( isDefined( hackable._hack_qualifier_func ) )
+	{
+		if ( !( hackable [[ hackable._hack_qualifier_func ]]( self ) ) )
+		{
+			return 0;
+		}
+	}
+	if ( !isinarray( level._hackable_objects, hackable ) )
+	{
+		return 0;
+	}
+	radsquared = 1024;
+	if ( isDefined( hackable.radius ) )
+	{
+		radsquared = hackable.radius * hackable.radius;
+	}
+	origin = hackable.origin;
+	if ( isDefined( hackable.entity ) )
+	{
+		origin = hackable.entity.origin;
+	}
+	if ( distance2dsquared( self.origin, origin ) > radsquared )
+	{
+		return 0;
+	}
+	if ( !isDefined( hackable.no_touch_check ) && !self istouching( hackable._trigger ) )
+	{
+		return 0;
+	}
+	if ( !self is_facing( hackable ) )
+	{
+		return 0;
+	}
+	if ( !isDefined( hackable.no_sight_check ) && !sighttracepassed( self.origin + vectorScale( ( 0, 0, 1 ), 50 ), origin, 0, undefined ) )
+	{
+		return 0;
+	}
+	if ( !isDefined( hackable.no_bullet_trace ) && !bullettracepassed( self.origin + vectorScale( ( 0, 0, 1 ), 50 ), origin, 0, undefined ) )
+	{
+		return 0;
+	}
+	return 1;
+}
+
+is_hacking( hackable )
+{
+	if ( can_hack( hackable ) )
+	{
+		return self usebuttonpressed();
+	}
+}
+
+set_hack_hint_string()
+{
+	if ( isDefined( self._trigger ) )
+	{
+		if ( isDefined( self.custom_string ) )
+		{
+			self._trigger sethintstring( self.custom_string );
+			return;
+		}
+		else if ( !isDefined( self.script_int ) || self.script_int <= 0 )
+		{
+			self._trigger sethintstring( &"ZOMBIE_HACK_NO_COST" );
+			return;
+		}
+		else
+		{
+			self._trigger sethintstring( &"ZOMBIE_HACK", self.script_int );
+		}
+	}
+}
+
+tidy_on_deregister( hackable )
+{
+	self endon( "clean_up_tidy_up" );
+	hackable waittill( "hackable_deregistered" );
+	if ( isDefined( self.hackerprogressbar ) )
+	{
+		self.hackerprogressbar maps/mp/gametypes_zm/_hud_util::destroyelem();
+	}
+	if ( isDefined( self.hackertexthud ) )
+	{
+		self.hackertexthud destroy();
+	}
+}
+
+hacker_do_hack( hackable )
+{
+	timer = 0;
+	hacked = 0;
+	hackable._trigger.beinghacked = 1;
+	if ( !isDefined( self.hackerprogressbar ) )
+	{
+		self.hackerprogressbar = self maps/mp/gametypes_zm/_hud_util::createprimaryprogressbar();
+	}
+	if ( !isDefined( self.hackertexthud ) )
+	{
+		self.hackertexthud = newclienthudelem( self );
+	}
+	hack_duration = hackable.script_float;
+	if ( self hasperk( "specialty_fastreload" ) )
+	{
+		hack_duration *= 0.66;
+	}
+	hack_duration = max( 1.5, hack_duration );
+	self thread tidy_on_deregister( hackable );
+	self.hackerprogressbar maps/mp/gametypes_zm/_hud_util::updatebar( 0.01, 1 / hack_duration );
+	self.hackertexthud.alignx = "center";
+	self.hackertexthud.aligny = "middle";
+	self.hackertexthud.horzalign = "center";
+	self.hackertexthud.vertalign = "bottom";
+	self.hackertexthud.y = -113;
+	if ( issplitscreen() )
+	{
+		self.hackertexthud.y = -107;
+	}
+	self.hackertexthud.foreground = 1;
+	self.hackertexthud.font = "default";
+	self.hackertexthud.fontscale = 1.8;
+	self.hackertexthud.alpha = 1;
+	self.hackertexthud.color = ( 0, 0, 1 );
+	self.hackertexthud settext( &"ZOMBIE_HACKING" );
+	self playloopsound( "zmb_progress_bar", 0,5 );
+	while ( self is_hacking( hackable ) )
+	{
+		wait 0.05;
+		timer += 0.05;
+		if ( self maps/mp/zombies/_zm_laststand::player_is_in_laststand() )
+		{
+			break;
+		}
+		else if ( timer >= hack_duration )
+		{
+			hacked = 1;
+			break;
+		}
+		else
+		{
+		}
+	}
+	self stoploopsound( 0.5 );
+	if ( hacked )
+	{
+		self playsound( "vox_mcomp_hack_success" );
+	}
+	else self playsound( "vox_mcomp_hack_fail" );
+	if ( isDefined( self.hackerprogressbar ) )
+	{
+		self.hackerprogressbar maps/mp/gametypes_zm/_hud_util::destroyelem();
+	}
+	if ( isDefined( self.hackertexthud ) )
+	{
+		self.hackertexthud destroy();
+	}
+	hackable set_hack_hint_string();
+	if ( isDefined( hackable._trigger ) )
+	{
+		hackable._trigger.beinghacked = 0;
+	}
+	self notify( "clean_up_tidy_up" );
+	return hacked;
+}
+
+lowreadywatcher( player )
+{
+	player endon( "disconnected" );
+	self endon( "kill_lowreadywatcher" );
+	self waittill( "hackable_deregistered" );
+}
+
+hackable_object_thread()
+{
+	self endon( "hackable_deregistered" );
+	height = 72;
+	radius = 64;
+	if ( isDefined( self.radius ) )
+	{
+		radius = self.radius;
+	}
+	if ( isDefined( self.height ) )
+	{
+		height = self.height;
+	}
+	if ( !isDefined( self.pooled ) )
+	{
+		trigger = spawn( "trigger_radius_use", self.origin, 0, radius, height );
+		trigger usetriggerrequirelookat();
+		trigger setcursorhint( "HINT_NOICON" );
+		trigger.radius = radius;
+		trigger.height = height;
+		trigger.beinghacked = 0;
+		self._trigger = trigger;
+	}
+	cost = 0;
+	if ( isDefined( self.script_int ) )
+	{
+		cost = self.script_int;
+	}
+	duration = 1;
+	if ( isDefined( self.script_float ) )
+	{
+		duration = self.script_float;
+	}
+	while ( 1 )
+	{
+		wait 0.1;
+		while ( !isDefined( self._trigger ) )
+		{
+			continue;
+		}
+		players = get_players();
+		if ( isDefined( self._trigger ) )
+		{
+			if ( isDefined( self.entity ) )
+			{
+				self.origin = self.entity.origin;
+				self._trigger.origin = self.entity.origin;
+				if ( isDefined( self.trigger_offset ) )
+				{
+					self._trigger.origin += self.trigger_offset;
+				}
+			}
+		}
+		i = 0;
+		while ( i < players.size )
+		{
+			if ( players[ i ] can_hack( self ) )
+			{
+				self set_hack_hint_string();
+				break;
+			}
+			else
+			{
+				i++;
+			}
+		}
+		i = 0;
+		while ( i < players.size )
+		{
+			hacker = players[ i ];
+			if ( !hacker is_hacking( self ) )
+			{
+				i++;
+				continue;
+			}
+			else if ( hacker.score >= cost || cost <= 0 )
+			{
+				self thread lowreadywatcher( hacker );
+				hack_success = hacker hacker_do_hack( self );
+				self notify( "kill_lowreadywatcher" );
+				if ( isDefined( hacker ) )
+				{
+				}
+				if ( isDefined( hacker ) && hack_success )
+				{
+					if ( cost )
+					{
+						if ( cost > 0 )
+						{
+							hacker maps/mp/zombies/_zm_score::minus_to_player_score( cost );
+							break;
+						}
+						else
+						{
+							hacker maps/mp/zombies/_zm_score::add_to_player_score( cost * -1 );
+						}
+					}
+					hacker notify( "successful_hack" );
+					if ( isDefined( self._hack_callback_func ) )
+					{
+						self thread [[ self._hack_callback_func ]]( hacker );
+					}
+				}
+				i++;
+				continue;
+			}
+			else
+			{
+				hacker play_sound_on_ent( "no_purchase" );
+				hacker maps/mp/zombies/_zm_audio::create_and_play_dialog( "general", "no_money", undefined, 1 );
+			}
+			i++;
+		}
+	}
+}
+
+hacker_on_player_connect()
+{
+	struct = spawnstruct();
+	struct.origin = self.origin;
+	struct.radius = 48;
+	struct.height = 64;
+	struct.script_float = 10;
+	struct.script_int = 500;
+	struct.entity = self;
+	struct.trigger_offset = vectorScale( ( 0, 0, 1 ), 48 );
+	register_pooled_hackable_struct( struct, ::player_hack, ::player_qualifier );
+	struct thread player_hack_disconnect_watcher( self );
+}
+
+player_hack_disconnect_watcher( player )
+{
+	player waittill( "disconnect" );
+	deregister_hackable_struct( self );
+}
+
+player_hack( hacker )
+{
+	if ( isDefined( self.entity ) )
+	{
+		self.entity maps/mp/zombies/_zm_score::player_add_points( "hacker_transfer", 500 );
+	}
+	if ( isDefined( hacker ) )
+	{
+		hacker thread maps/mp/zombies/_zm_audio::create_and_play_dialog( "general", "hack_plr" );
+	}
+}
+
+player_qualifier( player )
+{
+	if ( player == self.entity )
+	{
+		return 0;
+	}
+	if ( self.entity maps/mp/zombies/_zm_laststand::player_is_in_laststand() )
+	{
+		return 0;
+	}
+	if ( player maps/mp/zombies/_zm_laststand::player_is_in_laststand() )
+	{
+		return 0;
+	}
+	if ( isDefined( self.entity.sessionstate == "spectator" ) && self.entity.sessionstate == "spectator" )
+	{
+		return 0;
+	}
+	return 1;
+}
+
+hide_hint_when_hackers_active( custom_logic_func, custom_logic_func_param )
+{
+	invis_to_any = 0;
+	while ( 1 )
+	{
+		if ( isDefined( custom_logic_func ) )
+		{
+			self [[ custom_logic_func ]]( custom_logic_func_param );
+		}
+		if ( maps/mp/zombies/_zm_equip_hacker::any_hackers_active() )
+		{
+			players = get_players();
+			i = 0;
+			while ( i < players.size )
+			{
+				if ( players[ i ] hacker_active() )
+				{
+					self setinvisibletoplayer( players[ i ], 1 );
+					invis_to_any = 1;
+					i++;
+					continue;
+				}
+				else
+				{
+					self setinvisibletoplayer( players[ i ], 0 );
+				}
+				i++;
+			}
+		}
+		else while ( invis_to_any )
+		{
+			invis_to_any = 0;
+			players = get_players();
+			i = 0;
+			while ( i < players.size )
+			{
+				self setinvisibletoplayer( players[ i ], 0 );
+				i++;
+			}
+		}
+		wait 0.1;
+	}
+}
+
+hacker_debug_print( msg, color )
+{
+/#
+	if ( !getDvarInt( #"428DE100" ) )
+	{
+		return;
+	}
+	if ( !isDefined( color ) )
+	{
+		color = ( 0, 0, 1 );
+	}
+	print3d( self.origin + vectorScale( ( 0, 0, 1 ), 60 ), msg, color, 1, 1, 40 );
+#/
+}
+

patch_zm/maps/mp/zombies/NoKnownErrors/_zm_hackables_boards.gsc

@@ -0,0 +1,131 @@
+#include maps/mp/zombies/_zm_blockers;
+#include maps/mp/zombies/_zm_score;
+#include maps/mp/zombies/_zm_equip_hacker;
+#include maps/mp/zombies/_zm_utility;
+#include maps/mp/_utility;
+#include common_scripts/utility;
+
+hack_boards()
+{
+	windows = getstructarray( "exterior_goal", "targetname" );
+	i = 0;
+	while ( i < windows.size )
+	{
+		window = windows[ i ];
+		struct = spawnstruct();
+		spot = window;
+		if ( isDefined( window.trigger_location ) )
+		{
+			spot = window.trigger_location;
+		}
+		org = groundpos( spot.origin ) + vectorScale( ( 0, 0, 1 ), 4 );
+		r = 96;
+		h = 96;
+		if ( isDefined( spot.radius ) )
+		{
+			r = spot.radius;
+		}
+		if ( isDefined( spot.height ) )
+		{
+			h = spot.height;
+		}
+		struct.origin = org + vectorScale( ( 0, 0, 1 ), 48 );
+		struct.radius = r;
+		struct.height = h;
+		struct.script_float = 2;
+		struct.script_int = 0;
+		struct.window = window;
+		struct.no_bullet_trace = 1;
+		struct.no_sight_check = 1;
+		struct.dot_limit = 0.7;
+		struct.no_touch_check = 1;
+		struct.last_hacked_round = 0;
+		struct.num_hacks = 0;
+		maps/mp/zombies/_zm_equip_hacker::register_pooled_hackable_struct( struct, ::board_hack, ::board_qualifier );
+		i++;
+	}
+}
+
+board_hack( hacker )
+{
+	maps/mp/zombies/_zm_equip_hacker::deregister_hackable_struct( self );
+	num_chunks_checked = 0;
+	last_repaired_chunk = undefined;
+	if ( self.last_hacked_round != level.round_number )
+	{
+		self.last_hacked_round = level.round_number;
+		self.num_hacks = 0;
+	}
+	self.num_hacks++;
+	if ( self.num_hacks < 3 )
+	{
+		hacker maps/mp/zombies/_zm_score::add_to_player_score( 100 );
+	}
+	else
+	{
+		cost = int( min( 300, hacker.score ) );
+		if ( cost )
+		{
+			hacker maps/mp/zombies/_zm_score::minus_to_player_score( cost );
+		}
+	}
+	while ( 1 )
+	{
+		if ( all_chunks_intact( self.window, self.window.barrier_chunks ) )
+		{
+			break;
+		}
+		else chunk = get_random_destroyed_chunk( self.window, self.window.barrier_chunks );
+		if ( !isDefined( chunk ) )
+		{
+			break;
+		}
+		else self.window thread maps/mp/zombies/_zm_blockers::replace_chunk( self.window, chunk, undefined, 0, 1 );
+		last_repaired_chunk = chunk;
+		if ( isDefined( self.clip ) )
+		{
+			self.window.clip enable_trigger();
+			self.window.clip disconnectpaths();
+		}
+		else
+		{
+			blocker_disconnect_paths( self.window.neg_start, self.window.neg_end );
+		}
+		wait_network_frame();
+		num_chunks_checked++;
+		if ( num_chunks_checked >= 20 )
+		{
+			break;
+		}
+		else
+		{
+		}
+	}
+	if ( isDefined( self.window.zbarrier ) )
+	{
+		while ( isDefined( last_repaired_chunk ) )
+		{
+			while ( self.window.zbarrier getzbarrierpiecestate( last_repaired_chunk ) == "closing" )
+			{
+				wait 0.05;
+			}
+		}
+	}
+	else while ( isDefined( last_repaired_chunk ) && last_repaired_chunk.state == "mid_repair" )
+	{
+		wait 0.05;
+	}
+	maps/mp/zombies/_zm_equip_hacker::register_pooled_hackable_struct( self, ::board_hack, ::board_qualifier );
+	self.window notify( "blocker_hacked" );
+	self.window notify( "no valid boards" );
+}
+
+board_qualifier( player )
+{
+	if ( all_chunks_intact( self.window, self.window.barrier_chunks ) || no_valid_repairable_boards( self.window, self.window.barrier_chunks ) )
+	{
+		return 0;
+	}
+	return 1;
+}
+

patch_zm/maps/mp/zombies/NoKnownErrors/_zm_hackables_box.gsc

@@ -0,0 +1,371 @@
+#include maps/mp/zombies/_zm_audio;
+#include maps/mp/zombies/_zm_weapons;
+#include maps/mp/zombies/_zm_equip_hacker;
+#include maps/mp/zombies/_zm_magicbox;
+#include maps/mp/zombies/_zm_utility;
+#include maps/mp/_utility;
+#include common_scripts/utility;
+
+box_hacks()
+{
+	boxes = getstructarray( "treasure_chest_use", "targetname" );
+	i = 0;
+	while ( i < boxes.size )
+	{
+		box = boxes[ i ];
+		box.box_hacks[ "respin" ] = ::init_box_respin;
+		box.box_hacks[ "respin_respin" ] = ::init_box_respin_respin;
+		box.box_hacks[ "summon_box" ] = ::init_summon_box;
+		box.last_hacked_round = 0;
+		i++;
+	}
+	level._zombiemode_chest_joker_chance_override_func = ::check_for_free_locations;
+	level._zombiemode_custom_box_move_logic = ::custom_box_move_logic;
+	level._zombiemode_check_firesale_loc_valid_func = ::custom_check_firesale_loc_valid_func;
+	init_summon_hacks();
+}
+
+custom_check_firesale_loc_valid_func()
+{
+	if ( isDefined( self.unitrigger_stub ) )
+	{
+		box = self.unitrigger_stub.trigger_target;
+	}
+	else
+	{
+		if ( isDefined( self.stub ) )
+		{
+			box = self.stub.trigger_target;
+		}
+	}
+	if ( box.last_hacked_round >= level.round_number )
+	{
+		return 0;
+	}
+	return 1;
+}
+
+custom_box_move_logic()
+{
+	num_hacked_locs = 0;
+	i = 0;
+	while ( i < level.chests.size )
+	{
+		if ( level.chests[ i ].last_hacked_round >= level.round_number )
+		{
+			num_hacked_locs++;
+		}
+		i++;
+	}
+	if ( num_hacked_locs == 0 )
+	{
+		maps/mp/zombies/_zm_magicbox::default_box_move_logic();
+		return;
+	}
+	found_loc = 0;
+	original_spot = level.chest_index;
+	while ( !found_loc )
+	{
+		level.chest_index++;
+		if ( original_spot == level.chest_index )
+		{
+			level.chest_index++;
+		}
+		level.chest_index %= level.chests.size;
+		if ( level.chests[ level.chest_index ].last_hacked_round < level.round_number )
+		{
+			found_loc = 1;
+		}
+	}
+}
+
+check_for_free_locations( chance )
+{
+	boxes = level.chests;
+	stored_chance = chance;
+	chance = -1;
+	i = 0;
+	while ( i < boxes.size )
+	{
+		if ( i == level.chest_index )
+		{
+			i++;
+			continue;
+		}
+		else if ( boxes[ i ].last_hacked_round < level.round_number )
+		{
+			chance = stored_chance;
+			break;
+		}
+		else
+		{
+			i++;
+		}
+	}
+	return chance;
+}
+
+init_box_respin( chest, player )
+{
+	self thread box_respin_think( chest, player );
+}
+
+box_respin_think( chest, player )
+{
+	respin_hack = spawnstruct();
+	respin_hack.origin = self.origin + vectorScale( ( 0, 0, 1 ), 24 );
+	respin_hack.radius = 48;
+	respin_hack.height = 72;
+	respin_hack.script_int = 600;
+	respin_hack.script_float = 1.5;
+	respin_hack.player = player;
+	respin_hack.no_bullet_trace = 1;
+	respin_hack.chest = chest;
+	maps/mp/zombies/_zm_equip_hacker::register_pooled_hackable_struct( respin_hack, ::respin_box, ::hack_box_qualifier );
+	self.weapon_model waittill_either( "death", "kill_respin_think_thread" );
+	maps/mp/zombies/_zm_equip_hacker::deregister_hackable_struct( respin_hack );
+}
+
+respin_box_thread( hacker )
+{
+	if ( isDefined( self.chest.zbarrier.weapon_model ) )
+	{
+		self.chest.zbarrier.weapon_model notify( "kill_respin_think_thread" );
+	}
+	self.chest.no_fly_away = 1;
+	self.chest.zbarrier notify( "box_hacked_respin" );
+	self.chest disable_trigger();
+	play_sound_at_pos( "open_chest", self.chest.zbarrier.origin );
+	play_sound_at_pos( "music_chest", self.chest.zbarrier.origin );
+	maps/mp/zombies/_zm_weapons::unacquire_weapon_toggle( self.chest.zbarrier.weapon_string );
+	self.chest.zbarrier thread maps/mp/zombies/_zm_magicbox::treasure_chest_weapon_spawn( self.chest, hacker, 1 );
+	self.chest.zbarrier waittill( "randomization_done" );
+	self.chest.no_fly_away = undefined;
+	if ( !flag( "moving_chest_now" ) )
+	{
+		self.chest enable_trigger();
+		self.chest thread maps/mp/zombies/_zm_magicbox::treasure_chest_timeout();
+	}
+}
+
+respin_box( hacker )
+{
+	self thread respin_box_thread( hacker );
+}
+
+hack_box_qualifier( player )
+{
+	if ( player == self.chest.chest_user && isDefined( self.chest.weapon_out ) )
+	{
+		return 1;
+	}
+	return 0;
+}
+
+init_box_respin_respin( chest, player )
+{
+	self thread box_respin_respin_think( chest, player );
+}
+
+box_respin_respin_think( chest, player )
+{
+	respin_hack = spawnstruct();
+	respin_hack.origin = self.origin + vectorScale( ( 0, 0, 1 ), 24 );
+	respin_hack.radius = 48;
+	respin_hack.height = 72;
+	respin_hack.script_int = -950;
+	respin_hack.script_float = 1.5;
+	respin_hack.player = player;
+	respin_hack.no_bullet_trace = 1;
+	respin_hack.chest = chest;
+	maps/mp/zombies/_zm_equip_hacker::register_pooled_hackable_struct( respin_hack, ::respin_respin_box, ::hack_box_qualifier );
+	self.weapon_model waittill_either( "death", "kill_respin_respin_think_thread" );
+	maps/mp/zombies/_zm_equip_hacker::deregister_hackable_struct( respin_hack );
+}
+
+respin_respin_box( hacker )
+{
+	org = self.chest.zbarrier.origin;
+	if ( isDefined( self.chest.zbarrier.weapon_model ) )
+	{
+		self.chest.zbarrier.weapon_model notify( "kill_respin_respin_think_thread" );
+		self.chest.zbarrier.weapon_model notify( "kill_weapon_movement" );
+		self.chest.zbarrier.weapon_model moveto( org + vectorScale( ( 0, 0, 1 ), 40 ), 0,5 );
+	}
+	if ( isDefined( self.chest.zbarrier.weapon_model_dw ) )
+	{
+		self.chest.zbarrier.weapon_model_dw notify( "kill_weapon_movement" );
+		self.chest.zbarrier.weapon_model_dw moveto( ( org + vectorScale( ( 0, 0, 1 ), 40 ) ) - vectorScale( ( 0, 0, 1 ), 3 ), 0,5 );
+	}
+	self.chest.zbarrier notify( "box_hacked_rerespin" );
+	self.chest.box_rerespun = 1;
+	self thread fake_weapon_powerup_thread( self.chest.zbarrier.weapon_model, self.chest.zbarrier.weapon_model_dw );
+}
+
+fake_weapon_powerup_thread( weapon1, weapon2 )
+{
+	weapon1 endon( "death" );
+	playfxontag( level._effect[ "powerup_on_solo" ], weapon1, "tag_origin" );
+	playsoundatposition( "zmb_spawn_powerup", weapon1.origin );
+	weapon1 playloopsound( "zmb_spawn_powerup_loop" );
+	self thread fake_weapon_powerup_timeout( weapon1, weapon2 );
+	while ( isDefined( weapon1 ) )
+	{
+		waittime = randomfloatrange( 2.5, 5 );
+		yaw = randomint( 360 );
+		if ( yaw > 300 )
+		{
+			yaw = 300;
+		}
+		else
+		{
+			if ( yaw < 60 )
+			{
+				yaw = 60;
+			}
+		}
+		yaw = weapon1.angles[ 1 ] + yaw;
+		weapon1 rotateto( ( -60 + randomint( 120 ), yaw, -45 + randomint( 90 ) ), waittime, waittime * 0.5, waittime * 0.5 );
+		if ( isDefined( weapon2 ) )
+		{
+			weapon2 rotateto( ( -60 + randomint( 120 ), yaw, -45 + randomint( 90 ) ), waittime, waittime * 0.5, waittime * 0.5 );
+		}
+		wait randomfloat( waittime - 0,1 );
+	}
+}
+
+fake_weapon_powerup_timeout( weapon1, weapon2 )
+{
+	weapon1 endon( "death" );
+	wait 15;
+	i = 0;
+	while ( i < 40 )
+	{
+		if ( i % 2 )
+		{
+			weapon1 hide();
+			if ( isDefined( weapon2 ) )
+			{
+				weapon2 hide();
+			}
+		}
+		else
+		{
+			weapon1 show();
+			if ( isDefined( weapon2 ) )
+			{
+				weapon2 hide();
+			}
+		}
+		if ( i < 15 )
+		{
+			wait 0.5;
+			i++;
+			continue;
+		}
+		else if ( i < 25 )
+		{
+			wait 0.25;
+			i++;
+			continue;
+		}
+		else
+		{
+			wait 0.1;
+		}
+		i++;
+	}
+	self.chest notify( "trigger" );
+	if ( isDefined( weapon1 ) )
+	{
+		weapon1 delete();
+	}
+	if ( isDefined( weapon2 ) )
+	{
+		weapon2 delete();
+	}
+}
+
+init_summon_hacks()
+{
+	chests = getstructarray( "treasure_chest_use", "targetname" );
+	i = 0;
+	while ( i < chests.size )
+	{
+		chest = chests[ i ];
+		chest init_summon_box( chest.hidden );
+		i++;
+	}
+}
+
+init_summon_box( create )
+{
+	if ( create )
+	{
+		if ( isDefined( self._summon_hack_struct ) )
+		{
+			maps/mp/zombies/_zm_equip_hacker::deregister_hackable_struct( self._summon_hack_struct );
+			self._summon_hack_struct = undefined;
+		}
+		struct = spawnstruct();
+		struct.origin = self.chest_box.origin + vectorScale( ( 0, 0, 1 ), 24 );
+		struct.radius = 48;
+		struct.height = 72;
+		struct.script_int = 1200;
+		struct.script_float = 5;
+		struct.no_bullet_trace = 1;
+		struct.chest = self;
+		self._summon_hack_struct = struct;
+		maps/mp/zombies/_zm_equip_hacker::register_pooled_hackable_struct( struct, ::summon_box, ::summon_box_qualifier );
+	}
+	else
+	{
+		if ( isDefined( self._summon_hack_struct ) )
+		{
+			maps/mp/zombies/_zm_equip_hacker::deregister_hackable_struct( self._summon_hack_struct );
+			self._summon_hack_struct = undefined;
+		}
+	}
+}
+
+summon_box_thread( hacker )
+{
+	self.chest.last_hacked_round = level.round_number + randomintrange( 2, 5 );
+	maps/mp/zombies/_zm_equip_hacker::deregister_hackable_struct( self );
+	self.chest thread maps/mp/zombies/_zm_magicbox::show_chest();
+	self.chest notify( "kill_chest_think" );
+	self.chest.auto_open = 1;
+	self.chest.no_charge = 1;
+	self.chest.no_fly_away = 1;
+	self.chest.forced_user = hacker;
+	self.chest thread maps/mp/zombies/_zm_magicbox::treasure_chest_think();
+	self.chest.zbarrier waittill( "closed" );
+	self.chest.forced_user = undefined;
+	self.chest.auto_open = undefined;
+	self.chest.no_charge = undefined;
+	self.chest.no_fly_away = undefined;
+	self.chest thread maps/mp/zombies/_zm_magicbox::hide_chest();
+}
+
+summon_box( hacker )
+{
+	self thread summon_box_thread( hacker );
+	if ( isDefined( hacker ) )
+	{
+		hacker thread maps/mp/zombies/_zm_audio::create_and_play_dialog( "general", "hack_box" );
+	}
+}
+
+summon_box_qualifier( player )
+{
+	if ( self.chest.last_hacked_round > level.round_number )
+	{
+		return 0;
+	}
+	if ( isDefined( self.chest.zbarrier.chest_moving ) && self.chest.zbarrier.chest_moving )
+	{
+		return 0;
+	}
+	return 1;
+}
+

patch_zm/maps/mp/zombies/NoKnownErrors/_zm_hackables_doors.gsc

@@ -0,0 +1,108 @@
+#include maps/mp/zombies/_zm_equip_hacker;
+#include maps/mp/zombies/_zm_blockers;
+#include maps/mp/zombies/_zm_utility;
+#include maps/mp/_utility;
+#include common_scripts/utility;
+
+door_struct_debug()
+{
+	while ( 1 )
+	{
+		wait 0.1;
+		origin = self.origin;
+		point = origin;
+		i = 1;
+		while ( i < 5 )
+		{
+			point = origin + ( anglesToForward( self.door.angles ) * ( i * 2 ) );
+			passed = bullettracepassed( point, origin, 0, undefined );
+			color = vectorScale( ( 1, 0, 0 ), 255 );
+			if ( !passed )
+			{
+				color = vectorScale( ( 1, 0, 0 ), 255 );
+			}
+/#
+			print3d( point, "+", color, 1, 1 );
+#/
+			i++;
+		}
+	}
+}
+
+hack_doors( targetname, door_activate_func )
+{
+	if ( !isDefined( targetname ) )
+	{
+		targetname = "zombie_door";
+	}
+	doors = getentarray( targetname, "targetname" );
+	if ( !isDefined( door_activate_func ) )
+	{
+		door_activate_func = ::maps/mp/zombies/_zm_blockers::door_opened;
+	}
+	i = 0;
+	while ( i < doors.size )
+	{
+		door = doors[ i ];
+		struct = spawnstruct();
+		struct.origin = door.origin + ( anglesToForward( door.angles ) * 2 );
+		struct.radius = 48;
+		struct.height = 72;
+		struct.script_float = 32.7;
+		struct.script_int = 200;
+		struct.door = door;
+		struct.no_bullet_trace = 1;
+		struct.door_activate_func = door_activate_func;
+		trace_passed = 0;
+		door thread hide_door_buy_when_hacker_active( struct );
+		maps/mp/zombies/_zm_equip_hacker::register_pooled_hackable_struct( struct, ::door_hack );
+		door thread watch_door_for_open( struct );
+		i++;
+	}
+}
+
+hide_door_buy_when_hacker_active( door_struct )
+{
+	self endon( "death" );
+	self endon( "door_hacked" );
+	self endon( "door_opened" );
+	maps/mp/zombies/_zm_equip_hacker::hide_hint_when_hackers_active();
+}
+
+watch_door_for_open( door_struct )
+{
+	self waittill( "door_opened" );
+	self endon( "door_hacked" );
+	remove_all_door_hackables_that_target_door( door_struct.door );
+}
+
+door_hack( hacker )
+{
+	self.door notify( "door_hacked" );
+	self.door notify( "kill_door_think" );
+	remove_all_door_hackables_that_target_door( self.door );
+	self.door [[ self.door_activate_func ]]();
+	self.door._door_open = 1;
+}
+
+remove_all_door_hackables_that_target_door( door )
+{
+	candidates = [];
+	i = 0;
+	while ( i < level._hackable_objects.size )
+	{
+		obj = level._hackable_objects[ i ];
+		if ( isDefined( obj.door ) && obj.door.target == door.target )
+		{
+			candidates[ candidates.size ] = obj;
+		}
+		i++;
+	}
+	i = 0;
+	while ( i < candidates.size )
+	{
+		maps/mp/zombies/_zm_equip_hacker::deregister_hackable_struct( candidates[ i ] );
+		i++;
+	}
+}
+

patch_zm/maps/mp/zombies/NoKnownErrors/_zm_hackables_packapunch.gsc

@@ -0,0 +1,46 @@
+#include maps/mp/zombies/_zm_equip_hacker;
+#include maps/mp/zombies/_zm_utility;
+#include maps/mp/_utility;
+#include common_scripts/utility;
+
+hack_packapunch()
+{
+	vending_weapon_upgrade_trigger = getentarray( "specialty_weapupgrade", "script_noteworthy" );
+	perk = getent( vending_weapon_upgrade_trigger[ 0 ].target, "targetname" );
+	if ( isDefined( perk ) )
+	{
+		struct = spawnstruct();
+		struct.origin = perk.origin + ( anglesToRight( perk.angles ) * 26 ) + vectorScale( ( 0, 0, 1 ), 48 );
+		struct.radius = 48;
+		struct.height = 48;
+		struct.script_float = 5;
+		struct.script_int = -1000;
+		level._pack_hack_struct = struct;
+		maps/mp/zombies/_zm_equip_hacker::register_pooled_hackable_struct( level._pack_hack_struct, ::packapunch_hack );
+		level._pack_hack_struct pack_trigger_think();
+	}
+}
+
+pack_trigger_think()
+{
+	if ( !flag_exists( "enter_nml" ) )
+	{
+		return;
+	}
+	while ( 1 )
+	{
+		flag_wait( "enter_nml" );
+		self.script_int = -1000;
+		while ( flag( "enter_nml" ) )
+		{
+			wait 1;
+		}
+	}
+}
+
+packapunch_hack( hacker )
+{
+	maps/mp/zombies/_zm_equip_hacker::deregister_hackable_struct( level._pack_hack_struct );
+	level._pack_hack_struct.script_int = 0;
+	level notify( "packapunch_hacked" );
+}

patch_zm/maps/mp/zombies/NoKnownErrors/_zm_hackables_perks.gsc

@@ -0,0 +1,87 @@
+#include maps/mp/zombies/_zm_equip_hacker;
+#include maps/mp/zombies/_zm_utility;
+#include maps/mp/_utility;
+#include common_scripts/utility;
+
+hack_perks()
+{
+	vending_triggers = getentarray( "zombie_vending", "targetname" );
+	i = 0;
+	while ( i < vending_triggers.size )
+	{
+		struct = spawnstruct();
+		if ( isDefined( vending_triggers[ i ].machine ) )
+		{
+			machine[ 0 ] = vending_triggers[ i ].machine;
+		}
+		else
+		{
+			machine = getentarray( vending_triggers[ i ].target, "targetname" );
+		}
+		struct.origin = machine[ 0 ].origin + ( anglesToRight( machine[ 0 ].angles ) * 18 ) + vectorScale( ( 0, 0, 1 ), 48 );
+		struct.radius = 48;
+		struct.height = 64;
+		struct.script_float = 5;
+		while ( !isDefined( vending_triggers[ i ].cost ) )
+		{
+			wait 0.05;
+		}
+		struct.script_int = int( vending_triggers[ i ].cost * -1 );
+		struct.perk = vending_triggers[ i ];
+		if ( isDefined( level._hack_perks_override ) )
+		{
+			struct = struct [[ level._hack_perks_override ]]();
+		}
+		vending_triggers[ i ].hackable = struct;
+		maps/mp/zombies/_zm_equip_hacker::register_pooled_hackable_struct( struct, ::perk_hack, ::perk_hack_qualifier );
+		i++;
+	}
+	level._solo_revive_machine_expire_func = ::solo_revive_expire_func;
+}
+
+solo_revive_expire_func()
+{
+	if ( isDefined( self.hackable ) )
+	{
+		maps/mp/zombies/_zm_equip_hacker::deregister_hackable_struct( self.hackable );
+		self.hackable = undefined;
+	}
+}
+
+perk_hack_qualifier( player )
+{
+	if ( isDefined( player._retain_perks ) )
+	{
+		return 0;
+	}
+	if ( isDefined( self.perk ) && isDefined( self.perk.script_noteworthy ) )
+	{
+		if ( player hasperk( self.perk.script_noteworthy ) )
+		{
+			return 1;
+		}
+	}
+	return 0;
+}
+
+perk_hack( hacker )
+{
+	if ( flag( "solo_game" ) && self.perk.script_noteworthy == "specialty_quickrevive" )
+	{
+		hacker.lives--;
+
+	}
+	hacker notify( self.perk.script_noteworthy + "_stop" );
+	hacker playsoundtoplayer( "evt_perk_throwup", hacker );
+	while ( isDefined( hacker.perk_hud ) )
+	{
+		keys = getarraykeys( hacker.perk_hud );
+		i = 0;
+		while ( i < hacker.perk_hud.size )
+		{
+			hacker.perk_hud[ keys[ i ] ].x = i * 30;
+			i++;
+		}
+	}
+}
+

patch_zm/maps/mp/zombies/NoKnownErrors/_zm_hackables_powerups.gsc

@@ -0,0 +1,79 @@
+#include maps/mp/zombies/_zm_powerups;
+#include maps/mp/zombies/_zm_net;
+#include maps/mp/zombies/_zm_equip_hacker;
+#include maps/mp/zombies/_zm_utility;
+#include maps/mp/_utility;
+#include common_scripts/utility;
+
+unhackable_powerup( name )
+{
+	ret = 0;
+	switch( name )
+	{
+		case "bonus_points_player":
+		case "bonus_points_team":
+		case "lose_points_team":
+		case "random_weapon":
+			ret = 1;
+			break;
+	}
+	return ret;
+}
+
+hack_powerups()
+{
+	while ( 1 )
+	{
+		level waittill( "powerup_dropped", powerup );
+		if ( !unhackable_powerup( powerup.powerup_name ) )
+		{
+			struct = spawnstruct();
+			struct.origin = powerup.origin;
+			struct.radius = 65;
+			struct.height = 72;
+			struct.script_float = 5;
+			struct.script_int = 5000;
+			struct.powerup = powerup;
+			powerup thread powerup_pickup_watcher( struct );
+			maps/mp/zombies/_zm_equip_hacker::register_pooled_hackable_struct( struct, ::powerup_hack );
+		}
+	}
+}
+
+powerup_pickup_watcher( powerup_struct )
+{
+	self endon( "hacked" );
+	self waittill( "death" );
+	maps/mp/zombies/_zm_equip_hacker::deregister_hackable_struct( powerup_struct );
+}
+
+powerup_hack( hacker )
+{
+	self.powerup notify( "hacked" );
+	if ( isDefined( self.powerup.zombie_grabbable ) && self.powerup.zombie_grabbable )
+	{
+		self.powerup notify( "powerup_timedout" );
+		origin = self.powerup.origin;
+		self.powerup delete();
+		self.powerup = maps/mp/zombies/_zm_net::network_safe_spawn( "powerup", 1, "script_model", origin );
+		if ( isDefined( self.powerup ) )
+		{
+			self.powerup maps/mp/zombies/_zm_powerups::powerup_setup( "full_ammo" );
+			self.powerup thread maps/mp/zombies/_zm_powerups::powerup_timeout();
+			self.powerup thread maps/mp/zombies/_zm_powerups::powerup_wobble();
+			self.powerup thread maps/mp/zombies/_zm_powerups::powerup_grab();
+		}
+	}
+	else
+	{
+		if ( self.powerup.powerup_name == "full_ammo" )
+		{
+			self.powerup maps/mp/zombies/_zm_powerups::powerup_setup( "fire_sale" );
+		}
+		else
+		{
+			self.powerup maps/mp/zombies/_zm_powerups::powerup_setup( "full_ammo" );
+		}
+	}
+	maps/mp/zombies/_zm_equip_hacker::deregister_hackable_struct( self );
+}

patch_zm/maps/mp/zombies/NoKnownErrors/_zm_hackables_wallbuys.gsc

@@ -0,0 +1,55 @@
+#include maps/mp/zombies/_zm_equip_hacker;
+#include maps/mp/zombies/_zm_utility;
+#include maps/mp/_utility;
+#include common_scripts/utility;
+
+hack_wallbuys()
+{
+	weapon_spawns = getstructarray( "weapon_upgrade", "targetname" );
+	i = 0;
+	while ( i < weapon_spawns.size )
+	{
+		if ( weapontype( weapon_spawns[ i ].zombie_weapon_upgrade ) == "grenade" )
+		{
+			i++;
+			continue;
+		}
+		else if ( weapontype( weapon_spawns[ i ].zombie_weapon_upgrade ) == "melee" )
+		{
+			i++;
+			continue;
+		}
+		else if ( weapontype( weapon_spawns[ i ].zombie_weapon_upgrade ) == "mine" )
+		{
+			i++;
+			continue;
+		}
+		else if ( weapontype( weapon_spawns[ i ].zombie_weapon_upgrade ) == "bomb" )
+		{
+			i++;
+			continue;
+		}
+		else
+		{
+			struct = spawnstruct();
+			struct.origin = weapon_spawns[ i ].origin;
+			struct.radius = 48;
+			struct.height = 48;
+			struct.script_float = 2;
+			struct.script_int = 3000;
+			struct.wallbuy = weapon_spawns[ i ];
+			maps/mp/zombies/_zm_equip_hacker::register_pooled_hackable_struct( struct, ::wallbuy_hack );
+		}
+		i++;
+	}
+	bowie_triggers = getentarray( "bowie_upgrade", "targetname" );
+	array_thread( bowie_triggers, ::maps/mp/zombies/_zm_equip_hacker::hide_hint_when_hackers_active );
+}
+
+wallbuy_hack( hacker )
+{
+	self.wallbuy.hacked = 1;
+	self.clientfieldname = ( self.wallbuy.zombie_weapon_upgrade + "_" ) + self.origin;
+	level setclientfield( self.clientfieldname, 2 );
+	maps/mp/zombies/_zm_equip_hacker::deregister_hackable_struct( self );
+}

patch_zm/maps/mp/zombies/NoKnownErrors/_zm_perk_electric_cherry.gsc

@@ -0,0 +1,400 @@
+#include maps/mp/zombies/_zm_ai_basic;
+#include maps/mp/animscripts/shared;
+#include maps/mp/zombies/_zm_score;
+#include maps/mp/zombies/_zm_perks;
+#include maps/mp/zombies/_zm_net;
+#include maps/mp/zombies/_zm_utility;
+#include common_scripts/utility;
+#include maps/mp/_utility;
+
+enable_electric_cherry_perk_for_level()
+{
+	register_perk_basic_info( "specialty_grenadepulldeath", "electric_cherry", 2000, &"ZM_PRISON_PERK_CHERRY", "zombie_perk_bottle_cherry" );
+	register_perk_precache_func( "specialty_grenadepulldeath", ::electic_cherry_precache );
+	register_perk_clientfields( "specialty_grenadepulldeath", ::electric_cherry_register_clientfield, ::electric_cherry_set_clientfield );
+	register_perk_threads( "specialty_grenadepulldeath", ::electric_cherry_reload_attack, ::electric_cherry_perk_lost );
+	register_perk_machine( "specialty_grenadepulldeath", ::electric_cherry_perk_machine_setup, ::electric_cherry_perk_machine_think );
+	register_perk_host_migration_func( "specialty_grenadepulldeath", ::electric_cherry_host_migration_func );
+	if ( isDefined( level.custom_electric_cherry_perk_threads ) && level.custom_electric_cherry_perk_threads )
+	{
+		level thread [[ level.custom_electric_cherry_perk_threads ]]();
+	}
+}
+
+init_electric_cherry()
+{
+	level.custom_laststand_func = ::electric_cherry_laststand;
+	set_zombie_var( "tesla_head_gib_chance", 50 );
+	registerclientfield( "allplayers", "electric_cherry_reload_fx", 9000, 2, "int" );
+}
+
+electic_cherry_precache()
+{
+	precacheitem( "zombie_perk_bottle_cherry" );
+	precacheshader( "specialty_fastreload_zombies" );
+	precachemodel( "p6_zm_vending_electric_cherry_off" );
+	precachemodel( "p6_zm_vending_electric_cherry_on" );
+	precachestring( &"ZM_PRISON_PERK_CHERRY" );
+	level._effect[ "electriccherry" ] = loadfx( "misc/fx_zombie_cola_on" );
+	level._effect[ "electric_cherry_explode" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_electric_cherry_down" );
+	level._effect[ "electric_cherry_reload_small" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_electric_cherry_sm" );
+	level._effect[ "electric_cherry_reload_medium" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_electric_cherry_player" );
+	level._effect[ "electric_cherry_reload_large" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_electric_cherry_lg" );
+	level._effect[ "tesla_shock" ] = loadfx( "maps/zombie/fx_zombie_tesla_shock" );
+	level._effect[ "tesla_shock_secondary" ] = loadfx( "maps/zombie/fx_zombie_tesla_shock_secondary" );
+}
+
+electric_cherry_register_clientfield()
+{
+	registerclientfield( "toplayer", "perk_electric_cherry", 9000, 1, "int" );
+}
+
+electric_cherry_set_clientfield( state )
+{
+	self setclientfieldtoplayer( "perk_electric_cherry", state );
+}
+
+electric_cherry_perk_machine_setup( use_trigger, perk_machine, bump_trigger, collision )
+{
+	use_trigger.script_sound = "mus_perks_cherry_jingle";
+	use_trigger.script_string = "electric_cherry_perk";
+	use_trigger.script_label = "mus_perks_cherry_sting";
+	use_trigger.target = "vending_electriccherry";
+	perk_machine.script_string = "electriccherry_perk";
+	perk_machine.targetname = "vendingelectric_cherry";
+	if ( isDefined( bump_trigger ) )
+	{
+		bump_trigger.script_string = "electriccherry_perk";
+	}
+}
+
+electric_cherry_perk_machine_think()
+{
+	init_electric_cherry();
+	while ( 1 )
+	{
+		machine = getentarray( "vendingelectric_cherry", "targetname" );
+		machine_triggers = getentarray( "vending_electriccherry", "target" );
+		i = 0;
+		while ( i < machine.size )
+		{
+			machine[ i ] setmodel( "p6_zm_vending_electric_cherry_off" );
+			i++;
+		}
+		level thread do_initial_power_off_callback( machine, "electriccherry" );
+		array_thread( machine_triggers, ::set_power_on, 0 );
+		level waittill( "electric_cherry_on" );
+		i = 0;
+		while ( i < machine.size )
+		{
+			machine[ i ] setmodel( "p6_zm_vending_electric_cherry_on" );
+			machine[ i ] vibrate( vectorScale( ( 0, -1, 0 ), 100 ), 0.3, 0.4, 3 );
+			machine[ i ] playsound( "zmb_perks_power_on" );
+			machine[ i ] thread perk_fx( "electriccherry" );
+			machine[ i ] thread play_loop_on_machine();
+			i++;
+		}
+		level notify( "specialty_grenadepulldeath_power_on" );
+		array_thread( machine_triggers, ::set_power_on, 1 );
+		level waittill( "electric_cherry_off" );
+		array_thread( machine, ::turn_perk_off );
+	}
+}
+
+electric_cherry_host_migration_func()
+{
+	a_electric_cherry_perk_machines = getentarray( "vending_electriccherry", "targetname" );
+	_a130 = a_electric_cherry_perk_machines;
+	_k130 = getFirstArrayKey( _a130 );
+	while ( isDefined( _k130 ) )
+	{
+		perk_machine = _a130[ _k130 ];
+		if ( isDefined( perk_machine.model ) && perk_machine.model == "p6_zm_vending_electric_cherry_on" )
+		{
+			perk_machine perk_fx( undefined, 1 );
+			perk_machine thread perk_fx( "electriccherry" );
+		}
+		_k130 = getNextArrayKey( _a130, _k130 );
+	}
+}
+
+electric_cherry_laststand()
+{
+	visionsetlaststand( "zombie_last_stand", 1 );
+	if ( isDefined( self ) )
+	{
+		playfx( level._effect[ "electric_cherry_explode" ], self.origin );
+		self playsound( "zmb_cherry_explode" );
+		self notify( "electric_cherry_start" );
+		wait 0.05;
+		a_zombies = get_round_enemy_array();
+		a_zombies = get_array_of_closest( self.origin, a_zombies, undefined, undefined, 500 );
+		i = 0;
+		while ( i < a_zombies.size )
+		{
+			if ( isalive( self ) )
+			{
+				
+				if ( a_zombies[ i ].health <= 1000 )
+				{
+					a_zombies[ i ] thread electric_cherry_death_fx();
+					if ( isDefined( self.cherry_kills ) )
+					{
+						self.cherry_kills++;
+					}
+					self maps/mp/zombies/_zm_score::add_to_player_score( 40 );	
+				}
+				else
+				{
+					a_zombies[ i ] thread electric_cherry_stun();
+					a_zombies[ i ] thread electric_cherry_shock_fx();
+				}	
+				wait 0.1;
+				a_zombies[ i ] dodamage( 1000, self.origin, self, self, "none" );
+			}
+			i++;
+		}
+		self notify( "electric_cherry_end" );
+	}
+}
+
+electric_cherry_death_fx()
+{
+	self endon( "death" );
+	tag = "J_SpineUpper";
+	fx = "tesla_shock";
+	if ( self.isdog )
+	{
+		tag = "J_Spine1";
+	}
+	self playsound( "zmb_elec_jib_zombie" );
+	network_safe_play_fx_on_tag( "tesla_death_fx", 2, level._effect[ fx ], self, tag );
+	if ( isDefined( self.tesla_head_gib_func ) && !self.head_gibbed )
+	{
+		[[ self.tesla_head_gib_func ]]();
+	}
+}
+
+electric_cherry_shock_fx()
+{
+	self endon( "death" );
+	tag = "J_SpineUpper";
+	fx = "tesla_shock_secondary";
+	if ( self.isdog )
+	{
+		tag = "J_Spine1";
+	}
+	self playsound( "zmb_elec_jib_zombie" );
+	network_safe_play_fx_on_tag( "tesla_shock_fx", 2, level._effect[ fx ], self, tag );
+}
+
+electric_cherry_stun()
+{
+	self endon( "death" );
+	self notify( "stun_zombie" );
+	self endon( "stun_zombie" );
+	if ( self.health <= 0 )
+	{
+/#
+		iprintln( "trying to stun a dead zombie" );
+#/
+		return;
+	}
+	if ( self.ai_state != "find_flesh" )
+	{
+		return;
+	}
+	self.forcemovementscriptstate = 1;
+	self.ignoreall = 1;
+	i = 0;
+	while ( i < 2 )
+	{
+		self animscripted( self.origin, self.angles, "zm_afterlife_stun" );
+		self maps/mp/animscripts/shared::donotetracks( "stunned" );
+		i++;
+	}
+	self.forcemovementscriptstate = 0;
+	self.ignoreall = 0;
+	self setgoalpos( self.origin );
+	self thread maps/mp/zombies/_zm_ai_basic::find_flesh();
+}
+
+electric_cherry_reload_attack()
+{
+	self endon( "death" );
+	self endon( "disconnect" );
+	self endon( "stop_electric_cherry_reload_attack" );
+	self.wait_on_reload = [];
+	self.consecutive_electric_cherry_attacks = 0;
+	while ( 1 )
+	{
+		self waittill( "reload_start" );
+		str_current_weapon = self getcurrentweapon();
+		while ( isinarray( self.wait_on_reload, str_current_weapon ) )
+		{
+			continue;
+		}
+		self.wait_on_reload[ self.wait_on_reload.size ] = str_current_weapon;
+		self.consecutive_electric_cherry_attacks++;
+		n_clip_current = self getweaponammoclip( str_current_weapon );
+		n_clip_max = weaponclipsize( str_current_weapon );
+		n_fraction = n_clip_current / n_clip_max;
+		perk_radius = linear_map( n_fraction, 1, 0, 32, 128 );
+		perk_dmg = linear_map( n_fraction, 1, 0, 1, 1045 );
+		self thread check_for_reload_complete( str_current_weapon );
+		if ( isDefined( self ) )
+		{
+			switch( self.consecutive_electric_cherry_attacks )
+			{
+				case 0:
+				case 1:
+					n_zombie_limit = undefined;
+					break;
+				case 2:
+					n_zombie_limit = 8;
+					break;
+				case 3:
+					n_zombie_limit = 4;
+					break;
+				case 4:
+					n_zombie_limit = 2;
+					break;
+				case default:
+					n_zombie_limit = 0;
+			}
+			self thread electric_cherry_cooldown_timer( str_current_weapon );
+			if ( isDefined( n_zombie_limit ) && n_zombie_limit == 0 )
+			{
+				continue;
+			}
+			self thread electric_cherry_reload_fx( n_fraction );
+			self notify( "electric_cherry_start" );
+			self playsound( "zmb_cherry_explode" );
+			a_zombies = get_round_enemy_array();
+			a_zombies = get_array_of_closest( self.origin, a_zombies, undefined, undefined, perk_radius );
+			n_zombies_hit = 0;
+			i = 0;
+			while ( i < a_zombies.size )
+			{
+				if ( isalive( self ) )
+				{
+					if ( isDefined( n_zombie_limit ) )
+					{
+						if ( n_zombies_hit < n_zombie_limit )
+						{
+							n_zombies_hit++;	
+						}
+						else 
+						{
+							break;
+						}
+					}
+					if ( a_zombies[ i ].health <= perk_dmg )
+					{
+						a_zombies[ i ] thread electric_cherry_death_fx();
+						if ( isDefined( self.cherry_kills ) )
+						{
+							self.cherry_kills++;
+						}
+						self maps/mp/zombies/_zm_score::add_to_player_score( 40 );
+					}
+					else
+					{
+						if ( !isDefined( a_zombies[ i ].is_brutus ) )
+						{
+							a_zombies[ i ] thread electric_cherry_stun();
+						}
+						a_zombies[ i ] thread electric_cherry_shock_fx();
+					}
+					wait 0.1;
+					a_zombies[ i ] dodamage( perk_dmg, self.origin, self, self, "none" );
+				}
+				i++;
+			}
+			self notify( "electric_cherry_end" );
+		}
+	}
+}
+
+electric_cherry_cooldown_timer( str_current_weapon )
+{
+	self notify( "electric_cherry_cooldown_started" );
+	self endon( "electric_cherry_cooldown_started" );
+	self endon( "death" );
+	self endon( "disconnect" );
+	n_reload_time = weaponreloadtime( str_current_weapon );
+	if ( self hasperk( "specialty_fastreload" ) )
+	{
+		n_reload_time *= getDvarFloat( "perk_weapReloadMultiplier" );
+	}
+	n_cooldown_time = n_reload_time + 3;
+	wait n_cooldown_time;
+	self.consecutive_electric_cherry_attacks = 0;
+}
+
+check_for_reload_complete( weapon )
+{
+	self endon( "death" );
+	self endon( "disconnect" );
+	self endon( "player_lost_weapon_" + weapon );
+	self thread weapon_replaced_monitor( weapon );
+	while ( 1 )
+	{
+		self waittill( "reload" );
+		str_current_weapon = self getcurrentweapon();
+		if ( str_current_weapon == weapon )
+		{
+			arrayremovevalue( self.wait_on_reload, weapon );
+			self notify( "weapon_reload_complete_" + weapon );
+			return;
+		}
+		else
+		{
+		}
+	}
+}
+
+weapon_replaced_monitor( weapon )
+{
+	self endon( "death" );
+	self endon( "disconnect" );
+	self endon( "weapon_reload_complete_" + weapon );
+	while ( 1 )
+	{
+		self waittill( "weapon_change" );
+		primaryweapons = self getweaponslistprimaries();
+		if ( !isinarray( primaryweapons, weapon ) )
+		{
+			self notify( "player_lost_weapon_" + weapon );
+			arrayremovevalue( self.wait_on_reload, weapon );
+			return;
+		}
+		else
+		{
+		}
+	}
+}
+
+electric_cherry_reload_fx( n_fraction )
+{
+	if ( n_fraction >= 0.67 )
+	{
+		self setclientfield( "electric_cherry_reload_fx", 1 );
+	}
+	else if ( n_fraction >= 0.33 && n_fraction < 0.67 )
+	{
+		self setclientfield( "electric_cherry_reload_fx", 2 );
+	}
+	else
+	{
+		self setclientfield( "electric_cherry_reload_fx", 3 );
+	}
+	wait 1;
+	self setclientfield( "electric_cherry_reload_fx", 0 );
+}
+
+electric_cherry_perk_lost()
+{
+	self notify( "stop_electric_cherry_reload_attack" );
+}
+

patch_zm/maps/mp/zombies/NoKnownErrors/_zm_pers_upgrades.gsc

@@ -0,0 +1,685 @@
+#include maps/mp/zombies/_zm_pers_upgrades_functions;
+#include maps/mp/zombies/_zm_perks;
+#include maps/mp/zombies/_zm_powerups;
+#include maps/mp/zombies/_zm_stats;
+#include maps/mp/zombies/_zm_pers_upgrades;
+#include maps/mp/zombies/_zm_pers_upgrades_system;
+#include maps/mp/zombies/_zm_utility;
+#include maps/mp/_utility;
+#include common_scripts/utility;
+
+pers_upgrade_init()
+{
+	setup_pers_upgrade_boards();
+	setup_pers_upgrade_revive();
+	setup_pers_upgrade_multi_kill_headshots();
+	setup_pers_upgrade_cash_back();
+	setup_pers_upgrade_insta_kill();
+	setup_pers_upgrade_jugg();
+	setup_pers_upgrade_carpenter();
+	setup_pers_upgrade_flopper();
+	setup_pers_upgrade_perk_lose();
+	setup_pers_upgrade_pistol_points();
+	setup_pers_upgrade_double_points();
+	setup_pers_upgrade_sniper();
+	setup_pers_upgrade_box_weapon();
+	setup_pers_upgrade_nube();
+	level thread pers_upgrades_monitor();
+}
+
+pers_abilities_init_globals()
+{
+	self.successful_revives = 0;
+	self.failed_revives = 0;
+	self.failed_cash_back_prones = 0;
+	self.pers[ "last_headshot_kill_time" ] = getTime();
+	self.pers[ "zombies_multikilled" ] = 0;
+	self.non_headshot_kill_counter = 0;
+	if ( isDefined( level.pers_upgrade_box_weapon ) && level.pers_upgrade_box_weapon )
+	{
+		self.pers_box_weapon_awarded = undefined;
+	}
+	if ( isDefined( level.pers_upgrade_nube ) && level.pers_upgrade_nube )
+	{
+		self thread pers_nube_unlock_watcher();
+	}
+}
+
+is_pers_system_active()
+{
+	if ( !is_classic() )
+	{
+		return 0;
+	}
+	if ( is_pers_system_disabled() )
+	{
+		return 0;
+	}
+	return 1;
+}
+
+is_pers_system_disabled()
+{
+	if ( level flag_exists( "sq_minigame_active" ) && flag( "sq_minigame_active" ) )
+	{
+		return 1;
+	}
+	return 0;
+}
+
+setup_pers_upgrade_boards()
+{
+	if ( isDefined( level.pers_upgrade_boards ) && level.pers_upgrade_boards )
+	{
+		level.pers_boarding_round_start = 10;
+		level.pers_boarding_number_of_boards_required = 74;
+		pers_register_upgrade( "board", ::pers_upgrade_boards_active, "pers_boarding", level.pers_boarding_number_of_boards_required, 0 );
+	}
+}
+
+setup_pers_upgrade_revive()
+{
+	if ( isDefined( level.pers_upgrade_revive ) && level.pers_upgrade_revive )
+	{
+		level.pers_revivenoperk_number_of_revives_required = 17;
+		level.pers_revivenoperk_number_of_chances_to_keep = 1;
+		pers_register_upgrade( "revive", ::pers_upgrade_revive_active, "pers_revivenoperk", level.pers_revivenoperk_number_of_revives_required, 1 );
+	}
+}
+
+setup_pers_upgrade_multi_kill_headshots()
+{
+	if ( isDefined( level.pers_upgrade_multi_kill_headshots ) && level.pers_upgrade_multi_kill_headshots )
+	{
+		level.pers_multikill_headshots_required = 5;
+		level.pers_multikill_headshots_upgrade_reset_counter = 25;
+		pers_register_upgrade( "multikill_headshots", ::pers_upgrade_headshot_active, "pers_multikill_headshots", level.pers_multikill_headshots_required, 0 );
+	}
+}
+
+setup_pers_upgrade_cash_back()
+{
+	if ( isDefined( level.pers_upgrade_cash_back ) && level.pers_upgrade_cash_back )
+	{
+		level.pers_cash_back_num_perks_required = 50;
+		level.pers_cash_back_perk_buys_prone_required = 15;
+		level.pers_cash_back_failed_prones = 1;
+		level.pers_cash_back_money_reward = 1000;
+		pers_register_upgrade( "cash_back", ::pers_upgrade_cash_back_active, "pers_cash_back_bought", level.pers_cash_back_num_perks_required, 0 );
+		add_pers_upgrade_stat( "cash_back", "pers_cash_back_prone", level.pers_cash_back_perk_buys_prone_required );
+	}
+}
+
+setup_pers_upgrade_insta_kill()
+{
+	if ( isDefined( level.pers_upgrade_insta_kill ) && level.pers_upgrade_insta_kill )
+	{
+		level.pers_insta_kill_num_required = 2;
+		level.pers_insta_kill_upgrade_active_time = 18;
+		pers_register_upgrade( "insta_kill", ::pers_upgrade_insta_kill_active, "pers_insta_kill", level.pers_insta_kill_num_required, 0 );
+	}
+}
+
+setup_pers_upgrade_jugg()
+{
+	if ( isDefined( level.pers_upgrade_jugg ) && level.pers_upgrade_jugg )
+	{
+		level.pers_jugg_hit_and_die_total = 3;
+		level.pers_jugg_hit_and_die_round_limit = 2;
+		level.pers_jugg_round_reached_max = 1;
+		level.pers_jugg_round_lose_target = 15;
+		level.pers_jugg_upgrade_health_bonus = 90;
+		pers_register_upgrade( "jugg", ::pers_upgrade_jugg_active, "pers_jugg", level.pers_jugg_hit_and_die_total, 0 );
+	}
+}
+
+setup_pers_upgrade_carpenter()
+{
+	if ( isDefined( level.pers_upgrade_carpenter ) && level.pers_upgrade_carpenter )
+	{
+		level.pers_carpenter_zombie_kills = 1;
+		pers_register_upgrade( "carpenter", ::pers_upgrade_carpenter_active, "pers_carpenter", level.pers_carpenter_zombie_kills, 0 );
+	}
+}
+
+setup_pers_upgrade_flopper()
+{
+	if ( isDefined( level.pers_upgrade_flopper ) && level.pers_upgrade_flopper )
+	{
+		level.pers_flopper_damage_counter = 6;
+		level.pers_flopper_counter = 1;
+		level.pers_flopper_min_fall_damage_activate = 30;
+		level.pers_flopper_min_fall_damage_deactivate = 50;
+		pers_register_upgrade( "flopper", ::pers_upgrade_flopper_active, "pers_flopper_counter", level.pers_flopper_counter, 0 );
+	}
+}
+
+setup_pers_upgrade_perk_lose()
+{
+	if ( isDefined( level.pers_upgrade_perk_lose ) && level.pers_upgrade_perk_lose )
+	{
+		level.pers_perk_round_reached_max = 6;
+		level.pers_perk_lose_counter = 3;
+		pers_register_upgrade( "perk_lose", ::pers_upgrade_perk_lose_active, "pers_perk_lose_counter", level.pers_perk_lose_counter, 0 );
+	}
+}
+
+setup_pers_upgrade_pistol_points()
+{
+	if ( isDefined( level.pers_upgrade_pistol_points ) && level.pers_upgrade_pistol_points )
+	{
+		level.pers_pistol_points_num_kills_in_game = 8;
+		level.pers_pistol_points_accuracy = 0.25;
+		level.pers_pistol_points_counter = 1;
+		pers_register_upgrade( "pistol_points", ::pers_upgrade_pistol_points_active, "pers_pistol_points_counter", level.pers_pistol_points_counter, 0 );
+	}
+}
+
+setup_pers_upgrade_double_points()
+{
+	if ( isDefined( level.pers_upgrade_double_points ) && level.pers_upgrade_double_points )
+	{
+		level.pers_double_points_score = 2500;
+		level.pers_double_points_counter = 1;
+		pers_register_upgrade( "double_points", ::pers_upgrade_double_points_active, "pers_double_points_counter", level.pers_double_points_counter, 0 );
+	}
+}
+
+setup_pers_upgrade_sniper()
+{
+	if ( isDefined( level.pers_upgrade_sniper ) && level.pers_upgrade_sniper )
+	{
+		level.pers_sniper_round_kills_counter = 5;
+		level.pers_sniper_kill_distance = 800;
+		level.pers_sniper_counter = 1;
+		level.pers_sniper_misses = 3;
+		pers_register_upgrade( "sniper", ::pers_upgrade_sniper_active, "pers_sniper_counter", level.pers_sniper_counter, 0 );
+	}
+}
+
+setup_pers_upgrade_box_weapon()
+{
+	if ( isDefined( level.pers_upgrade_box_weapon ) && level.pers_upgrade_box_weapon )
+	{
+		level.pers_box_weapon_counter = 5;
+		level.pers_box_weapon_lose_round = 10;
+		pers_register_upgrade( "box_weapon", ::pers_upgrade_box_weapon_active, "pers_box_weapon_counter", level.pers_box_weapon_counter, 0 );
+	}
+}
+
+setup_pers_upgrade_nube()
+{
+	if ( isDefined( level.pers_upgrade_nube ) && level.pers_upgrade_nube )
+	{
+		level.pers_nube_counter = 1;
+		level.pers_nube_lose_round = 10;
+		level.pers_numb_num_kills_unlock = 5;
+		pers_register_upgrade( "nube", ::pers_upgrade_nube_active, "pers_nube_counter", level.pers_nube_counter, 0 );
+	}
+}
+
+pers_upgrade_boards_active()
+{
+	self endon( "disconnect" );
+	last_round_number = level.round_number;
+	while ( 1 )
+	{
+		self waittill( "pers_stats_end_of_round" );
+		if ( level.round_number >= last_round_number )
+		{
+			if ( maps/mp/zombies/_zm_pers_upgrades::is_pers_system_active() )
+			{
+				if ( self.rebuild_barrier_reward == 0 )
+				{
+					self maps/mp/zombies/_zm_stats::zero_client_stat( "pers_boarding", 0 );
+					return;
+				}
+			}
+		}
+		last_round_number = level.round_number;
+	}
+}
+
+pers_upgrade_revive_active()
+{
+	self endon( "disconnect" );
+	while ( 1 )
+	{
+		self waittill( "player_failed_revive" );
+		if ( maps/mp/zombies/_zm_pers_upgrades::is_pers_system_active() )
+		{
+			if ( self.failed_revives >= level.pers_revivenoperk_number_of_chances_to_keep )
+			{
+				self maps/mp/zombies/_zm_stats::zero_client_stat( "pers_revivenoperk", 0 );
+				self.failed_revives = 0;
+				return;
+			}
+		}
+	}
+}
+
+pers_upgrade_headshot_active()
+{
+	self endon( "disconnect" );
+	while ( 1 )
+	{
+		self waittill( "zombie_death_no_headshot" );
+		if ( maps/mp/zombies/_zm_pers_upgrades::is_pers_system_active() )
+		{
+			self.non_headshot_kill_counter++;
+			if ( self.non_headshot_kill_counter >= level.pers_multikill_headshots_upgrade_reset_counter )
+			{
+				self maps/mp/zombies/_zm_stats::zero_client_stat( "pers_multikill_headshots", 0 );
+				self.non_headshot_kill_counter = 0;
+				return;
+			}
+		}
+	}
+}
+
+pers_upgrade_cash_back_active()
+{
+	self endon( "disconnect" );
+	wait 0.5;
+
+	wait 0.5;
+	while ( 1 )
+	{
+		self waittill( "cash_back_failed_prone" );
+		wait 0.1;
+
+		if ( maps/mp/zombies/_zm_pers_upgrades::is_pers_system_active() )
+		{
+			self.failed_cash_back_prones++;
+			if ( self.failed_cash_back_prones >= level.pers_cash_back_failed_prones )
+			{
+				self maps/mp/zombies/_zm_stats::zero_client_stat( "pers_cash_back_bought", 0 );
+				self maps/mp/zombies/_zm_stats::zero_client_stat( "pers_cash_back_prone", 0 );
+				self.failed_cash_back_prones = 0;
+				wait 0.4;
+
+				return;
+			}
+		}
+	}
+}
+
+pers_upgrade_insta_kill_active()
+{
+	self endon( "disconnect" );
+	wait 0.2;
+
+	wait 0.2;
+	while ( 1 )
+	{
+		self waittill( "pers_melee_swipe" );
+		if ( maps/mp/zombies/_zm_pers_upgrades::is_pers_system_active() )
+		{
+			if ( isDefined( level.pers_melee_swipe_zombie_swiper ) )
+			{
+				e_zombie = level.pers_melee_swipe_zombie_swiper;
+				if ( isalive( e_zombie ) && isDefined( e_zombie.is_zombie ) && e_zombie.is_zombie )
+				{
+					e_zombie.marked_for_insta_upgraded_death = 1;
+					e_zombie dodamage( e_zombie.health + 666, e_zombie.origin, self, self, "none", "MOD_PISTOL_BULLET", 0, "knife_zm" );
+				}
+				level.pers_melee_swipe_zombie_swiper = undefined;
+			}
+			break;
+		}
+		else
+		{
+		}
+	}
+	self maps/mp/zombies/_zm_stats::zero_client_stat( "pers_insta_kill", 0 );
+	self kill_insta_kill_upgrade_hud_icon();
+	wait 0.4;
+}
+
+is_insta_kill_upgraded_and_active()
+{
+	if ( maps/mp/zombies/_zm_pers_upgrades::is_pers_system_active() )
+	{
+		if ( self maps/mp/zombies/_zm_powerups::is_insta_kill_active() )
+		{
+			if ( isDefined( self.pers_upgrades_awarded[ "insta_kill" ] ) && self.pers_upgrades_awarded[ "insta_kill" ] )
+			{
+				return 1;
+			}
+		}
+	}
+	return 0;
+}
+
+pers_upgrade_jugg_active()
+{
+	self endon( "disconnect" );
+	wait 0.5;
+
+	wait 0.5;
+	self maps/mp/zombies/_zm_perks::perk_set_max_health_if_jugg( "jugg_upgrade", 1, 0 );
+	while ( 1 )
+	{
+		level waittill( "start_of_round" );
+		if ( maps/mp/zombies/_zm_pers_upgrades::is_pers_system_active() )
+		{
+			if ( level.round_number == level.pers_jugg_round_lose_target )
+			{
+				self maps/mp/zombies/_zm_stats::increment_client_stat( "pers_jugg_downgrade_count", 0 );
+				wait 0.5;
+				if ( self.pers[ "pers_jugg_downgrade_count" ] >= level.pers_jugg_round_reached_max )
+				{
+					break;
+				}
+			}
+		}
+		else
+		{
+		}
+	}
+	self maps/mp/zombies/_zm_perks::perk_set_max_health_if_jugg( "jugg_upgrade", 1, 1 );
+	self maps/mp/zombies/_zm_stats::zero_client_stat( "pers_jugg", 0 );
+	self maps/mp/zombies/_zm_stats::zero_client_stat( "pers_jugg_downgrade_count", 0 );
+}
+
+pers_upgrade_carpenter_active()
+{
+	self endon( "disconnect" );
+	wait 0.2;
+
+	wait 0.2;
+	level waittill( "carpenter_finished" );
+	self.pers_carpenter_kill = undefined;
+	while ( 1 )
+	{
+		self waittill( "carpenter_zombie_killed_check_finished" );
+		if ( maps/mp/zombies/_zm_pers_upgrades::is_pers_system_active() )
+		{
+			if ( !isDefined( self.pers_carpenter_kill ) )
+			{
+				break;
+			}
+			else
+			{
+
+			}
+			self.pers_carpenter_kill = undefined;
+		}
+	}
+	self maps/mp/zombies/_zm_stats::zero_client_stat( "pers_carpenter", 0 );
+	wait 0.4;
+}
+
+persistent_carpenter_ability_check()
+{
+	if ( isDefined( level.pers_upgrade_carpenter ) && level.pers_upgrade_carpenter )
+	{
+		self endon( "disconnect" );
+
+		if ( isDefined( self.pers_upgrades_awarded[ "carpenter" ] ) && self.pers_upgrades_awarded[ "carpenter" ] )
+		{
+			level.pers_carpenter_boards_active = 1;
+		}
+		self.pers_carpenter_zombie_check_active = 1;
+		self.pers_carpenter_kill = undefined;
+		carpenter_extra_time = 3;
+		carpenter_finished_start_time = undefined;
+		level.carpenter_finished_start_time = undefined;
+		while ( 1 )
+		{
+			if ( !is_pers_system_disabled() )
+			{
+				if ( !isDefined( level.carpenter_powerup_active ) )
+				{
+					if ( !isDefined( level.carpenter_finished_start_time ) )
+					{
+						level.carpenter_finished_start_time = getTime();
+					}
+					time = getTime();
+					dt = ( time - level.carpenter_finished_start_time ) / 1000;
+					if ( dt >= carpenter_extra_time )
+					{
+						break;
+					}
+				}
+				else if ( isDefined( self.pers_carpenter_kill ) )
+				{
+					if ( isDefined( self.pers_upgrades_awarded[ "carpenter" ] ) && self.pers_upgrades_awarded[ "carpenter" ] )
+					{
+						break;
+					}
+					else self maps/mp/zombies/_zm_stats::increment_client_stat( "pers_carpenter", 0 );
+				}
+			}
+			wait 0.05;
+		}
+		self notify( "carpenter_zombie_killed_check_finished" );
+		self.pers_carpenter_zombie_check_active = undefined;
+		level.pers_carpenter_boards_active = undefined;
+	}
+}
+
+pers_zombie_death_location_check( attacker, v_pos )
+{
+	if ( maps/mp/zombies/_zm_pers_upgrades::is_pers_system_active() )
+	{
+		if ( is_player_valid( attacker ) )
+		{
+			if ( isDefined( attacker.pers_carpenter_zombie_check_active ) )
+			{
+				if ( !check_point_in_playable_area( v_pos ) )
+				{
+					attacker.pers_carpenter_kill = 1;
+				}
+			}
+		}
+	}
+}
+
+insta_kill_pers_upgrade_icon()
+{
+	if ( self.zombie_vars[ "zombie_powerup_insta_kill_ug_on" ] )
+	{
+		self.zombie_vars[ "zombie_powerup_insta_kill_ug_time" ] = level.pers_insta_kill_upgrade_active_time;
+		return;
+	}
+	self.zombie_vars[ "zombie_powerup_insta_kill_ug_on" ] = 1;
+	self._show_solo_hud = 1;
+	self thread time_remaining_pers_upgrade();
+}
+
+time_remaining_pers_upgrade()
+{
+	self endon( "disconnect" );
+	self endon( "kill_insta_kill_upgrade_hud_icon" );
+	while ( self.zombie_vars[ "zombie_powerup_insta_kill_ug_time" ] >= 0 )
+	{
+		wait 0.05;
+		self.zombie_vars[ "zombie_powerup_insta_kill_ug_time" ] -= 0.05;
+	}
+	self kill_insta_kill_upgrade_hud_icon();
+}
+
+kill_insta_kill_upgrade_hud_icon()
+{
+	self.zombie_vars[ "zombie_powerup_insta_kill_ug_on" ] = 0;
+	self._show_solo_hud = 0;
+	self.zombie_vars[ "zombie_powerup_insta_kill_ug_time" ] = level.pers_insta_kill_upgrade_active_time;
+	self notify( "kill_insta_kill_upgrade_hud_icon" );
+}
+
+pers_upgrade_flopper_active()
+{
+	self endon( "disconnect" );
+	wait 0.5;
+	/*
+/#
+	iprintlnbold( "*** WE'VE GOT FLOPPER UPGRADED ***" );
+#/
+	*/
+	wait 0.5;
+	self thread maps/mp/zombies/_zm_pers_upgrades_functions::pers_upgrade_flopper_watcher();
+	self waittill( "pers_flopper_lost" );
+	/*
+/#
+	iprintlnbold( "*** OH NO: Lost FLOPPER Upgrade ***" );
+#/	
+	*/
+	self maps/mp/zombies/_zm_stats::zero_client_stat( "pers_flopper_counter", 0 );
+	self.pers_num_flopper_damages = 0;
+}
+
+pers_upgrade_perk_lose_active()
+{
+	self endon( "disconnect" );
+	wait 0.5;
+	/*
+/#
+	iprintlnbold( "*** WE'VE GOT PERK LOSE UPGRADED ***" );
+#/
+	*/
+	wait 0.5;
+	self.pers_perk_lose_start_round = level.round_number;
+	self waittill( "pers_perk_lose_lost" );
+	/*
+/#
+	iprintlnbold( "*** OH NO: Lost PERK LOSE Upgrade ***" );
+#/
+	*/
+	self maps/mp/zombies/_zm_stats::zero_client_stat( "pers_perk_lose_counter", 0 );
+}
+
+pers_upgrade_pistol_points_active()
+{
+	self endon( "disconnect" );
+	wait 0.5;
+	/*
+/#
+	iprintlnbold( "*** WE'VE GOT PISTOL POINTS UPGRADED ***" );
+#/
+	*/
+	wait 0.5;
+	while ( 1 )
+	{
+		self waittill( "pers_pistol_points_kill" );
+		accuracy = self maps/mp/zombies/_zm_pers_upgrades_functions::pers_get_player_accuracy();
+		if ( accuracy > level.pers_pistol_points_accuracy )
+		{
+			break;
+		}
+		else
+		{
+		}
+	}
+	/*
+/#
+	iprintlnbold( "*** OH NO: Lost PISTOL POINTS Upgrade ***" );
+#/
+	*/
+	self maps/mp/zombies/_zm_stats::zero_client_stat( "pers_pistol_points_counter", 0 );
+}
+
+pers_upgrade_double_points_active()
+{
+	self endon( "disconnect" );
+	wait 0.5;
+	/*
+/#
+	iprintlnbold( "*** WE'VE GOT DOUBLE POINTS UPGRADED ***" );
+#/
+	*/
+	wait 0.5;
+	self waittill( "double_points_lost" );
+	/*
+/#
+	iprintlnbold( "*** OH NO: Lost DOUBLE POINTS Upgrade ***" );
+#/
+	*/
+	self maps/mp/zombies/_zm_stats::zero_client_stat( "pers_double_points_counter", 0 );
+}
+
+pers_upgrade_sniper_active()
+{
+	self endon( "disconnect" );
+	wait 0.5;
+	/*
+/#
+	iprintlnbold( "*** WE'VE GOT SNIPER UPGRADED ***" );
+#/
+	*/
+	wait 0.5;
+	self waittill( "pers_sniper_lost" );
+	/*
+/#
+	iprintlnbold( "*** OH NO: Lost SNIPER Upgrade ***" );
+#/
+	*/
+	self maps/mp/zombies/_zm_stats::zero_client_stat( "pers_sniper_counter", 0 );
+}
+
+pers_upgrade_box_weapon_active()
+{
+	self endon( "disconnect" );
+	wait 0.5;
+	/*
+/#
+	iprintlnbold( "*** WE'VE GOT BOX WEAPON UPGRADED ***" );
+#/
+	*/
+	self thread maps/mp/zombies/_zm_pers_upgrades_functions::pers_magic_box_teddy_bear();
+	wait 0.5;
+	self.pers_box_weapon_awarded = 1;
+	while ( 1 )
+	{
+		level waittill( "start_of_round" );
+		if ( maps/mp/zombies/_zm_pers_upgrades::is_pers_system_active() )
+		{
+			if ( level.round_number >= level.pers_box_weapon_lose_round )
+			{
+				break;
+			}
+		}
+		else
+		{
+		}
+	}
+	/*
+/#
+	iprintlnbold( "*** OH NO: Lost BOX WEAPON Upgrade ***" );
+#/
+	*/
+	self maps/mp/zombies/_zm_stats::zero_client_stat( "pers_box_weapon_counter", 0 );
+}
+
+pers_upgrade_nube_active()
+{
+	self endon( "disconnect" );
+	wait 0.5;
+	/*
+/#
+	iprintlnbold( "*** WE'VE GOT NUBE UPGRADED ***" );
+#/
+	*/
+	wait 0.5;
+	while ( 1 )
+	{
+		level waittill( "start_of_round" );
+		if ( maps/mp/zombies/_zm_pers_upgrades::is_pers_system_active() )
+		{
+			if ( level.round_number >= level.pers_nube_lose_round )
+			{
+				break;
+			}
+		}
+		else
+		{
+		}
+	}
+	/*
+/#
+	iprintlnbold( "*** OH NO: Lost NUBE Upgrade ***" );
+#/
+	*/
+	self maps/mp/zombies/_zm_stats::zero_client_stat( "pers_nube_counter", 0 );
+}
+

patch_zm/maps/mp/zombies/NoKnownErrors/_zm_pers_upgrades_system.gsc

@@ -0,0 +1,278 @@
+#include maps/mp/zombies/_zm_stats;
+#include maps/mp/zombies/_zm;
+#include maps/mp/zombies/_zm_audio;
+#include maps/mp/zombies/_zm_utility;
+#include maps/mp/_utility;
+#include common_scripts/utility;
+
+pers_register_upgrade( name, upgrade_active_func, stat_name, stat_desired_value, game_end_reset_if_not_achieved )
+{
+	if ( !isDefined( level.pers_upgrades ) )
+	{
+		level.pers_upgrades = [];
+		level.pers_upgrades_keys = [];
+	}
+	if ( isDefined( level.pers_upgrades[ name ] ) )
+	{
+	/*
+/#
+		assert( 0, "A persistent upgrade is already registered for name: " + name );
+#/
+	*/
+	}
+	level.pers_upgrades_keys[ level.pers_upgrades_keys.size ] = name;
+	level.pers_upgrades[ name ] = spawnstruct();
+	level.pers_upgrades[ name ].stat_names = [];
+	level.pers_upgrades[ name ].stat_desired_values = [];
+	level.pers_upgrades[ name ].upgrade_active_func = upgrade_active_func;
+	level.pers_upgrades[ name ].game_end_reset_if_not_achieved = game_end_reset_if_not_achieved;
+	add_pers_upgrade_stat( name, stat_name, stat_desired_value );
+	/*
+/#
+	if ( isDefined( level.devgui_add_ability ) )
+	{
+		[[ level.devgui_add_ability ]]( name, upgrade_active_func, stat_name, stat_desired_value, game_end_reset_if_not_achieved );
+#/
+	}
+	*/
+}
+
+add_pers_upgrade_stat( name, stat_name, stat_desired_value )
+{
+	if ( !isDefined( level.pers_upgrades[ name ] ) )
+	{
+	/*
+/#
+		assert( 0, name + " - Persistent upgrade is not registered yet." );
+#/
+	*/
+	}
+	stats_size = level.pers_upgrades[ name ].stat_names.size;
+	level.pers_upgrades[ name ].stat_names[ stats_size ] = stat_name;
+	level.pers_upgrades[ name ].stat_desired_values[ stats_size ] = stat_desired_value;
+}
+
+pers_upgrades_monitor()
+{
+	if ( !isDefined( level.pers_upgrades ) )
+	{
+		return;
+	}
+	if ( !is_classic() )
+	{
+		return;
+	}
+	level thread wait_for_game_end();
+	while ( 1 )
+	{
+		waittillframeend;
+		players = getplayers();
+		player_index = 0;
+		while ( player_index < players.size )
+		{
+			player = players[ player_index ];
+			if ( is_player_valid( player ) && isDefined( player.stats_this_frame ) )
+			{
+				if ( !player.stats_this_frame.size && isDefined( player.pers_upgrade_force_test ) && !player.pers_upgrade_force_test )
+				{
+					player_index++;
+					continue;
+				}
+				else
+				{
+					pers_upgrade_index = 0;
+					while ( pers_upgrade_index < level.pers_upgrades_keys.size )
+					{
+						pers_upgrade = level.pers_upgrades[ level.pers_upgrades_keys[ pers_upgrade_index ] ];
+						is_stat_updated = player is_any_pers_upgrade_stat_updated( pers_upgrade );
+						if ( is_stat_updated )
+						{
+							should_award = player check_pers_upgrade( pers_upgrade );
+							if ( should_award )
+							{
+								if ( isDefined( player.pers_upgrades_awarded[ level.pers_upgrades_keys[ pers_upgrade_index ] ] ) && player.pers_upgrades_awarded[ level.pers_upgrades_keys[ pers_upgrade_index ] ] )
+								{
+									//this checks whether the play already has the upgrade
+									pers_upgrade_index++;
+									continue;
+								}
+								else
+								{
+									player.pers_upgrades_awarded[ level.pers_upgrades_keys[ pers_upgrade_index ] ] = 1;
+									if ( flag( "initial_blackscreen_passed" ) && !is_true( player.is_hotjoining ) )
+									{
+										type = "upgrade";
+										if ( isDefined( level.snd_pers_upgrade_force_type ) )
+										{
+											type = level.snd_pers_upgrade_force_type;
+										}
+										player playsoundtoplayer( "evt_player_upgrade", player );
+										if ( isDefined( level.pers_upgrade_vo_spoken ) && level.pers_upgrade_vo_spoken )
+										{
+											player delay_thread( 1, ::create_and_play_dialog, "general", type, undefined, level.snd_pers_upgrade_force_variant );
+										}
+										else
+										{
+											player delay_thread( 1, ::play_vox_to_player, "general", type, level.snd_pers_upgrade_force_variant );
+										}
+										if ( isDefined( player.upgrade_fx_origin ) )
+										{
+											fx_org = player.upgrade_fx_origin;
+											player.upgrade_fx_origin = undefined;
+										}
+										else
+										{
+											fx_org = player.origin;
+											v_dir = anglesToForward( player getplayerangles() );
+											v_up = anglesToUp( player getplayerangles() );
+											fx_org = ( fx_org + ( v_dir * 30 ) ) + ( v_up * 12 );
+										}
+										playfx( level._effect[ "upgrade_aquired" ], fx_org );
+										level thread maps/mp/zombies/_zm::disable_end_game_intermission( 1.5 );
+									}
+/#
+									player iprintlnbold( "Upgraded!" );
+#/
+									if ( isDefined( pers_upgrade.upgrade_active_func ) )
+									{
+										player thread [[ pers_upgrade.upgrade_active_func ]]();
+									}
+									pers_upgrade_index++;
+									continue;
+								}
+							}
+							else
+							{
+								if ( isDefined( player.pers_upgrades_awarded[ level.pers_upgrades_keys[ pers_upgrade_index ] ] ) && player.pers_upgrades_awarded[ level.pers_upgrades_keys[ pers_upgrade_index ] ] )
+								{
+									if ( flag( "initial_blackscreen_passed" ) && !is_true( player.is_hotjoining ) )
+									{
+										player playsoundtoplayer( "evt_player_downgrade", player );
+									}
+										/*
+/#
+										player iprintlnbold( "Downgraded!" );
+#/
+										*/
+								}
+								player.pers_upgrades_awarded[ level.pers_upgrades_keys[ pers_upgrade_index ] ] = 0;
+							}
+						}
+						pers_upgrade_index++;
+					}
+					player.pers_upgrade_force_test = 0;
+					player.stats_this_frame = [];
+				}
+			}
+			player_index++;
+		}
+		wait 0.05;
+	}
+}
+
+wait_for_game_end()
+{
+	if ( !is_classic() )
+	{
+		return;
+	}
+	level waittill( "end_game" );
+	players = getplayers();
+	player_index = 0;
+	while ( player_index < players.size )
+	{
+		player = players[ player_index ];
+		index = 0;
+		while ( index < level.pers_upgrades_keys.size )
+		{
+			str_name = level.pers_upgrades_keys[ index ];
+			game_end_reset_if_not_achieved = level.pers_upgrades[ str_name ].game_end_reset_if_not_achieved;
+			while ( isDefined( game_end_reset_if_not_achieved ) && game_end_reset_if_not_achieved == 1 )
+			{
+				while ( isDefined( player.pers_upgrades_awarded[ str_name ] ) && !player.pers_upgrades_awarded[ str_name ] )
+				{
+					stat_index = 0;
+					while ( stat_index < level.pers_upgrades[ str_name ].stat_names.size )
+					{
+						player maps/mp/zombies/_zm_stats::zero_client_stat( level.pers_upgrades[ str_name ].stat_names[ stat_index ], 0 );
+						stat_index++;
+					}
+				}
+			}
+			index++;
+		}
+		player_index++;
+	}
+}
+
+check_pers_upgrade( pers_upgrade )
+{
+	should_award = 1;
+	i = 0;
+	while ( i < pers_upgrade.stat_names.size )
+	{
+		stat_name = pers_upgrade.stat_names[ i ];
+		should_award = self check_pers_upgrade_stat( stat_name, pers_upgrade.stat_desired_values[ i ] );
+		if ( !should_award )
+		{
+			break;
+		}
+		else
+		{
+			i++;
+		}
+	}
+	return should_award;
+}
+
+is_any_pers_upgrade_stat_updated( pers_upgrade )
+{
+	if ( isDefined( self.pers_upgrade_force_test ) && self.pers_upgrade_force_test )
+	{
+		return 1;
+	}
+	result = 0;
+	i = 0;
+	while ( i < pers_upgrade.stat_names.size )
+	{
+		stat_name = pers_upgrade.stat_names[ i ];
+		if ( isDefined( self.stats_this_frame[ stat_name ] ) )
+		{
+			result = 1;
+			break;
+		}
+		else
+		{
+			i++;
+		}
+	}
+	return result;
+}
+
+check_pers_upgrade_stat( stat_name, stat_desired_value )
+{
+	should_award = 1;
+	current_stat_value = self maps/mp/zombies/_zm_stats::get_global_stat( stat_name );
+	if ( current_stat_value < stat_desired_value )
+	{
+		should_award = 0;
+	}
+	return should_award;
+}
+
+round_end()
+{
+	if ( !is_classic() )
+	{
+		return;
+	}
+	self notify( "pers_stats_end_of_round" );
+	if ( isDefined( self.pers[ "pers_max_round_reached" ] ) )
+	{
+		if ( level.round_number > self.pers[ "pers_max_round_reached" ] )
+		{
+			self maps/mp/zombies/_zm_stats::set_client_stat( "pers_max_round_reached", level.round_number, 0 );
+		}
+	}
+}
+

patch_zm/maps/mp/zombies/NoKnownErrors/_zm_score.gsc

@@ -0,0 +1,397 @@
+#include maps/mp/zombies/_zm_pers_upgrades_functions;
+#include maps/mp/zombies/_zm_stats;
+#include maps/mp/zombies/_zm_utility;
+#include maps/mp/_utility;
+#include common_scripts/utility;
+
+init()
+{
+	level.score_cf_info = [];
+	score_cf_register_info( "damage", 1, 7 );
+	score_cf_register_info( "death_normal", 1, 3 );
+	score_cf_register_info( "death_torso", 1, 3 );
+	score_cf_register_info( "death_neck", 1, 3 );
+	score_cf_register_info( "death_head", 1, 3 );
+	score_cf_register_info( "death_melee", 1, 3 );
+	if ( !level.createfx_enabled )
+	{
+		registerclientfield( "allplayers", "score_cf_double_points_active", 1, 1, "int" );
+	}
+}
+
+score_cf_register_info( name, version, max_count )
+{
+	if ( level.createfx_enabled )
+	{
+		return;
+	}
+	info = spawnstruct();
+	info.name = name;
+	info.cf_field = "score_cf_" + name;
+	info.version = version;
+	info.max_count = max_count;
+	info.bit_count = getminbitcountfornum( max_count );
+	info.players = [];
+	level.score_cf_info[ name ] = info;
+	registerclientfield( "allplayers", info.cf_field, info.version, info.bit_count, "int" );
+}
+
+score_cf_increment_info( name )
+{
+	info = level.score_cf_info[ name ];
+	player_ent_index = self getentitynumber();
+	if ( !isDefined( info.players[ player_ent_index ] ) )
+	{
+		info.players[ player_ent_index ] = 0;
+	}
+	info.players[ player_ent_index ]++;
+	if ( info.players[ player_ent_index ] > info.max_count )
+	{
+		info.players[ player_ent_index ] = 0;
+	}
+	self setclientfield( info.cf_field, info.players[ player_ent_index ] );
+}
+
+score_cf_monitor()
+{
+	if ( level.createfx_enabled )
+	{
+		return;
+	}
+	info_keys = getarraykeys( level.score_cf_info );
+	while ( 1 )
+	{
+		wait_network_frame();
+		players = get_players();
+		player_index = 0;
+		while ( player_index < players.size )
+		{
+			player = players[ player_index ];
+			player_ent_index = player getentitynumber();
+			info_index = 0;
+			while ( info_index < info_keys.size )
+			{
+				info = level.score_cf_info[ info_keys[ info_index ] ];
+				info.players[ player_ent_index ] = 0;
+				player setclientfield( info.cf_field, 0 );
+				info_index++;
+			}
+			player_index++;
+		}
+	}
+}
+
+player_add_points( event, mod, hit_location, is_dog, zombie_team, damage_weapon )
+{
+	if ( level.intermission )
+	{
+		return;
+	}
+	if ( !is_player_valid( self ) )
+	{
+		return;
+	}
+	player_points = 0;
+	team_points = 0;
+	multiplier = get_points_multiplier( self );
+	switch( event )
+	{
+		case "death":
+			player_points = get_zombie_death_player_points();
+			team_points = get_zombie_death_team_points();
+			points = self player_add_points_kill_bonus( mod, hit_location );
+			if ( level.zombie_vars[ self.team ][ "zombie_powerup_insta_kill_on" ] == 1 && mod == "MOD_UNKNOWN" )
+			{
+				points *= 2;
+			}
+			player_points += points;
+			if ( team_points > 0 )
+			{
+				team_points += points;
+			}
+			if ( mod == "MOD_GRENADE" || mod == "MOD_GRENADE_SPLASH" )
+			{
+				self maps/mp/zombies/_zm_stats::increment_client_stat( "grenade_kills" );
+				self maps/mp/zombies/_zm_stats::increment_player_stat( "grenade_kills" );
+			}
+			break;
+		case "ballistic_knife_death":
+			player_points = get_zombie_death_player_points() + level.zombie_vars[ "zombie_score_bonus_melee" ];
+			self score_cf_increment_info( "death_melee" );
+			break;
+		case "damage_light":
+			player_points = level.zombie_vars[ "zombie_score_damage_light" ];
+			self score_cf_increment_info( "damage" );
+			break;
+		case "damage":
+			player_points = level.zombie_vars[ "zombie_score_damage_normal" ];
+			self score_cf_increment_info( "damage" );
+			break;
+		case "damage_ads":
+			player_points = int( level.zombie_vars[ "zombie_score_damage_normal" ] * 1.25 );
+			self score_cf_increment_info( "damage" );
+			break;
+		case "carpenter_powerup":
+		case "rebuild_board":
+			player_points = mod;
+			break;
+		case "bonus_points_powerup":
+			player_points = mod;
+			break;
+		case "nuke_powerup":
+			player_points = mod;
+			team_points = mod;
+			break;
+		case "jetgun_fling":
+		case "riotshield_fling":
+		case "thundergun_fling":
+			player_points = mod;
+			break;
+		case "hacker_transfer":
+			player_points = mod;
+			break;
+		case "reviver":
+			player_points = mod;
+			break;
+		case "vulture":
+			player_points = mod;
+			break;
+		case "build_wallbuy":
+			player_points = mod;
+			break;
+		default:
+		/*
+/#
+			assert( 0, "Unknown point event" );
+#/
+		*/
+			break;
+	}
+	player_points = multiplier * round_up_score( player_points, 5 );
+	team_points = multiplier * round_up_score( team_points, 5 );
+	if ( isDefined( self.point_split_receiver ) || event == "death" && event == "ballistic_knife_death" )
+	{
+		split_player_points = player_points - round_up_score( player_points * self.point_split_keep_percent, 10 );
+		self.point_split_receiver add_to_player_score( split_player_points );
+		player_points -= split_player_points;
+	}
+	if ( is_true( level.pers_upgrade_pistol_points ) )
+	{
+		player_points = self maps/mp/zombies/_zm_pers_upgrades_functions::pers_upgrade_pistol_points_set_score( player_points, event, mod, damage_weapon );
+	}
+	self add_to_player_score( player_points );
+	self.pers[ "score" ] = self.score;
+	if ( isDefined( level._game_module_point_adjustment ) )
+	{
+		level [[ level._game_module_point_adjustment ]]( self, zombie_team, player_points );
+	}
+}
+
+get_points_multiplier( player )
+{
+	multiplier = level.zombie_vars[ player.team ][ "zombie_point_scalar" ];
+	if ( isDefined( level.current_game_module ) && level.current_game_module == 2 )
+	{
+		if ( isDefined( level._race_team_double_points ) && level._race_team_double_points == player._race_team )
+		{
+			return multiplier;
+		}
+		else
+		{
+			return 1;
+		}
+	}
+	return multiplier;
+}
+
+get_zombie_death_player_points()
+{
+	players = get_players();
+	if ( players.size == 1 )
+	{
+		points = level.zombie_vars[ "zombie_score_kill_1player" ];
+	}
+	else if ( players.size == 2 )
+	{
+		points = level.zombie_vars[ "zombie_score_kill_2player" ];
+	}
+	else if ( players.size == 3 )
+	{
+		points = level.zombie_vars[ "zombie_score_kill_3player" ];
+	}
+	else
+	{
+		points = level.zombie_vars[ "zombie_score_kill_4player" ];
+	}
+	return points;
+}
+
+get_zombie_death_team_points()
+{
+	players = get_players();
+	if ( players.size == 1 )
+	{
+		points = level.zombie_vars[ "zombie_score_kill_1p_team" ];
+	}
+	else if ( players.size == 2 )
+	{
+		points = level.zombie_vars[ "zombie_score_kill_2p_team" ];
+	}
+	else if ( players.size == 3 )
+	{
+		points = level.zombie_vars[ "zombie_score_kill_3p_team" ];
+	}
+	else
+	{
+		points = level.zombie_vars[ "zombie_score_kill_4p_team" ];
+	}
+	return points;
+}
+
+player_add_points_kill_bonus( mod, hit_location )
+{
+	if ( mod == "MOD_MELEE" )
+	{
+		self score_cf_increment_info( "death_melee" );
+		return level.zombie_vars[ "zombie_score_bonus_melee" ];
+	}
+	if ( mod == "MOD_BURNED" )
+	{
+		self score_cf_increment_info( "death_torso" );
+		return level.zombie_vars[ "zombie_score_bonus_burn" ];
+	}
+	score = 0;
+	if ( isDefined( hit_location ) )
+	{
+		switch( hit_location )
+		{
+			case "head":
+			case "helmet":
+				self score_cf_increment_info( "death_head" );
+				score = level.zombie_vars[ "zombie_score_bonus_head" ];
+				break;
+			case "neck":
+				self score_cf_increment_info( "death_neck" );
+				score = level.zombie_vars[ "zombie_score_bonus_neck" ];
+				break;
+			case "torso_lower":
+			case "torso_upper":
+				self score_cf_increment_info( "death_torso" );
+				score = level.zombie_vars[ "zombie_score_bonus_torso" ];
+				break;
+			default:
+				self score_cf_increment_info( "death_normal" );
+				break;
+		}
+	}
+	return score;
+}
+
+player_reduce_points( event, mod, hit_location )
+{
+	if ( level.intermission )
+	{
+		return;
+	}
+	points = 0;
+	switch( event )
+	{
+		case "no_revive_penalty":
+			percent = level.zombie_vars[ "penalty_no_revive" ];
+			points = self.score * percent;
+			break;
+		case "died":
+			percent = level.zombie_vars[ "penalty_died" ];
+			points = self.score * percent;
+			break;
+		case "downed":
+			percent = level.zombie_vars[ "penalty_downed" ];
+			self notify( "I_am_down" );
+			points = self.score * percent;
+			self.score_lost_when_downed = round_up_to_ten( int( points ) );
+			break;
+		default:
+		/*
+/#
+			assert( 0, "Unknown point event" );
+#/
+		*/
+			break;
+	}
+	points = self.score - round_up_to_ten( int( points ) );
+	if ( points < 0 )
+	{
+		points = 0;
+	}
+	self.score = points;
+}
+
+add_to_player_score( points, add_to_total )
+{
+	if ( !isDefined( add_to_total ) )
+	{
+		add_to_total = 1;
+	}
+	if ( !isDefined( points ) || level.intermission )
+	{
+		return;
+	}
+	self.score += points;
+	self.pers[ "score" ] = self.score;
+	if ( add_to_total )
+	{
+		self.score_total += points;
+	}
+	self incrementplayerstat( "score", points );
+}
+
+minus_to_player_score( points, ignore_double_points_upgrade )
+{
+	if ( !isDefined( points ) || level.intermission )
+	{
+		return;
+	}
+	if ( !is_true( ignore_double_points_upgrade ) )
+	{
+		if ( is_true( level.pers_upgrade_double_points ) )
+		{
+			points = maps/mp/zombies/_zm_pers_upgrades_functions::pers_upgrade_double_points_set_score( points );
+		}
+	}
+	self.score -= points;
+	self.pers[ "score" ] = self.score;
+	level notify( "spent_points" );
+}
+
+add_to_team_score( points )
+{
+}
+
+minus_to_team_score( points )
+{
+}
+
+player_died_penalty()
+{
+	players = get_players( self.team );
+	i = 0;
+	while ( i < players.size )
+	{
+		if ( players[ i ] != self && !players[ i ].is_zombie )
+		{
+			players[ i ] player_reduce_points( "no_revive_penalty" );
+		}
+		i++;
+	}
+}
+
+player_downed_penalty()
+{
+/*
+/#
+	println( "ZM >> LAST STAND - player_downed_penalty " );
+#/
+*/
+	self player_reduce_points( "downed" );
+}
+

patch_zm/maps/mp/zombies/NoKnownErrors/_zm_tombstone.gsc

@@ -0,0 +1,540 @@
+#include maps/mp/zombies/_zm_perks;
+#include maps/mp/zombies/_zm_equipment;
+#include maps/mp/zombies/_zm_weapons;
+#include maps/mp/zombies/_zm_weap_cymbal_monkey;
+#include maps/mp/zombies/_zm_melee_weapon;
+#include maps/mp/zombies/_zm_utility;
+#include common_scripts/utility;
+#include maps/mp/_utility;
+
+init()
+{
+	onplayerconnect_callback( ::tombstone_player_init );
+	level.tombstone_laststand_func = ::tombstone_laststand;
+	level.tombstone_spawn_func = ::tombstone_spawn;
+	level thread tombstone_hostmigration();
+	if ( isDefined( level.zombiemode_using_tombstone_perk ) && level.zombiemode_using_tombstone_perk )
+	{
+		add_custom_limited_weapon_check( ::is_weapon_available_in_tombstone );
+	}
+}
+
+tombstone_player_init()
+{
+	while ( !isDefined( self.tombstone_index ) )
+	{
+		wait 0.1;
+	}
+	level.tombstones[ self.tombstone_index ] = spawnstruct();
+}
+
+tombstone_spawn()
+{
+	dc = spawn( "script_model", self.origin + vectorScale( ( 0, 0, 1 ), 40 ) );
+	dc.angles = self.angles;
+	dc setmodel( "tag_origin" );
+	dc_icon = spawn( "script_model", self.origin + vectorScale( ( 0, 0, 1 ), 40 ) );
+	dc_icon.angles = self.angles;
+	dc_icon setmodel( "ch_tombstone1" );
+	dc_icon linkto( dc );
+	dc.icon = dc_icon;
+	dc.script_noteworthy = "player_tombstone_model";
+	dc.player = self;
+	self thread tombstone_clear();
+	dc thread tombstone_wobble();
+	dc thread tombstone_revived( self );
+	result = self waittill_any_return( "player_revived", "spawned_player", "disconnect" );
+	if ( result == "player_revived" || result == "disconnect" )
+	{
+		dc notify( "tombstone_timedout" );
+		dc_icon unlink();
+		dc_icon delete();
+		dc delete();
+		return;
+	}
+	dc thread tombstone_timeout();
+	dc thread tombstone_grab();
+}
+
+tombstone_clear()
+{
+	result = self waittill_any_return( "tombstone_timedout", "tombstone_grabbed" );
+	level.tombstones[ self.tombstone_index ] = spawnstruct();
+}
+
+tombstone_revived( player )
+{
+	self endon( "tombstone_timedout" );
+	player endon( "disconnect" );
+	shown = 1;
+	while ( isDefined( self ) && isDefined( player ) )
+	{
+		if ( isDefined( player.revivetrigger ) && isDefined( player.revivetrigger.beingrevived ) && player.revivetrigger.beingrevived )
+		{
+			if ( shown )
+			{
+				shown = 0;
+				self.icon hide();
+			}
+		}
+		else
+		{
+			if ( !shown )
+			{
+				shown = 1;
+				self.icon show();
+			}
+		}
+		wait 0.05;
+	}
+}
+
+tombstone_laststand()
+{
+	primaries = self getweaponslistprimaries();
+	currentweapon = self getcurrentweapon();
+	dc = level.tombstones[ self.tombstone_index ];
+	dc.player = self;
+	dc.weapon = [];
+	dc.current_weapon = -1;
+	_a134 = primaries;
+	index = getFirstArrayKey( _a134 );
+	while ( isDefined( index ) )
+	{
+		weapon = _a134[ index ];
+		dc.weapon[ index ] = weapon;
+		dc.stockcount[ index ] = self getweaponammostock( weapon );
+		if ( weapon == currentweapon )
+		{
+			dc.current_weapon = index;
+		}
+		index = getNextArrayKey( _a134, index );
+	}
+	if ( isDefined( self.hasriotshield ) && self.hasriotshield )
+	{
+		dc.hasriotshield = 1;
+	}
+	dc save_weapons_for_tombstone( self );
+	if ( self hasweapon( "claymore_zm" ) )
+	{
+		dc.hasclaymore = 1;
+		dc.claymoreclip = self getweaponammoclip( "claymore_zm" );
+	}
+	if ( self hasweapon( "emp_grenade_zm" ) )
+	{
+		dc.hasemp = 1;
+		dc.empclip = self getweaponammoclip( "emp_grenade_zm" );
+	}
+	dc.perk = tombstone_save_perks( self );
+	lethal_grenade = self get_player_lethal_grenade();
+	if ( self hasweapon( lethal_grenade ) )
+	{
+		dc.grenade = self getweaponammoclip( lethal_grenade );
+	}
+	else
+	{
+		dc.grenade = 0;
+	}
+	if ( maps/mp/zombies/_zm_weap_cymbal_monkey::cymbal_monkey_exists() )
+	{
+		dc.zombie_cymbal_monkey_count = self getweaponammoclip( "cymbal_monkey_zm" );
+	}
+}
+
+tombstone_save_perks( ent )
+{
+	perk_array = [];
+	if ( ent hasperk( "specialty_armorvest" ) )
+	{
+		perk_array[ perk_array.size ] = "specialty_armorvest";
+	}
+	if ( ent hasperk( "specialty_deadshot" ) )
+	{
+		perk_array[ perk_array.size ] = "specialty_deadshot";
+	}
+	if ( ent hasperk( "specialty_fastreload" ) )
+	{
+		perk_array[ perk_array.size ] = "specialty_fastreload";
+	}
+	if ( ent hasperk( "specialty_flakjacket" ) )
+	{
+		perk_array[ perk_array.size ] = "specialty_flakjacket";
+	}
+	if ( ent hasperk( "specialty_longersprint" ) )
+	{
+		perk_array[ perk_array.size ] = "specialty_longersprint";
+	}
+	if ( ent hasperk( "specialty_quickrevive" ) )
+	{
+		perk_array[ perk_array.size ] = "specialty_quickrevive";
+	}
+	if ( ent hasperk( "specialty_rof" ) )
+	{
+		perk_array[ perk_array.size ] = "specialty_rof";
+	}
+	return perk_array;
+}
+
+tombstone_grab()
+{
+	self endon( "tombstone_timedout" );
+	wait 1;
+	while ( isDefined( self ) )
+	{
+		players = get_players();
+		i = 0;
+		while ( i < players.size )
+		{
+			if ( players[ i ].is_zombie )
+			{
+				i++;
+				continue;
+			}
+			else
+			{
+				if ( isDefined( self.player ) && players[ i ] == self.player )
+				{
+					tombstone_machine_triggers = getentarray( "specialty_scavenger", "script_noteworthy" );
+					istombstonepowered = 0;
+					_a258 = tombstone_machine_triggers;
+					_k258 = getFirstArrayKey( _a258 );
+					while ( isDefined( _k258 ) )
+					{
+						trigger = _a258[ _k258 ];
+						if ( isDefined( trigger.power_on ) || trigger.power_on && isDefined( trigger.turbine_power_on ) && trigger.turbine_power_on )
+						{
+							istombstonepowered = 1;
+						}
+						_k258 = getNextArrayKey( _a258, _k258 );
+					}
+					if ( istombstonepowered )
+					{
+						dist = distance( players[ i ].origin, self.origin );
+						if ( dist < 64 )
+						{
+							playfx( level._effect[ "powerup_grabbed" ], self.origin );
+							playfx( level._effect[ "powerup_grabbed_wave" ], self.origin );
+							players[ i ] tombstone_give();
+							wait 0.1;
+							playsoundatposition( "zmb_tombstone_grab", self.origin );
+							self stoploopsound();
+							self.icon unlink();
+							self.icon delete();
+							self delete();
+							self notify( "tombstone_grabbed" );
+							players[ i ] clientnotify( "dc0" );
+							players[ i ] notify( "dance_on_my_grave" );
+						}
+					}
+				}
+			}
+			i++;
+		}
+		wait_network_frame();
+	}
+}
+
+tombstone_give()
+{
+	dc = level.tombstones[ self.tombstone_index ];
+	while ( !flag( "solo_game" ) )
+	{
+		primaries = self getweaponslistprimaries();
+		while ( dc.weapon.size > 1 || primaries.size > 1 )
+		{
+			_a310 = primaries;
+			_k310 = getFirstArrayKey( _a310 );
+			while ( isDefined( _k310 ) )
+			{
+				weapon = _a310[ _k310 ];
+				self takeweapon( weapon );
+				_k310 = getNextArrayKey( _a310, _k310 );
+			}
+		}
+		i = 0;
+		while ( i < dc.weapon.size )
+		{
+			if ( !isDefined( dc.weapon[ i ] ) )
+			{
+				i++;
+				continue;
+			}
+			else if ( dc.weapon[ i ] == "none" )
+			{
+				i++;
+				continue;
+			}
+			else
+			{
+				weapon = dc.weapon[ i ];
+				stock = dc.stockcount[ i ];
+				if ( !self hasweapon( weapon ) )
+				{
+					self giveweapon( weapon, 0, self maps/mp/zombies/_zm_weapons::get_pack_a_punch_weapon_options( weapon ) );
+					self setweaponammoclip( weapon, weaponclipsize( weapon ) );
+					self setweaponammostock( weapon, stock );
+					if ( i == dc.current_weapon )
+					{
+						self switchtoweapon( weapon );
+					}
+				}
+			}
+			i++;
+		}
+	}
+	if ( isDefined( dc.hasriotshield ) && dc.hasriotshield )
+	{
+		self maps/mp/zombies/_zm_equipment::equipment_give( "riotshield_zm" );
+		if ( isDefined( self.player_shield_reset_health ) )
+		{
+			self [[ self.player_shield_reset_health ]]();
+		}
+	}
+	dc restore_weapons_for_tombstone( self );
+	if ( isDefined( dc.hasclaymore ) && dc.hasclaymore && !self hasweapon( "claymore_zm" ) )
+	{
+		self giveweapon( "claymore_zm" );
+		self set_player_placeable_mine( "claymore_zm" );
+		self setactionslot( 4, "weapon", "claymore_zm" );
+		self setweaponammoclip( "claymore_zm", dc.claymoreclip );
+	}
+	if ( isDefined( dc.hasemp ) && dc.hasemp )
+	{
+		self giveweapon( "emp_grenade_zm" );
+		self setweaponammoclip( "emp_grenade_zm", dc.empclip );
+	}
+	while ( isDefined( dc.perk ) && dc.perk.size > 0 )
+	{
+		i = 0;
+		while ( i < dc.perk.size )
+		{
+			if ( self hasperk( dc.perk[ i ] ) )
+			{
+				i++;
+				continue;
+			}
+			else if ( dc.perk[ i ] == "specialty_quickrevive" && flag( "solo_game" ) )
+			{
+				i++;
+				continue;
+			}
+			else
+			{
+				maps/mp/zombies/_zm_perks::give_perk( dc.perk[ i ] );
+			}
+			i++;
+		}
+	}
+	if ( dc.grenade > 0 && !flag( "solo_game" ) )
+	{
+		curgrenadecount = 0;
+		if ( self hasweapon( self get_player_lethal_grenade() ) )
+		{
+			self getweaponammoclip( self get_player_lethal_grenade() );
+		}
+		else
+		{
+			self giveweapon( self get_player_lethal_grenade() );
+		}
+		self setweaponammoclip( self get_player_lethal_grenade(), dc.grenade + curgrenadecount );
+	}
+	if ( maps/mp/zombies/_zm_weap_cymbal_monkey::cymbal_monkey_exists() && !flag( "solo_game" ) )
+	{
+		if ( dc.zombie_cymbal_monkey_count )
+		{
+			self maps/mp/zombies/_zm_weap_cymbal_monkey::player_give_cymbal_monkey();
+			self setweaponammoclip( "cymbal_monkey_zm", dc.zombie_cymbal_monkey_count );
+		}
+	}
+}
+
+tombstone_wobble()
+{
+	self endon( "tombstone_grabbed" );
+	self endon( "tombstone_timedout" );
+	if ( isDefined( self ) )
+	{
+		wait 1;
+		playfxontag( level._effect[ "powerup_on" ], self, "tag_origin" );
+		self playsound( "zmb_tombstone_spawn" );
+		self playloopsound( "zmb_tombstone_looper" );
+	}
+	while ( isDefined( self ) )
+	{
+		self rotateyaw( 360, 3 );
+		wait 2.9;
+	}
+}
+
+tombstone_timeout()
+{
+	self endon( "tombstone_grabbed" );
+	self thread playtombstonetimeraudio();
+	wait 48.5;
+	i = 0;
+	while ( i < 40 )
+	{
+		if ( i % 2 )
+		{
+			self.icon ghost();
+		}
+		else
+		{
+			self.icon show();
+		}
+		if ( i < 15 )
+		{
+			wait 0.5;
+			i++;
+			continue;
+		}
+		else if ( i < 25 )
+		{
+			wait 0.25;
+			i++;
+			continue;
+		}
+		else
+		{
+			wait 0.1;
+		}
+		i++;
+	}
+	self notify( "tombstone_timedout" );
+	self.icon unlink();
+	self.icon delete();
+	self delete();
+}
+
+playtombstonetimeraudio()
+{
+	self endon( "tombstone_grabbed" );
+	self endon( "tombstone_timedout" );
+	player = self.player;
+	self thread playtombstonetimerout( player );
+	while ( 1 )
+	{
+		player playsoundtoplayer( "zmb_tombstone_timer_count", player );
+		wait 1;
+	}
+}
+
+playtombstonetimerout( player )
+{
+	self endon( "tombstone_grabbed" );
+	self waittill( "tombstone_timedout" );
+	player playsoundtoplayer( "zmb_tombstone_timer_out", player );
+}
+
+save_weapons_for_tombstone( player )
+{
+	self.tombstone_melee_weapons = [];
+	i = 0;
+	while ( i < level._melee_weapons.size )
+	{
+		self save_weapon_for_tombstone( player, level._melee_weapons[ i ].weapon_name );
+		i++;
+	}
+}
+
+save_weapon_for_tombstone( player, weapon_name )
+{
+	if ( player hasweapon( weapon_name ) )
+	{
+		self.tombstone_melee_weapons[ weapon_name ] = 1;
+	}
+}
+
+restore_weapons_for_tombstone( player )
+{
+	i = 0;
+	while ( i < level._melee_weapons.size )
+	{
+		self restore_weapon_for_tombstone( player, level._melee_weapons[ i ].weapon_name );
+		i++;
+	}
+	self.tombstone_melee_weapons = undefined;
+}
+
+restore_weapon_for_tombstone( player, weapon_name )
+{
+	if ( isDefined( weapon_name ) || !isDefined( self.tombstone_melee_weapons ) && !isDefined( self.tombstone_melee_weapons[ weapon_name ] ) )
+	{
+		return;
+	}
+	if ( isDefined( self.tombstone_melee_weapons[ weapon_name ] ) && self.tombstone_melee_weapons[ weapon_name ] )
+	{
+		player giveweapon( weapon_name );
+		player change_melee_weapon( weapon_name, "none" );
+		self.tombstone_melee_weapons[ weapon_name ] = 0;
+	}
+}
+
+tombstone_hostmigration()
+{
+	level endon( "end_game" );
+	level notify( "tombstone_hostmigration" );
+	level endon( "tombstone_hostmigration" );
+	while ( 1 )
+	{
+		level waittill( "host_migration_end" );
+		tombstones = getentarray( "player_tombstone_model", "script_noteworthy" );
+		_a580 = tombstones;
+		_k580 = getFirstArrayKey( _a580 );
+		while ( isDefined( _k580 ) )
+		{
+			model = _a580[ _k580 ];
+			playfxontag( level._effect[ "powerup_on" ], model, "tag_origin" );
+			_k580 = getNextArrayKey( _a580, _k580 );
+		}
+	}
+}
+
+is_weapon_available_in_tombstone( weapon, player_to_check )
+{
+	count = 0;
+	upgradedweapon = weapon;
+	if ( isDefined( level.zombie_weapons[ weapon ] ) && isDefined( level.zombie_weapons[ weapon ].upgrade_name ) )
+	{
+		upgradedweapon = level.zombie_weapons[ weapon ].upgrade_name;
+	}
+	tombstone_index = 0;
+	while ( tombstone_index < level.tombstones.size )
+	{
+		dc = level.tombstones[ tombstone_index ];
+		if ( !isDefined( dc.weapon ) )
+		{
+			tombstone_index++;
+			continue;
+		}
+		else if ( isDefined( player_to_check ) && dc.player != player_to_check )
+		{
+			tombstone_index++;
+			continue;
+		}
+		else
+		{
+			weapon_index = 0;
+			while ( weapon_index < dc.weapon.size )
+			{
+				if ( !isDefined( dc.weapon[ weapon_index ] ) )
+				{
+					weapon_index++;
+					continue;
+				}
+				else
+				{
+					tombstone_weapon = dc.weapon[ weapon_index ];
+					if ( tombstone_weapon == weapon || tombstone_weapon == upgradedweapon )
+					{
+						count++;
+					}
+				}
+				weapon_index++;
+			}
+		}
+		tombstone_index++;
+	}
+	return count;
+}
+

patch_zm/maps/mp/zombies/_load.gsc

@@ -0,0 +1,523 @@
+#include maps/mp/gametypes_zm/_spawnlogic;
+#include maps/mp/animscripts/traverse/shared;
+#include maps/mp/animscripts/utility;
+#include maps/mp/zombies/_load;
+#include maps/mp/_createfx;
+#include maps/mp/_music;
+#include maps/mp/_busing;
+#include maps/mp/_script_gen;
+#include maps/mp/_utility;
+#include common_scripts/utility;
+
+main( bscriptgened, bcsvgened, bsgenabled )
+{
+	if ( !isDefined( level.script_gen_dump_reasons ) )
+	{
+		level.script_gen_dump_reasons = [];
+	}
+	if ( !isDefined( bsgenabled ) )
+	{
+		level.script_gen_dump_reasons[ level.script_gen_dump_reasons.size ] = "First run";
+	}
+	if ( !isDefined( bcsvgened ) )
+	{
+		bcsvgened = 0;
+	}
+	level.bcsvgened = bcsvgened;
+	if ( !isDefined( bscriptgened ) )
+	{
+		bscriptgened = 0;
+	}
+	else
+	{
+		bscriptgened = 1;
+	}
+	level.bscriptgened = bscriptgened;
+	level._loadstarted = 1;
+	struct_class_init();
+	level.clientscripts = getDvar( "cg_usingClientScripts" ) != "";
+	level._client_exploders = [];
+	level._client_exploder_ids = [];
+	if ( !isDefined( level.flag ) )
+	{
+		level.flag = [];
+		level.flags_lock = [];
+	}
+	if ( !isDefined( level.timeofday ) )
+	{
+		level.timeofday = "day";
+	}
+	flag_init( "scriptgen_done" );
+	level.script_gen_dump_reasons = [];
+	if ( !isDefined( level.script_gen_dump ) )
+	{
+		level.script_gen_dump = [];
+		level.script_gen_dump_reasons[ 0 ] = "First run";
+	}
+	if ( !isDefined( level.script_gen_dump2 ) )
+	{
+		level.script_gen_dump2 = [];
+	}
+	if ( isDefined( level.createfxent ) && isDefined( level.script ) )
+	{
+		script_gen_dump_addline( "maps\\mp\\createfx\\" + level.script + "_fx::main();", level.script + "_fx" );
+	}
+	while ( isDefined( level.script_gen_dump_preload ) )
+	{
+		i = 0;
+		while ( i < level.script_gen_dump_preload.size )
+		{
+			script_gen_dump_addline( level.script_gen_dump_preload[ i ].string, level.script_gen_dump_preload[ i ].signature );
+			i++;
+		}
+	}
+	if ( getDvar( "scr_RequiredMapAspectratio" ) == "" )
+	{
+		setdvar( "scr_RequiredMapAspectratio", "1" );
+	}
+	setdvar( "r_waterFogTest", 0 );
+	precacherumble( "reload_small" );
+	precacherumble( "reload_medium" );
+	precacherumble( "reload_large" );
+	precacherumble( "reload_clipin" );
+	precacherumble( "reload_clipout" );
+	precacherumble( "reload_rechamber" );
+	precacherumble( "pullout_small" );
+	precacherumble( "buzz_high" );
+	precacherumble( "riotshield_impact" );
+	registerclientsys( "levelNotify" );
+	level.aitriggerspawnflags = getaitriggerflags();
+	level.vehicletriggerspawnflags = getvehicletriggerflags();
+	level.physicstracemaskphysics = 1;
+	level.physicstracemaskvehicle = 2;
+	level.physicstracemaskwater = 4;
+	level.physicstracemaskclip = 8;
+	level.physicstracecontentsvehicleclip = 16;
+	level.createfx_enabled = getDvar( "createfx" ) != "";
+	level thread start_intro_screen_zm();
+	thread maps/mp/_interactive_objects::init();
+	maps/mp/_audio::init();
+	thread maps/mp/_busing::businit();
+	thread maps/mp/_music::music_init();
+	thread maps/mp/_fxanim::init();
+	thread maps/mp/_serverfaceanim_mp::init();
+	if ( level.createfx_enabled )
+	{
+		setinitialplayersconnected();
+	}
+	visionsetnight( "default_night" );
+	setup_traversals();
+	maps/mp/_art::main();
+	setupexploders();
+	parse_structs();
+	thread footsteps();
+	/*
+/#
+	level thread level_notify_listener();
+	level thread client_notify_listener();
+#/
+	*/
+	thread maps/mp/_createfx::fx_init();
+	if ( level.createfx_enabled )
+	{
+		calculate_map_center();
+		maps/mp/_createfx::createfx();
+	}
+	if ( getDvar( "r_reflectionProbeGenerate" ) == "1" )
+	{
+		maps/mp/_global_fx::main();
+		level waittill( "eternity" );
+	}
+	thread maps/mp/_global_fx::main();
+	maps/mp/_demo::init();
+	p = 0;
+	while ( p < 6 )
+	{
+		switch( p )
+		{
+			case 0:
+				triggertype = "trigger_multiple";
+				break;
+			case 1:
+				triggertype = "trigger_once";
+				break;
+			case 2:
+				triggertype = "trigger_use";
+				break;
+			case 3:
+				triggertype = "trigger_radius";
+				break;
+			case 4:
+				triggertype = "trigger_lookat";
+				break;
+			default:
+			/*
+/#
+				assert( p == 5 );
+#/
+			*/
+				triggertype = "trigger_damage";
+				break;
+		}
+		triggers = getentarray( triggertype, "classname" );
+		i = 0;
+		while ( i < triggers.size )
+		{
+			if ( isDefined( triggers[ i ].script_prefab_exploder ) )
+			{
+				triggers[ i ].script_exploder = triggers[ i ].script_prefab_exploder;
+			}
+			if ( isDefined( triggers[ i ].script_exploder ) )
+			{
+				level thread maps/mp/zombies/_load::exploder_load( triggers[ i ] );
+			}
+			i++;
+		}
+		p++;
+	}
+}
+
+level_notify_listener()
+{
+	while ( 1 )
+	{
+		val = getDvar( "level_notify" );
+		if ( val != "" )
+		{
+			level notify( val );
+			setdvar( "level_notify", "" );
+		}
+		wait 0.2;
+	}
+}
+
+client_notify_listener()
+{
+	while ( 1 )
+	{
+		val = getDvar( "client_notify" );
+		if ( val != "" )
+		{
+			clientnotify( val );
+			setdvar( "client_notify", "" );
+		}
+		wait 0.2;
+	}
+}
+
+footsteps()
+{
+	if ( is_true( level.fx_exclude_footsteps ) )
+	{
+		return;
+	}
+	maps/mp/animscripts/utility::setfootstepeffect( "asphalt", loadfx( "bio/player/fx_footstep_dust" ) );
+	maps/mp/animscripts/utility::setfootstepeffect( "brick", loadfx( "bio/player/fx_footstep_dust" ) );
+	maps/mp/animscripts/utility::setfootstepeffect( "carpet", loadfx( "bio/player/fx_footstep_dust" ) );
+	maps/mp/animscripts/utility::setfootstepeffect( "cloth", loadfx( "bio/player/fx_footstep_dust" ) );
+	maps/mp/animscripts/utility::setfootstepeffect( "concrete", loadfx( "bio/player/fx_footstep_dust" ) );
+	maps/mp/animscripts/utility::setfootstepeffect( "dirt", loadfx( "bio/player/fx_footstep_sand" ) );
+	maps/mp/animscripts/utility::setfootstepeffect( "foliage", loadfx( "bio/player/fx_footstep_sand" ) );
+	maps/mp/animscripts/utility::setfootstepeffect( "gravel", loadfx( "bio/player/fx_footstep_dust" ) );
+	maps/mp/animscripts/utility::setfootstepeffect( "grass", loadfx( "bio/player/fx_footstep_dust" ) );
+	maps/mp/animscripts/utility::setfootstepeffect( "metal", loadfx( "bio/player/fx_footstep_dust" ) );
+	maps/mp/animscripts/utility::setfootstepeffect( "mud", loadfx( "bio/player/fx_footstep_mud" ) );
+	maps/mp/animscripts/utility::setfootstepeffect( "paper", loadfx( "bio/player/fx_footstep_dust" ) );
+	maps/mp/animscripts/utility::setfootstepeffect( "plaster", loadfx( "bio/player/fx_footstep_dust" ) );
+	maps/mp/animscripts/utility::setfootstepeffect( "rock", loadfx( "bio/player/fx_footstep_dust" ) );
+	maps/mp/animscripts/utility::setfootstepeffect( "sand", loadfx( "bio/player/fx_footstep_sand" ) );
+	maps/mp/animscripts/utility::setfootstepeffect( "water", loadfx( "bio/player/fx_footstep_water" ) );
+	maps/mp/animscripts/utility::setfootstepeffect( "wood", loadfx( "bio/player/fx_footstep_dust" ) );
+}
+
+parse_structs()
+{
+	i = 0;
+	while ( i < level.struct.size )
+	{
+		if ( isDefined( level.struct[ i ].targetname ) )
+		{
+			if ( level.struct[ i ].targetname == "flak_fire_fx" )
+			{
+				level._effect[ "flak20_fire_fx" ] = loadfx( "weapon/tracer/fx_tracer_flak_single_noExp" );
+				level._effect[ "flak38_fire_fx" ] = loadfx( "weapon/tracer/fx_tracer_quad_20mm_Flak38_noExp" );
+				level._effect[ "flak_cloudflash_night" ] = loadfx( "weapon/flak/fx_flak_cloudflash_night" );
+				level._effect[ "flak_burst_single" ] = loadfx( "weapon/flak/fx_flak_single_day_dist" );
+			}
+			if ( level.struct[ i ].targetname == "fake_fire_fx" )
+			{
+				level._effect[ "distant_muzzleflash" ] = loadfx( "weapon/muzzleflashes/heavy" );
+			}
+			if ( level.struct[ i ].targetname == "spotlight_fx" )
+			{
+				level._effect[ "spotlight_beam" ] = loadfx( "env/light/fx_ray_spotlight_md" );
+			}
+		}
+		i++;
+	}
+}
+
+exploder_load( trigger )
+{
+	level endon( "killexplodertridgers" + trigger.script_exploder );
+	trigger waittill( "trigger" );
+	if ( isDefined( trigger.script_chance ) && randomfloat( 1 ) > trigger.script_chance )
+	{
+		if ( isDefined( trigger.script_delay ) )
+		{
+			wait trigger.script_delay;
+		}
+		else
+		{
+			wait 4;
+		}
+		level thread exploder_load( trigger );
+		return;
+	}
+	maps/mp/_utility::exploder( trigger.script_exploder );
+	level notify( "killexplodertridgers" + trigger.script_exploder );
+}
+
+setupexploders()
+{
+	ents = getentarray( "script_brushmodel", "classname" );
+	smodels = getentarray( "script_model", "classname" );
+	i = 0;
+	while ( i < smodels.size )
+	{
+		ents[ ents.size ] = smodels[ i ];
+		i++;
+	}
+	i = 0;
+	while ( i < ents.size )
+	{
+		if ( isDefined( ents[ i ].script_prefab_exploder ) )
+		{
+			ents[ i ].script_exploder = ents[ i ].script_prefab_exploder;
+		}
+		if ( isDefined( ents[ i ].script_exploder ) )
+		{
+			if ( ents[ i ].model == "fx" || !isDefined( ents[ i ].targetname ) && ents[ i ].targetname != "exploderchunk" )
+			{
+				ents[ i ] hide();
+				i++;
+				continue;
+			}
+			else
+			{
+				if ( isDefined( ents[ i ].targetname ) && ents[ i ].targetname == "exploder" )
+				{
+					ents[ i ] hide();
+					ents[ i ] notsolid();
+					i++;
+					continue;
+				}
+				else
+				{
+					if ( isDefined( ents[ i ].targetname ) && ents[ i ].targetname == "exploderchunk" )
+					{
+						ents[ i ] hide();
+						ents[ i ] notsolid();
+					}
+				}
+			}
+		}
+		i++;
+	}
+	script_exploders = [];
+	potentialexploders = getentarray( "script_brushmodel", "classname" );
+	i = 0;
+	while ( i < potentialexploders.size )
+	{
+		if ( isDefined( potentialexploders[ i ].script_prefab_exploder ) )
+		{
+			potentialexploders[ i ].script_exploder = potentialexploders[ i ].script_prefab_exploder;
+		}
+		if ( isDefined( potentialexploders[ i ].script_exploder ) )
+		{
+			script_exploders[ script_exploders.size ] = potentialexploders[ i ];
+		}
+		i++;
+	}
+	potentialexploders = getentarray( "script_model", "classname" );
+	i = 0;
+	while ( i < potentialexploders.size )
+	{
+		if ( isDefined( potentialexploders[ i ].script_prefab_exploder ) )
+		{
+			potentialexploders[ i ].script_exploder = potentialexploders[ i ].script_prefab_exploder;
+		}
+		if ( isDefined( potentialexploders[ i ].script_exploder ) )
+		{
+			script_exploders[ script_exploders.size ] = potentialexploders[ i ];
+		}
+		i++;
+	}
+	potentialexploders = getentarray( "item_health", "classname" );
+	i = 0;
+	while ( i < potentialexploders.size )
+	{
+		if ( isDefined( potentialexploders[ i ].script_prefab_exploder ) )
+		{
+			potentialexploders[ i ].script_exploder = potentialexploders[ i ].script_prefab_exploder;
+		}
+		if ( isDefined( potentialexploders[ i ].script_exploder ) )
+		{
+			script_exploders[ script_exploders.size ] = potentialexploders[ i ];
+		}
+		i++;
+	}
+	if ( !isDefined( level.createfxent ) )
+	{
+		level.createfxent = [];
+	}
+	acceptabletargetnames = [];
+	acceptabletargetnames[ "exploderchunk visible" ] = 1;
+	acceptabletargetnames[ "exploderchunk" ] = 1;
+	acceptabletargetnames[ "exploder" ] = 1;
+	i = 0;
+	while ( i < script_exploders.size )
+	{
+		exploder = script_exploders[ i ];
+		ent = createexploder( exploder.script_fxid );
+		ent.v = [];
+		ent.v[ "origin" ] = exploder.origin;
+		ent.v[ "angles" ] = exploder.angles;
+		ent.v[ "delay" ] = exploder.script_delay;
+		ent.v[ "firefx" ] = exploder.script_firefx;
+		ent.v[ "firefxdelay" ] = exploder.script_firefxdelay;
+		ent.v[ "firefxsound" ] = exploder.script_firefxsound;
+		ent.v[ "firefxtimeout" ] = exploder.script_firefxtimeout;
+		ent.v[ "earthquake" ] = exploder.script_earthquake;
+		ent.v[ "damage" ] = exploder.script_damage;
+		ent.v[ "damage_radius" ] = exploder.script_radius;
+		ent.v[ "soundalias" ] = exploder.script_soundalias;
+		ent.v[ "repeat" ] = exploder.script_repeat;
+		ent.v[ "delay_min" ] = exploder.script_delay_min;
+		ent.v[ "delay_max" ] = exploder.script_delay_max;
+		ent.v[ "target" ] = exploder.target;
+		ent.v[ "ender" ] = exploder.script_ender;
+		ent.v[ "type" ] = "exploder";
+		if ( !isDefined( exploder.script_fxid ) )
+		{
+			ent.v[ "fxid" ] = "No FX";
+		}
+		else
+		{
+			ent.v[ "fxid" ] = exploder.script_fxid;
+		}
+		ent.v[ "exploder" ] = exploder.script_exploder;
+		/*
+/#
+		assert( isDefined( exploder.script_exploder ), "Exploder at origin " + exploder.origin + " has no script_exploder" );
+#/
+		*/
+		if ( !isDefined( ent.v[ "delay" ] ) )
+		{
+			ent.v[ "delay" ] = 0;
+		}
+		if ( isDefined( exploder.target ) )
+		{
+			org = getent( ent.v[ "target" ], "targetname" ).origin;
+			ent.v[ "angles" ] = vectorToAngles( org - ent.v[ "origin" ] );
+		}
+		if ( exploder.classname == "script_brushmodel" || isDefined( exploder.model ) )
+		{
+			ent.model = exploder;
+			ent.model.disconnect_paths = exploder.script_disconnectpaths;
+		}
+		if ( isDefined( exploder.targetname ) && isDefined( acceptabletargetnames[ exploder.targetname ] ) )
+		{
+			ent.v[ "exploder_type" ] = exploder.targetname;
+		}
+		else
+		{
+			ent.v[ "exploder_type" ] = "normal";
+		}
+		ent maps/mp/_createfx::post_entity_creation_function();
+		i++;
+	}
+	level.createfxexploders = [];
+	i = 0;
+	while ( i < level.createfxent.size )
+	{
+		ent = level.createfxent[ i ];
+		if ( ent.v[ "type" ] != "exploder" )
+		{
+			i++;
+			continue;
+		}
+		else
+		{
+			ent.v[ "exploder_id" ] = getexploderid( ent );
+			if ( !isDefined( level.createfxexploders[ ent.v[ "exploder" ] ] ) )
+			{
+				level.createfxexploders[ ent.v[ "exploder" ] ] = [];
+			}
+			level.createfxexploders[ ent.v[ "exploder" ] ][ level.createfxexploders[ ent.v[ "exploder" ] ].size ] = ent;
+		}
+		i++;
+	}
+}
+
+setup_traversals()
+{
+	potential_traverse_nodes = getallnodes();
+	i = 0;
+	while ( i < potential_traverse_nodes.size )
+	{
+		node = potential_traverse_nodes[ i ];
+		if ( node.type == "Begin" )
+		{
+			node maps/mp/animscripts/traverse/shared::init_traverse();
+		}
+		i++;
+	}
+}
+
+calculate_map_center()
+{
+	if ( !isDefined( level.mapcenter ) )
+	{
+		level.nodesmins = ( 0, 0, 0 );
+		level.nodesmaxs = ( 0, 0, 0 );
+		level.mapcenter = maps/mp/gametypes_zm/_spawnlogic::findboxcenter( level.nodesmins, level.nodesmaxs );
+		/*
+/#
+		println( "map center: ", level.mapcenter );
+#/
+		*/
+		setmapcenter( level.mapcenter );
+	}
+}
+
+start_intro_screen_zm()
+{
+	if ( level.createfx_enabled )
+	{
+		return;
+	}
+	if ( !isDefined( level.introscreen ) )
+	{
+		level.introscreen = newhudelem();
+		level.introscreen.x = 0;
+		level.introscreen.y = 0;
+		level.introscreen.horzalign = "fullscreen";
+		level.introscreen.vertalign = "fullscreen";
+		level.introscreen.foreground = 0;
+		level.introscreen setshader( "black", 640, 480 );
+		level.introscreen.immunetodemogamehudsettings = 1;
+		level.introscreen.immunetodemofreecamera = 1;
+		wait 0.05;
+	}
+	level.introscreen.alpha = 1;
+	players = get_players();
+	i = 0;
+	while ( i < players.size )
+	{
+		players[ i ] freezecontrols( 1 );
+		i++;
+	}
+	wait 1;
+}
+

patch_zm/maps/mp/zombies/_zm_gump.gsc

@@ -0,0 +1,81 @@
+#include maps/mp/zombies/_zm_utility;
+#include maps/mp/_utility;
+#include common_scripts/utility;
+
+init()
+{
+	if ( isDefined( level.disable_blackscreen_clientfield ) && !level.disable_blackscreen_clientfield )
+	{
+		registerclientfield( "toplayer", "blackscreen", 1, 1, "int" );
+	}
+	if ( !isDefined( level.uses_gumps ) )
+	{
+		level.uses_gumps = 0;
+	}
+	if ( isDefined( level.uses_gumps ) && level.uses_gumps )
+	{
+		onplayerconnect_callback( ::player_connect_gump );
+	}
+}
+
+player_teleport_blackscreen_on()
+{
+	if ( isDefined( level.disable_blackscreen_clientfield ) && level.disable_blackscreen_clientfield )
+	{
+		return;
+	}
+	if ( isDefined( level.uses_gumps ) && level.uses_gumps )
+	{
+		self setclientfieldtoplayer( "blackscreen", 1 );
+		wait 0.05;
+		self setclientfieldtoplayer( "blackscreen", 0 );
+	}
+}
+
+player_connect_gump()
+{
+}
+
+player_watch_spectate_change()
+{
+	if ( isDefined( level.disable_blackscreen_clientfield ) && level.disable_blackscreen_clientfield )
+	{
+		return;
+	}
+	self endon( "disconnect" );
+	while ( 1 )
+	{
+		self waittill( "spectator_cycle" );
+		self setclientfieldtoplayer( "blackscreen", 1 );
+		wait 0.05;
+		self setclientfieldtoplayer( "blackscreen", 0 );
+	}
+}
+
+gump_test()
+{
+/*
+/#
+	wait 10;
+	pos1 = ( -4904, -7657, 4 );
+	pos3 = ( 7918, -6506, 177 );
+	pos2 = ( 1986, -73, 4 );
+	players = get_players();
+	if ( isDefined( players[ 0 ] ) )
+	{
+		players[ 0 ] setorigin( pos1 );
+	}
+	wait 0.05;
+	if ( isDefined( players[ 1 ] ) )
+	{
+		players[ 1 ] setorigin( pos2 );
+	}
+	wait 0.05;
+	if ( isDefined( players[ 2 ] ) )
+	{
+		players[ 2 ] setorigin( pos3 );
+#/
+	}
+*/
+}
+

patch_zm/maps/mp/zombies/_zm_timer.gsc

@@ -0,0 +1,80 @@
+#include maps/mp/zombies/_zm_utility;
+#include maps/mp/_utility;
+#include common_scripts/utility;
+
+init()
+{
+	precacheshader( "zombie_stopwatchneedle" );
+	precacheshader( "zombie_stopwatch" );
+	precacheshader( "zombie_stopwatch_glass" );
+	if ( !isDefined( level.stopwatch_length_width ) )
+	{
+		level.stopwatch_length_width = 96;
+	}
+}
+
+start_timer( time, stop_notify )
+{
+	self notify( "stop_prev_timer" );
+	self endon( "stop_prev_timer" );
+	if ( !isDefined( self.stopwatch_elem ) )
+	{
+		self.stopwatch_elem = newclienthudelem( self );
+		self.stopwatch_elem.horzalign = "left";
+		self.stopwatch_elem.vertalign = "top";
+		self.stopwatch_elem.alignx = "left";
+		self.stopwatch_elem.aligny = "top";
+		self.stopwatch_elem.x = 10;
+		self.stopwatch_elem.alpha = 0;
+		self.stopwatch_elem.sort = 2;
+		self.stopwatch_elem_glass = newclienthudelem( self );
+		self.stopwatch_elem_glass.horzalign = "left";
+		self.stopwatch_elem_glass.vertalign = "top";
+		self.stopwatch_elem_glass.alignx = "left";
+		self.stopwatch_elem_glass.aligny = "top";
+		self.stopwatch_elem_glass.x = 10;
+		self.stopwatch_elem_glass.alpha = 0;
+		self.stopwatch_elem_glass.sort = 3;
+		self.stopwatch_elem_glass setshader( "zombie_stopwatch_glass", level.stopwatch_length_width, level.stopwatch_length_width );
+	}
+	self thread update_hud_position();
+	if ( isDefined( stop_notify ) )
+	{
+		self thread wait_for_stop_notify( stop_notify );
+	}
+	if ( time > 60 )
+	{
+		time = 0;
+	}
+	self.stopwatch_elem setclock( time, 60, "zombie_stopwatch", level.stopwatch_length_width, level.stopwatch_length_width );
+	self.stopwatch_elem.alpha = 1;
+	self.stopwatch_elem_glass.alpha = 1;
+	wait time;
+	self notify( "countdown_finished" );
+	wait 1;
+	self.stopwatch_elem.alpha = 0;
+	self.stopwatch_elem_glass.alpha = 0;
+}
+
+wait_for_stop_notify( stop_notify )
+{
+	self endon( "stop_prev_timer" );
+	self endon( "countdown_finished" );
+	self waittill( stop_notify );
+	self.stopwatch_elem.alpha = 0;
+	self.stopwatch_elem_glass.alpha = 0;
+}
+
+update_hud_position()
+{
+	self endon( "disconnect" );
+	self endon( "stop_prev_timer" );
+	self endon( "countdown_finished" );
+	while ( 1 )
+	{
+		self.stopwatch_elem.y = 20;
+		self.stopwatch_elem_glass.y = 20;
+		wait 0.05;
+	}
+}
+

patch_zm/readme.md

@@ -0,0 +1,51 @@
+### The following gscs compile and run successfully with no known errors:
+```
+patch_zm/maps/mp/gametypes_zm/NoKnownErrors/_scoreboard.gsc
+patch_zm/maps/mp/gametypes_zm/NoKnownErrors/_shellshock.gsc
+patch_zm/maps/mp/gametypes_zm/NoKnownErrors/zclassic.gsc
+patch_zm/maps/mp/zombies/NoKnownErrors/_zm_ai_basic.gsc
+patch_zm/maps/mp/zombies/NoKnownErrors/_zm_ai_dogs.gsc
+patch_zm/maps/mp/zombies/NoKnownErrors/_zm_ai_faller.gsc
+patch_zm/maps/mp/zombies/NoKnownErrors/_zm_bot.gsc
+patch_zm/maps/mp/zombies/NoKnownErrors/_zm_equip_hacker.gsc
+patch_zm/maps/mp/zombies/NoKnownErrors/_zm_hackables_boards.gsc
+patch_zm/maps/mp/zombies/NoKnownErrors/_zm_hackables_box.gsc
+patch_zm/maps/mp/zombies/NoKnownErrors/_zm_hackables_doors.gsc
+patch_zm/maps/mp/zombies/NoKnownErrors/_zm_hackables_packapunch.gsc
+patch_zm/maps/mp/zombies/NoKnownErrors/_zm_hackables_perks.gsc
+patch_zm/maps/mp/zombies/NoKnownErrors/_zm_hackables_powerups.gsc
+patch_zm/maps/mp/zombies/NoKnownErrors/_zm_hackables_wallbuys.gsc
+patch_zm/maps/mp/zombies/NoKnownErrors/_zm_perk_electric_cherry.gsc
+patch_zm/maps/mp/zombies/NoKnownErrors/_zm_pers_upgrades.gsc
+patch_zm/maps/mp/zombies/NoKnownErrors/_zm_pers_upgrades_functions.gsc
+patch_zm/maps/mp/zombies/NoKnownErrors/_zm_pers_upgrades_system.gsc
+patch_zm/maps/mp/zombies/NoKnownErrors/_zm_score.gsc
+patch_zm/maps/mp/zombies/NoKnownErrors/_zm_tombstone.gsc
+```
+### The following scripts compile and run successfully with minor errors:
+```
+patch_zm/maps/mp/zombies/MinorErorrs/_zm_timer.gsc
+```
+### The following scripts compile and run successfully with major errors:
+```
+patch_zm/maps/mp/gametypes_zm/MajorErrors/_zm_gametype.gsc
+patch_zm/maps/mp/zombies/MajorErrors/_zm_magicbox.gsc
+patch_zm/maps/mp/zombies/MajorErrors/_zm_perks.gsc
+patch_zm/maps/mp/zombies/MajorErrors/_zm_powerups.gsc
+patch_zm/maps/mp/zombies/MajorErrors/_zm_weapons.gsc
+```
+### The following scripts compile and run serverside but clients cannot join due to exe_client_field_mismatch
+```
+patch_zm/maps/mp/zombies/exe_client_field_mismatch/_zm.gsc
+patch_zm/maps/mp/zombies/exe_client_field_mismatch/_zm_gump.gsc
+patch_zm/maps/mp/zombies/exe_client_field_mismatch/_zm_equipment.gsc
+```
+### The following scripts compile but cause a minidump or other severe error:
+```
+patch_zm/maps/mp/zombies/SevereErrors/_load.gsc
+```
+
+### notes:
+```
+The shaders that _zm_timer.gsc relies on do not exist.
+```

readme.md

@@ -0,0 +1,25 @@
+### About this project
+
+The way scripts are categorized is based on their current functionality. 
+The objective of this project is to get as many scripts in the No Known Erorrs category.
+Eventually, once scripts have been tested even more thoroughly there will be a new category for scripts that have parity with the original scripts.
+
+The categories are:
+
+No Known Errors: This means that during a short gameplay test no errors are observed.
+It can also mean that the script is unused such as the _hackables series meaning that while they are being parsed nothing is calling them.
+
+Minor Errors: Indicates that the scripts are functional but perhaps there is a typo in text shown on screen or other ui error.
+It means that while the script doesn't have 100% parity with the base script it nears 100% and all the expected core functionality of the script works.
+
+Major Errors: The scripts' core functionality is missing or broken so that anything from crashes occur during gameplay or perks not working.
+Any script categorized as having major errors is not yet in a playable state unlike scripts with only Minor or No Known Errors.
+
+exe_client_field_mismatch: This is a specific error that doesn't have a specific cause.
+Scripts that cause this error will run serverside but clients cannot join due to this error.
+
+Severe Errors: Minidump, hang on map_rotate, crash, or other error that prevents the server from starting up is in this category.
+This type of error can be caused by many different things
+
+Each script will be sorted by its location e.g. patch_zm/maps/mp/zombies and then sorted by error type so it would look like this:
+patch_zm/maps/mp/zombies/MinorErrors/_zm_timer.gsc

zm_highrise_patch/maps/mp/zombies/_zm_weap_slipgun.gsc

@@ -0,0 +1,891 @@
+#include maps/mp/zombies/_zm_audio;
+#include maps/mp/zombies/_zm_powerups;
+#include maps/mp/zombies/_zm_ai_basic;
+#include maps/mp/animscripts/zm_shared;
+#include maps/mp/animscripts/zm_utility;
+#include maps/mp/zombies/_zm;
+#include maps/mp/zombies/_zm_spawner;
+#include maps/mp/gametypes_zm/_weaponobjects;
+#include maps/mp/zombies/_zm_equipment;
+#include maps/mp/zombies/_zm_weapons;
+#include maps/mp/zombies/_zm_utility;
+#include maps/mp/_utility;
+#include common_scripts/utility;
+
+set_zombie_var_once( var, value, is_float, column, is_team_based )
+{
+	if ( !isDefined( level.zombie_vars ) || !isDefined( level.zombie_vars[ var ] ) )
+	{
+		set_zombie_var( var, value, is_float, column, is_team_based );
+	}
+}
+
+init()
+{
+	if ( !maps/mp/zombies/_zm_weapons::is_weapon_included( "slipgun_zm" ) )
+	{
+		return;
+	}
+	precachemodel( "t5_weapon_crossbow_bolt" );
+	precacheitem( "slip_bolt_zm" );
+	precacheitem( "slip_bolt_upgraded_zm" );
+	if ( is_true( level.slipgun_as_equipment ) )
+	{
+		maps/mp/zombies/_zm_equipment::register_equipment( "slipgun_zm", &"ZM_HIGHRISE_EQUIP_SLIPGUN_PICKUP_HINT_STRING", &"ZM_HIGHRISE_EQUIP_SLIPGUN_HOWTO", "jetgun_zm_icon", "slipgun", ::slipgun_activation_watcher_thread, ::transferslipgun, ::dropslipgun, ::pickupslipgun );
+		maps/mp/zombies/_zm_equipment::enemies_ignore_equipment( "slipgun_zm" );
+		maps/mp/gametypes_zm/_weaponobjects::createretrievablehint( "slipgun", &"ZM_HIGHRISE_EQUIP_SLIPGUN_PICKUP_HINT_STRING" );
+	}
+	set_zombie_var_once( "slipgun_reslip_max_spots", 8 );
+	set_zombie_var_once( "slipgun_reslip_rate", 6 );
+	set_zombie_var_once( "slipgun_max_kill_chain_depth", 16 );
+	set_zombie_var_once( "slipgun_max_kill_round", 100 );
+	set_zombie_var_once( "slipgun_chain_radius", 120 );
+	set_zombie_var_once( "slipgun_chain_wait_min", 0.75, 1 );
+	set_zombie_var_once( "slipgun_chain_wait_max", 1.5, 1 );
+	level.slippery_spot_count = 0;
+	level.sliquifier_distance_checks = 0;
+	maps/mp/zombies/_zm_spawner::register_zombie_damage_callback( ::slipgun_zombie_damage_response );
+	maps/mp/zombies/_zm_spawner::register_zombie_death_animscript_callback( ::slipgun_zombie_death_response );
+	level._effect[ "slipgun_explode" ] = loadfx( "weapon/liquifier/fx_liquifier_goo_explo" );
+	level._effect[ "slipgun_splatter" ] = loadfx( "maps/zombie/fx_zmb_goo_splat" );
+	level._effect[ "slipgun_simmer" ] = loadfx( "weapon/liquifier/fx_liquifier_goo_sizzle" );
+	level._effect[ "slipgun_viewmodel_eject" ] = loadfx( "weapon/liquifier/fx_liquifier_clip_eject" );
+	level._effect[ "slipgun_viewmodel_reload" ] = loadfx( "weapon/liquifier/fx_liquifier_reload_steam" );
+	onplayerconnect_callback( ::slipgun_player_connect );
+	thread wait_init_damage();
+}
+
+wait_init_damage()
+{
+	while ( !isDefined( level.zombie_vars ) || !isDefined( level.zombie_vars[ "zombie_health_start" ] ) )
+	{
+		wait 1;
+	}
+	wait 1;
+	level.slipgun_damage = maps/mp/zombies/_zm::ai_zombie_health( level.zombie_vars[ "slipgun_max_kill_round" ] );
+	level.slipgun_damage_mod = "MOD_PROJECTILE_SPLASH";
+}
+
+slipgun_player_connect()
+{
+	self thread watch_for_slip_bolt();
+}
+
+watch_for_slip_bolt()
+{
+	self endon( "death" );
+	self endon( "disconnect" );
+	for ( ;; )
+	{
+		self waittill( "grenade_fire", grenade, weaponname, parent );
+		self.num_sliquifier_kills = 0;
+		switch( weaponname )
+		{
+			case "slip_bolt_zm":
+				grenade thread slip_bolt( self, 0 );
+				break;
+			continue;
+			case "slip_bolt_upgraded_zm":
+				grenade thread slip_bolt( self, 1 );
+				break;
+			continue;
+		}
+	}
+}
+
+slip_bolt( player, upgraded )
+{
+	startpos = player getweaponmuzzlepoint();
+	self waittill( "explode", position );
+	duration = 24;
+	if ( upgraded )
+	{
+		duration = 36;
+	}
+	thread add_slippery_spot( position, duration, startpos );
+}
+
+dropslipgun()
+{
+	item = self maps/mp/zombies/_zm_equipment::placed_equipment_think( "t6_wpn_zmb_slipgun_world", "slipgun_zm", self.origin + vectorScale( ( 0, 0, 1 ), 30 ), self.angles );
+	if ( isDefined( item ) )
+	{
+		item.original_owner = self;
+		item.owner = undefined;
+		item.name = "slipgun_zm";
+		item.requires_pickup = 1;
+		item.clipammo = self getweaponammoclip( item.name );
+		item.stockammo = self getweaponammostock( item.name );
+	}
+	self takeweapon( "slipgun_zm" );
+	return item;
+}
+
+pickupslipgun( item )
+{
+	item.owner = self;
+	self giveweapon( item.name );
+	if ( isDefined( item.clipammo ) && isDefined( item.stockammo ) )
+	{
+		self setweaponammoclip( item.name, item.clipammo );
+		self setweaponammostock( item.name, item.stockammo );
+		item.clipammo = undefined;
+		item.stockammo = undefined;
+	}
+}
+
+transferslipgun( fromplayer, toplayer )
+{
+	toplayer notify( "slipgun_zm_taken" );
+	fromplayer notify( "slipgun_zm_taken" );
+}
+
+slipgun_activation_watcher_thread()
+{
+	self endon( "zombified" );
+	self endon( "disconnect" );
+	self endon( "slipgun_zm_taken" );
+	while ( 1 )
+	{
+		self waittill_either( "slipgun_zm_activate", "slipgun_zm_deactivate" );
+	}
+}
+
+slipgun_debug_circle( origin, radius, seconds, onslope, parent, start )
+{
+/*
+/#
+	if ( getDvarInt( #"6136A815" ) )
+	{
+		frames = int( 20 * seconds );
+		if ( isDefined( parent ) )
+		{
+			time = seconds;
+			frames = 1;
+			while ( time > 0 )
+			{
+				morigin = origin + ( parent.origin - start );
+				if ( isDefined( onslope ) && onslope )
+				{
+					circle( morigin, radius, ( 0, 0, 1 ), 0, 1, frames );
+				}
+				else
+				{
+					circle( morigin, radius, ( 0, 0, 1 ), 0, 1, frames );
+				}
+				time -= 0,05;
+				wait 0,05;
+			}
+		}
+		else if ( isDefined( onslope ) && onslope )
+		{
+			circle( origin, radius, ( 0, 0, 1 ), 0, 1, frames );
+			return;
+		}
+		else
+		{
+			circle( origin, radius, ( 0, 0, 1 ), 0, 1, frames );
+#/
+		}
+	}
+*/
+}
+
+slipgun_debug_line( start, end, color, seconds )
+{
+/*
+/#
+	if ( getDvarInt( #"6136A815" ) )
+	{
+		frames = int( 20 * seconds );
+		line( start, end, color, 1, 0, frames );
+#/
+	}
+*/
+}
+
+canzombieongoofall()
+{
+	if ( is_true( self.is_inert ) )
+	{
+		return 0;
+	}
+	if ( is_true( self.is_traversing ) )
+	{
+		return 0;
+	}
+	if ( is_true( self.barricade_enter ) )
+	{
+		return 0;
+	}
+	if ( randomint( 100 ) < 20 )
+	{
+		trace = groundtrace( self.origin + vectorScale( ( 0, 0, 1 ), 5 ), self.origin + vectorScale( ( 0, 0, 1 ), 300 ), 0, undefined );
+		origin = trace[ "position" ];
+		groundnormal = trace[ "normal" ];
+		if ( distancesquared( self.origin, origin ) > 256 )
+		{
+			return 0;
+		}
+		dot = vectordot( ( 0, 0, 1 ), groundnormal );
+		if ( dot < 0.9 )
+		{
+			return 0;
+		}
+		trace_origin = self.origin + vectorScale( anglesToForward( self.angles ), 200 );
+		trace = groundtrace( trace_origin + vectorScale( ( 0, 0, 1 ), 5 ), self.origin + vectorScale( ( 0, 0, 1 ), 300 ), 0, undefined );
+		origin = trace[ "position" ];
+		groundnormal = trace[ "normal" ];
+		if ( distancesquared( trace_origin, origin ) > 256 )
+		{
+			return 0;
+		}
+		dot = vectordot( ( 0, 0, 1 ), groundnormal );
+		if ( dot < 0.9 )
+		{
+			return 0;
+		}
+		return 1;
+	}
+	return 0;
+}
+
+zombiemoveongoo()
+{
+	self endon( "death" );
+	self endon( "removed" );
+	level endon( "intermission" );
+	if ( is_true( self.sliding_on_goo ) )
+	{
+		return;
+	}
+	self notify( "endOnGoo" );
+	self endon( "endOnGoo" );
+	self notify( "stop_zombie_goto_entrance" );
+	self notify( "stop_find_flesh" );
+	self notify( "zombie_acquire_enemy" );
+	self.goo_last_vel = self getvelocity();
+	self.goo_last_pos = self.origin;
+	slide_direction = anglesToForward( self.angles );
+	self animmode( "slide" );
+	self orientmode( "face enemy" );
+	self.forcemovementscriptstate = 1;
+	self.ai_state = "zombieMoveOnGoo";
+	self maps/mp/zombies/_zm_spawner::zombie_history( "zombieMoveOnGoo " + getTime() );
+	self.sliding_on_goo = 0;
+	self thread zombiemoveongoo_on_killanimscript();
+	for ( ;; )
+	{
+		while ( 1 )
+		{
+			if ( isDefined( self.is_on_goo ) )
+			{
+				self_on_goo = self.is_on_goo;
+			}
+			velocity = self getvelocity();
+			velocitylength = length( self getvelocity() );
+			if ( isDefined( self.has_legs ) )
+			{
+				iscrawler = !self.has_legs;
+			}
+			isleaper = self is_leaper();
+			while ( is_true( self.is_leaping ) )
+			{
+				wait 0.1;
+			}
+			if ( !self_on_goo )
+			{
+				self animcustom( ::zombie_moveongoo_animcustom_recover );
+				self waittill( "zombie_MoveOnGoo_animCustom_recover_done" );
+				break;
+			}
+			else
+			{
+				if ( velocitylength <= 0.2 )
+				{
+					self animmode( "normal" );
+					wait 0.1;
+					self animmode( "slide" );
+				}
+				if ( !self.sliding_on_goo || !issubstr( self.zombie_move_speed, "slide" ) )
+				{
+					if ( !iscrawler && !isleaper && !isDefined( self.fell_while_sliding ) && canzombieongoofall() )
+					{
+						self animcustom( ::zombie_moveongoo_animcustom_fall );
+						self waittill( "zombie_MoveOnGoo_animCustom_fall_done" );
+					}
+				}
+				else self.sliding_on_goo = 1;
+				if ( velocitylength <= 0.2 )
+				{
+					wait 0.1;
+				}
+				self animmode( "slide" );
+				self orientmode( "face enemy" );
+				if ( self.zombie_move_speed == "sprint" )
+				{
+					if ( !isDefined( self.zombie_move_speed ) || isDefined( self.zombie_move_speed ) && self.zombie_move_speed != "sprint_slide" )
+					{
+						animstatedef = self maps/mp/animscripts/zm_utility::append_missing_legs_suffix( "sprint_slide" );
+						self set_zombie_run_cycle( animstatedef );
+					}
+					break;
+				}
+				else if ( self.zombie_move_speed == "run" )
+				{
+					if ( !isDefined( self.zombie_move_speed ) || isDefined( self.zombie_move_speed ) && self.zombie_move_speed != "run_slide" )
+					{
+						animstatedef = self maps/mp/animscripts/zm_utility::append_missing_legs_suffix( "run_slide" );
+						self set_zombie_run_cycle( animstatedef );
+					}
+					break;
+				}
+				else
+				{
+					if ( !isDefined( self.zombie_move_speed ) || isDefined( self.zombie_move_speed ) && self.zombie_move_speed != "walk_slide" )
+					{
+						animstatedef = self maps/mp/animscripts/zm_utility::append_missing_legs_suffix( "walk_slide" );
+						self set_zombie_run_cycle( animstatedef );
+					}
+				}
+			}
+			wait 0.05;
+		}
+	}
+	zombiemoveongoo_gobacktonormal();
+}
+
+zombie_moveongoo_animcustom_fall()
+{
+	self endon( "death" );
+	self endon( "removed" );
+	level endon( "intermission" );
+	self.fell_while_sliding = 1;
+	self animmode( "normal" );
+	self orientmode( "face angle", self.angles[ 1 ] );
+	fallanimstatedef = "zm_move_slide_fall";
+	self setanimstatefromasd( fallanimstatedef );
+	maps/mp/animscripts/zm_shared::donotetracks( "slide_fall_anim" );
+	self notify( "zombie_MoveOnGoo_animCustom_fall_done" );
+}
+
+zombie_moveongoo_animcustom_recover()
+{
+	self endon( "death" );
+	self endon( "removed" );
+	level endon( "intermission" );
+	self.recovering_from_goo = 1;
+	if ( randomint( 100 ) < 50 )
+	{
+		animstatedef = maps/mp/animscripts/zm_utility::append_missing_legs_suffix( "zm_move_slide_recover" );
+		self setanimstatefromasd( animstatedef );
+		maps/mp/animscripts/zm_shared::donotetracks( "slide_recover_anim" );
+	}
+	self.recovering_from_goo = 0;
+	zombiemoveongoo_gobacktonormal();
+	self notify( "zombie_MoveOnGoo_animCustom_recover_done" );
+}
+
+zombiemoveongoo_on_killanimscript()
+{
+	self endon( "death" );
+	self endon( "removed" );
+	level endon( "intermission" );
+	self notify( "zombieMoveOnGoo_on_killAnimScript_thread" );
+	self endon( "zombieMoveOnGoo_on_killAnimScript_thread" );
+	self waittill_any( "endOnGoo", "killanimscript" );
+	zombiemoveongoo_gobacktonormal();
+}
+
+zombiemoveongoo_gobacktonormal()
+{
+	self animmode( "normal" );
+	self set_zombie_run_cycle();
+	self.sliding_on_goo = 0;
+	self.fell_while_sliding = undefined;
+	self notify( "zombieMoveOnGoo_on_killAnimScript_thread" );
+	self notify( "endOnGoo" );
+	self.forcemovementscriptstate = 0;
+	if ( !is_true( self.completed_emerging_into_playable_area ) )
+	{
+	/*
+/#
+		assert( isDefined( self.first_node ) );
+#/
+	*/
+		self maps/mp/zombies/_zm_spawner::reset_attack_spot();
+		self orientmode( "face default" );
+		self thread maps/mp/zombies/_zm_spawner::zombie_goto_entrance( self.first_node );
+	}
+	else
+	{
+		self orientmode( "face enemy" );
+		self thread maps/mp/zombies/_zm_ai_basic::find_flesh();
+	}
+}
+
+zombie_can_slip()
+{
+	if ( is_true( self.barricade_enter ) )
+	{
+		return 0;
+	}
+	if ( is_true( self.is_traversing ) )
+	{
+		return 0;
+	}
+	if ( !is_true( self.completed_emerging_into_playable_area ) && !isDefined( self.first_node ) )
+	{
+		return 0;
+	}
+	if ( is_true( self.is_leaping ) )
+	{
+		return 0;
+	}
+	return 1;
+}
+
+zombie_set_slipping( onoff )
+{
+	if ( isDefined( self ) )
+	{
+		self.is_on_goo = onoff;
+		if ( onoff )
+		{
+			self thread zombiemoveongoo();
+		}
+	}
+}
+
+slippery_spot_choke( lifetime )
+{
+	level.sliquifier_distance_checks++;
+	if ( level.sliquifier_distance_checks >= 32 )
+	{
+		level.sliquifier_distance_checks = 0;
+		lifetime -= 0.05;
+		wait 0.05;
+	}
+	return lifetime;
+}
+
+add_slippery_spot( origin, duration, startpos )
+{
+	wait 0.5;
+	level.slippery_spot_count++;
+	hit_norm = vectornormalize( startpos - origin );
+	hit_from = 6 * hit_norm;
+	trace_height = 120;
+	trace = bullettrace( origin + hit_from, origin + hit_from + ( 0, 0, trace_height * -1 ), 0, undefined );
+	if ( isDefined( trace[ "entity" ] ) )
+	{
+		parent = trace[ "entity" ];
+		if ( is_true( parent.can_move ) )
+		{
+			return;
+		}
+	}
+	fxorigin = origin + hit_from;
+	/*
+/#
+	red = ( 0, 0, 1 );
+	green = ( 0, 0, 1 );
+	dkgreen = vectorScale( ( 0, 0, 1 ), 0,15 );
+	blue = ( 0, 0, 1 );
+	grey = vectorScale( ( 0, 0, 1 ), 0,3 );
+	black = ( 0, 0, 1 );
+	slipgun_debug_line( origin, origin + hit_from, red, duration );
+	if ( trace[ "fraction" ] == 1 )
+	{
+		slipgun_debug_line( origin + hit_from, origin + hit_from + ( 0, 0, trace_height * -1 ), grey, duration );
+	}
+	else
+	{
+		slipgun_debug_line( origin + hit_from, trace[ "position" ], green, duration );
+		slipgun_debug_line( trace[ "position" ], origin + hit_from + ( 0, 0, trace_height * -1 ), dkgreen, duration );
+#/
+	}
+	*/
+	if ( trace[ "fraction" ] == 1 )
+	{
+		return;
+	}
+	moving_parent = undefined;
+	moving_parent_start = ( 0, 0, 1 );
+	if ( isDefined( trace[ "entity" ] ) )
+	{
+		parent = trace[ "entity" ];
+		if ( is_true( parent.can_move ) )
+		{
+			return;
+		}
+	}
+	origin = trace[ "position" ];
+	thread pool_of_goo( fxorigin, duration );
+	if ( !isDefined( level.slippery_spots ) )
+	{
+		level.slippery_spots = [];
+	}
+	level.slippery_spots[ level.slippery_spots.size ] = origin;
+	radius = 60;
+	height = 48;
+	/*
+/#
+	thread slipgun_debug_circle( origin, radius, duration, 0, moving_parent, moving_parent_start );
+#/
+	*/
+	slicked_players = [];
+	slicked_zombies = [];
+	lifetime = duration;
+	radius2 = radius * radius;
+	while ( lifetime > 0 )
+	{
+		oldlifetime = lifetime;
+		_a612 = get_players();
+		_k612 = getFirstArrayKey( _a612 );
+		while ( isDefined( _k612 ) )
+		{
+			player = _a612[ _k612 ];
+			num = player getentitynumber();
+			morigin = origin;
+			if ( isDefined( moving_parent ) )
+			{
+				morigin = origin + ( moving_parent.origin - moving_parent_start );
+			}
+			if ( distance2dsquared( player.origin, morigin ) < radius2 )
+			{
+				should_be_slick = abs( player.origin[ 2 ] - morigin[ 2 ] ) < height;
+			}
+			is_slick = isDefined( slicked_players[ num ] );
+			if ( should_be_slick != is_slick )
+			{
+				if ( !isDefined( player.slick_count ) )
+				{
+					player.slick_count = 0;
+				}
+				if ( should_be_slick )
+				{
+					player.slick_count++;
+					slicked_players[ num ] = player;
+				}
+				else
+				{
+					player.slick_count--;
+/*
+/#
+					assert( player.slick_count >= 0 );
+#/
+*/
+				}
+				player forceslick( player.slick_count );
+			}
+			lifetime = slippery_spot_choke( lifetime );
+			_k612 = getNextArrayKey( _a612, _k612 );
+		}
+		zombies = get_round_enemy_array();
+		while ( isDefined( zombies ) )
+		{
+			_a645 = zombies;
+			_k645 = getFirstArrayKey( _a645 );
+			while ( isDefined( _k645 ) )
+			{
+				zombie = _a645[ _k645 ];
+				if ( isDefined( zombie ) )
+				{
+					num = zombie getentitynumber();
+					morigin = origin;
+					if ( isDefined( moving_parent ) )
+					{
+						morigin = origin + ( moving_parent.origin - moving_parent_start );
+					}
+					if ( distance2dsquared( zombie.origin, morigin ) < radius2 )
+					{
+						should_be_slick = abs( zombie.origin[ 2 ] - morigin[ 2 ] ) < height;
+					}
+					if ( should_be_slick && !zombie zombie_can_slip() )
+					{
+						should_be_slick = 0;
+					}
+					is_slick = isDefined( slicked_zombies[ num ] );
+					if ( should_be_slick != is_slick )
+					{
+						if ( !isDefined( zombie.slick_count ) )
+						{
+							zombie.slick_count = 0;
+						}
+						if ( should_be_slick )
+						{
+							zombie.slick_count++;
+							slicked_zombies[ num ] = zombie;
+						}
+						else
+						{
+							if ( zombie.slick_count > 0 )
+							{
+								zombie.slick_count--;
+
+							}
+						}
+						zombie zombie_set_slipping( zombie.slick_count > 0 );
+					}
+					lifetime = slippery_spot_choke( lifetime );
+				}
+				_k645 = getNextArrayKey( _a645, _k645 );
+			}
+		}
+		if ( oldlifetime == lifetime )
+		{
+			lifetime -= 0.05;
+			wait 0.05;
+		}
+	}
+	_a684 = slicked_players;
+	_k684 = getFirstArrayKey( _a684 );
+	while ( isDefined( _k684 ) )
+	{
+		player = _a684[ _k684 ];
+		player.slick_count--;
+		/*
+
+/#
+		assert( player.slick_count >= 0 );
+#/
+	*/
+		player forceslick( player.slick_count );
+		_k684 = getNextArrayKey( _a684, _k684 );
+	}
+	_a690 = slicked_zombies;
+	_k690 = getFirstArrayKey( _a690 );
+	while ( isDefined( _k690 ) )
+	{
+		zombie = _a690[ _k690 ];
+		if ( isDefined( zombie ) )
+		{
+			if ( zombie.slick_count > 0 )
+			{
+				zombie.slick_count--;
+
+			}
+			zombie zombie_set_slipping( zombie.slick_count > 0 );
+		}
+		_k690 = getNextArrayKey( _a690, _k690 );
+	}
+	arrayremovevalue( level.slippery_spots, origin, 0 );
+	level.slippery_spot_count--;
+
+}
+
+pool_of_goo( origin, duration )
+{
+	effect_life = 24;
+	if ( duration > effect_life )
+	{
+		pool_of_goo( origin, duration - effect_life );
+		duration = effect_life;
+	}
+	if ( isDefined( level._effect[ "slipgun_splatter" ] ) )
+	{
+		playfx( level._effect[ "slipgun_splatter" ], origin );
+	}
+	wait duration;
+}
+
+explode_into_goo( player, chain_depth )
+{
+	if ( isDefined( self.marked_for_insta_upgraded_death ) )
+	{
+		return;
+	}
+	tag = "J_SpineLower";
+	if ( is_true( self.isdog ) )
+	{
+		tag = "tag_origin";
+	}
+	self.guts_explosion = 1;
+	self playsound( "wpn_slipgun_zombie_explode" );
+	if ( isDefined( level._effect[ "slipgun_explode" ] ) )
+	{
+		playfx( level._effect[ "slipgun_explode" ], self gettagorigin( tag ) );
+	}
+	if ( !is_true( self.isdog ) )
+	{
+		wait 0.1;
+	}
+	self ghost();
+	if ( !isDefined( self.goo_chain_depth ) )
+	{
+		self.goo_chain_depth = chain_depth;
+	}
+	chain_radius = level.zombie_vars[ "slipgun_chain_radius" ];
+	level thread explode_to_near_zombies( player, self.origin, chain_radius, self.goo_chain_depth );
+}
+
+explode_to_near_zombies( player, origin, radius, chain_depth )
+{
+	if ( level.zombie_vars[ "slipgun_max_kill_chain_depth" ] > 0 && chain_depth > level.zombie_vars[ "slipgun_max_kill_chain_depth" ] )
+	{
+		return;
+	}
+	enemies = get_round_enemy_array();
+	enemies = get_array_of_closest( origin, enemies );
+	minchainwait = level.zombie_vars[ "slipgun_chain_wait_min" ];
+	maxchainwait = level.zombie_vars[ "slipgun_chain_wait_max" ];
+	rsquared = radius * radius;
+	tag = "J_Head";
+	marked_zombies = [];
+	while ( isDefined( enemies ) && enemies.size )
+	{
+		index = 0;
+		enemy = enemies[ index ];
+		while ( distancesquared( enemy.origin, origin ) < rsquared )
+		{
+			if ( isalive( enemy ) && !is_true( enemy.guts_explosion ) && !is_true( enemy.nuked ) && !isDefined( enemy.slipgun_sizzle ) )
+			{
+				trace = bullettrace( origin + vectorScale( ( 0, 0, 1 ), 50 ), enemy.origin + vectorScale( ( 0, 0, 1 ), 50 ), 0, undefined, 1 );
+				if ( isDefined( trace[ "fraction" ] ) && trace[ "fraction" ] == 1 )
+				{
+					enemy.slipgun_sizzle = playfxontag( level._effect[ "slipgun_simmer" ], enemy, tag );
+					marked_zombies[ marked_zombies.size ] = enemy;
+				}
+			}
+			index++;
+			if ( index >= enemies.size )
+			{
+				break;
+			}
+			else
+			{
+				enemy = enemies[ index ];
+			}
+		}
+	}
+	while ( isDefined( marked_zombies ) && marked_zombies.size )
+	{
+		_a799 = marked_zombies;
+		_k799 = getFirstArrayKey( _a799 );
+		while ( isDefined( _k799 ) )
+		{
+			enemy = _a799[ _k799 ];
+			if ( isalive( enemy ) && !is_true( enemy.guts_explosion ) && !is_true( enemy.nuked ) )
+			{
+				wait randomfloatrange( minchainwait, maxchainwait );
+				if ( isalive( enemy ) && !is_true( enemy.guts_explosion ) && !is_true( enemy.nuked ) )
+				{
+					if ( !isDefined( enemy.goo_chain_depth ) )
+					{
+						enemy.goo_chain_depth = chain_depth;
+					}
+					if ( enemy.health > 0 )
+					{
+						if ( player maps/mp/zombies/_zm_powerups::is_insta_kill_active() )
+						{
+							enemy.health = 1;
+						}
+						enemy dodamage( level.slipgun_damage, origin, player, player, "none", level.slipgun_damage_mod, 0, "slip_goo_zm" );
+					}
+					if ( level.slippery_spot_count < level.zombie_vars[ "slipgun_reslip_max_spots" ] )
+					{
+						if ( isDefined( enemy.slick_count ) && enemy.slick_count == 0 && enemy.health <= 0 )
+						{
+							if ( level.zombie_vars[ "slipgun_reslip_rate" ] > 0 && randomint( level.zombie_vars[ "slipgun_reslip_rate" ] ) == 0 )
+							{
+								startpos = origin;
+								duration = 24;
+								thread add_slippery_spot( enemy.origin, duration, startpos );
+							}
+						}
+					}
+				}
+			}
+			_k799 = getNextArrayKey( _a799, _k799 );
+		}
+	}
+}
+
+slipgun_zombie_1st_hit_response( upgraded, player )
+{
+	self notify( "stop_find_flesh" );
+	self notify( "zombie_acquire_enemy" );
+	self orientmode( "face default" );
+	self.ignoreall = 1;
+	self.gibbed = 1;
+	if ( isalive( self ) )
+	{
+		if ( !isDefined( self.goo_chain_depth ) )
+		{
+			self.goo_chain_depth = 0;
+		}
+		if ( self.health > 0 )
+		{
+			if ( player maps/mp/zombies/_zm_powerups::is_insta_kill_active() )
+			{
+				self.health = 1;
+			}
+			self dodamage( level.slipgun_damage, self.origin, player, player, "none", level.slipgun_damage_mod, 0, "slip_goo_zm" );
+		}
+	}
+}
+
+slipgun_zombie_hit_response_internal( mod, damageweapon, player )
+{
+	if ( !self is_slipgun_damage( mod, damageweapon ) && !is_slipgun_explosive_damage( mod, damageweapon ) )
+	{
+		return 0;
+	}
+	self playsound( "wpn_slipgun_zombie_impact" );
+	upgraded = damageweapon == "slipgun_upgraded_zm";
+	self thread slipgun_zombie_1st_hit_response( upgraded, player );
+	if ( isDefined( player ) && isplayer( player ) )
+	{
+		player thread slipgun_play_zombie_hit_vox();
+	}
+	return 1;
+}
+
+slipgun_zombie_damage_response( mod, hit_location, hit_origin, player, amount )
+{
+	return slipgun_zombie_hit_response_internal( mod, self.damageweapon, player );
+}
+
+slipgun_zombie_death_response()
+{
+	if ( !self is_slipgun_damage( self.damagemod, self.damageweapon ) && !is_slipgun_explosive_damage( self.damagemod, self.damageweapon ) )
+	{
+		return 0;
+	}
+	level maps/mp/zombies/_zm_spawner::zombie_death_points( self.origin, self.damagemod, self.damagelocation, self.attacker, self );
+	self explode_into_goo( self.attacker, 0 );
+	return 1;
+}
+
+is_slipgun_explosive_damage( mod, weapon )
+{
+	if ( isDefined( weapon ) )
+	{
+		if ( weapon != "slip_goo_zm" && weapon != "slip_bolt_zm" )
+		{
+			return weapon == "slip_bolt_upgraded_zm";
+		}
+	}
+}
+
+is_slipgun_damage( mod, weapon )
+{
+	if ( isDefined( weapon ) )
+	{
+		if ( weapon != "slipgun_zm" )
+		{
+			return weapon == "slipgun_upgraded_zm";
+		}
+	}
+}
+
+slipgun_play_zombie_hit_vox()
+{
+	rand = randomintrange( 0, 101 );
+	if ( rand >= 20 )
+	{
+		self maps/mp/zombies/_zm_audio::create_and_play_dialog( "kill", "human" );
+	}
+}
+

zm_highrise_patch/readme.md

@@ -0,0 +1,14 @@
+### The following gscs compile and run successfully with no known errors:
+
+### The following scripts compile and run successfully with minor errors:
+
+### The following scripts compile and run successfully with major errors:
+```
+zm_highrise_patch/maps/mp/zombies/_zm_weap_slipgun.gsc
+```
+### The following scripts compile and run serverside but clients cannot join due to exe_client_field_mismatch
+
+### The following scripts compile but cause a minidump or other severe error:
+
+### notes:
+

zm_transit_patch/maps/mp/gametypes_zm/zgrief.gsc

@@ -0,0 +1,730 @@
+#include maps/mp/zombies/_zm_equipment;
+#include maps/mp/zombies/_zm_weapons;
+#include maps/mp/zombies/_zm_audio_announcer;
+#include maps/mp/zombies/_zm_zonemgr;
+#include maps/mp/_demo;
+#include maps/mp/zombies/_zm_laststand;
+#include maps/mp/zombies/_zm_weap_cymbal_monkey;
+#include maps/mp/zombies/_zm_magicbox;
+#include maps/mp/zombies/_zm_game_module;
+#include maps/mp/zombies/_zm;
+#include maps/mp/zombies/_zm_game_module_meat_utility;
+#include maps/mp/zombies/_zm_powerups;
+#include maps/mp/gametypes_zm/zmeat;
+#include maps/mp/zombies/_zm_stats;
+#include maps/mp/zombies/_zm_utility;
+#include common_scripts/utility;
+#include maps/mp/gametypes_zm/_hud_util;
+#include maps/mp/_utility;
+#include maps/mp/zombies/_zm_spawner;
+
+main()
+{
+	maps/mp/gametypes_zm/_zm_gametype::main();
+	level.onprecachegametype = ::onprecachegametype;
+	level.onstartgametype = ::onstartgametype;
+	level.custom_spectate_permissions = ::setspectatepermissionsgrief;
+	level._game_module_custom_spawn_init_func = ::custom_spawn_init_func;
+	//level._game_module_stat_update_func = ::maps/mp/zombies/_zm_stats::grief_custom_stat_update;
+	level._game_module_player_damage_callback = ::game_module_player_damage_callback;
+	level.custom_end_screen = ::custom_end_screen;
+	level.gamemode_map_postinit[ "zgrief" ] = ::postinit_func;
+	level._supress_survived_screen = 1;
+	level.game_module_team_name_override_og_x = 155;
+	level.prevent_player_damage = ::player_prevent_damage;
+	level._game_module_player_damage_grief_callback = ::game_module_player_damage_grief_callback;
+	level._grief_reset_message = ::grief_reset_message;
+	level._game_module_player_laststand_callback = ::grief_laststand_weapon_save;
+	level.onplayerspawned_restore_previous_weapons = ::grief_laststand_weapons_return;
+	level.game_module_onplayerconnect = ::grief_onplayerconnect;
+	level.game_mode_spawn_player_logic = ::game_mode_spawn_player_logic;
+	level.game_mode_custom_onplayerdisconnect = ::grief_onplayerdisconnect;
+	maps/mp/gametypes_zm/_zm_gametype::post_gametype_main( "zgrief" );
+}
+
+grief_onplayerconnect()
+{
+	self thread move_team_icons();
+	self thread zgrief_player_bled_out_msg();
+}
+
+grief_onplayerdisconnect( disconnecting_player )
+{
+	level thread update_players_on_bleedout_or_disconnect( disconnecting_player );
+}
+
+setspectatepermissionsgrief()
+{
+	self allowspectateteam( "allies", 1 );
+	self allowspectateteam( "axis", 1 );
+	self allowspectateteam( "freelook", 0 );
+	self allowspectateteam( "none", 1 );
+}
+
+custom_end_screen()
+{
+	players = get_players();
+	i = 0;
+	while ( i < players.size )
+	{
+		players[ i ].game_over_hud = newclienthudelem( players[ i ] );
+		players[ i ].game_over_hud.alignx = "center";
+		players[ i ].game_over_hud.aligny = "middle";
+		players[ i ].game_over_hud.horzalign = "center";
+		players[ i ].game_over_hud.vertalign = "middle";
+		players[ i ].game_over_hud.y -= 130;
+		players[ i ].game_over_hud.foreground = 1;
+		players[ i ].game_over_hud.fontscale = 3;
+		players[ i ].game_over_hud.alpha = 0;
+		players[ i ].game_over_hud.color = ( 1, 1, 1 );
+		players[ i ].game_over_hud.hidewheninmenu = 1;
+		players[ i ].game_over_hud settext( &"ZOMBIE_GAME_OVER" );
+		players[ i ].game_over_hud fadeovertime( 1 );
+		players[ i ].game_over_hud.alpha = 1;
+		if ( players[ i ] issplitscreen() )
+		{
+			players[ i ].game_over_hud.fontscale = 2;
+			players[ i ].game_over_hud.y += 40;
+		}
+		players[ i ].survived_hud = newclienthudelem( players[ i ] );
+		players[ i ].survived_hud.alignx = "center";
+		players[ i ].survived_hud.aligny = "middle";
+		players[ i ].survived_hud.horzalign = "center";
+		players[ i ].survived_hud.vertalign = "middle";
+		players[ i ].survived_hud.y -= 100;
+		players[ i ].survived_hud.foreground = 1;
+		players[ i ].survived_hud.fontscale = 2;
+		players[ i ].survived_hud.alpha = 0;
+		players[ i ].survived_hud.color = ( 1, 1, 1 );
+		players[ i ].survived_hud.hidewheninmenu = 1;
+		if ( players[ i ] issplitscreen() )
+		{
+			players[ i ].survived_hud.fontscale = 1.5;
+			players[ i ].survived_hud.y += 40;
+		}
+		winner_text = &"ZOMBIE_GRIEF_WIN";
+		loser_text = &"ZOMBIE_GRIEF_LOSE";
+		if ( level.round_number < 2 )
+		{
+			winner_text = &"ZOMBIE_GRIEF_WIN_SINGLE";
+			loser_text = &"ZOMBIE_GRIEF_LOSE_SINGLE";
+		}
+		if ( isDefined( level.host_ended_game ) && level.host_ended_game )
+		{
+			players[ i ].survived_hud settext( &"MP_HOST_ENDED_GAME" );
+		}
+		else
+		{
+			if ( isDefined( level.gamemodulewinningteam ) && players[ i ]._encounters_team == level.gamemodulewinningteam )
+			{
+				players[ i ].survived_hud settext( winner_text, level.round_number );
+				break;
+			}
+			else
+			{
+				players[ i ].survived_hud settext( loser_text, level.round_number );
+			}
+		}
+		players[ i ].survived_hud fadeovertime( 1 );
+		players[ i ].survived_hud.alpha = 1;
+		i++;
+	}
+}
+
+postinit_func()
+{
+	level.min_humans = 1;
+	level.zombie_ai_limit = 24;
+	level.prevent_player_damage = ::player_prevent_damage;
+	level.lock_player_on_team_score = 1;
+	level._zombie_spawning = 0;
+	level._get_game_module_players = undefined;
+	level.powerup_drop_count = 0;
+	level.is_zombie_level = 1;
+	setmatchtalkflag( "DeadChatWithDead", 1 );
+	setmatchtalkflag( "DeadChatWithTeam", 1 );
+	setmatchtalkflag( "DeadHearTeamLiving", 1 );
+	setmatchtalkflag( "DeadHearAllLiving", 1 );
+	setmatchtalkflag( "EveryoneHearsEveryone", 1 );
+}
+
+grief_game_end_check_func()
+{
+	return 0;
+}
+
+player_prevent_damage( einflictor, eattacker, idamage, idflags, smeansofdeath, sweapon, vpoint, vdir, shitloc, psoffsettime )
+{
+	if ( isDefined( eattacker ) && isplayer( eattacker ) && self != eattacker && !eattacker hasperk( "specialty_noname" ) && isDefined( self.is_zombie ) && !self.is_zombie )
+	{
+		return 1;
+	}
+	return 0;
+}
+
+game_module_player_damage_grief_callback( einflictor, eattacker, idamage, idflags, smeansofdeath, sweapon, vpoint, vdir, shitloc, psoffsettime )
+{
+	penalty = 10;
+	if ( isDefined( eattacker ) && isplayer( eattacker ) && eattacker != self && eattacker.team != self.team && smeansofdeath == "MOD_MELEE" )
+	{
+		self applyknockback( idamage, vdir );
+	}
+}
+
+onprecachegametype()
+{
+	level.playersuicideallowed = 1;
+	level.suicide_weapon = "death_self_zm";
+	precacheitem( "death_self_zm" );
+	precacheshellshock( "grief_stab_zm" );
+	precacheshader( "faction_cdc" );
+	precacheshader( "faction_cia" );
+	precacheshader( "waypoint_revive_cdc_zm" );
+	precacheshader( "waypoint_revive_cia_zm" );
+	level._effect[ "butterflies" ] = loadfx( "maps/zombie/fx_zmb_impact_noharm" );
+	level thread maps/mp/gametypes_zm/_zm_gametype::init();
+	maps/mp/gametypes_zm/_zm_gametype::rungametypeprecache( "zgrief" );
+}
+
+onstartgametype()
+{
+	level.no_end_game_check = 1;
+	level._game_module_game_end_check = ::grief_game_end_check_func;
+	level.round_end_custom_logic = ::grief_round_end_custom_logic;
+	maps/mp/gametypes_zm/_zm_gametype::setup_classic_gametype();
+	maps/mp/gametypes_zm/_zm_gametype::rungametypemain( "zgrief", ::zgrief_main );
+}
+
+zgrief_main()
+{
+	level thread maps/mp/zombies/_zm::round_start();
+	level thread maps/mp/gametypes_zm/_zm_gametype::kill_all_zombies();
+	flag_wait( "initial_blackscreen_passed" );
+	level thread maps/mp/zombies/_zm_game_module::wait_for_team_death_and_round_end();
+	players = get_players();
+	_a302 = players;
+	_k302 = getFirstArrayKey( _a302 );
+	while ( isDefined( _k302 ) )
+	{
+		player = _a302[ _k302 ];
+		player.is_hotjoin = 0;
+		_k302 = getNextArrayKey( _a302, _k302 );
+	}
+	wait 1;
+	playsoundatposition( "vox_zmba_grief_intro_0", ( 1, 1, 1 ) );
+}
+
+move_team_icons()
+{
+	self endon( "disconnect" );
+	flag_wait( "initial_blackscreen_passed" );
+	wait 0.5;
+}
+
+kill_start_chest()
+{
+	flag_wait( "initial_blackscreen_passed" );
+	wait 2;
+	start_chest = getstruct( "start_chest", "script_noteworthy" );
+	start_chest maps/mp/zombies/_zm_magicbox::hide_chest();
+}
+
+door_close_zombie_think()
+{
+	self endon( "death" );
+	while ( isalive( self ) )
+	{
+		if ( isDefined( self.enemy ) && isplayer( self.enemy ) )
+		{
+			insamezone = 0;
+			keys = getarraykeys( level.zones );
+			i = 0;
+			while ( i < keys.size )
+			{
+				if ( self maps/mp/zombies/_zm_zonemgr::entity_in_zone( keys[ i ] ) && self.enemy maps/mp/zombies/_zm_zonemgr::entity_in_zone( keys[ i ] ) )
+				{
+					insamezone = 1;
+				}
+				i++;
+			}
+			while ( insamezone )
+			{
+				wait 3;
+			}
+			nearestzombienode = getnearestnode( self.origin );
+			nearestplayernode = getnearestnode( self.enemy.origin );
+			if ( isDefined( nearestzombienode ) && isDefined( nearestplayernode ) )
+			{
+				if ( !nodesvisible( nearestzombienode, nearestplayernode ) && !nodescanpath( nearestzombienode, nearestplayernode ) )
+				{
+					self silentlyremovezombie();
+				}
+			}
+		}
+		wait 1;
+	}
+}
+
+silentlyremovezombie()
+{
+	level.zombie_total++;
+	playfx( level._effect[ "spawn_cloud" ], self.origin );
+	self.skip_death_notetracks = 1;
+	self.nodeathragdoll = 1;
+	self dodamage( self.maxhealth * 2, self.origin, self, self, "none", "MOD_SUICIDE" );
+	self self_delete();
+}
+
+zgrief_player_bled_out_msg()
+{
+	level endon( "end_game" );
+	self endon( "disconnect" );
+	while ( 1 )
+	{
+		self waittill( "bled_out" );
+		level thread update_players_on_bleedout_or_disconnect( self );
+	}
+}
+
+show_grief_hud_msg( msg, msg_parm, offset, cleanup_end_game )
+{
+	self endon( "disconnect" );
+	while ( isDefined( level.hostmigrationtimer ) )
+	{
+		wait 0.05;
+	}
+	zgrief_hudmsg = newclienthudelem( self );
+	zgrief_hudmsg.alignx = "center";
+	zgrief_hudmsg.aligny = "middle";
+	zgrief_hudmsg.horzalign = "center";
+	zgrief_hudmsg.vertalign = "middle";
+	zgrief_hudmsg.y -= 130;
+	if ( self issplitscreen() )
+	{
+		zgrief_hudmsg.y += 70;
+	}
+	if ( isDefined( offset ) )
+	{
+		zgrief_hudmsg.y += offset;
+	}
+	zgrief_hudmsg.foreground = 1;
+	zgrief_hudmsg.fontscale = 5;
+	zgrief_hudmsg.alpha = 0;
+	zgrief_hudmsg.color = ( 1, 1, 1 );
+	zgrief_hudmsg.hidewheninmenu = 1;
+	zgrief_hudmsg.font = "default";
+	if ( isDefined( cleanup_end_game ) && cleanup_end_game )
+	{
+		level endon( "end_game" );
+		zgrief_hudmsg thread show_grief_hud_msg_cleanup();
+	}
+	if ( isDefined( msg_parm ) )
+	{
+		zgrief_hudmsg settext( msg, msg_parm );
+	}
+	else
+	{
+		zgrief_hudmsg settext( msg );
+	}
+	zgrief_hudmsg changefontscaleovertime( 0.25 );
+	zgrief_hudmsg fadeovertime( 0.25 );
+	zgrief_hudmsg.alpha = 1;
+	zgrief_hudmsg.fontscale = 2;
+	wait 3.25;
+	zgrief_hudmsg changefontscaleovertime( 1 );
+	zgrief_hudmsg fadeovertime( 1 );
+	zgrief_hudmsg.alpha = 0;
+	zgrief_hudmsg.fontscale = 5;
+	wait 1;
+	zgrief_hudmsg notify( "death" );
+	if ( isDefined( zgrief_hudmsg ) )
+	{
+		zgrief_hudmsg destroy();
+	}
+}
+
+show_grief_hud_msg_cleanup()
+{
+	self endon( "death" );
+	level waittill( "end_game" );
+	if ( isDefined( self ) )
+	{
+		self destroy();
+	}
+}
+
+grief_reset_message()
+{
+	msg = &"ZOMBIE_GRIEF_RESET";
+	players = get_players();
+	if ( isDefined( level.hostmigrationtimer ) )
+	{
+		while ( isDefined( level.hostmigrationtimer ) )
+		{
+			wait 0.05;
+		}
+		wait 4;
+	}
+	_a697 = players;
+	_k697 = getFirstArrayKey( _a697 );
+	while ( isDefined( _k697 ) )
+	{
+		player = _a697[ _k697 ];
+		player thread show_grief_hud_msg( msg );
+		_k697 = getNextArrayKey( _a697, _k697 );
+	}
+	level thread maps/mp/zombies/_zm_audio_announcer::leaderdialog( "grief_restarted" );
+}
+
+grief_laststand_weapon_save( einflictor, attacker, idamage, smeansofdeath, sweapon, vdir, shitloc, psoffsettime, deathanimduration )
+{
+	self.grief_savedweapon_weapons = self getweaponslist();
+	self.grief_savedweapon_weaponsammo_stock = [];
+	self.grief_savedweapon_weaponsammo_clip = [];
+	self.grief_savedweapon_currentweapon = self getcurrentweapon();
+	self.grief_savedweapon_grenades = self get_player_lethal_grenade();
+	if ( isDefined( self.grief_savedweapon_grenades ) )
+	{
+		self.grief_savedweapon_grenades_clip = self getweaponammoclip( self.grief_savedweapon_grenades );
+	}
+	self.grief_savedweapon_tactical = self get_player_tactical_grenade();
+	if ( isDefined( self.grief_savedweapon_tactical ) )
+	{
+		self.grief_savedweapon_tactical_clip = self getweaponammoclip( self.grief_savedweapon_tactical );
+	}
+	i = 0;
+	while ( i < self.grief_savedweapon_weapons.size )
+	{
+		self.grief_savedweapon_weaponsammo_clip[ i ] = self getweaponammoclip( self.grief_savedweapon_weapons[ i ] );
+		self.grief_savedweapon_weaponsammo_stock[ i ] = self getweaponammostock( self.grief_savedweapon_weapons[ i ] );
+		i++;
+	}
+	if ( isDefined( self.hasriotshield ) && self.hasriotshield )
+	{
+		self.grief_hasriotshield = 1;
+	}
+	if ( self hasweapon( "claymore_zm" ) )
+	{
+		self.grief_savedweapon_claymore = 1;
+		self.grief_savedweapon_claymore_clip = self getweaponammoclip( "claymore_zm" );
+	}
+	if ( isDefined( self.current_equipment ) )
+	{
+		self.grief_savedweapon_equipment = self.current_equipment;
+	}
+}
+
+grief_laststand_weapons_return()
+{
+	if ( isDefined( level.isresetting_grief ) && !level.isresetting_grief )
+	{
+		return 0;
+	}
+	if ( !isDefined( self.grief_savedweapon_weapons ) )
+	{
+		return 0;
+	}
+	primary_weapons_returned = 0;
+	_a766 = self.grief_savedweapon_weapons;
+	index = getFirstArrayKey( _a766 );
+	while ( isDefined( index ) )
+	{
+		weapon = _a766[ index ];
+		if ( isDefined( self.grief_savedweapon_grenades ) || weapon == self.grief_savedweapon_grenades && isDefined( self.grief_savedweapon_tactical ) && weapon == self.grief_savedweapon_tactical )
+		{
+		}
+		else
+		{
+			if ( isweaponprimary( weapon ) )
+			{
+				if ( primary_weapons_returned >= 2 )
+				{
+					break;
+				}
+				else primary_weapons_returned++;
+			}
+			if ( weapon == "item_meat_zm" )
+			{
+				break;
+			}
+			else
+			{
+				self giveweapon( weapon, 0, self maps/mp/zombies/_zm_weapons::get_pack_a_punch_weapon_options( weapon ) );
+				if ( isDefined( self.grief_savedweapon_weaponsammo_clip[ index ] ) )
+				{
+					self setweaponammoclip( weapon, self.grief_savedweapon_weaponsammo_clip[ index ] );
+				}
+				if ( isDefined( self.grief_savedweapon_weaponsammo_stock[ index ] ) )
+				{
+					self setweaponammostock( weapon, self.grief_savedweapon_weaponsammo_stock[ index ] );
+				}
+			}
+		}
+		index = getNextArrayKey( _a766, index );
+	}
+	if ( isDefined( self.grief_savedweapon_grenades ) )
+	{
+		self giveweapon( self.grief_savedweapon_grenades );
+		if ( isDefined( self.grief_savedweapon_grenades_clip ) )
+		{
+			self setweaponammoclip( self.grief_savedweapon_grenades, self.grief_savedweapon_grenades_clip );
+		}
+	}
+	if ( isDefined( self.grief_savedweapon_tactical ) )
+	{
+		self giveweapon( self.grief_savedweapon_tactical );
+		if ( isDefined( self.grief_savedweapon_tactical_clip ) )
+		{
+			self setweaponammoclip( self.grief_savedweapon_tactical, self.grief_savedweapon_tactical_clip );
+		}
+	}
+	if ( isDefined( self.current_equipment ) )
+	{
+		self maps/mp/zombies/_zm_equipment::equipment_take( self.current_equipment );
+	}
+	if ( isDefined( self.grief_savedweapon_equipment ) )
+	{
+		self.do_not_display_equipment_pickup_hint = 1;
+		self maps/mp/zombies/_zm_equipment::equipment_give( self.grief_savedweapon_equipment );
+		self.do_not_display_equipment_pickup_hint = undefined;
+	}
+	if ( isDefined( self.grief_hasriotshield ) && self.grief_hasriotshield )
+	{
+		if ( isDefined( self.player_shield_reset_health ) )
+		{
+			self [[ self.player_shield_reset_health ]]();
+		}
+	}
+	if ( isDefined( self.grief_savedweapon_claymore ) && self.grief_savedweapon_claymore )
+	{
+		self giveweapon( "claymore_zm" );
+		self set_player_placeable_mine( "claymore_zm" );
+		self setactionslot( 4, "weapon", "claymore_zm" );
+		self setweaponammoclip( "claymore_zm", self.grief_savedweapon_claymore_clip );
+	}
+	primaries = self getweaponslistprimaries();
+	_a859 = primaries;
+	_k859 = getFirstArrayKey( _a859 );
+	while ( isDefined( _k859 ) )
+	{
+		weapon = _a859[ _k859 ];
+		if ( isDefined( self.grief_savedweapon_currentweapon ) && self.grief_savedweapon_currentweapon == weapon )
+		{
+			self switchtoweapon( weapon );
+			return 1;
+		}
+		_k859 = getNextArrayKey( _a859, _k859 );
+	}
+	if ( primaries.size > 0 )
+	{
+		self switchtoweapon( primaries[ 0 ] );
+		return 1;
+	}
+	return 0;
+}
+
+grief_store_player_scores()
+{
+	players = get_players();
+	_a883 = players;
+	_k883 = getFirstArrayKey( _a883 );
+	while ( isDefined( _k883 ) )
+	{
+		player = _a883[ _k883 ];
+		player._pre_round_score = player.score;
+		_k883 = getNextArrayKey( _a883, _k883 );
+	}
+}
+
+grief_restore_player_score()
+{
+	if ( !isDefined( self._pre_round_score ) )
+	{
+		self._pre_round_score = self.score;
+	}
+	if ( isDefined( self._pre_round_score ) )
+	{
+		self.score = self._pre_round_score;
+		self.pers[ "score" ] = self._pre_round_score;
+	}
+}
+
+game_mode_spawn_player_logic()
+{
+	if ( flag( "start_zombie_round_logic" ) && !isDefined( self.is_hotjoin ) )
+	{
+		self.is_hotjoin = 1;
+		return 1;
+	}
+	return 0;
+}
+
+update_players_on_bleedout_or_disconnect( excluded_player )
+{
+	other_team = undefined;
+	players = get_players();
+	players_remaining = 0;
+	_a920 = players;
+	_k920 = getFirstArrayKey( _a920 );
+	while ( isDefined( _k920 ) )
+	{
+		player = _a920[ _k920 ];
+		if ( player == excluded_player )
+		{
+		}
+		else if ( player.team == excluded_player.team )
+		{
+			if ( is_player_valid( player ) )
+			{
+				players_remaining++;
+			}
+			break;
+		}
+		_k920 = getNextArrayKey( _a920, _k920 );
+	}
+	_a937 = players;
+	_k937 = getFirstArrayKey( _a937 );
+	while ( isDefined( _k937 ) )
+	{
+		player = _a937[ _k937 ];
+		if ( player == excluded_player )
+		{
+		}
+		else if ( player.team != excluded_player.team )
+		{
+			other_team = player.team;
+			if ( players_remaining < 1 )
+			{
+				player thread show_grief_hud_msg( &"ZOMBIE_ZGRIEF_ALL_PLAYERS_DOWN", undefined, undefined, 1 );
+				player delay_thread_watch_host_migrate( 2, ::show_grief_hud_msg, &"ZOMBIE_ZGRIEF_SURVIVE", undefined, 30, 1 );
+				break;
+			}
+			else
+			{
+				player thread show_grief_hud_msg( &"ZOMBIE_ZGRIEF_PLAYER_BLED_OUT", players_remaining );
+			}
+		}
+		_k937 = getNextArrayKey( _a937, _k937 );
+	}
+	if ( players_remaining == 1 )
+	{
+		level thread maps/mp/zombies/_zm_audio_announcer::leaderdialog( "last_player", excluded_player.team );
+	}
+	if ( !isDefined( other_team ) )
+	{
+		return;
+	}
+	if ( players_remaining < 1 )
+	{
+		level thread maps/mp/zombies/_zm_audio_announcer::leaderdialog( "4_player_down", other_team );
+	}
+	else
+	{
+		level thread maps/mp/zombies/_zm_audio_announcer::leaderdialog( players_remaining + "_player_left", other_team );
+	}
+}
+
+delay_thread_watch_host_migrate( timer, func, param1, param2, param3, param4, param5, param6 )
+{
+	self thread _delay_thread_watch_host_migrate_proc( func, timer, param1, param2, param3, param4, param5, param6 );
+}
+
+_delay_thread_watch_host_migrate_proc( func, timer, param1, param2, param3, param4, param5, param6 )
+{
+	self endon( "death" );
+	self endon( "disconnect" );
+	wait timer;
+	if ( isDefined( level.hostmigrationtimer ) )
+	{
+		while ( isDefined( level.hostmigrationtimer ) )
+		{
+			wait 0.05;
+		}
+		wait timer;
+	}
+	single_thread( self, func, param1, param2, param3, param4, param5, param6 );
+}
+
+grief_round_end_custom_logic()
+{
+	waittillframeend;
+	if ( isDefined( level.gamemodulewinningteam ) )
+	{
+		level notify( "end_round_think" );
+	}
+}
+
+custom_spawn_init_func()
+{
+	array_thread( level.zombie_spawners, ::add_spawn_function, ::zombie_spawn_init );
+	array_thread( level.zombie_spawners, ::add_spawn_function, level._zombies_round_spawn_failsafe );
+}
+
+game_module_player_damage_callback( einflictor, eattacker, idamage, idflags, smeansofdeath, sweapon, vpoint, vdir, shitloc, psoffsettime )
+{
+	self.last_damage_from_zombie_or_player = 0;
+	if ( isDefined( eattacker ) )
+	{
+		if ( isplayer( eattacker ) && eattacker == self )
+		{
+			return;
+		}
+		if ( isDefined( eattacker.is_zombie ) || eattacker.is_zombie && isplayer( eattacker ) )
+		{
+			self.last_damage_from_zombie_or_player = 1;
+		}
+	}
+	if ( isDefined( self._being_shellshocked ) || self._being_shellshocked && self maps/mp/zombies/_zm_laststand::player_is_in_laststand() )
+	{
+		return;
+	}
+	if ( isplayer( eattacker ) && isDefined( eattacker._encounters_team ) && eattacker._encounters_team != self._encounters_team )
+	{
+		if ( isDefined( self.hasriotshield ) && self.hasriotshield && isDefined( vdir ) )
+		{
+			if ( isDefined( self.hasriotshieldequipped ) && self.hasriotshieldequipped )
+			{
+				if ( self maps/mp/zombies/_zm::player_shield_facing_attacker( vdir, 0.2 ) && isDefined( self.player_shield_apply_damage ) )
+				{
+					return;
+				}
+			}
+			else
+			{
+				if ( !isDefined( self.riotshieldentity ) )
+				{
+					if ( !self maps/mp/zombies/_zm::player_shield_facing_attacker( vdir, -0.2 ) && isDefined( self.player_shield_apply_damage ) )
+					{
+						return;
+					}
+				}
+			}
+		}
+		if ( isDefined( level._game_module_player_damage_grief_callback ) )
+		{
+			self [[ level._game_module_player_damage_grief_callback ]]( einflictor, eattacker, idamage, idflags, smeansofdeath, sweapon, vpoint, vdir, shitloc, psoffsettime );
+		}
+		if ( isDefined( level._effect[ "butterflies" ] ) )
+		{
+			if ( isDefined( sweapon ) && weapontype( sweapon ) == "grenade" )
+			{
+				playfx( level._effect[ "butterflies" ], self.origin + vectorScale( ( 1, 1, 1 ), 40 ) );
+			}
+			else
+			{
+				playfx( level._effect[ "butterflies" ], vpoint, vdir );
+			}
+		}
+		self thread do_game_mode_shellshock();
+		self playsound( "zmb_player_hit_ding" );
+	}
+}
+
+do_game_mode_shellshock()
+{
+	self endon( "disconnect" );
+	self._being_shellshocked = 1;
+	self shellshock( "grief_stab_zm", 0,75 );
+	wait 0.75;
+	self._being_shellshocked = 0;
+}

zm_transit_patch/maps/mp/zm_transit_utility.gsc

@@ -0,0 +1,279 @@
+#include maps/mp/_compass;
+#include maps/mp/zombies/_zm_zonemgr;
+#include maps/mp/zombies/_zm_perks;
+#include maps/mp/zombies/_zm_audio;
+#include maps/mp/zombies/_zm_score;
+#include maps/mp/zombies/_zm_utility;
+#include maps/mp/_utility;
+#include common_scripts/utility;
+
+playercanafford( player, cost )
+{
+	if ( !player usebuttonpressed() )
+	{
+		return 0;
+	}
+	if ( player in_revive_trigger() )
+	{
+		return 0;
+	}
+	if ( isDefined( cost ) )
+	{
+		if ( player.score < cost )
+		{
+			return 0;
+		}
+		player maps/mp/zombies/_zm_score::minus_to_player_score( cost );
+	}
+	return 1;
+}
+
+setinvisibletoall()
+{
+	players = get_players();
+	playerindex = 0;
+	while ( playerindex < players.size )
+	{
+		self setinvisibletoplayer( players[ playerindex ] );
+		playerindex++;
+	}
+}
+
+spawnandlinkfxtotag( effect, ent, tag )
+{
+	fxent = spawn( "script_model", ent gettagorigin( tag ) );
+	fxent setmodel( "tag_origin" );
+	fxent linkto( ent, tag );
+	wait_network_frame();
+	playfxontag( effect, fxent, "tag_origin" );
+	return fxent;
+}
+
+spawnandlinkfxtooffset( effect, ent, offsetorigin, offsetangles )
+{
+	fxent = spawn( "script_model", ( 0, 0, 0 ) );
+	fxent setmodel( "tag_origin" );
+	fxent linkto( ent, "", offsetorigin, offsetangles );
+	wait_network_frame();
+	playfxontag( effect, fxent, "tag_origin" );
+	return fxent;
+}
+
+custom_weapon_wall_prices()
+{
+	if ( !isDefined( level.zombie_include_weapons ) )
+	{
+		return;
+	}
+	weapon_spawns = [];
+	weapon_spawns = getentarray( "weapon_upgrade", "targetname" );
+	i = 0;
+	while ( i < weapon_spawns.size )
+	{
+		if ( !isDefined( level.zombie_weapons[ weapon_spawns[ i ].zombie_weapon_upgrade ] ) )
+		{
+			i++;
+			continue;
+		}
+		else
+		{
+			if ( isDefined( weapon_spawns[ i ].script_int ) )
+			{
+				cost = weapon_spawns[ i ].script_int;
+				level.zombie_weapons[ weapon_spawns[ i ].zombie_weapon_upgrade ].cost = cost;
+			}
+		}
+		i++;
+	}
+}
+
+pause_zombie_spawning()
+{
+	if ( !isDefined( level.spawnpausecount ) )
+	{
+		level.spawnpausecount = 0;
+	}
+	level.spawnpausecount++;
+	flag_clear( "spawn_zombies" );
+}
+
+try_resume_zombie_spawning()
+{
+	if ( !isDefined( level.spawnpausecount ) )
+	{
+		level.spawnpausecount = 0;
+	}
+	level.spawnpausecount--;
+
+	if ( level.spawnpausecount <= 0 )
+	{
+		level.spawnpausecount = 0;
+		flag_set( "spawn_zombies" );
+	}
+}
+
+automatonspeak( category, type, response, force_variant, override )
+{
+	if ( isDefined( level.automaton ) && !is_true( level.automaton.disabled_by_emp ) )
+	{
+		if ( type != "leaving" && type != "leaving_warning" )
+		{
+			level.automaton notify( "want_to_be_speaking" );
+			level.automaton waittill( "startspeaking" );
+		}
+		level.automaton maps/mp/zombies/_zm_audio::create_and_play_dialog( category, type, response, force_variant, override );
+	}
+}
+
+is_thedouche()
+{
+	return self.characterindex == 0;
+}
+
+is_theconspiracytheorist()
+{
+	return self.characterindex == 1;
+}
+
+is_thefarmersdaughter()
+{
+	return self.characterindex == 2;
+}
+
+is_theelectricalengineer()
+{
+	return self.characterindex == 3;
+}
+
+get_random_encounter_match( location )
+{
+	match_pool = [];
+	return random( match_pool );
+}
+
+transit_breakable_glass_init()
+{
+	glass = getentarray( "transit_glass", "targetname" );
+	if ( level.splitscreen && getDvarInt( "splitscreen_playerCount" ) > 2 )
+	{
+		array_delete( glass );
+		return;
+	}
+	array_thread( glass, ::transit_breakable_glass );
+}
+
+transit_breakable_glass()
+{
+	level endon( "intermission" );
+	self.health = 99999;
+	self setcandamage( 1 );
+	self.damage_state = 0;
+	while ( 1 )
+	{
+		self waittill( "damage", amount, attacker, direction, point, dmg_type );
+		if ( isplayer( attacker ) )
+		{
+			if ( self.damage_state == 0 )
+			{
+				self glass_gets_destroyed();
+				self.damage_state = 1;
+				self playsound( "fly_glass_break" );
+			}
+		}
+	}
+}
+
+glass_gets_destroyed()
+{
+	if ( isDefined( level._effect[ "glass_impact" ] ) )
+	{
+		playfx( level._effect[ "glass_impact" ], self.origin, anglesToForward( self.angles ) );
+	}
+	wait 0.1;
+	if ( isDefined( self.model ) && self.damage_state == 0 )
+	{
+		self setmodel( self.model + "_broken" );
+		self.damage_state = 1;
+		return;
+	}
+	else
+	{
+		self delete();
+		return;
+	}
+}
+
+solo_tombstone_removal()
+{
+	if ( getnumexpectedplayers() > 1 )
+	{
+		return;
+	}
+	level notify( "tombstone_removed" );
+	level thread maps/mp/zombies/_zm_perks::perk_machine_removal( "specialty_scavenger" );
+}
+
+sparking_power_lines()
+{
+	lines = getentarray( "power_line_sparking", "targetname" );
+}
+
+disconnect_door_zones( zone_a, zone_b, flag_name )
+{
+	level endon( "intermission" );
+	level endon( "end_game" );
+	while ( 1 )
+	{
+		flag_wait( flag_name );
+		azone = level.zones[ zone_a ].adjacent_zones[ zone_b ];
+		azone maps/mp/zombies/_zm_zonemgr::door_close_disconnect( flag_name );
+	}
+}
+
+enable_morse_code()
+{
+	level clientnotify( "mc1" );
+}
+
+disable_morse_code()
+{
+	level clientnotify( "mc0" );
+}
+
+transit_pathnode_spawning()
+{
+	precachemodel( "collision_wall_128x128x10_standard" );
+	precachemodel( "collision_wall_256x256x10_standard" );
+	precachemodel( "collision_clip_64x64x256" );
+	minimap_upperl = spawn( "script_origin", ( -12248, 9496, 552 ) );
+	minimap_upperl.targetname = "minimap_corner";
+	minimap_lowerr = spawn( "script_origin", ( 14472, -8496, -776 ) );
+	minimap_lowerr.targetname = "minimap_corner";
+	maps/mp/_compass::setupminimap( "compass_map_zm_transit" );
+	flag_wait( "start_zombie_round_logic" );
+	collision1 = spawn( "script_model", ( 2273, -126, 143 ) );
+	collision1 setmodel( "collision_wall_128x128x10_standard" );
+	collision1.angles = ( 0, 0, 0 );
+	collision1 ghost();
+	collision2 = spawn( "script_model", ( 2096, -126, 143 ) );
+	collision2 setmodel( "collision_wall_128x128x10_standard" );
+	collision2.angles = ( 0, 0, 0 );
+	collision2 ghost();
+	collision3 = spawn( "script_model", ( 1959, -126, 143 ) );
+	collision3 setmodel( "collision_wall_128x128x10_standard" );
+	collision3.angles = ( 0, 0, 0 );
+	collision3 ghost();
+	collision4 = spawn( "script_model", ( 12239, 8509, -688 ) );
+	collision4 setmodel( "collision_wall_128x128x10_standard" );
+	collision4.angles = ( 0, 0, 0 );
+	collision4 ghost();
+	collision5 = spawn( "script_model", ( 8320, -6679, 362 ) );
+	collision5 setmodel( "collision_wall_256x256x10_standard" );
+	collision5.angles = vectorScale( ( 0, 0, 0 ), 300 );
+	collision5 ghost();
+	collision5 = spawn( "script_model", ( 10068, 7272, -67 ) );
+	collision5 setmodel( "collision_clip_64x64x256" );
+	collision5.angles = ( 0, 0, 0 );
+	collision5 ghost();
+}
+

zm_transit_patch/maps/mp/zombies/_zm_weap_jetgun.gsc

@@ -0,0 +1,935 @@
+#include maps/mp/animscripts/zm_run;
+#include maps/mp/animscripts/zm_death;
+#include maps/mp/zombies/_zm_powerups;
+#include maps/mp/zombies/_zm_buildables;
+#include maps/mp/gametypes_zm/_weaponobjects;
+#include maps/mp/zombies/_zm_equipment;
+#include maps/mp/zombies/_zm_weapons;
+#include maps/mp/zombies/_zm_net;
+#include maps/mp/zombies/_zm_utility;
+#include maps/mp/_utility;
+#include common_scripts/utility;
+
+init()
+{
+	if ( !maps/mp/zombies/_zm_weapons::is_weapon_included( "jetgun_zm" ) )
+	{
+		return;
+	}
+	maps/mp/zombies/_zm_equipment::register_equipment( "jetgun_zm", &"ZOMBIE_EQUIP_JETGUN_PICKUP_HINT_STRING", &"ZOMBIE_EQUIP_JETGUN_HOWTO", "jetgun_zm_icon", "jetgun", ::jetgun_activation_watcher_thread, undefined, ::dropjetgun, ::pickupjetgun );
+	maps/mp/gametypes_zm/_weaponobjects::createretrievablehint( "jetgun", &"ZOMBIE_EQUIP_JETGUN_PICKUP_HINT_STRING" );
+	level._effect[ "jetgun_smoke_cloud" ] = loadfx( "weapon/thunder_gun/fx_thundergun_smoke_cloud" );
+	level._effect[ "jetgun_overheat" ] = loadfx( "weapon/jet_gun/fx_jetgun_overheat" );
+	level._effect[ "jetgun_vortex" ] = loadfx( "weapon/jet_gun/fx_jetgun_on" );
+	level._effect[ "jetgun_meat_grinder" ] = loadfx( "weapon/jet_gun/fx_jetgun_kill" );
+	set_zombie_var( "jetgun_cylinder_radius", 1024 );
+	set_zombie_var( "jetgun_grind_range", 128 );
+	set_zombie_var( "jetgun_gib_range", 256 );
+	set_zombie_var( "jetgun_gib_damage", 50 );
+	set_zombie_var( "jetgun_knockdown_range", 256 );
+	set_zombie_var( "jetgun_drag_range", 2048 );
+	set_zombie_var( "jetgun_knockdown_damage", 15 );
+	set_zombie_var( "powerup_move_dist", 50 );
+	set_zombie_var( "powerup_drag_range", 500 );
+	level.jetgun_pulled_in_range = int( level.zombie_vars[ "jetgun_drag_range" ] / 8 ) * ( level.zombie_vars[ "jetgun_drag_range" ] / 8 );
+	level.jetgun_pulling_in_range = int( level.zombie_vars[ "jetgun_drag_range" ] / 4 ) * ( level.zombie_vars[ "jetgun_drag_range" ] / 4 );
+	level.jetgun_inner_range = int( level.zombie_vars[ "jetgun_drag_range" ] / 2 ) * ( level.zombie_vars[ "jetgun_drag_range" ] / 2 );
+	level.jetgun_outer_edge = int( level.zombie_vars[ "jetgun_drag_range" ] * level.zombie_vars[ "jetgun_drag_range" ] );
+	level.jetgun_gib_refs = [];
+	level.jetgun_gib_refs[ level.jetgun_gib_refs.size ] = "guts";
+	level.jetgun_gib_refs[ level.jetgun_gib_refs.size ] = "right_arm";
+	level.jetgun_gib_refs[ level.jetgun_gib_refs.size ] = "left_arm";
+	level.jetgun_gib_refs[ level.jetgun_gib_refs.size ] = "right_leg";
+	level.jetgun_gib_refs[ level.jetgun_gib_refs.size ] = "left_leg";
+	level.jetgun_gib_refs[ level.jetgun_gib_refs.size ] = "no_legs";
+	/*
+/#
+	level thread jetgun_devgui_dvar_think();
+	level.zm_devgui_jetgun_never_overheat = ::never_overheat;
+#/
+	*/
+	onplayerconnect_callback( ::jetgun_on_player_connect );
+}
+
+dropjetgun()
+{
+	item = self maps/mp/zombies/_zm_equipment::placed_equipment_think( "t6_wpn_zmb_jet_gun_world", "jetgun_zm", self.origin + vectorScale( ( 1, 0, 1 ), 30 ), self.angles );
+	if ( isDefined( item ) )
+	{
+		item.overheating = self.jetgun_overheating;
+		item.heatval = self.jetgun_heatval;
+		item.original_owner = self;
+		item.owner = undefined;
+		item.name = "jetgun_zm";
+		item.requires_pickup = 1;
+	}
+	self.jetgun_overheating = undefined;
+	self.jetgun_heatval = undefined;
+	self takeweapon( "jetgun_zm" );
+	return item;
+}
+
+pickupjetgun( item )
+{
+	item.owner = self;
+	if ( isDefined( item.overheating ) && isDefined( item.heatval ) )
+	{
+		self.jetgun_overheating = item.overheating;
+		self.jetgun_heatval = item.heatval;
+	}
+	item.overheating = undefined;
+	item.heatval = undefined;
+	self setcurrentweaponspinlerp( 0 );
+}
+
+jetgun_activation_watcher_thread()
+{
+	self endon( "zombified" );
+	self endon( "disconnect" );
+	self endon( "jetgun_zm_taken" );
+	while ( 1 )
+	{
+		self waittill_either( "jetgun_zm_activate", "jetgun_zm_deactivate" );
+	}
+}
+
+jetgun_devgui_dvar_think()
+{
+/*
+/#
+	if ( !maps/mp/zombies/_zm_weapons::is_weapon_included( "jetgun_zm" ) )
+	{
+		return;
+	}
+	setdvar( "scr_jetgun_cylinder_radius", level.zombie_vars[ "jetgun_cylinder_radius" ] );
+	setdvar( "scr_jetgun_grind_range", level.zombie_vars[ "jetgun_grind_range" ] );
+	setdvar( "scr_jetgun_drag_range", level.zombie_vars[ "jetgun_drag_range" ] );
+	setdvar( "scr_jetgun_gib_range", level.zombie_vars[ "jetgun_gib_range" ] );
+	setdvar( "scr_jetgun_gib_damage", level.zombie_vars[ "jetgun_gib_damage" ] );
+	setdvar( "scr_jetgun_knockdown_range", level.zombie_vars[ "jetgun_knockdown_range" ] );
+	setdvar( "scr_jetgun_knockdown_damage", level.zombie_vars[ "jetgun_knockdown_damage" ] );
+	for ( ;; )
+	{
+		level.zombie_vars[ "jetgun_cylinder_radius" ] = getDvarInt( "scr_jetgun_cylinder_radius" );
+		level.zombie_vars[ "jetgun_grind_range" ] = getDvarInt( "scr_jetgun_grind_range" );
+		level.zombie_vars[ "jetgun_drag_range" ] = getDvarInt( "scr_jetgun_drag_range" );
+		level.zombie_vars[ "jetgun_gib_range" ] = getDvarInt( "scr_jetgun_gib_range" );
+		level.zombie_vars[ "jetgun_gib_damage" ] = getDvarInt( "scr_jetgun_gib_damage" );
+		level.zombie_vars[ "jetgun_knockdown_range" ] = getDvarInt( "scr_jetgun_knockdown_range" );
+		level.zombie_vars[ "jetgun_knockdown_damage" ] = getDvarInt( "scr_jetgun_knockdown_damage" );
+		wait 0.5;
+	}
+#/	
+*/
+}
+
+jetgun_on_player_connect()
+{
+	self thread wait_for_jetgun_fired();
+	self thread watch_weapon_changes();
+	self thread handle_overheated_jetgun();
+}
+
+get_jetgun_engine_direction()
+{
+	return self getcurrentweaponspinlerp();
+}
+
+set_jetgun_engine_direction( nv )
+{
+	self setcurrentweaponspinlerp( nv );
+}
+
+never_overheat()
+{
+/*
+/#
+	self notify( "never_overheat" );
+	self endon( "never_overheat" );
+	self endon( "death_or_disconnect" );
+	while ( 1 )
+	{
+		if ( self getcurrentweapon() == "jetgun_zm" )
+		{
+			self setweaponoverheating( 0, 0 );
+		}
+		wait 0.05;
+
+	}
+#/
+*/
+}
+
+watch_overheat()
+{
+	self endon( "death_or_disconnect" );
+	self endon( "weapon_change" );
+	if ( self getcurrentweapon() == "jetgun_zm" && isDefined( self.jetgun_overheating ) && isDefined( self.jetgun_heatval ) )
+	{
+		self setweaponoverheating( self.jetgun_overheating, self.jetgun_heatval );
+	}
+	while ( 1 )
+	{
+		if ( self getcurrentweapon() == "jetgun_zm" )
+		{
+			overheating = self isweaponoverheating( 0 );
+			heat = self isweaponoverheating( 1 );
+			self.jetgun_overheating = overheating;
+			self.jetgun_heatval = heat;
+			if ( overheating )
+			{
+				self notify( "jetgun_overheated" );
+			}
+			if ( heat > 75 )
+			{
+				self thread play_overheat_fx();
+			}
+		}
+		wait 0.05;
+	}
+}
+
+play_overheat_fx()
+{
+	if ( isDefined( self.overheat_fx_playing ) && !self.overheat_fx_playing )
+	{
+		self.overheat_fx_playing = 1;
+		playfxontag( level._effect[ "jetgun_overheat" ], self, "tag_flash" );
+		wait 5;
+		if ( isDefined( self ) )
+		{
+			self.overheat_fx_playing = 0;
+		}
+	}
+}
+
+handle_overheated_jetgun()
+{
+	self endon( "disconnect" );
+	while ( 1 )
+	{
+		self waittill( "jetgun_overheated" );
+		if ( self getcurrentweapon() == "jetgun_zm" )
+		{
+			if ( isDefined( level.explode_overheated_jetgun ) && level.explode_overheated_jetgun )
+			{
+				self thread maps/mp/zombies/_zm_equipment::equipment_release( "jetgun_zm" );
+				weapon_org = self gettagorigin( "tag_weapon" );
+				pcount = get_players().size;
+				pickup_time = 360 / pcount;
+				maps/mp/zombies/_zm_buildables::player_explode_buildable( "jetgun_zm", weapon_org, 250, 1, pickup_time );
+				self.jetgun_overheating = undefined;
+				self.jetgun_heatval = undefined;
+				self playsound( "wpn_jetgun_explo" );
+				break;
+			}
+			else
+			{
+				if ( isDefined( level.unbuild_overheated_jetgun ) && level.unbuild_overheated_jetgun )
+				{
+					self thread maps/mp/zombies/_zm_equipment::equipment_release( "jetgun_zm" );
+					maps/mp/zombies/_zm_buildables::unbuild_buildable( "jetgun_zm", 1 );
+					self.jetgun_overheating = undefined;
+					self.jetgun_heatval = undefined;
+					break;
+				}
+				else
+				{
+					if ( isDefined( level.take_overheated_jetgun ) && level.take_overheated_jetgun )
+					{
+						self thread maps/mp/zombies/_zm_equipment::equipment_release( "jetgun_zm" );
+						self.jetgun_overheating = undefined;
+						self.jetgun_heatval = undefined;
+					}
+				}
+			}
+		}
+	}
+}
+
+watch_weapon_changes()
+{
+	self endon( "disconnect" );
+	for ( ;; )
+	{
+		self waittill( "weapon_change", weapon );
+		if ( weapon == "jetgun_zm" )
+		{
+		/*
+/#
+			if ( getDvarInt( #"BCDDAAFF" ) > 0 )
+			{
+				self thread zombie_drag_radius();
+
+			}
+#/			
+		*/
+			self thread watch_overheat();
+		}
+	}
+}
+
+wait_for_jetgun_fired()
+{
+	self endon( "disconnect" );
+	self waittill( "spawned_player" );
+	for ( ;; )
+	{
+		self waittill( "weapon_fired" );
+		currentweapon = self getcurrentweapon();
+		if ( currentweapon == "jetgun_zm" || currentweapon == "jetgun_upgraded_zm" )
+		{
+			self jetgun_firing();
+		}
+	}
+}
+
+jetgun_network_choke()
+{
+	level.jetgun_network_choke_count++;
+	if ( level.jetgun_network_choke_count % 10 )
+	{
+		wait_network_frame();
+		wait_network_frame();
+		wait_network_frame();
+	}
+}
+
+is_jetgun_firing()
+{
+	return abs( self get_jetgun_engine_direction() ) > 0.2;
+}
+
+jetgun_firing()
+{
+	if ( !isDefined( self.jetsound_ent ) )
+	{
+		self.jetsound_ent = spawn( "script_origin", self.origin );
+		self.jetsound_ent linkto( self, "tag_origin" );
+	}
+	jetgun_fired = 0;
+	if ( self is_jetgun_firing() && jetgun_fired == 0 )
+	{
+		self.jetsound_ent playloopsound( "wpn_jetgun_effect_plr_loop", 0.8 );
+		self.jetsound_ent playsound( "wpn_jetgun_effect_plr_start" );
+		self notify( "jgun_snd" );
+	}
+	while ( self is_jetgun_firing() )
+	{
+		jetgun_fired = 1;
+		self thread jetgun_fired();
+		view_pos = self gettagorigin( "tag_flash" );
+		view_angles = self gettagangles( "tag_flash" );
+		if ( self get_jetgun_engine_direction() < 0 )
+		{
+			playfx( level._effect[ "jetgun_smoke_cloud" ], view_pos - self getplayerviewheight(), anglesToForward( view_angles ), anglesToUp( view_angles ) );
+		}
+		else
+		{
+			playfx( level._effect[ "jetgun_smoke_cloud" ], view_pos - self getplayerviewheight(), anglesToForward( view_angles ) * -1, anglesToUp( view_angles ) );
+		}
+		wait 0.25;
+	}
+	if ( jetgun_fired == 1 )
+	{
+		self.jetsound_ent stoploopsound( 0.5 );
+		self.jetsound_ent playsound( "wpn_jetgun_effect_plr_end" );
+		self.jetsound_ent thread sound_ent_cleanup();
+		jetgun_fired = 0;
+	}
+}
+
+sound_ent_cleanup()
+{
+	self endon( "jgun_snd" );
+	wait 4;
+	if ( isDefined( self.jetsound_ent ) )
+	{
+		self delete();
+	}
+}
+
+jetgun_fired()
+{
+	if ( !self is_jetgun_firing() )
+	{
+		return;
+	}
+	origin = self getweaponmuzzlepoint();
+	physicsjetthrust( origin, self getweaponforwarddir() * -1, level.zombie_vars[ "jetgun_grind_range" ], self get_jetgun_engine_direction(), 0.85 );
+	if ( !isDefined( level.jetgun_knockdown_enemies ) )
+	{
+		level.jetgun_knockdown_enemies = [];
+		level.jetgun_knockdown_gib = [];
+		level.jetgun_drag_enemies = [];
+		level.jetgun_fling_enemies = [];
+		level.jetgun_grind_enemies = [];
+	}
+	powerups = maps/mp/zombies/_zm_powerups::get_powerups();
+	if ( isDefined( powerups ) && powerups.size )
+	{
+		self thread try_pull_powerups( powerups );
+	}
+	self jetgun_get_enemies_in_range( self get_jetgun_engine_direction() );
+	level.jetgun_network_choke_count = 0;
+	_a408 = level.jetgun_fling_enemies;
+	index = getFirstArrayKey( _a408 );
+	while ( isDefined( index ) )
+	{
+		zombie = _a408[ index ];
+		jetgun_network_choke();
+		if ( isDefined( zombie ) )
+		{
+			zombie thread jetgun_fling_zombie( self, index );
+		}
+		index = getNextArrayKey( _a408, index );
+	}
+	_a418 = level.jetgun_drag_enemies;
+	_k418 = getFirstArrayKey( _a418 );
+	while ( isDefined( _k418 ) )
+	{
+		zombie = _a418[ _k418 ];
+		jetgun_network_choke();
+		if ( isDefined( zombie ) )
+		{
+			zombie.jetgun_owner = self;
+			zombie thread jetgun_drag_zombie( origin, -1 * self get_jetgun_engine_direction() );
+		}
+		_k418 = getNextArrayKey( _a418, _k418 );
+	}
+	level.jetgun_knockdown_enemies = [];
+	level.jetgun_knockdown_gib = [];
+	level.jetgun_drag_enemies = [];
+	level.jetgun_fling_enemies = [];
+	level.jetgun_grind_enemies = [];
+}
+
+try_pull_powerups( powerups )
+{
+	powerup_move_dist = level.zombie_vars[ "powerup_move_dist" ] * -1 * self get_jetgun_engine_direction();
+	powerup_range_squared = level.zombie_vars[ "powerup_drag_range" ] * level.zombie_vars[ "powerup_drag_range" ];
+	view_pos = self getweaponmuzzlepoint();
+	forward_view_angles = self getweaponforwarddir();
+	_a453 = powerups;
+	_k453 = getFirstArrayKey( _a453 );
+	while ( isDefined( _k453 ) )
+	{
+		powerup = _a453[ _k453 ];
+		if ( distancesquared( view_pos, powerup.origin ) > powerup_range_squared )
+		{
+		}
+		else normal = vectornormalize( powerup.origin - view_pos );
+		dot = vectordot( forward_view_angles, normal );
+		if ( abs( dot ) < 0.7 )
+		{
+		}
+		else
+		{
+			powerup notify( "move_powerup" );
+		}
+		_k453 = getNextArrayKey( _a453, _k453 );
+	}
+}
+
+jetgun_get_enemies_in_range( invert )
+{
+	view_pos = self getweaponmuzzlepoint();
+	zombies = get_array_of_closest( view_pos, get_round_enemy_array(), undefined, 3, level.zombie_vars[ "jetgun_drag_range" ] );
+	if ( !isDefined( zombies ) )
+	{
+	}
+	knockdown_range_squared = level.zombie_vars[ "jetgun_knockdown_range" ] * level.zombie_vars[ "jetgun_knockdown_range" ];
+	drag_range_squared = level.zombie_vars[ "jetgun_drag_range" ] * level.zombie_vars[ "jetgun_drag_range" ];
+	gib_range_squared = level.zombie_vars[ "jetgun_gib_range" ] * level.zombie_vars[ "jetgun_gib_range" ];
+	grind_range_squared = level.zombie_vars[ "jetgun_grind_range" ] * level.zombie_vars[ "jetgun_grind_range" ];
+	cylinder_radius_squared = level.zombie_vars[ "jetgun_cylinder_radius" ] * level.zombie_vars[ "jetgun_cylinder_radius" ];
+	forward_view_angles = self getweaponforwarddir();
+	end_pos = view_pos + vectorScale( forward_view_angles, level.zombie_vars[ "jetgun_knockdown_range" ] );
+	/*
+/#
+	if ( getDvarInt( #"BCDDAAFF" ) == 2 )
+	{
+		near_circle_pos = view_pos + vectorScale( forward_view_angles, 2 );
+		circle( near_circle_pos, level.zombie_vars[ "jetgun_cylinder_radius" ], ( 1, 0, 1 ), 0, 0, 100 );
+		line( near_circle_pos, end_pos, ( 1, 0, 1 ), 1, 0, 100 );
+		circle( end_pos, level.zombie_vars[ "jetgun_cylinder_radius" ], ( 1, 0, 1 ), 0, 0, 100 );
+
+	}
+#/
+	*/
+	i = 0;
+	while ( i < zombies.size )
+	{
+		self jetgun_check_enemies_in_range( zombies[ i ], view_pos, drag_range_squared, gib_range_squared, grind_range_squared, cylinder_radius_squared, forward_view_angles, end_pos, invert );
+		i++;
+	}
+}
+
+jetgun_check_enemies_in_range( zombie, view_pos, drag_range_squared, gib_range_squared, grind_range_squared, cylinder_radius_squared, forward_view_angles, end_pos, invert )
+{
+	if ( !isDefined( zombie ) )
+	{
+		return;
+	}
+	if ( !isDefined( zombie ) )
+	{
+		return;
+	}
+	if ( zombie enemy_killed_by_jetgun() )
+	{
+		return;
+	}
+	if ( !isDefined( zombie.ai_state ) || zombie.ai_state != "find_flesh" && zombie.ai_state != "zombieMoveOnBus" )
+	{
+		return;
+	}
+	if ( isDefined( zombie.in_the_ground ) && zombie.in_the_ground )
+	{
+		return;
+	}
+	if ( isDefined( zombie.is_avogadro ) && zombie.is_avogadro )
+	{
+		return;
+	}
+	if ( isDefined( zombie.isdog ) && zombie.isdog )
+	{
+		return;
+	}
+	if ( isDefined( zombie.isscreecher ) && zombie.isscreecher )
+	{
+		return;
+	}
+	if ( isDefined( self.animname ) && self.animname == "quad_zombie" )
+	{
+		return;
+	}
+	test_origin = zombie getcentroid();
+	test_range_squared = distancesquared( view_pos, test_origin );
+	if ( test_range_squared > drag_range_squared )
+	{
+		zombie jetgun_debug_print( "range", ( 1, 0, 1 ) );
+		return;
+	}
+	normal = vectornormalize( test_origin - view_pos );
+	dot = vectordot( forward_view_angles, normal );
+	if ( abs( dot ) < 0.7 )
+	{
+		zombie jetgun_debug_print( "dot", ( 1, 0, 1 ) );
+		return;
+	}
+	radial_origin = pointonsegmentnearesttopoint( view_pos, end_pos, test_origin );
+	if ( distancesquared( test_origin, radial_origin ) > cylinder_radius_squared )
+	{
+		zombie jetgun_debug_print( "cylinder", ( 1, 0, 1 ) );
+		return;
+	}
+	if ( zombie damageconetrace( view_pos, self ) == 0 )
+	{
+		zombie jetgun_debug_print( "cone", ( 1, 0, 1 ) );
+		return;
+	}
+	jetgun_blow_suck = invert;
+	if ( dot <= 0 )
+	{
+		jetgun_blow_suck *= -1;
+	}
+	if ( test_range_squared < grind_range_squared )
+	{
+		level.jetgun_fling_enemies[ level.jetgun_fling_enemies.size ] = zombie;
+		level.jetgun_grind_enemies[ level.jetgun_grind_enemies.size ] = dot < 0;
+	}
+	else
+	{
+		if ( test_range_squared < drag_range_squared && dot > 0 )
+		{
+			level.jetgun_drag_enemies[ level.jetgun_drag_enemies.size ] = zombie;
+		}
+	}
+}
+
+jetgun_debug_print( msg, color )
+{
+/*
+/#
+	if ( !getDvarInt( #"BCDDAAFF" ) )
+	{
+		return;
+	}
+	if ( !isDefined( color ) )
+	{
+		color = ( 1, 0, 1 );
+	}
+	print3d( self.origin + vectorScale( ( 1, 0, 1 ), 60 ), msg, color, 1, 1, 40 );
+#/
+*/
+}
+
+jetgun_debug_print_on_ent( msg, color )
+{
+/*
+/#
+	if ( !getDvarInt( #"BCDDAAFF" ) )
+	{
+		return;
+	}
+	if ( !isDefined( color ) )
+	{
+		color = ( 1, 0, 1 );
+	}
+	self notify( "new_jetgun_debug_print_on_ent" );
+	self endon( "death" );
+	self endon( "jetgun_end_drag_state" );
+	self endon( "new_jetgun_debug_print_on_ent" );
+	while ( 1 )
+	{
+		print3d( self.origin + vectorScale( ( 1, 0, 1 ), 60 ), msg, color, 1, 1 );
+		wait 0.05;
+
+	}
+#/
+*/
+}
+
+try_gibbing()
+{
+	if ( isDefined( self ) && isDefined( self.a ) && isDefined( self.isscreecher ) && !self.isscreecher )
+	{
+		self.a.gib_ref = random( level.jetgun_gib_refs );
+		self thread maps/mp/animscripts/zm_death::do_gib();
+	}
+}
+
+jetgun_handle_death_notetracks( note )
+{
+	if ( note == "jetgunned" )
+	{
+		self thread jetgun_grind_death_ending();
+	}
+}
+
+jetgun_grind_death_ending()
+{
+	if ( !isDefined( self ) )
+	{
+		return;
+	}
+	self hide();
+	wait 0.1;
+	self self_delete();
+}
+
+jetgun_grind_zombie( player )
+{
+	player endon( "death" );
+	player endon( "disconnect" );
+	self endon( "death" );
+	if ( !isDefined( self.jetgun_grind ) )
+	{
+		self.jetgun_grind = 1;
+		self notify( "grinding" );
+		player set_jetgun_engine_direction( 0.5 * player get_jetgun_engine_direction() );
+		if ( is_mature() )
+		{
+			if ( isDefined( level._effect[ "zombie_guts_explosion" ] ) )
+			{
+				playfx( level._effect[ "zombie_guts_explosion" ], self gettagorigin( "J_SpineLower" ) );
+			}
+		}
+		self.nodeathragdoll = 1;
+		self.handle_death_notetracks = ::jetgun_handle_death_notetracks;
+		self dodamage( self.health + 666, player.origin, player );
+	}
+}
+
+jetgun_fling_zombie( player, index )
+{
+	if ( !isDefined( self ) )
+	{
+		return;
+	}
+	if ( isDefined( self.jetgun_fling_func ) )
+	{
+		self [[ self.jetgun_fling_func ]]( player );
+		return;
+	}
+	was_alive = isalive( self );
+	if ( was_alive )
+	{
+		self.jetgun_fling = 1;
+		self notify( "flinging" );
+		deathanim = undefined;
+		if ( is_mature() )
+		{
+			player weaponplayejectbrass();
+		}
+		if ( isDefined( self.has_legs ) && self.has_legs )
+		{
+			if ( isDefined( self.jetgun_drag_state ) && self.jetgun_drag_state == "jetgun_sprint" )
+			{
+				deathanim = "zm_jetgun_sprint_death";
+			}
+			else
+			{
+				deathanim = "zm_jetgun_death";
+			}
+		}
+		else
+		{
+			deathanim = "zm_jetgun_death_crawl";
+		}
+		self.deathanim = deathanim;
+		player playsound( "evt_jetgun_zmb_suck" );
+	}
+	self thread jetgun_grind_zombie( player );
+}
+
+jetgun_drag_zombie( vdir, speed )
+{
+	if ( isDefined( self.jetgun_drag_func ) )
+	{
+		self [[ self.jetgun_drag_func ]]( vdir, speed );
+		return;
+	}
+	self zombie_do_drag( vdir, speed );
+}
+
+jetgun_knockdown_zombie( player, gib )
+{
+	self endon( "death" );
+	return;
+	if ( isDefined( self.jetgun_knockdown_func ) )
+	{
+		self [[ self.jetgun_knockdown_func ]]( player, gib );
+	}
+	else
+	{
+		self dodamage( level.zombie_vars[ "jetgun_knockdown_damage" ], player.origin, player );
+	}
+	if ( gib )
+	{
+		self.a.gib_ref = random( level.jetgun_gib_refs );
+		self thread maps/mp/animscripts/zm_death::do_gib();
+	}
+	self.jetgun_handle_pain_notetracks = ::handle_jetgun_pain_notetracks;
+	self dodamage( level.zombie_vars[ "jetgun_knockdown_damage" ], player.origin, player );
+}
+
+handle_jetgun_pain_notetracks( note )
+{
+	if ( note == "zombie_knockdown_ground_impact" )
+	{
+		playfx( level._effect[ "jetgun_knockdown_ground" ], self.origin, anglesToForward( self.angles ), anglesToUp( self.angles ) );
+	}
+}
+
+is_jetgun_damage()
+{
+	if ( isDefined( self.damageweapon ) && self.damageweapon != "jetgun_zm" && self.damageweapon == "jetgun_upgraded_zm" )
+	{
+		if ( self.damagemod != "MOD_GRENADE" )
+		{
+			return self.damagemod != "MOD_GRENADE_SPLASH";
+		}
+	}
+}
+
+enemy_killed_by_jetgun()
+{
+	if ( isDefined( self.jetgun_fling ) && !self.jetgun_fling )
+	{
+		if ( isDefined( self.jetgun_grind ) )
+		{
+			return self.jetgun_grind;
+		}
+	}
+}
+
+zombie_do_drag( vdir, speed )
+{
+	if ( !self zombie_is_in_drag_state() )
+	{
+		self zombie_enter_drag_state( vdir, speed );
+		self thread zombie_drag_think();
+	}
+	else
+	{
+		self zombie_keep_in_drag_state( vdir, speed );
+	}
+}
+
+zombie_is_in_drag_state()
+{
+	if ( isDefined( self.drag_state ) )
+	{
+		return self.drag_state;
+	}
+}
+
+zombie_should_stay_in_drag_state()
+{
+	if ( !isDefined( self ) || !isalive( self ) )
+	{
+		return 0;
+	}
+	if ( isDefined( self.jetgun_owner ) || self.jetgun_owner getcurrentweapon() != "jetgun_zm" && !self.jetgun_owner is_jetgun_firing() )
+	{
+		return 0;
+	}
+	if ( isDefined( self.drag_state ) && self.drag_state )
+	{
+		return 1;
+	}
+	return 0;
+}
+
+zombie_keep_in_drag_state( vdir, speed )
+{
+	self.drag_start_time = getTime();
+	self.drag_target = vdir;
+}
+
+zombie_enter_drag_state( vdir, speed )
+{
+	self.drag_state = 1;
+	self.jetgun_drag_state = "unaffected";
+	if ( isDefined( self.is_traversing ) )
+	{
+		self.was_traversing = self.is_traversing;
+	}
+	self notify( "killanimscript" );
+	self zombie_keep_in_drag_state( vdir, speed );
+	self.zombie_move_speed_pre_jetgun_drag = self.zombie_move_speed;
+}
+
+zombie_exit_drag_state()
+{
+	self notify( "jetgun_end_drag_state" );
+	self.drag_state = 0;
+	self.jetgun_drag_state = "unaffected";
+	self.needs_run_update = 1;
+	if ( isDefined( self.zombie_move_speed_pre_jetgun_drag ) )
+	{
+		self set_zombie_run_cycle( self.zombie_move_speed_pre_jetgun_drag );
+		self.zombie_move_speed_pre_jetgun_drag = undefined;
+	}
+	else
+	{
+		self set_zombie_run_cycle();
+	}
+	if ( isDefined( self.isdog ) && !self.isdog )
+	{
+		self maps/mp/animscripts/zm_run::moverun();
+	}
+	if ( isDefined( self.was_traversing ) && self.was_traversing )
+	{
+		self traversemode( "gravity" );
+		self.a.nodeath = 0;
+		self maps/mp/animscripts/zm_run::needsupdate();
+		if ( !self.isdog )
+		{
+			self maps/mp/animscripts/zm_run::moverun();
+		}
+		self.is_traversing = 0;
+		self notify( "zombie_end_traverse" );
+		if ( is_mature() )
+		{
+			if ( isDefined( level._effect[ "zombie_guts_explosion" ] ) )
+			{
+				playfx( level._effect[ "zombie_guts_explosion" ], self gettagorigin( "J_SpineLower" ) );
+			}
+		}
+		self.nodeathragdoll = 1;
+		self dodamage( self.health + 666, self.origin, self );
+	}
+}
+
+aiphysicstrace( start, end )
+{
+	result = physicstrace( start, end, ( 1, 0, 1 ), ( 1, 0, 1 ), self );
+	return result[ "position" ];
+}
+
+zombie_drag_think()
+{
+	self endon( "death" );
+	self endon( "flinging" );
+	self endon( "grinding" );
+	while ( self zombie_should_stay_in_drag_state() )
+	{
+		self._distance_to_jetgun_owner = distancesquared( self.origin, self.jetgun_owner.origin );
+		jetgun_network_choke();
+		if ( self.zombie_move_speed == "sprint" || self._distance_to_jetgun_owner < level.jetgun_pulled_in_range )
+		{
+			self jetgun_drag_set( "jetgun_sprint", "jetgun_walk_fast_crawl" );
+		}
+		else
+		{
+			if ( self._distance_to_jetgun_owner < level.jetgun_pulling_in_range )
+			{
+				self jetgun_drag_set( "jetgun_walk_fast", "jetgun_walk_fast" );
+				break;
+			}
+			else if ( self._distance_to_jetgun_owner < level.jetgun_inner_range )
+			{
+				self jetgun_drag_set( "jetgun_walk", "jetgun_walk_slow_crawl" );
+				break;
+			}
+			else
+			{
+				if ( self._distance_to_jetgun_owner < level.jetgun_outer_edge )
+				{
+					self jetgun_drag_set( "jetgun_walk_slow", "jetgun_walk_slow_crawl" );
+				}
+			}
+		}
+		wait 0.1;
+	}
+	self thread zombie_exit_drag_state();
+}
+
+jetgun_drag_set( legsanim, crawlanim )
+{
+	self endon( "death" );
+	self.needs_run_update = 1;
+	if ( self.has_legs )
+	{
+		self._had_legs = 1;
+		self set_zombie_run_cycle( legsanim );
+	}
+	else
+	{
+		self._had_legs = 0;
+		self set_zombie_run_cycle( crawlanim );
+	}
+/*
+/#
+	if ( self.jetgun_drag_state != legsanim )
+	{
+		self thread jetgun_debug_print_on_ent( legsanim, ( 1, 0, 1 ) );
+
+	}
+	self.jetgun_drag_state = legsanim;
+#/
+*/
+}
+
+zombie_drag_radius()
+{
+/*
+/#
+	self endon( "death_or_disconnect" );
+	self endon( "weapon_change" );
+	while ( 1 )
+	{
+		circle( self.origin, level.zombie_vars[ "jetgun_grind_range" ], vectorScale( ( 1, 0, 1 ), 0.5 ) );
+		circle( self.origin, level.zombie_vars[ "jetgun_drag_range" ] / 8, ( 1, 0, 1 ) );
+		circle( self.origin, level.zombie_vars[ "jetgun_drag_range" ] / 4, ( 1, 0, 1 ) );
+		circle( self.origin, level.zombie_vars[ "jetgun_drag_range" ] / 2, ( 1, 0, 1 ) );
+		circle( self.origin, level.zombie_vars[ "jetgun_drag_range" ], ( 1, 0, 1 ) );
+		wait 0.05;
+
+	}
+#/
+*/
+}
+

zm_transit_patch/readme.md

@@ -0,0 +1,24 @@
+### The following gscs compile and run successfully with no known errors:
+```
+zm_transit_patch/maps/mp/zm_transit_utility.gsc
+```
+### The following scripts compile and run successfully with minor errors:
+
+```
+zm_transit_patch/maps/mp/gametypes_zm/zgrief.gsc
+```
+
+### The following scripts compile and run successfully with major errors:
+
+```
+zm_transit_patch/maps/mp/zombies/_zm_weap_jetgun.gsc
+```
+
+### The following scripts compile and run serverside but clients cannot join due to exe_client_field_mismatch
+
+### The following scripts compile but cause a minidump or other severe error:
+
+### notes:
+```
+zm_transit_utility.gsc can be recompiled to fix tombstone
+```