uploading 64 scripts as a baseline from zm_tomb_patch

zm_tomb_patch/maps/mp/gametypes_zm/zstandard.gsc

@@ -0,0 +1,43 @@
+#include maps/mp/zombies/_zm;
+#include maps/mp/zombies/_zm_ai_dogs;
+#include maps/mp/zombies/_zm_stats;
+#include common_scripts/utility;
+#include maps/mp/gametypes_zm/_hud_util;
+#include maps/mp/_utility;
+
+main()
+{
+	maps/mp/gametypes_zm/_zm_gametype::main();
+	level.onprecachegametype = ::onprecachegametype;
+	level.onstartgametype = ::onstartgametype;
+	level._game_module_custom_spawn_init_func = ::maps/mp/gametypes_zm/_zm_gametype::custom_spawn_init_func;
+	level._game_module_stat_update_func = ::maps/mp/zombies/_zm_stats::survival_classic_custom_stat_update;
+	maps/mp/gametypes_zm/_zm_gametype::post_gametype_main( "zstandard" );
+}
+
+onprecachegametype()
+{
+	level.playersuicideallowed = 1;
+	level.canplayersuicide = ::canplayersuicide;
+	level.suicide_weapon = "death_self_zm";
+	precacheitem( "death_self_zm" );
+	maps/mp/zombies/_zm_ai_dogs::init();
+	maps/mp/gametypes_zm/_zm_gametype::rungametypeprecache( "zstandard" );
+}
+
+onstartgametype()
+{
+	maps/mp/gametypes_zm/_zm_gametype::setup_classic_gametype();
+	maps/mp/gametypes_zm/_zm_gametype::rungametypemain( "zstandard", ::zstandard_main );
+}
+
+zstandard_main()
+{
+	level.dog_rounds_allowed = getgametypesetting( "allowdogs" );
+	if ( level.dog_rounds_allowed )
+	{
+		maps/mp/zombies/_zm_ai_dogs::enable_dog_rounds();
+	}
+	level thread maps/mp/zombies/_zm::round_start();
+	level thread maps/mp/gametypes_zm/_zm_gametype::kill_all_zombies();
+}

zm_tomb_patch/maps/mp/zm_tomb_achievement.gsc

@@ -0,0 +1,239 @@
+#include maps/mp/gametypes_zm/_globallogic_score;
+#include maps/mp/zombies/_zm_utility;
+#include common_scripts/utility;
+#include maps/mp/_utility;
+
+init()
+{
+	level thread achievement_tomb_sidequest();
+	level thread achievement_all_your_base();
+	level thread achievement_playing_with_power();
+	level.achievement_sound_func = ::achievement_sound_func;
+	onplayerconnect_callback( ::onplayerconnect );
+}
+
+achievement_sound_func( achievement_name_lower )
+{
+	self endon( "disconnect" );
+	if ( !sessionmodeisonlinegame() )
+	{
+		return;
+	}
+	i = 0;
+	while ( i < ( self getentitynumber() + 1 ) )
+	{
+		wait_network_frame();
+		i++;
+	}
+	self thread do_player_general_vox( "general", "achievement" );
+}
+
+init_player_achievement_stats()
+{
+	if ( !is_gametype_active( "zclassic" ) )
+	{
+		return;
+	}
+	self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "zm_dlc4_tomb_sidequest", 0 );
+	self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "zm_dlc4_not_a_gold_digger", 0 );
+	self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "zm_dlc4_all_your_base", 0 );
+	self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "zm_dlc4_kung_fu_grip", 0 );
+	self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "zm_dlc4_playing_with_power", 0 );
+	self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "zm_dlc4_im_on_a_tank", 0 );
+	self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "zm_dlc4_saving_the_day_all_day", 0 );
+	self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "zm_dlc4_master_of_disguise", 0 );
+	self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "zm_dlc4_overachiever", 0 );
+	self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "zm_dlc4_master_wizard", 0 );
+}
+
+onplayerconnect()
+{
+	self thread achievement_not_a_gold_digger();
+	self thread achievement_kung_fu_grip();
+	self thread achievement_im_on_a_tank();
+	self thread achievement_saving_the_day_all_day();
+	self thread achievement_master_of_disguise();
+	self thread achievement_master_wizard();
+	self thread achievement_overachiever();
+}
+
+achievement_tomb_sidequest()
+{
+	level endon( "end_game" );
+	level waittill( "tomb_sidequest_complete" );
+/#
+#/
+	level giveachievement_wrapper( "ZM_DLC4_TOMB_SIDEQUEST", 1 );
+}
+
+achievement_all_your_base()
+{
+	level endon( "end_game" );
+	level waittill( "all_zones_captured_none_lost" );
+/#
+#/
+	level giveachievement_wrapper( "ZM_DLC4_ALL_YOUR_BASE", 1 );
+}
+
+achievement_playing_with_power()
+{
+	level endon( "end_game" );
+	flag_wait( "ee_all_staffs_crafted" );
+/#
+#/
+	level giveachievement_wrapper( "ZM_DLC4_PLAYING_WITH_POWER", 1 );
+}
+
+achievement_overachiever()
+{
+	level endon( "end_game" );
+	self endon( "disconnect" );
+	self waittill( "all_challenges_complete" );
+/#
+#/
+	self giveachievement_wrapper( "ZM_DLC4_OVERACHIEVER" );
+}
+
+achievement_not_a_gold_digger()
+{
+	level endon( "end_game" );
+	self endon( "disconnect" );
+	self waittill( "dig_up_weapon_shared" );
+/#
+#/
+	self giveachievement_wrapper( "ZM_DLC4_NOT_A_GOLD_DIGGER" );
+}
+
+achievement_kung_fu_grip()
+{
+	level endon( "end_game" );
+	self endon( "disconnect" );
+	self waittill_multiple( "mechz_grab_released_self", "mechz_grab_released_friendly" );
+/#
+#/
+	self giveachievement_wrapper( "ZM_DLC4_KUNG_FU_GRIP" );
+}
+
+achievement_im_on_a_tank()
+{
+	level endon( "end_game" );
+	self endon( "disconnect" );
+	self waittill( "rode_tank_around_map" );
+/#
+#/
+	self giveachievement_wrapper( "ZM_DLC4_IM_ON_A_TANK" );
+}
+
+achievement_saving_the_day_all_day()
+{
+	level endon( "end_game" );
+	self endon( "disconnect" );
+	self waittill_multiple( "revived_player", "quick_revived_player", "revived_player_with_quadrotor", "revived_player_with_upgraded_staff" );
+/#
+#/
+	self giveachievement_wrapper( "ZM_DLC4_SAVING_THE_DAY_ALL_DAY" );
+}
+
+_zombie_blood_achievement_think()
+{
+	self endon( "zombie_blood_over" );
+	b_finished_achievement = 0;
+	if ( !isDefined( self.zombie_blood_revives ) )
+	{
+		self.zombie_blood_revives = 0;
+	}
+	if ( !isDefined( self.zombie_blood_generators_started ) )
+	{
+		self.zombie_blood_generators_started = 0;
+	}
+	b_did_capture = 0;
+	n_revives = 0;
+	while ( 1 )
+	{
+		str_action = waittill_any_return( "completed_zone_capture", "do_revive_ended_normally", "revived_player_with_quadrotor", "revived_player_with_upgraded_staff" );
+		if ( issubstr( str_action, "revive" ) )
+		{
+			self.zombie_blood_revives++;
+		}
+		else
+		{
+			if ( str_action == "completed_zone_capture" )
+			{
+				self.zombie_blood_generators_started++;
+			}
+		}
+		if ( self.zombie_blood_generators_started > 0 && self.zombie_blood_revives >= 3 )
+		{
+			return 1;
+		}
+	}
+}
+
+achievement_master_of_disguise()
+{
+	level endon( "end_game" );
+	self endon( "disconnect" );
+	while ( 1 )
+	{
+		self waittill( "zombie_blood" );
+		b_finished_achievement = self _zombie_blood_achievement_think();
+		if ( isDefined( b_finished_achievement ) && b_finished_achievement )
+		{
+			break;
+		}
+		else
+		{
+		}
+	}
+/#
+#/
+	self giveachievement_wrapper( "ZM_DLC4_MASTER_OF_DISGUISE" );
+}
+
+watch_equipped_weapons_for_upgraded_staffs()
+{
+	self endon( "disconnect" );
+	self endon( "stop_weapon_switch_watcher_thread" );
+	while ( 1 )
+	{
+		self waittill( "weapon_change", str_weapon );
+		while ( self.sessionstate != "playing" )
+		{
+			continue;
+		}
+		if ( str_weapon == "staff_water_upgraded_zm" )
+		{
+			self notify( "upgraded_water_staff_equipped" );
+			continue;
+		}
+		else if ( str_weapon == "staff_lightning_upgraded_zm" )
+		{
+			self notify( "upgraded_lightning_staff_equipped" );
+			continue;
+		}
+		else if ( str_weapon == "staff_fire_upgraded_zm" )
+		{
+			self notify( "upgraded_fire_staff_equipped" );
+			continue;
+		}
+		else
+		{
+			if ( str_weapon == "staff_air_upgraded_zm" )
+			{
+				self notify( "upgraded_air_staff_equipped" );
+			}
+		}
+	}
+}
+
+achievement_master_wizard()
+{
+	level endon( "end_game" );
+	self endon( "disconnect" );
+	self thread watch_equipped_weapons_for_upgraded_staffs();
+	self waittill_multiple( "upgraded_air_staff_equipped", "upgraded_lightning_staff_equipped", "upgraded_water_staff_equipped", "upgraded_fire_staff_equipped" );
+	self notify( "stop_weapon_switch_watcher_thread" );
+/#
+#/
+	self giveachievement_wrapper( "ZM_DLC4_MASTER_WIZARD" );
+}

zm_tomb_patch/maps/mp/zm_tomb_amb.gsc

@@ -0,0 +1,713 @@
+#include maps/mp/zombies/_zm_zonemgr;
+#include maps/mp/zombies/_zm_audio;
+#include maps/mp/zombies/_zm_sidequests;
+#include maps/mp/_ambientpackage;
+#include maps/mp/zombies/_zm_utility;
+#include maps/mp/_utility;
+#include common_scripts/utility;
+
+main()
+{
+	level thread sndsetupendgamemusicstates();
+	if ( is_classic() )
+	{
+		thread sndmusicegg();
+		thread snd115egg();
+		thread sndstingersetup();
+		onplayerconnect_callback( ::sndtrackers );
+		level thread sndmaelstrom();
+	}
+}
+
+sndsetupendgamemusicstates()
+{
+	flag_wait( "start_zombie_round_logic" );
+	level thread maps/mp/zombies/_zm_audio::setupmusicstate( "game_over_ee", "mus_zombie_game_over_ee", 1, 0, undefined, "SILENCE" );
+}
+
+sndtrackers()
+{
+}
+
+sndstingersetup()
+{
+	level.sndmusicstingerevent = ::sndplaystinger;
+	level.sndstinger = spawnstruct();
+	level.sndstinger.ent = spawn( "script_origin", ( 0, 0, 0 ) );
+	level.sndstinger.queue = 0;
+	level.sndstinger.isplaying = 0;
+	level.sndstinger.states = [];
+	level.sndroundwait = 1;
+	flag_wait( "start_zombie_round_logic" );
+	level sndstingersetupstates();
+	level thread sndstingerroundwait();
+	level thread sndboardmonitor();
+	level thread locationstingerwait();
+	level thread snddoormusictrigs();
+}
+
+sndstingersetupstates()
+{
+	createstingerstate( "door_open", "mus_event_group_03", 2,5, "ignore" );
+	createstingerstate( "boards_gone", "mus_event_group_02", 0,5, "ignore" );
+	createstingerstate( "zone_nml_18", "mus_event_location_hilltop", 0,75, "queue" );
+	createstingerstate( "zone_village_2", "mus_event_location_church", 0,75, "queue" );
+	createstingerstate( "ug_bottom_zone", "mus_event_location_crypt", 0,75, "queue" );
+	createstingerstate( "zone_robot_head", "mus_event_location_robot", 0,75, "queue" );
+	createstingerstate( "zone_air_stairs", "mus_event_cave_air", 0,75, "queue" );
+	createstingerstate( "zone_fire_stairs", "mus_event_cave_fire", 0,75, "queue" );
+	createstingerstate( "zone_bolt_stairs", "mus_event_cave_bolt", 0,75, "queue" );
+	createstingerstate( "zone_ice_stairs", "mus_event_cave_ice", 0,75, "queue" );
+	createstingerstate( "poweron", "mus_event_poweron", 0, "reject" );
+	createstingerstate( "tank_ride", "mus_event_tank_ride", 0, "queue" );
+	createstingerstate( "generator_1", "mus_event_generator_1", 1, "reject" );
+	createstingerstate( "generator_2", "mus_event_generator_2", 1, "reject" );
+	createstingerstate( "generator_3", "mus_event_generator_3", 1, "reject" );
+	createstingerstate( "generator_4", "mus_event_generator_4", 1, "reject" );
+	createstingerstate( "generator_5", "mus_event_generator_5", 1, "reject" );
+	createstingerstate( "generator_6", "mus_event_generator_6", 1, "reject" );
+	createstingerstate( "staff_fire", "mus_event_staff_fire", 0,1, "reject" );
+	createstingerstate( "staff_ice", "mus_event_staff_ice", 0,1, "reject" );
+	createstingerstate( "staff_lightning", "mus_event_staff_lightning", 0,1, "reject" );
+	createstingerstate( "staff_wind", "mus_event_staff_wind", 0,1, "reject" );
+	createstingerstate( "staff_fire_upgraded", "mus_event_staff_fire_upgraded", 0,1, "reject" );
+	createstingerstate( "staff_ice_upgraded", "mus_event_staff_ice_upgraded", 0,1, "reject" );
+	createstingerstate( "staff_lightning_upgraded", "mus_event_staff_lightning_upgraded", 0,1, "reject" );
+	createstingerstate( "staff_wind_upgraded", "mus_event_staff_wind_upgraded", 0,1, "reject" );
+	createstingerstate( "staff_all_upgraded", "mus_event_staff_all_upgraded", 0,1, "reject" );
+	createstingerstate( "side_sting_1", "mus_side_stinger_1", 0,1, "reject" );
+	createstingerstate( "side_sting_2", "mus_side_stinger_2", 0,1, "reject" );
+	createstingerstate( "side_sting_3", "mus_side_stinger_3", 0,1, "reject" );
+	createstingerstate( "side_sting_4", "mus_side_stinger_4", 0,1, "reject" );
+	createstingerstate( "side_sting_5", "mus_side_stinger_5", 0,1, "reject" );
+	createstingerstate( "side_sting_6", "mus_side_stinger_6", 0,1, "reject" );
+}
+
+createstingerstate( state, alias, prewait, interrupt )
+{
+	s = level.sndstinger;
+	if ( !isDefined( s.states[ state ] ) )
+	{
+		s.states[ state ] = spawnstruct();
+		s.states[ state ].alias = alias;
+		s.states[ state ].prewait = prewait;
+		s.states[ state ].interrupt = interrupt;
+	}
+}
+
+sndboardmonitor()
+{
+	while ( 1 )
+	{
+		level waittill( "last_board_torn", barrier_origin );
+		players = getplayers();
+		_a122 = players;
+		_k122 = getFirstArrayKey( _a122 );
+		while ( isDefined( _k122 ) )
+		{
+			player = _a122[ _k122 ];
+			if ( distancesquared( player.origin, barrier_origin ) <= 22500 )
+			{
+				level thread maps/mp/zombies/_zm_audio::sndmusicstingerevent( "boards_gone" );
+				break;
+			}
+			else
+			{
+				_k122 = getNextArrayKey( _a122, _k122 );
+			}
+		}
+	}
+}
+
+locationstingerwait( zone_name, type )
+{
+	array = sndlocationsarray();
+	sndnorepeats = 3;
+	numcut = 0;
+	level.sndlastzone = undefined;
+	level.sndlocationplayed = 0;
+	level thread sndlocationbetweenroundswait();
+	for ( ;; )
+	{
+		while ( 1 )
+		{
+			level waittill( "newzoneActive", activezone );
+			wait 0,1;
+			while ( !sndlocationshouldplay( array, activezone ) )
+			{
+				continue;
+			}
+			if ( is_true( level.sndroundwait ) )
+			{
+			}
+		}
+		else while ( is_true( level.sndstinger.isplaying ) )
+		{
+			level thread sndlocationqueue( activezone );
+		}
+		level thread maps/mp/zombies/_zm_audio::sndmusicstingerevent( activezone );
+		level.sndlocationplayed = 1;
+		array = sndcurrentlocationarray( array, activezone, numcut, sndnorepeats );
+		level.sndlastzone = activezone;
+		if ( numcut >= sndnorepeats )
+		{
+			numcut = 0;
+		}
+		else
+		{
+			numcut++;
+		}
+		level waittill( "between_round_over" );
+		while ( is_true( level.sndroundwait ) )
+		{
+			wait 0,1;
+		}
+		level.sndlocationplayed = 0;
+	}
+}
+
+sndlocationsarray()
+{
+	array = [];
+	array[ 0 ] = "zone_nml_18";
+	array[ 1 ] = "zone_village_2";
+	array[ 2 ] = "ug_bottom_zone";
+	array[ 3 ] = "zone_air_stairs";
+	array[ 4 ] = "zone_fire_stairs";
+	array[ 5 ] = "zone_bolt_stairs";
+	array[ 6 ] = "zone_ice_stairs";
+	return array;
+}
+
+sndlocationshouldplay( array, activezone )
+{
+	shouldplay = 0;
+	if ( activezone == "zone_start_lower" && !flag( "fountain_transport_active" ) )
+	{
+		return shouldplay;
+	}
+	if ( is_true( level.music_override ) )
+	{
+		return shouldplay;
+	}
+	_a206 = array;
+	_k206 = getFirstArrayKey( _a206 );
+	while ( isDefined( _k206 ) )
+	{
+		place = _a206[ _k206 ];
+		if ( place == activezone )
+		{
+			shouldplay = 1;
+		}
+		_k206 = getNextArrayKey( _a206, _k206 );
+	}
+	if ( shouldplay == 0 )
+	{
+		return shouldplay;
+	}
+	playersinlocal = 0;
+	players = getplayers();
+	_a217 = players;
+	_k217 = getFirstArrayKey( _a217 );
+	while ( isDefined( _k217 ) )
+	{
+		player = _a217[ _k217 ];
+		if ( player maps/mp/zombies/_zm_zonemgr::is_player_in_zone( activezone ) )
+		{
+			if ( !is_true( player.afterlife ) )
+			{
+				playersinlocal++;
+			}
+		}
+		_k217 = getNextArrayKey( _a217, _k217 );
+	}
+	if ( playersinlocal >= 1 )
+	{
+		shouldplay = 1;
+	}
+	else
+	{
+		shouldplay = 0;
+	}
+	return shouldplay;
+}
+
+sndcurrentlocationarray( current_array, activezone, numcut, max_num_removed )
+{
+	if ( numcut >= max_num_removed )
+	{
+		current_array = sndlocationsarray();
+	}
+	_a240 = current_array;
+	_k240 = getFirstArrayKey( _a240 );
+	while ( isDefined( _k240 ) )
+	{
+		place = _a240[ _k240 ];
+		if ( place == activezone )
+		{
+			arrayremovevalue( current_array, place );
+			break;
+		}
+		else
+		{
+			_k240 = getNextArrayKey( _a240, _k240 );
+		}
+	}
+	return current_array;
+}
+
+sndlocationbetweenrounds()
+{
+	level endon( "newzoneActive" );
+	activezones = maps/mp/zombies/_zm_zonemgr::get_active_zone_names();
+	_a257 = activezones;
+	_k257 = getFirstArrayKey( _a257 );
+	while ( isDefined( _k257 ) )
+	{
+		zone = _a257[ _k257 ];
+		if ( isDefined( level.sndlastzone ) && zone == level.sndlastzone )
+		{
+		}
+		else
+		{
+			players = getplayers();
+			_a263 = players;
+			_k263 = getFirstArrayKey( _a263 );
+			while ( isDefined( _k263 ) )
+			{
+				player = _a263[ _k263 ];
+				if ( is_true( player.afterlife ) )
+				{
+				}
+				else
+				{
+					if ( player maps/mp/zombies/_zm_zonemgr::is_player_in_zone( zone ) )
+					{
+						wait 0,1;
+						level notify( "newzoneActive" );
+						return;
+					}
+				}
+				_k263 = getNextArrayKey( _a263, _k263 );
+			}
+		}
+		_k257 = getNextArrayKey( _a257, _k257 );
+	}
+}
+
+sndlocationbetweenroundswait()
+{
+	while ( is_true( level.sndroundwait ) )
+	{
+		wait 0,1;
+	}
+	while ( 1 )
+	{
+		level thread sndlocationbetweenrounds();
+		level waittill( "between_round_over" );
+		while ( is_true( level.sndroundwait ) )
+		{
+			wait 0,1;
+		}
+	}
+}
+
+sndlocationqueue( zone )
+{
+	level endon( "newzoneActive" );
+	while ( is_true( level.sndstinger.isplaying ) )
+	{
+		wait 0,5;
+	}
+	level notify( "newzoneActive" );
+}
+
+sndplaystinger( state, player )
+{
+	s = level.sndstinger;
+	if ( !isDefined( s.states[ state ] ) )
+	{
+		return;
+	}
+	interrupt = s.states[ state ].interrupt == "ignore";
+	if ( !is_true( s.isplaying ) || is_true( interrupt ) )
+	{
+		if ( interrupt )
+		{
+			wait s.states[ state ].prewait;
+			playstinger( state, player, 1 );
+		}
+		else if ( !level.sndroundwait )
+		{
+			s.isplaying = 1;
+			wait s.states[ state ].prewait;
+			playstinger( state, player, 0 );
+			level notify( "sndStingerDone" );
+			s.isplaying = 0;
+		}
+		else
+		{
+			if ( s.states[ state ].interrupt == "queue" )
+			{
+				level thread sndqueuestinger( state, player );
+			}
+		}
+		return;
+	}
+	if ( s.states[ state ].interrupt == "queue" )
+	{
+		level thread sndqueuestinger( state, player );
+	}
+}
+
+playstinger( state, player, ignore )
+{
+	s = level.sndstinger;
+	if ( !isDefined( s.states[ state ] ) )
+	{
+		return;
+	}
+	if ( is_true( level.music_override ) )
+	{
+		return;
+	}
+	if ( is_true( ignore ) )
+	{
+		if ( isDefined( player ) )
+		{
+			player playsoundtoplayer( s.states[ state ].alias, player );
+		}
+		else
+		{
+			s.ent playsound( s.states[ state ].alias );
+			s.ent thread playstingerstop();
+		}
+	}
+	else if ( isDefined( player ) )
+	{
+		player playsoundtoplayer( s.states[ state ].alias, player );
+		wait 8;
+	}
+	else
+	{
+		s.ent playsoundwithnotify( s.states[ state ].alias, "sndStingerDone" );
+		s.ent thread playstingerstop();
+		s.ent waittill( "sndStingerDone" );
+	}
+}
+
+sndqueuestinger( state, player )
+{
+	s = level.sndstinger;
+	count = 0;
+	if ( is_true( s.queue ) )
+	{
+		return;
+	}
+	else
+	{
+		s.queue = 1;
+		while ( 1 )
+		{
+			if ( is_true( level.sndroundwait ) || is_true( s.isplaying ) )
+			{
+				wait 0,5;
+				count++;
+				if ( count >= 120 )
+				{
+					return;
+				}
+				continue;
+			}
+			else
+			{
+			}
+		}
+		level thread sndplaystinger( state, player );
+		s.queue = 0;
+	}
+}
+
+sndstingerroundwait()
+{
+	wait 25;
+	level.sndroundwait = 0;
+	while ( 1 )
+	{
+		level waittill( "end_of_round" );
+		level thread sndstingerroundwait_start();
+	}
+}
+
+sndstingerroundwait_start()
+{
+	level.sndroundwait = 1;
+	wait 0,05;
+	level thread sndstingerroundwait_end();
+}
+
+sndstingerroundwait_end()
+{
+	level endon( "end_of_round" );
+	level waittill( "between_round_over" );
+	wait 28;
+	level.sndroundwait = 0;
+}
+
+playstingerstop()
+{
+	self endon( "sndStingerDone" );
+	level endon( "sndStingerDone" );
+	level waittill_any( "end_of_round", "sndStingerForceStop" );
+	wait 2;
+	self stopsounds();
+}
+
+sndmusicegg()
+{
+	origins = [];
+	origins[ 0 ] = ( 2682,23, 4456,15, -302,352 );
+	origins[ 1 ] = ( 721,043, -87,7068, 285,986 );
+	origins[ 2 ] = ( -674,048, 2536,67, -112,483 );
+	level.meteor_counter = 0;
+	level.music_override = 0;
+	i = 0;
+	while ( i < origins.size )
+	{
+		level thread sndmusicegg_wait( origins[ i ] );
+		i++;
+	}
+}
+
+sndmusicegg_wait( bottle_origin )
+{
+	temp_ent = spawn( "script_origin", bottle_origin );
+	temp_ent playloopsound( "zmb_meteor_loop" );
+	temp_ent thread maps/mp/zombies/_zm_sidequests::fake_use( "main_music_egg_hit", ::sndmusicegg_override );
+	temp_ent waittill( "main_music_egg_hit", player );
+	temp_ent stoploopsound( 1 );
+	player playsound( "zmb_meteor_activate" );
+	level.meteor_counter += 1;
+	if ( level.meteor_counter == 3 )
+	{
+		level thread sndmuseggplay( temp_ent, "mus_zmb_secret_song", 310 );
+	}
+	else
+	{
+		wait 1,5;
+		temp_ent delete();
+	}
+}
+
+sndmusicegg_override()
+{
+	if ( is_true( level.music_override ) )
+	{
+		return 0;
+	}
+	return 1;
+}
+
+sndmuseggplay( ent, alias, time )
+{
+	level.music_override = 1;
+	wait 1;
+	ent playsound( alias );
+	level setclientfield( "mus_zmb_egg_snapshot_loop", 1 );
+	level notify( "sndStingerForceStop" );
+	level thread sndeggmusicwait( time );
+	level waittill_either( "end_game", "sndSongDone" );
+	ent stopsounds();
+	level setclientfield( "mus_zmb_egg_snapshot_loop", 0 );
+	wait 0,05;
+	ent delete();
+	level.music_override = 0;
+}
+
+sndeggmusicwait( time )
+{
+	level endon( "end_game" );
+	wait time;
+	level notify( "sndSongDone" );
+}
+
+sndplaystingerwithoverride( alias, length )
+{
+	shouldplay = sndwait();
+	if ( !shouldplay )
+	{
+		return;
+	}
+	level.music_override = 1;
+	level setclientfield( "mus_zmb_egg_snapshot_loop", 1 );
+	level notify( "sndStingerForceStop" );
+	ent = spawn( "script_origin", ( 0, 0, 0 ) );
+	ent playsound( alias );
+	wait length;
+	level setclientfield( "mus_zmb_egg_snapshot_loop", 0 );
+	level.music_override = 0;
+	wait 0,05;
+	ent delete();
+}
+
+sndwait()
+{
+	counter = 0;
+	while ( is_true( level.music_override ) )
+	{
+		wait 1;
+		counter++;
+		if ( counter >= 60 )
+		{
+			return 0;
+		}
+	}
+	return 1;
+}
+
+snddoormusictrigs()
+{
+	trigs = getentarray( "sndMusicDoor", "script_noteworthy" );
+	_a557 = trigs;
+	_k557 = getFirstArrayKey( _a557 );
+	while ( isDefined( _k557 ) )
+	{
+		trig = _a557[ _k557 ];
+		trig thread snddoormusic();
+		_k557 = getNextArrayKey( _a557, _k557 );
+	}
+}
+
+snddoormusic()
+{
+	self endon( "sndDoorMusic_Triggered" );
+	for ( ;; )
+	{
+		while ( 1 )
+		{
+			self waittill( "trigger" );
+			if ( is_true( level.music_override ) )
+			{
+				wait 0,1;
+			}
+		}
+		else }
+	if ( isDefined( self.target ) )
+	{
+		ent = getent( self.target, "targetname" );
+		ent notify( "sndDoorMusic_Triggered" );
+	}
+	level thread sndplaystingerwithoverride( self.script_sound, self.script_int );
+}
+
+sndmaelstrom()
+{
+	trig = getent( "sndMaelstrom", "targetname" );
+	if ( !isDefined( trig ) )
+	{
+		return;
+	}
+	while ( 1 )
+	{
+		trig waittill( "trigger", who );
+		if ( isplayer( who ) && !is_true( who.sndmaelstrom ) )
+		{
+			who.sndmaelstrom = 1;
+			level setclientfield( "sndMaelstromPlr" + who getentitynumber(), 1 );
+		}
+		who thread sndmaelstrom_timeout();
+		wait 0,1;
+	}
+}
+
+sndmaelstrom_timeout()
+{
+	self notify( "sndMaelstrom_Timeout" );
+	self endon( "sndMaelstrom_Timeout" );
+	wait 2;
+	self.sndmaelstrom = 0;
+	level setclientfield( "sndMaelstromPlr" + self getentitynumber(), 0 );
+}
+
+snd115egg()
+{
+	level.snd115count = 0;
+	oneorigin = [];
+	oneorigin[ 0 ] = ( 2168, 4617, -289 );
+	oneorigin[ 1 ] = ( 2170, 4953, -289 );
+	fiveorigin = [];
+	fiveorigin[ 0 ] = ( -2459, 176, 243 );
+	fiveorigin[ 1 ] = ( -2792, 175, 243 );
+	_a625 = oneorigin;
+	_k625 = getFirstArrayKey( _a625 );
+	while ( isDefined( _k625 ) )
+	{
+		origin = _a625[ _k625 ];
+		level thread snd115egg_wait( origin, 0 );
+		_k625 = getNextArrayKey( _a625, _k625 );
+	}
+	_a628 = fiveorigin;
+	_k628 = getFirstArrayKey( _a628 );
+	while ( isDefined( _k628 ) )
+	{
+		origin = _a628[ _k628 ];
+		level thread snd115egg_wait( origin, 1 );
+		_k628 = getNextArrayKey( _a628, _k628 );
+	}
+}
+
+snd115egg_wait( origin, shouldwait )
+{
+	level endon( "sndEnd115" );
+	temp_ent = spawn( "script_origin", origin );
+	temp_ent thread snddelete115ent();
+	if ( shouldwait )
+	{
+		temp_ent thread maps/mp/zombies/_zm_sidequests::fake_use( "main_music_egg_hit", ::snd115egg_5_override );
+	}
+	else
+	{
+		temp_ent thread maps/mp/zombies/_zm_sidequests::fake_use( "main_music_egg_hit", ::snd115egg_1_override );
+	}
+	temp_ent waittill( "main_music_egg_hit", player );
+	player playsound( "zmb_meteor_activate" );
+	level.snd115count++;
+	if ( level.snd115count == 3 )
+	{
+		temp_ent notify( "sndDeleting" );
+		level thread sndmuseggplay( temp_ent, "mus_zmb_secret_song_aether", 135 );
+		level notify( "sndEnd115" );
+	}
+	else
+	{
+		temp_ent notify( "sndDeleting" );
+		temp_ent delete();
+	}
+}
+
+snd115egg_1_override()
+{
+	stance = self getstance();
+	if ( is_true( level.music_override ) || stance != "prone" )
+	{
+		return 0;
+	}
+	return 1;
+}
+
+snd115egg_5_override()
+{
+	stance = self getstance();
+	if ( !is_true( level.music_override ) || stance != "prone" && level.snd115count < 2 )
+	{
+		return 0;
+	}
+	return 1;
+}
+
+snddelete115ent()
+{
+	self endon( "sndDeleting" );
+	level waittill( "sndEnd115" );
+	self delete();
+}

zm_tomb_patch/maps/mp/zm_tomb_ambient_scripts.gsc

@@ -0,0 +1,122 @@
+#include maps/mp/animscripts/zm_death;
+#include maps/mp/zombies/_zm_laststand;
+#include maps/mp/zombies/_zm_score;
+#include maps/mp/zombies/_zm_utility;
+#include maps/mp/_utility;
+#include common_scripts/utility;
+
+#using_animtree( "fxanim_props_dlc4" );
+
+tomb_ambient_precache()
+{
+	precachemodel( "veh_t6_dlc_zm_zeppelin" );
+}
+
+init_tomb_ambient_scripts()
+{
+	tomb_ambient_precache();
+	registerclientfield( "world", "sky_battle_ambient_fx", 14000, 1, "int" );
+	level thread start_sky_battle();
+	level thread init_zeppelin( "sky_cowbell_zeppelin_low", "stop_ambient_zeppelins" );
+	delay_thread( 20, ::init_zeppelin, "sky_cowbell_zeppelin_mid", "stop_ambient_zeppelins" );
+	delay_thread( 40, ::init_zeppelin, "sky_cowbell_zeppelin_high", "stop_ambient_zeppelins" );
+	level thread vista_robot_pose();
+}
+
+init_zeppelin( str_script_noteworthy, str_ender )
+{
+	level endon( str_ender );
+	a_path_structs = getstructarray( str_script_noteworthy, "script_noteworthy" );
+	while ( a_path_structs.size > 0 )
+	{
+		m_zeppelin = spawn( "script_model", ( 0, 0, 0 ) );
+		m_zeppelin setmodel( "veh_t6_dlc_zm_zeppelin" );
+		m_zeppelin setforcenocull();
+		while ( 1 )
+		{
+			m_zeppelin move_zeppelin_down_new_path( a_path_structs );
+		}
+	}
+}
+
+move_zeppelin_down_new_path( a_structs )
+{
+	s_path_start = get_unused_struct( a_structs );
+	self ghost();
+	self moveto( s_path_start.origin, 0,1 );
+	self rotateto( s_path_start.angles, 0,1 );
+	self waittill( "movedone" );
+	self show();
+	if ( !isDefined( s_path_start.goal_struct ) )
+	{
+/#
+		assert( isDefined( s_path_start.target ), "move_zeppelin_down_new_path found start struct at " + s_path_start.origin + " without a target! These are needed for zeppelin splines!" );
+#/
+		s_path_start.goal_struct = getstruct( s_path_start.target, "targetname" );
+/#
+		assert( isDefined( s_path_start.goal_struct ), "move_zeppelin_down_new_path couldn't find goal for path start struct at " + s_path_start.origin );
+#/
+	}
+	n_move_time = randomfloatrange( 120, 150 );
+	self moveto( s_path_start.goal_struct.origin, n_move_time );
+	self waittill( "movedone" );
+}
+
+get_unused_struct( a_structs )
+{
+	a_valid_structs = [];
+	b_no_unused_structs = 0;
+	while ( !a_valid_structs.size )
+	{
+		_a90 = a_structs;
+		_k90 = getFirstArrayKey( _a90 );
+		while ( isDefined( _k90 ) )
+		{
+			struct = _a90[ _k90 ];
+			if ( !isDefined( struct.used ) || b_no_unused_structs )
+			{
+				struct.used = 0;
+			}
+			if ( !struct.used )
+			{
+				a_valid_structs[ a_valid_structs.size ] = struct;
+			}
+			_k90 = getNextArrayKey( _a90, _k90 );
+		}
+		if ( !a_valid_structs.size )
+		{
+			b_no_unused_structs = 1;
+		}
+	}
+	s_unused = random( a_valid_structs );
+	s_unused.used = 1;
+	return s_unused;
+}
+
+start_sky_battle()
+{
+	flag_wait( "start_zombie_round_logic" );
+	level setclientfield( "sky_battle_ambient_fx", 1 );
+}
+
+vista_robot_pose()
+{
+	flag_wait( "start_zombie_round_logic" );
+	a_robots = getstructarray( "trench_downed_robot_struct", "targetname" );
+	i = 0;
+	while ( i < a_robots.size )
+	{
+		if ( !isDefined( a_robots[ i ].angles ) )
+		{
+			a_robots[ i ].angles = ( 0, 0, 0 );
+		}
+		v_origin = getstartorigin( a_robots[ i ].origin, a_robots[ i ].angles, %ai_zombie_giant_robot_vista );
+		v_angles = getstartangles( a_robots[ i ].origin, a_robots[ i ].angles, %ai_zombie_giant_robot_vista );
+		e_robot = spawn( "script_model", v_origin );
+		e_robot.angles = v_angles;
+		e_robot setmodel( "veh_t6_dlc_zm_robot" );
+		e_robot useanimtree( -1 );
+		e_robot setanim( %ai_zombie_giant_robot_vista, 1, 0, 1 );
+		i++;
+	}
+}

zm_tomb_patch/maps/mp/zm_tomb_capture_zones_ffotd.gsc

@@ -0,0 +1,27 @@
+#include maps/mp/zombies/_zm_utility;
+#include maps/mp/_utility;
+#include common_scripts/utility;
+
+capture_zone_init_start()
+{
+}
+
+capture_zone_init_end()
+{
+}
+
+capture_event_start()
+{
+}
+
+capture_event_end()
+{
+}
+
+recapture_event_start()
+{
+}
+
+recapture_event_end()
+{
+}

zm_tomb_patch/maps/mp/zm_tomb_challenges.gsc

@@ -0,0 +1,383 @@
+#include maps/mp/zombies/_zm_weap_one_inch_punch;
+#include maps/mp/zombies/_zm_perks;
+#include maps/mp/zombies/_zm_powerup_zombie_blood;
+#include maps/mp/zombies/_zm_audio_announcer;
+#include maps/mp/zombies/_zm_powerups;
+#include maps/mp/zombies/_zm_weapons;
+#include raw/maps/mp/_zm_challenges;
+#include maps/mp/zm_tomb_vo;
+#include maps/mp/zm_tomb_utility;
+#include maps/mp/zombies/_zm_audio;
+#include maps/mp/zombies/_zm_utility;
+#include maps/mp/_utility;
+#include common_scripts/utility;
+
+#using_animtree( "fxanim_props_dlc4" );
+
+challenges_init()
+{
+	level.challenges_add_stats = ::tomb_challenges_add_stats;
+	maps/mp/zombies/_zm_challenges::init();
+}
+
+tomb_challenges_add_stats()
+{
+	n_kills = 115;
+	n_zone_caps = 6;
+	n_points_spent = 30000;
+	n_boxes_filled = 4;
+/#
+	if ( getDvarInt( "zombie_cheat" ) > 0 )
+	{
+		n_kills = 1;
+		n_zone_caps = 2;
+		n_points_spent = 500;
+		n_boxes_filled = 1;
+#/
+	}
+	add_stat( "zc_headshots", 0, &"ZM_TOMB_CH1", n_kills, undefined, ::reward_packed_weapon );
+	add_stat( "zc_zone_captures", 0, &"ZM_TOMB_CH2", n_zone_caps, undefined, ::reward_powerup_max_ammo );
+	add_stat( "zc_points_spent", 0, &"ZM_TOMB_CH3", n_points_spent, undefined, ::reward_double_tap, ::track_points_spent );
+	add_stat( "zc_boxes_filled", 1, &"ZM_TOMB_CHT", n_boxes_filled, undefined, ::reward_one_inch_punch, ::init_box_footprints );
+}
+
+track_points_spent()
+{
+	while ( 1 )
+	{
+		level waittill( "spent_points", player, points );
+		player increment_stat( "zc_points_spent", points );
+	}
+}
+
+init_box_footprints()
+{
+	level.n_soul_boxes_completed = 0;
+	flag_init( "vo_soul_box_intro_played" );
+	flag_init( "vo_soul_box_continue_played" );
+	a_boxes = getentarray( "foot_box", "script_noteworthy" );
+	array_thread( a_boxes, ::box_footprint_think );
+}
+
+box_footprint_think()
+{
+	self.n_souls_absorbed = 0;
+	n_souls_required = 30;
+/#
+	if ( getDvarInt( "zombie_cheat" ) > 0 )
+	{
+		n_souls_required = 10;
+#/
+	}
+	self useanimtree( -1 );
+	self thread watch_for_foot_stomp();
+	wait 1;
+	self setclientfield( "foot_print_box_glow", 1 );
+	wait 1;
+	self setclientfield( "foot_print_box_glow", 0 );
+	while ( self.n_souls_absorbed < n_souls_required )
+	{
+		self waittill( "soul_absorbed", player );
+		self.n_souls_absorbed++;
+		if ( self.n_souls_absorbed == 1 )
+		{
+			self clearanim( %o_zombie_dlc4_challenge_box_close, 0 );
+			self setanim( %o_zombie_dlc4_challenge_box_open );
+			self delay_thread( 1, ::setclientfield, "foot_print_box_glow", 1 );
+			if ( isDefined( player ) && !flag( "vo_soul_box_intro_played" ) )
+			{
+				player delay_thread( 1,5, ::richtofenrespondvoplay, "zm_box_start", 0, "vo_soul_box_intro_played" );
+			}
+		}
+		if ( self.n_souls_absorbed == floor( n_souls_required / 4 ) )
+		{
+			if ( isDefined( player ) && flag( "vo_soul_box_intro_played" ) && !flag( "vo_soul_box_continue_played" ) )
+			{
+				player thread richtofenrespondvoplay( "zm_box_continue", 1, "vo_soul_box_continue_played" );
+			}
+		}
+		if ( self.n_souls_absorbed == floor( n_souls_required / 2 ) || self.n_souls_absorbed == floor( n_souls_required / 1,3 ) )
+		{
+			if ( isDefined( player ) )
+			{
+				player create_and_play_dialog( "soul_box", "zm_box_encourage" );
+			}
+		}
+		if ( self.n_souls_absorbed == n_souls_required )
+		{
+			wait 1;
+			self clearanim( %o_zombie_dlc4_challenge_box_open, 0 );
+			self setanim( %o_zombie_dlc4_challenge_box_close );
+		}
+	}
+	self notify( "box_finished" );
+	level.n_soul_boxes_completed++;
+	e_volume = getent( self.target, "targetname" );
+	e_volume delete();
+	self delay_thread( 0,5, ::setclientfield, "foot_print_box_glow", 0 );
+	wait 1;
+	self movez( 30, 1, 1 );
+	wait 0,5;
+	n_rotations = randomintrange( 5, 7 );
+	v_start_angles = self.angles;
+	i = 0;
+	while ( i < n_rotations )
+	{
+		v_rotate_angles = v_start_angles + ( randomfloatrange( -10, 10 ), randomfloatrange( -10, 10 ), randomfloatrange( -10, 10 ) );
+		n_rotate_time = randomfloatrange( 0,2, 0,4 );
+		self rotateto( v_rotate_angles, n_rotate_time );
+		self waittill( "rotatedone" );
+		i++;
+	}
+	self rotateto( v_start_angles, 0,3 );
+	self movez( -60, 0,5, 0,5 );
+	self waittill( "rotatedone" );
+	trace_start = self.origin + vectorScale( ( 0, 1, 0 ), 200 );
+	trace_end = self.origin;
+	fx_trace = bullettrace( trace_start, trace_end, 0, self );
+	playfx( level._effect[ "mech_booster_landing" ], fx_trace[ "position" ], anglesToForward( self.angles ), anglesToUp( self.angles ) );
+	playsoundatposition( "zmb_footprintbox_disappear", self.origin );
+	self waittill( "movedone" );
+	level maps/mp/zombies/_zm_challenges::increment_stat( "zc_boxes_filled" );
+	if ( isDefined( player ) )
+	{
+		if ( level.n_soul_boxes_completed == 1 )
+		{
+			player thread richtofenrespondvoplay( "zm_box_complete" );
+		}
+		else
+		{
+			if ( level.n_soul_boxes_completed == 4 )
+			{
+				player thread richtofenrespondvoplay( "zm_box_final_complete", 1 );
+			}
+		}
+	}
+	self delete();
+}
+
+watch_for_foot_stomp()
+{
+	self endon( "box_finished" );
+	while ( 1 )
+	{
+		self waittill( "robot_foot_stomp" );
+		self clearanim( %o_zombie_dlc4_challenge_box_open, 0 );
+		self setanim( %o_zombie_dlc4_challenge_box_close );
+		self setclientfield( "foot_print_box_glow", 0 );
+		self.n_souls_absorbed = 0;
+		wait 5;
+	}
+}
+
+footprint_zombie_killed( attacker )
+{
+	a_volumes = getentarray( "foot_box_volume", "script_noteworthy" );
+	_a268 = a_volumes;
+	_k268 = getFirstArrayKey( _a268 );
+	while ( isDefined( _k268 ) )
+	{
+		e_volume = _a268[ _k268 ];
+		if ( self istouching( e_volume ) && isDefined( attacker ) && isplayer( attacker ) )
+		{
+			self setclientfield( "foot_print_box_fx", 1 );
+			m_box = getent( e_volume.target, "targetname" );
+			m_box notify( "soul_absorbed" );
+			return 1;
+		}
+		_k268 = getNextArrayKey( _a268, _k268 );
+	}
+	return 0;
+}
+
+reward_packed_weapon( player, s_stat )
+{
+	if ( !isDefined( s_stat.str_reward_weapon ) )
+	{
+		a_weapons = array( "scar_zm", "galil_zm", "mp44_zm" );
+		s_stat.str_reward_weapon = maps/mp/zombies/_zm_weapons::get_upgrade_weapon( random( a_weapons ) );
+	}
+	m_weapon = spawn( "script_model", self.origin );
+	m_weapon.angles = self.angles + vectorScale( ( 0, 1, 0 ), 180 );
+	m_weapon playsound( "zmb_spawn_powerup" );
+	m_weapon playloopsound( "zmb_spawn_powerup_loop", 0,5 );
+	str_model = getweaponmodel( s_stat.str_reward_weapon );
+	options = player maps/mp/zombies/_zm_weapons::get_pack_a_punch_weapon_options( s_stat.str_reward_weapon );
+	m_weapon useweaponmodel( s_stat.str_reward_weapon, str_model, options );
+	wait_network_frame();
+	if ( !reward_rise_and_grab( m_weapon, 50, 2, 2, 10 ) )
+	{
+		return 0;
+	}
+	weapon_limit = get_player_weapon_limit( player );
+	primaries = player getweaponslistprimaries();
+	if ( isDefined( primaries ) && primaries.size >= weapon_limit )
+	{
+		player maps/mp/zombies/_zm_weapons::weapon_give( s_stat.str_reward_weapon );
+	}
+	else
+	{
+		player giveweapon( s_stat.str_reward_weapon, 0, player maps/mp/zombies/_zm_weapons::get_pack_a_punch_weapon_options( s_stat.str_reward_weapon ) );
+		player givestartammo( s_stat.str_reward_weapon );
+	}
+	player switchtoweapon( s_stat.str_reward_weapon );
+	m_weapon stoploopsound( 0,1 );
+	player playsound( "zmb_powerup_grabbed" );
+	m_weapon delete();
+	return 1;
+}
+
+reward_powerup_max_ammo( player, s_stat )
+{
+	return reward_powerup( player, "full_ammo" );
+}
+
+reward_powerup_double_points( player, n_timeout )
+{
+	return reward_powerup( player, "double_points", n_timeout );
+}
+
+reward_powerup_zombie_blood( player, n_timeout )
+{
+	return reward_powerup( player, "zombie_blood", n_timeout );
+}
+
+reward_powerup( player, str_powerup, n_timeout )
+{
+	if ( !isDefined( n_timeout ) )
+	{
+		n_timeout = 10;
+	}
+	if ( !isDefined( level.zombie_powerups[ str_powerup ] ) )
+	{
+		return;
+	}
+	s_powerup = level.zombie_powerups[ str_powerup ];
+	m_reward = spawn( "script_model", self.origin );
+	m_reward.angles = self.angles + vectorScale( ( 0, 1, 0 ), 180 );
+	m_reward setmodel( s_powerup.model_name );
+	m_reward playsound( "zmb_spawn_powerup" );
+	m_reward playloopsound( "zmb_spawn_powerup_loop", 0,5 );
+	wait_network_frame();
+	if ( !reward_rise_and_grab( m_reward, 50, 2, 2, n_timeout ) )
+	{
+		return 0;
+	}
+	m_reward.hint = s_powerup.hint;
+	if ( !isDefined( player ) )
+	{
+		player = self.player_using;
+	}
+	switch( str_powerup )
+	{
+		case "full_ammo":
+			level thread maps/mp/zombies/_zm_powerups::full_ammo_powerup( m_reward, player );
+			player thread powerup_vo( "full_ammo" );
+			level thread maps/mp/zombies/_zm_audio_announcer::leaderdialog( "full_ammo", player.pers[ "team" ] );
+			break;
+		case "double_points":
+			level thread maps/mp/zombies/_zm_powerups::double_points_powerup( m_reward, player );
+			player thread powerup_vo( "double_points" );
+			level thread maps/mp/zombies/_zm_audio_announcer::leaderdialog( "double_points", player.pers[ "team" ] );
+			break;
+		case "zombie_blood":
+			level thread maps/mp/zombies/_zm_powerup_zombie_blood::zombie_blood_powerup( m_reward, player );
+			level thread maps/mp/zombies/_zm_audio_announcer::leaderdialog( "zombie_blood", player.pers[ "team" ] );
+	}
+	wait 0,1;
+	m_reward stoploopsound( 0,1 );
+	player playsound( "zmb_powerup_grabbed" );
+	m_reward delete();
+	return 1;
+}
+
+reward_double_tap( player, s_stat )
+{
+	m_reward = spawn( "script_model", self.origin );
+	m_reward.angles = self.angles + vectorScale( ( 0, 1, 0 ), 180 );
+	str_model = getweaponmodel( "zombie_perk_bottle_doubletap" );
+	m_reward setmodel( str_model );
+	m_reward playsound( "zmb_spawn_powerup" );
+	m_reward playloopsound( "zmb_spawn_powerup_loop", 0,5 );
+	wait_network_frame();
+	if ( !reward_rise_and_grab( m_reward, 50, 2, 2, 10 ) )
+	{
+		return 0;
+	}
+	if ( player hasperk( "specialty_rof" ) || player has_perk_paused( "specialty_rof" ) )
+	{
+		m_reward thread bottle_reject_sink( player );
+		return 0;
+	}
+	m_reward stoploopsound( 0,1 );
+	player playsound( "zmb_powerup_grabbed" );
+	m_reward thread maps/mp/zombies/_zm_perks::vending_trigger_post_think( player, "specialty_rof" );
+	m_reward delete();
+	return 1;
+}
+
+bottle_reject_sink( player )
+{
+	n_time = 1;
+	player playlocalsound( level.zmb_laugh_alias );
+	self thread maps/mp/zombies/_zm_challenges::reward_sink( 0, 61, n_time );
+	wait n_time;
+	self delete();
+}
+
+reward_one_inch_punch( player, s_stat )
+{
+	m_reward = spawn( "script_model", self.origin );
+	m_reward.angles = self.angles + vectorScale( ( 0, 1, 0 ), 180 );
+	m_reward setmodel( "tag_origin" );
+	playfxontag( level._effect[ "staff_soul" ], m_reward, "tag_origin" );
+	m_reward playsound( "zmb_spawn_powerup" );
+	m_reward playloopsound( "zmb_spawn_powerup_loop", 0,5 );
+	wait_network_frame();
+	if ( !reward_rise_and_grab( m_reward, 50, 2, 2, 10 ) )
+	{
+		return 0;
+	}
+	player thread maps/mp/zombies/_zm_weap_one_inch_punch::one_inch_punch_melee_attack();
+	m_reward stoploopsound( 0,1 );
+	player playsound( "zmb_powerup_grabbed" );
+	m_reward delete();
+	player thread one_inch_punch_watch_for_death( s_stat );
+	return 1;
+}
+
+one_inch_punch_watch_for_death( s_stat )
+{
+	self endon( "disconnect" );
+	self waittill( "bled_out" );
+	if ( s_stat.b_reward_claimed )
+	{
+		s_stat.b_reward_claimed = 0;
+	}
+	s_stat.a_b_player_rewarded[ self.characterindex ] = 0;
+}
+
+reward_beacon( player, s_stat )
+{
+	m_reward = spawn( "script_model", self.origin );
+	m_reward.angles = self.angles + vectorScale( ( 0, 1, 0 ), 180 );
+	str_model = getweaponmodel( "beacon_zm" );
+	m_reward setmodel( str_model );
+	m_reward playsound( "zmb_spawn_powerup" );
+	m_reward playloopsound( "zmb_spawn_powerup_loop", 0,5 );
+	wait_network_frame();
+	if ( !reward_rise_and_grab( m_reward, 50, 2, 2, 10 ) )
+	{
+		return 0;
+	}
+	player maps/mp/zombies/_zm_weapons::weapon_give( "beacon_zm" );
+	if ( isDefined( level.zombie_include_weapons[ "beacon_zm" ] ) && !level.zombie_include_weapons[ "beacon_zm" ] )
+	{
+		level.zombie_include_weapons[ "beacon_zm" ] = 1;
+		level.zombie_weapons[ "beacon_zm" ].is_in_box = 1;
+	}
+	m_reward stoploopsound( 0,1 );
+	player playsound( "zmb_powerup_grabbed" );
+	m_reward delete();
+	return 1;
+}

zm_tomb_patch/maps/mp/zm_tomb_chamber.gsc

@@ -0,0 +1,349 @@
+#include maps/mp/zombies/_zm_laststand;
+#include maps/mp/zombies/_zm_ai_basic;
+#include maps/mp/zm_tomb_utility;
+#include maps/mp/zombies/_zm_utility;
+#include maps/mp/_utility;
+#include common_scripts/utility;
+
+main()
+{
+	level thread inits();
+	level thread chamber_wall_change_randomly();
+}
+
+inits()
+{
+	a_walls = getentarray( "chamber_wall", "script_noteworthy" );
+	_a24 = a_walls;
+	_k24 = getFirstArrayKey( _a24 );
+	while ( isDefined( _k24 ) )
+	{
+		e_wall = _a24[ _k24 ];
+		e_wall.down_origin = e_wall.origin;
+		e_wall.up_origin = ( e_wall.origin[ 0 ], e_wall.origin[ 1 ], e_wall.origin[ 2 ] + 1000 );
+		_k24 = getNextArrayKey( _a24, _k24 );
+	}
+	level.n_chamber_wall_active = 0;
+	flag_wait( "start_zombie_round_logic" );
+	wait 3;
+	_a40 = a_walls;
+	_k40 = getFirstArrayKey( _a40 );
+	while ( isDefined( _k40 ) )
+	{
+		e_wall = _a40[ _k40 ];
+		e_wall moveto( e_wall.up_origin, 0,05 );
+		e_wall connectpaths();
+		_k40 = getNextArrayKey( _a40, _k40 );
+	}
+/#
+	level thread chamber_devgui();
+#/
+}
+
+chamber_devgui()
+{
+/#
+	setdvarint( "chamber_wall", 5 );
+	adddebugcommand( "devgui_cmd "Zombies/Tomb:1/Chamber:1/Fire:1" "chamber_wall 1"\n" );
+	adddebugcommand( "devgui_cmd "Zombies/Tomb:1/Chamber:1/Air:2" "chamber_wall 2"\n" );
+	adddebugcommand( "devgui_cmd "Zombies/Tomb:1/Chamber:1/Lightning:3" "chamber_wall 3"\n" );
+	adddebugcommand( "devgui_cmd "Zombies/Tomb:1/Chamber:1/Water:4" "chamber_wall 4"\n" );
+	adddebugcommand( "devgui_cmd "Zombies/Tomb:1/Chamber:1/None:5" "chamber_wall 0"\n" );
+	level thread watch_chamber_wall();
+#/
+}
+
+watch_chamber_wall()
+{
+/#
+	while ( 1 )
+	{
+		if ( getDvarInt( #"763A3046" ) != 5 )
+		{
+			chamber_change_walls( getDvarInt( #"763A3046" ) );
+			setdvarint( "chamber_wall", 5 );
+		}
+		wait 0,05;
+#/
+	}
+}
+
+cap_value( val, min, max )
+{
+	if ( val < min )
+	{
+		return min;
+	}
+	else
+	{
+		if ( val > max )
+		{
+			return max;
+		}
+		else
+		{
+			return val;
+		}
+	}
+}
+
+chamber_wall_dust()
+{
+	i = 1;
+	while ( i <= 9 )
+	{
+		playfxontag( level._effect[ "crypt_wall_drop" ], self, "tag_fx_dust_0" + i );
+		wait_network_frame();
+		i++;
+	}
+}
+
+chamber_change_walls( n_element )
+{
+	if ( n_element == level.n_chamber_wall_active )
+	{
+		return;
+	}
+	e_current_wall = undefined;
+	e_new_wall = undefined;
+	playsoundatposition( "zmb_chamber_wallchange", ( 10342, -7921, -272 ) );
+	a_walls = getentarray( "chamber_wall", "script_noteworthy" );
+	_a123 = a_walls;
+	_k123 = getFirstArrayKey( _a123 );
+	while ( isDefined( _k123 ) )
+	{
+		e_wall = _a123[ _k123 ];
+		if ( e_wall.script_int == n_element )
+		{
+			e_wall thread move_wall_down();
+		}
+		else
+		{
+			if ( e_wall.script_int == level.n_chamber_wall_active )
+			{
+				e_wall thread move_wall_up();
+			}
+		}
+		_k123 = getNextArrayKey( _a123, _k123 );
+	}
+	level.n_chamber_wall_active = n_element;
+}
+
+is_chamber_occupied()
+{
+	a_players = getplayers();
+	_a142 = a_players;
+	_k142 = getFirstArrayKey( _a142 );
+	while ( isDefined( _k142 ) )
+	{
+		e_player = _a142[ _k142 ];
+		if ( is_point_in_chamber( e_player.origin ) )
+		{
+			return 1;
+		}
+		_k142 = getNextArrayKey( _a142, _k142 );
+	}
+	return 0;
+}
+
+is_point_in_chamber( v_origin )
+{
+	if ( !isDefined( level.s_chamber_center ) )
+	{
+		level.s_chamber_center = getstruct( "chamber_center", "targetname" );
+		level.s_chamber_center.radius_sq = level.s_chamber_center.script_float * level.s_chamber_center.script_float;
+	}
+	return distance2dsquared( level.s_chamber_center.origin, v_origin ) < level.s_chamber_center.radius_sq;
+}
+
+chamber_wall_change_randomly()
+{
+	flag_wait( "start_zombie_round_logic" );
+	a_element_enums = array( 1, 2, 3, 4 );
+	level endon( "stop_random_chamber_walls" );
+	n_elem_prev = undefined;
+	while ( 1 )
+	{
+		while ( !is_chamber_occupied() )
+		{
+			wait 1;
+		}
+		flag_wait( "any_crystal_picked_up" );
+		n_round = cap_value( level.round_number, 10, 30 );
+		f_progression_pct = ( n_round - 10 ) / ( 30 - 10 );
+		n_change_wall_time = lerpfloat( 15, 5, f_progression_pct );
+		n_elem = random( a_element_enums );
+		arrayremovevalue( a_element_enums, n_elem, 0 );
+		if ( isDefined( n_elem_prev ) )
+		{
+			a_element_enums[ a_element_enums.size ] = n_elem_prev;
+		}
+		chamber_change_walls( n_elem );
+		wait n_change_wall_time;
+		n_elem_prev = n_elem;
+	}
+}
+
+move_wall_up()
+{
+	self moveto( self.up_origin, 1 );
+	self waittill( "movedone" );
+	self connectpaths();
+}
+
+move_wall_down()
+{
+	self moveto( self.down_origin, 1 );
+	self waittill( "movedone" );
+	rumble_players_in_chamber( 2, 0,1 );
+	self thread chamber_wall_dust();
+	self disconnectpaths();
+}
+
+random_shuffle( a_items, item )
+{
+	b_done_shuffling = undefined;
+	if ( !isDefined( item ) )
+	{
+		item = a_items[ a_items.size - 1 ];
+	}
+	while ( isDefined( b_done_shuffling ) && !b_done_shuffling )
+	{
+		a_items = array_randomize( a_items );
+		if ( a_items[ 0 ] != item )
+		{
+			b_done_shuffling = 1;
+		}
+		wait 0,05;
+	}
+	return a_items;
+}
+
+tomb_chamber_find_exit_point()
+{
+	self endon( "death" );
+	player = get_players()[ 0 ];
+	dist_zombie = 0;
+	dist_player = 0;
+	dest = 0;
+	away = vectornormalize( self.origin - player.origin );
+	endpos = self.origin + vectorScale( away, 600 );
+	locs = array_randomize( level.enemy_dog_locations );
+	i = 0;
+	while ( i < locs.size )
+	{
+		dist_zombie = distancesquared( locs[ i ].origin, endpos );
+		dist_player = distancesquared( locs[ i ].origin, player.origin );
+		if ( dist_zombie < dist_player )
+		{
+			dest = i;
+			break;
+		}
+		else
+		{
+			i++;
+		}
+	}
+	self notify( "stop_find_flesh" );
+	self notify( "zombie_acquire_enemy" );
+	if ( isDefined( locs[ dest ] ) )
+	{
+		self setgoalpos( locs[ dest ].origin );
+	}
+	self.b_wandering_in_chamber = 1;
+	flag_wait( "player_active_in_chamber" );
+	self.b_wandering_in_chamber = 0;
+	self thread maps/mp/zombies/_zm_ai_basic::find_flesh();
+}
+
+chamber_zombies_find_poi()
+{
+	zombies = getaiarray( level.zombie_team );
+	i = 0;
+	while ( i < zombies.size )
+	{
+		if ( isDefined( zombies[ i ].b_wandering_in_chamber ) && zombies[ i ].b_wandering_in_chamber )
+		{
+			i++;
+			continue;
+		}
+		else
+		{
+			if ( !is_point_in_chamber( zombies[ i ].origin ) )
+			{
+				i++;
+				continue;
+			}
+			else
+			{
+				zombies[ i ] thread tomb_chamber_find_exit_point();
+			}
+		}
+		i++;
+	}
+}
+
+tomb_is_valid_target_in_chamber()
+{
+	a_players = getplayers();
+	_a322 = a_players;
+	_k322 = getFirstArrayKey( _a322 );
+	while ( isDefined( _k322 ) )
+	{
+		e_player = _a322[ _k322 ];
+		if ( e_player maps/mp/zombies/_zm_laststand::player_is_in_laststand() )
+		{
+		}
+		else if ( isDefined( e_player.b_zombie_blood ) || e_player.b_zombie_blood && isDefined( e_player.ignoreme ) && e_player.ignoreme )
+		{
+		}
+		else
+		{
+			if ( !is_point_in_chamber( e_player.origin ) )
+			{
+				break;
+			}
+			else
+			{
+				return 1;
+			}
+		}
+		_k322 = getNextArrayKey( _a322, _k322 );
+	}
+	return 0;
+}
+
+is_player_in_chamber()
+{
+	if ( is_point_in_chamber( self.origin ) )
+	{
+		return 1;
+	}
+	else
+	{
+		return 0;
+	}
+}
+
+tomb_watch_chamber_player_activity()
+{
+	flag_init( "player_active_in_chamber" );
+	flag_wait( "start_zombie_round_logic" );
+	while ( 1 )
+	{
+		wait 1;
+		if ( is_chamber_occupied() )
+		{
+			if ( tomb_is_valid_target_in_chamber() )
+			{
+				flag_set( "player_active_in_chamber" );
+				break;
+			}
+			else
+			{
+				flag_clear( "player_active_in_chamber" );
+				chamber_zombies_find_poi();
+			}
+		}
+	}
+}

zm_tomb_patch/maps/mp/zm_tomb_classic.gsc

@@ -0,0 +1,36 @@
+#include maps/mp/zombies/_zm_magicbox;
+#include maps/mp/zombies/_zm_game_module;
+#include maps/mp/gametypes_zm/_zm_gametype;
+#include maps/mp/zm_tomb_craftables;
+#include maps/mp/zombies/_zm_craftables;
+#include maps/mp/zombies/_zm_utility;
+#include common_scripts/utility;
+#include maps/mp/_utility;
+
+precache()
+{
+	if ( isDefined( level.createfx_enabled ) && level.createfx_enabled )
+	{
+		return;
+	}
+	maps/mp/zombies/_zm_craftables::init();
+	maps/mp/zm_tomb_craftables::randomize_craftable_spawns();
+	maps/mp/zm_tomb_craftables::include_craftables();
+	maps/mp/zm_tomb_craftables::init_craftables();
+}
+
+main()
+{
+	maps/mp/gametypes_zm/_zm_gametype::setup_standard_objects( "tomb" );
+	maps/mp/zombies/_zm_game_module::set_current_game_module( level.game_module_standard_index );
+	level thread maps/mp/zombies/_zm_craftables::think_craftables();
+	flag_wait( "initial_blackscreen_passed" );
+}
+
+zm_treasure_chest_init()
+{
+	chest1 = getstruct( "start_chest", "script_noteworthy" );
+	level.chests = [];
+	level.chests[ level.chests.size ] = chest1;
+	maps/mp/zombies/_zm_magicbox::treasure_chest_init( "start_chest" );
+}

zm_tomb_patch/maps/mp/zm_tomb_distance_tracking.gsc

@@ -0,0 +1,433 @@
+#include maps/mp/zm_tomb_chamber;
+#include maps/mp/zombies/_zm_ai_basic;
+#include maps/mp/zombies/_zm_spawner;
+#include maps/mp/zombies/_zm_zonemgr;
+#include maps/mp/zombies/_zm_utility;
+#include maps/mp/_utility;
+#include common_scripts/utility;
+
+zombie_tracking_init()
+{
+	level.zombie_respawned_health = [];
+	if ( !isDefined( level.zombie_tracking_dist ) )
+	{
+		level.zombie_tracking_dist = 1520;
+	}
+	if ( !isDefined( level.zombie_tracking_high ) )
+	{
+		level.zombie_tracking_high = 1000;
+	}
+	if ( !isDefined( level.zombie_tracking_wait ) )
+	{
+		level.zombie_tracking_wait = 10;
+	}
+	for ( ;; )
+	{
+		while ( 1 )
+		{
+			a_players = get_players();
+			_a33 = a_players;
+			_k33 = getFirstArrayKey( _a33 );
+			while ( isDefined( _k33 ) )
+			{
+				player = _a33[ _k33 ];
+				if ( !player maps/mp/zombies/_zm_zonemgr::player_in_zone( "zone_air_stairs" ) && !player maps/mp/zombies/_zm_zonemgr::player_in_zone( "zone_bolt_stairs" ) || player maps/mp/zombies/_zm_zonemgr::player_in_zone( "zone_fire_stairs" ) && player maps/mp/zombies/_zm_zonemgr::player_in_zone( "zone_ice_stairs" ) )
+				{
+					player.b_in_tunnels = 1;
+				}
+				else
+				{
+					player.b_in_tunnels = 0;
+				}
+				_k33 = getNextArrayKey( _a33, _k33 );
+			}
+			zombies = get_round_enemy_array();
+			if ( !isDefined( zombies ) || isDefined( level.ignore_distance_tracking ) && level.ignore_distance_tracking )
+			{
+				wait level.zombie_tracking_wait;
+			}
+		}
+		else i = 0;
+		while ( i < zombies.size )
+		{
+			if ( isDefined( zombies[ i ] ) && isDefined( zombies[ i ].ignore_distance_tracking ) && !zombies[ i ].ignore_distance_tracking )
+			{
+				zombies[ i ] thread delete_zombie_noone_looking( level.zombie_tracking_dist, level.zombie_tracking_high );
+			}
+			i++;
+		}
+		wait level.zombie_tracking_wait;
+	}
+}
+
+delete_zombie_noone_looking( how_close, how_high )
+{
+	self endon( "death" );
+	if ( !isDefined( how_close ) )
+	{
+		how_close = 1500;
+	}
+	if ( !isDefined( how_high ) )
+	{
+		how_high = 600;
+	}
+	distance_squared_check = how_close * how_close;
+	too_far_dist = distance_squared_check * 3;
+	if ( isDefined( level.zombie_tracking_too_far_dist ) )
+	{
+		too_far_dist = level.zombie_tracking_too_far_dist * level.zombie_tracking_too_far_dist;
+	}
+	self.inview = 0;
+	self.player_close = 0;
+	n_distance_squared = 0;
+	n_height_difference = 0;
+	players = get_players();
+	i = 0;
+	while ( i < players.size )
+	{
+		if ( players[ i ].sessionstate == "spectator" )
+		{
+			i++;
+			continue;
+		}
+		else if ( isDefined( level.only_track_targeted_players ) )
+		{
+			if ( !isDefined( self.favoriteenemy ) || self.favoriteenemy != players[ i ] )
+			{
+				i++;
+				continue;
+			}
+		}
+		else
+		{
+			can_be_seen = self player_can_see_me( players[ i ] );
+			if ( can_be_seen && distancesquared( self.origin, players[ i ].origin ) < too_far_dist )
+			{
+				self.inview++;
+			}
+			n_modifier = 1;
+			if ( isDefined( players[ i ].b_in_tunnels ) && players[ i ].b_in_tunnels )
+			{
+				n_modifier = 2,25;
+			}
+			n_distance_squared = distancesquared( self.origin, players[ i ].origin );
+			n_height_difference = abs( self.origin[ 2 ] - players[ i ].origin[ 2 ] );
+			if ( n_distance_squared < ( distance_squared_check * n_modifier ) && n_height_difference < how_high )
+			{
+				self.player_close++;
+			}
+		}
+		i++;
+	}
+	if ( self.inview == 0 && self.player_close == 0 )
+	{
+		if ( !isDefined( self.animname ) || self.animname != "zombie" && self.animname != "mechz_zombie" )
+		{
+			return;
+		}
+		if ( isDefined( self.electrified ) && self.electrified == 1 )
+		{
+			return;
+		}
+		if ( isDefined( self.in_the_ground ) && self.in_the_ground == 1 )
+		{
+			return;
+		}
+		zombies = getaiarray( "axis" );
+		if ( isDefined( self.damagemod ) && self.damagemod == "MOD_UNKNOWN" && self.health < self.maxhealth )
+		{
+			if ( isDefined( self.exclude_distance_cleanup_adding_to_total ) && !self.exclude_distance_cleanup_adding_to_total && isDefined( self.isscreecher ) && !self.isscreecher )
+			{
+				level.zombie_total++;
+				level.zombie_respawned_health[ level.zombie_respawned_health.size ] = self.health;
+			}
+		}
+		else
+		{
+			if ( ( zombies.size + level.zombie_total ) > 24 || ( zombies.size + level.zombie_total ) <= 24 && self.health >= self.maxhealth )
+			{
+				if ( isDefined( self.exclude_distance_cleanup_adding_to_total ) && !self.exclude_distance_cleanup_adding_to_total && isDefined( self.isscreecher ) && !self.isscreecher )
+				{
+					level.zombie_total++;
+					if ( self.health < level.zombie_health )
+					{
+						level.zombie_respawned_health[ level.zombie_respawned_health.size ] = self.health;
+					}
+				}
+			}
+		}
+		self maps/mp/zombies/_zm_spawner::reset_attack_spot();
+		self notify( "zombie_delete" );
+		if ( isDefined( self.is_mechz ) && self.is_mechz )
+		{
+			self notify( "mechz_cleanup" );
+			level.mechz_left_to_spawn++;
+			wait_network_frame();
+			level notify( "spawn_mechz" );
+		}
+		self delete();
+		recalc_zombie_array();
+	}
+}
+
+player_can_see_me( 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 );
+	if ( forwarddotbanzai >= 1 )
+	{
+		anglefromcenter = 0;
+	}
+	else if ( forwarddotbanzai <= -1 )
+	{
+		anglefromcenter = 180;
+	}
+	else
+	{
+		anglefromcenter = acos( forwarddotbanzai );
+	}
+	playerfov = getDvarFloat( "cg_fov" );
+	banzaivsplayerfovbuffer = getDvarFloat( "g_banzai_player_fov_buffer" );
+	if ( banzaivsplayerfovbuffer <= 0 )
+	{
+		banzaivsplayerfovbuffer = 0,2;
+	}
+	playercanseeme = anglefromcenter <= ( ( playerfov * 0,5 ) * ( 1 - banzaivsplayerfovbuffer ) );
+	return playercanseeme;
+}
+
+escaped_zombies_cleanup_init()
+{
+	self endon( "death" );
+	self.zombie_path_bad = 0;
+	while ( 1 )
+	{
+		if ( !self.zombie_path_bad )
+		{
+			self waittill( "bad_path" );
+		}
+		found_player = undefined;
+		players = get_players();
+		i = 0;
+		while ( i < players.size )
+		{
+			if ( is_player_valid( players[ i ] ) && self maymovetopoint( players[ i ].origin, 1 ) )
+			{
+				self.favoriteenemy = players[ i ];
+				found_player = 1;
+				i++;
+				continue;
+			}
+			i++;
+		}
+		n_delete_distance = 1500;
+		n_delete_height = 1000;
+		if ( !isDefined( found_player ) && isDefined( self.in_the_ground ) && !isDefined( self.completed_emerging_into_playable_area ) )
+		{
+			self thread delete_zombie_noone_looking( n_delete_distance, n_delete_height );
+			self.zombie_path_bad = 1;
+			self escaped_zombies_cleanup();
+		}
+		else
+		{
+			if ( !isDefined( found_player ) && isDefined( self.completed_emerging_into_playable_area ) && self.completed_emerging_into_playable_area )
+			{
+				self thread delete_zombie_noone_looking( n_delete_distance, n_delete_height );
+				self.zombie_path_bad = 1;
+				self escaped_zombies_cleanup();
+			}
+		}
+		wait 0,1;
+	}
+}
+
+escaped_zombies_cleanup()
+{
+	self endon( "death" );
+	s_escape = self get_escape_position();
+	self notify( "stop_find_flesh" );
+	self notify( "zombie_acquire_enemy" );
+	if ( isDefined( s_escape ) )
+	{
+		self setgoalpos( s_escape.origin );
+		self thread check_player_available();
+		self waittill_any( "goal", "reaquire_player" );
+	}
+	self.zombie_path_bad = !can_zombie_path_to_any_player();
+	wait 0,1;
+	if ( !self.zombie_path_bad )
+	{
+		self thread maps/mp/zombies/_zm_ai_basic::find_flesh();
+	}
+}
+
+get_escape_position()
+{
+	self endon( "death" );
+	str_zone = get_current_zone();
+	if ( !isDefined( str_zone ) )
+	{
+		str_zone = self.zone_name;
+	}
+	if ( isDefined( str_zone ) )
+	{
+		a_zones = get_adjacencies_to_zone( str_zone );
+		a_dog_locations = get_dog_locations_in_zones( a_zones );
+		s_farthest = self get_farthest_dog_location( a_dog_locations );
+	}
+	return s_farthest;
+}
+
+check_player_available()
+{
+	self notify( "_check_player_available" );
+	self endon( "_check_player_available" );
+	self endon( "death" );
+	self endon( "goal" );
+	while ( self.zombie_path_bad )
+	{
+		wait randomfloatrange( 0,2, 0,5 );
+		if ( self can_zombie_see_any_player() )
+		{
+			self notify( "reaquire_player" );
+			return;
+		}
+	}
+	self notify( "reaquire_player" );
+}
+
+can_zombie_path_to_any_player()
+{
+	a_players = get_players();
+	i = 0;
+	while ( i < a_players.size )
+	{
+		if ( !is_player_valid( a_players[ i ] ) )
+		{
+			i++;
+			continue;
+		}
+		else
+		{
+			v_player_origin = a_players[ i ].origin;
+			if ( isDefined( self.b_on_tank ) )
+			{
+				if ( isDefined( a_players[ i ].b_already_on_tank ) )
+				{
+					if ( self.b_on_tank != a_players[ i ].b_already_on_tank )
+					{
+						v_player_origin = level.vh_tank gettagorigin( "window_left_rear_jmp_jnt" );
+					}
+				}
+			}
+			if ( findpath( self.origin, v_player_origin ) )
+			{
+				return 1;
+			}
+		}
+		i++;
+	}
+	return 0;
+}
+
+can_zombie_see_any_player()
+{
+	a_players = get_players();
+	zombie_in_chamber = maps/mp/zm_tomb_chamber::is_point_in_chamber( self.origin );
+	i = 0;
+	while ( i < a_players.size )
+	{
+		if ( !is_player_valid( a_players[ i ] ) )
+		{
+			i++;
+			continue;
+		}
+		else player_origin = a_players[ i ].origin;
+		if ( isDefined( a_players[ i ].b_already_on_tank ) && a_players[ i ].b_already_on_tank )
+		{
+			if ( isDefined( self.b_on_tank ) && self.b_on_tank )
+			{
+				return 1;
+			}
+			else
+			{
+				player_origin = level.vh_tank gettagorigin( "window_left_rear_jmp_jnt" );
+			}
+		}
+		else
+		{
+			player_in_chamber = maps/mp/zm_tomb_chamber::is_point_in_chamber( a_players[ i ].origin );
+			if ( player_in_chamber != zombie_in_chamber )
+			{
+				i++;
+				continue;
+			}
+		}
+		else
+		{
+			path_length = 0;
+			path_length = self calcpathlength( player_origin );
+			if ( self maymovetopoint( player_origin, 1 ) || path_length != 0 )
+			{
+				return 1;
+			}
+		}
+		i++;
+	}
+	return 0;
+}
+
+get_adjacencies_to_zone( str_zone )
+{
+	a_adjacencies = [];
+	a_adjacencies[ 0 ] = str_zone;
+	a_adjacent_zones = getarraykeys( level.zones[ str_zone ].adjacent_zones );
+	i = 0;
+	while ( i < a_adjacent_zones.size )
+	{
+		if ( level.zones[ str_zone ].adjacent_zones[ a_adjacent_zones[ i ] ].is_connected )
+		{
+			a_adjacencies[ a_adjacencies.size ] = a_adjacent_zones[ i ];
+		}
+		i++;
+	}
+	return a_adjacencies;
+}
+
+get_dog_locations_in_zones( a_zones )
+{
+	a_dog_locations = [];
+	_a471 = a_zones;
+	_k471 = getFirstArrayKey( _a471 );
+	while ( isDefined( _k471 ) )
+	{
+		zone = _a471[ _k471 ];
+		a_dog_locations = arraycombine( a_dog_locations, level.zones[ zone ].dog_locations, 0, 0 );
+		_k471 = getNextArrayKey( _a471, _k471 );
+	}
+	return a_dog_locations;
+}
+
+get_farthest_dog_location( a_dog_locations )
+{
+	n_farthest_index = 0;
+	n_distance_farthest = 0;
+	i = 0;
+	while ( i < a_dog_locations.size )
+	{
+		n_distance_sq = distancesquared( self.origin, a_dog_locations[ i ].origin );
+		if ( n_distance_sq > n_distance_farthest )
+		{
+			n_distance_farthest = n_distance_sq;
+			n_farthest_index = i;
+		}
+		i++;
+	}
+	return a_dog_locations[ n_farthest_index ];
+}

zm_tomb_patch/maps/mp/zm_tomb_ee_lights.gsc

@@ -0,0 +1,197 @@
+#include maps/mp/zm_tomb_quest_crypt;
+#include maps/mp/zombies/_zm_net;
+#include maps/mp/zm_tomb_utility;
+#include maps/mp/zombies/_zm_sidequests;
+#include maps/mp/zombies/_zm_craftables;
+#include maps/mp/zombies/_zm_utility;
+#include maps/mp/_utility;
+#include common_scripts/utility;
+
+main()
+{
+	registerclientfield( "world", "light_show", 14000, 2, "int" );
+	flag_init( "show_morse_code" );
+	init_morse_code();
+	flag_wait( "start_zombie_round_logic" );
+	chamber_discs = getentarray( "crypt_puzzle_disc", "script_noteworthy" );
+	lit_discs = [];
+	_a24 = chamber_discs;
+	_k24 = getFirstArrayKey( _a24 );
+	while ( isDefined( _k24 ) )
+	{
+		disc = _a24[ _k24 ];
+		if ( isDefined( disc.script_int ) )
+		{
+			lit_discs[ disc.script_int - 1 ] = disc;
+		}
+		_k24 = getNextArrayKey( _a24, _k24 );
+	}
+	flag_wait_any( "ee_all_staffs_upgraded", "show_morse_code" );
+	while ( 1 )
+	{
+		setclientfield( "light_show", 1 );
+		if ( randomint( 100 ) < 10 )
+		{
+			turn_all_lights_off( lit_discs );
+			wait 10;
+			setclientfield( "light_show", 3 );
+			light_show_morse( lit_discs, "GIOVAN BATTISTA BELLASO" );
+			setclientfield( "light_show", 1 );
+		}
+		turn_all_lights_off( lit_discs );
+		wait 10;
+		setclientfield( "light_show", 2 );
+		light_show_morse( lit_discs, level.cipher_key );
+		_a56 = level.morse_messages;
+		_k56 = getFirstArrayKey( _a56 );
+		while ( isDefined( _k56 ) )
+		{
+			message = _a56[ _k56 ];
+			setclientfield( "light_show", 1 );
+			cipher = phrase_convert_to_cipher( message, level.cipher_key );
+			turn_all_lights_off( lit_discs );
+			wait 10;
+			light_show_morse( lit_discs, cipher );
+			_k56 = getNextArrayKey( _a56, _k56 );
+		}
+	}
+}
+
+init_morse_code()
+{
+	level.morse_letters = [];
+	level.morse_letters[ "A" ] = ".-";
+	level.morse_letters[ "B" ] = "-...";
+	level.morse_letters[ "C" ] = "-.-.";
+	level.morse_letters[ "D" ] = "-..";
+	level.morse_letters[ "E" ] = ".";
+	level.morse_letters[ "F" ] = "..-.";
+	level.morse_letters[ "G" ] = "--.";
+	level.morse_letters[ "H" ] = "....";
+	level.morse_letters[ "I" ] = "..";
+	level.morse_letters[ "J" ] = ".---";
+	level.morse_letters[ "K" ] = "-.-";
+	level.morse_letters[ "L" ] = ".-..";
+	level.morse_letters[ "M" ] = "--";
+	level.morse_letters[ "N" ] = "-.";
+	level.morse_letters[ "O" ] = "---";
+	level.morse_letters[ "P" ] = ".--.";
+	level.morse_letters[ "Q" ] = "--.-";
+	level.morse_letters[ "R" ] = ".-.";
+	level.morse_letters[ "S" ] = "...";
+	level.morse_letters[ "T" ] = "-";
+	level.morse_letters[ "U" ] = "..-";
+	level.morse_letters[ "V" ] = "...-";
+	level.morse_letters[ "W" ] = ".--";
+	level.morse_letters[ "X" ] = "-..-";
+	level.morse_letters[ "Y" ] = "-.--";
+	level.morse_letters[ "Z" ] = "--..";
+	level.morse_messages = [];
+	level.morse_messages[ 0 ] = "WARN MESSINES";
+	level.morse_messages[ 1 ] = "SOMETHING BLUE IN THE EARTH";
+	level.morse_messages[ 2 ] = "NOT CLAY";
+	level.morse_messages[ 3 ] = "WE GREW WEAK";
+	level.morse_messages[ 4 ] = "THOUGHT IT WAS FLU";
+	level.morse_messages[ 5 ] = "MEN BECAME BEASTS";
+	level.morse_messages[ 6 ] = "BLOOD TURNED TO ASH";
+	level.morse_messages[ 7 ] = "LIBERATE TUTE DE INFERNIS";
+	level.cipher_key = "INFERNO";
+}
+
+turn_all_lights_off( a_discs )
+{
+	_a114 = a_discs;
+	_k114 = getFirstArrayKey( _a114 );
+	while ( isDefined( _k114 ) )
+	{
+		disc = _a114[ _k114 ];
+		disc maps/mp/zm_tomb_quest_crypt::bryce_cake_light_update( 0 );
+		_k114 = getNextArrayKey( _a114, _k114 );
+	}
+}
+
+turn_all_lights_on( a_discs )
+{
+	_a122 = a_discs;
+	_k122 = getFirstArrayKey( _a122 );
+	while ( isDefined( _k122 ) )
+	{
+		disc = _a122[ _k122 ];
+		disc maps/mp/zm_tomb_quest_crypt::bryce_cake_light_update( 1 );
+		_k122 = getNextArrayKey( _a122, _k122 );
+	}
+}
+
+phrase_convert_to_cipher( str_phrase, str_key )
+{
+	alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+	alphabet_vals = [];
+	num = 0;
+	i = 0;
+	while ( i < alphabet.size )
+	{
+		letter = alphabet[ i ];
+		alphabet_vals[ letter ] = num;
+		num++;
+		i++;
+	}
+	encrypted_phrase = [];
+	j = 0;
+	i = 0;
+	while ( i < str_phrase.size )
+	{
+		cipher_letter = str_key[ j % str_key.size ];
+		original_letter = str_phrase[ i ];
+		n_original_letter = alphabet_vals[ original_letter ];
+		if ( !isDefined( n_original_letter ) )
+		{
+			encrypted_phrase[ encrypted_phrase.size ] = original_letter;
+			i++;
+			continue;
+		}
+		else
+		{
+			n_cipher_offset = alphabet_vals[ cipher_letter ];
+			n_ciphered_letter = ( n_original_letter + n_cipher_offset ) % alphabet.size;
+			encrypted_phrase[ encrypted_phrase.size ] = alphabet[ n_ciphered_letter ];
+			j++;
+		}
+		i++;
+	}
+	return encrypted_phrase;
+}
+
+light_show_morse( a_discs, message )
+{
+	i = 0;
+	while ( i < message.size )
+	{
+		letter = message[ i ];
+		letter_code = level.morse_letters[ letter ];
+		if ( isDefined( letter_code ) )
+		{
+			j = 0;
+			while ( j < letter_code.size )
+			{
+				turn_all_lights_on( a_discs );
+				if ( letter_code[ j ] == "." )
+				{
+					wait 0,2;
+				}
+				else
+				{
+					if ( letter_code[ j ] == "-" )
+					{
+						wait 1;
+					}
+				}
+				turn_all_lights_off( a_discs );
+				wait 0,5;
+				j++;
+			}
+		}
+		else wait 2;
+		wait 1,5;
+		i++;
+	}
+}

zm_tomb_patch/maps/mp/zm_tomb_ee_main.gsc

@@ -0,0 +1,527 @@
+#include maps/mp/zombies/_zm_weapons;
+#include maps/mp/zombies/_zm;
+#include maps/mp/zm_tomb_amb;
+#include maps/mp/gametypes_zm/_hud;
+#include maps/mp/gametypes_zm/_hud_util;
+#include maps/mp/zm_tomb_vo;
+#include maps/mp/zm_tomb_utility;
+#include maps/mp/zombies/_zm_sidequests;
+#include maps/mp/zombies/_zm_utility;
+#include maps/mp/_utility;
+#include common_scripts/utility;
+
+init()
+{
+	registerclientfield( "actor", "ee_zombie_fist_fx", 14000, 1, "int" );
+	registerclientfield( "actor", "ee_zombie_soul_portal", 14000, 1, "int" );
+	registerclientfield( "world", "ee_sam_portal", 14000, 2, "int" );
+	registerclientfield( "vehicle", "ee_plane_fx", 14000, 1, "int" );
+	registerclientfield( "world", "ee_ending", 14000, 1, "int" );
+	precache_models();
+	flag_init( "ee_all_staffs_crafted" );
+	flag_init( "ee_all_staffs_upgraded" );
+	flag_init( "ee_all_staffs_placed" );
+	flag_init( "ee_mech_zombie_hole_opened" );
+	flag_init( "ee_mech_zombie_fight_completed" );
+	flag_init( "ee_maxis_drone_retrieved" );
+	flag_init( "ee_all_players_upgraded_punch" );
+	flag_init( "ee_souls_absorbed" );
+	flag_init( "ee_samantha_released" );
+	flag_init( "ee_quadrotor_disabled" );
+	flag_init( "ee_sam_portal_active" );
+	if ( !is_sidequest_allowed( "zclassic" ) )
+	{
+		return;
+	}
+/#
+	level thread setup_ee_main_devgui();
+#/
+	declare_sidequest( "little_girl_lost", ::init_sidequest, ::sidequest_logic, ::complete_sidequest, ::generic_stage_start, ::generic_stage_end );
+	maps/mp/zm_tomb_ee_main_step_1::init();
+	maps/mp/zm_tomb_ee_main_step_2::init();
+	maps/mp/zm_tomb_ee_main_step_3::init();
+	maps/mp/zm_tomb_ee_main_step_4::init();
+	maps/mp/zm_tomb_ee_main_step_5::init();
+	maps/mp/zm_tomb_ee_main_step_6::init();
+	maps/mp/zm_tomb_ee_main_step_7::init();
+	maps/mp/zm_tomb_ee_main_step_8::init();
+	flag_wait( "start_zombie_round_logic" );
+	sidequest_start( "little_girl_lost" );
+}
+
+precache_models()
+{
+	precachemodel( "p_rus_alarm_button" );
+	precachemodel( "p6_zm_tm_staff_holder" );
+	precachemodel( "p6_zm_tm_runes" );
+	precachemodel( "drone_collision" );
+}
+
+init_sidequest()
+{
+	level.n_ee_step = 0;
+	level.n_ee_robot_staffs_planted = 0;
+}
+
+sidequest_logic()
+{
+	level._cur_stage_name = "step_0";
+	flag_wait( "ee_all_staffs_crafted" );
+	flag_wait( "all_zones_captured" );
+	level.n_ee_step++;
+	level thread zombie_blood_hint_watch();
+	stage_start( "little_girl_lost", "step_1" );
+	level waittill( "little_girl_lost_step_1_over" );
+	stage_start( "little_girl_lost", "step_2" );
+	level waittill( "little_girl_lost_step_2_over" );
+	level thread maps/mp/zm_tomb_amb::sndplaystingerwithoverride( "mus_event_ee_step2", 15 );
+	stage_start( "little_girl_lost", "step_3" );
+	level waittill( "little_girl_lost_step_3_over" );
+	level thread maps/mp/zm_tomb_amb::sndplaystingerwithoverride( "mus_event_ee_step3", 35 );
+	stage_start( "little_girl_lost", "step_4" );
+	level waittill( "little_girl_lost_step_4_over" );
+	level thread maps/mp/zm_tomb_amb::sndplaystingerwithoverride( "mus_event_ee_step4", 30 );
+	stage_start( "little_girl_lost", "step_5" );
+	level waittill( "little_girl_lost_step_5_over" );
+	level thread maps/mp/zm_tomb_amb::sndplaystingerwithoverride( "mus_event_ee_step5", 29 );
+	stage_start( "little_girl_lost", "step_6" );
+	level waittill( "little_girl_lost_step_6_over" );
+	level thread maps/mp/zm_tomb_amb::sndplaystingerwithoverride( "mus_event_ee_step6", 28 );
+	stage_start( "little_girl_lost", "step_7" );
+	level waittill( "little_girl_lost_step_7_over" );
+	level thread maps/mp/zm_tomb_amb::sndplaystingerwithoverride( "mus_event_ee_step7", 31 );
+	stage_start( "little_girl_lost", "step_8" );
+	level waittill( "little_girl_lost_step_8_over" );
+}
+
+zombie_blood_hint_watch()
+{
+	n_curr_step = level.n_ee_step;
+	a_player_hint[ 0 ] = 0;
+	a_player_hint[ 1 ] = 0;
+	a_player_hint[ 2 ] = 0;
+	a_player_hint[ 3 ] = 0;
+	while ( !flag( "ee_samantha_released" ) )
+	{
+		level waittill( "player_zombie_blood", e_player );
+		while ( n_curr_step != level.n_ee_step )
+		{
+			n_curr_step = level.n_ee_step;
+			i = 0;
+			while ( i < a_player_hint.size )
+			{
+				a_player_hint[ i ] = 0;
+				i++;
+			}
+		}
+		if ( !a_player_hint[ e_player.characterindex ] )
+		{
+			wait randomfloatrange( 3, 7 );
+			if ( isDefined( e_player.vo_promises_playing ) && e_player.vo_promises_playing )
+			{
+				continue;
+			}
+			while ( isDefined( level.sam_talking ) && level.sam_talking )
+			{
+				wait 0,05;
+			}
+			if ( isDefined( e_player ) && isplayer( e_player ) && e_player.zombie_vars[ "zombie_powerup_zombie_blood_on" ] )
+			{
+				a_player_hint[ e_player.characterindex ] = 1;
+				set_players_dontspeak( 1 );
+				level.sam_talking = 1;
+				str_vox = get_zombie_blood_hint_vox();
+				e_player playsoundtoplayer( str_vox, e_player );
+				n_duration = soundgetplaybacktime( str_vox );
+				wait ( n_duration / 1000 );
+				level.sam_talking = 0;
+				set_players_dontspeak( 0 );
+			}
+			continue;
+		}
+		else
+		{
+			if ( randomint( 100 ) < 20 )
+			{
+				wait randomfloatrange( 3, 7 );
+				if ( isDefined( e_player.vo_promises_playing ) && e_player.vo_promises_playing )
+				{
+					continue;
+				}
+				while ( isDefined( level.sam_talking ) && level.sam_talking )
+				{
+					wait 0,05;
+				}
+				if ( isDefined( e_player ) && isplayer( e_player ) && e_player.zombie_vars[ "zombie_powerup_zombie_blood_on" ] )
+				{
+					str_vox = get_zombie_blood_hint_generic_vox();
+					if ( isDefined( str_vox ) )
+					{
+						set_players_dontspeak( 1 );
+						level.sam_talking = 1;
+						e_player playsoundtoplayer( str_vox, e_player );
+						n_duration = soundgetplaybacktime( str_vox );
+						wait ( n_duration / 1000 );
+						level.sam_talking = 0;
+						set_players_dontspeak( 0 );
+					}
+				}
+			}
+		}
+	}
+}
+
+get_step_announce_vox()
+{
+	switch( level.n_ee_step )
+	{
+		case 1:
+			return "vox_sam_all_staff_upgrade_key_0";
+		case 2:
+			return "vox_sam_all_staff_ascend_darkness_0";
+		case 3:
+			return "vox_sam_all_staff_rain_fire_0";
+		case 4:
+			return "vox_sam_all_staff_unleash_hoard_0";
+		case 5:
+			return "vox_sam_all_staff_skewer_beast_0";
+		case 6:
+			return "vox_sam_all_staff_fist_iron_0";
+		case 7:
+			return "vox_sam_all_staff_raise_hell_0";
+		default:
+			return undefined;
+	}
+}
+
+get_zombie_blood_hint_vox()
+{
+	if ( flag( "all_zones_captured" ) )
+	{
+		return "vox_sam_upgrade_staff_clue_" + level.n_ee_step + "_0";
+	}
+	return "vox_sam_upgrade_staff_clue_" + level.n_ee_step + "_grbld_0";
+}
+
+get_zombie_blood_hint_generic_vox()
+{
+	if ( !isDefined( level.generic_clue_index ) )
+	{
+		level.generic_clue_index = 0;
+	}
+	vo_array[ 0 ] = "vox_sam_heard_by_all_1_0";
+	vo_array[ 1 ] = "vox_sam_heard_by_all_2_0";
+	vo_array[ 2 ] = "vox_sam_heard_by_all_3_0";
+	vo_array[ 3 ] = "vox_sam_slow_progress_0";
+	vo_array[ 4 ] = "vox_sam_slow_progress_2";
+	vo_array[ 5 ] = "vox_sam_slow_progress_3";
+	if ( level.generic_clue_index >= vo_array.size )
+	{
+		return undefined;
+	}
+	str_vo = vo_array[ level.generic_clue_index ];
+	level.generic_clue_index++;
+	return str_vo;
+}
+
+complete_sidequest()
+{
+	level.sndgameovermusicoverride = "game_over_ee";
+	a_players = getplayers();
+	_a293 = a_players;
+	_k293 = getFirstArrayKey( _a293 );
+	while ( isDefined( _k293 ) )
+	{
+		player = _a293[ _k293 ];
+		player freezecontrols( 1 );
+		player thread fadetoblackforxsec( 0, 5, 0,5, 0, "white" );
+		_k293 = getNextArrayKey( _a293, _k293 );
+	}
+	playsoundatposition( "zmb_squest_whiteout", ( 0, 0, -1 ) );
+	delay_thread( 0,5, ::remove_portal_beam );
+	level.custom_intermission = ::player_intermission_ee;
+	level setclientfield( "ee_ending", 1 );
+	wait_network_frame();
+	level notify( "end_game" );
+}
+
+remove_portal_beam()
+{
+	if ( isDefined( level.ee_ending_beam_fx ) )
+	{
+		level.ee_ending_beam_fx delete();
+	}
+}
+
+generic_stage_start()
+{
+	str_vox = get_step_announce_vox();
+	if ( isDefined( str_vox ) )
+	{
+		level thread ee_samantha_say( str_vox );
+	}
+}
+
+generic_stage_end()
+{
+	level.n_ee_step++;
+	if ( level.n_ee_step <= 6 )
+	{
+		flag_wait( "all_zones_captured" );
+	}
+	wait_network_frame();
+	wait_network_frame();
+}
+
+all_staffs_inserted_in_puzzle_room()
+{
+	n_staffs_inserted = 0;
+	_a350 = level.a_elemental_staffs;
+	_k350 = getFirstArrayKey( _a350 );
+	while ( isDefined( _k350 ) )
+	{
+		staff = _a350[ _k350 ];
+		if ( staff.upgrade.charger.is_inserted )
+		{
+			n_staffs_inserted++;
+		}
+		_k350 = getNextArrayKey( _a350, _k350 );
+	}
+	if ( n_staffs_inserted == 4 )
+	{
+		return 1;
+	}
+	else
+	{
+		return 0;
+	}
+}
+
+ee_samantha_say( str_vox )
+{
+	flag_waitopen( "story_vo_playing" );
+	flag_set( "story_vo_playing" );
+	set_players_dontspeak( 1 );
+	samanthasay( str_vox, get_players()[ 0 ] );
+	set_players_dontspeak( 0 );
+	flag_clear( "story_vo_playing" );
+}
+
+player_intermission_ee()
+{
+	self closemenu();
+	self closeingamemenu();
+	level endon( "stop_intermission" );
+	self endon( "disconnect" );
+	self endon( "death" );
+	self notify( "_zombie_game_over" );
+	self.score = self.score_total;
+	self.sessionstate = "intermission";
+	self.spectatorclient = -1;
+	self.killcamentity = -1;
+	self.archivetime = 0;
+	self.psoffsettime = 0;
+	self.friendlydamage = undefined;
+	points = getstructarray( "ee_cam", "targetname" );
+	if ( !isDefined( points ) || points.size == 0 )
+	{
+		points = getentarray( "info_intermission", "classname" );
+		if ( points.size < 1 )
+		{
+/#
+			println( "NO info_intermission POINTS IN MAP" );
+#/
+			return;
+		}
+	}
+	self.game_over_bg = newclienthudelem( self );
+	self.game_over_bg.horzalign = "fullscreen";
+	self.game_over_bg.vertalign = "fullscreen";
+	self.game_over_bg setshader( "black", 640, 480 );
+	self.game_over_bg.alpha = 1;
+	visionsetnaked( "cheat_bw", 0,05 );
+	org = undefined;
+	while ( 1 )
+	{
+		points = array_randomize( points );
+		i = 0;
+		while ( i < points.size )
+		{
+			point = points[ i ];
+			if ( !isDefined( org ) )
+			{
+				self spawn( point.origin, point.angles );
+			}
+			if ( isDefined( points[ i ].target ) )
+			{
+				if ( !isDefined( org ) )
+				{
+					org = spawn( "script_model", self.origin + vectorScale( ( 0, 0, -1 ), 60 ) );
+					org setmodel( "tag_origin" );
+				}
+				org.origin = points[ i ].origin;
+				org.angles = points[ i ].angles;
+				j = 0;
+				while ( j < get_players().size )
+				{
+					player = get_players()[ j ];
+					player camerasetposition( org );
+					player camerasetlookat();
+					player cameraactivate( 1 );
+					j++;
+				}
+				speed = 20;
+				if ( isDefined( points[ i ].speed ) )
+				{
+					speed = points[ i ].speed;
+				}
+				target_point = getstruct( points[ i ].target, "targetname" );
+				dist = distance( points[ i ].origin, target_point.origin );
+				time = dist / speed;
+				q_time = time * 0,25;
+				if ( q_time > 1 )
+				{
+					q_time = 1;
+				}
+				self.game_over_bg fadeovertime( q_time );
+				self.game_over_bg.alpha = 0;
+				org moveto( target_point.origin, time, q_time, q_time );
+				org rotateto( target_point.angles, time, q_time, q_time );
+				wait ( time - q_time );
+				self.game_over_bg fadeovertime( q_time );
+				self.game_over_bg.alpha = 1;
+				wait q_time;
+				i++;
+				continue;
+			}
+			else
+			{
+				self.game_over_bg fadeovertime( 1 );
+				self.game_over_bg.alpha = 0;
+				wait 5;
+				self.game_over_bg thread maps/mp/zombies/_zm::fade_up_over_time( 1 );
+			}
+			i++;
+		}
+	}
+}
+
+setup_ee_main_devgui()
+{
+/#
+	wait 5;
+	b_activated = 0;
+	while ( !b_activated )
+	{
+		_a507 = getplayers();
+		_k507 = getFirstArrayKey( _a507 );
+		while ( isDefined( _k507 ) )
+		{
+			player = _a507[ _k507 ];
+			if ( distance2d( player.origin, ( 2904, 5040, -336 ) ) < 100 && player usebuttonpressed() )
+			{
+				wait 2;
+				if ( player usebuttonpressed() )
+				{
+					b_activated = 1;
+				}
+			}
+			_k507 = getNextArrayKey( _a507, _k507 );
+		}
+		wait 0,05;
+	}
+	setdvar( "ee_main_progress", "off" );
+	setdvar( "ee_main_end_level", "off" );
+	setdvar( "ee_upgrade_beacon", "off" );
+	adddebugcommand( "devgui_cmd "Zombies/Tomb:1/EE Main:1/Next Step:1" "ee_main_progress on"\n" );
+	adddebugcommand( "devgui_cmd "Zombies/Tomb:1/EE Main:1/Upgrade Beacon:2" "ee_upgrade_beacon on"\n" );
+	adddebugcommand( "devgui_cmd "Zombies/Tomb:1/EE Main:1/End Level:3" "ee_main_end_level on"\n" );
+	level thread watch_devgui_ee_main();
+#/
+}
+
+watch_devgui_ee_main()
+{
+/#
+	while ( 1 )
+	{
+		if ( getDvar( "ee_main_progress" ) == "on" )
+		{
+			setdvar( "ee_main_progress", "off" );
+			level.ee_debug = 1;
+			flag_set( "samantha_intro_done" );
+			switch( level._cur_stage_name )
+			{
+				case "step_0":
+					flag_set( "ee_all_staffs_crafted" );
+					flag_set( "all_zones_captured" );
+					break;
+				break;
+				case "step_1":
+					flag_set( "ee_all_staffs_upgraded" );
+					level waittill( "little_girl_lost_step_1_over" );
+					break;
+				break;
+				case "step_2":
+					flag_set( "ee_all_staffs_placed" );
+					level waittill( "little_girl_lost_step_2_over" );
+					break;
+				break;
+				case "step_3":
+					flag_set( "ee_mech_zombie_hole_opened" );
+					m_floor = getent( "easter_mechzombie_spawn", "targetname" );
+					if ( isDefined( m_floor ) )
+					{
+						m_floor delete();
+					}
+					level waittill( "little_girl_lost_step_3_over" );
+					break;
+				break;
+				case "step_4":
+					flag_set( "ee_mech_zombie_fight_completed" );
+					flag_set( "ee_quadrotor_disabled" );
+					level waittill( "little_girl_lost_step_4_over" );
+					break;
+				break;
+				case "step_5":
+					flag_set( "ee_maxis_drone_retrieved" );
+					flag_clear( "ee_quadrotor_disabled" );
+					level waittill( "little_girl_lost_step_5_over" );
+					break;
+				break;
+				case "step_6":
+					flag_set( "ee_all_players_upgraded_punch" );
+					level waittill( "little_girl_lost_step_6_over" );
+					break;
+				break;
+				case "step_7":
+					flag_set( "ee_souls_absorbed" );
+					level waittill( "little_girl_lost_step_7_over" );
+					break;
+				break;
+				case "step_8":
+					flag_set( "ee_quadrotor_disabled" );
+					level waittill( "little_girl_lost_step_8_over" );
+					break;
+				break;
+				default:
+				}
+			}
+			if ( getDvar( "ee_main_end_level" ) == "on" )
+			{
+				setdvar( "ee_main_end_level", "off" );
+				level setclientfield( "ee_sam_portal", 2 );
+				complete_sidequest();
+			}
+			if ( getDvar( "ee_upgrade_beacon" ) == "on" )
+			{
+				setdvar( "ee_upgrade_beacon", "off" );
+				setdvar( "force_three_robot_round", "on" );
+				flag_set( "fire_link_enabled" );
+				array_thread( get_players(), ::maps/mp/zombies/_zm_weapons::weapon_give, "beacon_zm" );
+			}
+			wait 0,05;
+#/
+		}
+	}
+}

zm_tomb_patch/maps/mp/zm_tomb_ee_main_step_1.gsc

@@ -0,0 +1,29 @@
+#include maps/mp/zm_tomb_ee_main;
+#include maps/mp/zombies/_zm_sidequests;
+#include maps/mp/zombies/_zm_utility;
+#include maps/mp/_utility;
+#include common_scripts/utility;
+
+init()
+{
+	declare_sidequest_stage( "little_girl_lost", "step_1", ::init_stage, ::stage_logic, ::exit_stage );
+}
+
+init_stage()
+{
+	level._cur_stage_name = "step_1";
+}
+
+stage_logic()
+{
+/#
+	iprintln( level._cur_stage_name + " of little girl lost started" );
+#/
+	flag_wait( "ee_all_staffs_upgraded" );
+	wait_network_frame();
+	stage_completed( "little_girl_lost", level._cur_stage_name );
+}
+
+exit_stage( success )
+{
+}

zm_tomb_patch/maps/mp/zm_tomb_ee_main_step_2.gsc

@@ -0,0 +1,159 @@
+#include maps/mp/zm_tomb_craftables;
+#include maps/mp/zombies/_zm_unitrigger;
+#include maps/mp/zombies/_zm_powerup_zombie_blood;
+#include maps/mp/zm_tomb_ee_main;
+#include maps/mp/zombies/_zm_sidequests;
+#include maps/mp/zombies/_zm_utility;
+#include maps/mp/_utility;
+#include common_scripts/utility;
+
+init()
+{
+	declare_sidequest_stage( "little_girl_lost", "step_2", ::init_stage, ::stage_logic, ::exit_stage );
+	precachemodel( "p6_zm_tm_staff_holder" );
+}
+
+init_stage()
+{
+	level._cur_stage_name = "step_2";
+	a_structs = getstructarray( "robot_head_staff", "targetname" );
+	_a21 = a_structs;
+	_k21 = getFirstArrayKey( _a21 );
+	while ( isDefined( _k21 ) )
+	{
+		unitrigger_stub = _a21[ _k21 ];
+		level thread create_robot_head_trigger( unitrigger_stub );
+		wait_network_frame();
+		wait_network_frame();
+		wait_network_frame();
+		_k21 = getNextArrayKey( _a21, _k21 );
+	}
+}
+
+stage_logic()
+{
+/#
+	iprintln( level._cur_stage_name + " of little girl lost started" );
+#/
+	flag_wait( "ee_all_staffs_placed" );
+	playsoundatposition( "zmb_squest_robot_alarm_high", ( -14, -1, 871 ) );
+	wait 3;
+	wait_network_frame();
+	stage_completed( "little_girl_lost", level._cur_stage_name );
+}
+
+exit_stage( success )
+{
+	a_structs = getstructarray( "robot_head_staff", "targetname" );
+	_a52 = a_structs;
+	_k52 = getFirstArrayKey( _a52 );
+	while ( isDefined( _k52 ) )
+	{
+		struct = _a52[ _k52 ];
+		struct thread remove_plinth();
+		wait_network_frame();
+		wait_network_frame();
+		wait_network_frame();
+		_k52 = getNextArrayKey( _a52, _k52 );
+	}
+}
+
+remove_plinth()
+{
+	playfx( level._effect[ "teleport_1p" ], self.m_plinth.origin );
+	playsoundatposition( "zmb_footprintbox_disappear", self.m_plinth.origin );
+	wait 3;
+	if ( isDefined( self.m_plinth.m_staff ) )
+	{
+		self.m_plinth.m_staff unlink();
+		self.m_plinth.m_staff.origin = self.m_plinth.v_old_origin;
+		self.m_plinth.m_staff.angles = self.m_plinth.v_old_angles;
+		self.m_plinth.e_staff.ee_in_use = undefined;
+	}
+	self.m_sign delete();
+	self.m_plinth delete();
+	self.m_coll delete();
+	unregister_unitrigger( self );
+}
+
+create_robot_head_trigger( unitrigger_stub )
+{
+	playfx( level._effect[ "teleport_1p" ], unitrigger_stub.origin );
+	playsoundatposition( "zmb_footprintbox_disappear", unitrigger_stub.origin );
+	wait 3;
+	unitrigger_stub.radius = 50;
+	unitrigger_stub.height = 256;
+	unitrigger_stub.script_unitrigger_type = "unitrigger_radius_use";
+	unitrigger_stub.cursor_hint = "HINT_NOICON";
+	unitrigger_stub.require_look_at = 1;
+	m_coll = spawn( "script_model", unitrigger_stub.origin );
+	m_coll setmodel( "drone_collision" );
+	unitrigger_stub.m_coll = m_coll;
+	wait_network_frame();
+	m_plinth = spawn( "script_model", unitrigger_stub.origin );
+	m_plinth.angles = unitrigger_stub.angles;
+	m_plinth setmodel( "p6_zm_tm_staff_holder" );
+	unitrigger_stub.m_plinth = m_plinth;
+	wait_network_frame();
+	m_sign = spawn( "script_model", unitrigger_stub.origin );
+	m_sign setmodel( "p6_zm_tm_runes" );
+	m_sign linkto( unitrigger_stub.m_plinth, "tag_origin", ( 0, 15, 40 ) );
+	m_sign hidepart( "j_fire" );
+	m_sign hidepart( "j_ice" );
+	m_sign hidepart( "j_lightning" );
+	m_sign hidepart( "j_wind" );
+	switch( unitrigger_stub.script_noteworthy )
+	{
+		case "fire":
+			m_sign showpart( "j_fire" );
+			break;
+		case "water":
+			m_sign showpart( "j_ice" );
+			break;
+		case "lightning":
+			m_sign showpart( "j_lightning" );
+			break;
+		case "air":
+			m_sign showpart( "j_wind" );
+			break;
+	}
+	m_sign maps/mp/zombies/_zm_powerup_zombie_blood::make_zombie_blood_entity();
+	unitrigger_stub.m_sign = m_sign;
+	unitrigger_stub.origin += vectorScale( ( 0, 0, 1 ), 30 );
+	maps/mp/zombies/_zm_unitrigger::register_static_unitrigger( unitrigger_stub, ::robot_head_trigger_think );
+}
+
+robot_head_trigger_think()
+{
+	self endon( "kill_trigger" );
+	str_weap_staff = "staff_" + self.script_noteworthy + "_upgraded_zm";
+	e_upgraded_staff = maps/mp/zm_tomb_craftables::get_staff_info_from_weapon_name( str_weap_staff );
+	while ( 1 )
+	{
+		self waittill( "trigger", player );
+		if ( player hasweapon( str_weap_staff ) )
+		{
+			e_upgraded_staff.ee_in_use = 1;
+			player takeweapon( str_weap_staff );
+			maps/mp/zm_tomb_craftables::clear_player_staff( str_weap_staff );
+			level.n_ee_robot_staffs_planted++;
+			if ( level.n_ee_robot_staffs_planted == 4 )
+			{
+				flag_set( "ee_all_staffs_placed" );
+			}
+			e_upgraded_staff thread place_staff( self.stub.m_plinth );
+		}
+	}
+}
+
+place_staff( m_plinth )
+{
+	m_staff = getent( "craftable_" + self.weapname, "targetname" );
+	m_plinth.e_staff = self;
+	m_plinth.m_staff = m_staff;
+	m_plinth.v_old_angles = m_staff.angles;
+	m_plinth.v_old_origin = m_staff.origin;
+	m_staff linkto( m_plinth, "tag_origin", ( 0, 10, 30 ), ( 345, 90, 0 ) );
+	m_staff show();
+	m_plinth playsound( "zmb_squest_robot_place_staff" );
+}

zm_tomb_patch/maps/mp/zm_tomb_ee_main_step_3.gsc

@@ -0,0 +1,153 @@
+#include maps/mp/zombies/_zm_unitrigger;
+#include maps/mp/zm_tomb_ee_main;
+#include maps/mp/zombies/_zm_sidequests;
+#include maps/mp/zombies/_zm_utility;
+#include maps/mp/_utility;
+#include common_scripts/utility;
+
+init()
+{
+	declare_sidequest_stage( "little_girl_lost", "step_3", ::init_stage, ::stage_logic, ::exit_stage );
+}
+
+init_stage()
+{
+	level._cur_stage_name = "step_3";
+	level.check_valid_poi = ::mech_zombie_hole_valid;
+	create_buttons_and_triggers();
+}
+
+stage_logic()
+{
+/#
+	iprintln( level._cur_stage_name + " of little girl lost started" );
+#/
+	level thread watch_for_triple_attack();
+	flag_wait( "ee_mech_zombie_hole_opened" );
+	wait_network_frame();
+	stage_completed( "little_girl_lost", level._cur_stage_name );
+}
+
+exit_stage( success )
+{
+	level.check_valid_poi = undefined;
+	level notify( "fire_link_cooldown" );
+	flag_set( "fire_link_enabled" );
+	a_buttons = getentarray( "fire_link_button", "targetname" );
+	array_delete( a_buttons );
+	a_structs = getstructarray( "fire_link", "targetname" );
+	_a51 = a_structs;
+	_k51 = getFirstArrayKey( _a51 );
+	while ( isDefined( _k51 ) )
+	{
+		unitrigger_stub = _a51[ _k51 ];
+		unregister_unitrigger( unitrigger_stub );
+		_k51 = getNextArrayKey( _a51, _k51 );
+	}
+}
+
+create_buttons_and_triggers()
+{
+	a_structs = getstructarray( "fire_link", "targetname" );
+	_a60 = a_structs;
+	_k60 = getFirstArrayKey( _a60 );
+	while ( isDefined( _k60 ) )
+	{
+		unitrigger_stub = _a60[ _k60 ];
+		unitrigger_stub.radius = 36;
+		unitrigger_stub.height = 256;
+		unitrigger_stub.script_unitrigger_type = "unitrigger_radius_use";
+		unitrigger_stub.cursor_hint = "HINT_NOICON";
+		unitrigger_stub.require_look_at = 1;
+		m_model = spawn( "script_model", unitrigger_stub.origin );
+		m_model setmodel( "p_rus_alarm_button" );
+		m_model.angles = unitrigger_stub.angles;
+		m_model.targetname = "fire_link_button";
+		m_model thread ready_to_activate( unitrigger_stub );
+		wait_network_frame();
+		_k60 = getNextArrayKey( _a60, _k60 );
+	}
+}
+
+ready_to_activate( unitrigger_stub )
+{
+	self endon( "death" );
+	self playsoundwithnotify( "vox_maxi_robot_sync_0", "sync_done" );
+	self waittill( "sync_done" );
+	wait 0,5;
+	self playsoundwithnotify( "vox_maxi_robot_await_0", "ready_to_use" );
+	self waittill( "ready_to_use" );
+	maps/mp/zombies/_zm_unitrigger::register_static_unitrigger( unitrigger_stub, ::activate_fire_link );
+}
+
+watch_for_triple_attack()
+{
+	t_hole = getent( "fire_link_damage", "targetname" );
+	while ( !flag( "ee_mech_zombie_hole_opened" ) )
+	{
+		t_hole waittill( "damage", damage, attacker, direction, point, type, tagname, modelname, partname, weaponname );
+		if ( isDefined( weaponname ) && weaponname == "beacon_zm" && flag( "fire_link_enabled" ) )
+		{
+			playsoundatposition( "zmb_squest_robot_floor_collapse", t_hole.origin );
+			wait 3;
+			m_floor = getent( "easter_mechzombie_spawn", "targetname" );
+			m_floor delete();
+			flag_set( "ee_mech_zombie_hole_opened" );
+			t_hole delete();
+			return;
+		}
+	}
+}
+
+mech_zombie_hole_valid( valid )
+{
+	t_hole = getent( "fire_link_damage", "targetname" );
+	if ( self istouching( t_hole ) )
+	{
+		return 1;
+	}
+	return valid;
+}
+
+activate_fire_link()
+{
+	self endon( "kill_trigger" );
+	while ( 1 )
+	{
+		self waittill( "trigger", player );
+		self playsound( "zmb_squest_robot_button" );
+		if ( flag( "three_robot_round" ) )
+		{
+			level thread fire_link_cooldown( self );
+			self playsound( "zmb_squest_robot_button_activate" );
+			self playloopsound( "zmb_squest_robot_button_timer", 0,5 );
+			flag_waitopen( "fire_link_enabled" );
+			self stoploopsound( 0,5 );
+			self playsound( "zmb_squest_robot_button_deactivate" );
+			continue;
+		}
+		else
+		{
+			self playsound( "vox_maxi_robot_abort_0" );
+			self playsound( "zmb_squest_robot_button_deactivate" );
+			wait 3;
+		}
+	}
+}
+
+fire_link_cooldown( t_button )
+{
+	level notify( "fire_link_cooldown" );
+	level endon( "fire_link_cooldown" );
+	flag_set( "fire_link_enabled" );
+	if ( isDefined( t_button ) )
+	{
+		t_button playsound( "vox_maxi_robot_activated_0" );
+	}
+	wait 25;
+	if ( isDefined( t_button ) )
+	{
+		t_button playsound( "vox_maxi_robot_deactivated_0" );
+	}
+	flag_clear( "fire_link_enabled" );
+}

zm_tomb_patch/maps/mp/zm_tomb_ee_main_step_4.gsc

@@ -0,0 +1,249 @@
+#include maps/mp/animscripts/zm_shared;
+#include maps/mp/zombies/_zm_powerups;
+#include maps/mp/zombies/_zm_spawner;
+#include maps/mp/zombies/_zm_ai_mechz_ffotd;
+#include maps/mp/zm_tomb_vo;
+#include maps/mp/zombies/_zm_ai_mechz_booster;
+#include maps/mp/zombies/_zm_ai_mechz_ft;
+#include maps/mp/zombies/_zm_ai_mechz_claw;
+#include maps/mp/zombies/_zm_ai_mechz_dev;
+#include maps/mp/zombies/_zm_ai_mechz;
+#include maps/mp/zm_tomb_ee_main;
+#include maps/mp/zombies/_zm_sidequests;
+#include maps/mp/zombies/_zm_utility;
+#include maps/mp/_utility;
+#include common_scripts/utility;
+
+init()
+{
+	declare_sidequest_stage( "little_girl_lost", "step_4", ::init_stage, ::stage_logic, ::exit_stage );
+}
+
+init_stage()
+{
+	level._cur_stage_name = "step_4";
+	level.ee_mech_zombies_killed = 0;
+	level.ee_mech_zombies_alive = 0;
+	level.ee_mech_zombies_spawned = 0;
+	level.quadrotor_custom_behavior = ::mech_zombie_hole_search;
+}
+
+stage_logic()
+{
+/#
+	iprintln( level._cur_stage_name + " of little girl lost started" );
+#/
+	flag_wait( "ee_quadrotor_disabled" );
+	level thread sndee4music();
+	while ( !flag( "ee_mech_zombie_fight_completed" ) )
+	{
+		while ( level.ee_mech_zombies_spawned < 8 )
+		{
+			if ( level.ee_mech_zombies_alive < 4 )
+			{
+				ai = spawn_zombie( level.mechz_spawners[ 0 ] );
+				ai thread ee_mechz_spawn( level.ee_mech_zombies_spawned % 4 );
+				level.ee_mech_zombies_alive++;
+				level.ee_mech_zombies_spawned++;
+			}
+			wait randomfloatrange( 0,5, 1 );
+		}
+	}
+	flag_wait( "ee_mech_zombie_fight_completed" );
+	wait_network_frame();
+	stage_completed( "little_girl_lost", level._cur_stage_name );
+}
+
+exit_stage( success )
+{
+	level.quadrotor_custom_behavior = undefined;
+}
+
+mech_zombie_hole_search()
+{
+	s_goal = getstruct( "ee_mech_hole_goal_0", "targetname" );
+	if ( distance2dsquared( self.origin, s_goal.origin ) < 250000 )
+	{
+		self setvehgoalpos( s_goal.origin, 1, 2, 1 );
+		self waittill_any( "near_goal", "force_goal", "reached_end_node" );
+		s_goal = getstruct( "ee_mech_hole_goal_1", "targetname" );
+		self setvehgoalpos( s_goal.origin, 1, 0, 1 );
+		self waittill_any( "near_goal", "force_goal", "reached_end_node" );
+		wait 2;
+		s_goal = getstruct( "ee_mech_hole_goal_2", "targetname" );
+		self setvehgoalpos( s_goal.origin, 1, 0, 1 );
+		self waittill_any( "near_goal", "force_goal", "reached_end_node" );
+		playsoundatposition( "zmb_squest_maxis_folly", s_goal.origin );
+		maxissay( "vox_maxi_drone_upgraded_3", self );
+		flag_set( "ee_quadrotor_disabled" );
+		self dodamage( 200, self.origin );
+		self delete();
+		level.maxis_quadrotor = undefined;
+	}
+}
+
+ee_mechz_spawn( n_spawn_pos )
+{
+	self maps/mp/zombies/_zm_ai_mechz_ffotd::spawn_start();
+	self endon( "death" );
+	level endon( "intermission" );
+	self mechz_attach_objects();
+	self mechz_set_starting_health();
+	self mechz_setup_fx();
+	self mechz_setup_snd();
+	self.closest_player_override = ::maps/mp/zombies/_zm_ai_mechz::get_favorite_enemy;
+	self.animname = "mechz_zombie";
+	self.has_legs = 1;
+	self.no_gib = 1;
+	self.ignore_all_poi = 1;
+	self.is_mechz = 1;
+	self.ignore_enemy_count = 1;
+	self.no_damage_points = 1;
+	self.melee_anim_func = ::melee_anim_func;
+	self.meleedamage = 75;
+	recalc_zombie_array();
+	self setphysparams( 20, 0, 80 );
+	self.zombie_init_done = 1;
+	self notify( "zombie_init_done" );
+	self.allowpain = 0;
+	self animmode( "normal" );
+	self orientmode( "face enemy" );
+	self maps/mp/zombies/_zm_spawner::zombie_setup_attack_properties();
+	self.completed_emerging_into_playable_area = 1;
+	self notify( "completed_emerging_into_playable_area" );
+	self.no_powerups = 0;
+	self setfreecameralockonallowed( 0 );
+	self thread maps/mp/zombies/_zm_spawner::zombie_eye_glow();
+	level thread maps/mp/zombies/_zm_spawner::zombie_death_event( self );
+	self thread maps/mp/zombies/_zm_spawner::enemy_death_detection();
+	a_spawner_structs = getstructarray( "mech_hole_spawner", "targetname" );
+	spawn_pos = a_spawner_structs[ n_spawn_pos ];
+	if ( !isDefined( spawn_pos.angles ) )
+	{
+		spawn_pos.angles = ( 0, 0, 0 );
+	}
+	self thread mechz_death();
+	self thread mechz_death_ee();
+	self forceteleport( spawn_pos.origin, spawn_pos.angles );
+	self set_zombie_run_cycle( "walk" );
+	if ( isDefined( level.mechz_find_flesh_override_func ) )
+	{
+		level thread [[ level.mechz_find_flesh_override_func ]]();
+	}
+	else
+	{
+		self thread mechz_find_flesh();
+	}
+	self thread mechz_jump_think( spawn_pos );
+	self ee_mechz_do_jump( spawn_pos );
+	self maps/mp/zombies/_zm_ai_mechz_ffotd::spawn_end();
+}
+
+mechz_death_ee()
+{
+	self waittill( "death" );
+	level.ee_mech_zombies_killed++;
+	level.ee_mech_zombies_alive--;
+
+	if ( level.ee_mech_zombies_killed == 4 )
+	{
+		v_max_ammo_origin = self.origin;
+		level thread maps/mp/zombies/_zm_powerups::specific_powerup_drop( "full_ammo", v_max_ammo_origin );
+	}
+	if ( level.ee_mech_zombies_killed == 8 )
+	{
+		v_nuke_origin = self.origin;
+		level thread maps/mp/zombies/_zm_powerups::specific_powerup_drop( "nuke", v_nuke_origin );
+		flag_set( "ee_mech_zombie_fight_completed" );
+	}
+}
+
+ee_mechz_do_jump( s_spawn_pos )
+{
+	self endon( "death" );
+	self endon( "kill_jump" );
+/#
+	if ( getDvarInt( #"E7121222" ) > 0 )
+	{
+		println( "\nMZ: Doing Jump-Teleport\n" );
+#/
+	}
+/#
+	if ( getDvarInt( #"E7121222" ) > 1 )
+	{
+		println( "\nMZ: Jump setting not interruptable\n" );
+#/
+	}
+	self.not_interruptable = 1;
+	self setfreecameralockonallowed( 0 );
+	self animscripted( self.origin, self.angles, "zm_fly_out" );
+	self maps/mp/animscripts/zm_shared::donotetracks( "jump_anim" );
+	self ghost();
+	if ( isDefined( self.m_claw ) )
+	{
+		self.m_claw ghost();
+	}
+	old_fx = self.fx_field;
+	self thread maps/mp/zombies/_zm_spawner::zombie_eye_glow_stop();
+	self fx_cleanup();
+	self animscripted( self.origin, self.angles, "zm_fly_hover" );
+	wait level.mechz_jump_delay;
+	s_landing_point = getstruct( s_spawn_pos.target, "targetname" );
+	if ( !isDefined( s_landing_point.angles ) )
+	{
+		s_landing_point.angles = ( 0, 0, 0 );
+	}
+	self animscripted( s_landing_point.origin, s_landing_point.angles, "zm_fly_in" );
+	self show();
+	self.fx_field = old_fx;
+	self setclientfield( "mechz_fx", self.fx_field );
+	self thread maps/mp/zombies/_zm_spawner::zombie_eye_glow();
+	if ( isDefined( self.m_claw ) )
+	{
+		self.m_claw show();
+	}
+	self maps/mp/animscripts/zm_shared::donotetracks( "jump_anim" );
+	self.not_interruptable = 0;
+	self setfreecameralockonallowed( 1 );
+/#
+	if ( getDvarInt( #"E7121222" ) > 1 )
+	{
+		println( "\nMZ: Jump clearing not interruptable\n" );
+#/
+	}
+	mechz_jump_cleanup();
+	self.closest_jump_point = s_landing_point;
+}
+
+sndee4music()
+{
+	shouldplay = sndwait();
+	if ( !shouldplay )
+	{
+		return;
+	}
+	level.music_override = 1;
+	level setclientfield( "mus_zmb_egg_snapshot_loop", 1 );
+	ent = spawn( "script_origin", ( 0, 0, 0 ) );
+	ent playloopsound( "mus_mechz_fight_loop" );
+	flag_wait( "ee_mech_zombie_fight_completed" );
+	level setclientfield( "mus_zmb_egg_snapshot_loop", 0 );
+	level.music_override = 0;
+	wait 0,05;
+	ent delete();
+}
+
+sndwait()
+{
+	counter = 0;
+	while ( is_true( level.music_override ) )
+	{
+		wait 1;
+		counter++;
+		if ( counter >= 60 )
+		{
+			return 0;
+		}
+	}
+	return 1;
+}

zm_tomb_patch/maps/mp/zm_tomb_ee_main_step_5.gsc

@@ -0,0 +1,151 @@
+#include maps/mp/zombies/_zm_unitrigger;
+#include maps/mp/zombies/_zm_powerup_zombie_blood;
+#include maps/mp/zm_tomb_utility;
+#include maps/mp/zm_tomb_ee_main;
+#include maps/mp/zombies/_zm_sidequests;
+#include maps/mp/zombies/_zm_utility;
+#include maps/mp/_utility;
+#include common_scripts/utility;
+
+init()
+{
+	declare_sidequest_stage( "little_girl_lost", "step_5", ::init_stage, ::stage_logic, ::exit_stage );
+}
+
+init_stage()
+{
+	level._cur_stage_name = "step_5";
+	level.callbackvehicledamage = ::ee_plane_vehicledamage;
+	level.zombie_ai_limit--;
+
+}
+
+stage_logic()
+{
+/#
+	iprintln( level._cur_stage_name + " of little girl lost started" );
+#/
+	level thread spawn_zombie_blood_plane();
+	flag_wait( "ee_maxis_drone_retrieved" );
+	wait_network_frame();
+	stage_completed( "little_girl_lost", level._cur_stage_name );
+}
+
+exit_stage( success )
+{
+	level.zombie_ai_limit++;
+}
+
+spawn_zombie_blood_plane()
+{
+	s_biplane_pos = getstruct( "air_crystal_biplane_pos", "targetname" );
+	vh_biplane = spawnvehicle( "veh_t6_dlc_zm_biplane", "zombie_blood_biplane", "biplane_zm", ( 0, 0, 1 ), ( 0, 0, 1 ) );
+	vh_biplane ent_flag_init( "biplane_down", 0 );
+	vh_biplane maps/mp/zombies/_zm_powerup_zombie_blood::make_zombie_blood_entity();
+	vh_biplane playloopsound( "zmb_zombieblood_3rd_plane_loop", 1 );
+	vh_biplane.health = 10000;
+	vh_biplane setcandamage( 1 );
+	vh_biplane setforcenocull();
+	vh_biplane attachpath( getvehiclenode( "biplane_start", "targetname" ) );
+	vh_biplane startpath();
+	vh_biplane setclientfield( "ee_plane_fx", 1 );
+	vh_biplane ent_flag_wait( "biplane_down" );
+	vh_biplane playsound( "zmb_zombieblood_3rd_plane_explode" );
+	e_special_zombie = getentarray( "zombie_spawner_dig", "script_noteworthy" )[ 0 ];
+	ai_pilot = spawn_zombie( e_special_zombie, "zombie_blood_pilot" );
+	ai_pilot magic_bullet_shield();
+	ai_pilot.ignore_enemy_count = 1;
+	ai_pilot maps/mp/zombies/_zm_powerup_zombie_blood::make_zombie_blood_entity();
+	ai_pilot forceteleport( vh_biplane.origin, vh_biplane.angles );
+	ai_pilot.sndname = "capzomb";
+	ai_pilot.ignore_nuke = 1;
+	ai_pilot.b_zombie_blood_damage_only = 1;
+	playfx( level._effect[ "biplane_explode" ], vh_biplane.origin );
+	vh_biplane delete();
+	a_start_pos = getstructarray( "pilot_goal", "script_noteworthy" );
+	a_start_pos = get_array_of_closest( ai_pilot.origin, a_start_pos );
+	linker = spawn( "script_model", ai_pilot.origin );
+	linker setmodel( "tag_origin" );
+	ai_pilot linkto( linker );
+	linker moveto( a_start_pos[ 0 ].origin, 3 );
+	linker waittill( "movedone" );
+	linker delete();
+	ai_pilot stop_magic_bullet_shield();
+	level thread zombie_pilot_sound( ai_pilot );
+	ai_pilot.ignoreall = 1;
+	ai_pilot.zombie_move_speed = "sprint";
+	ai_pilot set_zombie_run_cycle( "sprint" );
+	ai_pilot thread pilot_loop_logic( a_start_pos[ 0 ] );
+	ai_pilot waittill( "death" );
+	level thread spawn_quadrotor_pickup( ai_pilot.origin, ai_pilot.angles );
+}
+
+zombie_pilot_sound( ai_pilot )
+{
+	sndent = spawn( "script_origin", ai_pilot.origin );
+	sndent playloopsound( "zmb_zombieblood_3rd_loop_other" );
+	while ( isDefined( ai_pilot ) && isalive( ai_pilot ) )
+	{
+		sndent.origin = ai_pilot.origin;
+		wait 0,3;
+	}
+	sndent delete();
+}
+
+pilot_loop_logic( s_start )
+{
+	self endon( "death" );
+	s_goal = s_start;
+	while ( isalive( self ) )
+	{
+		self setgoalpos( s_goal.origin );
+		self waittill( "goal" );
+		s_goal = getstruct( s_goal.target, "targetname" );
+	}
+}
+
+ee_plane_vehicledamage( e_inflictor, e_attacker, n_damage, n_dflags, str_means_of_death, str_weapon, v_point, v_dir, str_hit_loc, psoffsettime, b_damage_from_underneath, n_model_index, str_part_name )
+{
+	if ( self.vehicletype == "biplane_zm" && !self ent_flag( "biplane_down" ) )
+	{
+		if ( isplayer( e_attacker ) && e_attacker.zombie_vars[ "zombie_powerup_zombie_blood_on" ] )
+		{
+			self ent_flag_set( "biplane_down" );
+		}
+		return 0;
+	}
+	return n_damage;
+}
+
+spawn_quadrotor_pickup( v_origin, v_angles )
+{
+	m_quadrotor = spawn( "script_model", v_origin + vectorScale( ( 0, 0, 1 ), 30 ) );
+	m_quadrotor.angles = v_angles;
+	m_quadrotor setmodel( "veh_t6_dlc_zm_quadrotor" );
+	m_quadrotor.targetname = "quadrotor_pickup";
+	unitrigger_stub = spawnstruct();
+	unitrigger_stub.origin = v_origin;
+	unitrigger_stub.radius = 36;
+	unitrigger_stub.height = 256;
+	unitrigger_stub.script_unitrigger_type = "unitrigger_radius_use";
+	unitrigger_stub.hint_string = &"ZM_TOMB_DIHS";
+	unitrigger_stub.cursor_hint = "HINT_NOICON";
+	unitrigger_stub.require_look_at = 1;
+	maps/mp/zombies/_zm_unitrigger::register_static_unitrigger( unitrigger_stub, ::quadrotor_pickup_think );
+	flag_wait( "ee_maxis_drone_retrieved" );
+	unregister_unitrigger( unitrigger_stub );
+}
+
+quadrotor_pickup_think()
+{
+	self endon( "kill_trigger" );
+	m_quadrotor = getent( "quadrotor_pickup", "targetname" );
+	while ( 1 )
+	{
+		self waittill( "trigger", player );
+		player playsound( "vox_maxi_drone_upgraded_0" );
+		flag_clear( "ee_quadrotor_disabled" );
+		flag_set( "ee_maxis_drone_retrieved" );
+		m_quadrotor delete();
+	}
+}

zm_tomb_patch/maps/mp/zm_tomb_ee_main_step_6.gsc

@@ -0,0 +1,156 @@
+#include maps/mp/zombies/_zm_weap_one_inch_punch;
+#include maps/mp/zombies/_zm_spawner;
+#include maps/mp/gametypes_zm/_hud;
+#include maps/mp/gametypes_zm/_hud_util;
+#include maps/mp/zm_tomb_ee_main;
+#include maps/mp/zombies/_zm_sidequests;
+#include maps/mp/zombies/_zm_utility;
+#include maps/mp/_utility;
+#include common_scripts/utility;
+
+init()
+{
+	declare_sidequest_stage( "little_girl_lost", "step_6", ::init_stage, ::stage_logic, ::exit_stage );
+}
+
+init_stage()
+{
+	level._cur_stage_name = "step_6";
+	maps/mp/zombies/_zm_spawner::add_custom_zombie_spawn_logic( ::ruins_fist_glow_monitor );
+}
+
+stage_logic()
+{
+/#
+	iprintln( level._cur_stage_name + " of little girl lost started" );
+#/
+	level setclientfield( "sndChamberMusic", 1 );
+	flag_wait( "ee_all_players_upgraded_punch" );
+	level setclientfield( "sndChamberMusic", 0 );
+	wait_network_frame();
+	stage_completed( "little_girl_lost", level._cur_stage_name );
+}
+
+exit_stage( success )
+{
+}
+
+ruins_fist_glow_monitor()
+{
+	if ( flag( "ee_all_players_upgraded_punch" ) )
+	{
+		return;
+	}
+	while ( isDefined( self.zone_name ) && self.zone_name == "ug_bottom_zone" )
+	{
+		wait 0,1;
+		self setclientfield( "ee_zombie_fist_fx", 1 );
+		self.has_soul = 1;
+		while ( isalive( self ) )
+		{
+			self waittill( "damage", amount, inflictor, direction, point, type, tagname, modelname, partname, weaponname, idflags );
+			if ( !isDefined( inflictor.n_ee_punch_souls ) )
+			{
+				inflictor.n_ee_punch_souls = 0;
+				inflictor.b_punch_upgraded = 0;
+			}
+			if ( self.has_soul && inflictor.n_ee_punch_souls < 20 && isDefined( weaponname ) && weaponname == "one_inch_punch_zm" && is_true( self.completed_emerging_into_playable_area ) )
+			{
+				self setclientfield( "ee_zombie_fist_fx", 0 );
+				self.has_soul = 0;
+				playsoundatposition( "zmb_squest_punchtime_punched", self.origin );
+				inflictor.n_ee_punch_souls++;
+				if ( inflictor.n_ee_punch_souls == 20 )
+				{
+					level thread spawn_punch_upgrade_tablet( self.origin, inflictor );
+				}
+			}
+		}
+	}
+}
+
+spawn_punch_upgrade_tablet( v_origin, e_player )
+{
+	m_tablet = spawn( "script_model", v_origin + vectorScale( ( 0, 0, 1 ), 50 ) );
+	m_tablet setmodel( "p6_zm_tm_tablet" );
+	m_fx = spawn( "script_model", m_tablet.origin );
+	m_fx setmodel( "tag_origin" );
+	m_fx setinvisibletoall();
+	m_fx setvisibletoplayer( e_player );
+	m_tablet linkto( m_fx );
+	playfxontag( level._effect[ "special_glow" ], m_fx, "tag_origin" );
+	m_fx thread rotate_punch_upgrade_tablet();
+	m_tablet playloopsound( "zmb_squest_punchtime_tablet_loop", 0,5 );
+	m_tablet setinvisibletoall();
+	m_tablet setvisibletoplayer( e_player );
+	while ( isDefined( e_player ) && !e_player istouching( m_tablet ) )
+	{
+		wait 0,05;
+	}
+	m_tablet delete();
+	m_fx delete();
+	e_player playsound( "zmb_squest_punchtime_tablet_pickup" );
+	if ( isDefined( e_player ) )
+	{
+		e_player thread fadetoblackforxsec( 0, 0,3, 0,5, 0,5, "white" );
+		a_zombies = getaispeciesarray( level.zombie_team, "all" );
+		_a137 = a_zombies;
+		_k137 = getFirstArrayKey( _a137 );
+		while ( isDefined( _k137 ) )
+		{
+			zombie = _a137[ _k137 ];
+			if ( distance2dsquared( e_player.origin, zombie.origin ) < 65536 && !is_true( zombie.is_mechz ) && is_true( zombie.has_legs ) && is_true( zombie.completed_emerging_into_playable_area ) )
+			{
+				zombie.v_punched_from = e_player.origin;
+				zombie animcustom( ::maps/mp/zombies/_zm_weap_one_inch_punch::knockdown_zombie_animate );
+			}
+			_k137 = getNextArrayKey( _a137, _k137 );
+		}
+		wait 1;
+		e_player.b_punch_upgraded = 1;
+		if ( e_player hasweapon( "staff_fire_upgraded_zm" ) )
+		{
+			e_player.str_punch_element = "fire";
+		}
+		else if ( e_player hasweapon( "staff_air_upgraded_zm" ) )
+		{
+			e_player.str_punch_element = "air";
+		}
+		else if ( e_player hasweapon( "staff_lightning_upgraded_zm" ) )
+		{
+			e_player.str_punch_element = "lightning";
+		}
+		else if ( e_player hasweapon( "staff_water_upgraded_zm" ) )
+		{
+			e_player.str_punch_element = "ice";
+		}
+		else
+		{
+			e_player.str_punch_element = "upgraded";
+		}
+		e_player thread maps/mp/zombies/_zm_weap_one_inch_punch::one_inch_punch_melee_attack();
+		a_players = getplayers();
+		_a178 = a_players;
+		_k178 = getFirstArrayKey( _a178 );
+		while ( isDefined( _k178 ) )
+		{
+			player = _a178[ _k178 ];
+			if ( !isDefined( player.b_punch_upgraded ) || !player.b_punch_upgraded )
+			{
+				return;
+			}
+			_k178 = getNextArrayKey( _a178, _k178 );
+		}
+		flag_set( "ee_all_players_upgraded_punch" );
+	}
+}
+
+rotate_punch_upgrade_tablet()
+{
+	self endon( "death" );
+	while ( 1 )
+	{
+		self rotateyaw( 360, 5 );
+		self waittill( "rotatedone" );
+	}
+}

zm_tomb_patch/maps/mp/zm_tomb_ee_main_step_7.gsc

@@ -0,0 +1,93 @@
+#include maps/mp/zm_tomb_chamber;
+#include maps/mp/zm_tomb_vo;
+#include maps/mp/zm_tomb_ee_main;
+#include maps/mp/zombies/_zm_sidequests;
+#include maps/mp/zombies/_zm_utility;
+#include maps/mp/_utility;
+#include common_scripts/utility;
+
+init()
+{
+	declare_sidequest_stage( "little_girl_lost", "step_7", ::init_stage, ::stage_logic, ::exit_stage );
+}
+
+init_stage()
+{
+	level._cur_stage_name = "step_7";
+	level.n_ee_portal_souls = 0;
+}
+
+stage_logic()
+{
+/#
+	iprintln( level._cur_stage_name + " of little girl lost started" );
+#/
+	level thread monitor_puzzle_portal();
+	level setclientfield( "sndChamberMusic", 2 );
+	flag_wait( "ee_souls_absorbed" );
+	level setclientfield( "sndChamberMusic", 3 );
+	wait_network_frame();
+	stage_completed( "little_girl_lost", level._cur_stage_name );
+}
+
+exit_stage( success )
+{
+}
+
+ee_zombie_killed_override( einflictor, attacker, idamage, smeansofdeath, sweapon, vdir, shitloc, psoffsettime )
+{
+	if ( isDefined( attacker ) && isplayer( attacker ) && maps/mp/zm_tomb_chamber::is_point_in_chamber( self.origin ) )
+	{
+		level.n_ee_portal_souls++;
+		if ( level.n_ee_portal_souls == 1 )
+		{
+			level thread ee_samantha_say( "vox_sam_generic_encourage_3" );
+		}
+		else if ( level.n_ee_portal_souls == floor( 33,33333 ) )
+		{
+			level thread ee_samantha_say( "vox_sam_generic_encourage_4" );
+		}
+		else if ( level.n_ee_portal_souls == floor( 66,66666 ) )
+		{
+			level thread ee_samantha_say( "vox_sam_generic_encourage_5" );
+		}
+		else
+		{
+			if ( level.n_ee_portal_souls == 100 )
+			{
+				level thread ee_samantha_say( "vox_sam_generic_encourage_0" );
+				flag_set( "ee_souls_absorbed" );
+			}
+		}
+		self setclientfield( "ee_zombie_soul_portal", 1 );
+	}
+}
+
+monitor_puzzle_portal()
+{
+/#
+	if ( is_true( level.ee_debug ) )
+	{
+		flag_set( "ee_sam_portal_active" );
+		level setclientfield( "ee_sam_portal", 1 );
+		return;
+#/
+	}
+	while ( !flag( "ee_souls_absorbed" ) )
+	{
+		if ( all_staffs_inserted_in_puzzle_room() && !flag( "ee_sam_portal_active" ) )
+		{
+			flag_set( "ee_sam_portal_active" );
+			level setclientfield( "ee_sam_portal", 1 );
+		}
+		else
+		{
+			if ( !all_staffs_inserted_in_puzzle_room() && flag( "ee_sam_portal_active" ) )
+			{
+				flag_clear( "ee_sam_portal_active" );
+				level setclientfield( "ee_sam_portal", 0 );
+			}
+		}
+		wait 0,5;
+	}
+}

zm_tomb_patch/maps/mp/zm_tomb_ee_main_step_8.gsc

@@ -0,0 +1,105 @@
+#include maps/mp/zm_tomb_chamber;
+#include maps/mp/gametypes_zm/_hud;
+#include maps/mp/gametypes_zm/_hud_util;
+#include maps/mp/zm_tomb_vo;
+#include maps/mp/zm_tomb_utility;
+#include maps/mp/zm_tomb_ee_main;
+#include maps/mp/zombies/_zm_sidequests;
+#include maps/mp/zombies/_zm_utility;
+#include maps/mp/_utility;
+#include common_scripts/utility;
+
+init()
+{
+	declare_sidequest_stage( "little_girl_lost", "step_8", ::init_stage, ::stage_logic, ::exit_stage );
+}
+
+init_stage()
+{
+	level._cur_stage_name = "step_8";
+	level.quadrotor_custom_behavior = ::move_into_portal;
+}
+
+stage_logic()
+{
+/#
+	iprintln( level._cur_stage_name + " of little girl lost started" );
+#/
+	level notify( "tomb_sidequest_complete" );
+	_a34 = get_players();
+	_k34 = getFirstArrayKey( _a34 );
+	while ( isDefined( _k34 ) )
+	{
+		player = _a34[ _k34 ];
+		if ( player is_player_in_chamber() )
+		{
+			player thread fadetoblackforxsec( 0, 1, 0,5, 0,5, "white" );
+		}
+		_k34 = getNextArrayKey( _a34, _k34 );
+	}
+	wait 0,5;
+	level setclientfield( "ee_sam_portal", 2 );
+	level notify( "stop_random_chamber_walls" );
+	a_walls = getentarray( "chamber_wall", "script_noteworthy" );
+	_a51 = a_walls;
+	_k51 = getFirstArrayKey( _a51 );
+	while ( isDefined( _k51 ) )
+	{
+		e_wall = _a51[ _k51 ];
+		e_wall thread maps/mp/zm_tomb_chamber::move_wall_up();
+		e_wall hide();
+		_k51 = getNextArrayKey( _a51, _k51 );
+	}
+	flag_wait( "ee_quadrotor_disabled" );
+	wait 1;
+	level thread ee_samantha_say( "vox_sam_all_staff_freedom_0" );
+	s_pos = getstruct( "player_portal_final", "targetname" );
+	t_portal = tomb_spawn_trigger_radius( s_pos.origin, 100, 1 );
+	t_portal.require_look_at = 1;
+	t_portal.hint_string = &"ZM_TOMB_TELE";
+	t_portal thread waittill_player_activates();
+	level.ee_ending_beam_fx = spawn( "script_model", s_pos.origin + vectorScale( ( 0, 1, 0 ), 300 ) );
+	level.ee_ending_beam_fx.angles = vectorScale( ( 0, 1, 0 ), 90 );
+	level.ee_ending_beam_fx setmodel( "tag_origin" );
+	playfxontag( level._effect[ "ee_beam" ], level.ee_ending_beam_fx, "tag_origin" );
+	level.ee_ending_beam_fx playsound( "zmb_squest_crystal_sky_pillar_start" );
+	level.ee_ending_beam_fx playloopsound( "zmb_squest_crystal_sky_pillar_loop", 3 );
+	flag_wait( "ee_samantha_released" );
+	t_portal tomb_unitrigger_delete();
+	wait_network_frame();
+	stage_completed( "little_girl_lost", level._cur_stage_name );
+}
+
+exit_stage( success )
+{
+}
+
+waittill_player_activates()
+{
+	while ( 1 )
+	{
+		self waittill( "trigger", player );
+		flag_set( "ee_samantha_released" );
+	}
+}
+
+move_into_portal()
+{
+	s_goal = getstruct( "maxis_portal_path", "targetname" );
+	if ( distance2dsquared( self.origin, s_goal.origin ) < 250000 )
+	{
+		self setvehgoalpos( s_goal.origin, 1, 2, 1 );
+		self waittill_any( "near_goal", "force_goal", "reached_end_node" );
+		maxissay( "vox_maxi_drone_upgraded_1", self );
+		wait 1;
+		level thread maxissay( "vox_maxi_drone_upgraded_2", self );
+		s_goal = getstruct( s_goal.target, "targetname" );
+		self setvehgoalpos( s_goal.origin, 1, 0, 1 );
+		self waittill_any( "near_goal", "force_goal", "reached_end_node" );
+		self playsound( "zmb_qrdrone_leave" );
+		flag_set( "ee_quadrotor_disabled" );
+		self dodamage( 200, self.origin );
+		self delete();
+		level.maxis_quadrotor = undefined;
+	}
+}

zm_tomb_patch/maps/mp/zm_tomb_ee_side.gsc

@@ -0,0 +1,668 @@
+#include maps/mp/zm_tomb_amb;
+#include maps/mp/zombies/_zm_unitrigger;
+#include maps/mp/zombies/_zm_spawner;
+#include maps/mp/zombies/_zm_zonemgr;
+#include maps/mp/zombies/_zm_score;
+#include maps/mp/zombies/_zm_powerups;
+#include maps/mp/zombies/_zm_audio;
+#include maps/mp/zm_tomb_ee_lights;
+#include maps/mp/zm_tomb_vo;
+#include maps/mp/zm_tomb_utility;
+#include maps/mp/zombies/_zm_weapons;
+#include maps/mp/zombies/_zm_sidequests;
+#include maps/mp/zombies/_zm_utility;
+#include maps/mp/_utility;
+#include common_scripts/utility;
+
+init()
+{
+	precacheshader( "zm_tm_wth_dog" );
+	precachemodel( "p6_zm_tm_tablet" );
+	precachemodel( "p6_zm_tm_tablet_muddy" );
+	precachemodel( "p6_zm_tm_radio_01" );
+	precachemodel( "p6_zm_tm_radio_01_panel2_blood" );
+	registerclientfield( "world", "wagon_1_fire", 14000, 1, "int" );
+	registerclientfield( "world", "wagon_2_fire", 14000, 1, "int" );
+	registerclientfield( "world", "wagon_3_fire", 14000, 1, "int" );
+	registerclientfield( "actor", "ee_zombie_tablet_fx", 14000, 1, "int" );
+	registerclientfield( "toplayer", "ee_beacon_reward", 14000, 1, "int" );
+	onplayerconnect_callback( ::onplayerconnect_ee_jump_scare );
+	onplayerconnect_callback( ::onplayerconnect_ee_oneinchpunch );
+	sq_one_inch_punch();
+	a_triggers = getentarray( "audio_bump_trigger", "targetname" );
+	_a43 = a_triggers;
+	_k43 = getFirstArrayKey( _a43 );
+	while ( isDefined( _k43 ) )
+	{
+		trigger = _a43[ _k43 ];
+		if ( isDefined( trigger.script_sound ) && trigger.script_sound == "zmb_perks_bump_bottle" )
+		{
+			trigger thread check_for_change();
+		}
+		_k43 = getNextArrayKey( _a43, _k43 );
+	}
+	level thread wagon_fire_challenge();
+	level thread wall_hole_poster();
+	level thread quadrotor_medallions();
+	level thread maps/mp/zm_tomb_ee_lights::main();
+	level thread radio_ee_song();
+}
+
+quadrotor_medallions()
+{
+	flag_init( "ee_medallions_collected" );
+	level thread quadrotor_medallions_vo();
+	level.n_ee_medallions = 4;
+	flag_wait( "ee_medallions_collected" );
+	level thread maps/mp/zombies/_zm_audio::sndmusicstingerevent( "side_sting_4" );
+	s_mg_spawn = getstruct( "mgspawn", "targetname" );
+	v_spawnpt = s_mg_spawn.origin;
+	v_spawnang = s_mg_spawn.angles;
+	player = get_players()[ 0 ];
+	options = player maps/mp/zombies/_zm_weapons::get_pack_a_punch_weapon_options( "mg08_upgraded_zm" );
+	m_mg_model = spawn_weapon_model( "mg08_upgraded_zm", undefined, v_spawnpt, v_spawnang, options );
+	playfxontag( level._effect[ "special_glow" ], m_mg_model, "tag_origin" );
+	t_weapon_swap = tomb_spawn_trigger_radius( v_spawnpt, 100, 1 );
+	t_weapon_swap.require_look_at = 1;
+	t_weapon_swap.hint_string = &"ZM_TOMB_X2PU";
+	t_weapon_swap.hint_parm1 = getweapondisplayname( "mg08_upgraded_zm" );
+	b_retrieved = 0;
+	while ( !b_retrieved )
+	{
+		t_weapon_swap waittill( "trigger", e_player );
+		b_retrieved = swap_mg( e_player );
+	}
+	t_weapon_swap tomb_unitrigger_delete();
+	m_mg_model delete();
+}
+
+quadrotor_medallions_vo()
+{
+	n_vo_counter = 0;
+	while ( n_vo_counter < 4 )
+	{
+		level waittill( "quadrotor_medallion_found", v_quadrotor );
+		v_quadrotor playsound( "zmb_medallion_pickup" );
+		if ( isDefined( v_quadrotor ) )
+		{
+			maxissay( "vox_maxi_drone_pickups_" + n_vo_counter, v_quadrotor );
+			n_vo_counter++;
+			if ( isDefined( v_quadrotor ) && n_vo_counter == 4 )
+			{
+				maxissay( "vox_maxi_drone_pickups_" + n_vo_counter, v_quadrotor );
+			}
+		}
+	}
+}
+
+swap_mg( e_player )
+{
+	str_current_weapon = e_player getcurrentweapon();
+	str_reward_weapon = maps/mp/zombies/_zm_weapons::get_upgrade_weapon( "mg08_zm" );
+	if ( is_player_valid( e_player ) && !e_player.is_drinking && !is_placeable_mine( str_current_weapon ) && !is_equipment( str_current_weapon ) && level.revive_tool != str_current_weapon && str_current_weapon != "none" && !e_player hacker_active() )
+	{
+		if ( e_player hasweapon( str_reward_weapon ) )
+		{
+			e_player givemaxammo( str_reward_weapon );
+		}
+		else
+		{
+			a_weapons = e_player getweaponslistprimaries();
+			if ( isDefined( a_weapons ) && a_weapons.size >= get_player_weapon_limit( e_player ) )
+			{
+				e_player takeweapon( str_current_weapon );
+			}
+			e_player giveweapon( str_reward_weapon, 0, e_player maps/mp/zombies/_zm_weapons::get_pack_a_punch_weapon_options( str_reward_weapon ) );
+			e_player givestartammo( str_reward_weapon );
+			e_player switchtoweapon( str_reward_weapon );
+		}
+		return 1;
+	}
+	else
+	{
+		return 0;
+	}
+}
+
+wall_hole_poster()
+{
+	m_poster = getent( "hole_poster", "targetname" );
+	m_poster setcandamage( 1 );
+	m_poster.health = 1000;
+	m_poster.maxhealth = m_poster.health;
+	while ( 1 )
+	{
+		m_poster waittill( "damage" );
+		if ( m_poster.health <= 0 )
+		{
+			m_poster physicslaunch( m_poster.origin, ( 0, 0, 0 ) );
+		}
+	}
+}
+
+wagon_fire_challenge()
+{
+	flag_init( "ee_wagon_timer_start" );
+	flag_init( "ee_wagon_challenge_complete" );
+	s_powerup = getstruct( "wagon_powerup", "targetname" );
+	flag_wait( "start_zombie_round_logic" );
+	wagon_fire_start();
+	while ( 1 )
+	{
+		flag_wait( "ee_wagon_timer_start" );
+		flag_wait_or_timeout( "ee_wagon_challenge_complete", 30 );
+		if ( !flag( "ee_wagon_challenge_complete" ) )
+		{
+			wagon_fire_start();
+			flag_clear( "ee_wagon_timer_start" );
+			continue;
+		}
+		else
+		{
+			maps/mp/zombies/_zm_powerups::specific_powerup_drop( "zombie_blood", s_powerup.origin );
+			level waittill( "end_of_round" );
+			waittillframeend;
+			while ( level.weather_rain > 0 )
+			{
+				level waittill( "end_of_round" );
+				waittillframeend;
+			}
+			wagon_fire_start();
+			flag_clear( "ee_wagon_timer_start" );
+			flag_clear( "ee_wagon_challenge_complete" );
+		}
+	}
+}
+
+wagon_fire_start()
+{
+	level.n_wagon_fires_out = 0;
+	a_triggers = getentarray( "wagon_damage_trigger", "targetname" );
+	_a249 = a_triggers;
+	_k249 = getFirstArrayKey( _a249 );
+	while ( isDefined( _k249 ) )
+	{
+		trigger = _a249[ _k249 ];
+		trigger thread wagon_fire_trigger_watch();
+		level setclientfield( trigger.script_noteworthy, 1 );
+		_k249 = getNextArrayKey( _a249, _k249 );
+	}
+}
+
+wagon_fire_trigger_watch()
+{
+	self notify( "watch_reset" );
+	self endon( "watch_reset" );
+	while ( 1 )
+	{
+		self waittill( "damage", damage, attacker, direction, point, type, tagname, modelname, partname, weaponname );
+		if ( isplayer( attacker ) || attacker getcurrentweapon() == "staff_water_zm" && attacker getcurrentweapon() == "staff_water_upgraded_zm" )
+		{
+			level.n_wagon_fires_out++;
+			if ( !flag( "ee_wagon_timer_start" ) )
+			{
+				flag_set( "ee_wagon_timer_start" );
+			}
+			level setclientfield( self.script_noteworthy, 0 );
+			if ( level.n_wagon_fires_out == 3 )
+			{
+				flag_set( "ee_wagon_challenge_complete" );
+				level thread maps/mp/zombies/_zm_audio::sndmusicstingerevent( "side_sting_1" );
+			}
+			return;
+		}
+	}
+}
+
+check_for_change()
+{
+	while ( 1 )
+	{
+		self waittill( "trigger", e_player );
+		if ( e_player getstance() == "prone" )
+		{
+			e_player maps/mp/zombies/_zm_score::add_to_player_score( 25 );
+			play_sound_at_pos( "purchase", e_player.origin );
+			return;
+		}
+		else
+		{
+			wait 0,1;
+		}
+	}
+}
+
+onplayerconnect_ee_jump_scare()
+{
+	self endon( "disconnect" );
+	if ( !isDefined( level.jump_scare_lookat_point ) )
+	{
+		level.jump_scare_lookat_point = getstruct( "struct_gg_look", "targetname" );
+	}
+	if ( !isDefined( level.b_saw_jump_scare ) )
+	{
+		level.b_saw_jump_scare = 0;
+	}
+	while ( !level.b_saw_jump_scare )
+	{
+		n_time = 0;
+		while ( self adsbuttonpressed() && n_time < 25 )
+		{
+			n_time++;
+			wait 0,05;
+		}
+		if ( n_time >= 25 && self adsbuttonpressed() && self maps/mp/zombies/_zm_zonemgr::is_player_in_zone( "zone_nml_18" ) && sq_is_weapon_sniper( self getcurrentweapon() ) && is_player_looking_at( level.jump_scare_lookat_point.origin, 0,998, 0, undefined ) )
+		{
+			self playsoundtoplayer( "zmb_easteregg_scarydog", self );
+			self.wth_elem = newclienthudelem( self );
+			self.wth_elem.horzalign = "fullscreen";
+			self.wth_elem.vertalign = "fullscreen";
+			self.wth_elem.sort = 1000;
+			self.wth_elem.foreground = 0;
+			self.wth_elem setshader( "zm_tm_wth_dog", 640, 480 );
+			self.wth_elem.hidewheninmenu = 1;
+			j_time = 0;
+			while ( self adsbuttonpressed() && j_time < 5 )
+			{
+				j_time++;
+				wait 0,05;
+			}
+			self.wth_elem destroy();
+			level.b_saw_jump_scare = 1;
+		}
+		wait 0,05;
+	}
+}
+
+sq_is_weapon_sniper( str_weapon )
+{
+	a_snipers = array( "dsr50" );
+	_a380 = a_snipers;
+	_k380 = getFirstArrayKey( _a380 );
+	while ( isDefined( _k380 ) )
+	{
+		str_sniper = _a380[ _k380 ];
+		if ( issubstr( str_weapon, str_sniper ) && !issubstr( str_weapon, "+is" ) )
+		{
+			return 1;
+		}
+		_k380 = getNextArrayKey( _a380, _k380 );
+	}
+	return 0;
+}
+
+onplayerconnect_ee_oneinchpunch()
+{
+	self.sq_one_inch_punch_stage = 0;
+	self.sq_one_inch_punch_kills = 0;
+}
+
+sq_one_inch_punch_disconnect_watch()
+{
+	self waittill( "disconnect" );
+	if ( isDefined( self.sq_one_inch_punch_tablet ) )
+	{
+		self.sq_one_inch_punch_tablet delete();
+	}
+	spawn_tablet_model( self.sq_one_inch_punch_tablet_num, "bunker", "muddy" );
+	level.n_tablets_remaining++;
+}
+
+sq_one_inch_punch_death_watch()
+{
+	self endon( "disconnect" );
+	self waittill( "bled_out" );
+	if ( self.sq_one_inch_punch_stage < 6 )
+	{
+		self.sq_one_inch_punch_stage = 0;
+		self.sq_one_inch_punch_kills = 0;
+		if ( isDefined( self.sq_one_inch_punch_tablet ) )
+		{
+			self.sq_one_inch_punch_tablet delete();
+		}
+		spawn_tablet_model( self.sq_one_inch_punch_tablet_num, "bunker", "muddy" );
+		level.n_tablets_remaining++;
+	}
+}
+
+sq_one_inch_punch()
+{
+	maps/mp/zombies/_zm_spawner::add_custom_zombie_spawn_logic( ::bunker_volume_death_check );
+	maps/mp/zombies/_zm_spawner::add_custom_zombie_spawn_logic( ::church_volume_death_check );
+	level.n_tablets_remaining = 4;
+	a_tablets = [];
+	n_player_id = 0;
+	while ( n_player_id < level.n_tablets_remaining )
+	{
+		a_tablets[ n_player_id ] = spawn_tablet_model( n_player_id + 1, "bunker", "muddy" );
+		n_player_id++;
+	}
+	t_bunker = getent( "trigger_oneinchpunch_bunker_table", "targetname" );
+	t_bunker thread bunker_trigger_thread();
+	t_bunker setcursorhint( "HINT_NOICON" );
+	t_birdbath = getent( "trigger_oneinchpunch_church_birdbath", "targetname" );
+	t_birdbath thread birdbath_trigger_thread();
+	t_birdbath setcursorhint( "HINT_NOICON" );
+}
+
+bunker_trigger_thread()
+{
+	while ( 1 )
+	{
+		self waittill( "trigger", player );
+		if ( player.sq_one_inch_punch_stage == 0 )
+		{
+			player.sq_one_inch_punch_stage++;
+			player.sq_one_inch_punch_tablet_num = level.n_tablets_remaining;
+			player setclientfieldtoplayer( "player_tablet_state", 2 );
+			player playsound( "zmb_squest_oiptablet_pickup" );
+			player thread sq_one_inch_punch_disconnect_watch();
+			player thread sq_one_inch_punch_death_watch();
+			m_tablet = getent( "tablet_bunker_" + level.n_tablets_remaining, "targetname" );
+			m_tablet delete();
+			level.n_tablets_remaining--;
+
+/#
+			iprintln( "1 - take the tablet to the church" );
+#/
+		}
+		if ( player.sq_one_inch_punch_stage == 4 )
+		{
+			player.sq_one_inch_punch_tablet = spawn_tablet_model( player.sq_one_inch_punch_tablet_num, "bunker", "clean" );
+			player.sq_one_inch_punch_stage++;
+			player setclientfieldtoplayer( "player_tablet_state", 0 );
+			player playsound( "zmb_squest_oiptablet_place_table" );
+/#
+			iprintln( "5 - charge the tablet in the bunker" );
+#/
+			continue;
+		}
+		else
+		{
+			if ( player.sq_one_inch_punch_stage == 6 && isDefined( player.beacon_ready ) && player.beacon_ready )
+			{
+				player setclientfieldtoplayer( "ee_beacon_reward", 0 );
+				player maps/mp/zombies/_zm_weapons::weapon_give( "beacon_zm" );
+				player thread richtofenrespondvoplay( "get_beacon" );
+				if ( isDefined( level.zombie_include_weapons[ "beacon_zm" ] ) && !level.zombie_include_weapons[ "beacon_zm" ] )
+				{
+					level.zombie_include_weapons[ "beacon_zm" ] = 1;
+					level.zombie_weapons[ "beacon_zm" ].is_in_box = 1;
+				}
+				player playsound( "zmb_squest_oiptablet_get_reward" );
+				player.sq_one_inch_punch_stage++;
+/#
+				iprintln( "7 - tablet is activated; bestow rewards" );
+#/
+			}
+		}
+	}
+}
+
+birdbath_trigger_thread()
+{
+	while ( 1 )
+	{
+		self waittill( "trigger", player );
+		if ( player.sq_one_inch_punch_stage == 1 )
+		{
+			if ( isDefined( player.sq_one_inch_punch_reclean ) )
+			{
+				player.sq_one_inch_punch_reclean = undefined;
+				player.sq_one_inch_punch_stage++;
+				player.sq_one_inch_punch_tablet = spawn_tablet_model( player.sq_one_inch_punch_tablet_num, "church", "clean" );
+				level thread tablet_cleanliness_chastise( player, 1 );
+			}
+			else
+			{
+				player.sq_one_inch_punch_tablet = spawn_tablet_model( player.sq_one_inch_punch_tablet_num, "church", "muddy" );
+			}
+			player playsound( "zmb_squest_oiptablet_bathe" );
+			player setclientfieldtoplayer( "player_tablet_state", 0 );
+			player.sq_one_inch_punch_stage++;
+/#
+			iprintln( "2 - charge the tablet in the church" );
+#/
+		}
+		if ( player.sq_one_inch_punch_stage == 3 )
+		{
+			player setclientfieldtoplayer( "player_tablet_state", 1 );
+			player.sq_one_inch_punch_stage++;
+			if ( isDefined( player.sq_one_inch_punch_tablet ) )
+			{
+				player.sq_one_inch_punch_tablet delete();
+			}
+			player playsound( "zmb_squest_oiptablet_pickup_clean" );
+			player thread tablet_cleanliness_thread();
+/#
+			iprintln( "4 - take the tablet to the tank bunker" );
+#/
+		}
+	}
+}
+
+tablet_cleanliness_thread()
+{
+	self endon( "death_or_disconnect" );
+	while ( self.sq_one_inch_punch_stage == 4 )
+	{
+		if ( self.is_player_slowed )
+		{
+			self setclientfieldtoplayer( "player_tablet_state", 2 );
+			self playsoundtoplayer( "zmb_squest_oiptablet_dirtied", self );
+			self.sq_one_inch_punch_stage = 1;
+			self.sq_one_inch_punch_reclean = 1;
+			level thread tablet_cleanliness_chastise( self );
+/#
+			iprintln( "1 - take the tablet to the church" );
+#/
+		}
+		wait 1;
+	}
+}
+
+tablet_cleanliness_chastise( e_player, b_cleaned )
+{
+	if ( !isDefined( b_cleaned ) )
+	{
+		b_cleaned = 0;
+	}
+	if ( isDefined( e_player ) && isDefined( level.sam_talking ) || level.sam_talking && flag( "story_vo_playing" ) )
+	{
+		return;
+	}
+	flag_set( "story_vo_playing" );
+	e_player set_player_dontspeak( 1 );
+	level.sam_talking = 1;
+	str_line = "vox_sam_generic_chastise_7";
+	if ( b_cleaned )
+	{
+		str_line = "vox_sam_generic_chastise_8";
+	}
+	if ( isDefined( e_player ) )
+	{
+		e_player playsoundtoplayer( str_line, e_player );
+	}
+	n_duration = soundgetplaybacktime( str_line );
+	wait ( n_duration / 1000 );
+	level.sam_talking = 0;
+	flag_clear( "story_vo_playing" );
+	if ( isDefined( e_player ) )
+	{
+		e_player set_player_dontspeak( 0 );
+	}
+}
+
+bunker_volume_death_check()
+{
+	self waittill( "death" );
+	if ( !isDefined( self ) )
+	{
+		return;
+	}
+	volume_name = "oneinchpunch_bunker_volume";
+	volume = getent( volume_name, "targetname" );
+/#
+	assert( isDefined( volume ), volume_name + " does not exist" );
+#/
+	attacker = self.attacker;
+	if ( isDefined( attacker ) && isplayer( attacker ) )
+	{
+		if ( attacker.sq_one_inch_punch_stage == 5 || self.damagemod == "MOD_MELEE" && self.damageweapon == "tomb_shield_zm" )
+		{
+			if ( self istouching( volume ) )
+			{
+				self setclientfield( "ee_zombie_tablet_fx", 1 );
+				attacker.sq_one_inch_punch_kills++;
+/#
+				iprintln( "kill count: " + attacker.sq_one_inch_punch_kills );
+#/
+				if ( attacker.sq_one_inch_punch_kills >= 20 )
+				{
+					attacker thread bunker_spawn_reward();
+					attacker.sq_one_inch_punch_stage++;
+					level thread maps/mp/zombies/_zm_audio::sndmusicstingerevent( "side_sting_3" );
+/#
+					iprintln( "6 - activate the tablet in the bunker" );
+#/
+				}
+			}
+		}
+	}
+}
+
+bunker_spawn_reward()
+{
+	self endon( "disconnect" );
+	wait 2;
+	self setclientfieldtoplayer( "ee_beacon_reward", 1 );
+	wait 2;
+	self.beacon_ready = 1;
+}
+
+church_volume_death_check()
+{
+	self waittill( "death" );
+	if ( !isDefined( self ) )
+	{
+		return;
+	}
+	volume_name = "oneinchpunch_church_volume";
+	volume = getent( volume_name, "targetname" );
+/#
+	assert( isDefined( volume ), volume_name + " does not exist" );
+#/
+	attacker = self.attacker;
+	if ( isDefined( attacker ) && isplayer( attacker ) )
+	{
+		if ( attacker.sq_one_inch_punch_stage == 2 || self.damagemod == "MOD_MELEE" && self.damageweapon == "tomb_shield_zm" )
+		{
+			if ( self istouching( volume ) )
+			{
+				self setclientfield( "ee_zombie_tablet_fx", 1 );
+				attacker.sq_one_inch_punch_kills++;
+/#
+				iprintln( "kill count: " + attacker.sq_one_inch_punch_kills );
+#/
+				if ( attacker.sq_one_inch_punch_kills >= 20 )
+				{
+					attacker.sq_one_inch_punch_stage++;
+					attacker.sq_one_inch_punch_kills = 0;
+					attacker.sq_one_inch_punch_tablet delete();
+					attacker.sq_one_inch_punch_tablet = spawn_tablet_model( attacker.sq_one_inch_punch_tablet_num, "church", "clean" );
+					level thread maps/mp/zombies/_zm_audio::sndmusicstingerevent( "side_sting_6" );
+/#
+					iprintln( "3 - tablet is charged, pick up the tablet from the birdbath" );
+#/
+				}
+			}
+		}
+	}
+}
+
+spawn_tablet_model( n_player_id, str_location, str_state )
+{
+	s_tablet_spawn = getstruct( "oneinchpunch_" + str_location + "_tablet_" + n_player_id, "targetname" );
+	v_spawnpt = s_tablet_spawn.origin;
+	v_spawnang = s_tablet_spawn.angles;
+	m_tablet = spawn( "script_model", v_spawnpt );
+	m_tablet.angles = v_spawnang;
+	if ( str_state == "clean" )
+	{
+		m_tablet setmodel( "p6_zm_tm_tablet" );
+		if ( str_location == "church" )
+		{
+			m_tablet playsound( "zmb_squest_oiptablet_charged" );
+		}
+	}
+	else
+	{
+		m_tablet setmodel( "p6_zm_tm_tablet_muddy" );
+	}
+	m_tablet.targetname = "tablet_" + str_location + "_" + n_player_id;
+	return m_tablet;
+}
+
+radio_ee_song()
+{
+	level.found_ee_radio_count = 0;
+	wait 3;
+	a_structs = getstructarray( "ee_radio_pos", "targetname" );
+	_a775 = a_structs;
+	_k775 = getFirstArrayKey( _a775 );
+	while ( isDefined( _k775 ) )
+	{
+		unitrigger_stub = _a775[ _k775 ];
+		unitrigger_stub.radius = 50;
+		unitrigger_stub.height = 128;
+		unitrigger_stub.script_unitrigger_type = "unitrigger_radius_use";
+		unitrigger_stub.cursor_hint = "HINT_NOICON";
+		unitrigger_stub.require_look_at = 1;
+		m_radio = spawn( "script_model", unitrigger_stub.origin );
+		m_radio.angles = unitrigger_stub.angles;
+		m_radio setmodel( "p6_zm_tm_radio_01" );
+		m_radio attach( "p6_zm_tm_radio_01_panel2_blood", "tag_j_cover" );
+		maps/mp/zombies/_zm_unitrigger::register_static_unitrigger( unitrigger_stub, ::radio_ee_think );
+/#
+		unitrigger_stub thread radio_ee_debug();
+#/
+		wait_network_frame();
+		_k775 = getNextArrayKey( _a775, _k775 );
+	}
+}
+
+radio_ee_debug()
+{
+/#
+	self endon( "stop_display" );
+	while ( 1 )
+	{
+		print3d( self.origin, "R", vectorScale( ( 0, 0, 0 ), 255 ), 1 );
+		wait 0,05;
+#/
+	}
+}
+
+radio_ee_think()
+{
+	self endon( "kill_trigger" );
+	while ( 1 )
+	{
+		self waittill( "trigger", player );
+		if ( is_player_valid( player ) && isDefined( level.music_override ) && !level.music_override )
+		{
+			level.found_ee_radio_count++;
+			if ( level.found_ee_radio_count == 3 )
+			{
+				level.music_override = 1;
+				ent = spawn( "script_origin", ( 0, 0, 0 ) );
+				level thread maps/mp/zm_tomb_amb::sndmuseggplay( ent, "mus_zmb_secret_song_a7x", 352 );
+			}
+/#
+			self.stub notify( "stop_display" );
+#/
+			maps/mp/zombies/_zm_unitrigger::unregister_unitrigger( self.stub );
+			return;
+		}
+	}
+}

zm_tomb_patch/maps/mp/zm_tomb_ffotd.gsc

@@ -0,0 +1,240 @@
+#include codescripts/struct;
+#include maps/mp/zombies/_zm_zonemgr;
+#include maps/mp/zombies/_zm_utility;
+#include common_scripts/utility;
+#include maps/mp/_utility;
+
+main_start()
+{
+	level thread spawned_collision_ffotd();
+	level thread spawn_kill_brushes();
+	level thread respawn_struct_fix();
+	onplayerconnect_callback( ::one_inch_punch_take_think );
+}
+
+main_end()
+{
+	level thread player_spawn_fix();
+	level thread update_charger_position();
+	level thread traversal_blocker_disabler();
+}
+
+update_charger_position()
+{
+	_a26 = level.a_elemental_staffs;
+	_k26 = getFirstArrayKey( _a26 );
+	while ( isDefined( _k26 ) )
+	{
+		e_staff = _a26[ _k26 ];
+		e_staff moveto( e_staff.charger.origin, 0,05 );
+		_k26 = getNextArrayKey( _a26, _k26 );
+	}
+	_a31 = level.a_elemental_staffs_upgraded;
+	_k31 = getFirstArrayKey( _a31 );
+	while ( isDefined( _k31 ) )
+	{
+		e_staff = _a31[ _k31 ];
+		e_staff moveto( e_staff.charger.origin, 0,05 );
+		_k31 = getNextArrayKey( _a31, _k31 );
+	}
+}
+
+spawned_collision_ffotd()
+{
+	precachemodel( "collision_ai_64x64x10" );
+	precachemodel( "collision_wall_256x256x10_standard" );
+	precachemodel( "collision_wall_512x512x10_standard" );
+	precachemodel( "collision_geo_256x256x10_standard" );
+	precachemodel( "collision_geo_512x512x10_standard" );
+	precachemodel( "collision_geo_ramp_standard" );
+	precachemodel( "collision_player_512x512x512" );
+	precachemodel( "collision_geo_32x32x128_standard" );
+	precachemodel( "collision_geo_64x64x128_standard" );
+	precachemodel( "collision_geo_64x64x256_standard" );
+	precachemodel( "collision_player_wall_256x256x10" );
+	precachemodel( "collision_player_wall_512x512x10" );
+	precachemodel( "collision_player_wall_32x32x10" );
+	precachemodel( "collision_geo_64x64x10_standard" );
+	precachemodel( "p6_zm_tm_barbedwire_tube" );
+	precachemodel( "p6_zm_tm_rubble_rebar_group" );
+	flag_wait( "start_zombie_round_logic" );
+	m_disconnector = spawn( "script_model", ( -568, -956, 160 ), 1 );
+	m_disconnector setmodel( "collision_ai_64x64x10" );
+	m_disconnector.angles = vectorScale( ( 0, 0, -1 ), 35 );
+	m_disconnector disconnectpaths();
+	m_disconnector ghost();
+	if ( isDefined( level.optimise_for_splitscreen ) && !level.optimise_for_splitscreen )
+	{
+		collision1a = spawn( "script_model", ( 1128, -2664,25, 122 ) );
+		collision1a setmodel( "collision_player_wall_256x256x10" );
+		collision1a.angles = vectorScale( ( 0, 0, -1 ), 285 );
+		collision1a ghost();
+		collision1b = spawn( "script_model", ( 909,5, -2856,5, -6 ) );
+		collision1b setmodel( "collision_player_wall_512x512x10" );
+		collision1b.angles = vectorScale( ( 0, 0, -1 ), 195 );
+		collision1b ghost();
+		collision1c = spawn( "script_model", ( 415, -2989, -6 ) );
+		collision1c setmodel( "collision_player_wall_512x512x10" );
+		collision1c.angles = vectorScale( ( 0, 0, -1 ), 195 );
+		collision1c ghost();
+		collision2a = spawn( "script_model", ( -6760, -6536, 280 ) );
+		collision2a setmodel( "collision_geo_512x512x10_standard" );
+		collision2a.angles = ( 0, 0, -1 );
+		collision2a ghost();
+		collision2b = spawn( "script_model", ( -6224, -6536, 280 ) );
+		collision2b setmodel( "collision_geo_512x512x10_standard" );
+		collision2b.angles = ( 0, 0, -1 );
+		collision2b ghost();
+		collision2c = spawn( "script_model", ( -5704, -6536, 280 ) );
+		collision2c setmodel( "collision_geo_512x512x10_standard" );
+		collision2c.angles = ( 0, 0, -1 );
+		collision2c ghost();
+		collision3a = spawn( "script_model", ( 1088, 4216, -192 ) );
+		collision3a setmodel( "collision_geo_256x256x10_standard" );
+		collision3a.angles = ( 0, 0, -1 );
+		collision3a ghost();
+		collision4a = spawn( "script_model", ( 545,36, -2382,3, 404 ) );
+		collision4a setmodel( "collision_wall_256x256x10_standard" );
+		collision4a.angles = ( 0, 293,8, 180 );
+		collision4a ghost();
+		collision4b = spawn( "script_model", ( 579,36, -2367,3, 264 ) );
+		collision4b setmodel( "collision_geo_ramp_standard" );
+		collision4b.angles = ( 0, 293,8, 180 );
+		collision4b ghost();
+		collision5a = spawn( "script_model", ( 67,87, -3193,25, 504 ) );
+		collision5a setmodel( "collision_player_512x512x512" );
+		collision5a.angles = vectorScale( ( 0, 0, -1 ), 14,1 );
+		collision5a ghost();
+		collision5b = spawn( "script_model", ( 292,5, -2865,5, 286 ) );
+		collision5b setmodel( "collision_geo_32x32x128_standard" );
+		collision5b.angles = ( 270, 22,4, 0 );
+		collision5b ghost();
+		collision5c = spawn( "script_model", ( 292,5, -2865,5, 266 ) );
+		collision5c setmodel( "collision_geo_32x32x128_standard" );
+		collision5c.angles = ( 270, 22,4, 0 );
+		collision5c ghost();
+		collision5d = spawn( "script_model", ( 339, -3024,5, 280 ) );
+		collision5d setmodel( "collision_geo_64x64x128_standard" );
+		collision5d.angles = ( 270, 18,2, 0 );
+		collision5d ghost();
+		model5a = spawn( "script_model", ( 248,15, -2917,26, 351,01 ) );
+		model5a setmodel( "p6_zm_tm_barbedwire_tube" );
+		model5a.angles = ( 6,00001, 188, 90 );
+		collision6a = spawn( "script_model", ( -227,25, 4010,25, -96 ) );
+		collision6a setmodel( "collision_player_wall_256x256x10" );
+		collision6a.angles = vectorScale( ( 0, 0, -1 ), 265,299 );
+		collision6a ghost();
+		model6a = spawn( "script_model", ( -231,124, 4093,08, -230,685 ) );
+		model6a setmodel( "p6_zm_tm_rubble_rebar_group" );
+		model6a.angles = ( 25,883, 2,13901, 0,55601 );
+		collision7a = spawn( "script_model", ( 599, -2478, 184 ) );
+		collision7a setmodel( "collision_geo_64x64x128_standard" );
+		collision7a.angles = ( 270, 14,7, 0 );
+		collision7a ghost();
+		collision8a = spawn( "script_model", ( -3190, -555, -111 ) );
+		collision8a setmodel( "collision_player_wall_512x512x10" );
+		collision8a.angles = vectorScale( ( 0, 0, -1 ), 1,8 );
+		collision8a ghost();
+		collision11a = spawn( "script_model", ( 812,812, -64,1434, 384 ) );
+		collision11a setmodel( "collision_player_wall_256x256x10" );
+		collision11a.angles = vectorScale( ( 0, 0, -1 ), 9,99998 );
+		collision11a ghost();
+		collision12a = spawn( "script_model", ( 180, 4128, 40 ) );
+		collision12a setmodel( "collision_player_wall_512x512x10" );
+		collision12a.angles = vectorScale( ( 0, 0, -1 ), 270 );
+		collision12a ghost();
+		collision13a = spawn( "script_model", ( 2088, 588, 240 ) );
+		collision13a setmodel( "collision_player_wall_512x512x10" );
+		collision13a.angles = ( 0, 0, -1 );
+		collision13a ghost();
+		collision14a = spawn( "script_model", ( -787, 375, 380 ) );
+		collision14a setmodel( "collision_player_wall_256x256x10" );
+		collision14a.angles = ( 0, 0, -1 );
+		collision14a ghost();
+		collision14b = spawn( "script_model", ( -899, 375, 236 ) );
+		collision14b setmodel( "collision_player_wall_32x32x10" );
+		collision14b.angles = ( 0, 0, -1 );
+		collision14b ghost();
+		collision15a = spawn( "script_model", ( 1704, 2969,34, -187,83 ) );
+		collision15a setmodel( "collision_geo_64x64x10_standard" );
+		collision15a.angles = vectorScale( ( 0, 0, -1 ), 47,4 );
+		collision15a ghost();
+	}
+}
+
+spawn_kill_brushes()
+{
+	t_killbrush_1 = spawn( "trigger_box", ( 1643, 2168, 96 ), 0, 256, 1200, 512 );
+	t_killbrush_1.script_noteworthy = "kill_brush";
+	t_killbrush_2 = spawn( "trigger_box", ( -1277, 892, 184 ), 0, 148, 88, 128 );
+	t_killbrush_2.script_noteworthy = "kill_brush";
+}
+
+one_inch_punch_take_think()
+{
+	self endon( "disconnect" );
+	while ( 1 )
+	{
+		self waittill( "bled_out" );
+		self.one_inch_punch_flag_has_been_init = 0;
+		if ( self ent_flag_exist( "melee_punch_cooldown" ) )
+		{
+		}
+	}
+}
+
+player_spawn_fix()
+{
+	s_zone_nml_18 = level.zones[ "zone_nml_18" ];
+	s_zone_nml_19 = level.zones[ "zone_nml_19" ];
+	add_adjacent_zone( "zone_nml_18", "zone_nml_19", "activate_zone_ruins" );
+}
+
+respawn_struct_fix()
+{
+	spawn1 = createstruct();
+	spawn1.model = undefined;
+	spawn1.origin = ( 2400, 120, 160 );
+	spawn1.targetname = "nml_11_spawn_points";
+	spawn1.radius = 32;
+	spawn1.script_int = 1;
+	spawn2 = createstruct();
+	spawn2.model = undefined;
+	spawn2.origin = ( 2392, 360, 160 );
+	spawn2.targetname = "nml_11_spawn_points";
+	spawn2.radius = 32;
+	spawn2.script_int = 1;
+	spawn3 = createstruct();
+	spawn3.model = undefined;
+	spawn3.origin = ( 2616, 152, 160 );
+	spawn3.targetname = "nml_11_spawn_points";
+	spawn3.radius = 32;
+	spawn3.script_int = 1;
+}
+
+traversal_blocker_disabler()
+{
+	level endon( "activate_zone_nml" );
+	pos1 = ( -1509, 3912, -168 );
+	pos2 = ( 672, 3720, -179 );
+	b_too_close = 0;
+	while ( level.round_number < 10 && !b_too_close )
+	{
+		a_players = getplayers();
+		_a310 = a_players;
+		_k310 = getFirstArrayKey( _a310 );
+		while ( isDefined( _k310 ) )
+		{
+			player = _a310[ _k310 ];
+			if ( distancesquared( player.origin, pos1 ) < 4096 || distancesquared( player.origin, pos2 ) < 4096 )
+			{
+				b_too_close = 1;
+			}
+			_k310 = getNextArrayKey( _a310, _k310 );
+		}
+		wait 1;
+	}
+	m_traversal_blocker = getent( "traversal_blocker", "targetname" );
+	m_traversal_blocker.origin += vectorScale( ( 0, 0, -1 ), 10000 );
+	m_traversal_blocker connectpaths();
+}

zm_tomb_patch/maps/mp/zm_tomb_fx.gsc

@@ -0,0 +1,147 @@
+#include maps/mp/_utility;
+
+#using_animtree( "fxanim_props" );
+#using_animtree( "fxanim_props_dlc4" );
+
+main()
+{
+	precache_createfx_fx();
+	precache_scripted_fx();
+	precache_fxanim_props();
+	precache_fxanim_props_dlc4();
+	maps/mp/createfx/zm_tomb_fx::main();
+}
+
+precache_scripted_fx()
+{
+	level._effect[ "eye_glow_blue" ] = loadfx( "maps/zombie/fx_zombie_eye_single_blue" );
+	level._effect[ "switch_sparks" ] = loadfx( "env/electrical/fx_elec_wire_spark_burst" );
+	level._effect[ "zapper_light_ready" ] = loadfx( "maps/zombie_tomb/fx_tomb_capture_light_green" );
+	level._effect[ "zapper_light_notready" ] = loadfx( "maps/zombie_tomb/fx_tomb_capture_light_red" );
+	level._effect[ "m14_zm_fx" ] = loadfx( "maps/zombie/fx_zmb_wall_buy_rifle" );
+	level._effect[ "fx_tomb_ee_vortex" ] = loadfx( "maps/zombie_tomb/fx_tomb_ee_vortex" );
+	level._effect[ "poltergeist" ] = loadfx( "misc/fx_zombie_couch_effect" );
+	level._effect[ "door_steam" ] = loadfx( "maps/zombie_tomb/fx_tomb_dieselmagic_doors_steam" );
+	level._effect[ "zomb_gib" ] = loadfx( "maps/zombie/fx_zmb_tranzit_lava_torso_explo" );
+	level._effect[ "spawn_cloud" ] = loadfx( "maps/zombie/fx_zmb_race_zombie_spawn_cloud" );
+	level._effect[ "robot_foot_stomp" ] = loadfx( "maps/zombie_tomb/fx_tomb_robot_dust" );
+	level._effect[ "eject_warning" ] = loadfx( "maps/zombie_tomb/fx_tomb_robot_eject_warning" );
+	level._effect[ "eject_steam" ] = loadfx( "maps/zombie_tomb/fx_tomb_robot_eject_steam" );
+	level._effect[ "giant_robot_footstep_warning_light" ] = loadfx( "maps/zombie_tomb/fx_tomb_foot_warning_light_red" );
+	level._effect[ "air_glow" ] = loadfx( "maps/zombie_tomb/fx_tomb_elem_reveal_air_glow" );
+	level._effect[ "elec_glow" ] = loadfx( "maps/zombie_tomb/fx_tomb_elem_reveal_elec_glow" );
+	level._effect[ "fire_glow" ] = loadfx( "maps/zombie_tomb/fx_tomb_elem_reveal_fire_glow" );
+	level._effect[ "ice_glow" ] = loadfx( "maps/zombie_tomb/fx_tomb_elem_reveal_ice_glow" );
+	level._effect[ "digging" ] = loadfx( "maps/zombie_tomb/fx_tomb_shovel_dig" );
+	level._effect[ "mechz_death" ] = loadfx( "maps/zombie_tomb/fx_tomb_mech_death" );
+	level._effect[ "mechz_sparks" ] = loadfx( "maps/zombie_tomb/fx_tomb_mech_dmg_sparks" );
+	level._effect[ "mechz_steam" ] = loadfx( "maps/zombie_tomb/fx_tomb_mech_dmg_steam" );
+	level._effect[ "mechz_claw" ] = loadfx( "maps/zombie_tomb/fx_tomb_mech_wpn_claw" );
+	level._effect[ "mechz_claw_arm" ] = loadfx( "maps/zombie_tomb/fx_tomb_mech_wpn_source" );
+	level._effect[ "staff_charge" ] = loadfx( "weapon/zmb_staff/fx_zmb_staff_charge" );
+	level._effect[ "staff_soul" ] = loadfx( "weapon/zmb_staff/fx_zmb_staff_charge_souls" );
+	level._effect[ "fire_muzzle" ] = loadfx( "weapon/zmb_staff/fx_zmb_staff_fire_muz_flash_1p" );
+	level._effect[ "crypt_gem_beam" ] = loadfx( "weapon/zmb_staff/fx_zmb_staff_charge_souls" );
+	level._effect[ "crypt_wall_drop" ] = loadfx( "maps/zombie_tomb/fx_tomb_chamber_walls_impact" );
+	level._effect[ "air_puzzle_smoke" ] = loadfx( "maps/zombie_tomb/fx_tomb_puzzle_air_smoke" );
+	level._effect[ "elec_piano_glow" ] = loadfx( "maps/zombie_tomb/fx_tomb_puzzle_elec_sparks" );
+	level._effect[ "fire_ash_explosion" ] = loadfx( "maps/zombie_tomb/fx_tomb_puzzle_fire_exp_ash" );
+	level._effect[ "fire_sacrifice_flame" ] = loadfx( "maps/zombie_tomb/fx_tomb_puzzle_fire_sacrifice" );
+	level._effect[ "fire_torch" ] = loadfx( "maps/zombie_tomb/fx_tomb_puzzle_fire_torch" );
+	level._effect[ "ice_explode" ] = loadfx( "maps/zombie_tomb/fx_tomb_puzzle_ice_pipe_burst" );
+	level._effect[ "puzzle_orb_trail" ] = loadfx( "maps/zombie_tomb/fx_tomb_puzzle_plinth_trail" );
+	level._effect[ "teleport_1p" ] = loadfx( "maps/zombie_tomb/fx_tomb_teleport_1p" );
+	level._effect[ "teleport_3p" ] = loadfx( "maps/zombie_tomb/fx_tomb_teleport_3p" );
+	level._effect[ "teleport_air" ] = loadfx( "maps/zombie_tomb/fx_tomb_portal_air" );
+	level._effect[ "teleport_elec" ] = loadfx( "maps/zombie_tomb/fx_tomb_portal_elec" );
+	level._effect[ "teleport_fire" ] = loadfx( "maps/zombie_tomb/fx_tomb_portal_fire" );
+	level._effect[ "teleport_ice" ] = loadfx( "maps/zombie_tomb/fx_tomb_portal_ice" );
+	level._effect[ "tesla_elec_kill" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_afterlife_zmb_tport" );
+	level._effect[ "capture_progression" ] = loadfx( "maps/zombie_tomb/fx_tomb_capture_progression" );
+	level._effect[ "capture_complete" ] = loadfx( "maps/zombie_tomb/fx_tomb_capture_complete" );
+	level._effect[ "capture_exhaust" ] = loadfx( "maps/zombie_tomb/fx_tomb_capture_exhaust_back" );
+	level._effect[ "screecher_hole" ] = loadfx( "maps/zombie_tomb/fx_tomb_screecher_vortex" );
+	level._effect[ "zone_capture_zombie_spawn" ] = loadfx( "maps/zombie_tomb/fx_tomb_emergence_spawn" );
+	level._effect[ "crusader_zombie_eyes" ] = loadfx( "maps/zombie/fx_zombie_crusader_eyes" );
+	level._effect[ "zone_capture_zombie_torso_fx" ] = loadfx( "maps/zombie_tomb/fx_tomb_crusader_torso_loop" );
+	level._effect[ "player_rain" ] = loadfx( "maps/zombie_tomb/fx_tomb_player_weather_rain" );
+	level._effect[ "player_snow" ] = loadfx( "maps/zombie_tomb/fx_tomb_player_weather_snow" );
+	level._effect[ "lightning_flash" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_lightning_lg" );
+	level._effect[ "tank_treads" ] = loadfx( "maps/zombie_tomb/fx_tomb_veh_tank_treadfx_mud" );
+	level._effect[ "tank_light_grn" ] = loadfx( "maps/zombie_tomb/fx_tomb_capture_light_green" );
+	level._effect[ "tank_light_red" ] = loadfx( "maps/zombie_tomb/fx_tomb_capture_light_red" );
+	level._effect[ "tank_overheat" ] = loadfx( "maps/zombie_tomb/fx_tomb_veh_tank_exhaust_overheat" );
+	level._effect[ "tank_exhaust" ] = loadfx( "maps/zombie_tomb/fx_tomb_veh_tank_exhaust" );
+	level._effect[ "bottle_glow" ] = loadfx( "maps/zombie_tomb/fx_tomb_dieselmagic_portal" );
+	level._effect[ "perk_pipe_smoke" ] = loadfx( "maps/zombie_tomb/fx_tomb_perk_machine_exhaust" );
+	level._effect[ "wagon_fire" ] = loadfx( "maps/zombie_tomb/fx_tomb_ee_fire_wagon" );
+	level._effect[ "zombie_fist_glow" ] = loadfx( "maps/zombie_tomb/fx_tomb_ee_fists" );
+	level._effect[ "ee_vortex" ] = loadfx( "maps/zombie_tomb/fx_tomb_ee_vortex" );
+	level._effect[ "ee_beam" ] = loadfx( "maps/zombie_tomb/fx_tomb_ee_beam" );
+	level._effect[ "foot_box_glow" ] = loadfx( "maps/zombie_tomb/fx_tomb_challenge_fire" );
+	level._effect[ "couch_fx" ] = loadfx( "maps/zombie_tomb/fx_tomb_debris_blocker" );
+	level._effect[ "sky_plane_tracers" ] = loadfx( "maps/zombie_tomb/fx_tomb_sky_plane_tracers" );
+	level._effect[ "sky_plane_trail" ] = loadfx( "maps/zombie_tomb/fx_tomb_sky_plane_trail" );
+	level._effect[ "biplane_explode" ] = loadfx( "maps/zombie_tomb/fx_tomb_explo_airplane" );
+	level._effect[ "special_glow" ] = loadfx( "maps/zombie_tomb/fx_tomb_elem_reveal_glow" );
+}
+
+precache_createfx_fx()
+{
+	level._effect[ "fx_sky_dist_aa_tracers" ] = loadfx( "maps/zombie_tomb/fx_tomb_sky_dist_aa_tracers" );
+	level._effect[ "fx_tomb_vortex_glow" ] = loadfx( "maps/zombie_tomb/fx_tomb_vortex_glow" );
+	level._effect[ "fx_pack_a_punch" ] = loadfx( "maps/zombie_tomb/fx_tomb_pack_a_punch_light_beams" );
+	level._effect[ "fx_tomb_dust_fall" ] = loadfx( "maps/zombie_tomb/fx_tomb_dust_fall" );
+	level._effect[ "fx_tomb_dust_fall_lg" ] = loadfx( "maps/zombie_tomb/fx_tomb_dust_fall_lg" );
+	level._effect[ "fx_tomb_embers_flat" ] = loadfx( "maps/zombie_tomb/fx_tomb_embers_flat" );
+	level._effect[ "fx_tomb_fire_lg" ] = loadfx( "maps/zombie_tomb/fx_tomb_fire_lg" );
+	level._effect[ "fx_tomb_fire_sm" ] = loadfx( "maps/zombie_tomb/fx_tomb_fire_sm" );
+	level._effect[ "fx_tomb_fire_line_sm" ] = loadfx( "maps/zombie_tomb/fx_tomb_fire_line_sm" );
+	level._effect[ "fx_tomb_fire_sm_smolder" ] = loadfx( "maps/zombie_tomb/fx_tomb_fire_sm_smolder" );
+	level._effect[ "fx_tomb_ground_fog" ] = loadfx( "maps/zombie_tomb/fx_tomb_ground_fog" );
+	level._effect[ "fx_tomb_sparks" ] = loadfx( "maps/zombie_tomb/fx_tomb_sparks" );
+	level._effect[ "fx_tomb_water_drips" ] = loadfx( "maps/zombie_tomb/fx_tomb_water_drips" );
+	level._effect[ "fx_tomb_water_drips_sm" ] = loadfx( "maps/zombie_tomb/fx_tomb_water_drips_sm" );
+	level._effect[ "fx_tomb_smoke_pillar_xlg" ] = loadfx( "maps/zombie_tomb/fx_tomb_smoke_pillar_xlg" );
+	level._effect[ "fx_tomb_godray_md" ] = loadfx( "maps/zombie_tomb/fx_tomb_godray_md" );
+	level._effect[ "fx_tomb_godray_mist_md" ] = loadfx( "maps/zombie_tomb/fx_tomb_godray_mist_md" );
+	level._effect[ "fx_tomb_dust_motes_md" ] = loadfx( "maps/zombie_tomb/fx_tomb_dust_motes_md" );
+	level._effect[ "fx_tomb_dust_motes_lg" ] = loadfx( "maps/zombie_tomb/fx_tomb_dust_motes_lg" );
+	level._effect[ "fx_tomb_light_md" ] = loadfx( "maps/zombie_tomb/fx_tomb_light_md" );
+	level._effect[ "fx_tomb_light_lg" ] = loadfx( "maps/zombie_tomb/fx_tomb_light_lg" );
+	level._effect[ "fx_tomb_light_expensive" ] = loadfx( "maps/zombie_tomb/fx_tomb_light_expensive" );
+	level._effect[ "fx_tomb_steam_md" ] = loadfx( "maps/zombie_tomb/fx_tomb_steam_md" );
+	level._effect[ "fx_tomb_steam_lg" ] = loadfx( "maps/zombie_tomb/fx_tomb_steam_lg" );
+	level._effect[ "fx_tomb_church_fire_vista" ] = loadfx( "maps/zombie_tomb/fx_tomb_church_fire_vista" );
+	level._effect[ "fx_tomb_church_custom" ] = loadfx( "maps/zombie_tomb/fx_tomb_church_custom" );
+	level._effect[ "fx_tomb_chamber_glow" ] = loadfx( "maps/zombie_tomb/fx_tomb_chamber_glow" );
+	level._effect[ "fx_tomb_chamber_glow_blue" ] = loadfx( "maps/zombie_tomb/fx_tomb_chamber_glow_blue" );
+	level._effect[ "fx_tomb_chamber_glow_purple" ] = loadfx( "maps/zombie_tomb/fx_tomb_chamber_glow_purple" );
+	level._effect[ "fx_tomb_chamber_glow_yellow" ] = loadfx( "maps/zombie_tomb/fx_tomb_chamber_glow_yellow" );
+	level._effect[ "fx_tomb_chamber_glow_red" ] = loadfx( "maps/zombie_tomb/fx_tomb_chamber_glow_red" );
+	level._effect[ "fx_tomb_chamber_walls_impact" ] = loadfx( "maps/zombie_tomb/fx_tomb_chamber_walls_impact" );
+	level._effect[ "fx_tomb_crafting_chamber_glow" ] = loadfx( "maps/zombie_tomb/fx_tomb_crafting_chamber_glow" );
+	level._effect[ "fx_tomb_probe_elec_on" ] = loadfx( "maps/zombie_tomb/fx_tomb_probe_elec_on" );
+	level._effect[ "fx_tomb_robot_ambient" ] = loadfx( "maps/zombie_tomb/fx_tomb_robot_ambient" );
+	level._effect[ "fx_tomb_skybox_vortex" ] = loadfx( "maps/zombie_tomb/fx_tomb_skybox_vortex" );
+}
+
+precache_fxanim_props()
+{
+	level.scr_anim[ "fxanim_props" ][ "dogfights" ] = %fxanim_zom_tomb_dogfights_anim;
+}
+
+precache_fxanim_props_dlc4()
+{
+	level.scr_anim[ "fxanim_props_dlc4" ][ "church_wires" ] = %fxanim_zom_tomb_church_wires_anim;
+	level.scr_anim[ "fxanim_props_dlc4" ][ "no_mans_wire" ] = %fxanim_zom_tomb_no_mans_wire_anim;
+	level.scr_anim[ "fxanim_props_dlc4" ][ "float_bunker" ] = %fxanim_zom_tomb_debris_float_bunker_anim;
+	level.scr_anim[ "fxanim_props_dlc4" ][ "chamber_rocks01" ] = %fxanim_zom_tomb_chamber_rocks01_anim;
+	level.scr_anim[ "fxanim_props_dlc4" ][ "chamber_rocks02" ] = %fxanim_zom_tomb_chamber_rocks02_anim;
+	level.scr_anim[ "fxanim_props_dlc4" ][ "head_fans" ] = %fxanim_zom_tomb_robot_head_fans_anim;
+	level.scr_anim[ "fxanim_props_dlc4" ][ "church_drain" ] = %fxanim_zom_tomb_church_drain_anim;
+	level.scr_anim[ "fxanim_props_dlc4" ][ "wires_ruins" ] = %fxanim_zom_tomb_wires_ruins_anim;
+	level.scr_anim[ "fxanim_props_dlc4" ][ "pap_ropes" ] = %fxanim_zom_tomb_pap_ropes_anim;
+	level.scr_anim[ "fxanim_props_dlc4" ][ "church_ceiling" ] = %fxanim_zom_tomb_church_ceiling_anim;
+	level.scr_anim[ "fxanim_props_dlc4" ][ "crane_hook" ] = %fxanim_zom_tomb_crane_hook_anim;
+}

zm_tomb_patch/maps/mp/zm_tomb_gamemodes.gsc

@@ -0,0 +1,13 @@
+#include maps/mp/zm_tomb_classic;
+#include maps/mp/zm_tomb;
+#include maps/mp/gametypes_zm/_zm_gametype;
+#include maps/mp/zombies/_zm_game_module;
+#include maps/mp/zombies/_zm_utility;
+#include maps/mp/_utility;
+#include common_scripts/utility;
+
+init()
+{
+	add_map_gamemode( "zclassic", ::maps/mp/zm_tomb::zstandard_preinit, undefined, undefined );
+	add_map_location_gamemode( "zclassic", "tomb", ::maps/mp/zm_tomb_classic::precache, ::maps/mp/zm_tomb_classic::main );
+}

zm_tomb_patch/maps/mp/zm_tomb_giant_robot_ffotd.gsc

@@ -0,0 +1,35 @@
+#include maps/mp/zombies/_zm_utility;
+#include maps/mp/_utility;
+#include common_scripts/utility;
+
+init_giant_robot_start()
+{
+}
+
+init_giant_robot_end()
+{
+}
+
+init_giant_robot_glows_start()
+{
+}
+
+init_giant_robot_glows_end()
+{
+}
+
+giant_robot_spawn_start()
+{
+}
+
+giant_robot_spawn_end()
+{
+}
+
+giant_robot_head_player_eject_start()
+{
+}
+
+giant_robot_head_player_eject_end()
+{
+}

zm_tomb_patch/maps/mp/zm_tomb_quest_air.gsc

@@ -0,0 +1,283 @@
+#include maps/mp/zm_tomb_vo;
+#include maps/mp/zombies/_zm_net;
+#include maps/mp/zm_tomb_utility;
+#include maps/mp/zombies/_zm_sidequests;
+#include maps/mp/zombies/_zm_craftables;
+#include maps/mp/zombies/_zm_utility;
+#include maps/mp/_utility;
+#include common_scripts/utility;
+
+main()
+{
+	flag_init( "air_puzzle_1_complete" );
+	flag_init( "air_puzzle_2_complete" );
+	flag_init( "air_upgrade_available" );
+	air_puzzle_1_init();
+	air_puzzle_2_init();
+	maps/mp/zm_tomb_vo::add_puzzle_completion_line( 2, "vox_sam_wind_puz_solve_1" );
+	maps/mp/zm_tomb_vo::add_puzzle_completion_line( 2, "vox_sam_wind_puz_solve_0" );
+	maps/mp/zm_tomb_vo::add_puzzle_completion_line( 2, "vox_sam_wind_puz_solve_2" );
+	level thread maps/mp/zm_tomb_vo::watch_one_shot_line( "puzzle", "try_puzzle", "vo_try_puzzle_air1" );
+	level thread maps/mp/zm_tomb_vo::watch_one_shot_line( "puzzle", "try_puzzle", "vo_try_puzzle_air2" );
+	level thread air_puzzle_1_run();
+	flag_wait( "air_puzzle_1_complete" );
+	playsoundatposition( "zmb_squest_step1_finished", ( 0, 0, 0 ) );
+	level thread air_puzzle_1_cleanup();
+	level thread rumble_players_in_chamber( 5, 3 );
+	level thread air_puzzle_2_run();
+}
+
+air_puzzle_1_init()
+{
+	level.a_ceiling_rings = getentarray( "ceiling_ring", "script_noteworthy" );
+	_a56 = level.a_ceiling_rings;
+	_k56 = getFirstArrayKey( _a56 );
+	while ( isDefined( _k56 ) )
+	{
+		e_ring = _a56[ _k56 ];
+		e_ring ceiling_ring_init();
+		_k56 = getNextArrayKey( _a56, _k56 );
+	}
+}
+
+air_puzzle_1_cleanup()
+{
+	i = 1;
+	while ( i <= 3 )
+	{
+		n_move = ( 4 - i ) * 20;
+		e_ring = getent( "ceiling_ring_0" + i, "targetname" );
+		e_ring rotateyaw( 360, 1,5, 0,5, 0 );
+		e_ring movez( n_move, 1,5, 0,5, 0 );
+		e_ring waittill( "movedone" );
+		i++;
+	}
+	playsoundatposition( "zmb_squest_wind_ring_disappear", level.a_ceiling_rings[ 0 ].origin );
+}
+
+air_puzzle_1_run()
+{
+	array_thread( level.a_ceiling_rings, ::ceiling_ring_run );
+}
+
+check_puzzle_solved()
+{
+	num_solved = 0;
+	_a85 = level.a_ceiling_rings;
+	_k85 = getFirstArrayKey( _a85 );
+	while ( isDefined( _k85 ) )
+	{
+		e_ring = _a85[ _k85 ];
+		if ( e_ring.script_int != e_ring.position )
+		{
+			return 0;
+		}
+		_k85 = getNextArrayKey( _a85, _k85 );
+	}
+	return 1;
+}
+
+ceiling_ring_randomize()
+{
+	n_offset_from_final = randomintrange( 1, 4 );
+	self.position = ( self.script_int + n_offset_from_final ) % 4;
+	ceiling_ring_update_position();
+/#
+	assert( self.position != self.script_int );
+#/
+}
+
+ceiling_ring_update_position()
+{
+	new_angles = ( self.angles[ 0 ], self.position * 90, self.angles[ 2 ] );
+	self rotateto( new_angles, 0,5, 0,2, 0,2 );
+	self playsound( "zmb_squest_wind_ring_turn" );
+	self waittill( "rotatedone" );
+}
+
+ceiling_ring_rotate()
+{
+	self.position = ( self.position + 1 ) % 4;
+/#
+	if ( self.position == self.script_int )
+	{
+		iprintlnbold( "Ring is in place." );
+#/
+	}
+	self ceiling_ring_update_position();
+	solved = check_puzzle_solved();
+	if ( solved && !flag( "air_puzzle_1_complete" ) )
+	{
+		self thread maps/mp/zm_tomb_vo::say_puzzle_completion_line( 2 );
+		flag_set( "air_puzzle_1_complete" );
+	}
+}
+
+ceiling_ring_init()
+{
+	self.position = 0;
+}
+
+ceiling_ring_run()
+{
+	level endon( "air_puzzle_1_complete" );
+	self setcandamage( 1 );
+	self.position = 0;
+	ceiling_ring_randomize();
+	n_rotations = 0;
+	while ( 1 )
+	{
+		self waittill( "damage", damage, attacker, direction_vec, point, mod, tagname, modelname, partname, weaponname );
+		if ( weaponname == "staff_air_zm" )
+		{
+			level notify( "vo_try_puzzle_air1" );
+			self ceiling_ring_rotate();
+			rumble_nearby_players( self.origin, 1500, 2 );
+			n_rotations++;
+			if ( ( n_rotations % 4 ) == 0 )
+			{
+				level notify( "vo_puzzle_bad" );
+			}
+			continue;
+		}
+		else
+		{
+			level notify( "vo_puzzle_confused" );
+		}
+	}
+}
+
+air_puzzle_2_init()
+{
+	a_smoke_pos = getstructarray( "puzzle_smoke_origin", "targetname" );
+	_a179 = a_smoke_pos;
+	_k179 = getFirstArrayKey( _a179 );
+	while ( isDefined( _k179 ) )
+	{
+		s_smoke_pos = _a179[ _k179 ];
+		s_smoke_pos.detector_brush = getent( s_smoke_pos.target, "targetname" );
+		s_smoke_pos.detector_brush ghost();
+		_k179 = getNextArrayKey( _a179, _k179 );
+	}
+}
+
+air_puzzle_2_run()
+{
+	a_smoke_pos = getstructarray( "puzzle_smoke_origin", "targetname" );
+	_a190 = a_smoke_pos;
+	_k190 = getFirstArrayKey( _a190 );
+	while ( isDefined( _k190 ) )
+	{
+		s_smoke_pos = _a190[ _k190 ];
+		s_smoke_pos thread air_puzzle_smoke();
+		_k190 = getNextArrayKey( _a190, _k190 );
+	}
+	while ( 1 )
+	{
+		level waittill( "air_puzzle_smoke_solved" );
+		all_smoke_solved = 1;
+		_a200 = a_smoke_pos;
+		_k200 = getFirstArrayKey( _a200 );
+		while ( isDefined( _k200 ) )
+		{
+			s_smoke_pos = _a200[ _k200 ];
+			if ( !s_smoke_pos.solved )
+			{
+				all_smoke_solved = 0;
+			}
+			_k200 = getNextArrayKey( _a200, _k200 );
+		}
+		if ( all_smoke_solved )
+		{
+			a_players = getplayers();
+			_a211 = a_players;
+			_k211 = getFirstArrayKey( _a211 );
+			while ( isDefined( _k211 ) )
+			{
+				e_player = _a211[ _k211 ];
+				if ( e_player hasweapon( "staff_air_zm" ) )
+				{
+					e_player thread maps/mp/zm_tomb_vo::say_puzzle_completion_line( 2 );
+					break;
+				}
+				else
+				{
+					_k211 = getNextArrayKey( _a211, _k211 );
+				}
+			}
+			flag_set( "air_puzzle_2_complete" );
+			level thread play_puzzle_stinger_on_all_players();
+			return;
+		}
+		else
+		{
+		}
+	}
+}
+
+air_puzzle_smoke()
+{
+	self.e_fx = spawn( "script_model", self.origin );
+	self.e_fx.angles = self.angles;
+	self.e_fx setmodel( "tag_origin" );
+	self.e_fx playloopsound( "zmb_squest_wind_incense_loop", 2 );
+	s_dest = getstruct( "puzzle_smoke_dest", "targetname" );
+	playfxontag( level._effect[ "air_puzzle_smoke" ], self.e_fx, "tag_origin" );
+	self thread air_puzzle_run_smoke_direction();
+	flag_wait( "air_puzzle_2_complete" );
+	self.e_fx movez( -1000, 1, 0,1, 0,1 );
+	self.e_fx waittill( "movedone" );
+	wait 5;
+	self.e_fx delete();
+	self.detector_brush delete();
+}
+
+air_puzzle_run_smoke_direction()
+{
+	level endon( "air_puzzle_2_complete" );
+	self endon( "death" );
+	s_dest = getstruct( "puzzle_smoke_dest", "targetname" );
+	v_to_dest = vectornormalize( s_dest.origin - self.origin );
+	f_min_dot = cos( self.script_int );
+	self.solved = 0;
+	self.detector_brush setcandamage( 1 );
+	direction_failures = 0;
+	while ( 1 )
+	{
+		self.detector_brush waittill( "damage", damage, attacker, direction_vec, point, mod, tagname, modelname, partname, weaponname );
+		if ( weaponname == "staff_air_zm" )
+		{
+			level notify( "vo_try_puzzle_air2" );
+			new_yaw = vectoangles( direction_vec );
+			new_orient = ( 0, new_yaw, 0 );
+			self.e_fx rotateto( new_orient, 1, 0,3, 0,3 );
+			self.e_fx waittill( "rotatedone" );
+			f_dot = vectordot( v_to_dest, direction_vec );
+			self.solved = f_dot > f_min_dot;
+			if ( !self.solved )
+			{
+				direction_failures++;
+				if ( direction_failures > 4 )
+				{
+					level notify( "vo_puzzle_confused" );
+				}
+			}
+			else
+			{
+				if ( randomint( 100 ) < 10 )
+				{
+					level notify( "vo_puzzle_good" );
+				}
+			}
+			level notify( "air_puzzle_smoke_solved" );
+			continue;
+		}
+		else
+		{
+			if ( issubstr( weaponname, "staff" ) )
+			{
+				level notify( "vo_puzzle_bad" );
+			}
+		}
+	}
+}

zm_tomb_patch/maps/mp/zm_tomb_quest_crypt.gsc

@@ -0,0 +1,377 @@
+#include maps/mp/zombies/_zm_audio;
+#include maps/mp/zm_tomb_vo;
+#include maps/mp/zombies/_zm_net;
+#include maps/mp/zm_tomb_utility;
+#include maps/mp/zombies/_zm_sidequests;
+#include maps/mp/zombies/_zm_craftables;
+#include maps/mp/zombies/_zm_utility;
+#include maps/mp/_utility;
+#include common_scripts/utility;
+
+#using_animtree( "fxanim_props_dlc4" );
+
+main()
+{
+	precachemodel( "p6_power_lever" );
+	onplayerconnect_callback( ::on_player_connect_crypt );
+	flag_init( "staff_air_zm_upgrade_unlocked" );
+	flag_init( "staff_water_zm_upgrade_unlocked" );
+	flag_init( "staff_fire_zm_upgrade_unlocked" );
+	flag_init( "staff_lightning_zm_upgrade_unlocked" );
+	flag_init( "disc_rotation_active" );
+	level thread maps/mp/zm_tomb_vo::watch_one_shot_line( "puzzle", "try_puzzle", "vo_try_puzzle_crypt" );
+	init_crypt_gems();
+	chamber_disc_puzzle_init();
+}
+
+on_player_connect_crypt()
+{
+	discs = getentarray( "crypt_puzzle_disc", "script_noteworthy" );
+	_a42 = discs;
+	_k42 = getFirstArrayKey( _a42 );
+	while ( isDefined( _k42 ) )
+	{
+		disc = _a42[ _k42 ];
+		disc delay_thread( 0,5, ::bryce_cake_light_update, 0 );
+		_k42 = getNextArrayKey( _a42, _k42 );
+	}
+}
+
+chamber_disc_puzzle_init()
+{
+	level.gem_start_pos = [];
+	level.gem_start_pos[ "crypt_gem_fire" ] = 2;
+	level.gem_start_pos[ "crypt_gem_air" ] = 3;
+	level.gem_start_pos[ "crypt_gem_ice" ] = 0;
+	level.gem_start_pos[ "crypt_gem_elec" ] = 1;
+	chamber_discs = getentarray( "crypt_puzzle_disc", "script_noteworthy" );
+	array_thread( chamber_discs, ::chamber_disc_run );
+	flag_wait( "chamber_entrance_opened" );
+	chamber_discs_randomize();
+}
+
+chamber_disc_run()
+{
+	flag_wait( "start_zombie_round_logic" );
+	self.position = 0;
+	self bryce_cake_light_update( 0 );
+	if ( isDefined( self.target ) )
+	{
+		a_levers = getentarray( self.target, "targetname" );
+		_a77 = a_levers;
+		_k77 = getFirstArrayKey( _a77 );
+		while ( isDefined( _k77 ) )
+		{
+			e_lever = _a77[ _k77 ];
+			e_lever.trigger_stub = tomb_spawn_trigger_radius( e_lever.origin, 100, 1 );
+			e_lever.trigger_stub.require_look_at = 0;
+			if ( !isDefined( e_lever.script_string ) && isDefined( "clockwise" ) )
+			{
+				if ( isDefined( e_lever.script_string ) && isDefined( "clockwise" ) )
+				{
+					clockwise = e_lever.script_string == "clockwise";
+				}
+			}
+			e_lever.trigger_stub thread chamber_disc_trigger_run( self, e_lever, clockwise );
+			_k77 = getNextArrayKey( _a77, _k77 );
+		}
+		self thread chamber_disc_move_to_position();
+	}
+	self useanimtree( -1 );
+	n_wait = randomfloatrange( 0, 5 );
+	wait n_wait;
+	self setanim( %fxanim_zom_tomb_chamber_piece_anim );
+}
+
+init_crypt_gems()
+{
+	disc = getent( "crypt_puzzle_disc_main", "targetname" );
+	gems = getentarray( "crypt_gem", "script_noteworthy" );
+	_a101 = gems;
+	_k101 = getFirstArrayKey( _a101 );
+	while ( isDefined( _k101 ) )
+	{
+		gem = _a101[ _k101 ];
+		gem linkto( disc );
+		gem thread run_crypt_gem_pos();
+		_k101 = getNextArrayKey( _a101, _k101 );
+	}
+}
+
+light_discs_bottom_to_top()
+{
+	discs = getentarray( "crypt_puzzle_disc", "script_noteworthy" );
+	i = 1;
+	while ( i <= 4 )
+	{
+		_a113 = discs;
+		_k113 = getFirstArrayKey( _a113 );
+		while ( isDefined( _k113 ) )
+		{
+			disc = _a113[ _k113 ];
+			if ( !isDefined( disc.script_int ) || !isDefined( i ) && isDefined( disc.script_int ) && isDefined( i ) && disc.script_int == i )
+			{
+				disc bryce_cake_light_update( 1 );
+				break;
+			}
+			else
+			{
+				_k113 = getNextArrayKey( _a113, _k113 );
+			}
+		}
+		wait 1;
+		i++;
+	}
+}
+
+run_crypt_gem_pos()
+{
+	str_weapon = undefined;
+	complete_flag = undefined;
+	str_orb_path = undefined;
+	str_glow_fx = undefined;
+	n_element = self.script_int;
+	switch( self.targetname )
+	{
+		case "crypt_gem_air":
+			str_weapon = "staff_air_zm";
+			complete_flag = "staff_air_zm_upgrade_unlocked";
+			str_orb_path = "air_orb_exit_path";
+			str_final_pos = "air_orb_plinth_final";
+			break;
+		case "crypt_gem_ice":
+			str_weapon = "staff_water_zm";
+			complete_flag = "staff_water_zm_upgrade_unlocked";
+			str_orb_path = "ice_orb_exit_path";
+			str_final_pos = "ice_orb_plinth_final";
+			break;
+		case "crypt_gem_fire":
+			str_weapon = "staff_fire_zm";
+			complete_flag = "staff_fire_zm_upgrade_unlocked";
+			str_orb_path = "fire_orb_exit_path";
+			str_final_pos = "fire_orb_plinth_final";
+			break;
+		case "crypt_gem_elec":
+			str_weapon = "staff_lightning_zm";
+			complete_flag = "staff_lightning_zm_upgrade_unlocked";
+			str_orb_path = "lightning_orb_exit_path";
+			str_final_pos = "lightning_orb_plinth_final";
+			break;
+		default:
+/#
+			assertmsg( "Unknown crypt gem targetname: " + self.targetname );
+#/
+			return;
+	}
+	e_gem_model = puzzle_orb_chamber_to_crypt( str_orb_path, self );
+	e_main_disc = getent( "crypt_puzzle_disc_main", "targetname" );
+	e_gem_model linkto( e_main_disc );
+	str_targetname = self.targetname;
+	self delete();
+	e_gem_model setcandamage( 1 );
+	while ( 1 )
+	{
+		e_gem_model waittill( "damage", damage, attacker, direction_vec, point, mod, tagname, modelname, partname, weaponname );
+		if ( weaponname == str_weapon )
+		{
+			break;
+		}
+		else
+		{
+		}
+	}
+	e_gem_model setclientfield( "element_glow_fx", n_element );
+	e_gem_model playsound( "zmb_squest_crystal_charge" );
+	e_gem_model playloopsound( "zmb_squest_crystal_charge_loop", 2 );
+	while ( 1 )
+	{
+		if ( chamber_disc_gem_has_clearance( str_targetname ) )
+		{
+			break;
+		}
+		else level waittill( "crypt_disc_rotation" );
+	}
+	flag_set( "disc_rotation_active" );
+	level thread maps/mp/zombies/_zm_audio::sndmusicstingerevent( "side_sting_5" );
+	light_discs_bottom_to_top();
+	level thread puzzle_orb_pillar_show();
+	e_gem_model unlink();
+	s_ascent = getstruct( "orb_crypt_ascent_path", "targetname" );
+	v_next_pos = ( e_gem_model.origin[ 0 ], e_gem_model.origin[ 1 ], s_ascent.origin[ 2 ] );
+	e_gem_model setclientfield( "element_glow_fx", n_element );
+	playfxontag( level._effect[ "puzzle_orb_trail" ], e_gem_model, "tag_origin" );
+	e_gem_model playsound( "zmb_squest_crystal_leave" );
+	e_gem_model puzzle_orb_move( v_next_pos );
+	flag_clear( "disc_rotation_active" );
+	level thread chamber_discs_randomize();
+	e_gem_model puzzle_orb_follow_path( s_ascent );
+	v_next_pos = ( e_gem_model.origin[ 0 ], e_gem_model.origin[ 1 ], e_gem_model.origin[ 2 ] + 2000 );
+	e_gem_model puzzle_orb_move( v_next_pos );
+	s_chamber_path = getstruct( str_orb_path, "targetname" );
+	str_model = e_gem_model.model;
+	e_gem_model delete();
+	e_gem_model = puzzle_orb_follow_return_path( s_chamber_path, n_element );
+	s_final = getstruct( str_final_pos, "targetname" );
+	e_gem_model puzzle_orb_move( s_final.origin );
+	e_new_gem = spawn( "script_model", s_final.origin );
+	e_new_gem setmodel( e_gem_model.model );
+	e_new_gem.script_int = n_element;
+	e_new_gem setclientfield( "element_glow_fx", n_element );
+	e_gem_model delete();
+	e_new_gem playsound( "zmb_squest_crystal_arrive" );
+	e_new_gem playloopsound( "zmb_squest_crystal_charge_loop", 0,1 );
+	flag_set( complete_flag );
+}
+
+chamber_disc_move_to_position()
+{
+	new_angles = ( self.angles[ 0 ], self.position * 90, self.angles[ 2 ] );
+	self rotateto( new_angles, 1, 0, 0 );
+	self playsound( "zmb_crypt_disc_turn" );
+	wait ( 1 * 0,75 );
+	self bryce_cake_light_update( 0 );
+	wait ( 1 * 0,25 );
+	self bryce_cake_light_update( 0 );
+	self playsound( "zmb_crypt_disc_stop" );
+	rumble_nearby_players( self.origin, 1000, 2 );
+}
+
+chamber_discs_move_all_to_position( discs )
+{
+	if ( !isDefined( discs ) )
+	{
+		discs = undefined;
+	}
+	flag_set( "disc_rotation_active" );
+	if ( !isDefined( discs ) )
+	{
+		discs = getentarray( "chamber_puzzle_disc", "script_noteworthy" );
+	}
+	_a285 = discs;
+	_k285 = getFirstArrayKey( _a285 );
+	while ( isDefined( _k285 ) )
+	{
+		e_disc = _a285[ _k285 ];
+		e_disc chamber_disc_move_to_position();
+		_k285 = getNextArrayKey( _a285, _k285 );
+	}
+	flag_clear( "disc_rotation_active" );
+}
+
+chamber_disc_get_gem_position( gem_name )
+{
+	disc = getent( "crypt_puzzle_disc_main", "targetname" );
+	return ( disc.position + level.gem_start_pos[ gem_name ] ) % 4;
+}
+
+chamber_disc_gem_has_clearance( gem_name )
+{
+	gem_position = chamber_disc_get_gem_position( gem_name );
+	discs = getentarray( "crypt_puzzle_disc", "script_noteworthy" );
+	_a303 = discs;
+	_k303 = getFirstArrayKey( _a303 );
+	while ( isDefined( _k303 ) )
+	{
+		disc = _a303[ _k303 ];
+		if ( !isDefined( disc.targetname ) || !isDefined( "crypt_puzzle_disc_main" ) && isDefined( disc.targetname ) && isDefined( "crypt_puzzle_disc_main" ) && disc.targetname == "crypt_puzzle_disc_main" )
+		{
+		}
+		else
+		{
+			if ( disc.position != gem_position )
+			{
+				return 0;
+			}
+		}
+		_k303 = getNextArrayKey( _a303, _k303 );
+	}
+	return 1;
+}
+
+chamber_disc_rotate( b_clockwise )
+{
+	if ( b_clockwise )
+	{
+		self.position = ( self.position + 1 ) % 4;
+	}
+	else
+	{
+		self.position = ( self.position + 3 ) % 4;
+	}
+	self chamber_disc_move_to_position();
+}
+
+bryce_cake_light_update( b_on )
+{
+	if ( !isDefined( b_on ) )
+	{
+		b_on = 1;
+	}
+	if ( !isDefined( self.n_bryce_cake ) )
+	{
+		self.n_bryce_cake = 0;
+	}
+	if ( !b_on )
+	{
+		self.n_bryce_cake = ( self.n_bryce_cake + 1 ) % 2;
+	}
+	else
+	{
+		self.n_bryce_cake = 2;
+	}
+	self setclientfield( "bryce_cake", self.n_bryce_cake );
+}
+
+chamber_discs_randomize()
+{
+	discs = getentarray( "crypt_puzzle_disc", "script_noteworthy" );
+	prev_disc_pos = 0;
+	_a345 = discs;
+	_k345 = getFirstArrayKey( _a345 );
+	while ( isDefined( _k345 ) )
+	{
+		disc = _a345[ _k345 ];
+		if ( !isDefined( disc.target ) )
+		{
+		}
+		else
+		{
+			disc.position = ( prev_disc_pos + randomintrange( 1, 3 ) ) % 4;
+			prev_disc_pos = disc.position;
+		}
+		_k345 = getNextArrayKey( _a345, _k345 );
+	}
+	chamber_discs_move_all_to_position( discs );
+}
+
+chamber_disc_switch_spark()
+{
+	self setclientfield( "switch_spark", 1 );
+	wait 0,5;
+	self setclientfield( "switch_spark", 0 );
+}
+
+chamber_disc_trigger_run( e_disc, e_lever, b_clockwise )
+{
+	discs_to_rotate = array( e_disc );
+	e_lever useanimtree( -1 );
+	n_anim_time = getanimlength( %fxanim_zom_tomb_puzzle_lever_switch_anim );
+	while ( 1 )
+	{
+		self waittill( "trigger", e_triggerer );
+		if ( !flag( "disc_rotation_active" ) )
+		{
+			flag_set( "disc_rotation_active" );
+			e_lever setanim( %fxanim_zom_tomb_puzzle_lever_switch_anim, 1, 0, 1 );
+			e_lever playsound( "zmb_crypt_lever" );
+			wait ( n_anim_time * 0,5 );
+			e_lever thread chamber_disc_switch_spark();
+			array_thread( discs_to_rotate, ::chamber_disc_rotate, b_clockwise );
+			wait 1;
+			e_lever clearanim( %fxanim_zom_tomb_puzzle_lever_switch_anim, 0 );
+			flag_clear( "disc_rotation_active" );
+			level notify( "vo_try_puzzle_crypt" );
+		}
+		level notify( "crypt_disc_rotation" );
+	}
+}

zm_tomb_patch/maps/mp/zm_tomb_quest_elec.gsc

@@ -0,0 +1,476 @@
+#include maps/mp/zombies/_zm_unitrigger;
+#include maps/mp/zm_tomb_chamber;
+#include maps/mp/zm_tomb_vo;
+#include maps/mp/zombies/_zm_net;
+#include maps/mp/zm_tomb_utility;
+#include maps/mp/zombies/_zm_sidequests;
+#include maps/mp/zombies/_zm_craftables;
+#include maps/mp/zombies/_zm_utility;
+#include maps/mp/_utility;
+#include common_scripts/utility;
+
+main()
+{
+	onplayerconnect_callback( ::onplayerconnect );
+	flag_init( "electric_puzzle_1_complete" );
+	flag_init( "electric_puzzle_2_complete" );
+	flag_init( "electric_upgrade_available" );
+	maps/mp/zm_tomb_vo::add_puzzle_completion_line( 3, "vox_sam_lightning_puz_solve_0" );
+	maps/mp/zm_tomb_vo::add_puzzle_completion_line( 3, "vox_sam_lightning_puz_solve_1" );
+	maps/mp/zm_tomb_vo::add_puzzle_completion_line( 3, "vox_sam_lightning_puz_solve_2" );
+	level thread maps/mp/zm_tomb_vo::watch_one_shot_line( "puzzle", "try_puzzle", "vo_try_puzzle_lightning1" );
+	level thread maps/mp/zm_tomb_vo::watch_one_shot_line( "puzzle", "try_puzzle", "vo_try_puzzle_lightning2" );
+	electric_puzzle_1_init();
+	electric_puzzle_2_init();
+	level thread electric_puzzle_1_run();
+	flag_wait( "electric_puzzle_1_complete" );
+	playsoundatposition( "zmb_squest_step1_finished", ( 0, 0, -1 ) );
+	level thread rumble_players_in_chamber( 5, 3 );
+	level thread electric_puzzle_2_run();
+	flag_wait( "electric_puzzle_2_complete" );
+	level thread electric_puzzle_2_cleanup();
+}
+
+onplayerconnect()
+{
+	self thread electric_puzzle_watch_staff();
+}
+
+electric_puzzle_watch_staff()
+{
+	self endon( "disconnect" );
+	a_piano_keys = getstructarray( "piano_key", "script_noteworthy" );
+	while ( 1 )
+	{
+		self waittill( "projectile_impact", str_weap_name, v_explode_point, n_radius, e_projectile, n_impact );
+		while ( str_weap_name == "staff_lightning_zm" )
+		{
+			while ( !flag( "electric_puzzle_1_complete" ) && maps/mp/zm_tomb_chamber::is_chamber_occupied() )
+			{
+				n_index = get_closest_index( v_explode_point, a_piano_keys, 20 );
+				while ( isDefined( n_index ) )
+				{
+					a_piano_keys[ n_index ] notify( "piano_key_shot" );
+					a_players = getplayers();
+					_a77 = a_players;
+					_k77 = getFirstArrayKey( _a77 );
+					while ( isDefined( _k77 ) )
+					{
+						e_player = _a77[ _k77 ];
+						if ( e_player hasweapon( "staff_lightning_zm" ) )
+						{
+							level notify( "vo_try_puzzle_lightning1" );
+						}
+						_k77 = getNextArrayKey( _a77, _k77 );
+					}
+				}
+			}
+		}
+	}
+}
+
+electric_puzzle_1_init()
+{
+	flag_init( "piano_chord_ringing" );
+}
+
+electric_puzzle_1_run()
+{
+	a_piano_keys = getstructarray( "piano_key", "script_noteworthy" );
+	level.a_piano_keys_playing = [];
+	array_thread( a_piano_keys, ::piano_key_run );
+	level thread piano_run_chords();
+}
+
+piano_keys_stop()
+{
+	level notify( "piano_keys_stop" );
+	level.a_piano_keys_playing = [];
+}
+
+show_chord_debug( a_chord_notes )
+{
+/#
+	if ( !isDefined( a_chord_notes ) )
+	{
+		a_chord_notes = [];
+	}
+	a_piano_keys = getstructarray( "piano_key", "script_noteworthy" );
+	_a129 = a_piano_keys;
+	_k129 = getFirstArrayKey( _a129 );
+	while ( isDefined( _k129 ) )
+	{
+		e_key = _a129[ _k129 ];
+		e_key notify( "stop_debug_position" );
+		_a132 = a_chord_notes;
+		_k132 = getFirstArrayKey( _a132 );
+		while ( isDefined( _k132 ) )
+		{
+			note = _a132[ _k132 ];
+			if ( note == e_key.script_string )
+			{
+				e_key thread puzzle_debug_position();
+				break;
+			}
+			else
+			{
+				_k132 = getNextArrayKey( _a132, _k132 );
+			}
+		}
+		_k129 = getNextArrayKey( _a129, _k129 );
+#/
+	}
+}
+
+piano_run_chords()
+{
+	a_chords = getstructarray( "piano_chord", "targetname" );
+	_a147 = a_chords;
+	_k147 = getFirstArrayKey( _a147 );
+	while ( isDefined( _k147 ) )
+	{
+		s_chord = _a147[ _k147 ];
+		s_chord.notes = strtok( s_chord.script_string, " " );
+/#
+		assert( s_chord.notes.size == 3 );
+#/
+		_k147 = getNextArrayKey( _a147, _k147 );
+	}
+	a_chord_order = array( "a_minor", "e_minor", "d_minor" );
+	_a154 = a_chord_order;
+	_k154 = getFirstArrayKey( _a154 );
+	while ( isDefined( _k154 ) )
+	{
+		chord_name = _a154[ _k154 ];
+		s_chord = getstruct( "piano_chord_" + chord_name, "script_noteworthy" );
+/#
+		show_chord_debug( s_chord.notes );
+#/
+		chord_solved = 0;
+		while ( !chord_solved )
+		{
+			level waittill( "piano_key_played" );
+			while ( level.a_piano_keys_playing.size == 3 )
+			{
+				correct_notes_playing = 0;
+				_a169 = level.a_piano_keys_playing;
+				_k169 = getFirstArrayKey( _a169 );
+				while ( isDefined( _k169 ) )
+				{
+					played_note = _a169[ _k169 ];
+					_a171 = s_chord.notes;
+					_k171 = getFirstArrayKey( _a171 );
+					while ( isDefined( _k171 ) )
+					{
+						requested_note = _a171[ _k171 ];
+						if ( requested_note == played_note )
+						{
+							correct_notes_playing++;
+						}
+						_k171 = getNextArrayKey( _a171, _k171 );
+					}
+					_k169 = getNextArrayKey( _a169, _k169 );
+				}
+				if ( correct_notes_playing == 3 )
+				{
+					chord_solved = 1;
+					break;
+				}
+				else
+				{
+					a_players = getplayers();
+					_a185 = a_players;
+					_k185 = getFirstArrayKey( _a185 );
+					while ( isDefined( _k185 ) )
+					{
+						e_player = _a185[ _k185 ];
+						if ( e_player hasweapon( "staff_lightning_zm" ) )
+						{
+							level notify( "vo_puzzle_bad" );
+						}
+						_k185 = getNextArrayKey( _a185, _k185 );
+					}
+				}
+			}
+		}
+		a_players = getplayers();
+		_a197 = a_players;
+		_k197 = getFirstArrayKey( _a197 );
+		while ( isDefined( _k197 ) )
+		{
+			e_player = _a197[ _k197 ];
+			if ( e_player hasweapon( "staff_lightning_zm" ) )
+			{
+				level notify( "vo_puzzle_good" );
+			}
+			_k197 = getNextArrayKey( _a197, _k197 );
+		}
+		flag_set( "piano_chord_ringing" );
+		rumble_nearby_players( a_chords[ 0 ].origin, 1500, 2 );
+		wait 4;
+		flag_clear( "piano_chord_ringing" );
+		piano_keys_stop();
+/#
+		show_chord_debug();
+#/
+		_k154 = getNextArrayKey( _a154, _k154 );
+	}
+	e_player = get_closest_player( a_chords[ 0 ].origin );
+	e_player thread maps/mp/zm_tomb_vo::say_puzzle_completion_line( 3 );
+	flag_set( "electric_puzzle_1_complete" );
+}
+
+piano_key_run()
+{
+	piano_key_note = self.script_string;
+	while ( 1 )
+	{
+		self waittill( "piano_key_shot" );
+		if ( !flag( "piano_chord_ringing" ) )
+		{
+			if ( level.a_piano_keys_playing.size >= 3 )
+			{
+				piano_keys_stop();
+			}
+			self.e_fx = spawn( "script_model", self.origin );
+			self.e_fx playloopsound( "zmb_kbd_" + piano_key_note );
+			self.e_fx.angles = self.angles;
+			self.e_fx setmodel( "tag_origin" );
+			playfxontag( level._effect[ "elec_piano_glow" ], self.e_fx, "tag_origin" );
+			level.a_piano_keys_playing[ level.a_piano_keys_playing.size ] = piano_key_note;
+			level notify( "piano_key_played" );
+			level waittill( "piano_keys_stop" );
+			self.e_fx delete();
+		}
+	}
+}
+
+electric_puzzle_2_init()
+{
+	level.electric_relays = [];
+	level.electric_relays[ "bunker" ] = spawnstruct();
+	level.electric_relays[ "tank_platform" ] = spawnstruct();
+	level.electric_relays[ "start" ] = spawnstruct();
+	level.electric_relays[ "elec" ] = spawnstruct();
+	level.electric_relays[ "ruins" ] = spawnstruct();
+	level.electric_relays[ "air" ] = spawnstruct();
+	level.electric_relays[ "ice" ] = spawnstruct();
+	level.electric_relays[ "village" ] = spawnstruct();
+	_a273 = level.electric_relays;
+	_k273 = getFirstArrayKey( _a273 );
+	while ( isDefined( _k273 ) )
+	{
+		s_relay = _a273[ _k273 ];
+		s_relay.connections = [];
+		_k273 = getNextArrayKey( _a273, _k273 );
+	}
+	level.electric_relays[ "tank_platform" ].connections[ 0 ] = "ruins";
+	level.electric_relays[ "start" ].connections[ 1 ] = "tank_platform";
+	level.electric_relays[ "elec" ].connections[ 0 ] = "ice";
+	level.electric_relays[ "ruins" ].connections[ 2 ] = "chamber";
+	level.electric_relays[ "air" ].connections[ 2 ] = "start";
+	level.electric_relays[ "ice" ].connections[ 3 ] = "village";
+	level.electric_relays[ "village" ].connections[ 2 ] = "air";
+	level.electric_relays[ "bunker" ].position = 2;
+	level.electric_relays[ "tank_platform" ].position = 1;
+	level.electric_relays[ "start" ].position = 3;
+	level.electric_relays[ "elec" ].position = 1;
+	level.electric_relays[ "ruins" ].position = 3;
+	level.electric_relays[ "air" ].position = 0;
+	level.electric_relays[ "ice" ].position = 1;
+	level.electric_relays[ "village" ].position = 1;
+	a_switches = getentarray( "puzzle_relay_switch", "script_noteworthy" );
+	_a303 = a_switches;
+	_k303 = getFirstArrayKey( _a303 );
+	while ( isDefined( _k303 ) )
+	{
+		e_switch = _a303[ _k303 ];
+		level.electric_relays[ e_switch.script_string ].e_switch = e_switch;
+		_k303 = getNextArrayKey( _a303, _k303 );
+	}
+	array_thread( level.electric_relays, ::relay_switch_run );
+}
+
+electric_puzzle_2_run()
+{
+	update_relays();
+}
+
+electric_puzzle_2_cleanup()
+{
+	_a320 = level.electric_relays;
+	_k320 = getFirstArrayKey( _a320 );
+	while ( isDefined( _k320 ) )
+	{
+		s_relay = _a320[ _k320 ];
+		if ( isDefined( s_relay.trigger_stub ) )
+		{
+			maps/mp/zombies/_zm_unitrigger::register_unitrigger( s_relay.trigger_stub );
+		}
+		if ( isDefined( s_relay.e_switch ) )
+		{
+			s_relay.e_switch stoploopsound( 0,5 );
+		}
+		if ( isDefined( s_relay.e_fx ) )
+		{
+			s_relay.e_fx delete();
+		}
+		_k320 = getNextArrayKey( _a320, _k320 );
+	}
+}
+
+kill_all_relay_power()
+{
+	_a341 = level.electric_relays;
+	_k341 = getFirstArrayKey( _a341 );
+	while ( isDefined( _k341 ) )
+	{
+		s_relay = _a341[ _k341 ];
+		s_relay.receiving_power = 0;
+		s_relay.sending_power = 0;
+		_k341 = getNextArrayKey( _a341, _k341 );
+	}
+}
+
+relay_give_power( s_relay )
+{
+	if ( !flag( "electric_puzzle_1_complete" ) )
+	{
+		return;
+	}
+	if ( !isDefined( s_relay ) )
+	{
+		kill_all_relay_power();
+		s_relay = level.electric_relays[ "elec" ];
+	}
+	s_relay.receiving_power = 1;
+	str_target_relay = s_relay.connections[ s_relay.position ];
+	if ( isDefined( str_target_relay ) )
+	{
+		if ( str_target_relay == "chamber" )
+		{
+			s_relay.e_switch thread maps/mp/zm_tomb_vo::say_puzzle_completion_line( 3 );
+			level thread play_puzzle_stinger_on_all_players();
+			flag_set( "electric_puzzle_2_complete" );
+			return;
+		}
+		else
+		{
+			s_relay.sending_power = 1;
+			s_target_relay = level.electric_relays[ str_target_relay ];
+			relay_give_power( s_target_relay );
+		}
+	}
+}
+
+update_relay_fx_and_sound()
+{
+	if ( !flag( "electric_puzzle_1_complete" ) )
+	{
+		return;
+	}
+	_a398 = level.electric_relays;
+	_k398 = getFirstArrayKey( _a398 );
+	while ( isDefined( _k398 ) )
+	{
+		s_relay = _a398[ _k398 ];
+		if ( s_relay.sending_power )
+		{
+			if ( isDefined( s_relay.e_fx ) )
+			{
+				s_relay.e_fx delete();
+			}
+			s_relay.e_switch playloopsound( "zmb_squest_elec_switch_hum", 1 );
+		}
+		else if ( s_relay.receiving_power )
+		{
+			if ( !isDefined( s_relay.e_fx ) )
+			{
+				v_offset = anglesToRight( s_relay.e_switch.angles ) * 1;
+				s_relay.e_fx = spawn( "script_model", s_relay.e_switch.origin + v_offset );
+				s_relay.e_fx.angles = s_relay.e_switch.angles + vectorScale( ( 0, 0, -1 ), 90 );
+				s_relay.e_fx setmodel( "tag_origin" );
+				playfxontag( level._effect[ "fx_tomb_sparks" ], s_relay.e_fx, "tag_origin" );
+			}
+			s_relay.e_switch playloopsound( "zmb_squest_elec_switch_spark", 1 );
+		}
+		else
+		{
+			if ( isDefined( s_relay.e_fx ) )
+			{
+				s_relay.e_fx delete();
+			}
+			s_relay.e_switch stoploopsound( 1 );
+		}
+		_k398 = getNextArrayKey( _a398, _k398 );
+	}
+}
+
+update_relay_rotation()
+{
+	self.e_switch rotateto( ( self.position * 90, self.e_switch.angles[ 1 ], self.e_switch.angles[ 2 ] ), 0,1, 0, 0 );
+	self.e_switch playsound( "zmb_squest_elec_switch" );
+	self.e_switch waittill( "rotatedone" );
+}
+
+update_relays()
+{
+	relay_give_power();
+	update_relay_fx_and_sound();
+}
+
+relay_switch_run()
+{
+/#
+	assert( isDefined( self.e_switch ) );
+#/
+	self.trigger_stub = spawnstruct();
+	self.trigger_stub.origin = self.e_switch.origin;
+	self.trigger_stub.radius = 50;
+	self.trigger_stub.cursor_hint = "HINT_NOICON";
+	self.trigger_stub.hint_string = "";
+	self.trigger_stub.script_unitrigger_type = "unitrigger_radius_use";
+	self.trigger_stub.require_look_at = 1;
+	maps/mp/zombies/_zm_unitrigger::register_unitrigger( self.trigger_stub, ::relay_unitrigger_think );
+	level endon( "electric_puzzle_2_complete" );
+	self thread update_relay_rotation();
+	n_tries = 0;
+	while ( 1 )
+	{
+		self.trigger_stub waittill( "trigger", e_user );
+		n_tries++;
+		level notify( "vo_try_puzzle_lightning2" );
+		self.position = ( self.position + 1 ) % 4;
+		str_target_relay = self.connections[ self.position ];
+		if ( isDefined( str_target_relay ) )
+		{
+			if ( str_target_relay == "village" || str_target_relay == "ruins" )
+			{
+				level notify( "vo_puzzle_good" );
+			}
+		}
+		else if ( ( n_tries % 8 ) == 0 )
+		{
+			level notify( "vo_puzzle_confused" );
+		}
+		else
+		{
+			if ( ( n_tries % 4 ) == 0 )
+			{
+				level notify( "vo_puzzle_bad" );
+			}
+		}
+		self update_relay_rotation();
+		update_relays();
+	}
+}
+
+relay_unitrigger_think()
+{
+	self endon( "kill_trigger" );
+	while ( 1 )
+	{
+		self waittill( "trigger", player );
+		self.stub notify( "trigger" );
+	}
+}

zm_tomb_patch/maps/mp/zm_tomb_quest_fire.gsc

@@ -0,0 +1,525 @@
+#include maps/mp/zm_tomb_chamber;
+#include maps/mp/zm_tomb_vo;
+#include maps/mp/zombies/_zm_net;
+#include maps/mp/zm_tomb_utility;
+#include maps/mp/zombies/_zm_sidequests;
+#include maps/mp/zombies/_zm_craftables;
+#include maps/mp/zombies/_zm_utility;
+#include maps/mp/_utility;
+#include common_scripts/utility;
+
+#using_animtree( "zm_tomb_basic" );
+
+main()
+{
+	flag_init( "fire_puzzle_1_complete" );
+	flag_init( "fire_puzzle_2_complete" );
+	flag_init( "fire_upgrade_available" );
+	onplayerconnect_callback( ::onplayerconnect );
+	fire_puzzle_1_init();
+	fire_puzzle_2_init();
+	maps/mp/zm_tomb_vo::add_puzzle_completion_line( 1, "vox_sam_fire_puz_solve_0" );
+	maps/mp/zm_tomb_vo::add_puzzle_completion_line( 1, "vox_sam_fire_puz_solve_1" );
+	maps/mp/zm_tomb_vo::add_puzzle_completion_line( 1, "vox_sam_fire_puz_solve_2" );
+	level thread maps/mp/zm_tomb_vo::watch_one_shot_line( "puzzle", "try_puzzle", "vo_try_puzzle_fire1" );
+	level thread maps/mp/zm_tomb_vo::watch_one_shot_line( "puzzle", "try_puzzle", "vo_try_puzzle_fire2" );
+	level thread fire_puzzle_1_run();
+	flag_wait( "fire_puzzle_1_complete" );
+	playsoundatposition( "zmb_squest_step1_finished", ( -1, 0, 0 ) );
+	level thread rumble_players_in_chamber( 5, 3 );
+	level thread fire_puzzle_1_cleanup();
+	level thread fire_puzzle_2_run();
+	flag_wait( "fire_puzzle_2_complete" );
+	level thread fire_puzzle_2_cleanup();
+	flag_wait( "staff_fire_zm_upgrade_unlocked" );
+}
+
+onplayerconnect()
+{
+	self thread fire_puzzle_watch_staff();
+}
+
+init_animtree()
+{
+	scriptmodelsuseanimtree( -1 );
+}
+
+fire_puzzle_1_init()
+{
+}
+
+fire_puzzle_1_run()
+{
+	level.sacrifice_volumes = getentarray( "fire_sacrifice_volume", "targetname" );
+	level.clone_list = [];
+	level thread clone_cleanup_watch_player_presence();
+	array_thread( level.sacrifice_volumes, ::init_sacrifice_volume );
+	b_any_volumes_unfinished = 1;
+	while ( b_any_volumes_unfinished )
+	{
+		level waittill( "fire_sacrifice_completed" );
+		b_any_volumes_unfinished = 0;
+		_a98 = level.sacrifice_volumes;
+		_k98 = getFirstArrayKey( _a98 );
+		while ( isDefined( _k98 ) )
+		{
+			e_volume = _a98[ _k98 ];
+			if ( !e_volume.b_gods_pleased )
+			{
+				b_any_volumes_unfinished = 1;
+			}
+			_k98 = getNextArrayKey( _a98, _k98 );
+		}
+	}
+/#
+	iprintlnbold( "Fire Chamber Puzzle Completed" );
+#/
+	e_player = get_closest_player( level.sacrifice_volumes[ 0 ].origin );
+	e_player thread maps/mp/zm_tomb_vo::say_puzzle_completion_line( 1 );
+	flag_set( "fire_puzzle_1_complete" );
+}
+
+fire_puzzle_1_cleanup()
+{
+	array_delete( level.sacrifice_volumes );
+	level.sacrifice_volumes = [];
+	array_delete( level.clone_list );
+	level.clone_list = [];
+}
+
+clone_cleanup_watch_player_presence()
+{
+	level endon( "fire_puzzle_1_complete" );
+	while ( 1 )
+	{
+		wait 1;
+		if ( level.clone_list.size > 0 )
+		{
+			if ( !maps/mp/zm_tomb_chamber::is_chamber_occupied() )
+			{
+				array_delete( level.clone_list );
+				level.clone_list = [];
+			}
+		}
+	}
+}
+
+init_sacrifice_volume()
+{
+	self.b_gods_pleased = 0;
+	self.num_sacrifices_received = 0;
+	self.pct_sacrifices_received = 0;
+	self.e_ignition_point = getstruct( self.target, "targetname" );
+	self.e_ignition_point thread run_sacrifice_ignition( self );
+}
+
+run_sacrifice_plinth( e_volume )
+{
+	while ( 1 )
+	{
+		if ( flag( "fire_puzzle_1_complete" ) )
+		{
+			break;
+		}
+		else if ( isDefined( e_volume ) )
+		{
+			if ( e_volume.pct_sacrifices_received > self.script_float || e_volume.b_gods_pleased )
+			{
+				break;
+			}
+		}
+		else
+		{
+			wait 0,5;
+		}
+	}
+	light_plinth();
+}
+
+run_sacrifice_ignition( e_volume )
+{
+	e_volume ent_flag_init( "flame_on" );
+	if ( flag( "fire_puzzle_1_complete" ) )
+	{
+		return;
+	}
+	level endon( "fire_puzzle_1_complete" );
+	a_torch_pos = getstructarray( self.target, "targetname" );
+	array_thread( a_torch_pos, ::run_sacrifice_plinth, e_volume );
+	sndorigin = a_torch_pos[ 0 ].origin;
+	if ( !isDefined( self.angles ) )
+	{
+		self.angles = ( -1, 0, 0 );
+	}
+	max_hit_distance_sq = 10000;
+	while ( !e_volume.b_gods_pleased )
+	{
+		e_volume ent_flag_clear( "flame_on" );
+		level waittill( "fire_staff_explosion", v_point, e_projectile );
+		while ( !maps/mp/zm_tomb_chamber::is_chamber_occupied() )
+		{
+			continue;
+		}
+		while ( !e_projectile istouching( e_volume ) )
+		{
+			continue;
+		}
+		self.e_fx = spawn( "script_model", self.origin );
+		self.e_fx.angles = vectorScale( ( -1, 0, 0 ), 90 );
+		self.e_fx setmodel( "tag_origin" );
+		self.e_fx setclientfield( "barbecue_fx", 1 );
+		e_volume ent_flag_set( "flame_on" );
+		wait 6;
+		self.e_fx delete();
+	}
+	level notify( "fire_sacrifice_completed" );
+}
+
+light_plinth()
+{
+	e_fx = spawn( "script_model", self.origin );
+	e_fx setmodel( "tag_origin" );
+	playfxontag( level._effect[ "fire_torch" ], e_fx, "tag_origin" );
+	e_fx.angles = vectorScale( ( -1, 0, 0 ), 90 );
+	e_fx playsound( "zmb_squest_fire_torch_ignite" );
+	e_fx playloopsound( "zmb_squest_fire_torch_loop", 0,6 );
+	flag_wait( "fire_puzzle_1_complete" );
+	wait 30;
+	e_fx stoploopsound( 0,1 );
+	e_fx playsound( "zmb_squest_fire_torch_out" );
+	e_fx delete();
+}
+
+is_church_occupied()
+{
+	return 1;
+}
+
+sacrifice_puzzle_zombie_killed( einflictor, attacker, idamage, smeansofdeath, sweapon, vdir, shitloc, psoffsettime )
+{
+	if ( isDefined( level.craftables_crafted[ "elemental_staff_fire" ] ) && !level.craftables_crafted[ "elemental_staff_fire" ] && getDvarInt( "zombie_cheat" ) <= 0 )
+	{
+		return;
+	}
+	if ( isDefined( self.is_mechz ) && self.is_mechz )
+	{
+		return;
+	}
+	if ( !isDefined( level.sacrifice_volumes ) )
+	{
+		return;
+	}
+	if ( !maps/mp/zm_tomb_chamber::is_chamber_occupied() )
+	{
+		return;
+	}
+	_a297 = level.sacrifice_volumes;
+	_k297 = getFirstArrayKey( _a297 );
+	while ( isDefined( _k297 ) )
+	{
+		e_volume = _a297[ _k297 ];
+		if ( e_volume.b_gods_pleased )
+		{
+		}
+		else
+		{
+			if ( self istouching( e_volume ) )
+			{
+				level notify( "vo_try_puzzle_fire1" );
+				self thread fire_sacrifice_death_clone( e_volume );
+				return;
+			}
+		}
+		_k297 = getNextArrayKey( _a297, _k297 );
+	}
+}
+
+delete_oldest_clone()
+{
+	if ( level.clone_list.size == 0 )
+	{
+		return;
+	}
+	clone = level.clone_list[ 0 ];
+	arrayremoveindex( level.clone_list, 0, 0 );
+	clone delete();
+}
+
+fire_sacrifice_death_clone( e_sacrifice_volume )
+{
+	if ( level.clone_list.size >= 15 )
+	{
+		level delete_oldest_clone();
+	}
+	self ghost();
+	clone = self spawn_zombie_clone();
+	if ( self.has_legs )
+	{
+		clone setanim( %ch_dazed_a_death, 1, 0, 1 );
+	}
+	else
+	{
+		clone setanim( %ai_zombie_crawl_death_v1, 1, 0, 1 );
+	}
+	n_anim_time = getanimlength( %ch_dazed_a_death );
+	level.clone_list[ level.clone_list.size ] = clone;
+	clone endon( "death" );
+	wait n_anim_time;
+	e_sacrifice_volume ent_flag_wait( "flame_on" );
+	a_players = getplayers();
+	_a359 = a_players;
+	_k359 = getFirstArrayKey( _a359 );
+	while ( isDefined( _k359 ) )
+	{
+		e_player = _a359[ _k359 ];
+		if ( e_player hasweapon( "staff_fire_zm" ) )
+		{
+			level notify( "vo_puzzle_good" );
+		}
+		_k359 = getNextArrayKey( _a359, _k359 );
+	}
+	playfx( level._effect[ "fire_ash_explosion" ], clone.origin, anglesToForward( clone.angles ), anglesToUp( clone.angles ) );
+	e_sacrifice_volume.num_sacrifices_received++;
+	e_sacrifice_volume.pct_sacrifices_received = e_sacrifice_volume.num_sacrifices_received / 32;
+	if ( e_sacrifice_volume.num_sacrifices_received >= 32 )
+	{
+		e_sacrifice_volume.b_gods_pleased = 1;
+	}
+	e_sacrifice_volume notify( "sacrifice_received" );
+	arrayremovevalue( level.clone_list, clone );
+	clone delete();
+}
+
+spawn_zombie_clone()
+{
+	clone = spawn( "script_model", self.origin );
+	clone.angles = self.angles;
+	clone setmodel( self.model );
+	if ( isDefined( self.headmodel ) )
+	{
+		clone.headmodel = self.headmodel;
+		clone attach( clone.headmodel, "", 1 );
+	}
+	clone useanimtree( -1 );
+	return clone;
+}
+
+fire_puzzle_2_init()
+{
+	i = 1;
+	while ( i <= 4 )
+	{
+		a_ternary = getentarray( "fire_torch_ternary_group_0" + i, "targetname" );
+		if ( a_ternary.size > 1 )
+		{
+			index_to_save = randomintrange( 0, a_ternary.size );
+			a_ternary[ index_to_save ] ghost();
+			arrayremoveindex( a_ternary, index_to_save, 0 );
+			array_delete( a_ternary );
+			i++;
+			continue;
+		}
+		else
+		{
+			a_ternary[ 0 ] ghost();
+		}
+		i++;
+	}
+	a_torches = getstructarray( "church_torch_target", "script_noteworthy" );
+	array_thread( a_torches, ::fire_puzzle_torch_run );
+}
+
+fire_puzzle_2_run()
+{
+	a_ternary = getentarray( "fire_torch_ternary", "script_noteworthy" );
+/#
+	assert( a_ternary.size == 4 );
+#/
+	_a434 = a_ternary;
+	_k434 = getFirstArrayKey( _a434 );
+	while ( isDefined( _k434 ) )
+	{
+		e_number = _a434[ _k434 ];
+		e_number show();
+		e_target_torch = getstruct( e_number.target, "targetname" );
+		e_target_torch.b_correct_torch = 1;
+		e_target_torch thread puzzle_debug_position();
+		_k434 = getNextArrayKey( _a434, _k434 );
+	}
+}
+
+fire_puzzle_2_cleanup()
+{
+	a_torches = getstructarray( "church_torch_target", "script_noteworthy" );
+	_a446 = a_torches;
+	_k446 = getFirstArrayKey( _a446 );
+	while ( isDefined( _k446 ) )
+	{
+		s_torch = _a446[ _k446 ];
+		if ( !isDefined( s_torch.e_fx ) )
+		{
+			s_torch thread fire_puzzle_2_torch_flame();
+			wait 0,25;
+		}
+		_k446 = getNextArrayKey( _a446, _k446 );
+	}
+	wait 30;
+	_a459 = a_torches;
+	_k459 = getFirstArrayKey( _a459 );
+	while ( isDefined( _k459 ) )
+	{
+		s_torch = _a459[ _k459 ];
+		if ( isDefined( s_torch.e_fx ) )
+		{
+			s_torch.e_fx delete();
+			wait 0,25;
+		}
+		_k459 = getNextArrayKey( _a459, _k459 );
+	}
+}
+
+fire_puzzle_2_is_complete()
+{
+	a_torches = getstructarray( "church_torch_target", "script_noteworthy" );
+	wrong_torch = 0;
+	unlit_torch = 0;
+	_a476 = a_torches;
+	_k476 = getFirstArrayKey( _a476 );
+	while ( isDefined( _k476 ) )
+	{
+		e_torch = _a476[ _k476 ];
+		if ( isDefined( e_torch.e_fx ) && !e_torch.b_correct_torch )
+		{
+			wrong_torch = 1;
+		}
+		if ( !isDefined( e_torch.e_fx ) && e_torch.b_correct_torch )
+		{
+			unlit_torch = 1;
+		}
+		_k476 = getNextArrayKey( _a476, _k476 );
+	}
+	if ( !isDefined( level.n_torches_lit ) )
+	{
+		level.n_torches_lit = 0;
+	}
+	if ( !isDefined( level.n_wrong_torches ) )
+	{
+		level.n_wrong_torches = 0;
+	}
+	level.n_torches_lit++;
+	a_players = getplayers();
+	_a504 = a_players;
+	_k504 = getFirstArrayKey( _a504 );
+	while ( isDefined( _k504 ) )
+	{
+		e_player = _a504[ _k504 ];
+		if ( e_player hasweapon( "staff_fire_zm" ) )
+		{
+			if ( ( level.n_torches_lit % 12 ) == 0 && !flag( "fire_puzzle_2_complete" ) )
+			{
+				level notify( "vo_puzzle_confused" );
+				break;
+			}
+			else
+			{
+				if ( wrong_torch && !flag( "fire_puzzle_2_complete" ) )
+				{
+					level.n_wrong_torches++;
+					if ( ( level.n_wrong_torches % 5 ) == 0 )
+					{
+						level notify( "vo_puzzle_bad" );
+					}
+					break;
+				}
+				else
+				{
+					if ( unlit_torch )
+					{
+						level notify( "vo_puzzle_good" );
+					}
+				}
+			}
+		}
+		_k504 = getNextArrayKey( _a504, _k504 );
+	}
+	if ( !wrong_torch )
+	{
+		return !unlit_torch;
+	}
+}
+
+fire_puzzle_watch_staff()
+{
+	self endon( "disconnect" );
+	while ( 1 )
+	{
+		self waittill( "projectile_impact", str_weap_name, v_explode_point, n_radius, e_projectile, n_impact );
+		if ( str_weap_name == "staff_fire_zm" )
+		{
+			level notify( "fire_staff_explosion" );
+		}
+	}
+}
+
+fire_puzzle_2_torch_flame()
+{
+	if ( isDefined( self.e_fx ) )
+	{
+		self.e_fx delete();
+	}
+	self.e_fx = spawn( "script_model", self.origin );
+	self.e_fx.angles = vectorScale( ( -1, 0, 0 ), 90 );
+	self.e_fx setmodel( "tag_origin" );
+	playfxontag( level._effect[ "fire_torch" ], self.e_fx, "tag_origin" );
+	self.e_fx playsound( "zmb_squest_fire_torch_ignite" );
+	self.e_fx playloopsound( "zmb_squest_fire_torch_loop", 0,6 );
+	rumble_nearby_players( self.origin, 1500, 2 );
+	self.e_fx endon( "death" );
+	if ( fire_puzzle_2_is_complete() && !flag( "fire_puzzle_2_complete" ) )
+	{
+		self.e_fx thread maps/mp/zm_tomb_vo::say_puzzle_completion_line( 1 );
+		level thread play_puzzle_stinger_on_all_players();
+		flag_set( "fire_puzzle_2_complete" );
+	}
+	wait 15;
+	self.e_fx stoploopsound( 0,1 );
+	self.e_fx playsound( "zmb_squest_fire_torch_out" );
+	if ( !flag( "fire_puzzle_2_complete" ) )
+	{
+		self.e_fx delete();
+	}
+}
+
+fire_puzzle_torch_run()
+{
+	level endon( "fire_puzzle_2_complete" );
+	self.b_correct_torch = 0;
+	max_hit_distance_sq = 4096;
+	while ( 1 )
+	{
+		level waittill( "fire_staff_explosion", v_point );
+		while ( !is_church_occupied() )
+		{
+			continue;
+		}
+		dist_sq = distancesquared( v_point, self.origin );
+		while ( dist_sq > max_hit_distance_sq )
+		{
+			continue;
+		}
+		a_players = getplayers();
+		_a614 = a_players;
+		_k614 = getFirstArrayKey( _a614 );
+		while ( isDefined( _k614 ) )
+		{
+			e_player = _a614[ _k614 ];
+			if ( e_player hasweapon( "staff_fire_zm" ) )
+			{
+				level notify( "vo_try_puzzle_fire2" );
+			}
+			_k614 = getNextArrayKey( _a614, _k614 );
+		}
+		self thread fire_puzzle_2_torch_flame();
+		wait 2;
+	}
+}

zm_tomb_patch/maps/mp/zm_tomb_quest_ice.gsc

@@ -0,0 +1,357 @@
+#include maps/mp/zm_tomb_vo;
+#include maps/mp/zombies/_zm_net;
+#include maps/mp/zm_tomb_utility;
+#include maps/mp/zombies/_zm_sidequests;
+#include maps/mp/zombies/_zm_craftables;
+#include maps/mp/zombies/_zm_utility;
+#include maps/mp/_utility;
+#include common_scripts/utility;
+
+main()
+{
+	precachemodel( "p6_zm_tm_note_rock_01_anim" );
+	flag_init( "ice_puzzle_1_complete" );
+	flag_init( "ice_puzzle_2_complete" );
+	flag_init( "ice_upgrade_available" );
+	flag_init( "ice_tile_flipping" );
+	maps/mp/zm_tomb_vo::add_puzzle_completion_line( 4, "vox_sam_ice_puz_solve_0" );
+	maps/mp/zm_tomb_vo::add_puzzle_completion_line( 4, "vox_sam_ice_puz_solve_1" );
+	maps/mp/zm_tomb_vo::add_puzzle_completion_line( 4, "vox_sam_ice_puz_solve_2" );
+	level thread maps/mp/zm_tomb_vo::watch_one_shot_line( "puzzle", "try_puzzle", "vo_try_puzzle_water1" );
+	level thread maps/mp/zm_tomb_vo::watch_one_shot_line( "puzzle", "try_puzzle", "vo_try_puzzle_water2" );
+	ice_puzzle_1_init();
+	level thread ice_puzzle_2_init();
+	level thread ice_puzzle_1_run();
+	flag_wait( "ice_puzzle_1_complete" );
+	playsoundatposition( "zmb_squest_step1_finished", ( 0, 0, 0 ) );
+	level thread rumble_players_in_chamber( 5, 3 );
+	ice_puzzle_1_cleanup();
+	level thread ice_puzzle_2_run();
+	flag_wait( "ice_puzzle_2_complete" );
+	flag_wait( "staff_water_zm_upgrade_unlocked" );
+}
+
+ice_puzzle_1_init()
+{
+	ice_tiles_randomize();
+	a_ceiling_tile_brushes = getentarray( "ice_ceiling_tile", "script_noteworthy" );
+	level.unsolved_tiles = a_ceiling_tile_brushes;
+	_a68 = a_ceiling_tile_brushes;
+	_k68 = getFirstArrayKey( _a68 );
+	while ( isDefined( _k68 ) )
+	{
+		tile = _a68[ _k68 ];
+		tile.showing_tile_side = 0;
+		tile.value = int( tile.script_string );
+		tile thread ceiling_tile_flip();
+		tile thread ceiling_tile_process_damage();
+		_k68 = getNextArrayKey( _a68, _k68 );
+	}
+	a_ice_ternary_digit_brushes = getentarray( "ice_chamber_digit", "targetname" );
+	_a77 = a_ice_ternary_digit_brushes;
+	_k77 = getFirstArrayKey( _a77 );
+	while ( isDefined( _k77 ) )
+	{
+		digit = _a77[ _k77 ];
+		digit ghost();
+		digit notsolid();
+		_k77 = getNextArrayKey( _a77, _k77 );
+	}
+	level.ternary_digits = [];
+	level.ternary_digits[ 0 ] = array( -1, 0, -1 );
+	level.ternary_digits[ 1 ] = array( -1, 1, -1 );
+	level.ternary_digits[ 2 ] = array( -1, 2, -1 );
+	level.ternary_digits[ 3 ] = array( 1, -1, 0 );
+	level.ternary_digits[ 4 ] = array( 1, -1, 1 );
+	level.ternary_digits[ 5 ] = array( 1, -1, 2 );
+	level.ternary_digits[ 6 ] = array( 2, -1, 0 );
+	level.ternary_digits[ 7 ] = array( 2, -1, 1 );
+	level.ternary_digits[ 8 ] = array( 2, -1, 2 );
+	level.ternary_digits[ 9 ] = array( 1, 0, 0 );
+	level.ternary_digits[ 10 ] = array( 1, 0, 1 );
+	level.ternary_digits[ 11 ] = array( 1, 0, 2 );
+	level thread update_ternary_display();
+}
+
+ice_puzzle_1_cleanup()
+{
+	a_ceiling_tile_brushes = getentarray( "ice_ceiling_tile", "script_noteworthy" );
+	_a105 = a_ceiling_tile_brushes;
+	_k105 = getFirstArrayKey( _a105 );
+	while ( isDefined( _k105 ) )
+	{
+		tile = _a105[ _k105 ];
+		tile thread ceiling_tile_flip( 0 );
+		_k105 = getNextArrayKey( _a105, _k105 );
+	}
+	a_ice_ternary_digit_brushes = getentarray( "ice_chamber_digit", "targetname" );
+	array_delete( a_ice_ternary_digit_brushes );
+}
+
+ice_tiles_randomize()
+{
+	a_original_tiles = getentarray( "ice_tile_original", "targetname" );
+	a_original_positions = [];
+	_a120 = a_original_tiles;
+	_k120 = getFirstArrayKey( _a120 );
+	while ( isDefined( _k120 ) )
+	{
+		e_tile = _a120[ _k120 ];
+		a_original_positions[ a_original_positions.size ] = e_tile.origin;
+		_k120 = getNextArrayKey( _a120, _k120 );
+	}
+	a_unused_tiles = getentarray( "ice_ceiling_tile", "script_noteworthy" );
+	n_total_tiles = a_unused_tiles.size;
+	_a127 = a_original_positions;
+	_k127 = getFirstArrayKey( _a127 );
+	while ( isDefined( _k127 ) )
+	{
+		v_pos = _a127[ _k127 ];
+		e_tile = random( a_unused_tiles );
+		arrayremovevalue( a_unused_tiles, e_tile, 0 );
+		e_tile moveto( v_pos, 0,5, 0,1, 0,1 );
+		e_tile waittill( "movedone" );
+		_k127 = getNextArrayKey( _a127, _k127 );
+	}
+/#
+	assert( a_unused_tiles.size == ( n_total_tiles - a_original_positions.size ) );
+#/
+	array_delete( a_unused_tiles );
+}
+
+reset_tiles()
+{
+	a_ceiling_tile_brushes = getentarray( "ice_ceiling_tile", "script_noteworthy" );
+	_a144 = a_ceiling_tile_brushes;
+	_k144 = getFirstArrayKey( _a144 );
+	while ( isDefined( _k144 ) )
+	{
+		tile = _a144[ _k144 ];
+		tile thread ceiling_tile_flip( 1 );
+		_k144 = getNextArrayKey( _a144, _k144 );
+	}
+}
+
+update_ternary_display()
+{
+	a_ice_ternary_digit_brushes = getentarray( "ice_chamber_digit", "targetname" );
+	level endon( "ice_puzzle_1_complete" );
+	while ( 1 )
+	{
+		level waittill( "update_ice_chamber_digits", newval );
+		_a160 = a_ice_ternary_digit_brushes;
+		_k160 = getFirstArrayKey( _a160 );
+		while ( isDefined( _k160 ) )
+		{
+			digit = _a160[ _k160 ];
+			digit ghost();
+			if ( isDefined( newval ) )
+			{
+				digit_slot = int( digit.script_noteworthy );
+				shown_value = level.ternary_digits[ newval ][ digit_slot ];
+				digit_value = int( digit.script_string );
+				if ( shown_value == digit_value )
+				{
+					digit show();
+				}
+			}
+			_k160 = getNextArrayKey( _a160, _k160 );
+		}
+	}
+}
+
+change_ice_gem_value()
+{
+	ice_gem = getent( "ice_chamber_gem", "targetname" );
+	if ( level.unsolved_tiles.size != 0 )
+	{
+		correct_tile = random( level.unsolved_tiles );
+		ice_gem.value = correct_tile.value;
+		level notify( "update_ice_chamber_digits" );
+	}
+	else
+	{
+		level notify( "update_ice_chamber_digits" );
+	}
+}
+
+process_gem_shooting()
+{
+	level endon( "ice_puzzle_1_complete" );
+	ice_gem = getent( "ice_chamber_gem", "targetname" );
+	ice_gem.value = -1;
+	ice_gem setcandamage( 1 );
+	while ( 1 )
+	{
+		self waittill( "damage", damage, attacker, direction_vec, point, mod, tagname, modelname, partname, weaponname );
+		if ( weaponname == "staff_water_zm" )
+		{
+			change_ice_gem_value();
+		}
+	}
+}
+
+ice_puzzle_1_run()
+{
+	level thread process_gem_shooting();
+	change_ice_gem_value();
+}
+
+ceiling_tile_flip( b_flip_to_tile_side )
+{
+	if ( !isDefined( b_flip_to_tile_side ) )
+	{
+		b_flip_to_tile_side = !self.showing_tile_side;
+	}
+	if ( b_flip_to_tile_side == self.showing_tile_side )
+	{
+		return;
+	}
+	self.showing_tile_side = !self.showing_tile_side;
+	self rotateroll( 180, 0,5, 0,1, 0,1 );
+	self playsound( "zmb_squest_ice_tile_flip" );
+	if ( !self.showing_tile_side )
+	{
+		arrayremovevalue( level.unsolved_tiles, self, 0 );
+	}
+	else
+	{
+		level.unsolved_tiles[ level.unsolved_tiles.size ] = self;
+	}
+	if ( level.unsolved_tiles.size == 0 && !flag( "ice_puzzle_1_complete" ) )
+	{
+		self thread maps/mp/zm_tomb_vo::say_puzzle_completion_line( 4 );
+		flag_set( "ice_puzzle_1_complete" );
+	}
+	self waittill( "rotatedone" );
+}
+
+ceiling_tile_process_damage()
+{
+	level endon( "ice_puzzle_1_complete" );
+	ice_gem = getent( "ice_chamber_gem", "targetname" );
+	self setcandamage( 1 );
+	ice_gem setcandamage( 1 );
+	while ( 1 )
+	{
+		self waittill( "damage", damage, attacker, direction_vec, point, mod, tagname, modelname, partname, weaponname );
+		if ( issubstr( weaponname, "water" ) && self.showing_tile_side && !flag( "ice_tile_flipping" ) )
+		{
+			level notify( "vo_try_puzzle_water1" );
+			flag_set( "ice_tile_flipping" );
+			if ( ice_gem.value == self.value )
+			{
+				level notify( "vo_puzzle_good" );
+				self ceiling_tile_flip( 0 );
+				rumble_nearby_players( self.origin, 1500, 2 );
+				wait 0,2;
+			}
+			else
+			{
+				level notify( "vo_puzzle_bad" );
+				reset_tiles();
+				rumble_nearby_players( self.origin, 1500, 2 );
+				wait 2;
+			}
+			change_ice_gem_value();
+			flag_clear( "ice_tile_flipping" );
+			continue;
+		}
+		else
+		{
+			level notify( "vo_puzzle_confused" );
+		}
+	}
+}
+
+ice_puzzle_2_init()
+{
+}
+
+ice_puzzle_2_run()
+{
+	a_stone_positions = getstructarray( "puzzle_stone_water", "targetname" );
+	level.ice_stones_remaining = a_stone_positions.size;
+	_a328 = a_stone_positions;
+	_k328 = getFirstArrayKey( _a328 );
+	while ( isDefined( _k328 ) )
+	{
+		s_stone = _a328[ _k328 ];
+		s_stone thread ice_stone_run();
+		wait_network_frame();
+		_k328 = getNextArrayKey( _a328, _k328 );
+	}
+}
+
+ice_stone_run()
+{
+	v_up = anglesToUp( self.angles );
+	v_spawn_pos = self.origin - ( 64 * v_up );
+	self.e_model = spawn( "script_model", v_spawn_pos );
+	self.e_model.angles = self.angles;
+	self.e_model setmodel( "p6_zm_tm_note_rock_01_anim" );
+	self.e_model moveto( self.origin, 1, 0,5, 0,5 );
+	playfx( level._effect[ "digging" ], self.origin );
+	self.e_model setcandamage( 1 );
+	has_tried = 0;
+	while ( !flag( "ice_puzzle_2_complete" ) )
+	{
+		self.e_model waittill( "damage", amount, inflictor, direction, point, type, tagname, modelname, partname, weaponname, idflags );
+		level notify( "vo_try_puzzle_water2" );
+		if ( issubstr( weaponname, "water" ) )
+		{
+			level notify( "vo_puzzle_good" );
+			break;
+		}
+		else if ( has_tried )
+		{
+			level notify( "vo_puzzle_bad" );
+		}
+		has_tried = 1;
+	}
+	self.e_model setclientfield( "stone_frozen", 1 );
+	playsoundatposition( "zmb_squest_ice_stone_freeze", self.origin );
+	while ( !flag( "ice_puzzle_2_complete" ) )
+	{
+		self.e_model waittill( "damage", amount, inflictor, direction, point, type, tagname, modelname, partname, weaponname, idflags );
+		if ( !issubstr( weaponname, "staff" ) && issubstr( type, "BULLET" ) )
+		{
+			level notify( "vo_puzzle_good" );
+			break;
+		}
+		else level notify( "vo_puzzle_confused" );
+	}
+	self.e_model delete();
+	playfx( level._effect[ "ice_explode" ], self.origin, anglesToForward( self.angles ), anglesToUp( self.angles ) );
+	playsoundatposition( "zmb_squest_ice_stone_shatter", self.origin );
+	level.ice_stones_remaining--;
+
+	while ( level.ice_stones_remaining <= 0 && !flag( "ice_puzzle_2_complete" ) )
+	{
+		flag_set( "ice_puzzle_2_complete" );
+		e_player = get_closest_player( self.origin );
+		e_player thread maps/mp/zm_tomb_vo::say_puzzle_completion_line( 4 );
+		level thread play_puzzle_stinger_on_all_players();
+		level.weather_snow = 5;
+		level.weather_rain = 0;
+		_a408 = getplayers();
+		_k408 = getFirstArrayKey( _a408 );
+		while ( isDefined( _k408 ) )
+		{
+			player = _a408[ _k408 ];
+			player set_weather_to_player();
+			_k408 = getNextArrayKey( _a408, _k408 );
+		}
+		wait 5;
+		level.weather_snow = 0;
+		level.weather_rain = 0;
+		_a419 = getplayers();
+		_k419 = getFirstArrayKey( _a419 );
+		while ( isDefined( _k419 ) )
+		{
+			player = _a419[ _k419 ];
+			player set_weather_to_player();
+			_k419 = getNextArrayKey( _a419, _k419 );
+		}
+	}
+}

zm_tomb_patch/maps/mp/zm_tomb_standard.gsc

@@ -0,0 +1,27 @@
+#include maps/mp/zombies/_zm_magicbox;
+#include maps/mp/zombies/_zm_game_module;
+#include maps/mp/gametypes_zm/_zm_gametype;
+#include maps/mp/zombies/_zm_utility;
+#include common_scripts/utility;
+#include maps/mp/_utility;
+
+precache()
+{
+}
+
+main()
+{
+	maps/mp/gametypes_zm/_zm_gametype::setup_standard_objects( "tomb" );
+	maps/mp/zombies/_zm_game_module::set_current_game_module( level.game_module_standard_index );
+	flag_wait( "initial_blackscreen_passed" );
+	flag_set( "power_on" );
+	zm_treasure_chest_init();
+}
+
+zm_treasure_chest_init()
+{
+	chest1 = getstruct( "start_chest", "script_noteworthy" );
+	level.chests = [];
+	level.chests[ level.chests.size ] = chest1;
+	maps/mp/zombies/_zm_magicbox::treasure_chest_init( "start_chest" );
+}

zm_tomb_patch/maps/mp/zm_tomb_teleporter.gsc

@@ -0,0 +1,432 @@
+#include maps/mp/zombies/_zm_score;
+#include maps/mp/zm_tomb_vo;
+#include maps/mp/gametypes_zm/_hud;
+#include maps/mp/zm_tomb_utility;
+#include maps/mp/zombies/_zm_craftables;
+#include maps/mp/zombies/_zm_powerups;
+#include maps/mp/zombies/_zm_utility;
+#include maps/mp/_utility;
+#include common_scripts/utility;
+
+#using_animtree( "fxanim_props_dlc4" );
+
+teleporter_init()
+{
+	registerclientfield( "scriptmover", "teleporter_fx", 14000, 1, "int" );
+	precacheshellshock( "lava" );
+	level.teleport = [];
+	level.n_active_links = 0;
+	level.n_countdown = 0;
+	level.n_teleport_delay = 0;
+	level.teleport_cost = 0;
+	level.n_teleport_cooldown = 0;
+	level.is_cooldown = 0;
+	level.n_active_timer = -1;
+	level.n_teleport_time = 0;
+	level.a_teleport_models = [];
+	a_entrance_models = getentarray( "teleport_model", "targetname" );
+	_a40 = a_entrance_models;
+	_k40 = getFirstArrayKey( _a40 );
+	while ( isDefined( _k40 ) )
+	{
+		e_model = _a40[ _k40 ];
+		e_model useanimtree( -1 );
+		level.a_teleport_models[ e_model.script_int ] = e_model;
+		_k40 = getNextArrayKey( _a40, _k40 );
+	}
+	array_thread( a_entrance_models, ::teleporter_samantha_chamber_line );
+	a_portal_frames = getentarray( "portal_exit_frame", "script_noteworthy" );
+	level.a_portal_exit_frames = [];
+	_a51 = a_portal_frames;
+	_k51 = getFirstArrayKey( _a51 );
+	while ( isDefined( _k51 ) )
+	{
+		e_frame = _a51[ _k51 ];
+		e_frame useanimtree( -1 );
+		e_frame ghost();
+		level.a_portal_exit_frames[ e_frame.script_int ] = e_frame;
+		_k51 = getNextArrayKey( _a51, _k51 );
+	}
+	level.a_teleport_exits = [];
+	a_exits = getstructarray( "portal_exit", "script_noteworthy" );
+	_a62 = a_exits;
+	_k62 = getFirstArrayKey( _a62 );
+	while ( isDefined( _k62 ) )
+	{
+		s_portal = _a62[ _k62 ];
+		level.a_teleport_exits[ s_portal.script_int ] = s_portal;
+		_k62 = getNextArrayKey( _a62, _k62 );
+	}
+	level.a_teleport_exit_triggers = [];
+	a_trigs = getstructarray( "chamber_exit_trigger", "script_noteworthy" );
+	_a70 = a_trigs;
+	_k70 = getFirstArrayKey( _a70 );
+	while ( isDefined( _k70 ) )
+	{
+		s_trig = _a70[ _k70 ];
+		level.a_teleport_exit_triggers[ s_trig.script_int ] = s_trig;
+		_k70 = getNextArrayKey( _a70, _k70 );
+	}
+	a_s_teleporters = getstructarray( "trigger_teleport_pad", "targetname" );
+	array_thread( a_s_teleporters, ::run_chamber_entrance_teleporter );
+	spawn_stargate_fx_origins();
+	root = %root;
+	i = %fxanim_zom_tomb_portal_open_anim;
+	i = %fxanim_zom_tomb_portal_collapse_anim;
+}
+
+init_animtree()
+{
+	scriptmodelsuseanimtree( -1 );
+}
+
+teleporter_samantha_chamber_line()
+{
+	max_dist_sq = 640000;
+	level.sam_chamber_line_played = 0;
+	flag_wait( "samantha_intro_done" );
+	while ( !level.sam_chamber_line_played )
+	{
+		a_players = getplayers();
+		_a103 = a_players;
+		_k103 = getFirstArrayKey( _a103 );
+		while ( isDefined( _k103 ) )
+		{
+			e_player = _a103[ _k103 ];
+			dist_sq = distance2dsquared( self.origin, e_player.origin );
+			height_diff = abs( self.origin[ 2 ] - e_player.origin[ 2 ] );
+			if ( dist_sq < max_dist_sq && height_diff < 150 && isDefined( e_player.isspeaking ) && !e_player.isspeaking )
+			{
+				level thread play_teleporter_samantha_chamber_line( e_player );
+				return;
+			}
+			_k103 = getNextArrayKey( _a103, _k103 );
+		}
+		wait 0,1;
+	}
+}
+
+play_teleporter_samantha_chamber_line( e_player )
+{
+	if ( level.sam_chamber_line_played )
+	{
+		return;
+	}
+	level.sam_chamber_line_played = 1;
+	flag_waitopen( "story_vo_playing" );
+	flag_set( "story_vo_playing" );
+	set_players_dontspeak( 1 );
+	maps/mp/zm_tomb_vo::samanthasay( "vox_sam_enter_chamber_1_0", e_player, 1 );
+	maps/mp/zm_tomb_vo::samanthasay( "vox_sam_enter_chamber_2_0", e_player );
+	set_players_dontspeak( 0 );
+	flag_clear( "story_vo_playing" );
+}
+
+run_chamber_exit( n_enum )
+{
+	s_portal = level.a_teleport_exits[ n_enum ];
+	s_activate_pos = level.a_teleport_exit_triggers[ n_enum ];
+	e_portal_frame = level.a_portal_exit_frames[ n_enum ];
+	e_portal_frame show();
+	str_building_flag = e_portal_frame.targetname + "_building";
+	flag_init( str_building_flag );
+	s_activate_pos.trigger_stub = tomb_spawn_trigger_radius( s_activate_pos.origin, 50, 1 );
+	s_activate_pos.trigger_stub set_unitrigger_hint_string( &"ZM_TOMB_TELE" );
+	s_portal.target = s_activate_pos.target;
+	s_portal.origin = e_portal_frame gettagorigin( "fx_portal_jnt" );
+	s_portal.angles = e_portal_frame gettagangles( "fx_portal_jnt" );
+	s_portal.angles = ( s_portal.angles[ 0 ], s_portal.angles[ 1 ] + 180, s_portal.angles[ 2 ] );
+	str_fx = get_teleport_fx_from_enum( n_enum );
+	collapse_time = getanimlength( %fxanim_zom_tomb_portal_collapse_anim );
+	open_time = getanimlength( %fxanim_zom_tomb_portal_open_anim );
+	flag_wait( "start_zombie_round_logic" );
+	while ( 1 )
+	{
+		s_activate_pos.trigger_stub waittill( "trigger", e_player );
+		while ( !is_player_valid( e_player ) )
+		{
+			continue;
+		}
+		while ( e_player.score < level.teleport_cost )
+		{
+			continue;
+		}
+		s_activate_pos.trigger_stub set_unitrigger_hint_string( "" );
+		s_activate_pos.trigger_stub trigger_off();
+		if ( level.teleport_cost > 0 )
+		{
+			e_player maps/mp/zombies/_zm_score::minus_to_player_score( level.teleport_cost );
+		}
+		e_portal_frame playloopsound( "zmb_teleporter_loop_pre", 1 );
+		e_portal_frame setanim( %fxanim_zom_tomb_portal_open_anim, 1, 0,1, 1 );
+		flag_set( str_building_flag );
+		e_portal_frame thread whirlwind_rumble_nearby_players( str_building_flag );
+		wait open_time;
+		e_portal_frame setanim( %fxanim_zom_tomb_portal_open_1frame_anim, 1, 0,1, 1 );
+		wait_network_frame();
+		flag_clear( str_building_flag );
+		e_fx = spawn( "script_model", s_portal.origin );
+		e_fx.angles = s_portal.angles;
+		e_fx setmodel( "tag_origin" );
+		e_fx setclientfield( "element_glow_fx", n_enum + 4 );
+		rumble_nearby_players( e_fx.origin, 1000, 2 );
+		e_portal_frame playloopsound( "zmb_teleporter_loop_post", 1 );
+		s_portal thread teleporter_radius_think();
+		wait 20;
+		e_portal_frame setanim( %fxanim_zom_tomb_portal_collapse_anim, 1, 0,1, 1 );
+		e_portal_frame stoploopsound( 0,5 );
+		e_portal_frame playsound( "zmb_teleporter_anim_collapse_pew" );
+		s_portal notify( "teleporter_radius_stop" );
+		e_fx setclientfield( "element_glow_fx", 0 );
+		wait collapse_time;
+		e_fx delete();
+		s_activate_pos.trigger_stub trigger_on();
+		s_activate_pos.trigger_stub set_unitrigger_hint_string( &"ZM_TOMB_TELE" );
+	}
+}
+
+run_chamber_entrance_teleporter()
+{
+	self endon( "death" );
+	fx_glow = get_teleport_fx_from_enum( self.script_int );
+	e_model = level.a_teleport_models[ self.script_int ];
+	self.origin = e_model gettagorigin( "fx_portal_jnt" );
+	self.angles = e_model gettagangles( "fx_portal_jnt" );
+	self.angles = ( self.angles[ 0 ], self.angles[ 1 ] + 180, self.angles[ 2 ] );
+	self.trigger_stub = tomb_spawn_trigger_radius( self.origin - vectorScale( ( 0, 0, 0 ), 30 ), 50 );
+	flag_init( "enable_teleporter_" + self.script_int );
+	str_building_flag = "teleporter_building_" + self.script_int;
+	flag_init( str_building_flag );
+	collapse_time = getanimlength( %fxanim_zom_tomb_portal_collapse_anim );
+	open_time = getanimlength( %fxanim_zom_tomb_portal_open_anim );
+	flag_wait( "start_zombie_round_logic" );
+	e_model setanim( %fxanim_zom_tomb_portal_collapse_anim, 1, 0,1, 1 );
+	wait collapse_time;
+	while ( 1 )
+	{
+		flag_wait( "enable_teleporter_" + self.script_int );
+		flag_set( str_building_flag );
+		e_model thread whirlwind_rumble_nearby_players( str_building_flag );
+		e_model setanim( %fxanim_zom_tomb_portal_open_anim, 1, 0,1, 1 );
+		e_model playloopsound( "zmb_teleporter_loop_pre", 1 );
+		wait open_time;
+		e_model setanim( %fxanim_zom_tomb_portal_open_1frame_anim, 1, 0,1, 1 );
+		wait_network_frame();
+		e_fx = spawn( "script_model", self.origin );
+		e_fx.angles = self.angles;
+		e_fx setmodel( "tag_origin" );
+		e_fx setclientfield( "element_glow_fx", self.script_int + 4 );
+		rumble_nearby_players( e_fx.origin, 1000, 2 );
+		e_model playloopsound( "zmb_teleporter_loop_post", 1 );
+		if ( isDefined( self.exit_enabled ) && !self.exit_enabled )
+		{
+			self.exit_enabled = 1;
+			level thread run_chamber_exit( self.script_int );
+		}
+		self thread stargate_teleport_think();
+		flag_clear( str_building_flag );
+		flag_waitopen( "enable_teleporter_" + self.script_int );
+		level notify( "disable_teleporter_" + self.script_int );
+		e_fx setclientfield( "element_glow_fx", 0 );
+		e_model stoploopsound( 0,5 );
+		e_model playsound( "zmb_teleporter_anim_collapse_pew" );
+		e_model setanim( %fxanim_zom_tomb_portal_collapse_anim, 1, 0,1, 1 );
+		wait collapse_time;
+		e_fx delete();
+	}
+}
+
+teleporter_radius_think( radius )
+{
+	if ( !isDefined( radius ) )
+	{
+		radius = 120;
+	}
+	self endon( "teleporter_radius_stop" );
+	radius_sq = radius * radius;
+	while ( 1 )
+	{
+		a_players = getplayers();
+		_a336 = a_players;
+		_k336 = getFirstArrayKey( _a336 );
+		while ( isDefined( _k336 ) )
+		{
+			e_player = _a336[ _k336 ];
+			dist_sq = distancesquared( e_player.origin, self.origin );
+			if ( dist_sq < radius_sq && e_player getstance() != "prone" && isDefined( e_player.teleporting ) && !e_player.teleporting )
+			{
+				playfx( level._effect[ "teleport_3p" ], self.origin, ( 0, 0, 0 ), ( 0, 0, 0 ) );
+				playsoundatposition( "zmb_teleporter_tele_3d", self.origin );
+				level thread stargate_teleport_player( self.target, e_player );
+			}
+			_k336 = getNextArrayKey( _a336, _k336 );
+		}
+		wait_network_frame();
+	}
+}
+
+stargate_teleport_think()
+{
+	self endon( "death" );
+	level endon( "disable_teleporter_" + self.script_int );
+	e_potal = level.a_teleport_models[ self.script_int ];
+	while ( 1 )
+	{
+		self.trigger_stub waittill( "trigger", e_player );
+		if ( e_player getstance() != "prone" && isDefined( e_player.teleporting ) && !e_player.teleporting )
+		{
+			playfx( level._effect[ "teleport_3p" ], self.origin, ( 0, 0, 0 ), ( 0, 0, 0 ) );
+			playsoundatposition( "zmb_teleporter_tele_3d", self.origin );
+			level notify( "player_teleported" );
+			level thread stargate_teleport_player( self.target, e_player );
+		}
+	}
+}
+
+stargate_teleport_enable( n_index )
+{
+	flag_set( "enable_teleporter_" + n_index );
+}
+
+stargate_teleport_disable( n_index )
+{
+	flag_clear( "enable_teleporter_" + n_index );
+}
+
+stargate_play_fx()
+{
+	self.e_fx setclientfield( "teleporter_fx", 1 );
+	self waittill( "stop_teleport_fx" );
+	self.e_fx setclientfield( "teleporter_fx", 0 );
+}
+
+spawn_stargate_fx_origins()
+{
+	a_teleport_positions = getstructarray( "teleport_room", "script_noteworthy" );
+	_a406 = a_teleport_positions;
+	_k406 = getFirstArrayKey( _a406 );
+	while ( isDefined( _k406 ) )
+	{
+		s_teleport = _a406[ _k406 ];
+		v_fx_pos = ( s_teleport.origin + ( 0, 0, 64 ) ) + ( anglesToForward( s_teleport.angles ) * 120 );
+		s_teleport.e_fx = spawn( "script_model", v_fx_pos );
+		s_teleport.e_fx setmodel( "tag_origin" );
+		s_teleport.e_fx.angles = s_teleport.angles + vectorScale( ( 0, 0, 0 ), 180 );
+		_k406 = getNextArrayKey( _a406, _k406 );
+	}
+}
+
+stargate_teleport_player( str_teleport_to, player, n_teleport_time_sec, show_fx )
+{
+	if ( !isDefined( n_teleport_time_sec ) )
+	{
+		n_teleport_time_sec = 2;
+	}
+	if ( !isDefined( show_fx ) )
+	{
+		show_fx = 1;
+	}
+	player.teleporting = 1;
+	if ( show_fx )
+	{
+		player thread fadetoblackforxsec( 0, 0,3, 0, 0,5, "white" );
+		wait_network_frame();
+	}
+	n_pos = player.characterindex;
+	prone_offset = vectorScale( ( 0, 0, 0 ), 49 );
+	crouch_offset = vectorScale( ( 0, 0, 0 ), 20 );
+	stand_offset = ( 0, 0, 0 );
+	image_room = getstruct( "teleport_room_" + n_pos, "targetname" );
+	player disableoffhandweapons();
+	player disableweapons();
+	player freezecontrols( 1 );
+	wait_network_frame();
+	if ( player getstance() == "prone" )
+	{
+		desired_origin = image_room.origin + prone_offset;
+	}
+	else if ( player getstance() == "crouch" )
+	{
+		desired_origin = image_room.origin + crouch_offset;
+	}
+	else
+	{
+		desired_origin = image_room.origin + stand_offset;
+	}
+	player.teleport_origin = spawn( "script_model", player.origin );
+	player.teleport_origin setmodel( "tag_origin" );
+	player.teleport_origin.angles = player.angles;
+	player playerlinktoabsolute( player.teleport_origin, "tag_origin" );
+	player.teleport_origin.origin = desired_origin;
+	player.teleport_origin.angles = image_room.angles;
+	if ( show_fx )
+	{
+		player playsoundtoplayer( "zmb_teleporter_tele_2d", player );
+	}
+	wait_network_frame();
+	player.teleport_origin.angles = image_room.angles;
+	if ( show_fx )
+	{
+		image_room thread stargate_play_fx();
+	}
+	wait n_teleport_time_sec;
+	if ( show_fx )
+	{
+		player thread fadetoblackforxsec( 0, 0,3, 0, 0,5, "white" );
+		wait_network_frame();
+	}
+	image_room notify( "stop_teleport_fx" );
+	a_pos = getstructarray( str_teleport_to, "targetname" );
+	s_pos = get_free_teleport_pos( player, a_pos );
+	player unlink();
+	if ( isDefined( player.teleport_origin ) )
+	{
+		player.teleport_origin delete();
+		player.teleport_origin = undefined;
+	}
+	player setorigin( s_pos.origin );
+	player setplayerangles( s_pos.angles );
+	player enableweapons();
+	player enableoffhandweapons();
+	player freezecontrols( 0 );
+	player.teleporting = 0;
+}
+
+is_teleport_landing_valid( s_pos, n_radius )
+{
+	n_radius_sq = n_radius * n_radius;
+	a_players = getplayers();
+	_a514 = a_players;
+	_k514 = getFirstArrayKey( _a514 );
+	while ( isDefined( _k514 ) )
+	{
+		e_player = _a514[ _k514 ];
+		if ( distance2dsquared( s_pos.origin, e_player.origin ) < n_radius_sq )
+		{
+			return 0;
+		}
+		_k514 = getNextArrayKey( _a514, _k514 );
+	}
+	return 1;
+}
+
+get_free_teleport_pos( player, a_structs )
+{
+	n_player_radius = 64;
+	while ( 1 )
+	{
+		a_players = getplayers();
+		_a534 = a_structs;
+		_k534 = getFirstArrayKey( _a534 );
+		while ( isDefined( _k534 ) )
+		{
+			s_pos = _a534[ _k534 ];
+			if ( is_teleport_landing_valid( s_pos, n_player_radius ) )
+			{
+				return s_pos;
+			}
+			_k534 = getNextArrayKey( _a534, _k534 );
+		}
+		wait 0,05;
+	}
+}

zm_tomb_patch/maps/mp/zombies/_zm_ai_mechz_booster.gsc

@@ -0,0 +1,300 @@
+#include maps/mp/zombies/_zm_spawner;
+#include maps/mp/animscripts/zm_shared;
+#include maps/mp/zombies/_zm_ai_mechz;
+#include maps/mp/zombies/_zm_ai_mechz_dev;
+#include maps/mp/zm_tomb_tank;
+#include maps/mp/animscripts/zm_utility;
+#include maps/mp/zombies/_zm_utility;
+#include maps/mp/zombies/_zm_net;
+#include maps/mp/_utility;
+#include common_scripts/utility;
+#include maps/mp/zombies/_zm_zonemgr;
+
+#using_animtree( "mechz_claw" );
+
+mechz_in_range_for_jump()
+{
+	if ( !isDefined( self.jump_pos ) )
+	{
+/#
+		iprintln( "\nMZ Error: Trying to jump without valid jump_pos\n" );
+#/
+		self.jump_requested = 0;
+		return 0;
+	}
+	dist = distancesquared( self.origin, self.jump_pos.origin );
+	if ( dist <= 100 )
+	{
+		return 1;
+	}
+	return 0;
+}
+
+mechz_jump_think( spawn_pos )
+{
+	self endon( "death" );
+	self endon( "stop_jump_think" );
+	self.closest_jump_point = spawn_pos;
+	self.goal_pos = self.origin;
+	self setgoalpos( self.goal_pos );
+	self thread mechz_jump_stuck_watcher();
+	while ( 1 )
+	{
+		while ( isDefined( self.jump_requested ) && self.jump_requested )
+		{
+			if ( !self mechz_should_jump() )
+			{
+				self.jump_requested = 0;
+				self.jump_pos = undefined;
+			}
+			wait 1;
+		}
+		while ( !isDefined( self.ai_state ) || self.ai_state != "find_flesh" )
+		{
+			wait 0,05;
+		}
+		while ( isDefined( self.not_interruptable ) && self.not_interruptable )
+		{
+			wait 0,05;
+		}
+/#
+		while ( isDefined( self.force_behavior ) && self.force_behavior )
+		{
+			wait 0,05;
+#/
+		}
+		if ( self mechz_should_jump() )
+		{
+			self.jump_requested = 1;
+			self.jump_pos = get_closest_mechz_spawn_pos( self.origin );
+			if ( !isDefined( self.jump_pos ) )
+			{
+				self.jump_requested = 0;
+			}
+		}
+		wait 1;
+	}
+}
+
+watch_for_riot_shield_melee()
+{
+	self endon( "new_stuck_watcher" );
+	self endon( "death" );
+	while ( 1 )
+	{
+		self waittill( "item_attack" );
+/#
+		if ( getDvarInt( #"E7121222" ) > 1 )
+		{
+			println( "\n\tMZ: Resetting fail count because of item attack\n" );
+#/
+		}
+		self.fail_count = 0;
+	}
+}
+
+watch_for_valid_melee()
+{
+	self endon( "new_stuck_watcher" );
+	self endon( "death" );
+	while ( 1 )
+	{
+		self waittillmatch( "melee_anim" );
+		return "end";
+		if ( isDefined( self.favoriteenemy ) && distancesquared( self.origin, self.favoriteenemy.origin ) < 16384 )
+		{
+/#
+			if ( getDvarInt( #"E7121222" ) > 1 )
+			{
+				println( "\n\tMZ: Resetting fail count because of melee\n" );
+#/
+			}
+			self.fail_count = 0;
+		}
+	}
+}
+
+mechz_jump_stuck_watcher()
+{
+	self notify( "new_stuck_watcher" );
+	self endon( "death" );
+	self endon( "new_stuck_watcher" );
+	self.fail_count = 0;
+	self thread watch_for_valid_melee();
+	self thread watch_for_riot_shield_melee();
+	while ( 1 )
+	{
+		while ( !isDefined( self.goal_pos ) )
+		{
+			wait 0,05;
+		}
+		while ( isDefined( self.not_interruptable ) && self.not_interruptable )
+		{
+			wait 0,05;
+		}
+		while ( isDefined( self.ai_state ) && self.ai_state != "find_flesh" )
+		{
+			wait 0,05;
+		}
+/#
+		while ( isDefined( self.force_behavior ) && self.force_behavior )
+		{
+			wait 0,05;
+#/
+		}
+		if ( !findpath( self.origin, self.goal_pos, self, 0, 0 ) )
+		{
+/#
+			if ( getDvarInt( #"E7121222" ) > 1 )
+			{
+				println( "\n\tMZ: Incrementing fail count\n" );
+#/
+			}
+/#
+			println( "Mechz could not path to goal_pos " + self.goal_pos );
+#/
+			self.fail_count++;
+		}
+		else
+		{
+/#
+			if ( getDvarInt( #"E7121222" ) > 1 )
+			{
+				println( "\n\tMZ: Resetting fail count because of good path\n" );
+#/
+			}
+			self.fail_count = 0;
+		}
+		wait 1;
+	}
+}
+
+mechz_should_jump()
+{
+/#
+	if ( getDvarInt( #"E7121222" ) > 1 )
+	{
+		println( "\n\tMZ: Checking should jump\n" );
+#/
+	}
+	if ( !isDefined( self.favoriteenemy ) )
+	{
+/#
+		if ( getDvarInt( #"E7121222" ) > 1 )
+		{
+			println( "\n\t\tMZ: Not doing jump because has no enemy\n" );
+#/
+		}
+		return 0;
+	}
+	dist = distancesquared( self.origin, self.favoriteenemy.origin );
+	if ( dist >= level.mechz_jump_dist_threshold )
+	{
+/#
+		if ( getDvarInt( #"E7121222" ) > 1 )
+		{
+			println( "\n\t\tMZ: Doing jump because target is too far\n" );
+#/
+		}
+		return 1;
+	}
+	if ( self.fail_count >= level.mechz_failed_paths_to_jump )
+	{
+/#
+		if ( getDvarInt( #"E7121222" ) > 1 )
+		{
+			println( "\n\t\tMZ: Doing jump because has failed too many pathfind checks\n" );
+#/
+		}
+		return 1;
+	}
+	return 0;
+}
+
+mechz_do_jump( wait_for_stationary_tank )
+{
+	self endon( "death" );
+	self endon( "kill_jump" );
+/#
+	if ( getDvarInt( #"E7121222" ) > 0 )
+	{
+		println( "\nMZ: Doing Jump-Teleport\n" );
+#/
+	}
+/#
+	if ( getDvarInt( #"E7121222" ) > 1 )
+	{
+		println( "\nMZ: Jump setting not interruptable\n" );
+#/
+	}
+	self.not_interruptable = 1;
+	self setfreecameralockonallowed( 0 );
+	self thread mechz_jump_vo();
+	self animscripted( self.origin, self.angles, "zm_fly_out" );
+	self maps/mp/animscripts/zm_shared::donotetracks( "jump_anim" );
+	self ghost();
+	self.mechz_hidden = 1;
+	if ( isDefined( self.m_claw ) )
+	{
+		self.m_claw ghost();
+	}
+	if ( self.fx_field )
+	{
+		self.fx_field_old = self.fx_field;
+	}
+	self thread maps/mp/zombies/_zm_spawner::zombie_eye_glow_stop();
+	self fx_cleanup();
+	self animscripted( self.origin, self.angles, "zm_fly_hover" );
+	wait level.mechz_jump_delay;
+	if ( isDefined( wait_for_stationary_tank ) && wait_for_stationary_tank )
+	{
+		level.vh_tank ent_flag_waitopen( "tank_moving" );
+	}
+	self notsolid();
+	closest_jump_point = get_best_mechz_spawn_pos( 1 );
+	if ( isDefined( closest_jump_point ) )
+	{
+		self.closest_jump_point = closest_jump_point;
+	}
+	if ( !isDefined( self.closest_jump_point.angles ) )
+	{
+		self.closest_jump_point.angles = ( 0, 0, 0 );
+	}
+	self animscripted( self.closest_jump_point.origin, self.closest_jump_point.angles, "zm_fly_in" );
+	self solid();
+	self.mechz_hidden = 0;
+	self show();
+	self.fx_field = self.fx_field_old;
+	self.fx_field_old = undefined;
+	self setclientfield( "mechz_fx", self.fx_field );
+	self thread maps/mp/zombies/_zm_spawner::zombie_eye_glow();
+	if ( isDefined( self.m_claw ) )
+	{
+		self.m_claw show();
+	}
+	self maps/mp/animscripts/zm_shared::donotetracks( "jump_anim" );
+	self.not_interruptable = 0;
+	self setfreecameralockonallowed( 1 );
+/#
+	if ( getDvarInt( #"E7121222" ) > 1 )
+	{
+		println( "\nMZ: Jump clearing not interruptable\n" );
+#/
+	}
+	mechz_jump_cleanup();
+}
+
+mechz_kill_jump_watcher()
+{
+	self endon( "jump_complete" );
+	self waittill_either( "death", "kill_jump" );
+	self mechz_jump_cleanup();
+}
+
+mechz_jump_cleanup()
+{
+	self.fx_field &= 128;
+	self setclientfield( "mechz_fx", self.fx_field );
+	self stopanimscripted();
+	self notify( "jump_complete" );
+}

zm_tomb_patch/maps/mp/zombies/_zm_ai_mechz_claw.gsc

@@ -0,0 +1,637 @@
+#include maps/mp/zombies/_zm_weap_riotshield_tomb;
+#include maps/mp/zombies/_zm_laststand;
+#include maps/mp/animscripts/zm_shared;
+#include maps/mp/zombies/_zm_ai_mechz_ft;
+#include maps/mp/zombies/_zm_ai_mechz;
+#include maps/mp/zombies/_zm_ai_mechz_dev;
+#include maps/mp/zm_tomb_tank;
+#include maps/mp/animscripts/zm_utility;
+#include maps/mp/zm_tomb_utility;
+#include maps/mp/zombies/_zm_utility;
+#include maps/mp/zombies/_zm_net;
+#include maps/mp/_utility;
+#include common_scripts/utility;
+#include maps/mp/zombies/_zm_zonemgr;
+
+#using_animtree( "mechz_claw" );
+
+mechz_claw_detach()
+{
+	if ( isDefined( self.m_claw ) )
+	{
+		self.m_claw setanim( %ai_zombie_mech_grapple_arm_open_idle, 1, 0,2, 1 );
+		if ( isDefined( self.m_claw.fx_ent ) )
+		{
+			self.m_claw.fx_ent delete();
+		}
+		self.m_claw unlink();
+		self.m_claw physicslaunch( self.m_claw.origin, ( 0, 0, 0 ) );
+		self.m_claw thread mechz_delayed_item_delete();
+		self.m_claw = undefined;
+	}
+	if ( isDefined( self.m_claw_damage_trigger ) )
+	{
+		self.m_claw_damage_trigger unlink();
+		self.m_claw_damage_trigger delete();
+		self.m_claw_damage_trigger = undefined;
+	}
+}
+
+mechz_claw_release( bopenclaw )
+{
+	self.explosive_dmg_taken_on_grab_start = undefined;
+	if ( isDefined( self.e_grabbed ) )
+	{
+		if ( isplayer( self.e_grabbed ) )
+		{
+			self.e_grabbed setclientfieldtoplayer( "mechz_grab", 0 );
+			self.e_grabbed allowcrouch( 1 );
+			self.e_grabbed allowprone( 1 );
+		}
+		if ( !isDefined( self.e_grabbed._fall_down_anchor ) )
+		{
+			trace_start = self.e_grabbed.origin + vectorScale( ( 0, 0, 0 ), 70 );
+			trace_end = self.e_grabbed.origin + vectorScale( ( 0, 0, 0 ), 500 );
+			drop_trace = playerphysicstrace( trace_start, trace_end ) + vectorScale( ( 0, 0, 0 ), 24 );
+			self.e_grabbed unlink();
+			self.e_grabbed setorigin( drop_trace );
+		}
+		self.e_grabbed = undefined;
+		if ( isDefined( bopenclaw ) && bopenclaw )
+		{
+			self.m_claw setanim( %ai_zombie_mech_grapple_arm_open_idle, 1, 0,2, 1 );
+		}
+	}
+}
+
+mechz_claw_shot_pain_reaction()
+{
+	self mechz_interrupt();
+	self animscripted( self.origin, self.angles, "zm_head_pain" );
+	self maps/mp/animscripts/zm_shared::donotetracks( "head_pain_anim" );
+}
+
+ent_released_from_claw_grab_achievement( e_releaser, e_held_by_mechz )
+{
+	if ( isDefined( e_releaser ) && isDefined( e_held_by_mechz ) && isplayer( e_releaser ) && isplayer( e_held_by_mechz ) )
+	{
+		if ( e_releaser == e_held_by_mechz )
+		{
+			e_releaser notify( "mechz_grab_released_self" );
+			return;
+		}
+		else
+		{
+			e_releaser notify( "mechz_grab_released_friendly" );
+		}
+	}
+}
+
+mechz_claw_notetracks()
+{
+	self endon( "death" );
+	self endon( "kill_claw" );
+	self waittillmatch( "grapple_anim" );
+	return "muzzleflash";
+	self waittillmatch( "grapple_anim" );
+	return "end";
+}
+
+mechz_claw_aim( target_pos )
+{
+	self endon( "death" );
+	self endon( "kill_claw" );
+	self endon( "claw_complete" );
+	aim_anim = mechz_get_aim_anim( "zm_grapple", target_pos );
+	self animscripted( self.origin, self.angles, "zm_grapple_aim_start" );
+	self thread mechz_claw_notetracks();
+	self maps/mp/animscripts/zm_shared::donotetracks( "grapple_anim" );
+	while ( flag( "mechz_launching_claw" ) )
+	{
+		self animscripted( self.origin, self.angles, aim_anim );
+		self maps/mp/animscripts/zm_shared::donotetracks( "grapple_anim" );
+		self clearanim( %root, 0 );
+	}
+}
+
+player_can_be_grabbed()
+{
+	if ( self getstance() == "prone" && isDefined( self.is_dtp ) && self.is_dtp )
+	{
+		return 0;
+	}
+	if ( !is_player_valid( self, 1, 1 ) )
+	{
+		return 0;
+	}
+	return 1;
+}
+
+mechz_claw_explosive_watcher()
+{
+	if ( !isDefined( self.explosive_dmg_taken ) )
+	{
+		self.explosive_dmg_taken = 0;
+	}
+	self.explosive_dmg_taken_on_grab_start = self.explosive_dmg_taken;
+}
+
+mechz_unlink_on_laststand( mechz )
+{
+	self endon( "death" );
+	self endon( "disconnect" );
+	mechz endon( "death" );
+	mechz endon( "claw_complete" );
+	mechz endon( "kill_claw" );
+	while ( 1 )
+	{
+		if ( isDefined( self ) && self maps/mp/zombies/_zm_laststand::player_is_in_laststand() )
+		{
+			mechz thread mechz_claw_release();
+			return;
+		}
+		wait 0,05;
+	}
+}
+
+claw_grapple()
+{
+	self endon( "death" );
+	self endon( "kill_claw" );
+	if ( !isDefined( self.favoriteenemy ) )
+	{
+		return;
+	}
+	v_claw_origin = self gettagorigin( "tag_claw" );
+	v_claw_angles = vectorToAngle( self.origin - self.favoriteenemy.origin );
+	self.fx_field |= 256;
+	self setclientfield( "mechz_fx", self.fx_field );
+	self.m_claw setanim( %ai_zombie_mech_grapple_arm_open_idle, 1, 0, 1 );
+	self.m_claw unlink();
+	self.m_claw.fx_ent = spawn( "script_model", self.m_claw gettagorigin( "tag_claw" ) );
+	self.m_claw.fx_ent.angles = self.m_claw gettagangles( "tag_claw" );
+	self.m_claw.fx_ent setmodel( "tag_origin" );
+	self.m_claw.fx_ent linkto( self.m_claw, "tag_claw" );
+	network_safe_play_fx_on_tag( "mech_claw", 1, level._effect[ "mechz_claw" ], self.m_claw.fx_ent, "tag_origin" );
+	v_enemy_origin = self.favoriteenemy.origin + vectorScale( ( 0, 0, 0 ), 36 );
+	n_dist = distance( v_claw_origin, v_enemy_origin );
+	n_time = n_dist / 1200;
+	self playsound( "zmb_ai_mechz_claw_fire" );
+	self.m_claw moveto( v_enemy_origin, n_time );
+	self.m_claw thread check_for_claw_move_complete();
+	self.m_claw playloopsound( "zmb_ai_mechz_claw_loop_out", 0,1 );
+	self.e_grabbed = undefined;
+	a_players = getplayers();
+	_a260 = a_players;
+	_k260 = getFirstArrayKey( _a260 );
+	while ( isDefined( _k260 ) )
+	{
+		player = _a260[ _k260 ];
+		if ( !is_player_valid( player, 1, 1 ) || !player player_can_be_grabbed() )
+		{
+		}
+		else
+		{
+			n_dist_sq = distancesquared( player.origin + vectorScale( ( 0, 0, 0 ), 36 ), self.m_claw.origin );
+			if ( n_dist_sq < 2304 )
+			{
+				if ( isDefined( player.hasriotshield ) && player.hasriotshield && player getcurrentweapon() == level.riotshield_name )
+				{
+					shield_dmg = level.zombie_vars[ "riotshield_hit_points" ];
+					player maps/mp/zombies/_zm_weap_riotshield_tomb::player_damage_shield( shield_dmg - 1, 1 );
+					wait 1;
+					player maps/mp/zombies/_zm_weap_riotshield_tomb::player_damage_shield( 1, 1 );
+				}
+				else
+				{
+					self.e_grabbed = player;
+					self.e_grabbed setclientfieldtoplayer( "mechz_grab", 1 );
+					self.e_grabbed playerlinktodelta( self.m_claw, "tag_attach_player" );
+					self.e_grabbed setplayerangles( vectorToAngle( self.origin - self.e_grabbed.origin ) );
+					self.e_grabbed playsound( "zmb_ai_mechz_claw_grab" );
+					self.e_grabbed setstance( "stand" );
+					self.e_grabbed allowcrouch( 0 );
+					self.e_grabbed allowprone( 0 );
+					self.e_grabbed thread mechz_grabbed_played_vo( self );
+					if ( !flag( "mechz_claw_move_complete" ) )
+					{
+						self.m_claw moveto( self.m_claw.origin, 0,05 );
+					}
+				}
+				break;
+			}
+		}
+		else
+		{
+			_k260 = getNextArrayKey( _a260, _k260 );
+		}
+	}
+	wait 0,05;
+	if ( !flag( "mechz_claw_move_complete" ) && !isDefined( self.e_grabbed ) )
+	{
+		a_ai_zombies = get_round_enemy_array();
+		_a306 = a_ai_zombies;
+		_k306 = getFirstArrayKey( _a306 );
+		while ( isDefined( _k306 ) )
+		{
+			ai_zombie = _a306[ _k306 ];
+			if ( isalive( ai_zombie ) && isDefined( ai_zombie.is_giant_robot ) || ai_zombie.is_giant_robot && isDefined( ai_zombie.is_mechz ) && ai_zombie.is_mechz )
+			{
+			}
+			else
+			{
+				n_dist_sq = distancesquared( ai_zombie.origin + vectorScale( ( 0, 0, 0 ), 36 ), self.m_claw.origin );
+				if ( n_dist_sq < 2304 )
+				{
+					self.e_grabbed = ai_zombie;
+					self.e_grabbed linkto( self.m_claw, "tag_attach_player", ( 0, 0, 0 ) );
+					self.e_grabbed.mechz_grabbed_by = self;
+					self.e_grabbed animcustom( ::zombie_grabbed_by_mechz_claw );
+					break;
+				}
+			}
+			else
+			{
+				_k306 = getNextArrayKey( _a306, _k306 );
+			}
+		}
+	}
+	self.m_claw clearanim( %root, 0,2 );
+	self.m_claw setanim( %ai_zombie_mech_grapple_arm_closed_idle, 1, 0,2, 1 );
+	wait 0,5;
+	if ( isDefined( self.e_grabbed ) )
+	{
+		n_time = n_dist / 200;
+	}
+	else
+	{
+		n_time = n_dist / 1000;
+	}
+	self mechz_claw_explosive_watcher();
+	v_claw_origin = self gettagorigin( "tag_claw" );
+	v_claw_angles = self gettagangles( "tag_claw" );
+	self.m_claw moveto( v_claw_origin, max( 0,05, n_time ) );
+	self.m_claw playloopsound( "zmb_ai_mechz_claw_loop_in", 0,1 );
+	self.m_claw waittill( "movedone" );
+	v_claw_origin = self gettagorigin( "tag_claw" );
+	v_claw_angles = self gettagangles( "tag_claw" );
+	self.m_claw playsound( "zmb_ai_mechz_claw_back" );
+	self.m_claw stoploopsound( 1 );
+	if ( maps/mp/zombies/_zm_ai_mechz::sndmechzisnetworksafe( "angry" ) )
+	{
+		self playsound( "zmb_ai_mechz_vox_angry" );
+	}
+	self.m_claw.origin = v_claw_origin;
+	self.m_claw.angles = v_claw_angles;
+	self.m_claw clearanim( %root, 0,2 );
+	self.m_claw linkto( self, "tag_claw", ( 0, 0, 0 ) );
+	self.m_claw setanim( %ai_zombie_mech_grapple_arm_closed_idle, 1, 0,2, 1 );
+	self.m_claw.fx_ent delete();
+	self.m_claw.fx_ent = undefined;
+	self.fx_field &= 256;
+	self setclientfield( "mechz_fx", self.fx_field );
+	flag_clear( "mechz_launching_claw" );
+	if ( isDefined( self.e_grabbed ) )
+	{
+		if ( !isDefined( self.flamethrower_trigger ) )
+		{
+			self mechz_flamethrower_initial_setup();
+		}
+		if ( isplayer( self.e_grabbed ) && is_player_valid( self.e_grabbed ) )
+		{
+			self.e_grabbed thread mechz_unlink_on_laststand( self );
+		}
+		else
+		{
+			if ( isai( self.e_grabbed ) )
+			{
+				self.e_grabbed thread mechz_zombie_flamethrower_gib( self );
+			}
+		}
+		self thread check_for_claw_damaged( self.e_grabbed );
+		self animscripted( self.origin, self.angles, "zm_flamethrower_claw_victim" );
+		self maps/mp/animscripts/zm_shared::donotetracks( "flamethrower_anim" );
+	}
+	flag_clear( "mechz_claw_move_complete" );
+}
+
+zombie_grabbed_by_mechz_claw()
+{
+	self endon( "death" );
+	self setanimstatefromasd( "zm_grabbed_by_mech" );
+	self.mechz_grabbed_by waittill_any( "death", "claw_complete", "kill_claw" );
+}
+
+check_for_claw_damaged( player )
+{
+	player endon( "death" );
+	player endon( "disconnect" );
+	self endon( "death" );
+	self endon( "claw_complete" );
+	self endon( "kill_claw" );
+	self thread claw_damaged_mechz_endon_watcher( player );
+	player thread claw_damaged_player_endon_watcher( self );
+	self.m_claw setcandamage( 1 );
+	while ( isDefined( self.e_grabbed ) )
+	{
+		self.m_claw waittill( "damage", amount, inflictor, direction, point, type, tagname, modelname, partname, weaponname, idflags );
+		if ( is_player_valid( inflictor ) )
+		{
+			self dodamage( 1, inflictor.origin, inflictor, inflictor, "left_hand", type );
+			self.m_claw setcandamage( 0 );
+			self notify( "claw_damaged" );
+			return;
+		}
+		else
+		{
+		}
+	}
+}
+
+claw_damaged_mechz_endon_watcher( player )
+{
+	self endon( "claw_damaged" );
+	player endon( "death" );
+	player endon( "disconnect" );
+	self waittill_any( "death", "claw_complete", "kill_claw" );
+	if ( isDefined( self ) && isDefined( self.m_claw ) )
+	{
+		self.m_claw setcandamage( 0 );
+	}
+}
+
+claw_damaged_player_endon_watcher( mechz )
+{
+	mechz endon( "claw_damaged" );
+	mechz endon( "death" );
+	mechz endon( "claw_complete" );
+	mechz endon( "kill_claw" );
+	self waittill_any( "death", "disconnect" );
+	if ( isDefined( mechz ) && isDefined( mechz.m_claw ) )
+	{
+		mechz.m_claw setcandamage( 0 );
+	}
+}
+
+check_for_players_mid_grapple()
+{
+	self endon( "movedone" );
+	while ( 1 )
+	{
+		a_players = getplayers();
+		_a471 = a_players;
+		_k471 = getFirstArrayKey( _a471 );
+		while ( isDefined( _k471 ) )
+		{
+			player = _a471[ _k471 ];
+			if ( !is_player_valid( player, 1, 1 ) || !player player_can_be_grabbed() )
+			{
+			}
+			else
+			{
+				n_dist_sq = distancesquared( player.origin + vectorScale( ( 0, 0, 0 ), 36 ), self.origin );
+				if ( n_dist_sq < 2304 )
+				{
+					self moveto( self.origin, 0,05 );
+					self notify( "movedone" );
+					return;
+				}
+			}
+			_k471 = getNextArrayKey( _a471, _k471 );
+		}
+		wait 0,05;
+	}
+}
+
+check_for_claw_move_complete()
+{
+	self waittill( "movedone" );
+	wait 0,05;
+	flag_set( "mechz_claw_move_complete" );
+}
+
+mechz_zombie_flamethrower_gib( mechz )
+{
+	mechz waittillmatch( "flamethrower_anim" );
+	return "start_ft";
+	if ( isalive( self ) )
+	{
+		self thread zombie_gib_all();
+		self dodamage( self.health, self.origin, self );
+	}
+}
+
+should_do_claw_attack()
+{
+/#
+	assert( isDefined( self.favoriteenemy ) );
+#/
+/#
+	if ( getDvarInt( #"E7121222" ) > 1 )
+	{
+		println( "\n\tMZ: Checking should claw\n" );
+#/
+	}
+	if ( isDefined( self.has_powerplant ) && !self.has_powerplant )
+	{
+/#
+		if ( getDvarInt( #"E7121222" ) > 1 )
+		{
+			println( "\n\t\tMZ: Not doing claw because powerplant has been destroyed\n" );
+#/
+		}
+		return 0;
+	}
+	if ( isDefined( self.disable_complex_behaviors ) && self.disable_complex_behaviors )
+	{
+/#
+		if ( getDvarInt( #"E7121222" ) > 1 )
+		{
+			println( "\n\t\tMZ: Not doing claw because doing force aggro\n" );
+#/
+		}
+		return 0;
+	}
+	if ( isDefined( self.not_interruptable ) && self.not_interruptable )
+	{
+/#
+		if ( getDvarInt( #"E7121222" ) > 1 )
+		{
+			println( "\n\t\tMZ: Not doing claw because another behavior has set not_interruptable\n" );
+#/
+		}
+		return 0;
+	}
+	if ( isDefined( self.last_claw_time ) && ( getTime() - self.last_claw_time ) < level.mechz_claw_cooldown_time )
+	{
+/#
+		if ( getDvarInt( #"E7121222" ) > 1 )
+		{
+			println( "\n\t\tMZ: Not doing claw because claw is on cooldown\n" );
+#/
+		}
+		return 0;
+	}
+	if ( !self mechz_check_in_arc() )
+	{
+/#
+		if ( getDvarInt( #"E7121222" ) > 1 )
+		{
+			println( "\n\t\tMZ: Not doing claw because target is not in front arc\n" );
+#/
+		}
+		return 0;
+	}
+	n_dist_sq = distancesquared( self.origin, self.favoriteenemy.origin );
+	if ( n_dist_sq < 90000 || n_dist_sq > 1000000 )
+	{
+/#
+		if ( getDvarInt( #"E7121222" ) > 1 )
+		{
+			println( "\n\t\tMZ: Not doing claw because target is not in range\n" );
+#/
+		}
+		return 0;
+	}
+	if ( !self.favoriteenemy player_can_be_grabbed() )
+	{
+/#
+		if ( getDvarInt( #"E7121222" ) > 1 )
+		{
+			println( "\n\t\tMZ: Not doing claw because player is prone or dtp\n" );
+#/
+		}
+		return 0;
+	}
+	curr_zone = get_zone_from_position( self.origin + vectorScale( ( 0, 0, 0 ), 36 ) );
+	if ( isDefined( curr_zone ) && curr_zone == "ug_bottom_zone" )
+	{
+/#
+		if ( getDvarInt( #"E7121222" ) > 1 )
+		{
+			println( "\n\t\tMZ: Not doing claw because mech is in main chamber\n" );
+#/
+		}
+		return 0;
+	}
+	clip_mask = level.physicstracemaskclip | level.physicstracemaskphysics;
+	claw_origin = self.origin + vectorScale( ( 0, 0, 0 ), 65 );
+	trace = physicstrace( claw_origin, self.favoriteenemy.origin + vectorScale( ( 0, 0, 0 ), 30 ), ( -15, -15, -20 ), ( 15, 15, 40 ), self, clip_mask );
+	if ( trace[ "fraction" ] != 1 )
+	{
+		if ( isDefined( trace[ "entity" ] ) )
+		{
+			b_cansee = trace[ "entity" ] == self.favoriteenemy;
+		}
+	}
+	if ( !b_cansee )
+	{
+/#
+		if ( getDvarInt( #"E7121222" ) > 1 )
+		{
+			println( "\n\t\tMZ: Not doing claw because capsule trace failed\n" );
+#/
+		}
+		return 0;
+	}
+	return 1;
+}
+
+mechz_do_claw_grab()
+{
+	self endon( "death" );
+	self endon( "kill_claw" );
+/#
+	if ( getDvarInt( #"E7121222" ) > 0 )
+	{
+		println( "\n\tMZ: Doing Claw Attack\n" );
+#/
+	}
+/#
+	assert( isDefined( self.favoriteenemy ) );
+#/
+	self thread mechz_kill_claw_watcher();
+	self.last_claw_time = getTime();
+	target_pos = self.favoriteenemy.origin + vectorScale( ( 0, 0, 0 ), 30 );
+	self thread mechz_stop_basic_find_flesh();
+	self.ai_state = "grapple_attempt";
+	flag_set( "mechz_launching_claw" );
+	self thread mechz_claw_aim( target_pos );
+	self orientmode( "face enemy" );
+	self waittillmatch( "grapple_anim" );
+	return "muzzleflash";
+	self claw_grapple();
+	self mechz_claw_cleanup();
+}
+
+mechz_kill_claw_watcher()
+{
+	self endon( "claw_complete" );
+	self waittill_either( "death", "kill_claw" );
+	self mechz_claw_cleanup();
+}
+
+mechz_claw_cleanup()
+{
+	self.fx_field &= 256;
+	self.fx_field &= 64;
+	self setclientfield( "mechz_fx", self.fx_field );
+	self mechz_claw_release();
+	if ( isDefined( self.m_claw ) )
+	{
+		self.m_claw clearanim( %root, 0,2 );
+		if ( isDefined( self.m_claw.fx_ent ) )
+		{
+			self.m_claw.fx_ent delete();
+			self.m_claw.fx_ent = undefined;
+		}
+		if ( isDefined( self.has_powerplant ) && !self.has_powerplant )
+		{
+			self mechz_claw_detach();
+			flag_clear( "mechz_launching_claw" );
+		}
+		else
+		{
+			if ( !self.m_claw islinkedto( self ) )
+			{
+				v_claw_origin = self gettagorigin( "tag_claw" );
+				v_claw_angles = self gettagangles( "tag_claw" );
+				n_dist = distance( self.m_claw.origin, v_claw_origin );
+				n_time = n_dist / 1000;
+				self.m_claw moveto( v_claw_origin, max( 0,05, n_time ) );
+				self.m_claw playloopsound( "zmb_ai_mechz_claw_loop_in", 0,1 );
+				self.m_claw waittill( "movedone" );
+				v_claw_origin = self gettagorigin( "tag_claw" );
+				v_claw_angles = self gettagangles( "tag_claw" );
+				self.m_claw playsound( "zmb_ai_mechz_claw_back" );
+				self.m_claw stoploopsound( 1 );
+				self.m_claw.origin = v_claw_origin;
+				self.m_claw.angles = v_claw_angles;
+				self.m_claw clearanim( %root, 0,2 );
+				self.m_claw linkto( self, "tag_claw", ( 0, 0, 0 ) );
+			}
+			self.m_claw setanim( %ai_zombie_mech_grapple_arm_closed_idle, 1, 0,2, 1 );
+		}
+	}
+	self notify( "claw_complete" );
+}
+
+mechz_claw_damage_trigger_thread()
+{
+	self endon( "death" );
+	self.m_claw_damage_trigger endon( "death" );
+	while ( 1 )
+	{
+		self.m_claw_damage_trigger waittill( "damage", amount, inflictor, direction, point, type, tagname, modelname, partname, weaponname, idflags );
+		while ( self.m_claw islinkedto( self ) )
+		{
+			continue;
+		}
+		if ( is_player_valid( inflictor ) )
+		{
+			self dodamage( 1, inflictor.origin, inflictor, inflictor, "left_hand", type );
+			self.m_claw setcandamage( 0 );
+			self notify( "claw_damaged" );
+		}
+	}
+}

zm_tomb_patch/maps/mp/zombies/_zm_ai_mechz_dev.gsc

@@ -0,0 +1,505 @@
+#include maps/mp/animscripts/zm_shared;
+#include maps/mp/zombies/_zm_ai_mechz;
+#include maps/mp/animscripts/zm_utility;
+#include maps/mp/zombies/_zm_net;
+#include maps/mp/zombies/_zm_utility;
+#include maps/mp/_utility;
+#include common_scripts/utility;
+
+#using_animtree( "mechz_claw" );
+
+mechz_debug()
+{
+/#
+	while ( 1 )
+	{
+		debug_level = getDvarInt( #"E7121222" );
+		while ( isDefined( debug_level ) && debug_level )
+		{
+			while ( debug_level == 1 )
+			{
+				mechz_array = getentarray( "mechz_zombie_ai" );
+				i = 0;
+				while ( i < mechz_array.size )
+				{
+					if ( isDefined( mechz_array[ i ].goal_pos ) )
+					{
+						debugstar( mechz_array[ i ].goal_pos, ( 0, 0, 1 ), 1 );
+						line( mechz_array[ i ].goal_pos, mechz_array[ i ].origin, ( 0, 0, 1 ), 0, 1 );
+					}
+					i++;
+				}
+			}
+		}
+#/
+	}
+}
+
+setup_devgui()
+{
+/#
+	setdvar( "spawn_Mechz", "off" );
+	setdvar( "force_mechz_jump", "off" );
+	setdvar( "test_mechz_tank", "off" );
+	setdvar( "test_mechz_robot", "off" );
+	setdvar( "reset_mechz_thinking", "off" );
+	setdvar( "test_mechz_sprint", "off" );
+	setdvar( "mechz_force_behavior", "none" );
+	setdvarint( "mechz_behavior_orient", 0 );
+	setdvarint( "mechz_behavior_dist", 300 );
+	adddebugcommand( "devgui_cmd "Zombies/Zombie Spawning:2/Spawn Zombie:1/Mech Zombie:1" "spawn_Mechz on"\n" );
+	adddebugcommand( "devgui_cmd "Zombies/MechZ:3/Force Behavior:1/Jump In:1" "mechz_force_behavior jump_in"\n" );
+	adddebugcommand( "devgui_cmd "Zombies/MechZ:3/Force Behavior:1/Jump Out:2" "mechz_force_behavior jump_out"\n" );
+	adddebugcommand( "devgui_cmd "Zombies/MechZ:3/Force Behavior:1/Flamethrower:3" "mechz_force_behavior flamethrower"\n" );
+	adddebugcommand( "devgui_cmd "Zombies/MechZ:3/Force Behavior:1/Damage Armor:4" "mechz_force_behavior damage_armor"\n" );
+	adddebugcommand( "devgui_cmd "Zombies/MechZ:3/Force Behavior:1/Damage Faceplate:5" "mechz_force_behavior damage_faceplate"\n" );
+	adddebugcommand( "devgui_cmd "Zombies/MechZ:3/Force Behavior:1/Claw Attack:5" "mechz_force_behavior claw_attack"\n" );
+	adddebugcommand( "devgui_cmd "Zombies/MechZ:3/Force Behavior:1/Melee:6" "mechz_force_behavior melee"\n" );
+	adddebugcommand( "devgui_cmd "Zombies/MechZ:3/Force Behavior:1/Angles:7/zero degrees:1" "mechz_behavior_orient 0"\n" );
+	adddebugcommand( "devgui_cmd "Zombies/MechZ:3/Force Behavior:1/Angles:7/forty-five degrees:2" "mechz_behavior_orient 45"\n" );
+	adddebugcommand( "devgui_cmd "Zombies/MechZ:3/Force Behavior:1/Angles:7/ninety degrees:3" "mechz_behavior_orient 90"\n" );
+	adddebugcommand( "devgui_cmd "Zombies/MechZ:3/Force Behavior:1/Angles:7/one thirty five degrees:4" "mechz_behavior_orient 135"\n" );
+	adddebugcommand( "devgui_cmd "Zombies/MechZ:3/Force Behavior:1/Angles:7/one eighty degrees:5" "mechz_behavior_orient 180"\n" );
+	adddebugcommand( "devgui_cmd "Zombies/MechZ:3/Force Behavior:1/Angles:7/two twenty five degrees:6" "mechz_behavior_orient 225"\n" );
+	adddebugcommand( "devgui_cmd "Zombies/MechZ:3/Force Behavior:1/Angles:7/two seventy degrees:7" "mechz_behavior_orient 270"\n" );
+	adddebugcommand( "devgui_cmd "Zombies/MechZ:3/Force Behavior:1/Angles:7/three fifteen degrees:8" "mechz_behavior_orient 315"\n" );
+	adddebugcommand( "devgui_cmd "Zombies/MechZ:3/Force Behavior:1/Distance:8/one hundred:1" "mechz_behavior_dist 100"\n" );
+	adddebugcommand( "devgui_cmd "Zombies/MechZ:3/Force Behavior:1/Distance:8/two hundred:2" "mechz_behavior_dist 200"\n" );
+	adddebugcommand( "devgui_cmd "Zombies/MechZ:3/Force Behavior:1/Distance:8/three hundred:3" "mechz_behavior_dist 300"\n" );
+	adddebugcommand( "devgui_cmd "Zombies/MechZ:3/Force Behavior:1/Distance:8/four hundred:4" "mechz_behavior_dist 400"\n" );
+	adddebugcommand( "devgui_cmd "Zombies/MechZ:3/Force Behavior:1/Distance:8/five hundred:5" "mechz_behavior_dist 500"\n" );
+	adddebugcommand( "devgui_cmd "Zombies/MechZ:3/Test Tank Knockdown:2" "test_mechz_tank on"\n" );
+	adddebugcommand( "devgui_cmd "Zombies/MechZ:3/Test Robot Knockdown:3" "test_mechz_robot on"\n" );
+	adddebugcommand( "devgui_cmd "Zombies/MechZ:3/Test Sprint:4" "test_mechz_sprint on"\n" );
+	adddebugcommand( "devgui_cmd "Zombies/MechZ:3/Reset Mech:5" "reset_mechz_thinking on"\n" );
+	level thread watch_devgui_mechz();
+#/
+}
+
+watch_devgui_mechz()
+{
+/#
+	while ( 1 )
+	{
+		if ( getDvar( "spawn_Mechz" ) == "on" )
+		{
+			mechz_health_increases();
+			level.mechz_left_to_spawn = 1;
+			if ( getDvarInt( "zombie_cheat" ) >= 2 )
+			{
+				level.round_number++;
+			}
+			level notify( "spawn_mechz" );
+			setdvar( "spawn_Mechz", "off" );
+			level.mechz_last_spawn_round = 0;
+		}
+		if ( getDvar( "mechz_force_behavior" ) != "none" )
+		{
+			behavior = getDvar( "mechz_force_behavior" );
+			zombies = getaiarray( "axis" );
+			i = 0;
+			while ( i < zombies.size )
+			{
+				if ( isDefined( zombies[ i ].is_mechz ) && zombies[ i ].is_mechz )
+				{
+					zombies[ i ] thread mechz_force_behavior( behavior );
+				}
+				i++;
+			}
+			setdvar( "mechz_force_behavior", "none" );
+		}
+		if ( getDvar( "test_mechz_tank" ) == "on" )
+		{
+			setdvar( "test_mechz_tank", "off" );
+			mechz = undefined;
+			zombies = getaiarray( "axis" );
+			i = 0;
+			while ( i < zombies.size )
+			{
+				if ( isDefined( zombies[ i ].is_mechz ) && zombies[ i ].is_mechz )
+				{
+					mechz = zombies[ i ];
+				}
+				i++;
+			}
+			while ( !isDefined( mechz ) )
+			{
+				continue;
+			}
+			mechz.not_interruptable = 1;
+			mechz mechz_stop_basic_find_flesh();
+			mechz.ai_state = "devgui";
+			mechz.goal_pos = ( 446, -4318, 200 );
+			mechz setgoalpos( mechz.goal_pos );
+		}
+		if ( getDvar( "test_mechz_robot" ) == "on" )
+		{
+			setdvar( "test_mechz_robot", "off" );
+			mechz = undefined;
+			zombies = getaiarray( "axis" );
+			i = 0;
+			while ( i < zombies.size )
+			{
+				if ( isDefined( zombies[ i ].is_mechz ) && zombies[ i ].is_mechz )
+				{
+					mechz = zombies[ i ];
+				}
+				i++;
+			}
+			while ( !isDefined( mechz ) )
+			{
+				continue;
+			}
+			mechz.not_interruptable = 1;
+			mechz mechz_stop_basic_find_flesh();
+			mechz.ai_state = "devgui";
+			mechz.goal_pos = ( 1657, -336, 92 );
+			mechz setgoalpos( mechz.goal_pos );
+		}
+		while ( getDvar( "test_mechz_sprint" ) == "on" )
+		{
+			setdvar( "test_mechz_sprint", "off" );
+			zombies = getaiarray( "axis" );
+			i = 0;
+			while ( i < zombies.size )
+			{
+				if ( isDefined( zombies[ i ].is_mechz ) && zombies[ i ].is_mechz )
+				{
+					zombies[ i ].force_sprint = 1;
+				}
+				i++;
+			}
+		}
+		while ( getDvar( "reset_mechz_thinking" ) == "on" )
+		{
+			setdvar( "reset_mechz_thinking", "off" );
+			zombies = getaiarray( "axis" );
+			i = 0;
+			while ( i < zombies.size )
+			{
+				if ( isDefined( zombies[ i ].is_mechz ) && zombies[ i ].is_mechz )
+				{
+					zombies[ i ].not_interruptable = 0;
+					zombies[ i ].force_sprint = 0;
+				}
+				i++;
+			}
+		}
+		wait 0,1;
+#/
+	}
+}
+
+mechz_force_behavior( behavior )
+{
+/#
+	self notify( "kill_force_behavior" );
+	self thread mechz_stop_basic_find_flesh();
+	self.ignoreall = 1;
+	self.force_behavior = 1;
+	if ( behavior == "jump_in" )
+	{
+		self thread mechz_force_jump_in();
+	}
+	if ( behavior == "jump_out" )
+	{
+		self thread mechz_force_jump_out();
+	}
+	if ( behavior == "flamethrower" )
+	{
+		self thread mechz_force_flamethrower();
+	}
+	if ( behavior == "claw_attack" )
+	{
+		self thread mechz_force_claw_attack();
+	}
+	if ( behavior == "damage_armor" )
+	{
+		self thread mechz_force_damage_armor();
+	}
+	if ( behavior == "damage_faceplate" )
+	{
+		self thread mechz_force_damage_faceplate();
+	}
+	if ( behavior == "melee" )
+	{
+		self thread mechz_force_melee();
+	}
+	if ( behavior == "none" )
+	{
+		self.ignoreall = 0;
+		self.force_behavior = 0;
+		self notify( "kill_force_behavior" );
+#/
+	}
+}
+
+get_behavior_orient()
+{
+/#
+	behavior_orient = getDvarInt( #"2F660A7B" );
+	return level.players[ 0 ].angles + vectorScale( ( 0, 0, 1 ), 180 ) + ( 0, behavior_orient, 0 );
+#/
+}
+
+setup_force_behavior()
+{
+/#
+	if ( !isDefined( level.test_align_struct ) )
+	{
+		player = get_players()[ 0 ];
+		pos = player.origin;
+		offset = anglesToForward( player.angles );
+		offset = vectornormalize( offset );
+		level.test_align_struct = spawn( "script_model", pos + ( 300 * offset ) );
+		level.test_align_struct setmodel( "tag_origin" );
+		level.test_align_struct.angles = player.angles + vectorScale( ( 0, 0, 1 ), 180 );
+		level.test_align_struct thread align_test_struct();
+		level.test_align_struct.angles = player.angles + vectorScale( ( 0, 0, 1 ), 180 );
+	}
+	self linkto( level.test_align_struct, "tag_origin", ( 0, 0, 1 ), ( 0, 0, 1 ) );
+	self.fx_field &= 64;
+	self.fx_field &= 128;
+	self.fx_field &= 256;
+#/
+}
+
+align_test_struct()
+{
+/#
+	while ( 1 )
+	{
+		pos = level.players[ 0 ].origin;
+		offset = anglesToForward( level.players[ 0 ].angles );
+		offset = vectornormalize( offset );
+		dist = getDvarInt( #"6DCD047E" );
+		level.test_align_struct.origin = pos + ( dist * offset );
+		level.test_align_struct.angles = get_behavior_orient();
+		wait 0,05;
+#/
+	}
+}
+
+scripted_behavior( anim_scripted_name, notify_name )
+{
+/#
+	self animscripted( level.test_align_struct.origin, level.test_align_struct.angles, anim_scripted_name );
+	self maps/mp/animscripts/zm_shared::donotetracks( notify_name );
+#/
+}
+
+mechz_force_jump_in()
+{
+/#
+	self endon( "kill_force_behavior" );
+	self setup_force_behavior();
+	while ( 1 )
+	{
+		self animscripted( self.origin, self.angles, "zm_idle" );
+		wait 0,2;
+		self scripted_behavior( "zm_spawn", "jump_anim" );
+#/
+	}
+}
+
+mechz_force_jump_out()
+{
+/#
+	self endon( "kill_force_behavior" );
+	self setup_force_behavior();
+	while ( 1 )
+	{
+		self animscripted( self.origin, self.angles, "zm_idle" );
+		wait 0,2;
+		self scripted_behavior( "zm_fly_out", "jump_anim" );
+		self ghost();
+		self animscripted( self.origin, self.angles, "zm_fly_hover" );
+		wait level.mechz_jump_delay;
+		self show();
+		self scripted_behavior( "zm_fly_in", "jump_anim" );
+#/
+	}
+}
+
+mechz_force_flamethrower()
+{
+/#
+	self endon( "kill_force_behavior" );
+	self setup_force_behavior();
+	curr_aim_anim = 1;
+	curr_timer = 0;
+	self animscripted( self.origin, self.angles, "zm_idle" );
+	wait 0,2;
+	self scripted_behavior( "zm_flamethrower_aim_start", "flamethrower_anim" );
+	while ( 1 )
+	{
+		if ( curr_timer > 3 )
+		{
+			curr_aim_anim++;
+			curr_timer = 0;
+			if ( curr_aim_anim < 10 )
+			{
+				iprintln( "Testing aim_" + curr_aim_anim );
+			}
+		}
+		if ( curr_aim_anim >= 10 )
+		{
+			iprintln( "Testing flamethrower sweep" );
+			curr_aim_anim = 1;
+			self scripted_behavior( "zm_flamethrower_sweep", "flamethrower_anim" );
+			self.fx_field |= 64;
+			self setclientfield( "mechz_fx", self.fx_field );
+			continue;
+		}
+		else
+		{
+			length = self getanimlengthfromasd( "zm_flamethrower_aim_" + curr_aim_anim, 0 );
+			self clearanim( %root, 0 );
+			self scripted_behavior( "zm_flamethrower_aim_" + curr_aim_anim, "flamethrower_anim" );
+			curr_timer += length;
+		}
+#/
+	}
+}
+
+fake_launch_claw()
+{
+/#
+	self.launching_claw = 1;
+	v_claw_origin = self gettagorigin( "tag_claw" );
+	v_claw_angles = vectorToAngle( self.origin - level.players[ 0 ].origin );
+	self.fx_field |= 256;
+	self setclientfield( "mechz_fx", self.fx_field );
+	self.m_claw setanim( %ai_zombie_mech_grapple_arm_open_idle, 1, 0, 1 );
+	self.m_claw unlink();
+	self.m_claw.fx_ent = spawn( "script_model", self.m_claw gettagorigin( "tag_claw" ) );
+	self.m_claw.fx_ent.angles = self.m_claw gettagangles( "tag_claw" );
+	self.m_claw.fx_ent setmodel( "tag_origin" );
+	self.m_claw.fx_ent linkto( self.m_claw, "tag_claw" );
+	network_safe_play_fx_on_tag( "mech_claw", 1, level._effect[ "mechz_claw" ], self.m_claw.fx_ent, "tag_origin" );
+	self.m_claw clearanim( %root, 0,2 );
+	self.m_claw setanim( %ai_zombie_mech_grapple_arm_open_idle, 1, 0,2, 1 );
+	offset = anglesToForward( self.angles );
+	offset = vectornormalize( offset );
+	target_pos = self.origin + ( offset * 500 ) + vectorScale( ( 0, 0, 1 ), 36 );
+	n_time = 0,08333334;
+	self.m_claw moveto( target_pos, n_time );
+	self.m_claw waittill( "movedone" );
+	self.m_claw clearanim( %root, 0,2 );
+	self.m_claw setanim( %ai_zombie_mech_grapple_arm_closed_idle, 1, 0,2, 1 );
+	wait 0,5;
+	self.m_claw moveto( v_claw_origin, 0,5 );
+	self.m_claw waittill( "movedone" );
+	self.m_claw.fx_ent delete();
+	self.fx_field &= 256;
+	self setclientfield( "mechz_fx", self.fx_field );
+	v_claw_origin = self gettagorigin( "tag_claw" );
+	v_claw_angles = self gettagangles( "tag_claw" );
+	self.m_claw.origin = v_claw_origin;
+	self.m_claw.angles = v_claw_angles;
+	self.m_claw linkto( self, "tag_claw" );
+	self.launching_claw = 0;
+#/
+}
+
+mechz_force_claw_attack()
+{
+/#
+	self endon( "kill_force_behavior" );
+	self setup_force_behavior();
+	while ( 1 )
+	{
+		self animscripted( self.origin, self.angles, "zm_idle" );
+		wait 0,2;
+		self scripted_behavior( "zm_grapple_aim_start", "grapple_anim" );
+		self thread fake_launch_claw();
+		while ( isDefined( self.launching_claw ) && self.launching_claw )
+		{
+			self clearanim( %root, 0 );
+			wait 0,05;
+			self scripted_behavior( "zm_grapple_aim_5", "grapple_anim" );
+		}
+		self scripted_behavior( "zm_flamethrower_claw_victim", "flamethrower_anim" );
+#/
+	}
+}
+
+mechz_force_damage_armor()
+{
+/#
+	self endon( "kill_force_behavior" );
+	self setup_force_behavior();
+	if ( !isDefined( self.next_armor_piece ) )
+	{
+		self.next_armor_piece = 0;
+	}
+	self thread scripted_behavior( "zm_idle", "idle_anim" );
+	if ( self.next_armor_piece == self.armor_state.size )
+	{
+		self.next_armor_piece = 0;
+		i = 0;
+		while ( i < self.armor_state.size )
+		{
+			self.fx_field &= 1 << self.armor_state[ i ].index;
+			if ( isDefined( self.armor_state[ i ].model ) )
+			{
+				self attach( self.armor_state[ i ].model, self.armor_state[ i ].tag );
+			}
+			i++;
+		}
+	}
+	else self.fx_field |= 1 << self.armor_state[ self.next_armor_piece ].index;
+	if ( isDefined( self.armor_state[ self.next_armor_piece ].model ) )
+	{
+		self detach( self.armor_state[ self.next_armor_piece ].model, self.armor_state[ self.next_armor_piece ].tag );
+	}
+	self.next_armor_piece++;
+	self setclientfield( "mechz_fx", self.fx_field );
+	while ( 1 )
+	{
+		self scripted_behavior( "zm_idle", "idle_anim" );
+#/
+	}
+}
+
+mechz_force_damage_faceplate()
+{
+/#
+	self endon( "kill_force_behavior" );
+	self setup_force_behavior();
+	self thread scripted_behavior( "zm_idle", "idle_anim" );
+	if ( isDefined( self.has_helmet ) && self.has_helmet )
+	{
+		self.has_helmet = 0;
+		self detach( "c_zom_mech_faceplate", "J_Helmet" );
+		self.fx_field |= 1024;
+		self.fx_field &= 2048;
+	}
+	else
+	{
+		self.has_helmet = 1;
+		self.fx_field &= 1024;
+		self.fx_field |= 2048;
+		self attach( "c_zom_mech_faceplate", "J_Helmet" );
+	}
+	self setclientfield( "mechz_fx", self.fx_field );
+	while ( 1 )
+	{
+		self scripted_behavior( "zm_idle", "idle_anim" );
+#/
+	}
+}
+
+mechz_force_melee()
+{
+/#
+	self endon( "kill_force_behavior" );
+	self setup_force_behavior();
+	while ( 1 )
+	{
+		self animscripted( self.origin, self.angles, "zm_idle" );
+		wait 0,2;
+		self scripted_behavior( "zm_melee_stand", "melee_anim" );
+#/
+	}
+}

zm_tomb_patch/maps/mp/zombies/_zm_ai_mechz_ffotd.gsc

@@ -0,0 +1,33 @@
+#include maps/mp/zombies/_zm_utility;
+#include maps/mp/_utility;
+#include common_scripts/utility;
+
+mechz_init_start()
+{
+}
+
+mechz_init_end()
+{
+}
+
+spawn_start()
+{
+	self.not_interruptable = 1;
+}
+
+spawn_end()
+{
+	self.not_interruptable = 0;
+}
+
+mechz_round_tracker_start()
+{
+}
+
+mechz_round_tracker_loop_start()
+{
+}
+
+mechz_round_tracker_loop_end()
+{
+}

zm_tomb_patch/maps/mp/zombies/_zm_ai_mechz_ft.gsc

@@ -0,0 +1,589 @@
+#include maps/mp/_visionset_mgr;
+#include maps/mp/animscripts/zm_shared;
+#include maps/mp/zombies/_zm_ai_mechz;
+#include maps/mp/zombies/_zm_ai_mechz_dev;
+#include maps/mp/zm_tomb_tank;
+#include maps/mp/animscripts/zm_utility;
+#include maps/mp/zombies/_zm_utility;
+#include maps/mp/zombies/_zm_net;
+#include maps/mp/_utility;
+#include common_scripts/utility;
+#include maps/mp/zombies/_zm_zonemgr;
+
+#using_animtree( "mechz_claw" );
+
+init_flamethrower_triggers()
+{
+	flag_wait( "initial_players_connected" );
+	level.flamethrower_trigger_array = getentarray( "flamethrower_trigger", "script_noteworthy" );
+/#
+	if ( isDefined( level.flamethrower_trigger_array ) )
+	{
+		assert( level.flamethrower_trigger_array.size >= 4 );
+	}
+#/
+	i = 0;
+	while ( i < level.flamethrower_trigger_array.size )
+	{
+		level.flamethrower_trigger_array[ i ] enablelinkto();
+		i++;
+	}
+}
+
+mechz_flamethrower_initial_setup()
+{
+	self endon( "death" );
+	if ( isDefined( self.flamethrower_trigger ) )
+	{
+		self release_flamethrower_trigger();
+	}
+	self.flamethrower_trigger = get_flamethrower_trigger();
+	if ( !isDefined( self.flamethrower_trigger ) )
+	{
+/#
+		println( "Error: No free flamethrower triggers! Make sure you haven't spawned more than 4 mech zombies" );
+#/
+		return;
+	}
+	self.flamethrower_trigger.origin = self gettagorigin( "tag_flamethrower_FX" );
+	self.flamethrower_trigger.angles = self gettagangles( "tag_flamethrower_FX" );
+	self.flamethrower_trigger linkto( self, "tag_flamethrower_FX" );
+	self thread mechz_watch_for_flamethrower_damage();
+}
+
+get_flamethrower_trigger()
+{
+	i = 0;
+	while ( i < level.flamethrower_trigger_array.size )
+	{
+		if ( isDefined( level.flamethrower_trigger_array[ i ].in_use ) && !level.flamethrower_trigger_array[ i ].in_use )
+		{
+			level.flamethrower_trigger_array[ i ].in_use = 1;
+			level.flamethrower_trigger_array[ i ].original_position = level.flamethrower_trigger_array[ i ].origin;
+			return level.flamethrower_trigger_array[ i ];
+		}
+		i++;
+	}
+	return undefined;
+}
+
+release_flamethrower_trigger()
+{
+	if ( !isDefined( self.flamethrower_trigger ) )
+	{
+		return;
+	}
+	self.flamethrower_trigger.in_use = 0;
+	self.flamethrower_trigger unlink();
+	self.flamethrower_trigger.origin = self.flamethrower_trigger.original_position;
+	self.flamethrower_linked = 0;
+	self.flamethrower_trigger = undefined;
+}
+
+mechz_flamethrower_dist_watcher()
+{
+	self endon( "kill_ft" );
+	wait 0,5;
+	while ( 1 )
+	{
+		if ( isDefined( self.favoriteenemy ) || !is_player_valid( self.favoriteenemy, 1, 1 ) && distancesquared( self.origin, self.favoriteenemy.origin ) > 50000 )
+		{
+			self notify( "stop_ft" );
+			return;
+		}
+		wait 0,05;
+	}
+}
+
+mechz_flamethrower_arc_watcher()
+{
+	self endon( "death" );
+	self endon( "kill_ft" );
+	self endon( "stop_ft" );
+	aim_anim = undefined;
+	while ( 1 )
+	{
+		old_anim = aim_anim;
+		aim_anim = mechz_get_aim_anim( "zm_flamethrower", self.favoriteenemy.origin, 26 );
+		self.curr_aim_anim = aim_anim;
+		if ( !isDefined( aim_anim ) )
+		{
+			self notify( "stop_ft" );
+			return;
+		}
+		if ( !isDefined( old_anim ) || old_anim != aim_anim )
+		{
+			self notify( "arc_change" );
+		}
+		wait 0,05;
+	}
+}
+
+mechz_play_flamethrower_aim()
+{
+	self endon( "death" );
+	self endon( "kill_ft" );
+	self endon( "stop_ft" );
+	self endon( "arc_change" );
+	if ( isDefined( self.curr_aim_anim ) )
+	{
+		self stopanimscripted();
+		self animscripted( self.origin, self.angles, self.curr_aim_anim );
+		self maps/mp/animscripts/zm_shared::donotetracks( "flamethrower_anim" );
+	}
+	else
+	{
+		wait 0,05;
+	}
+}
+
+mechz_flamethrower_aim()
+{
+	self endon( "death" );
+	self endon( "kill_ft" );
+	self endon( "stop_ft" );
+	self waittillmatch( "flamethrower_anim" );
+	return "end";
+	self thread mechz_flamethrower_dist_watcher();
+	self thread mechz_flamethrower_arc_watcher();
+	aim_anim = undefined;
+	while ( 1 )
+	{
+		self mechz_play_flamethrower_aim();
+	}
+}
+
+mechz_flamethrower_tank_sweep()
+{
+	self endon( "death" );
+	self endon( "kill_ft" );
+	self endon( "stop_ft" );
+	while ( 1 )
+	{
+		self stopanimscripted();
+		self.angles = vectorToAngle( level.vh_tank.origin - self.origin );
+		self animscripted( self.origin, self.angles, "zm_flamethrower_sweep_up" );
+		self maps/mp/animscripts/zm_shared::donotetracks( "flamethrower_anim" );
+		if ( level.vh_tank ent_flag( "tank_moving" ) )
+		{
+			break;
+		}
+		else a_players_on_tank = get_players_on_tank( 1 );
+		if ( !a_players_on_tank.size )
+		{
+			break;
+		}
+		else
+		{
+		}
+	}
+	self notify( "stop_ft" );
+}
+
+mechz_stop_firing_watcher()
+{
+	self endon( "death" );
+	self endon( "kill_ft" );
+	self endon( "flamethrower_complete" );
+	self waittillmatch( "flamethrower_anim" );
+	return "stop_ft";
+	self.firing = 0;
+}
+
+mechz_watch_for_flamethrower_damage()
+{
+	self endon( "death" );
+	while ( 1 )
+	{
+		self waittillmatch( "flamethrower_anim" );
+		return "start_ft";
+		self.firing = 1;
+		self thread mechz_stop_firing_watcher();
+		while ( isDefined( self.firing ) && self.firing )
+		{
+			if ( isDefined( self.doing_tank_sweep ) && self.doing_tank_sweep )
+			{
+				do_tank_sweep_auto_damage = !level.vh_tank ent_flag( "tank_moving" );
+			}
+			players = getplayers();
+			i = 0;
+			while ( i < players.size )
+			{
+				if ( isDefined( players[ i ].is_burning ) && !players[ i ].is_burning )
+				{
+					if ( do_tank_sweep_auto_damage || players[ i ] entity_on_tank() && players[ i ] istouching( self.flamethrower_trigger ) )
+					{
+						players[ i ] thread player_flame_damage();
+					}
+				}
+				i++;
+			}
+			zombies = getaispeciesarray( "axis", "all" );
+			i = 0;
+			while ( i < zombies.size )
+			{
+				if ( isDefined( zombies[ i ].is_mechz ) && zombies[ i ].is_mechz )
+				{
+					i++;
+					continue;
+				}
+				else
+				{
+					if ( isDefined( zombies[ i ].on_fire ) && zombies[ i ].on_fire )
+					{
+						i++;
+						continue;
+					}
+					else
+					{
+						if ( do_tank_sweep_auto_damage || zombies[ i ] entity_on_tank() && zombies[ i ] istouching( self.flamethrower_trigger ) )
+						{
+							zombies[ i ].on_fire = 1;
+							zombies[ i ] promote_to_explosive();
+						}
+					}
+				}
+				i++;
+			}
+			wait 0,1;
+		}
+	}
+}
+
+player_flame_damage()
+{
+	self endon( "zombified" );
+	self endon( "death" );
+	self endon( "disconnect" );
+	n_player_dmg = 30;
+	n_jugga_dmg = 45;
+	n_burn_time = 1,5;
+	if ( isDefined( self.is_zombie ) && self.is_zombie )
+	{
+		return;
+	}
+	self thread player_stop_burning();
+	if ( !isDefined( self.is_burning ) && is_player_valid( self, 1, 0 ) )
+	{
+		self.is_burning = 1;
+		maps/mp/_visionset_mgr::vsmgr_activate( "overlay", "zm_transit_burn", self, n_burn_time, level.zm_transit_burn_max_duration );
+		self notify( "burned" );
+		if ( !self hasperk( "specialty_armorvest" ) )
+		{
+			self dodamage( n_player_dmg, self.origin );
+		}
+		else
+		{
+			self dodamage( n_jugga_dmg, self.origin );
+		}
+		wait 0,5;
+		self.is_burning = undefined;
+	}
+}
+
+player_stop_burning()
+{
+	self notify( "player_stop_burning" );
+	self endon( "player_stop_burning" );
+	self endon( "death_or_disconnect" );
+	self waittill( "zombified" );
+	self notify( "stop_flame_damage" );
+	maps/mp/_visionset_mgr::vsmgr_deactivate( "overlay", "zm_transit_burn", self );
+}
+
+zombie_burning_fx()
+{
+	self endon( "death" );
+	self endon( "stop_flame_damage" );
+	while ( 1 )
+	{
+		if ( isDefined( level._effect ) && isDefined( level._effect[ "character_fire_death_torso" ] ) )
+		{
+			if ( !self.isdog )
+			{
+				playfxontag( level._effect[ "character_fire_death_torso" ], self, "J_SpineLower" );
+			}
+		}
+		if ( isDefined( level._effect ) && isDefined( level._effect[ "character_fire_death_sm" ] ) )
+		{
+			wait 1;
+			tagarray = [];
+			if ( randomint( 2 ) == 0 )
+			{
+				tagarray[ 0 ] = "J_Elbow_LE";
+				tagarray[ 1 ] = "J_Elbow_RI";
+				tagarray[ 2 ] = "J_HEAD";
+			}
+			else
+			{
+				tagarray[ 0 ] = "J_Wrist_RI";
+				tagarray[ 1 ] = "J_Wrist_LE";
+				tagarray[ 2 ] = "J_HEAD";
+			}
+			tagarray = array_randomize( tagarray );
+			self thread network_safe_play_fx_on_tag( "flamethrower", 2, level._effect[ "character_fire_death_sm" ], self, tagarray[ 0 ] );
+		}
+		wait 12;
+	}
+}
+
+zombie_burning_audio()
+{
+	self playloopsound( "zmb_fire_loop" );
+	self waittill_any( "death", "stop_flame_damage" );
+	if ( isDefined( self ) && isalive( self ) )
+	{
+		self stoploopsound( 0,25 );
+	}
+}
+
+zombie_burning_dmg()
+{
+	self endon( "death" );
+	self endon( "stop_flame_damage" );
+	damageradius = 25;
+	damage = 2;
+	while ( 1 )
+	{
+		eyeorigin = self geteye();
+		players = get_players();
+		i = 0;
+		while ( i < players.size )
+		{
+			if ( is_player_valid( players[ i ], 1, 0 ) )
+			{
+				playereye = players[ i ] geteye();
+				if ( distancesquared( eyeorigin, playereye ) < ( damageradius * damageradius ) )
+				{
+					players[ i ] dodamage( damage, self.origin, self );
+					players[ i ] notify( "burned" );
+				}
+			}
+			i++;
+		}
+		wait 1;
+	}
+}
+
+promote_to_explosive()
+{
+	self endon( "death" );
+	self thread zombie_burning_audio();
+	self thread zombie_burning_fx();
+	self thread explode_on_death();
+	self thread zombie_burning_dmg();
+	self thread on_fire_timeout();
+}
+
+explode_on_death()
+{
+	self endon( "stop_flame_damage" );
+	self waittill( "death" );
+	if ( !isDefined( self ) )
+	{
+		return;
+	}
+	tag = "J_SpineLower";
+	if ( isDefined( self.animname ) && self.animname == "zombie_dog" )
+	{
+		tag = "tag_origin";
+	}
+	if ( is_mature() )
+	{
+		if ( isDefined( level._effect[ "zomb_gib" ] ) )
+		{
+			playfx( level._effect[ "zomb_gib" ], self gettagorigin( tag ) );
+		}
+	}
+	else
+	{
+		if ( isDefined( level._effect[ "spawn_cloud" ] ) )
+		{
+			playfx( level._effect[ "spawn_cloud" ], self gettagorigin( tag ) );
+		}
+	}
+	self radiusdamage( self.origin, 128, 30, 15, undefined, "MOD_EXPLOSIVE" );
+	self ghost();
+	if ( isDefined( self.isdog ) && self.isdog )
+	{
+		self hide();
+	}
+	else
+	{
+		self delay_thread( 1, ::self_delete );
+	}
+}
+
+on_fire_timeout()
+{
+	self endon( "death" );
+	wait 12;
+	if ( isDefined( self ) && isalive( self ) )
+	{
+		self.is_on_fire = 0;
+		self notify( "stop_flame_damage" );
+	}
+}
+
+should_do_flamethrower_attack()
+{
+/#
+	assert( isDefined( self.favoriteenemy ) );
+#/
+/#
+	if ( getDvarInt( #"E7121222" ) > 1 )
+	{
+		println( "\n\tMZ: Checking should flame\n" );
+#/
+	}
+	if ( isDefined( self.disable_complex_behaviors ) && self.disable_complex_behaviors )
+	{
+/#
+		if ( getDvarInt( #"E7121222" ) > 1 )
+		{
+			println( "\n\t\tMZ: Not doing flamethrower because doing force aggro\n" );
+#/
+		}
+		return 0;
+	}
+	if ( isDefined( self.not_interruptable ) && self.not_interruptable )
+	{
+/#
+		if ( getDvarInt( #"E7121222" ) > 1 )
+		{
+			println( "\n\t\tMZ: Not doing flamethrower because another behavior has set not_interruptable\n" );
+#/
+		}
+		return 0;
+	}
+	if ( !self mechz_check_in_arc( 26 ) )
+	{
+/#
+		if ( getDvarInt( #"E7121222" ) > 1 )
+		{
+			println( "\n\t\tMZ: Not doing flamethrower because target is not in front arc\n" );
+#/
+		}
+		return 0;
+	}
+	if ( isDefined( self.last_flamethrower_time ) && ( getTime() - self.last_flamethrower_time ) < level.mechz_flamethrower_cooldown_time )
+	{
+/#
+		if ( getDvarInt( #"E7121222" ) > 1 )
+		{
+			println( "\n\t\tMZ: Not doing flamethrower because it is still on cooldown\n" );
+#/
+		}
+		return 0;
+	}
+	n_dist_sq = distancesquared( self.origin, self.favoriteenemy.origin );
+	if ( n_dist_sq < 10000 || n_dist_sq > 50000 )
+	{
+/#
+		if ( getDvarInt( #"E7121222" ) > 1 )
+		{
+			println( "\n\t\tMZ: Not doing flamethrower because target is not in range\n" );
+#/
+		}
+		return 0;
+	}
+	b_cansee = bullettracepassed( self.origin + vectorScale( ( 0, 0, 1 ), 36 ), self.favoriteenemy.origin + vectorScale( ( 0, 0, 1 ), 36 ), 0, undefined );
+	if ( !b_cansee )
+	{
+/#
+		if ( getDvarInt( #"E7121222" ) > 1 )
+		{
+			println( "\n\t\tMZ: Not doing flamethrower because cannot see target\n" );
+#/
+		}
+		return 0;
+	}
+	return 1;
+}
+
+mechz_do_flamethrower_attack( tank_sweep )
+{
+	self endon( "death" );
+	self endon( "kill_ft" );
+/#
+	if ( getDvarInt( #"E7121222" ) > 0 )
+	{
+		println( "\n\tMZ: Doing Flamethrower Attack\n" );
+#/
+	}
+	self thread mechz_stop_basic_find_flesh();
+	self.ai_state = "flamethrower_attack";
+	self setgoalpos( self.origin );
+	self clearanim( %root, 0,2 );
+	self.last_flamethrower_time = getTime();
+	self thread mechz_kill_flamethrower_watcher();
+	if ( !isDefined( self.flamethrower_trigger ) )
+	{
+		self mechz_flamethrower_initial_setup();
+	}
+	n_nearby_enemies = 0;
+	a_players = getplayers();
+	_a628 = a_players;
+	_k628 = getFirstArrayKey( _a628 );
+	while ( isDefined( _k628 ) )
+	{
+		player = _a628[ _k628 ];
+		if ( distance2dsquared( player.origin, self.favoriteenemy.origin ) < 10000 )
+		{
+			n_nearby_enemies++;
+		}
+		_k628 = getNextArrayKey( _a628, _k628 );
+	}
+	if ( isDefined( tank_sweep ) && tank_sweep )
+	{
+		self.doing_tank_sweep = 1;
+		self thread mechz_flamethrower_tank_sweep();
+	}
+	else
+	{
+		if ( randomint( 100 ) < level.mechz_ft_sweep_chance && n_nearby_enemies > 1 )
+		{
+			self.doing_ft_sweep = 1;
+			self animscripted( self.origin, self.angles, "zm_flamethrower_sweep" );
+			self maps/mp/animscripts/zm_shared::donotetracks( "flamethrower_anim" );
+		}
+		else
+		{
+			self animscripted( self.origin, self.angles, "zm_flamethrower_aim_start" );
+			self thread mechz_flamethrower_aim();
+			self maps/mp/animscripts/zm_shared::donotetracks( "flamethrower_anim" );
+		}
+	}
+	self orientmode( "face default" );
+	if ( isDefined( self.doing_ft_sweep ) && self.doing_ft_sweep )
+	{
+		self.doing_ft_sweep = 0;
+	}
+	else
+	{
+		self.cant_melee = 1;
+		self waittill( "stop_ft" );
+		self mechz_flamethrower_cleanup();
+		wait 0,5;
+		self stopanimscripted();
+		return;
+	}
+	self mechz_flamethrower_cleanup();
+}
+
+mechz_kill_flamethrower_watcher()
+{
+	self endon( "flamethrower_complete" );
+	self waittill_either( "kill_ft", "death" );
+	self mechz_flamethrower_cleanup();
+}
+
+mechz_flamethrower_cleanup()
+{
+	self.fx_field &= 64;
+	self setclientfield( "mechz_fx", self.fx_field );
+	self.firing = 0;
+	self.doing_tank_sweep = 0;
+	self.cant_melee = 0;
+	self notify( "flamethrower_complete" );
+}

zm_tomb_patch/maps/mp/zombies/_zm_challenges.gsc

@@ -0,0 +1,884 @@
+#include maps/mp/zombies/_zm_score;
+#include maps/mp/zombies/_zm_laststand;
+#include maps/mp/zombies/_zm_unitrigger;
+#include maps/mp/zm_tomb_utility;
+#include maps/mp/zombies/_zm_utility;
+#include maps/mp/_utility;
+#include common_scripts/utility;
+
+#using_animtree( "fxanim_props_dlc4" );
+
+init()
+{
+	level._challenges = spawnstruct();
+	stats_init();
+	level.a_m_challenge_boards = [];
+	level.a_uts_challenge_boxes = [];
+	a_m_challenge_boxes = getentarray( "challenge_box", "targetname" );
+	array_thread( a_m_challenge_boxes, ::box_init );
+	onplayerconnect_callback( ::onplayerconnect );
+	n_bits = getminbitcountfornum( 14 );
+	registerclientfield( "toplayer", "challenge_complete_1", 14000, 1, "int" );
+	registerclientfield( "toplayer", "challenge_complete_2", 14000, 1, "int" );
+	registerclientfield( "toplayer", "challenge_complete_3", 14000, 1, "int" );
+	registerclientfield( "toplayer", "challenge_complete_4", 14000, 1, "int" );
+/#
+	level thread challenges_devgui();
+#/
+}
+
+onplayerconnect()
+{
+	player_stats_init( self.characterindex );
+	_a55 = level._challenges.a_players[ self.characterindex ].a_stats;
+	_k55 = getFirstArrayKey( _a55 );
+	while ( isDefined( _k55 ) )
+	{
+		s_stat = _a55[ _k55 ];
+		s_stat.b_display_tag = 1;
+		_a58 = level.a_m_challenge_boards;
+		_k58 = getFirstArrayKey( _a58 );
+		while ( isDefined( _k58 ) )
+		{
+			m_board = _a58[ _k58 ];
+			m_board showpart( s_stat.str_medal_tag );
+			m_board hidepart( s_stat.str_glow_tag );
+			_k58 = getNextArrayKey( _a58, _k58 );
+		}
+		_k55 = getNextArrayKey( _a55, _k55 );
+	}
+	self thread onplayerspawned();
+}
+
+onplayerspawned()
+{
+	self endon( "disconnect" );
+	for ( ;; )
+	{
+		self waittill( "spawned_player" );
+		_a81 = level._challenges.a_players[ self.characterindex ].a_stats;
+		_k81 = getFirstArrayKey( _a81 );
+		while ( isDefined( _k81 ) )
+		{
+			s_stat = _a81[ _k81 ];
+			while ( s_stat.b_medal_awarded && !s_stat.b_reward_claimed )
+			{
+				_a85 = level.a_m_challenge_boards;
+				_k85 = getFirstArrayKey( _a85 );
+				while ( isDefined( _k85 ) )
+				{
+					m_board = _a85[ _k85 ];
+					self setclientfieldtoplayer( s_stat.s_parent.cf_complete, 1 );
+					_k85 = getNextArrayKey( _a85, _k85 );
+				}
+			}
+			_k81 = getNextArrayKey( _a81, _k81 );
+		}
+		_a92 = level._challenges.s_team.a_stats;
+		_k92 = getFirstArrayKey( _a92 );
+		while ( isDefined( _k92 ) )
+		{
+			s_stat = _a92[ _k92 ];
+			while ( s_stat.b_medal_awarded && s_stat.a_b_player_rewarded[ self.characterindex ] )
+			{
+				_a96 = level.a_m_challenge_boards;
+				_k96 = getFirstArrayKey( _a96 );
+				while ( isDefined( _k96 ) )
+				{
+					m_board = _a96[ _k96 ];
+					self setclientfieldtoplayer( s_stat.s_parent.cf_complete, 1 );
+					_k96 = getNextArrayKey( _a96, _k96 );
+				}
+			}
+			_k92 = getNextArrayKey( _a92, _k92 );
+		}
+	}
+}
+
+stats_init()
+{
+	level._challenges.a_stats = [];
+	if ( isDefined( level.challenges_add_stats ) )
+	{
+		[[ level.challenges_add_stats ]]();
+	}
+	_a124 = level._challenges.a_stats;
+	_k124 = getFirstArrayKey( _a124 );
+	while ( isDefined( _k124 ) )
+	{
+		stat = _a124[ _k124 ];
+		if ( isDefined( stat.fp_init_stat ) )
+		{
+			level thread [[ stat.fp_init_stat ]]();
+		}
+		_k124 = getNextArrayKey( _a124, _k124 );
+	}
+	level._challenges.a_players = [];
+	i = 0;
+	while ( i < 4 )
+	{
+		player_stats_init( i );
+		i++;
+	}
+	team_stats_init();
+}
+
+add_stat( str_name, b_team, str_hint, n_goal, str_reward_model, fp_give_reward, fp_init_stat )
+{
+	if ( !isDefined( b_team ) )
+	{
+		b_team = 0;
+	}
+	if ( !isDefined( str_hint ) )
+	{
+		str_hint = &"";
+	}
+	if ( !isDefined( n_goal ) )
+	{
+		n_goal = 1;
+	}
+	stat = spawnstruct();
+	stat.str_name = str_name;
+	stat.b_team = b_team;
+	stat.str_hint = str_hint;
+	stat.n_goal = n_goal;
+	stat.str_reward_model = str_reward_model;
+	stat.fp_give_reward = fp_give_reward;
+	if ( isDefined( fp_init_stat ) )
+	{
+		stat.fp_init_stat = fp_init_stat;
+	}
+	level._challenges.a_stats[ str_name ] = stat;
+	stat.cf_complete = "challenge_complete_" + level._challenges.a_stats.size;
+}
+
+player_stats_init( n_index )
+{
+	a_characters = array( "d", "n", "r", "t" );
+	str_character = a_characters[ n_index ];
+	if ( !isDefined( level._challenges.a_players[ n_index ] ) )
+	{
+		level._challenges.a_players[ n_index ] = spawnstruct();
+		level._challenges.a_players[ n_index ].a_stats = [];
+	}
+	s_player_set = level._challenges.a_players[ n_index ];
+	n_challenge_index = 1;
+	_a196 = level._challenges.a_stats;
+	_k196 = getFirstArrayKey( _a196 );
+	while ( isDefined( _k196 ) )
+	{
+		s_challenge = _a196[ _k196 ];
+		if ( !s_challenge.b_team )
+		{
+			if ( !isDefined( s_player_set.a_stats[ s_challenge.str_name ] ) )
+			{
+				s_player_set.a_stats[ s_challenge.str_name ] = spawnstruct();
+			}
+			s_stat = s_player_set.a_stats[ s_challenge.str_name ];
+			s_stat.s_parent = s_challenge;
+			s_stat.n_value = 0;
+			s_stat.b_medal_awarded = 0;
+			s_stat.b_reward_claimed = 0;
+			n_index = level._challenges.a_stats.size + 1;
+			s_stat.str_medal_tag = "j_" + str_character + "_medal_0" + n_challenge_index;
+			s_stat.str_glow_tag = "j_" + str_character + "_glow_0" + n_challenge_index;
+			s_stat.b_display_tag = 0;
+			n_challenge_index++;
+		}
+		_k196 = getNextArrayKey( _a196, _k196 );
+	}
+	s_player_set.n_completed = 0;
+	s_player_set.n_medals_held = 0;
+}
+
+team_stats_init( n_index )
+{
+	if ( !isDefined( level._challenges.s_team ) )
+	{
+		level._challenges.s_team = spawnstruct();
+		level._challenges.s_team.a_stats = [];
+	}
+	s_team_set = level._challenges.s_team;
+	_a243 = level._challenges.a_stats;
+	_k243 = getFirstArrayKey( _a243 );
+	while ( isDefined( _k243 ) )
+	{
+		s_challenge = _a243[ _k243 ];
+		if ( s_challenge.b_team )
+		{
+			if ( !isDefined( s_team_set.a_stats[ s_challenge.str_name ] ) )
+			{
+				s_team_set.a_stats[ s_challenge.str_name ] = spawnstruct();
+			}
+			s_stat = s_team_set.a_stats[ s_challenge.str_name ];
+			s_stat.s_parent = s_challenge;
+			s_stat.n_value = 0;
+			s_stat.b_medal_awarded = 0;
+			s_stat.b_reward_claimed = 0;
+			s_stat.a_b_player_rewarded = array( 0, 0, 0, 0 );
+			s_stat.str_medal_tag = "j_g_medal";
+			s_stat.str_glow_tag = "j_g_glow";
+			s_stat.b_display_tag = 1;
+		}
+		_k243 = getNextArrayKey( _a243, _k243 );
+	}
+	s_team_set.n_completed = 0;
+	s_team_set.n_medals_held = 0;
+}
+
+challenge_exists( str_name )
+{
+	if ( isDefined( level._challenges.a_stats[ str_name ] ) )
+	{
+		return 1;
+	}
+	else
+	{
+		return 0;
+	}
+}
+
+get_stat( str_stat, player )
+{
+	s_parent_stat = level._challenges.a_stats[ str_stat ];
+/#
+	assert( isDefined( s_parent_stat ), "Challenge stat: " + str_stat + " does not exist" );
+#/
+/#
+	if ( !s_parent_stat.b_team )
+	{
+		assert( isDefined( player ), "Challenge stat: " + str_stat + " is a player stat, but no player passed in" );
+	}
+#/
+	if ( s_parent_stat.b_team )
+	{
+		s_stat = level._challenges.s_team.a_stats[ str_stat ];
+	}
+	else
+	{
+		s_stat = level._challenges.a_players[ player.characterindex ].a_stats[ str_stat ];
+	}
+	return s_stat;
+}
+
+increment_stat( str_stat, n_increment )
+{
+	if ( !isDefined( n_increment ) )
+	{
+		n_increment = 1;
+	}
+	s_stat = get_stat( str_stat, self );
+	if ( !s_stat.b_medal_awarded )
+	{
+		s_stat.n_value += n_increment;
+		check_stat_complete( s_stat );
+	}
+}
+
+set_stat( str_stat, n_set )
+{
+	s_stat = get_stat( str_stat, self );
+	if ( !s_stat.b_medal_awarded )
+	{
+		s_stat.n_value = n_set;
+		check_stat_complete( s_stat );
+	}
+}
+
+check_stat_complete( s_stat )
+{
+	if ( s_stat.b_medal_awarded )
+	{
+		return 1;
+	}
+	if ( s_stat.n_value >= s_stat.s_parent.n_goal )
+	{
+		s_stat.b_medal_awarded = 1;
+		if ( s_stat.s_parent.b_team )
+		{
+			s_team_stats = level._challenges.s_team;
+			s_team_stats.n_completed++;
+			s_team_stats.n_medals_held++;
+			a_players = get_players();
+			_a358 = a_players;
+			_k358 = getFirstArrayKey( _a358 );
+			while ( isDefined( _k358 ) )
+			{
+				player = _a358[ _k358 ];
+				player setclientfieldtoplayer( s_stat.s_parent.cf_complete, 1 );
+				player playsound( "evt_medal_acquired" );
+				wait_network_frame();
+				_k358 = getNextArrayKey( _a358, _k358 );
+			}
+		}
+		else s_player_stats = level._challenges.a_players[ self.characterindex ];
+		s_player_stats.n_completed++;
+		s_player_stats.n_medals_held++;
+		self playsound( "evt_medal_acquired" );
+		self setclientfieldtoplayer( s_stat.s_parent.cf_complete, 1 );
+		_a376 = level.a_m_challenge_boards;
+		_k376 = getFirstArrayKey( _a376 );
+		while ( isDefined( _k376 ) )
+		{
+			m_board = _a376[ _k376 ];
+			m_board showpart( s_stat.str_glow_tag );
+			_k376 = getNextArrayKey( _a376, _k376 );
+		}
+		if ( isplayer( self ) )
+		{
+			if ( ( level._challenges.a_players[ self.characterindex ].n_completed + level._challenges.s_team.n_completed ) == level._challenges.a_stats.size )
+			{
+				self notify( "all_challenges_complete" );
+			}
+		}
+		else
+		{
+			_a391 = get_players();
+			_k391 = getFirstArrayKey( _a391 );
+			while ( isDefined( _k391 ) )
+			{
+				player = _a391[ _k391 ];
+				if ( isDefined( player.characterindex ) )
+				{
+					if ( ( level._challenges.a_players[ player.characterindex ].n_completed + level._challenges.s_team.n_completed ) == level._challenges.a_stats.size )
+					{
+						player notify( "all_challenges_complete" );
+					}
+				}
+				_k391 = getNextArrayKey( _a391, _k391 );
+			}
+		}
+		wait_network_frame();
+	}
+}
+
+stat_reward_available( stat, player )
+{
+	if ( isstring( stat ) )
+	{
+		s_stat = get_stat( stat, player );
+	}
+	else
+	{
+		s_stat = stat;
+	}
+	if ( !s_stat.b_medal_awarded )
+	{
+		return 0;
+	}
+	if ( s_stat.b_reward_claimed )
+	{
+		return 0;
+	}
+	if ( s_stat.s_parent.b_team && s_stat.a_b_player_rewarded[ player.characterindex ] )
+	{
+		return 0;
+	}
+	return 1;
+}
+
+player_has_unclaimed_team_reward()
+{
+	_a441 = level._challenges.s_team.a_stats;
+	_k441 = getFirstArrayKey( _a441 );
+	while ( isDefined( _k441 ) )
+	{
+		s_stat = _a441[ _k441 ];
+		if ( s_stat.b_medal_awarded && !s_stat.a_b_player_rewarded[ self.characterindex ] )
+		{
+			return 1;
+		}
+		_k441 = getNextArrayKey( _a441, _k441 );
+	}
+	return 0;
+}
+
+board_init( m_board )
+{
+	self.m_board = m_board;
+	a_challenges = getarraykeys( level._challenges.a_stats );
+	a_characters = array( "d", "n", "r", "t" );
+	m_board.a_s_medal_tags = [];
+	b_team_hint_added = 0;
+	_a473 = level._challenges.a_players;
+	n_char_index = getFirstArrayKey( _a473 );
+	while ( isDefined( n_char_index ) )
+	{
+		s_set = _a473[ n_char_index ];
+		str_character = a_characters[ n_char_index ];
+		n_challenge_index = 1;
+		_a477 = s_set.a_stats;
+		_k477 = getFirstArrayKey( _a477 );
+		while ( isDefined( _k477 ) )
+		{
+			s_stat = _a477[ _k477 ];
+			str_medal_tag = "j_" + str_character + "_medal_0" + n_challenge_index;
+			str_glow_tag = "j_" + str_character + "_glow_0" + n_challenge_index;
+			s_tag = spawnstruct();
+			s_tag.v_origin = m_board gettagorigin( str_medal_tag );
+			s_tag.s_stat = s_stat;
+			s_tag.n_character_index = n_char_index;
+			s_tag.str_medal_tag = str_medal_tag;
+			m_board.a_s_medal_tags[ m_board.a_s_medal_tags.size ] = s_tag;
+			m_board hidepart( str_medal_tag );
+			m_board hidepart( str_glow_tag );
+			n_challenge_index++;
+			_k477 = getNextArrayKey( _a477, _k477 );
+		}
+		n_char_index = getNextArrayKey( _a473, n_char_index );
+	}
+	_a495 = level._challenges.s_team.a_stats;
+	_k495 = getFirstArrayKey( _a495 );
+	while ( isDefined( _k495 ) )
+	{
+		s_stat = _a495[ _k495 ];
+		str_medal_tag = "j_g_medal";
+		str_glow_tag = "j_g_glow";
+		s_tag = spawnstruct();
+		s_tag.v_origin = m_board gettagorigin( str_medal_tag );
+		s_tag.s_stat = s_stat;
+		s_tag.n_character_index = 4;
+		s_tag.str_medal_tag = str_medal_tag;
+		m_board.a_s_medal_tags[ m_board.a_s_medal_tags.size ] = s_tag;
+		m_board hidepart( str_glow_tag );
+		b_team_hint_added = 1;
+		_k495 = getNextArrayKey( _a495, _k495 );
+	}
+	level.a_m_challenge_boards[ level.a_m_challenge_boards.size ] = m_board;
+}
+
+box_init()
+{
+	self useanimtree( -1 );
+	s_unitrigger_stub = spawnstruct();
+	s_unitrigger_stub.origin = self.origin + ( 0, 0, 0 );
+	s_unitrigger_stub.angles = self.angles;
+	s_unitrigger_stub.radius = 64;
+	s_unitrigger_stub.script_length = 64;
+	s_unitrigger_stub.script_width = 64;
+	s_unitrigger_stub.script_height = 64;
+	s_unitrigger_stub.cursor_hint = "HINT_NOICON";
+	s_unitrigger_stub.hint_string = &"";
+	s_unitrigger_stub.script_unitrigger_type = "unitrigger_box_use";
+	s_unitrigger_stub.prompt_and_visibility_func = ::box_prompt_and_visiblity;
+	s_unitrigger_stub ent_flag_init( "waiting_for_grab" );
+	s_unitrigger_stub ent_flag_init( "reward_timeout" );
+	s_unitrigger_stub.b_busy = 0;
+	s_unitrigger_stub.m_box = self;
+	s_unitrigger_stub.b_disable_trigger = 0;
+	if ( isDefined( self.script_string ) )
+	{
+		s_unitrigger_stub.str_location = self.script_string;
+	}
+	if ( isDefined( s_unitrigger_stub.m_box.target ) )
+	{
+		s_unitrigger_stub.m_board = getent( s_unitrigger_stub.m_box.target, "targetname" );
+		s_unitrigger_stub board_init( s_unitrigger_stub.m_board );
+	}
+	unitrigger_force_per_player_triggers( s_unitrigger_stub, 1 );
+	level.a_uts_challenge_boxes[ level.a_uts_challenge_boxes.size ] = s_unitrigger_stub;
+	maps/mp/zombies/_zm_unitrigger::register_static_unitrigger( s_unitrigger_stub, ::box_think );
+}
+
+box_prompt_and_visiblity( player )
+{
+	if ( self.stub.b_disable_trigger )
+	{
+		return 0;
+	}
+	self thread update_box_prompt( player );
+	return 1;
+}
+
+update_box_prompt( player )
+{
+	self endon( "kill_trigger" );
+	player endon( "death_or_disconnect" );
+	str_hint = &"";
+	str_old_hint = &"";
+	m_board = self.stub.m_board;
+	self sethintstring( str_hint );
+	while ( 1 )
+	{
+		s_hint_tag = undefined;
+		b_showing_stat = 0;
+		self.b_can_open = 0;
+		if ( self.stub.b_busy )
+		{
+			if ( self.stub ent_flag( "waiting_for_grab" ) || !isDefined( self.stub.player_using ) && self.stub.player_using == player )
+			{
+				str_hint = &"ZM_TOMB_CH_G";
+			}
+			else
+			{
+				str_hint = &"";
+			}
+		}
+		else str_hint = &"";
+		player.s_lookat_stat = undefined;
+		n_closest_dot = 0,996;
+		v_eye_origin = player getplayercamerapos();
+		v_eye_direction = anglesToForward( player getplayerangles() );
+		_a619 = m_board.a_s_medal_tags;
+		str_tag = getFirstArrayKey( _a619 );
+		while ( isDefined( str_tag ) )
+		{
+			s_tag = _a619[ str_tag ];
+			if ( !s_tag.s_stat.b_display_tag )
+			{
+			}
+			else
+			{
+				v_tag_origin = s_tag.v_origin;
+				v_eye_to_tag = vectornormalize( v_tag_origin - v_eye_origin );
+				n_dot = vectordot( v_eye_to_tag, v_eye_direction );
+				if ( n_dot > n_closest_dot )
+				{
+					n_closest_dot = n_dot;
+					str_hint = s_tag.s_stat.s_parent.str_hint;
+					s_hint_tag = s_tag;
+					b_showing_stat = 1;
+					self.b_can_open = 0;
+					if ( s_tag.n_character_index == player.characterindex || s_tag.n_character_index == 4 )
+					{
+						player.s_lookat_stat = s_tag.s_stat;
+						if ( stat_reward_available( s_tag.s_stat, player ) )
+						{
+							str_hint = &"ZM_TOMB_CH_S";
+							b_showing_stat = 0;
+							self.b_can_open = 1;
+						}
+					}
+				}
+			}
+			str_tag = getNextArrayKey( _a619, str_tag );
+		}
+		if ( str_hint == &"" )
+		{
+			s_player = level._challenges.a_players[ player.characterindex ];
+			s_team = level._challenges.s_team;
+			if ( s_player.n_medals_held > 0 || player player_has_unclaimed_team_reward() )
+			{
+				str_hint = &"ZM_TOMB_CH_O";
+				self.b_can_open = 1;
+				break;
+			}
+			else
+			{
+				str_hint = &"ZM_TOMB_CH_V";
+			}
+		}
+		if ( str_old_hint != str_hint )
+		{
+			str_old_hint = str_hint;
+			self.stub.hint_string = str_hint;
+			if ( isDefined( s_hint_tag ) )
+			{
+				str_name = s_hint_tag.s_stat.s_parent.str_name;
+				n_character_index = s_hint_tag.n_character_index;
+				if ( n_character_index != 4 )
+				{
+					s_player_stat = level._challenges.a_players[ n_character_index ].a_stats[ str_name ];
+					break;
+				}
+			}
+			self sethintstring( self.stub.hint_string );
+		}
+		wait 0,1;
+	}
+}
+
+box_think()
+{
+	self endon( "kill_trigger" );
+	s_team = level._challenges.s_team;
+	while ( 1 )
+	{
+		self waittill( "trigger", player );
+		while ( !is_player_valid( player ) )
+		{
+			continue;
+		}
+		while ( self.stub.b_busy )
+		{
+			current_weapon = player getcurrentweapon();
+			while ( isDefined( player.intermission ) && !player.intermission && !is_placeable_mine( current_weapon ) && !is_equipment_that_blocks_purchase( current_weapon ) && current_weapon != "none" && !player maps/mp/zombies/_zm_laststand::player_is_in_laststand() && !player isthrowinggrenade() && !player in_revive_trigger() || player isswitchingweapons() && player.is_drinking > 0 )
+			{
+				wait 0,1;
+			}
+			if ( self.stub ent_flag( "waiting_for_grab" ) )
+			{
+				if ( !isDefined( self.stub.player_using ) )
+				{
+					self.stub.player_using = player;
+				}
+				if ( player == self.stub.player_using )
+				{
+					self.stub ent_flag_clear( "waiting_for_grab" );
+				}
+			}
+			wait 0,05;
+		}
+		if ( self.b_can_open )
+		{
+			self.stub.hint_string = &"";
+			self sethintstring( self.stub.hint_string );
+			level thread open_box( player, self.stub );
+		}
+	}
+}
+
+get_reward_category( player, s_select_stat )
+{
+	if ( isDefined( s_select_stat ) || s_select_stat.s_parent.b_team && level._challenges.s_team.n_medals_held > 0 )
+	{
+		return level._challenges.s_team;
+	}
+	if ( level._challenges.a_players[ player.characterindex ].n_medals_held > 0 )
+	{
+		return level._challenges.a_players[ player.characterindex ];
+	}
+	return undefined;
+}
+
+get_reward_stat( s_category )
+{
+	_a809 = s_category.a_stats;
+	_k809 = getFirstArrayKey( _a809 );
+	while ( isDefined( _k809 ) )
+	{
+		s_stat = _a809[ _k809 ];
+		if ( s_stat.b_medal_awarded && !s_stat.b_reward_claimed )
+		{
+			if ( s_stat.s_parent.b_team && s_stat.a_b_player_rewarded[ self.characterindex ] )
+			{
+				break;
+			}
+			else
+			{
+				return s_stat;
+			}
+		}
+		_k809 = getNextArrayKey( _a809, _k809 );
+	}
+	return undefined;
+}
+
+open_box( player, ut_stub, fp_reward_override, param1 )
+{
+	m_box = ut_stub.m_box;
+	while ( ut_stub.b_busy )
+	{
+		wait 1;
+	}
+	ut_stub.b_busy = 1;
+	ut_stub.player_using = player;
+	if ( isDefined( player ) && isDefined( player.s_lookat_stat ) )
+	{
+		s_select_stat = player.s_lookat_stat;
+	}
+	m_box setanim( %o_zombie_dlc4_challenge_box_open );
+	m_box delay_thread( 0,75, ::setclientfield, "foot_print_box_glow", 1 );
+	wait 0,5;
+	if ( isDefined( fp_reward_override ) )
+	{
+		ut_stub [[ fp_reward_override ]]( player, param1 );
+	}
+	else
+	{
+		ut_stub spawn_reward( player, s_select_stat );
+	}
+	wait 1;
+	m_box setanim( %o_zombie_dlc4_challenge_box_close );
+	m_box delay_thread( 0,75, ::setclientfield, "foot_print_box_glow", 0 );
+	wait 2;
+	ut_stub.b_busy = 0;
+	ut_stub.player_using = undefined;
+}
+
+spawn_reward( player, s_select_stat )
+{
+	if ( isDefined( player ) )
+	{
+		player endon( "death_or_disconnect" );
+		if ( isDefined( s_select_stat ) )
+		{
+			s_category = get_reward_category( player, s_select_stat );
+			if ( stat_reward_available( s_select_stat, player ) )
+			{
+				s_stat = s_select_stat;
+			}
+		}
+		if ( !isDefined( s_stat ) )
+		{
+			s_category = get_reward_category( player );
+			s_stat = player get_reward_stat( s_category );
+		}
+		if ( self [[ s_stat.s_parent.fp_give_reward ]]( player, s_stat ) )
+		{
+			if ( isDefined( s_stat.s_parent.cf_complete ) )
+			{
+				player setclientfieldtoplayer( s_stat.s_parent.cf_complete, 0 );
+			}
+			while ( s_stat.s_parent.b_team )
+			{
+				s_stat.a_b_player_rewarded[ player.characterindex ] = 1;
+				a_players = get_players();
+				_a917 = a_players;
+				_k917 = getFirstArrayKey( _a917 );
+				while ( isDefined( _k917 ) )
+				{
+					player = _a917[ _k917 ];
+					if ( !s_stat.a_b_player_rewarded[ player.characterindex ] )
+					{
+						return;
+					}
+					_k917 = getNextArrayKey( _a917, _k917 );
+				}
+			}
+			s_stat.b_reward_claimed = 1;
+			s_category.n_medals_held--;
+
+		}
+	}
+}
+
+reward_grab_wait( n_timeout )
+{
+	if ( !isDefined( n_timeout ) )
+	{
+		n_timeout = 10;
+	}
+	self ent_flag_clear( "reward_timeout" );
+	self ent_flag_set( "waiting_for_grab" );
+	self endon( "waiting_for_grab" );
+	if ( n_timeout > 0 )
+	{
+		wait n_timeout;
+		self ent_flag_set( "reward_timeout" );
+		self ent_flag_clear( "waiting_for_grab" );
+	}
+	else
+	{
+		self ent_flag_waitopen( "waiting_for_grab" );
+	}
+}
+
+reward_sink( n_delay, n_z, n_time )
+{
+	if ( isDefined( n_delay ) )
+	{
+		wait n_delay;
+		if ( isDefined( self ) )
+		{
+			self movez( n_z * -1, n_time );
+		}
+	}
+}
+
+reward_rise_and_grab( m_reward, n_z, n_rise_time, n_delay, n_timeout )
+{
+	m_reward movez( n_z, n_rise_time );
+	wait n_rise_time;
+	if ( n_timeout > 0 )
+	{
+		m_reward thread reward_sink( n_delay, n_z, n_timeout + 1 );
+	}
+	self reward_grab_wait( n_timeout );
+	if ( self ent_flag( "reward_timeout" ) )
+	{
+		return 0;
+	}
+	return 1;
+}
+
+reward_points( player, s_stat )
+{
+	player maps/mp/zombies/_zm_score::add_to_player_score( 2500 );
+}
+
+challenges_devgui()
+{
+/#
+	setdvar( "award_challenge", "0" );
+	adddebugcommand( "devgui_cmd "Zombies/Tomb:1/Challenges:10/Award Player1" "award_challenge 1"\n" );
+	adddebugcommand( "devgui_cmd "Zombies/Tomb:1/Challenges:10/Award Player2" "award_challenge 2"\n" );
+	adddebugcommand( "devgui_cmd "Zombies/Tomb:1/Challenges:10/Award Player3" "award_challenge 3"\n" );
+	adddebugcommand( "devgui_cmd "Zombies/Tomb:1/Challenges:10/Award Team" "award_challenge 4"\n" );
+	thread watch_devgui_award_challenges();
+#/
+}
+
+watch_devgui_award_challenges()
+{
+/#
+	while ( 1 )
+	{
+		n_award_challenge = getDvarInt( "award_challenge" );
+		if ( n_award_challenge != 0 )
+		{
+			devgui_award_challenge( n_award_challenge );
+			setdvarint( "award_challenge", 0 );
+		}
+		wait 0,5;
+#/
+	}
+}
+
+devgui_award_challenge( n_index )
+{
+/#
+	if ( n_index == 4 )
+	{
+		s_team_stats = level._challenges.s_team;
+		s_team_stats.n_completed = 1;
+		s_team_stats.n_medals_held = 1;
+		a_keys = getarraykeys( level._challenges.s_team.a_stats );
+		s_stat = level._challenges.s_team.a_stats[ a_keys[ 0 ] ];
+		s_stat.b_medal_awarded = 1;
+		s_stat.b_reward_claimed = 0;
+		a_players = get_players();
+		_a1055 = a_players;
+		_k1055 = getFirstArrayKey( _a1055 );
+		while ( isDefined( _k1055 ) )
+		{
+			player = _a1055[ _k1055 ];
+			s_stat.a_b_player_rewarded[ player.characterindex ] = 0;
+			player setclientfieldtoplayer( s_stat.s_parent.cf_complete, 1 );
+			_k1055 = getNextArrayKey( _a1055, _k1055 );
+		}
+		_a1061 = level.a_m_challenge_boards;
+		_k1061 = getFirstArrayKey( _a1061 );
+		while ( isDefined( _k1061 ) )
+		{
+			m_board = _a1061[ _k1061 ];
+			m_board showpart( s_stat.str_glow_tag );
+			_k1061 = getNextArrayKey( _a1061, _k1061 );
+		}
+	}
+	else a_keys = getarraykeys( level._challenges.a_players[ 0 ].a_stats );
+	a_players = get_players();
+	_a1071 = a_players;
+	_k1071 = getFirstArrayKey( _a1071 );
+	while ( isDefined( _k1071 ) )
+	{
+		player = _a1071[ _k1071 ];
+		s_player_data = level._challenges.a_players[ player.characterindex ];
+		s_player_data.n_completed++;
+		s_player_data.n_medals_held++;
+		s_stat = s_player_data.a_stats[ a_keys[ n_index - 1 ] ];
+		s_stat.b_medal_awarded = 1;
+		s_stat.b_reward_claimed = 0;
+		player setclientfieldtoplayer( s_stat.s_parent.cf_complete, 1 );
+		_a1082 = level.a_m_challenge_boards;
+		_k1082 = getFirstArrayKey( _a1082 );
+		while ( isDefined( _k1082 ) )
+		{
+			m_board = _a1082[ _k1082 ];
+			m_board showpart( s_stat.str_glow_tag );
+			_k1082 = getNextArrayKey( _a1082, _k1082 );
+		}
+		_k1071 = getNextArrayKey( _a1071, _k1071 );
+#/
+	}
+}

zm_tomb_patch/maps/mp/zombies/_zm_magicbox_tomb.gsc

@@ -0,0 +1,298 @@
+#include maps/mp/zombies/_zm_magicbox;
+#include maps/mp/zombies/_zm_unitrigger;
+#include maps/mp/zombies/_zm_weapons;
+#include maps/mp/zombies/_zm_utility;
+#include maps/mp/_utility;
+#include common_scripts/utility;
+
+init()
+{
+	registerclientfield( "zbarrier", "magicbox_initial_fx", 2000, 1, "int" );
+	registerclientfield( "zbarrier", "magicbox_amb_fx", 2000, 2, "int" );
+	registerclientfield( "zbarrier", "magicbox_open_fx", 2000, 1, "int" );
+	registerclientfield( "zbarrier", "magicbox_leaving_fx", 2000, 1, "int" );
+	level._effect[ "lght_marker" ] = loadfx( "maps/zombie_tomb/fx_tomb_marker" );
+	level._effect[ "lght_marker_flare" ] = loadfx( "maps/zombie/fx_zmb_tranzit_marker_fl" );
+	level._effect[ "poltergeist" ] = loadfx( "system_elements/fx_null" );
+	level._effect[ "box_powered" ] = loadfx( "maps/zombie_tomb/fx_tomb_magicbox_on" );
+	level._effect[ "box_unpowered" ] = loadfx( "maps/zombie_tomb/fx_tomb_magicbox_off" );
+	level._effect[ "box_gone_ambient" ] = loadfx( "maps/zombie_tomb/fx_tomb_magicbox_amb_base" );
+	level._effect[ "box_here_ambient" ] = loadfx( "maps/zombie_tomb/fx_tomb_magicbox_amb_slab" );
+	level._effect[ "box_is_open" ] = loadfx( "maps/zombie_tomb/fx_tomb_magicbox_open" );
+	level._effect[ "box_portal" ] = loadfx( "maps/zombie_tomb/fx_tomb_magicbox_portal" );
+	level._effect[ "box_is_leaving" ] = loadfx( "maps/zombie_tomb/fx_tomb_magicbox_leave" );
+	level.chest_joker_model = "zombie_teddybear";
+	precachemodel( level.chest_joker_model );
+	level.chest_joker_custom_movement = ::custom_joker_movement;
+	level.custom_magic_box_timer_til_despawn = ::custom_magic_box_timer_til_despawn;
+	level.custom_magic_box_do_weapon_rise = ::custom_magic_box_do_weapon_rise;
+	level.custom_magic_box_weapon_wait = ::custom_magic_box_weapon_wait;
+	level.custom_magicbox_float_height = 50;
+	level.magic_box_zbarrier_state_func = ::set_magic_box_zbarrier_state;
+	level thread wait_then_create_base_magic_box_fx();
+	level thread handle_fire_sale();
+}
+
+custom_joker_movement()
+{
+	v_origin = self.weapon_model.origin - vectorScale( ( 0, 1, 0 ), 5 );
+	self.weapon_model delete();
+	m_lock = spawn( "script_model", v_origin );
+	m_lock setmodel( level.chest_joker_model );
+	m_lock.angles = self.angles + vectorScale( ( 0, 1, 0 ), 270 );
+	m_lock playsound( "zmb_hellbox_bear" );
+	wait 0,5;
+	level notify( "weapon_fly_away_start" );
+	wait 1;
+	m_lock rotateyaw( 3000, 4, 4 );
+	wait 3;
+	v_angles = anglesToForward( self.angles - vectorScale( ( 0, 1, 0 ), 90 ) );
+	m_lock moveto( m_lock.origin + ( 20 * v_angles ), 0,5, 0,5 );
+	m_lock waittill( "movedone" );
+	m_lock moveto( m_lock.origin + ( -100 * v_angles ), 0,5, 0,5 );
+	m_lock waittill( "movedone" );
+	m_lock delete();
+	self notify( "box_moving" );
+	level notify( "weapon_fly_away_end" );
+}
+
+custom_magic_box_timer_til_despawn( magic_box )
+{
+	self endon( "kill_weapon_movement" );
+	putbacktime = 12;
+	v_float = anglesToForward( magic_box.angles - vectorScale( ( 0, 1, 0 ), 90 ) ) * 40;
+	self moveto( self.origin - ( v_float * 0,25 ), putbacktime, putbacktime * 0,5 );
+	wait putbacktime;
+	if ( isDefined( self ) )
+	{
+		self delete();
+	}
+}
+
+custom_magic_box_weapon_wait()
+{
+	wait 0,5;
+}
+
+wait_then_create_base_magic_box_fx()
+{
+	while ( !isDefined( level.chests ) )
+	{
+		wait 0,5;
+	}
+	while ( !isDefined( level.chests[ level.chests.size - 1 ].zbarrier ) )
+	{
+		wait 0,5;
+	}
+	_a125 = level.chests;
+	_k125 = getFirstArrayKey( _a125 );
+	while ( isDefined( _k125 ) )
+	{
+		chest = _a125[ _k125 ];
+		chest.zbarrier setclientfield( "magicbox_initial_fx", 1 );
+		_k125 = getNextArrayKey( _a125, _k125 );
+	}
+}
+
+set_magic_box_zbarrier_state( state )
+{
+	i = 0;
+	while ( i < self getnumzbarrierpieces() )
+	{
+		self hidezbarrierpiece( i );
+		i++;
+	}
+	self notify( "zbarrier_state_change" );
+	switch( state )
+	{
+		case "away":
+			self showzbarrierpiece( 0 );
+			self.state = "away";
+			self.owner.is_locked = 0;
+			break;
+		case "arriving":
+			self showzbarrierpiece( 1 );
+			self thread magic_box_arrives();
+			self.state = "arriving";
+			break;
+		case "initial":
+			self showzbarrierpiece( 1 );
+			self thread magic_box_initial();
+			thread maps/mp/zombies/_zm_unitrigger::register_static_unitrigger( self.owner.unitrigger_stub, ::maps/mp/zombies/_zm_magicbox::magicbox_unitrigger_think );
+			self.state = "close";
+			break;
+		case "open":
+			self showzbarrierpiece( 2 );
+			self thread magic_box_opens();
+			self.state = "open";
+			break;
+		case "close":
+			self showzbarrierpiece( 2 );
+			self thread magic_box_closes();
+			self.state = "close";
+			break;
+		case "leaving":
+			self showzbarrierpiece( 1 );
+			self thread magic_box_leaves();
+			self.state = "leaving";
+			self.owner.is_locked = 0;
+			break;
+		default:
+			if ( isDefined( level.custom_magicbox_state_handler ) )
+			{
+				self [[ level.custom_magicbox_state_handler ]]( state );
+			}
+			break;
+	}
+}
+
+magic_box_initial()
+{
+	self setzbarrierpiecestate( 1, "open" );
+	wait 1;
+	self setclientfield( "magicbox_amb_fx", 1 );
+}
+
+magic_box_arrives()
+{
+	self setclientfield( "magicbox_leaving_fx", 0 );
+	self setzbarrierpiecestate( 1, "opening" );
+	while ( self getzbarrierpiecestate( 1 ) == "opening" )
+	{
+		wait 0,05;
+	}
+	self notify( "arrived" );
+	self.state = "close";
+	s_zone_capture_area = level.zone_capture.zones[ self.zone_capture_area ];
+	if ( isDefined( s_zone_capture_area ) )
+	{
+		if ( !s_zone_capture_area ent_flag( "player_controlled" ) )
+		{
+			self setclientfield( "magicbox_amb_fx", 1 );
+			return;
+		}
+		else
+		{
+			self setclientfield( "magicbox_amb_fx", 2 );
+		}
+	}
+}
+
+magic_box_leaves()
+{
+	self setclientfield( "magicbox_leaving_fx", 1 );
+	self setclientfield( "magicbox_open_fx", 0 );
+	self setzbarrierpiecestate( 1, "closing" );
+	self playsound( "zmb_hellbox_rise" );
+	while ( self getzbarrierpiecestate( 1 ) == "closing" )
+	{
+		wait 0,1;
+	}
+	self notify( "left" );
+	s_zone_capture_area = level.zone_capture.zones[ self.zone_capture_area ];
+	if ( isDefined( s_zone_capture_area ) )
+	{
+		if ( s_zone_capture_area ent_flag( "player_controlled" ) )
+		{
+			self setclientfield( "magicbox_amb_fx", 3 );
+		}
+		else
+		{
+			self setclientfield( "magicbox_amb_fx", 0 );
+		}
+	}
+	if ( isDefined( level.dig_magic_box_moved ) && !level.dig_magic_box_moved )
+	{
+		level.dig_magic_box_moved = 1;
+	}
+}
+
+magic_box_opens()
+{
+	self setclientfield( "magicbox_open_fx", 1 );
+	self setzbarrierpiecestate( 2, "opening" );
+	self playsound( "zmb_hellbox_open" );
+	while ( self getzbarrierpiecestate( 2 ) == "opening" )
+	{
+		wait 0,1;
+	}
+	self notify( "opened" );
+	self thread magic_box_open_idle();
+}
+
+magic_box_open_idle()
+{
+	self endon( "stop_open_idle" );
+	self hidezbarrierpiece( 2 );
+	self showzbarrierpiece( 5 );
+	while ( 1 )
+	{
+		self setzbarrierpiecestate( 5, "opening" );
+		while ( self getzbarrierpiecestate( 5 ) != "open" )
+		{
+			wait 0,05;
+		}
+	}
+}
+
+magic_box_closes()
+{
+	self notify( "stop_open_idle" );
+	self hidezbarrierpiece( 5 );
+	self showzbarrierpiece( 2 );
+	self setzbarrierpiecestate( 2, "closing" );
+	self playsound( "zmb_hellbox_close" );
+	self setclientfield( "magicbox_open_fx", 0 );
+	while ( self getzbarrierpiecestate( 2 ) == "closing" )
+	{
+		wait 0,1;
+	}
+	self notify( "closed" );
+}
+
+custom_magic_box_do_weapon_rise()
+{
+	self endon( "box_hacked_respin" );
+	wait 0,5;
+	self setzbarrierpiecestate( 3, "closed" );
+	self setzbarrierpiecestate( 4, "closed" );
+	wait_network_frame();
+	self zbarrierpieceuseboxriselogic( 3 );
+	self zbarrierpieceuseboxriselogic( 4 );
+	self showzbarrierpiece( 3 );
+	self showzbarrierpiece( 4 );
+	self setzbarrierpiecestate( 3, "opening" );
+	self setzbarrierpiecestate( 4, "opening" );
+	while ( self getzbarrierpiecestate( 3 ) != "open" )
+	{
+		wait 0,5;
+	}
+	self hidezbarrierpiece( 3 );
+	self hidezbarrierpiece( 4 );
+}
+
+handle_fire_sale()
+{
+	while ( 1 )
+	{
+		level waittill( "fire_sale_off" );
+		i = 0;
+		while ( i < level.chests.size )
+		{
+			if ( level.chest_index != i && isDefined( level.chests[ i ].was_temp ) )
+			{
+				if ( isDefined( level.chests[ i ].zbarrier.zone_capture_area ) && level.zone_capture.zones[ level.chests[ i ].zbarrier.zone_capture_area ] ent_flag( "player_controlled" ) )
+				{
+					level.chests[ i ].zbarrier setclientfield( "magicbox_amb_fx", 3 );
+					i++;
+					continue;
+				}
+				else
+				{
+					level.chests[ i ].zbarrier setclientfield( "magicbox_amb_fx", 0 );
+				}
+			}
+			i++;
+		}
+	}
+}

zm_tomb_patch/maps/mp/zombies/_zm_melee_weapon.gsc

@@ -0,0 +1,627 @@
+#include maps/mp/zombies/_zm_audio;
+#include maps/mp/zombies/_zm_score;
+#include maps/mp/zombies/_zm_pers_upgrades_functions;
+#include maps/mp/zombies/_zm_laststand;
+#include maps/mp/zombies/_zm_weapons;
+#include maps/mp/zombies/_zm_utility;
+#include maps/mp/_utility;
+#include common_scripts/utility;
+
+init( weapon_name, flourish_weapon_name, ballistic_weapon_name, ballistic_upgraded_weapon_name, cost, wallbuy_targetname, hint_string, vo_dialog_id, flourish_fn )
+{
+	precacheitem( weapon_name );
+	precacheitem( flourish_weapon_name );
+	add_melee_weapon( weapon_name, flourish_weapon_name, ballistic_weapon_name, ballistic_upgraded_weapon_name, cost, wallbuy_targetname, hint_string, vo_dialog_id, flourish_fn );
+	melee_weapon_triggers = getentarray( wallbuy_targetname, "targetname" );
+	i = 0;
+	while ( i < melee_weapon_triggers.size )
+	{
+		knife_model = getent( melee_weapon_triggers[ i ].target, "targetname" );
+		if ( isDefined( knife_model ) )
+		{
+			knife_model hide();
+		}
+		melee_weapon_triggers[ i ] thread melee_weapon_think( weapon_name, cost, flourish_fn, vo_dialog_id, flourish_weapon_name, ballistic_weapon_name, ballistic_upgraded_weapon_name );
+		if ( isDefined( level.monolingustic_prompt_format ) && !level.monolingustic_prompt_format )
+		{
+			melee_weapon_triggers[ i ] sethintstring( hint_string, cost );
+			if ( getDvarInt( #"1F0A2129" ) && isDefined( level.disable_melee_wallbuy_icons ) && !level.disable_melee_wallbuy_icons )
+			{
+				cursor_hint = "HINT_WEAPON";
+				cursor_hint_weapon = weapon_name;
+				melee_weapon_triggers[ i ] setcursorhint( cursor_hint, cursor_hint_weapon );
+			}
+			else
+			{
+				melee_weapon_triggers[ i ] setcursorhint( "HINT_NOICON" );
+			}
+		}
+		else
+		{
+			weapon_display = get_weapon_display_name( weapon_name );
+			hint_string = &"ZOMBIE_WEAPONCOSTONLY";
+			melee_weapon_triggers[ i ] sethintstring( hint_string, weapon_display, cost );
+			if ( getDvarInt( #"1F0A2129" ) && isDefined( level.disable_melee_wallbuy_icons ) && !level.disable_melee_wallbuy_icons )
+			{
+				cursor_hint = "HINT_WEAPON";
+				cursor_hint_weapon = weapon_name;
+				melee_weapon_triggers[ i ] setcursorhint( cursor_hint, cursor_hint_weapon );
+				break;
+			}
+			else
+			{
+				melee_weapon_triggers[ i ] setcursorhint( "HINT_NOICON" );
+			}
+		}
+		melee_weapon_triggers[ i ] usetriggerrequirelookat();
+		i++;
+	}
+	melee_weapon_structs = getstructarray( wallbuy_targetname, "targetname" );
+	i = 0;
+	while ( i < melee_weapon_structs.size )
+	{
+		prepare_stub( melee_weapon_structs[ i ].trigger_stub, weapon_name, flourish_weapon_name, ballistic_weapon_name, ballistic_upgraded_weapon_name, cost, wallbuy_targetname, hint_string, vo_dialog_id, flourish_fn );
+		i++;
+	}
+	register_melee_weapon_for_level( weapon_name );
+	if ( !isDefined( level.ballistic_weapon_name ) )
+	{
+		level.ballistic_weapon_name = [];
+	}
+	level.ballistic_weapon_name[ weapon_name ] = ballistic_weapon_name;
+	if ( !isDefined( level.ballistic_upgraded_weapon_name ) )
+	{
+		level.ballistic_upgraded_weapon_name = [];
+	}
+	level.ballistic_upgraded_weapon_name[ weapon_name ] = ballistic_upgraded_weapon_name;
+/#
+	if ( !isDefined( level.zombie_weapons[ weapon_name ] ) )
+	{
+		if ( isDefined( level.devgui_add_weapon ) )
+		{
+			[[ level.devgui_add_weapon ]]( weapon_name, "", weapon_name, cost );
+#/
+		}
+	}
+}
+
+prepare_stub( stub, weapon_name, flourish_weapon_name, ballistic_weapon_name, ballistic_upgraded_weapon_name, cost, wallbuy_targetname, hint_string, vo_dialog_id, flourish_fn )
+{
+	if ( isDefined( stub ) )
+	{
+		if ( isDefined( level.monolingustic_prompt_format ) && !level.monolingustic_prompt_format )
+		{
+			stub.hint_string = hint_string;
+			if ( getDvarInt( #"1F0A2129" ) && isDefined( level.disable_melee_wallbuy_icons ) && !level.disable_melee_wallbuy_icons )
+			{
+				stub.cursor_hint = "HINT_WEAPON";
+				stub.cursor_hint_weapon = weapon_name;
+			}
+			else
+			{
+				stub.cursor_hint = "HINT_NOICON";
+				stub.cursor_hint_weapon = undefined;
+			}
+		}
+		else
+		{
+			stub.hint_parm1 = get_weapon_display_name( weapon_name );
+			stub.hint_parm2 = cost;
+			stub.hint_string = &"ZOMBIE_WEAPONCOSTONLY";
+			if ( getDvarInt( #"1F0A2129" ) && isDefined( level.disable_melee_wallbuy_icons ) && !level.disable_melee_wallbuy_icons )
+			{
+				stub.cursor_hint = "HINT_WEAPON";
+				stub.cursor_hint_weapon = weapon_name;
+			}
+			else
+			{
+				stub.cursor_hint = "HINT_NOICON";
+				stub.cursor_hint_weapon = undefined;
+			}
+		}
+		stub.cost = cost;
+		stub.weapon_name = weapon_name;
+		stub.vo_dialog_id = vo_dialog_id;
+		stub.flourish_weapon_name = flourish_weapon_name;
+		stub.ballistic_weapon_name = ballistic_weapon_name;
+		stub.ballistic_upgraded_weapon_name = ballistic_upgraded_weapon_name;
+		stub.trigger_func = ::melee_weapon_think;
+		stub.flourish_fn = flourish_fn;
+	}
+}
+
+add_stub( stub, weapon_name )
+{
+	melee_weapon = undefined;
+	i = 0;
+	while ( i < level._melee_weapons.size )
+	{
+		if ( level._melee_weapons[ i ].weapon_name == weapon_name )
+		{
+			melee_weapon = level._melee_weapons[ i ];
+			break;
+		}
+		else
+		{
+			i++;
+		}
+	}
+	if ( isDefined( stub ) && isDefined( melee_weapon ) )
+	{
+		prepare_stub( stub, melee_weapon.weapon_name, melee_weapon.flourish_weapon_name, melee_weapon.ballistic_weapon_name, melee_weapon.ballistic_upgraded_weapon_name, melee_weapon.cost, melee_weapon.wallbuy_targetname, melee_weapon.hint_string, melee_weapon.vo_dialog_id, melee_weapon.flourish_fn );
+	}
+}
+
+give_melee_weapon_by_name( weapon_name )
+{
+	melee_weapon = undefined;
+	i = 0;
+	while ( i < level._melee_weapons.size )
+	{
+		if ( level._melee_weapons[ i ].weapon_name == weapon_name )
+		{
+			melee_weapon = level._melee_weapons[ i ];
+			break;
+		}
+		else
+		{
+			i++;
+		}
+	}
+	if ( isDefined( melee_weapon ) )
+	{
+		self thread give_melee_weapon( melee_weapon.vo_dialog_id, melee_weapon.flourish_weapon_name, melee_weapon.weapon_name, melee_weapon.ballistic_weapon_name, melee_weapon.ballistic_upgraded_weapon_name, melee_weapon.flourish_fn, undefined );
+	}
+}
+
+add_melee_weapon( weapon_name, flourish_weapon_name, ballistic_weapon_name, ballistic_upgraded_weapon_name, cost, wallbuy_targetname, hint_string, vo_dialog_id, flourish_fn )
+{
+	melee_weapon = spawnstruct();
+	melee_weapon.weapon_name = weapon_name;
+	melee_weapon.flourish_weapon_name = flourish_weapon_name;
+	melee_weapon.ballistic_weapon_name = ballistic_weapon_name;
+	melee_weapon.ballistic_upgraded_weapon_name = ballistic_upgraded_weapon_name;
+	melee_weapon.cost = cost;
+	melee_weapon.wallbuy_targetname = wallbuy_targetname;
+	melee_weapon.hint_string = hint_string;
+	melee_weapon.vo_dialog_id = vo_dialog_id;
+	melee_weapon.flourish_fn = flourish_fn;
+	if ( !isDefined( level._melee_weapons ) )
+	{
+		level._melee_weapons = [];
+	}
+	level._melee_weapons[ level._melee_weapons.size ] = melee_weapon;
+}
+
+player_can_see_weapon_prompt( weapon_name )
+{
+	if ( is_true( level._allow_melee_weapon_switching ) )
+	{
+		return 1;
+	}
+	if ( isDefined( self get_player_melee_weapon() ) && self hasweapon( self get_player_melee_weapon() ) )
+	{
+		return 0;
+	}
+	return 1;
+}
+
+spectator_respawn_all()
+{
+	i = 0;
+	while ( i < level._melee_weapons.size )
+	{
+		self spectator_respawn( level._melee_weapons[ i ].wallbuy_targetname, level._melee_weapons[ i ].weapon_name );
+		i++;
+	}
+}
+
+spectator_respawn( wallbuy_targetname, weapon_name )
+{
+	melee_triggers = getentarray( wallbuy_targetname, "targetname" );
+	players = get_players();
+	i = 0;
+	while ( i < melee_triggers.size )
+	{
+		melee_triggers[ i ] setvisibletoall();
+		while ( isDefined( level._allow_melee_weapon_switching ) && !level._allow_melee_weapon_switching )
+		{
+			j = 0;
+			while ( j < players.size )
+			{
+				if ( !players[ j ] player_can_see_weapon_prompt( weapon_name ) )
+				{
+					melee_triggers[ i ] setinvisibletoplayer( players[ j ] );
+				}
+				j++;
+			}
+		}
+		i++;
+	}
+}
+
+trigger_hide_all()
+{
+	i = 0;
+	while ( i < level._melee_weapons.size )
+	{
+		self trigger_hide( level._melee_weapons[ i ].wallbuy_targetname );
+		i++;
+	}
+}
+
+trigger_hide( wallbuy_targetname )
+{
+	melee_triggers = getentarray( wallbuy_targetname, "targetname" );
+	i = 0;
+	while ( i < melee_triggers.size )
+	{
+		melee_triggers[ i ] setinvisibletoplayer( self );
+		i++;
+	}
+}
+
+has_any_ballistic_knife()
+{
+	if ( self hasweapon( "knife_ballistic_zm" ) )
+	{
+		return 1;
+	}
+	if ( self hasweapon( "knife_ballistic_upgraded_zm" ) )
+	{
+		return 1;
+	}
+	i = 0;
+	while ( i < level._melee_weapons.size )
+	{
+		if ( self hasweapon( level._melee_weapons[ i ].ballistic_weapon_name ) )
+		{
+			return 1;
+		}
+		if ( self hasweapon( level._melee_weapons[ i ].ballistic_upgraded_weapon_name ) )
+		{
+			return 1;
+		}
+		i++;
+	}
+	return 0;
+}
+
+has_upgraded_ballistic_knife()
+{
+	if ( self hasweapon( "knife_ballistic_upgraded_zm" ) )
+	{
+		return 1;
+	}
+	i = 0;
+	while ( i < level._melee_weapons.size )
+	{
+		if ( self hasweapon( level._melee_weapons[ i ].ballistic_upgraded_weapon_name ) )
+		{
+			return 1;
+		}
+		i++;
+	}
+	return 0;
+}
+
+give_ballistic_knife( weapon_string, upgraded )
+{
+	current_melee_weapon = self get_player_melee_weapon();
+	if ( isDefined( current_melee_weapon ) )
+	{
+		if ( upgraded && isDefined( level.ballistic_upgraded_weapon_name ) && isDefined( level.ballistic_upgraded_weapon_name[ current_melee_weapon ] ) )
+		{
+			weapon_string = level.ballistic_upgraded_weapon_name[ current_melee_weapon ];
+		}
+		if ( !upgraded && isDefined( level.ballistic_weapon_name ) && isDefined( level.ballistic_weapon_name[ current_melee_weapon ] ) )
+		{
+			weapon_string = level.ballistic_weapon_name[ current_melee_weapon ];
+		}
+	}
+	return weapon_string;
+}
+
+change_melee_weapon( weapon_name, current_weapon )
+{
+	current_melee_weapon = self get_player_melee_weapon();
+	if ( isDefined( current_melee_weapon ) && current_melee_weapon != weapon_name )
+	{
+		self takeweapon( current_melee_weapon );
+		unacquire_weapon_toggle( current_melee_weapon );
+	}
+	self set_player_melee_weapon( weapon_name );
+	had_ballistic = 0;
+	had_ballistic_upgraded = 0;
+	ballistic_was_primary = 0;
+	primaryweapons = self getweaponslistprimaries();
+	i = 0;
+	while ( i < primaryweapons.size )
+	{
+		primary_weapon = primaryweapons[ i ];
+		if ( issubstr( primary_weapon, "knife_ballistic_" ) )
+		{
+			had_ballistic = 1;
+			if ( primary_weapon == current_weapon )
+			{
+				ballistic_was_primary = 1;
+			}
+			self notify( "zmb_lost_knife" );
+			self takeweapon( primary_weapon );
+			unacquire_weapon_toggle( primary_weapon );
+			if ( issubstr( primary_weapon, "upgraded" ) )
+			{
+				had_ballistic_upgraded = 1;
+			}
+		}
+		i++;
+	}
+	if ( had_ballistic )
+	{
+		if ( had_ballistic_upgraded )
+		{
+			new_ballistic = level.ballistic_upgraded_weapon_name[ weapon_name ];
+			if ( ballistic_was_primary )
+			{
+				current_weapon = new_ballistic;
+			}
+			self giveweapon( new_ballistic, 0, self maps/mp/zombies/_zm_weapons::get_pack_a_punch_weapon_options( new_ballistic ) );
+		}
+		else
+		{
+			new_ballistic = level.ballistic_weapon_name[ weapon_name ];
+			if ( ballistic_was_primary )
+			{
+				current_weapon = new_ballistic;
+			}
+			self giveweapon( new_ballistic, 0 );
+		}
+	}
+	return current_weapon;
+}
+
+melee_weapon_think( weapon_name, cost, flourish_fn, vo_dialog_id, flourish_weapon_name, ballistic_weapon_name, ballistic_upgraded_weapon_name )
+{
+	self.first_time_triggered = 0;
+	while ( isDefined( self.stub ) )
+	{
+		self endon( "kill_trigger" );
+		if ( isDefined( self.stub.first_time_triggered ) )
+		{
+			self.first_time_triggered = self.stub.first_time_triggered;
+		}
+		weapon_name = self.stub.weapon_name;
+		cost = self.stub.cost;
+		flourish_fn = self.stub.flourish_fn;
+		vo_dialog_id = self.stub.vo_dialog_id;
+		flourish_weapon_name = self.stub.flourish_weapon_name;
+		ballistic_weapon_name = self.stub.ballistic_weapon_name;
+		ballistic_upgraded_weapon_name = self.stub.ballistic_upgraded_weapon_name;
+		players = getplayers();
+		while ( isDefined( level._allow_melee_weapon_switching ) && !level._allow_melee_weapon_switching )
+		{
+			i = 0;
+			while ( i < players.size )
+			{
+				if ( !players[ i ] player_can_see_weapon_prompt( weapon_name ) )
+				{
+					self setinvisibletoplayer( players[ i ] );
+				}
+				i++;
+			}
+		}
+	}
+	for ( ;; )
+	{
+		self waittill( "trigger", player );
+		if ( !is_player_valid( player ) )
+		{
+			player thread ignore_triggers( 0,5 );
+			continue;
+		}
+		else if ( player in_revive_trigger() )
+		{
+			wait 0,1;
+			continue;
+		}
+		else if ( player isthrowinggrenade() )
+		{
+			wait 0,1;
+			continue;
+		}
+		else if ( player.is_drinking > 0 )
+		{
+			wait 0,1;
+			continue;
+		}
+		else if ( player hasweapon( weapon_name ) || player has_powerup_weapon() )
+		{
+			wait 0,1;
+			continue;
+		}
+		else
+		{
+			if ( player isswitchingweapons() )
+			{
+				wait 0,1;
+				break;
+			}
+			else current_weapon = player getcurrentweapon();
+			if ( !is_placeable_mine( current_weapon ) || is_equipment( current_weapon ) && player has_powerup_weapon() )
+			{
+				wait 0,1;
+				break;
+			}
+			else
+			{
+				if ( player maps/mp/zombies/_zm_laststand::player_is_in_laststand() || isDefined( player.intermission ) && player.intermission )
+				{
+					wait 0,1;
+					break;
+				}
+				else
+				{
+					player_has_weapon = player hasweapon( weapon_name );
+					if ( !player_has_weapon )
+					{
+						cost = self.stub.cost;
+						if ( player maps/mp/zombies/_zm_pers_upgrades_functions::is_pers_double_points_active() )
+						{
+							cost = int( cost / 2 );
+						}
+						if ( player.score >= cost )
+						{
+							if ( self.first_time_triggered == 0 )
+							{
+								model = getent( self.target, "targetname" );
+								if ( isDefined( model ) )
+								{
+									model thread melee_weapon_show( player );
+								}
+								else
+								{
+									if ( isDefined( self.clientfieldname ) )
+									{
+										level setclientfield( self.clientfieldname, 1 );
+									}
+								}
+								self.first_time_triggered = 1;
+								if ( isDefined( self.stub ) )
+								{
+									self.stub.first_time_triggered = 1;
+								}
+							}
+							player maps/mp/zombies/_zm_score::minus_to_player_score( cost, 1 );
+							bbprint( "zombie_uses", "playername %s playerscore %d round %d cost %d name %s x %f y %f z %f type %s", player.name, player.score, level.round_number, cost, weapon_name, self.origin, "weapon" );
+							player thread give_melee_weapon( vo_dialog_id, flourish_weapon_name, weapon_name, ballistic_weapon_name, ballistic_upgraded_weapon_name, flourish_fn, self );
+						}
+						else
+						{
+							play_sound_on_ent( "no_purchase" );
+							player maps/mp/zombies/_zm_audio::create_and_play_dialog( "general", "no_money_weapon", undefined, 1 );
+						}
+						break;
+					}
+					else
+					{
+						if ( isDefined( level._allow_melee_weapon_switching ) && !level._allow_melee_weapon_switching )
+						{
+							self setinvisibletoplayer( player );
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+melee_weapon_show( player )
+{
+	player_angles = vectorToAngle( player.origin - self.origin );
+	player_yaw = player_angles[ 1 ];
+	weapon_yaw = self.angles[ 1 ];
+	yaw_diff = angleClamp180( player_yaw - weapon_yaw );
+	if ( yaw_diff > 0 )
+	{
+		yaw = weapon_yaw - 90;
+	}
+	else
+	{
+		yaw = weapon_yaw + 90;
+	}
+	self.og_origin = self.origin;
+	self.origin += anglesToForward( ( 0, yaw, 0 ) ) * 8;
+	wait 0,05;
+	self show();
+	play_sound_at_pos( "weapon_show", self.origin, self );
+	time = 1;
+	self moveto( self.og_origin, time );
+}
+
+give_melee_weapon( vo_dialog_id, flourish_weapon_name, weapon_name, ballistic_weapon_name, ballistic_upgraded_weapon_name, flourish_fn, trigger )
+{
+	if ( isDefined( flourish_fn ) )
+	{
+		self thread [[ flourish_fn ]]();
+	}
+	gun = self do_melee_weapon_flourish_begin( flourish_weapon_name );
+	self maps/mp/zombies/_zm_audio::create_and_play_dialog( "weapon_pickup", vo_dialog_id );
+	self waittill_any( "fake_death", "death", "player_downed", "weapon_change_complete" );
+	self do_melee_weapon_flourish_end( gun, flourish_weapon_name, weapon_name, ballistic_weapon_name, ballistic_upgraded_weapon_name );
+	if ( self maps/mp/zombies/_zm_laststand::player_is_in_laststand() || isDefined( self.intermission ) && self.intermission )
+	{
+		return;
+	}
+	if ( isDefined( level._allow_melee_weapon_switching ) && !level._allow_melee_weapon_switching )
+	{
+		if ( isDefined( trigger ) )
+		{
+			trigger setinvisibletoplayer( self );
+		}
+		self trigger_hide_all();
+	}
+}
+
+do_melee_weapon_flourish_begin( flourish_weapon_name )
+{
+	self increment_is_drinking();
+	self disable_player_move_states( 1 );
+	gun = self getcurrentweapon();
+	weapon = flourish_weapon_name;
+	self giveweapon( weapon );
+	self switchtoweapon( weapon );
+	return gun;
+}
+
+do_melee_weapon_flourish_end( gun, flourish_weapon_name, weapon_name, ballistic_weapon_name, ballistic_upgraded_weapon_name )
+{
+/#
+	assert( !is_zombie_perk_bottle( gun ) );
+#/
+/#
+	assert( gun != level.revive_tool );
+#/
+	self enable_player_move_states();
+	weapon = flourish_weapon_name;
+	if ( self maps/mp/zombies/_zm_laststand::player_is_in_laststand() || isDefined( self.intermission ) && self.intermission )
+	{
+		self takeweapon( weapon );
+		self.lastactiveweapon = "none";
+		return;
+	}
+	self takeweapon( weapon );
+	self giveweapon( weapon_name );
+	gun = change_melee_weapon( weapon_name, gun );
+	if ( self hasweapon( "knife_zm" ) )
+	{
+		self takeweapon( "knife_zm" );
+	}
+	if ( self is_multiple_drinking() )
+	{
+		self decrement_is_drinking();
+		return;
+	}
+	else if ( gun == "knife_zm" )
+	{
+		self switchtoweapon( weapon_name );
+		self decrement_is_drinking();
+		return;
+	}
+	else if ( gun != "none" && !is_placeable_mine( gun ) && !is_equipment( gun ) )
+	{
+		self switchtoweapon( gun );
+	}
+	else
+	{
+		primaryweapons = self getweaponslistprimaries();
+		if ( isDefined( primaryweapons ) && primaryweapons.size > 0 )
+		{
+			self switchtoweapon( primaryweapons[ 0 ] );
+		}
+	}
+	self waittill( "weapon_change_complete" );
+	if ( !self maps/mp/zombies/_zm_laststand::player_is_in_laststand() && isDefined( self.intermission ) && !self.intermission )
+	{
+		self decrement_is_drinking();
+	}
+}

zm_tomb_patch/maps/mp/zombies/_zm_perk_divetonuke.gsc

@@ -0,0 +1,180 @@
+#include maps/mp/_visionset_mgr;
+#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_divetonuke_perk_for_level()
+{
+	maps/mp/zombies/_zm_perks::register_perk_basic_info( "specialty_flakjacket", "divetonuke", 2000, &"ZOMBIE_PERK_DIVETONUKE", "zombie_perk_bottle_nuke" );
+	maps/mp/zombies/_zm_perks::register_perk_precache_func( "specialty_flakjacket", ::divetonuke_precache );
+	maps/mp/zombies/_zm_perks::register_perk_clientfields( "specialty_flakjacket", ::divetonuke_register_clientfield, ::divetonuke_set_clientfield );
+	maps/mp/zombies/_zm_perks::register_perk_machine( "specialty_flakjacket", ::divetonuke_perk_machine_setup, ::divetonuke_perk_machine_think );
+	maps/mp/zombies/_zm_perks::register_perk_host_migration_func( "specialty_flakjacket", ::divetonuke_host_migration_func );
+}
+
+init_divetonuke()
+{
+	level.zombiemode_divetonuke_perk_func = ::divetonuke_explode;
+	maps/mp/_visionset_mgr::vsmgr_register_info( "visionset", "zm_perk_divetonuke", 9000, 400, 5, 1 );
+	level._effect[ "divetonuke_groundhit" ] = loadfx( "maps/zombie/fx_zmb_phdflopper_exp" );
+	set_zombie_var( "zombie_perk_divetonuke_radius", 300 );
+	set_zombie_var( "zombie_perk_divetonuke_min_damage", 1000 );
+	set_zombie_var( "zombie_perk_divetonuke_max_damage", 5000 );
+}
+
+divetonuke_precache()
+{
+	if ( isDefined( level.divetonuke_precache_override_func ) )
+	{
+		[[ level.divetonuke_precache_override_func ]]();
+		return;
+	}
+	precacheitem( "zombie_perk_bottle_nuke" );
+	precacheshader( "specialty_divetonuke_zombies" );
+	precachemodel( "zombie_vending_nuke" );
+	precachemodel( "zombie_vending_nuke_on" );
+	precachestring( &"ZOMBIE_PERK_DIVETONUKE" );
+	level._effect[ "divetonuke_light" ] = loadfx( "misc/fx_zombie_cola_dtap_on" );
+	level.machine_assets[ "divetonuke" ] = spawnstruct();
+	level.machine_assets[ "divetonuke" ].weapon = "zombie_perk_bottle_nuke";
+	level.machine_assets[ "divetonuke" ].off_model = "zombie_vending_nuke";
+	level.machine_assets[ "divetonuke" ].on_model = "zombie_vending_nuke_on";
+}
+
+divetonuke_register_clientfield()
+{
+	registerclientfield( "toplayer", "perk_dive_to_nuke", 9000, 1, "int" );
+}
+
+divetonuke_set_clientfield( state )
+{
+	self setclientfieldtoplayer( "perk_dive_to_nuke", state );
+}
+
+divetonuke_perk_machine_setup( use_trigger, perk_machine, bump_trigger, collision )
+{
+	use_trigger.script_sound = "mus_perks_phd_jingle";
+	use_trigger.script_string = "divetonuke_perk";
+	use_trigger.script_label = "mus_perks_phd_sting";
+	use_trigger.target = "vending_divetonuke";
+	perk_machine.script_string = "divetonuke_perk";
+	perk_machine.targetname = "vending_divetonuke";
+	if ( isDefined( bump_trigger ) )
+	{
+		bump_trigger.script_string = "divetonuke_perk";
+	}
+}
+
+divetonuke_perk_machine_think()
+{
+	init_divetonuke();
+	while ( 1 )
+	{
+		machine = getentarray( "vending_divetonuke", "targetname" );
+		machine_triggers = getentarray( "vending_divetonuke", "target" );
+		i = 0;
+		while ( i < machine.size )
+		{
+			machine[ i ] setmodel( level.machine_assets[ "divetonuke" ].off_model );
+			i++;
+		}
+		array_thread( machine_triggers, ::set_power_on, 0 );
+		level thread do_initial_power_off_callback( machine, "divetonuke" );
+		level waittill( "divetonuke_on" );
+		i = 0;
+		while ( i < machine.size )
+		{
+			machine[ i ] setmodel( level.machine_assets[ "divetonuke" ].on_model );
+			machine[ i ] vibrate( vectorScale( ( 0, -1, 0 ), 100 ), 0,3, 0,4, 3 );
+			machine[ i ] playsound( "zmb_perks_power_on" );
+			machine[ i ] thread perk_fx( "divetonuke_light" );
+			machine[ i ] thread play_loop_on_machine();
+			i++;
+		}
+		level notify( "specialty_flakjacket_power_on" );
+		array_thread( machine_triggers, ::set_power_on, 1 );
+		if ( isDefined( level.machine_assets[ "divetonuke" ].power_on_callback ) )
+		{
+			array_thread( machine, level.machine_assets[ "divetonuke" ].power_on_callback );
+		}
+		level waittill( "divetonuke_off" );
+		if ( isDefined( level.machine_assets[ "divetonuke" ].power_off_callback ) )
+		{
+			array_thread( machine, level.machine_assets[ "divetonuke" ].power_off_callback );
+		}
+		array_thread( machine, ::turn_perk_off );
+	}
+}
+
+divetonuke_host_migration_func()
+{
+	flop = getentarray( "vending_divetonuke", "targetname" );
+	_a138 = flop;
+	_k138 = getFirstArrayKey( _a138 );
+	while ( isDefined( _k138 ) )
+	{
+		perk = _a138[ _k138 ];
+		if ( isDefined( perk.model ) && perk.model == level.machine_assets[ "divetonuke" ].on_model )
+		{
+			perk perk_fx( undefined, 1 );
+			perk thread perk_fx( "divetonuke_light" );
+		}
+		_k138 = getNextArrayKey( _a138, _k138 );
+	}
+}
+
+divetonuke_explode( attacker, origin )
+{
+	radius = level.zombie_vars[ "zombie_perk_divetonuke_radius" ];
+	min_damage = level.zombie_vars[ "zombie_perk_divetonuke_min_damage" ];
+	max_damage = level.zombie_vars[ "zombie_perk_divetonuke_max_damage" ];
+	if ( isDefined( level.flopper_network_optimized ) && level.flopper_network_optimized )
+	{
+		attacker thread divetonuke_explode_network_optimized( origin, radius, max_damage, min_damage, "MOD_GRENADE_SPLASH" );
+	}
+	else
+	{
+		radiusdamage( origin, radius, max_damage, min_damage, attacker, "MOD_GRENADE_SPLASH" );
+	}
+	playfx( level._effect[ "divetonuke_groundhit" ], origin );
+	attacker playsound( "zmb_phdflop_explo" );
+	maps/mp/_visionset_mgr::vsmgr_activate( "visionset", "zm_perk_divetonuke", attacker );
+	wait 1;
+	maps/mp/_visionset_mgr::vsmgr_deactivate( "visionset", "zm_perk_divetonuke", attacker );
+}
+
+divetonuke_explode_network_optimized( origin, radius, max_damage, min_damage, damage_mod )
+{
+	self endon( "disconnect" );
+	a_zombies = get_array_of_closest( origin, get_round_enemy_array(), undefined, undefined, radius );
+	network_stall_counter = 0;
+	while ( isDefined( a_zombies ) )
+	{
+		i = 0;
+		while ( i < a_zombies.size )
+		{
+			e_zombie = a_zombies[ i ];
+			if ( !isDefined( e_zombie ) || !isalive( e_zombie ) )
+			{
+				i++;
+				continue;
+			}
+			else
+			{
+				dist = distance( e_zombie.origin, origin );
+				damage = min_damage + ( ( max_damage - min_damage ) * ( 1 - ( dist / radius ) ) );
+				e_zombie dodamage( damage, e_zombie.origin, self, self, 0, damage_mod );
+				network_stall_counter--;
+
+				if ( network_stall_counter <= 0 )
+				{
+					wait_network_frame();
+					network_stall_counter = randomintrange( 1, 3 );
+				}
+			}
+			i++;
+		}
+	}
+}

zm_tomb_patch/maps/mp/zombies/_zm_powerup_zombie_blood.gsc

@@ -0,0 +1,217 @@
+#include maps/mp/_visionset_mgr;
+#include maps/mp/zombies/_zm_utility;
+#include maps/mp/zombies/_zm_powerups;
+#include maps/mp/_utility;
+#include common_scripts/utility;
+
+init( str_zombie_model )
+{
+	level.str_zombie_blood_model = str_zombie_model;
+	precachemodel( level.str_zombie_blood_model );
+	registerclientfield( "allplayers", "player_zombie_blood_fx", 14000, 1, "int" );
+	level._effect[ "zombie_blood" ] = loadfx( "maps/zombie_tomb/fx_tomb_pwr_up_zmb_blood" );
+	level._effect[ "zombie_blood_1st" ] = loadfx( "maps/zombie_tomb/fx_zm_blood_overlay_pclouds" );
+	add_zombie_powerup( "zombie_blood", "p6_zm_tm_blood_power_up", &"ZOMBIE_POWERUP_MAX_AMMO", ::func_should_always_drop, 1, 0, 0, undefined, "powerup_zombie_blood", "zombie_powerup_zombie_blood_time", "zombie_powerup_zombie_blood_on" );
+	powerup_set_can_pick_up_in_last_stand( "zombie_blood", 0 );
+	onplayerconnect_callback( ::init_player_zombie_blood_vars );
+	level.a_zombie_blood_entities = [];
+	array_thread( getentarray( "zombie_blood_visible", "targetname" ), ::make_zombie_blood_entity );
+	if ( !isDefined( level.vsmgr_prio_visionset_zm_powerup_zombie_blood ) )
+	{
+		level.vsmgr_prio_visionset_zm_powerup_zombie_blood = 15;
+	}
+	if ( !isDefined( level.vsmgr_prio_overlay_zm_powerup_zombie_blood ) )
+	{
+		level.vsmgr_prio_overlay_zm_powerup_zombie_blood = 16;
+	}
+	maps/mp/_visionset_mgr::vsmgr_register_info( "visionset", "zm_powerup_zombie_blood_visionset", 14000, level.vsmgr_prio_visionset_zm_powerup_zombie_blood, 15, 1 );
+	maps/mp/_visionset_mgr::vsmgr_register_info( "overlay", "zm_powerup_zombie_blood_overlay", 14000, level.vsmgr_prio_overlay_zm_powerup_zombie_blood, 15, 1 );
+}
+
+init_player_zombie_blood_vars()
+{
+	self.zombie_vars[ "zombie_powerup_zombie_blood_on" ] = 0;
+	self.zombie_vars[ "zombie_powerup_zombie_blood_time" ] = 30;
+}
+
+zombie_blood_powerup( m_powerup, e_player )
+{
+	e_player notify( "zombie_blood" );
+	e_player endon( "zombie_blood" );
+	e_player endon( "disconnect" );
+	e_player thread powerup_vo( "zombie_blood" );
+	e_player.ignoreme = 1;
+	e_player._show_solo_hud = 1;
+	e_player.zombie_vars[ "zombie_powerup_zombie_blood_time" ] = 30;
+	e_player.zombie_vars[ "zombie_powerup_zombie_blood_on" ] = 1;
+	level notify( "player_zombie_blood" );
+	maps/mp/_visionset_mgr::vsmgr_activate( "visionset", "zm_powerup_zombie_blood_visionset", e_player );
+	maps/mp/_visionset_mgr::vsmgr_activate( "overlay", "zm_powerup_zombie_blood_overlay", e_player );
+	e_player setclientfield( "player_zombie_blood_fx", 1 );
+	__new = [];
+	_a73 = level.a_zombie_blood_entities;
+	__key = getFirstArrayKey( _a73 );
+	while ( isDefined( __key ) )
+	{
+		__value = _a73[ __key ];
+		if ( isDefined( __value ) )
+		{
+			if ( isstring( __key ) )
+			{
+				__new[ __key ] = __value;
+				break;
+			}
+			else
+			{
+				__new[ __new.size ] = __value;
+			}
+		}
+		__key = getNextArrayKey( _a73, __key );
+	}
+	level.a_zombie_blood_entities = __new;
+	_a74 = level.a_zombie_blood_entities;
+	_k74 = getFirstArrayKey( _a74 );
+	while ( isDefined( _k74 ) )
+	{
+		e_zombie_blood = _a74[ _k74 ];
+		if ( isDefined( e_zombie_blood.e_unique_player ) )
+		{
+			if ( e_zombie_blood.e_unique_player == e_player )
+			{
+				e_zombie_blood setvisibletoplayer( e_player );
+			}
+		}
+		else
+		{
+			e_zombie_blood setvisibletoplayer( e_player );
+		}
+		_k74 = getNextArrayKey( _a74, _k74 );
+	}
+	if ( !isDefined( e_player.m_fx ) )
+	{
+		v_origin = e_player gettagorigin( "J_Eyeball_LE" );
+		v_angles = e_player gettagangles( "J_Eyeball_LE" );
+		m_fx = spawn( "script_model", v_origin );
+		m_fx setmodel( "tag_origin" );
+		m_fx.angles = v_angles;
+		m_fx linkto( e_player, "J_Eyeball_LE", ( 0, 0, 0 ), ( 0, 0, 0 ) );
+		m_fx thread fx_disconnect_watch( e_player );
+		playfxontag( level._effect[ "zombie_blood" ], m_fx, "tag_origin" );
+		e_player.m_fx = m_fx;
+		e_player.m_fx playloopsound( "zmb_zombieblood_3rd_loop", 1 );
+		if ( isDefined( level.str_zombie_blood_model ) )
+		{
+			e_player.hero_model = e_player.model;
+			e_player setmodel( level.str_zombie_blood_model );
+		}
+	}
+	e_player thread watch_zombie_blood_early_exit();
+	while ( e_player.zombie_vars[ "zombie_powerup_zombie_blood_time" ] >= 0 )
+	{
+		wait 0,05;
+		e_player.zombie_vars[ "zombie_powerup_zombie_blood_time" ] -= 0,05;
+	}
+	e_player notify( "zombie_blood_over" );
+	if ( isDefined( e_player.characterindex ) )
+	{
+		e_player playsound( "vox_plr_" + e_player.characterindex + "_exert_grunt_" + randomintrange( 0, 3 ) );
+	}
+	e_player.m_fx delete();
+	maps/mp/_visionset_mgr::vsmgr_deactivate( "visionset", "zm_powerup_zombie_blood_visionset", e_player );
+	maps/mp/_visionset_mgr::vsmgr_deactivate( "overlay", "zm_powerup_zombie_blood_overlay", e_player );
+	e_player.zombie_vars[ "zombie_powerup_zombie_blood_on" ] = 0;
+	e_player.zombie_vars[ "zombie_powerup_zombie_blood_time" ] = 30;
+	e_player._show_solo_hud = 0;
+	e_player setclientfield( "player_zombie_blood_fx", 0 );
+	if ( !isDefined( e_player.early_exit ) )
+	{
+		e_player.ignoreme = 0;
+	}
+	else
+	{
+		e_player.early_exit = undefined;
+	}
+	__new = [];
+	_a145 = level.a_zombie_blood_entities;
+	__key = getFirstArrayKey( _a145 );
+	while ( isDefined( __key ) )
+	{
+		__value = _a145[ __key ];
+		if ( isDefined( __value ) )
+		{
+			if ( isstring( __key ) )
+			{
+				__new[ __key ] = __value;
+				break;
+			}
+			else
+			{
+				__new[ __new.size ] = __value;
+			}
+		}
+		__key = getNextArrayKey( _a145, __key );
+	}
+	level.a_zombie_blood_entities = __new;
+	_a146 = level.a_zombie_blood_entities;
+	_k146 = getFirstArrayKey( _a146 );
+	while ( isDefined( _k146 ) )
+	{
+		e_zombie_blood = _a146[ _k146 ];
+		e_zombie_blood setinvisibletoplayer( e_player );
+		_k146 = getNextArrayKey( _a146, _k146 );
+	}
+	if ( isDefined( e_player.hero_model ) )
+	{
+		e_player setmodel( e_player.hero_model );
+		e_player.hero_model = undefined;
+	}
+}
+
+fx_disconnect_watch( e_player )
+{
+	self endon( "death" );
+	e_player waittill( "disconnect" );
+	self delete();
+}
+
+watch_zombie_blood_early_exit()
+{
+	self notify( "early_exit_watch" );
+	self endon( "early_exit_watch" );
+	self endon( "zombie_blood_over" );
+	self endon( "disconnect" );
+	waittill_any_ents_two( self, "player_downed", level, "end_game" );
+	self.zombie_vars[ "zombie_powerup_zombie_blood_time" ] = -0,05;
+	self.early_exit = 1;
+}
+
+make_zombie_blood_entity()
+{
+/#
+	assert( isDefined( level.a_zombie_blood_entities ), "zombie blood powerup not initiliazed in level" );
+#/
+	level.a_zombie_blood_entities[ level.a_zombie_blood_entities.size ] = self;
+	self setinvisibletoall();
+	_a196 = getplayers();
+	_k196 = getFirstArrayKey( _a196 );
+	while ( isDefined( _k196 ) )
+	{
+		e_player = _a196[ _k196 ];
+		if ( e_player.zombie_vars[ "zombie_powerup_zombie_blood_on" ] )
+		{
+			if ( isDefined( self.e_unique_player ) )
+			{
+				if ( self.e_unique_player == e_player )
+				{
+					self setvisibletoplayer( e_player );
+				}
+				break;
+			}
+			else
+			{
+				self setvisibletoplayer( e_player );
+			}
+		}
+		_k196 = getNextArrayKey( _a196, _k196 );
+	}
+}

zm_tomb_patch/maps/mp/zombies/_zm_riotshield_tomb.gsc

@@ -0,0 +1,671 @@
+#include maps/mp/zombies/_zm_weapons;
+#include maps/mp/zombies/_zm_equipment;
+#include maps/mp/zombies/_zm_buildables;
+#include maps/mp/zombies/_zm_weap_riotshield_tomb;
+#include common_scripts/utility;
+#include maps/mp/zombies/_zm_utility;
+#include maps/mp/_utility;
+
+init()
+{
+	level.riotshield_name = "tomb_shield_zm";
+	level.deployedshieldmodel = [];
+	level.stowedshieldmodel = [];
+	level.carriedshieldmodel = [];
+	level.deployedshieldmodel[ 0 ] = "t6_wpn_zmb_shield_dlc4_dmg0_world";
+	level.deployedshieldmodel[ 2 ] = "t6_wpn_zmb_shield_dlc4_dmg1_world";
+	level.deployedshieldmodel[ 3 ] = "t6_wpn_zmb_shield_dlc4_dmg2_world";
+	level.stowedshieldmodel[ 0 ] = "t6_wpn_zmb_shield_dlc4_dmg0_stow";
+	level.stowedshieldmodel[ 2 ] = "t6_wpn_zmb_shield_dlc4_dmg1_stow";
+	level.stowedshieldmodel[ 3 ] = "t6_wpn_zmb_shield_dlc4_dmg2_stow";
+	level.carriedshieldmodel[ 0 ] = "t6_wpn_zmb_shield_dlc4_dmg0_world";
+	level.carriedshieldmodel[ 2 ] = "t6_wpn_zmb_shield_dlc4_dmg1_world";
+	level.carriedshieldmodel[ 3 ] = "t6_wpn_zmb_shield_dlc4_dmg2_world";
+	level.viewshieldmodel[ 0 ] = "t6_wpn_zmb_shield_dlc4_dmg0_view";
+	level.viewshieldmodel[ 2 ] = "t6_wpn_zmb_shield_dlc4_dmg1_view";
+	level.viewshieldmodel[ 3 ] = "t6_wpn_zmb_shield_dlc4_dmg2_view";
+	precachemodel( level.stowedshieldmodel[ 0 ] );
+	precachemodel( level.stowedshieldmodel[ 2 ] );
+	precachemodel( level.stowedshieldmodel[ 3 ] );
+	precachemodel( level.carriedshieldmodel[ 0 ] );
+	precachemodel( level.carriedshieldmodel[ 2 ] );
+	precachemodel( level.carriedshieldmodel[ 3 ] );
+	precachemodel( level.viewshieldmodel[ 0 ] );
+	precachemodel( level.viewshieldmodel[ 2 ] );
+	precachemodel( level.viewshieldmodel[ 3 ] );
+	level.riotshield_placement_zoffset = 26;
+}
+
+attachriotshield( model, tag )
+{
+	if ( isDefined( self.prev_shield_model ) && isDefined( self.prev_shield_tag ) )
+	{
+		self detachshieldmodel( self.prev_shield_model, self.prev_shield_tag );
+	}
+	self.prev_shield_model = model;
+	self.prev_shield_tag = tag;
+	if ( isDefined( self.prev_shield_model ) && isDefined( self.prev_shield_tag ) )
+	{
+		self attachshieldmodel( self.prev_shield_model, self.prev_shield_tag );
+	}
+}
+
+removeriotshield()
+{
+	if ( isDefined( self.prev_shield_model ) && isDefined( self.prev_shield_tag ) )
+	{
+		self detachshieldmodel( self.prev_shield_model, self.prev_shield_tag );
+	}
+	self.prev_shield_model = undefined;
+	self.prev_shield_tag = undefined;
+	if ( self getcurrentweapon() != level.riotshield_name )
+	{
+		return;
+	}
+	self setheldweaponmodel( 0 );
+}
+
+setriotshieldviewmodel( modelnum )
+{
+	self.prev_shield_viewmodel = modelnum;
+	if ( self getcurrentweapon() != level.riotshield_name )
+	{
+		return;
+	}
+	if ( isDefined( self.prev_shield_viewmodel ) )
+	{
+		self setheldweaponmodel( self.prev_shield_viewmodel );
+	}
+	else
+	{
+		self setheldweaponmodel( 0 );
+	}
+}
+
+specialriotshieldviewmodel()
+{
+	if ( self getcurrentweapon() != level.riotshield_name )
+	{
+		return;
+	}
+	self setheldweaponmodel( 3 );
+}
+
+restoreriotshieldviewmodel()
+{
+	if ( self getcurrentweapon() != level.riotshield_name )
+	{
+		return;
+	}
+	if ( isDefined( self.prev_shield_viewmodel ) )
+	{
+		self setheldweaponmodel( self.prev_shield_viewmodel );
+	}
+	else
+	{
+		self setheldweaponmodel( 0 );
+	}
+}
+
+updateriotshieldmodel()
+{
+	if ( !isDefined( self.shield_damage_level ) )
+	{
+		if ( isDefined( self.player_shield_reset_health ) )
+		{
+			self [[ self.player_shield_reset_health ]]();
+		}
+	}
+	update = 0;
+	if ( !isDefined( self.prev_shield_damage_level ) || self.prev_shield_damage_level != self.shield_damage_level )
+	{
+		self.prev_shield_damage_level = self.shield_damage_level;
+		update = 1;
+	}
+	if ( !isDefined( self.prev_shield_placement ) || self.prev_shield_placement != self.shield_placement )
+	{
+		self.prev_shield_placement = self.shield_placement;
+		update = 1;
+	}
+	if ( update )
+	{
+		if ( self.prev_shield_placement == 0 )
+		{
+			self attachriotshield();
+			return;
+		}
+		else if ( self.prev_shield_placement == 1 )
+		{
+			self attachriotshield( level.carriedshieldmodel[ self.prev_shield_damage_level ], "tag_weapon_left" );
+			self setriotshieldviewmodel( self.prev_shield_damage_level );
+			return;
+		}
+		else if ( self.prev_shield_placement == 2 )
+		{
+			self attachriotshield( level.stowedshieldmodel[ self.prev_shield_damage_level ], "tag_stowed_back" );
+			return;
+		}
+		else
+		{
+			if ( self.prev_shield_placement == 3 )
+			{
+				self attachriotshield();
+				if ( isDefined( self.shield_ent ) )
+				{
+					self.shield_ent setmodel( level.deployedshieldmodel[ self.prev_shield_damage_level ] );
+				}
+			}
+		}
+	}
+}
+
+updatestandaloneriotshieldmodel()
+{
+	update = 0;
+	if ( !isDefined( self.prev_shield_damage_level ) || self.prev_shield_damage_level != self.shield_damage_level )
+	{
+		self.prev_shield_damage_level = self.shield_damage_level;
+		update = 1;
+	}
+	if ( update )
+	{
+		self setmodel( level.deployedshieldmodel[ self.prev_shield_damage_level ] );
+	}
+}
+
+watchshieldlaststand()
+{
+	self endon( "death" );
+	self endon( "disconnect" );
+	self notify( "watchShieldLastStand" );
+	self endon( "watchShieldLastStand" );
+	while ( 1 )
+	{
+		self waittill( "weapons_taken_for_last_stand" );
+		self.riotshield_hidden = 0;
+		if ( isDefined( self.hasriotshield ) && self.hasriotshield )
+		{
+			if ( self.prev_shield_placement == 1 || self.prev_shield_placement == 2 )
+			{
+				self.riotshield_hidden = 2;
+				self.shield_placement = 0;
+				self updateriotshieldmodel();
+			}
+		}
+		str_notify = self waittill_any_return( "player_revived", "bled_out" );
+		if ( str_notify == "player_revived" )
+		{
+			if ( isDefined( self.riotshield_hidden ) && self.riotshield_hidden > 0 )
+			{
+				self.shield_placement = self.riotshield_hidden;
+				self updateriotshieldmodel();
+			}
+		}
+		else
+		{
+			self maps/mp/zombies/_zm_weap_riotshield_tomb::player_take_riotshield();
+		}
+		self.riotshield_hidden = undefined;
+	}
+}
+
+trackriotshield()
+{
+	self endon( "death" );
+	self endon( "disconnect" );
+	self.hasriotshield = self hasweapon( level.riotshield_name );
+	self.hasriotshieldequipped = self getcurrentweapon() == level.riotshield_name;
+	self.shield_placement = 0;
+	if ( self.hasriotshield )
+	{
+		if ( self.hasriotshieldequipped )
+		{
+			self.shield_placement = 1;
+			self updateriotshieldmodel();
+		}
+		else
+		{
+			self.shield_placement = 2;
+			self updateriotshieldmodel();
+		}
+	}
+	for ( ;; )
+	{
+		self waittill( "weapon_change", newweapon );
+		if ( newweapon == level.riotshield_name )
+		{
+			if ( self.hasriotshieldequipped )
+			{
+				continue;
+			}
+			else if ( isDefined( self.riotshieldentity ) )
+			{
+				self notify( "destroy_riotshield" );
+			}
+			self.shield_placement = 1;
+			self updateriotshieldmodel();
+			if ( self.hasriotshield )
+			{
+				break;
+			}
+			self.hasriotshield = 1;
+			self.hasriotshieldequipped = 1;
+			continue;
+		}
+		else if ( self ismantling() && newweapon == "none" )
+		{
+			continue;
+		}
+		else
+		{
+			if ( self.hasriotshieldequipped )
+			{
+/#
+				assert( self.hasriotshield );
+#/
+				self.hasriotshield = self hasweapon( level.riotshield_name );
+				if ( isDefined( self.riotshield_hidden ) && self.riotshield_hidden )
+				{
+				}
+				else
+				{
+					if ( self.hasriotshield )
+					{
+						self.shield_placement = 2;
+						break;
+					}
+					else if ( isDefined( self.shield_ent ) )
+					{
+/#
+						assert( self.shield_placement == 3 );
+#/
+						break;
+					}
+					else
+					{
+						self.shield_placement = 0;
+					}
+				}
+				self updateriotshieldmodel();
+				self.hasriotshieldequipped = 0;
+				break;
+			}
+			else if ( self.hasriotshield )
+			{
+				if ( !self hasweapon( level.riotshield_name ) )
+				{
+					self.shield_placement = 0;
+					self updateriotshieldmodel();
+					self.hasriotshield = 0;
+				}
+				break;
+			}
+			else
+			{
+				if ( self hasweapon( level.riotshield_name ) )
+				{
+					self.shield_placement = 2;
+					self updateriotshieldmodel();
+					self.hasriotshield = 1;
+				}
+			}
+		}
+	}
+}
+
+trackequipmentchange()
+{
+	self endon( "death" );
+	self endon( "disconnect" );
+	for ( ;; )
+	{
+		self waittill( "equipment_dropped", equipname );
+		self notify( "weapon_change" );
+	}
+}
+
+updateriotshieldplacement()
+{
+	self endon( "death" );
+	self endon( "disconnect" );
+	self endon( "deploy_riotshield" );
+	self endon( "start_riotshield_deploy" );
+	self endon( "weapon_change" );
+	while ( 1 )
+	{
+		placement = self canplaceriotshield( "raise_riotshield" );
+		if ( placement[ "result" ] && riotshielddistancetest( placement[ "origin" ] ) )
+		{
+			self restoreriotshieldviewmodel();
+			self setplacementhint( 1 );
+		}
+		else
+		{
+			self specialriotshieldviewmodel();
+			self setplacementhint( 0 );
+		}
+		wait 0,05;
+	}
+}
+
+startriotshielddeploy()
+{
+	self notify( "start_riotshield_deploy" );
+	self thread updateriotshieldplacement();
+	self thread watchriotshielddeploy();
+}
+
+spawnriotshieldcover( origin, angles )
+{
+	shield_ent = spawn( "script_model", origin, 1 );
+	shield_ent.angles = angles;
+	shield_ent setowner( self );
+	shield_ent.owner = self;
+	shield_ent.owner.shield_ent = shield_ent;
+	shield_ent.isriotshield = 1;
+	self.shield_placement = 3;
+	self updateriotshieldmodel();
+	shield_ent setscriptmoverflag( 0 );
+	self thread maps/mp/zombies/_zm_buildables::delete_on_disconnect( shield_ent, "destroy_riotshield", 1 );
+	maps/mp/zombies/_zm_equipment::destructible_equipment_list_add( shield_ent );
+	return shield_ent;
+}
+
+watchriotshielddeploy()
+{
+	self endon( "death" );
+	self endon( "disconnect" );
+	self endon( "start_riotshield_deploy" );
+	self endon( "destroy_riotshield" );
+	self waittill( "deploy_riotshield", deploy_attempt );
+	self restoreriotshieldviewmodel();
+	self setplacementhint( 1 );
+	placement_hint = 0;
+	if ( deploy_attempt )
+	{
+		placement = self canplaceriotshield( "deploy_riotshield" );
+		if ( placement[ "result" ] && riotshielddistancetest( placement[ "origin" ] ) && self check_plant_position( placement[ "origin" ], placement[ "angles" ] ) )
+		{
+			self doriotshielddeploy( placement[ "origin" ], placement[ "angles" ] );
+		}
+		else
+		{
+			placement_hint = 1;
+			clip_max_ammo = weaponclipsize( level.riotshield_name );
+			self setweaponammoclip( level.riotshield_name, clip_max_ammo );
+		}
+	}
+	else
+	{
+		placement_hint = 1;
+	}
+	if ( placement_hint )
+	{
+		self setriotshieldfailhint();
+	}
+}
+
+check_plant_position( origin, angles )
+{
+	if ( isDefined( level.equipment_safe_to_drop ) )
+	{
+		ret = 1;
+		test_ent = spawn( "script_model", origin );
+		test_ent setmodel( level.deployedshieldmodel[ 0 ] );
+		test_ent.angles = angles;
+		if ( !( self [[ level.equipment_safe_to_drop ]]( test_ent ) ) )
+		{
+			ret = 0;
+		}
+		test_ent delete();
+		return ret;
+	}
+	return 1;
+}
+
+doriotshielddeploy( origin, angles )
+{
+	self endon( "death" );
+	self endon( "disconnect" );
+	self endon( "start_riotshield_deploy" );
+	self notify( "deployed_riotshield" );
+	self maps/mp/zombies/_zm_buildables::track_placed_buildables( level.riotshield_name );
+	if ( isDefined( self.current_equipment ) && self.current_equipment == level.riotshield_name )
+	{
+		self maps/mp/zombies/_zm_equipment::equipment_to_deployed( level.riotshield_name );
+	}
+	zoffset = level.riotshield_placement_zoffset;
+	shield_ent = self spawnriotshieldcover( origin + ( 0, 0, zoffset ), angles );
+	item_ent = deployriotshield( self, shield_ent );
+	primaries = self getweaponslistprimaries();
+/#
+	assert( isDefined( item_ent ) );
+	assert( !isDefined( self.riotshieldretrievetrigger ) );
+	assert( !isDefined( self.riotshieldentity ) );
+#/
+	self maps/mp/zombies/_zm_weapons::switch_back_primary_weapon( primaries[ 0 ] );
+	if ( isDefined( level.equipment_planted ) )
+	{
+		self [[ level.equipment_planted ]]( shield_ent, level.riotshield_name, self );
+	}
+	if ( isDefined( level.equipment_safe_to_drop ) )
+	{
+		if ( !( self [[ level.equipment_safe_to_drop ]]( shield_ent ) ) )
+		{
+			self notify( "destroy_riotshield" );
+			shield_ent delete();
+			item_ent delete();
+			return;
+		}
+	}
+	self.riotshieldretrievetrigger = item_ent;
+	self.riotshieldentity = shield_ent;
+	self thread watchdeployedriotshieldents();
+	self thread deleteshieldondamage( self.riotshieldentity );
+	self thread deleteshieldmodelonweaponpickup( self.riotshieldretrievetrigger );
+	self thread deleteriotshieldonplayerdeath();
+	self thread watchshieldtriggervisibility( self.riotshieldretrievetrigger );
+	self.riotshieldentity thread watchdeployedriotshielddamage();
+	return shield_ent;
+}
+
+riotshielddistancetest( origin )
+{
+/#
+	assert( isDefined( origin ) );
+#/
+	min_dist_squared = getDvarFloat( "riotshield_deploy_limit_radius" );
+	min_dist_squared *= min_dist_squared;
+	i = 0;
+	while ( i < level.players.size )
+	{
+		if ( isDefined( level.players[ i ].riotshieldentity ) )
+		{
+			dist_squared = distancesquared( level.players[ i ].riotshieldentity.origin, origin );
+			if ( min_dist_squared > dist_squared )
+			{
+/#
+				println( "Shield placement denied!  Failed distance check to other riotshields." );
+#/
+				return 0;
+			}
+		}
+		i++;
+	}
+	return 1;
+}
+
+watchdeployedriotshieldents()
+{
+/#
+	assert( isDefined( self.riotshieldretrievetrigger ) );
+	assert( isDefined( self.riotshieldentity ) );
+#/
+	riotshieldretrievetrigger = self.riotshieldretrievetrigger;
+	riotshieldentity = self.riotshieldentity;
+	self waittill_any( "destroy_riotshield", "disconnect", "tomb_shield_zm_taken" );
+	if ( isDefined( self ) )
+	{
+		self.shield_placement = 0;
+		self updateriotshieldmodel();
+	}
+	if ( isDefined( riotshieldretrievetrigger ) )
+	{
+		riotshieldretrievetrigger delete();
+	}
+	if ( isDefined( riotshieldentity ) )
+	{
+		riotshieldentity delete();
+	}
+}
+
+watchdeployedriotshielddamage()
+{
+	self endon( "death" );
+	damagemax = getDvarInt( "riotshield_deployed_health" );
+	self.damagetaken = 0;
+	while ( 1 )
+	{
+		self.maxhealth = 100000;
+		self.health = self.maxhealth;
+		self waittill( "damage", damage, attacker, direction, point, type, tagname, modelname, partname, weaponname, idflags );
+		if ( isDefined( level.players_can_damage_riotshields ) && !level.players_can_damage_riotshields )
+		{
+			continue;
+		}
+		if ( !isDefined( attacker ) || !isplayer( attacker ) )
+		{
+			continue;
+		}
+/#
+		if ( isDefined( self.owner ) )
+		{
+			assert( isDefined( self.owner.team ) );
+		}
+#/
+		while ( is_encounter() && attacker.team == self.owner.team && attacker != self.owner )
+		{
+			continue;
+		}
+		if ( isDefined( level.riotshield_damage_callback ) )
+		{
+			self.owner [[ level.riotshield_damage_callback ]]( damage, 0 );
+			continue;
+		}
+		else
+		{
+			if ( type == "MOD_MELEE" )
+			{
+				damage *= getDvarFloat( "riotshield_melee_damage_scale" );
+			}
+			else if ( type == "MOD_PISTOL_BULLET" || type == "MOD_RIFLE_BULLET" )
+			{
+				damage *= getDvarFloat( "riotshield_bullet_damage_scale" );
+			}
+			else
+			{
+				if ( type != "MOD_GRENADE" && type != "MOD_GRENADE_SPLASH" && type != "MOD_EXPLOSIVE" && type != "MOD_EXPLOSIVE_SPLASH" || type == "MOD_PROJECTILE" && type == "MOD_PROJECTILE_SPLASH" )
+				{
+					damage *= getDvarFloat( "riotshield_explosive_damage_scale" );
+					break;
+				}
+				else
+				{
+					if ( type == "MOD_IMPACT" )
+					{
+						damage *= getDvarFloat( "riotshield_projectile_damage_scale" );
+					}
+				}
+			}
+			self.damagetaken += damage;
+			if ( self.damagetaken >= damagemax )
+			{
+				self damagethendestroyriotshield();
+			}
+		}
+	}
+}
+
+damagethendestroyriotshield()
+{
+	self endon( "death" );
+	self.owner.riotshieldretrievetrigger delete();
+	self notsolid();
+	self setclientflag( 14 );
+	wait getDvarFloat( "riotshield_destroyed_cleanup_time" );
+	self.owner notify( "destroy_riotshield" );
+}
+
+deleteshieldondamage( shield_ent )
+{
+	shield_ent waittill( "death" );
+	self notify( "destroy_riotshield" );
+}
+
+deleteshieldmodelonweaponpickup( shield_trigger )
+{
+	shield_trigger waittill( "trigger", player );
+	self maps/mp/zombies/_zm_equipment::equipment_from_deployed( level.riotshield_name );
+	self notify( "destroy_riotshield" );
+	if ( self != player )
+	{
+		if ( isDefined( level.transferriotshield ) )
+		{
+			[[ level.transferriotshield ]]( self, player );
+		}
+	}
+}
+
+watchshieldtriggervisibility( trigger )
+{
+	self endon( "death" );
+	trigger endon( "death" );
+	while ( isDefined( trigger ) )
+	{
+		players = get_players();
+		_a760 = players;
+		_k760 = getFirstArrayKey( _a760 );
+		while ( isDefined( _k760 ) )
+		{
+			player = _a760[ _k760 ];
+			pickup = 1;
+			if ( !isDefined( player ) )
+			{
+			}
+			else if ( is_true( player.afterlife ) )
+			{
+				trigger setinvisibletoplayer( player );
+				wait 0,05;
+			}
+			else
+			{
+				if ( isDefined( level.cantransferriotshield ) )
+				{
+					pickup = [[ level.cantransferriotshield ]]( self, player );
+				}
+				if ( !isDefined( trigger ) )
+				{
+					return;
+				}
+				if ( pickup )
+				{
+					trigger setvisibletoplayer( player );
+				}
+				else
+				{
+					trigger setinvisibletoplayer( player );
+				}
+				wait 0,05;
+			}
+			_k760 = getNextArrayKey( _a760, _k760 );
+		}
+		wait 0,05;
+	}
+}
+
+deleteriotshieldonplayerdeath()
+{
+	self.riotshieldentity endon( "death" );
+	self waittill( "death" );
+	self notify( "destroy_riotshield" );
+}

zm_tomb_patch/maps/mp/zombies/_zm_weap_ballistic_knife.gsc

@@ -0,0 +1,308 @@
+#include maps/mp/zombies/_zm_stats;
+#include common_scripts/utility;
+#include maps/mp/_utility;
+
+init()
+{
+	if ( !isDefined( level.ballistic_knife_autorecover ) )
+	{
+		level.ballistic_knife_autorecover = 1;
+	}
+	if ( isDefined( level._uses_retrievable_ballisitic_knives ) && level._uses_retrievable_ballisitic_knives == 1 )
+	{
+		precachemodel( "t5_weapon_ballistic_knife_projectile" );
+		precachemodel( "t5_weapon_ballistic_knife_blade_retrieve" );
+	}
+}
+
+on_spawn( watcher, player )
+{
+	player endon( "death" );
+	player endon( "disconnect" );
+	player endon( "zmb_lost_knife" );
+	level endon( "game_ended" );
+	self waittill( "stationary", endpos, normal, angles, attacker, prey, bone );
+	isfriendly = 0;
+	if ( isDefined( endpos ) )
+	{
+		retrievable_model = spawn( "script_model", endpos );
+		retrievable_model setmodel( "t5_weapon_ballistic_knife_blade_retrieve" );
+		retrievable_model setowner( player );
+		retrievable_model.owner = player;
+		retrievable_model.angles = angles;
+		retrievable_model.name = watcher.weapon;
+		if ( isDefined( prey ) )
+		{
+			if ( isplayer( prey ) && player.team == prey.team )
+			{
+				isfriendly = 1;
+			}
+			else
+			{
+				if ( isai( prey ) && player.team == prey.team )
+				{
+					isfriendly = 1;
+				}
+			}
+			if ( !isfriendly )
+			{
+				retrievable_model linkto( prey, bone );
+				retrievable_model thread force_drop_knives_to_ground_on_death( player, prey );
+			}
+			else
+			{
+				if ( isfriendly )
+				{
+					retrievable_model physicslaunch( normal, ( randomint( 10 ), randomint( 10 ), randomint( 10 ) ) );
+					normal = ( 0, 0, 1 );
+				}
+			}
+		}
+		watcher.objectarray[ watcher.objectarray.size ] = retrievable_model;
+		if ( isfriendly )
+		{
+			retrievable_model waittill( "stationary" );
+		}
+		retrievable_model thread drop_knives_to_ground( player );
+		if ( isfriendly )
+		{
+			player notify( "ballistic_knife_stationary" );
+		}
+		else
+		{
+			player notify( "ballistic_knife_stationary" );
+		}
+		retrievable_model thread wait_to_show_glowing_model( prey );
+	}
+}
+
+wait_to_show_glowing_model( prey )
+{
+	level endon( "game_ended" );
+	self endon( "death" );
+	wait 2;
+	self setmodel( "t5_weapon_ballistic_knife_blade_retrieve" );
+}
+
+on_spawn_retrieve_trigger( watcher, player )
+{
+	player endon( "death" );
+	player endon( "disconnect" );
+	player endon( "zmb_lost_knife" );
+	level endon( "game_ended" );
+	player waittill( "ballistic_knife_stationary", retrievable_model, normal, prey );
+	if ( !isDefined( retrievable_model ) )
+	{
+		return;
+	}
+	trigger_pos = [];
+	if ( isDefined( prey ) || isplayer( prey ) && isai( prey ) )
+	{
+		trigger_pos[ 0 ] = prey.origin[ 0 ];
+		trigger_pos[ 1 ] = prey.origin[ 1 ];
+		trigger_pos[ 2 ] = prey.origin[ 2 ] + 10;
+	}
+	else
+	{
+		trigger_pos[ 0 ] = retrievable_model.origin[ 0 ] + ( 10 * normal[ 0 ] );
+		trigger_pos[ 1 ] = retrievable_model.origin[ 1 ] + ( 10 * normal[ 1 ] );
+		trigger_pos[ 2 ] = retrievable_model.origin[ 2 ] + ( 10 * normal[ 2 ] );
+	}
+	if ( is_true( level.ballistic_knife_autorecover ) )
+	{
+		trigger_pos[ 2 ] -= 50;
+		pickup_trigger = spawn( "trigger_radius", ( trigger_pos[ 0 ], trigger_pos[ 1 ], trigger_pos[ 2 ] ), 0, 50, 100 );
+	}
+	else
+	{
+		pickup_trigger = spawn( "trigger_radius_use", ( trigger_pos[ 0 ], trigger_pos[ 1 ], trigger_pos[ 2 ] ) );
+		pickup_trigger setcursorhint( "HINT_NOICON" );
+	}
+	pickup_trigger.owner = player;
+	retrievable_model.retrievabletrigger = pickup_trigger;
+	hint_string = &"WEAPON_BALLISTIC_KNIFE_PICKUP";
+	if ( isDefined( hint_string ) )
+	{
+		pickup_trigger sethintstring( hint_string );
+	}
+	else
+	{
+		pickup_trigger sethintstring( &"GENERIC_PICKUP" );
+	}
+	pickup_trigger setteamfortrigger( player.team );
+	player clientclaimtrigger( pickup_trigger );
+	pickup_trigger enablelinkto();
+	if ( isDefined( prey ) )
+	{
+		pickup_trigger linkto( prey );
+	}
+	else
+	{
+		pickup_trigger linkto( retrievable_model );
+	}
+	if ( isDefined( level.knife_planted ) )
+	{
+		[[ level.knife_planted ]]( retrievable_model, pickup_trigger, prey );
+	}
+	retrievable_model thread watch_use_trigger( pickup_trigger, retrievable_model, ::pick_up, watcher.weapon, watcher.pickupsoundplayer, watcher.pickupsound );
+	player thread watch_shutdown( pickup_trigger, retrievable_model );
+}
+
+debug_print( endpos )
+{
+/#
+	self endon( "death" );
+	while ( 1 )
+	{
+		print3d( endpos, "pickup_trigger" );
+		wait 0,05;
+#/
+	}
+}
+
+watch_use_trigger( trigger, model, callback, weapon, playersoundonuse, npcsoundonuse )
+{
+	self endon( "death" );
+	self endon( "delete" );
+	level endon( "game_ended" );
+	max_ammo = weaponmaxammo( weapon ) + 1;
+	autorecover = is_true( level.ballistic_knife_autorecover );
+	while ( 1 )
+	{
+		trigger waittill( "trigger", player );
+		while ( !isalive( player ) )
+		{
+			continue;
+		}
+		if ( !player isonground() && !is_true( trigger.force_pickup ) )
+		{
+			continue;
+		}
+		if ( isDefined( trigger.triggerteam ) && player.team != trigger.triggerteam )
+		{
+			continue;
+		}
+		if ( isDefined( trigger.claimedby ) && player != trigger.claimedby )
+		{
+			continue;
+		}
+		ammo_stock = player getweaponammostock( weapon );
+		ammo_clip = player getweaponammoclip( weapon );
+		current_weapon = player getcurrentweapon();
+		total_ammo = ammo_stock + ammo_clip;
+		hasreloaded = 1;
+		if ( total_ammo > 0 && ammo_stock == total_ammo && current_weapon == weapon )
+		{
+			hasreloaded = 0;
+		}
+		if ( total_ammo >= max_ammo || !hasreloaded )
+		{
+			continue;
+		}
+		if ( !autorecover && player usebuttonpressed() && !player.throwinggrenade || !player meleebuttonpressed() && is_true( trigger.force_pickup ) )
+		{
+			if ( isDefined( playersoundonuse ) )
+			{
+				player playlocalsound( playersoundonuse );
+			}
+			if ( isDefined( npcsoundonuse ) )
+			{
+				player playsound( npcsoundonuse );
+			}
+			player thread [[ callback ]]( weapon, model, trigger );
+			return;
+		}
+		else
+		{
+		}
+	}
+}
+
+pick_up( weapon, model, trigger )
+{
+	if ( self hasweapon( weapon ) )
+	{
+		current_weapon = self getcurrentweapon();
+		if ( current_weapon != weapon )
+		{
+			clip_ammo = self getweaponammoclip( weapon );
+			if ( !clip_ammo )
+			{
+				self setweaponammoclip( weapon, 1 );
+			}
+			else
+			{
+				new_ammo_stock = self getweaponammostock( weapon ) + 1;
+				self setweaponammostock( weapon, new_ammo_stock );
+			}
+		}
+		else
+		{
+			new_ammo_stock = self getweaponammostock( weapon ) + 1;
+			self setweaponammostock( weapon, new_ammo_stock );
+		}
+	}
+	self maps/mp/zombies/_zm_stats::increment_client_stat( "ballistic_knives_pickedup" );
+	self maps/mp/zombies/_zm_stats::increment_player_stat( "ballistic_knives_pickedup" );
+	model destroy_ent();
+	trigger destroy_ent();
+}
+
+destroy_ent()
+{
+	if ( isDefined( self ) )
+	{
+		if ( isDefined( self.glowing_model ) )
+		{
+			self.glowing_model delete();
+		}
+		self delete();
+	}
+}
+
+watch_shutdown( trigger, model )
+{
+	self waittill_any( "death_or_disconnect", "zmb_lost_knife" );
+	trigger destroy_ent();
+	model destroy_ent();
+}
+
+drop_knives_to_ground( player )
+{
+	player endon( "death" );
+	player endon( "zmb_lost_knife" );
+	for ( ;; )
+	{
+		level waittill( "drop_objects_to_ground", origin, radius );
+		if ( distancesquared( origin, self.origin ) < ( radius * radius ) )
+		{
+			self physicslaunch( ( 0, 0, 1 ), vectorScale( ( 0, 0, 1 ), 5 ) );
+			self thread update_retrieve_trigger( player );
+		}
+	}
+}
+
+force_drop_knives_to_ground_on_death( player, prey )
+{
+	self endon( "death" );
+	player endon( "zmb_lost_knife" );
+	prey waittill( "death" );
+	self unlink();
+	self physicslaunch( ( 0, 0, 1 ), vectorScale( ( 0, 0, 1 ), 5 ) );
+	self thread update_retrieve_trigger( player );
+}
+
+update_retrieve_trigger( player )
+{
+	self endon( "death" );
+	player endon( "zmb_lost_knife" );
+	if ( isDefined( level.custom_update_retrieve_trigger ) )
+	{
+		self [[ level.custom_update_retrieve_trigger ]]( player );
+		return;
+	}
+	self waittill( "stationary" );
+	trigger = self.retrievabletrigger;
+	trigger.origin = ( self.origin[ 0 ], self.origin[ 1 ], self.origin[ 2 ] + 10 );
+	trigger linkto( self );
+}

zm_tomb_patch/maps/mp/zombies/_zm_weap_claymore.gsc

@@ -0,0 +1,482 @@
+#include maps/mp/gametypes_zm/_weaponobjects;
+#include maps/mp/zombies/_zm_stats;
+#include maps/mp/zombies/_zm_weapons;
+#include maps/mp/zombies/_zm_audio;
+#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 ( !isDefined( level.claymores_max_per_player ) )
+	{
+		level.claymores_max_per_player = 12;
+	}
+	trigs = getentarray( "claymore_purchase", "targetname" );
+	i = 0;
+	while ( i < trigs.size )
+	{
+		model = getent( trigs[ i ].target, "targetname" );
+		if ( isDefined( model ) )
+		{
+			model hide();
+		}
+		i++;
+	}
+	array_thread( trigs, ::buy_claymores );
+	level thread give_claymores_after_rounds();
+	level.claymores_on_damage = ::satchel_damage;
+	level.pickup_claymores = ::pickup_claymores;
+	level.pickup_claymores_trigger_listener = ::pickup_claymores_trigger_listener;
+	level.claymore_detectiondot = cos( 70 );
+	level.claymore_detectionmindist = 20;
+	level._effect[ "claymore_laser" ] = loadfx( "weapon/claymore/fx_claymore_laser" );
+}
+
+buy_claymores()
+{
+	self.zombie_cost = 1000;
+	self sethintstring( &"ZOMBIE_CLAYMORE_PURCHASE" );
+	self setcursorhint( "HINT_WEAPON", "claymore_zm" );
+	self endon( "kill_trigger" );
+	if ( !isDefined( self.stub ) )
+	{
+		return;
+	}
+	if ( isDefined( self.stub ) && !isDefined( self.stub.claymores_triggered ) )
+	{
+		self.stub.claymores_triggered = 0;
+	}
+	self.claymores_triggered = self.stub.claymores_triggered;
+	while ( 1 )
+	{
+		self waittill( "trigger", who );
+		while ( who in_revive_trigger() )
+		{
+			continue;
+		}
+		while ( who has_powerup_weapon() )
+		{
+			wait 0,1;
+		}
+		if ( is_player_valid( who ) )
+		{
+			if ( who.score >= self.zombie_cost )
+			{
+				if ( !who is_player_placeable_mine( "claymore_zm" ) )
+				{
+					play_sound_at_pos( "purchase", self.origin );
+					who maps/mp/zombies/_zm_score::minus_to_player_score( self.zombie_cost );
+					who thread claymore_setup();
+					who thread show_claymore_hint( "claymore_purchased" );
+					who thread maps/mp/zombies/_zm_audio::create_and_play_dialog( "weapon_pickup", "grenade" );
+					if ( isDefined( self.stub ) )
+					{
+						self.claymores_triggered = self.stub.claymores_triggered;
+					}
+					if ( self.claymores_triggered == 0 )
+					{
+						model = getent( self.target, "targetname" );
+						if ( isDefined( model ) )
+						{
+							model thread maps/mp/zombies/_zm_weapons::weapon_show( who );
+						}
+						else
+						{
+							if ( isDefined( self.clientfieldname ) )
+							{
+								level setclientfield( self.clientfieldname, 1 );
+							}
+						}
+						self.claymores_triggered = 1;
+						if ( isDefined( self.stub ) )
+						{
+							self.stub.claymores_triggered = 1;
+						}
+					}
+					trigs = getentarray( "claymore_purchase", "targetname" );
+					i = 0;
+					while ( i < trigs.size )
+					{
+						trigs[ i ] setinvisibletoplayer( who );
+						i++;
+					}
+				}
+				else who thread show_claymore_hint( "already_purchased" );
+				break;
+			}
+			else
+			{
+				who play_sound_on_ent( "no_purchase" );
+				who maps/mp/zombies/_zm_audio::create_and_play_dialog( "general", "no_money_weapon" );
+			}
+		}
+	}
+}
+
+claymore_unitrigger_update_prompt( player )
+{
+	if ( player is_player_placeable_mine( "claymore_zm" ) )
+	{
+		self sethintstring( "" );
+		self setcursorhint( "HINT_NOICON" );
+		return 0;
+	}
+	self sethintstring( &"ZOMBIE_CLAYMORE_PURCHASE" );
+	self setcursorhint( "HINT_WEAPON", "claymore_zm" );
+	return 1;
+}
+
+set_claymore_visible()
+{
+	players = get_players();
+	trigs = getentarray( "claymore_purchase", "targetname" );
+	while ( 1 )
+	{
+		j = 0;
+		while ( j < players.size )
+		{
+			while ( !players[ j ] is_player_placeable_mine( "claymore_zm" ) )
+			{
+				i = 0;
+				while ( i < trigs.size )
+				{
+					trigs[ i ] setinvisibletoplayer( players[ j ], 0 );
+					i++;
+				}
+			}
+			j++;
+		}
+		wait 1;
+		players = get_players();
+	}
+}
+
+claymore_safe_to_plant()
+{
+	if ( self.owner.claymores.size >= level.claymores_max_per_player )
+	{
+		return 0;
+	}
+	if ( isDefined( level.claymore_safe_to_plant ) )
+	{
+		return self [[ level.claymore_safe_to_plant ]]();
+	}
+	return 1;
+}
+
+claymore_wait_and_detonate()
+{
+	wait 0,1;
+	self detonate( self.owner );
+}
+
+claymore_watch()
+{
+	self endon( "death" );
+	self notify( "claymore_watch" );
+	self endon( "claymore_watch" );
+	while ( 1 )
+	{
+		self waittill( "grenade_fire", claymore, weapname );
+		if ( weapname == "claymore_zm" )
+		{
+			claymore.owner = self;
+			claymore.team = self.team;
+			self notify( "zmb_enable_claymore_prompt" );
+			if ( claymore claymore_safe_to_plant() )
+			{
+				if ( isDefined( level.claymore_planted ) )
+				{
+					self thread [[ level.claymore_planted ]]( claymore );
+				}
+				claymore thread claymore_detonation();
+				claymore thread play_claymore_effects();
+				self maps/mp/zombies/_zm_stats::increment_client_stat( "claymores_planted" );
+				self maps/mp/zombies/_zm_stats::increment_player_stat( "claymores_planted" );
+				break;
+			}
+			else
+			{
+				claymore thread claymore_wait_and_detonate();
+			}
+		}
+	}
+}
+
+claymore_setup()
+{
+	if ( !isDefined( self.claymores ) )
+	{
+		self.claymores = [];
+	}
+	self thread claymore_watch();
+	self giveweapon( "claymore_zm" );
+	self set_player_placeable_mine( "claymore_zm" );
+	self setactionslot( 4, "weapon", "claymore_zm" );
+	self setweaponammostock( "claymore_zm", 2 );
+}
+
+adjust_trigger_origin( origin )
+{
+	origin += vectorScale( ( 0, 0, 1 ), 20 );
+	return origin;
+}
+
+on_spawn_retrieve_trigger( watcher, player )
+{
+	self maps/mp/gametypes_zm/_weaponobjects::onspawnretrievableweaponobject( watcher, player );
+	if ( isDefined( self.pickuptrigger ) )
+	{
+		self.pickuptrigger sethintlowpriority( 0 );
+	}
+}
+
+pickup_claymores()
+{
+	player = self.owner;
+	if ( !player hasweapon( "claymore_zm" ) )
+	{
+		player thread claymore_watch();
+		player giveweapon( "claymore_zm" );
+		player set_player_placeable_mine( "claymore_zm" );
+		player setactionslot( 4, "weapon", "claymore_zm" );
+		player setweaponammoclip( "claymore_zm", 0 );
+		player notify( "zmb_enable_claymore_prompt" );
+	}
+	else
+	{
+		clip_ammo = player getweaponammoclip( self.name );
+		clip_max_ammo = weaponclipsize( self.name );
+		if ( clip_ammo >= clip_max_ammo )
+		{
+			self destroy_ent();
+			player notify( "zmb_disable_claymore_prompt" );
+			return;
+		}
+	}
+	self pick_up();
+	clip_ammo = player getweaponammoclip( self.name );
+	clip_max_ammo = weaponclipsize( self.name );
+	if ( clip_ammo >= clip_max_ammo )
+	{
+		player notify( "zmb_disable_claymore_prompt" );
+	}
+	player maps/mp/zombies/_zm_stats::increment_client_stat( "claymores_pickedup" );
+	player maps/mp/zombies/_zm_stats::increment_player_stat( "claymores_pickedup" );
+}
+
+pickup_claymores_trigger_listener( trigger, player )
+{
+	self thread pickup_claymores_trigger_listener_enable( trigger, player );
+	self thread pickup_claymores_trigger_listener_disable( trigger, player );
+}
+
+pickup_claymores_trigger_listener_enable( trigger, player )
+{
+	self endon( "delete" );
+	self endon( "death" );
+	while ( 1 )
+	{
+		player waittill_any( "zmb_enable_claymore_prompt", "spawned_player" );
+		if ( !isDefined( trigger ) )
+		{
+			return;
+		}
+		trigger trigger_on();
+		trigger linkto( self );
+	}
+}
+
+pickup_claymores_trigger_listener_disable( trigger, player )
+{
+	self endon( "delete" );
+	self endon( "death" );
+	while ( 1 )
+	{
+		player waittill( "zmb_disable_claymore_prompt" );
+		if ( !isDefined( trigger ) )
+		{
+			return;
+		}
+		trigger unlink();
+		trigger trigger_off();
+	}
+}
+
+shouldaffectweaponobject( object )
+{
+	pos = self.origin + vectorScale( ( 0, 0, 1 ), 32 );
+	dirtopos = pos - object.origin;
+	objectforward = anglesToForward( object.angles );
+	dist = vectordot( dirtopos, objectforward );
+	if ( dist < level.claymore_detectionmindist )
+	{
+		return 0;
+	}
+	dirtopos = vectornormalize( dirtopos );
+	dot = vectordot( dirtopos, objectforward );
+	return dot > level.claymore_detectiondot;
+}
+
+claymore_detonation()
+{
+	self endon( "death" );
+	self waittill_not_moving();
+	detonateradius = 96;
+	damagearea = spawn( "trigger_radius", self.origin + ( 0, 0, 0 - detonateradius ), 4, detonateradius, detonateradius * 2 );
+	damagearea setexcludeteamfortrigger( self.team );
+	damagearea enablelinkto();
+	damagearea linkto( self );
+	if ( is_true( self.isonbus ) )
+	{
+		damagearea setmovingplatformenabled( 1 );
+	}
+	self.damagearea = damagearea;
+	self thread delete_claymores_on_death( self.owner, damagearea );
+	self.owner.claymores[ self.owner.claymores.size ] = self;
+	while ( 1 )
+	{
+		damagearea waittill( "trigger", ent );
+		if ( isDefined( self.owner ) && ent == self.owner )
+		{
+			continue;
+		}
+		while ( isDefined( ent.pers ) && isDefined( ent.pers[ "team" ] ) && ent.pers[ "team" ] == self.team )
+		{
+			continue;
+		}
+		if ( isDefined( ent.ignore_claymore ) && ent.ignore_claymore )
+		{
+			continue;
+		}
+		while ( !ent shouldaffectweaponobject( self ) )
+		{
+			continue;
+		}
+		if ( ent damageconetrace( self.origin, self ) > 0 )
+		{
+			self playsound( "wpn_claymore_alert" );
+			wait 0,4;
+			if ( isDefined( self.owner ) )
+			{
+				self detonate( self.owner );
+			}
+			else
+			{
+				self detonate( undefined );
+			}
+			return;
+		}
+	}
+}
+
+delete_claymores_on_death( player, ent )
+{
+	self waittill( "death" );
+	if ( isDefined( player ) )
+	{
+		arrayremovevalue( player.claymores, self );
+	}
+	wait 0,05;
+	if ( isDefined( ent ) )
+	{
+		ent delete();
+	}
+}
+
+satchel_damage()
+{
+	self endon( "death" );
+	self setcandamage( 1 );
+	self.health = 100000;
+	self.maxhealth = self.health;
+	attacker = undefined;
+	while ( 1 )
+	{
+		self waittill( "damage", amount, attacker );
+		if ( !isDefined( self ) )
+		{
+			return;
+		}
+		self.health = self.maxhealth;
+		while ( !isplayer( attacker ) )
+		{
+			continue;
+		}
+		if ( isDefined( self.owner ) && attacker == self.owner )
+		{
+			continue;
+		}
+		while ( isDefined( attacker.pers ) && isDefined( attacker.pers[ "team" ] ) && attacker.pers[ "team" ] != level.zombie_team )
+		{
+			continue;
+		}
+	}
+	if ( level.satchelexplodethisframe )
+	{
+		wait ( 0,1 + randomfloat( 0,4 ) );
+	}
+	else wait 0,05;
+	if ( !isDefined( self ) )
+	{
+		return;
+	}
+	level.satchelexplodethisframe = 1;
+	thread reset_satchel_explode_this_frame();
+	self detonate( attacker );
+}
+
+reset_satchel_explode_this_frame()
+{
+	wait 0,05;
+	level.satchelexplodethisframe = 0;
+}
+
+play_claymore_effects()
+{
+	self endon( "death" );
+	self waittill_not_moving();
+	playfxontag( level._effect[ "claymore_laser" ], self, "tag_fx" );
+}
+
+give_claymores_after_rounds()
+{
+	while ( 1 )
+	{
+		level waittill( "between_round_over" );
+		while ( !level flag_exists( "teleporter_used" ) || !flag( "teleporter_used" ) )
+		{
+			players = get_players();
+			i = 0;
+			while ( i < players.size )
+			{
+				if ( players[ i ] is_player_placeable_mine( "claymore_zm" ) )
+				{
+					players[ i ] giveweapon( "claymore_zm" );
+					players[ i ] set_player_placeable_mine( "claymore_zm" );
+					players[ i ] setactionslot( 4, "weapon", "claymore_zm" );
+					players[ i ] setweaponammoclip( "claymore_zm", 2 );
+				}
+				i++;
+			}
+		}
+	}
+}
+
+show_claymore_hint( string )
+{
+	self endon( "death" );
+	self endon( "disconnect" );
+	if ( string == "claymore_purchased" )
+	{
+		text = &"ZOMBIE_CLAYMORE_HOWTO";
+	}
+	else
+	{
+		text = &"ZOMBIE_CLAYMORE_ALREADY_PURCHASED";
+	}
+	show_equipment_hint_text( text );
+}

zm_tomb_patch/maps/mp/zombies/_zm_weap_one_inch_punch.gsc

@@ -0,0 +1,369 @@
+#include maps/mp/animscripts/zm_shared;
+#include maps/mp/zombies/_zm_weap_staff_lightning;
+#include maps/mp/zombies/_zm_score;
+#include maps/mp/zombies/_zm_weap_staff_water;
+#include maps/mp/zombies/_zm_weap_staff_fire;
+#include maps/mp/zombies/_zm_spawner;
+#include maps/mp/zombies/_zm_audio;
+#include maps/mp/zombies/_zm_net;
+#include maps/mp/zombies/_zm_utility;
+#include common_scripts/utility;
+#include maps/mp/_utility;
+
+one_inch_precache()
+{
+	precacheitem( "one_inch_punch_zm" );
+	precacheitem( "one_inch_punch_fire_zm" );
+	precacheitem( "one_inch_punch_air_zm" );
+	precacheitem( "one_inch_punch_ice_zm" );
+	precacheitem( "one_inch_punch_lightning_zm" );
+	precacheitem( "one_inch_punch_upgraded_zm" );
+	precacheitem( "zombie_one_inch_punch_flourish" );
+	precacheitem( "zombie_one_inch_punch_upgrade_flourish" );
+	level._effect[ "oneinch_impact" ] = loadfx( "maps/zombie_tomb/fx_tomb_perk_one_inch_punch" );
+	level._effect[ "punch_knockdown_ground" ] = loadfx( "weapon/thunder_gun/fx_thundergun_knockback_ground" );
+}
+
+one_inch_punch_melee_attack()
+{
+	self endon( "disconnect" );
+	self endon( "stop_one_inch_punch_attack" );
+	if ( isDefined( self.one_inch_punch_flag_has_been_init ) && !self.one_inch_punch_flag_has_been_init )
+	{
+		self ent_flag_init( "melee_punch_cooldown" );
+	}
+	self.one_inch_punch_flag_has_been_init = 1;
+	current_melee_weapon = self get_player_melee_weapon();
+	self takeweapon( current_melee_weapon );
+	if ( isDefined( self.b_punch_upgraded ) && self.b_punch_upgraded )
+	{
+		str_weapon = self getcurrentweapon();
+		self disable_player_move_states( 1 );
+		self giveweapon( "zombie_one_inch_punch_upgrade_flourish" );
+		self switchtoweapon( "zombie_one_inch_punch_upgrade_flourish" );
+		self waittill_any( "player_downed", "weapon_change_complete" );
+		self switchtoweapon( str_weapon );
+		self enable_player_move_states();
+		self takeweapon( "zombie_one_inch_punch_upgrade_flourish" );
+		if ( self.str_punch_element == "air" )
+		{
+			self giveweapon( "one_inch_punch_air_zm" );
+			self set_player_melee_weapon( "one_inch_punch_air_zm" );
+		}
+		else if ( self.str_punch_element == "fire" )
+		{
+			self giveweapon( "one_inch_punch_fire_zm" );
+			self set_player_melee_weapon( "one_inch_punch_fire_zm" );
+		}
+		else if ( self.str_punch_element == "ice" )
+		{
+			self giveweapon( "one_inch_punch_ice_zm" );
+			self set_player_melee_weapon( "one_inch_punch_ice_zm" );
+		}
+		else if ( self.str_punch_element == "lightning" )
+		{
+			self giveweapon( "one_inch_punch_lightning_zm" );
+			self set_player_melee_weapon( "one_inch_punch_lightning_zm" );
+		}
+		else
+		{
+			self giveweapon( "one_inch_punch_upgraded_zm" );
+			self set_player_melee_weapon( "one_inch_punch_upgraded_zm" );
+		}
+	}
+	else
+	{
+		str_weapon = self getcurrentweapon();
+		self disable_player_move_states( 1 );
+		self giveweapon( "zombie_one_inch_punch_flourish" );
+		self switchtoweapon( "zombie_one_inch_punch_flourish" );
+		self waittill_any( "player_downed", "weapon_change_complete" );
+		self switchtoweapon( str_weapon );
+		self enable_player_move_states();
+		self takeweapon( "zombie_one_inch_punch_flourish" );
+		self giveweapon( "one_inch_punch_zm" );
+		self set_player_melee_weapon( "one_inch_punch_zm" );
+		self thread maps/mp/zombies/_zm_audio::create_and_play_dialog( "perk", "one_inch" );
+	}
+	self thread monitor_melee_swipe();
+}
+
+monitor_melee_swipe()
+{
+	self endon( "disconnect" );
+	self notify( "stop_monitor_melee_swipe" );
+	self endon( "stop_monitor_melee_swipe" );
+	self endon( "bled_out" );
+	while ( 1 )
+	{
+		while ( !self ismeleeing() )
+		{
+			wait 0,05;
+		}
+		while ( self getcurrentweapon() == level.riotshield_name )
+		{
+			wait 0,1;
+		}
+		range_mod = 1;
+		self setclientfield( "oneinchpunch_impact", 1 );
+		wait_network_frame();
+		self setclientfield( "oneinchpunch_impact", 0 );
+		v_punch_effect_fwd = anglesToForward( self getplayerangles() );
+		v_punch_yaw = get2dyaw( ( 0, 0, 0 ), v_punch_effect_fwd );
+		if ( isDefined( self.b_punch_upgraded ) && self.b_punch_upgraded && isDefined( self.str_punch_element ) && self.str_punch_element == "air" )
+		{
+			range_mod *= 2;
+		}
+		a_zombies = getaispeciesarray( level.zombie_team, "all" );
+		a_zombies = get_array_of_closest( self.origin, a_zombies, undefined, undefined, 100 );
+		_a147 = a_zombies;
+		_k147 = getFirstArrayKey( _a147 );
+		while ( isDefined( _k147 ) )
+		{
+			zombie = _a147[ _k147 ];
+			if ( self is_player_facing( zombie, v_punch_yaw ) && distancesquared( self.origin, zombie.origin ) <= ( 4096 * range_mod ) )
+			{
+				self thread zombie_punch_damage( zombie, 1 );
+			}
+			else
+			{
+				if ( self is_player_facing( zombie, v_punch_yaw ) )
+				{
+					self thread zombie_punch_damage( zombie, 0,5 );
+				}
+			}
+			_k147 = getNextArrayKey( _a147, _k147 );
+		}
+		while ( self ismeleeing() )
+		{
+			wait 0,05;
+		}
+		wait 0,05;
+	}
+}
+
+is_player_facing( zombie, v_punch_yaw )
+{
+	v_player_to_zombie_yaw = get2dyaw( self.origin, zombie.origin );
+	yaw_diff = v_player_to_zombie_yaw - v_punch_yaw;
+	if ( yaw_diff < 0 )
+	{
+		yaw_diff *= -1;
+	}
+	if ( yaw_diff < 35 )
+	{
+		return 1;
+	}
+	else
+	{
+		return 0;
+	}
+}
+
+is_oneinch_punch_damage()
+{
+	if ( isDefined( self.damageweapon ) )
+	{
+		return self.damageweapon == "one_inch_punch_zm";
+	}
+}
+
+gib_zombies_head( player )
+{
+	player endon( "disconnect" );
+	self maps/mp/zombies/_zm_spawner::zombie_head_gib();
+}
+
+punch_cooldown()
+{
+	wait 1;
+	self ent_flag_set( "melee_punch_cooldown" );
+}
+
+zombie_punch_damage( ai_zombie, n_mod )
+{
+	self endon( "disconnect" );
+	ai_zombie.punch_handle_pain_notetracks = ::handle_punch_pain_notetracks;
+	if ( isDefined( n_mod ) )
+	{
+		if ( isDefined( self.b_punch_upgraded ) && self.b_punch_upgraded )
+		{
+			n_base_damage = 11275;
+		}
+		else
+		{
+			n_base_damage = 2250;
+		}
+		n_damage = int( n_base_damage * n_mod );
+		if ( isDefined( ai_zombie.is_mechz ) && !ai_zombie.is_mechz )
+		{
+			if ( n_damage >= ai_zombie.health )
+			{
+				self thread zombie_punch_death( ai_zombie );
+				self do_player_general_vox( "kill", "one_inch_punch" );
+				if ( isDefined( self.b_punch_upgraded ) && self.b_punch_upgraded && isDefined( self.str_punch_element ) )
+				{
+					switch( self.str_punch_element )
+					{
+						case "fire":
+							ai_zombie thread maps/mp/zombies/_zm_weap_staff_fire::flame_damage_fx( self.current_melee_weapon, self, n_mod );
+							break;
+						case "ice":
+							ai_zombie thread maps/mp/zombies/_zm_weap_staff_water::ice_affect_zombie( self.current_melee_weapon, self, 0, n_mod );
+							break;
+						case "lightning":
+							if ( isDefined( ai_zombie.is_mechz ) && ai_zombie.is_mechz )
+							{
+								return;
+							}
+							if ( isDefined( ai_zombie.is_electrocuted ) && ai_zombie.is_electrocuted )
+							{
+								return;
+							}
+							tag = "J_SpineUpper";
+							network_safe_play_fx_on_tag( "lightning_impact", 2, level._effect[ "lightning_impact" ], ai_zombie, tag );
+							ai_zombie thread maps/mp/zombies/_zm_audio::do_zombies_playvocals( "electrocute", ai_zombie.animname );
+							break;
+					}
+				}
+				break;
+		}
+		else self maps/mp/zombies/_zm_score::player_add_points( "damage_light" );
+		if ( isDefined( self.b_punch_upgraded ) && self.b_punch_upgraded && isDefined( self.str_punch_element ) )
+		{
+			switch( self.str_punch_element )
+			{
+				case "fire":
+					ai_zombie thread maps/mp/zombies/_zm_weap_staff_fire::flame_damage_fx( self.current_melee_weapon, self, n_mod );
+					break;
+				case "ice":
+					ai_zombie thread maps/mp/zombies/_zm_weap_staff_water::ice_affect_zombie( self.current_melee_weapon, self, 0, n_mod );
+					break;
+				case "lightning":
+					ai_zombie thread maps/mp/zombies/_zm_weap_staff_lightning::stun_zombie();
+					break;
+			}
+		}
+	}
+	ai_zombie dodamage( n_damage, ai_zombie.origin, self, self, 0, "MOD_MELEE", 0, self.current_melee_weapon );
+}
+}
+
+zombie_punch_death( ai_zombie )
+{
+	ai_zombie thread gib_zombies_head( self );
+	if ( isDefined( level.ragdoll_limit_check ) && !( [[ level.ragdoll_limit_check ]]() ) )
+	{
+		return;
+	}
+	if ( isDefined( ai_zombie ) )
+	{
+		ai_zombie startragdoll();
+		ai_zombie setclientfield( "oneinchpunch_physics_launchragdoll", 1 );
+	}
+	wait_network_frame();
+	if ( isDefined( ai_zombie ) )
+	{
+		ai_zombie setclientfield( "oneinchpunch_physics_launchragdoll", 0 );
+	}
+}
+
+handle_punch_pain_notetracks( note )
+{
+	if ( note == "zombie_knockdown_ground_impact" )
+	{
+		playfx( level._effect[ "punch_knockdown_ground" ], self.origin, anglesToForward( self.angles ), anglesToUp( self.angles ) );
+	}
+}
+
+knockdown_zombie_animate()
+{
+	self notify( "end_play_punch_pain_anim" );
+	self endon( "killanimscript" );
+	self endon( "death" );
+	self endon( "end_play_punch_pain_anim" );
+	if ( isDefined( self.marked_for_death ) && self.marked_for_death )
+	{
+		return;
+	}
+	self.allowpain = 0;
+	animation_direction = undefined;
+	animation_legs = "";
+	animation_side = undefined;
+	animation_duration = "_default";
+	v_forward = vectordot( anglesToForward( self.angles ), vectornormalize( self.v_punched_from - self.origin ) );
+	if ( v_forward > 0,6 )
+	{
+		animation_direction = "back";
+		if ( isDefined( self.has_legs ) && !self.has_legs )
+		{
+			animation_legs = "_crawl";
+		}
+		if ( randomint( 100 ) > 75 )
+		{
+			animation_side = "belly";
+		}
+		else
+		{
+			animation_side = "back";
+		}
+	}
+	else if ( self.damageyaw > 75 && self.damageyaw < 135 )
+	{
+		animation_direction = "left";
+		animation_side = "belly";
+	}
+	else
+	{
+		if ( self.damageyaw > -135 && self.damageyaw < -75 )
+		{
+			animation_direction = "right";
+			animation_side = "belly";
+		}
+		else
+		{
+			animation_direction = "front";
+			animation_side = "belly";
+		}
+	}
+	self thread knockdown_zombie_animate_state();
+	self setanimstatefromasd( "zm_punch_fall_" + animation_direction + animation_legs );
+	self maps/mp/animscripts/zm_shared::donotetracks( "punch_fall_anim", self.punch_handle_pain_notetracks );
+	if ( isDefined( self.has_legs ) || !self.has_legs && isDefined( self.marked_for_death ) && self.marked_for_death )
+	{
+		return;
+	}
+	if ( isDefined( self.a.gib_ref ) )
+	{
+		if ( self.a.gib_ref != "no_legs" && self.a.gib_ref != "no_arms" && self.a.gib_ref != "left_leg" && self.a.gib_ref == "right_leg" || randomint( 100 ) > 25 && self.a.gib_ref != "left_arm" && self.a.gib_ref == "right_arm" && randomint( 100 ) > 75 )
+		{
+			animation_duration = "_late";
+		}
+		else
+		{
+			if ( randomint( 100 ) > 75 )
+			{
+				animation_duration = "_early";
+			}
+		}
+	}
+	else
+	{
+		if ( randomint( 100 ) > 25 )
+		{
+			animation_duration = "_early";
+		}
+	}
+	self setanimstatefromasd( "zm_punch_getup_" + animation_side + animation_duration );
+	self maps/mp/animscripts/zm_shared::donotetracks( "punch_getup_anim" );
+	self.allowpain = 1;
+	self notify( "back_up" );
+}
+
+knockdown_zombie_animate_state()
+{
+	self endon( "death" );
+	self.is_knocked_down = 1;
+	self waittill_any( "damage", "back_up" );
+	self.is_knocked_down = 0;
+}

zm_tomb_patch/maps/mp/zombies/_zm_weap_riotshield_tomb.gsc

@@ -0,0 +1,783 @@
+#include maps/mp/zombies/_zm_audio;
+#include maps/mp/animscripts/zm_death;
+#include maps/mp/zombies/_zm_unitrigger;
+#include maps/mp/zombies/_zm_weapons;
+#include maps/mp/zombies/_zm_laststand;
+#include maps/mp/zombies/_zm_stats;
+#include maps/mp/gametypes_zm/_weaponobjects;
+#include maps/mp/zombies/_zm_equipment;
+#include maps/mp/zombies/_zm_spawner;
+#include maps/mp/zm_tomb_utility;
+#include maps/mp/zombies/_zm_utility;
+#include common_scripts/utility;
+#include maps/mp/_utility;
+
+init()
+{
+	maps/mp/zombies/_zm_riotshield_tomb::init();
+	set_zombie_var( "riotshield_cylinder_radius", 360 );
+	set_zombie_var( "riotshield_fling_range", 90 );
+	set_zombie_var( "riotshield_gib_range", 90 );
+	set_zombie_var( "riotshield_gib_damage", 75 );
+	set_zombie_var( "riotshield_knockdown_range", 90 );
+	set_zombie_var( "riotshield_knockdown_damage", 15 );
+	set_zombie_var( "riotshield_hit_points", 1500 );
+	set_zombie_var( "riotshield_fling_damage_shield", 100 );
+	set_zombie_var( "riotshield_knockdown_damage_shield", 15 );
+	level.riotshield_network_choke_count = 0;
+	level.riotshield_gib_refs = [];
+	level.riotshield_gib_refs[ level.riotshield_gib_refs.size ] = "guts";
+	level.riotshield_gib_refs[ level.riotshield_gib_refs.size ] = "right_arm";
+	level.riotshield_gib_refs[ level.riotshield_gib_refs.size ] = "left_arm";
+	level.riotshield_damage_callback = ::player_damage_shield;
+	level.deployed_riotshield_damage_callback = ::deployed_damage_shield;
+	level.transferriotshield = ::transferriotshield;
+	level.cantransferriotshield = ::cantransferriotshield;
+	maps/mp/zombies/_zm_spawner::register_zombie_damage_callback( ::riotshield_zombie_damage_response );
+	maps/mp/zombies/_zm_equipment::register_equipment( "tomb_shield_zm", &"ZOMBIE_EQUIP_RIOTSHIELD_PICKUP_HINT_STRING", &"ZOMBIE_EQUIP_RIOTSHIELD_HOWTO", "riotshield_zm_icon", "riotshield", ::riotshield_activation_watcher_thread, undefined, ::dropshield, ::pickupshield );
+	maps/mp/gametypes_zm/_weaponobjects::createretrievablehint( "riotshield", &"ZOMBIE_EQUIP_RIOTSHIELD_PICKUP_HINT_STRING" );
+	onplayerconnect_callback( ::onplayerconnect );
+}
+
+onplayerconnect()
+{
+	self.player_shield_reset_health = ::player_init_shield_health;
+	self.player_shield_apply_damage = ::player_damage_shield;
+	self.player_shield_reset_location = ::player_init_shield_location;
+	self thread watchriotshielduse();
+	self thread watchriotshieldmelee();
+	self thread player_watch_laststand();
+}
+
+dropshield()
+{
+	self.shield_placement = 0;
+	self maps/mp/zombies/_zm_riotshield_tomb::updateriotshieldmodel();
+	item = self maps/mp/zombies/_zm_equipment::placed_equipment_think( "t6_wpn_zmb_shield_dlc4_dmg0_world", "tomb_shield_zm", self.origin + vectorScale( ( 0, 0, 1 ), 30 ), self.angles );
+	if ( isDefined( item ) )
+	{
+		item.shielddamagetaken = self.shielddamagetaken;
+		item.original_owner = self;
+		item.owner = undefined;
+		item.name = level.riotshield_name;
+		item.isriotshield = 1;
+		item deployed_damage_shield( 0 );
+		item setscriptmoverflag( 0 );
+		item.requires_pickup = 1;
+		item thread watchtoofriendly( self );
+	}
+	self takeweapon( level.riotshield_name );
+	return item;
+}
+
+watchtoofriendly( player )
+{
+	wait 1;
+	if ( isDefined( self ) && isDefined( player ) && distance2dsquared( self.origin, player.origin ) < 36 )
+	{
+		if ( isalive( player ) )
+		{
+			player playlocalsound( level.zmb_laugh_alias );
+		}
+		player maps/mp/zombies/_zm_stats::increment_client_stat( "cheat_total", 0 );
+		self deployed_damage_shield( 2000 );
+	}
+}
+
+pickupshield( item )
+{
+	item.owner = self;
+	damage = item.shielddamagetaken;
+	damagemax = level.zombie_vars[ "riotshield_hit_points" ];
+	self.shielddamagetaken = damage;
+	self player_set_shield_health( damage, damagemax );
+}
+
+placeshield( origin, angles )
+{
+	if ( self getcurrentweapon() != level.riotshield_name )
+	{
+		self switchtoweapon( level.riotshield_name );
+		self waittill( "weapon_change" );
+	}
+	item = self maps/mp/zombies/_zm_riotshield_tomb::doriotshielddeploy( origin, angles );
+	if ( isDefined( item ) )
+	{
+		item.origin = self.origin + vectorScale( ( 0, 0, 1 ), 30 );
+		item.angles = self.angles;
+		item.owner = self;
+	}
+	return item;
+}
+
+cantransferriotshield( fromplayer, toplayer )
+{
+	if ( isDefined( toplayer.screecher_weapon ) )
+	{
+		return 0;
+	}
+	if ( isDefined( toplayer.is_drinking ) && toplayer.is_drinking > 0 )
+	{
+		return 0;
+	}
+	if ( toplayer maps/mp/zombies/_zm_laststand::player_is_in_laststand() || toplayer in_revive_trigger() )
+	{
+		return 0;
+	}
+	if ( toplayer isthrowinggrenade() )
+	{
+		return 0;
+	}
+	if ( fromplayer == toplayer )
+	{
+		return 1;
+	}
+	if ( toplayer is_player_equipment( level.riotshield_name ) && toplayer.shield_placement != 3 )
+	{
+		return 0;
+	}
+	if ( fromplayer.session_team != toplayer.session_team )
+	{
+		return 0;
+	}
+	return 1;
+}
+
+transferriotshield( fromplayer, toplayer )
+{
+	damage = fromplayer.shielddamagetaken;
+	toplayer player_take_riotshield();
+	fromplayer player_take_riotshield();
+	toplayer.shielddamagetaken = damage;
+	toplayer.shield_placement = 3;
+	toplayer.shield_damage_level = 0;
+	toplayer maps/mp/zombies/_zm_equipment::equipment_give( "tomb_shield_zm" );
+	toplayer switchtoweapon( "tomb_shield_zm" );
+	damagemax = level.zombie_vars[ "riotshield_hit_points" ];
+	toplayer player_set_shield_health( damage, damagemax );
+}
+
+player_take_riotshield()
+{
+	self notify( "destroy_riotshield" );
+	if ( self getcurrentweapon() == "tomb_shield_zm" )
+	{
+		new_primary = "";
+		if ( isDefined( self.laststand ) && self.laststand )
+		{
+			new_primary = self.laststandpistol;
+			self giveweapon( new_primary );
+		}
+		else
+		{
+			primaryweapons = self getweaponslistprimaries();
+			i = 0;
+			while ( i < primaryweapons.size )
+			{
+				if ( primaryweapons[ i ] != "tomb_shield_zm" )
+				{
+					new_primary = primaryweapons[ i ];
+					break;
+				}
+				else
+				{
+					i++;
+				}
+			}
+			if ( new_primary == "" )
+			{
+				self maps/mp/zombies/_zm_weapons::give_fallback_weapon();
+				new_primary = "zombie_fists_zm";
+			}
+		}
+		self switchtoweaponimmediate( new_primary );
+		self playsound( "wpn_riotshield_zm_destroy" );
+		self waittill( "weapon_change" );
+	}
+	self maps/mp/zombies/_zm_riotshield_tomb::removeriotshield();
+	self maps/mp/zombies/_zm_equipment::equipment_take( "tomb_shield_zm" );
+	self.hasriotshield = 0;
+	self.hasriotshieldequipped = 0;
+}
+
+player_watch_laststand()
+{
+	self endon( "disconnect" );
+	while ( 1 )
+	{
+		self waittill( "entering_last_stand" );
+		if ( self getcurrentweapon() == "tomb_shield_zm" )
+		{
+			new_primary = self.laststandpistol;
+			self giveweapon( new_primary );
+			self switchtoweaponimmediate( new_primary );
+		}
+	}
+}
+
+player_init_shield_health()
+{
+	retval = self.shielddamagetaken > 0;
+	self.shielddamagetaken = 0;
+	self.shield_damage_level = 0;
+	self maps/mp/zombies/_zm_riotshield_tomb::updateriotshieldmodel();
+	return retval;
+}
+
+player_init_shield_location()
+{
+	self.hasriotshield = 1;
+	self.hasriotshieldequipped = 0;
+	self.shield_placement = 2;
+	self maps/mp/zombies/_zm_riotshield_tomb::updateriotshieldmodel();
+}
+
+player_set_shield_health( damage, max_damage )
+{
+	shieldhealth = int( ( 100 * ( max_damage - damage ) ) / max_damage );
+	if ( shieldhealth >= 50 )
+	{
+		self.shield_damage_level = 0;
+	}
+	else if ( shieldhealth >= 25 )
+	{
+		self.shield_damage_level = 2;
+	}
+	else
+	{
+		self.shield_damage_level = 3;
+	}
+	self maps/mp/zombies/_zm_riotshield_tomb::updateriotshieldmodel();
+}
+
+deployed_set_shield_health( damage, max_damage )
+{
+	shieldhealth = int( ( 100 * ( max_damage - damage ) ) / max_damage );
+	if ( shieldhealth >= 50 )
+	{
+		self.shield_damage_level = 0;
+	}
+	else if ( shieldhealth >= 25 )
+	{
+		self.shield_damage_level = 2;
+	}
+	else
+	{
+		self.shield_damage_level = 3;
+	}
+	self maps/mp/zombies/_zm_riotshield_tomb::updatestandaloneriotshieldmodel();
+}
+
+player_damage_shield( idamage, bheld )
+{
+	damagemax = level.zombie_vars[ "riotshield_hit_points" ];
+	if ( !isDefined( self.shielddamagetaken ) )
+	{
+		self.shielddamagetaken = 0;
+	}
+	self.shielddamagetaken += idamage;
+	if ( self.shielddamagetaken >= damagemax )
+	{
+		if ( bheld || !isDefined( self.shield_ent ) )
+		{
+			self playrumbleonentity( "damage_heavy" );
+			earthquake( 1, 0,75, self.origin, 100 );
+		}
+		else
+		{
+			if ( isDefined( self.shield_ent ) )
+			{
+				if ( is_true( self.shield_ent.destroy_begun ) )
+				{
+					return;
+				}
+				self.shield_ent.destroy_begun = 1;
+				shield_origin = self.shield_ent.origin;
+				level thread maps/mp/zombies/_zm_equipment::equipment_disappear_fx( shield_origin, level._riotshield_dissapear_fx );
+				wait 1;
+				playsoundatposition( "wpn_riotshield_zm_destroy", shield_origin );
+			}
+		}
+		self thread player_take_riotshield();
+	}
+	else
+	{
+		if ( bheld )
+		{
+			self playrumbleonentity( "damage_light" );
+			earthquake( 0,5, 0,5, self.origin, 100 );
+		}
+		self player_set_shield_health( self.shielddamagetaken, damagemax );
+		self playsound( "fly_riotshield_zm_impact_zombies" );
+	}
+}
+
+deployed_damage_shield( idamage )
+{
+	damagemax = level.zombie_vars[ "riotshield_hit_points" ];
+	if ( !isDefined( self.shielddamagetaken ) )
+	{
+		self.shielddamagetaken = 0;
+	}
+	self.shielddamagetaken += idamage;
+	if ( self.shielddamagetaken >= damagemax )
+	{
+		shield_origin = self.origin;
+		if ( isDefined( self.stub ) )
+		{
+			thread maps/mp/zombies/_zm_unitrigger::unregister_unitrigger( self.stub );
+		}
+		if ( isDefined( self.original_owner ) )
+		{
+			self.original_owner maps/mp/zombies/_zm_equipment::equipment_take( "tomb_shield_zm" );
+		}
+		maps/mp/zombies/_zm_equipment::equipment_disappear_fx( shield_origin, level._riotshield_dissapear_fx );
+		playsoundatposition( "wpn_riotshield_zm_destroy", shield_origin );
+		self_delete();
+	}
+	else
+	{
+		self deployed_set_shield_health( self.shielddamagetaken, damagemax );
+	}
+}
+
+riotshield_activation_watcher_thread()
+{
+	self endon( "zombified" );
+	self endon( "disconnect" );
+	self endon( "tomb_shield_zm_taken" );
+	while ( 1 )
+	{
+		self waittill_either( "tomb_shield_zm_activate", "tomb_shield_zm_deactivate" );
+	}
+}
+
+watchriotshielduse()
+{
+	self endon( "death" );
+	self endon( "disconnect" );
+	self.shielddamagetaken = 0;
+	self thread maps/mp/zombies/_zm_riotshield_tomb::trackriotshield();
+	self thread maps/mp/zombies/_zm_riotshield_tomb::trackequipmentchange();
+	self thread maps/mp/zombies/_zm_riotshield_tomb::watchshieldlaststand();
+	self thread trackstuckzombies();
+	for ( ;; )
+	{
+		self waittill( "raise_riotshield" );
+		self thread maps/mp/zombies/_zm_riotshield_tomb::startriotshielddeploy();
+	}
+}
+
+watchriotshieldmelee()
+{
+	for ( ;; )
+	{
+		self waittill( "weapon_melee", weapon );
+		if ( weapon == level.riotshield_name )
+		{
+			self riotshield_melee();
+		}
+	}
+}
+
+is_riotshield_damage( mod, player, amount )
+{
+	if ( mod == "MOD_MELEE" && player hasweapon( level.riotshield_name ) && amount < 10 )
+	{
+		return 1;
+	}
+	return 0;
+}
+
+riotshield_damage( amount )
+{
+}
+
+riotshield_fling_zombie( player, fling_vec, index )
+{
+	if ( !isDefined( self ) || !isalive( self ) )
+	{
+		return;
+	}
+	if ( isDefined( self.ignore_riotshield ) && self.ignore_riotshield )
+	{
+		return;
+	}
+	if ( isDefined( self.riotshield_fling_func ) )
+	{
+		self [[ self.riotshield_fling_func ]]( player );
+		return;
+	}
+	damage = 2500;
+	self dodamage( damage, player.origin, player, player, "", "MOD_IMPACT" );
+	if ( self.health < 1 )
+	{
+		self.riotshield_death = 1;
+		if ( isDefined( level.ragdoll_limit_check ) && !( [[ level.ragdoll_limit_check ]]() ) )
+		{
+			return;
+		}
+		self startragdoll();
+		self launchragdoll( fling_vec );
+	}
+}
+
+zombie_knockdown( player, gib )
+{
+	damage = level.zombie_vars[ "riotshield_knockdown_damage" ];
+	if ( isDefined( level.override_riotshield_damage_func ) )
+	{
+		self [[ level.override_riotshield_damage_func ]]( player, gib );
+	}
+	else
+	{
+		if ( gib )
+		{
+			self.a.gib_ref = random( level.riotshield_gib_refs );
+			self thread maps/mp/animscripts/zm_death::do_gib();
+		}
+		self dodamage( damage, player.origin, player );
+	}
+}
+
+riotshield_knockdown_zombie( player, gib )
+{
+	self endon( "death" );
+	playsoundatposition( "vox_riotshield_forcehit", self.origin );
+	playsoundatposition( "wpn_riotshield_proj_impact", self.origin );
+	if ( !isDefined( self ) || !isalive( self ) )
+	{
+		return;
+	}
+	if ( isDefined( self.riotshield_knockdown_func ) )
+	{
+		self [[ self.riotshield_knockdown_func ]]( player, gib );
+	}
+	else
+	{
+		self zombie_knockdown( player, gib );
+	}
+	self dodamage( level.zombie_vars[ "riotshield_knockdown_damage" ], player.origin, player );
+	self playsound( "fly_riotshield_forcehit" );
+}
+
+riotshield_get_enemies_in_range()
+{
+	view_pos = self geteye();
+	zombies = get_array_of_closest( view_pos, get_round_enemy_array_wrapper(), undefined, undefined, 2 * level.zombie_vars[ "riotshield_knockdown_range" ] );
+	if ( !isDefined( zombies ) )
+	{
+		return;
+	}
+	knockdown_range_squared = level.zombie_vars[ "riotshield_knockdown_range" ] * level.zombie_vars[ "riotshield_knockdown_range" ];
+	gib_range_squared = level.zombie_vars[ "riotshield_gib_range" ] * level.zombie_vars[ "riotshield_gib_range" ];
+	fling_range_squared = level.zombie_vars[ "riotshield_fling_range" ] * level.zombie_vars[ "riotshield_fling_range" ];
+	cylinder_radius_squared = level.zombie_vars[ "riotshield_cylinder_radius" ] * level.zombie_vars[ "riotshield_cylinder_radius" ];
+	forward_view_angles = self getweaponforwarddir();
+	end_pos = view_pos + vectorScale( forward_view_angles, level.zombie_vars[ "riotshield_knockdown_range" ] );
+/#
+	if ( getDvarInt( #"BF480CE9" ) == 2 )
+	{
+		near_circle_pos = view_pos + vectorScale( forward_view_angles, 2 );
+		circle( near_circle_pos, level.zombie_vars[ "riotshield_cylinder_radius" ], ( 0, 0, 1 ), 0, 0, 100 );
+		line( near_circle_pos, end_pos, ( 0, 0, 1 ), 1, 0, 100 );
+		circle( end_pos, level.zombie_vars[ "riotshield_cylinder_radius" ], ( 0, 0, 1 ), 0, 0, 100 );
+#/
+	}
+	i = 0;
+	while ( i < zombies.size )
+	{
+		if ( !isDefined( zombies[ i ] ) || !isalive( zombies[ i ] ) )
+		{
+			i++;
+			continue;
+		}
+		else
+		{
+			test_origin = zombies[ i ] getcentroid();
+			test_range_squared = distancesquared( view_pos, test_origin );
+			if ( test_range_squared > knockdown_range_squared )
+			{
+				zombies[ i ] riotshield_debug_print( "range", ( 0, 0, 1 ) );
+				return;
+			}
+			normal = vectornormalize( test_origin - view_pos );
+			dot = vectordot( forward_view_angles, normal );
+			if ( dot <= 0 )
+			{
+				zombies[ i ] riotshield_debug_print( "dot", ( 0, 0, 1 ) );
+				i++;
+				continue;
+			}
+			else radial_origin = pointonsegmentnearesttopoint( view_pos, end_pos, test_origin );
+			if ( distancesquared( test_origin, radial_origin ) > cylinder_radius_squared )
+			{
+				zombies[ i ] riotshield_debug_print( "cylinder", ( 0, 0, 1 ) );
+				i++;
+				continue;
+			}
+			else if ( zombies[ i ] damageconetrace( view_pos, self ) == 0 )
+			{
+				zombies[ i ] riotshield_debug_print( "cone", ( 0, 0, 1 ) );
+				i++;
+				continue;
+			}
+			else if ( test_range_squared < fling_range_squared )
+			{
+				level.riotshield_fling_enemies[ level.riotshield_fling_enemies.size ] = zombies[ i ];
+				dist_mult = ( fling_range_squared - test_range_squared ) / fling_range_squared;
+				fling_vec = vectornormalize( test_origin - view_pos );
+				if ( test_range_squared >= 5000 )
+				{
+					fling_vec += vectornormalize( test_origin - radial_origin );
+				}
+				fling_vec = ( fling_vec[ 0 ], fling_vec[ 1 ], abs( fling_vec[ 2 ] ) );
+				fling_vec = vectorScale( fling_vec, 100 + ( 100 * dist_mult ) );
+				level.riotshield_fling_vecs[ level.riotshield_fling_vecs.size ] = fling_vec;
+				zombies[ i ] riotshield_debug_print( "fling", ( 0, 0, 1 ) );
+				i++;
+				continue;
+			}
+			else
+			{
+				level.riotshield_knockdown_enemies[ level.riotshield_knockdown_enemies.size ] = zombies[ i ];
+				level.riotshield_knockdown_gib[ level.riotshield_knockdown_gib.size ] = 0;
+				zombies[ i ] riotshield_debug_print( "knockdown", ( 0, 0, 1 ) );
+			}
+		}
+		i++;
+	}
+}
+
+riotshield_network_choke()
+{
+	level.riotshield_network_choke_count++;
+	if ( level.riotshield_network_choke_count % 10 )
+	{
+		wait_network_frame();
+		wait_network_frame();
+		wait_network_frame();
+	}
+}
+
+riotshield_melee()
+{
+	if ( !isDefined( level.riotshield_knockdown_enemies ) )
+	{
+		level.riotshield_knockdown_enemies = [];
+		level.riotshield_knockdown_gib = [];
+		level.riotshield_fling_enemies = [];
+		level.riotshield_fling_vecs = [];
+	}
+	self riotshield_get_enemies_in_range();
+	shield_damage = 0;
+	level.riotshield_network_choke_count = 0;
+	i = 0;
+	while ( i < level.riotshield_fling_enemies.size )
+	{
+		riotshield_network_choke();
+		if ( isDefined( level.riotshield_fling_enemies[ i ] ) )
+		{
+			level.riotshield_fling_enemies[ i ] thread riotshield_fling_zombie( self, level.riotshield_fling_vecs[ i ], i );
+			shield_damage += level.zombie_vars[ "riotshield_fling_damage_shield" ];
+		}
+		i++;
+	}
+	i = 0;
+	while ( i < level.riotshield_knockdown_enemies.size )
+	{
+		riotshield_network_choke();
+		level.riotshield_knockdown_enemies[ i ] thread riotshield_knockdown_zombie( self, level.riotshield_knockdown_gib[ i ] );
+		shield_damage += level.zombie_vars[ "riotshield_knockdown_damage_shield" ];
+		i++;
+	}
+	level.riotshield_knockdown_enemies = [];
+	level.riotshield_knockdown_gib = [];
+	level.riotshield_fling_enemies = [];
+	level.riotshield_fling_vecs = [];
+	if ( shield_damage )
+	{
+		self player_damage_shield( shield_damage, 0 );
+	}
+}
+
+trackstuckzombies()
+{
+	self endon( "death" );
+	self endon( "disconnect" );
+	for ( ;; )
+	{
+		self waittill( "deployed_riotshield" );
+		if ( isDefined( self.riotshieldentity ) )
+		{
+			self thread watchstuckzombies();
+		}
+	}
+}
+
+attack_shield( shield )
+{
+	self endon( "death" );
+	shield.owner endon( "death" );
+	shield.owner endon( "disconnect" );
+	shield.owner endon( "start_riotshield_deploy" );
+	shield.owner endon( "destroy_riotshield" );
+	if ( isDefined( self.doing_shield_attack ) && self.doing_shield_attack )
+	{
+		return 0;
+	}
+	self.old_origin = self.origin;
+	if ( getDvar( "zombie_shield_attack_freq" ) == "" )
+	{
+		setdvar( "zombie_shield_attack_freq", "15" );
+	}
+	freq = getDvarInt( "zombie_shield_attack_freq" );
+	self.doing_shield_attack = 1;
+	self.enemyoverride[ 0 ] = shield.origin;
+	self.enemyoverride[ 1 ] = shield;
+	wait ( randomint( 100 ) / 100 );
+	self thread maps/mp/zombies/_zm_audio::do_zombies_playvocals( "attack", self.animname );
+	attackanim = "zm_riotshield_melee";
+	if ( !self.has_legs )
+	{
+		attackanim += "_crawl";
+	}
+	self orientmode( "face point", shield.origin );
+	self animscripted( self.origin, flat_angle( vectorToAngle( shield.origin - self.origin ) ), attackanim );
+	if ( isDefined( shield.owner.player_shield_apply_damage ) )
+	{
+		shield.owner [[ shield.owner.player_shield_apply_damage ]]( 100, 0 );
+	}
+	else
+	{
+		shield.owner player_damage_shield( 100, 0 );
+	}
+	self thread attack_shield_stop( shield );
+	wait ( randomint( 100 ) / 100 );
+	self.doing_shield_attack = 0;
+	self orientmode( "face default" );
+}
+
+attack_shield_stop( shield )
+{
+	self notify( "attack_shield_stop" );
+	self endon( "attack_shield_stop" );
+	self endon( "death" );
+	shield waittill( "death" );
+	self stopanimscripted();
+	if ( isDefined( self.doing_shield_attack ) && self.doing_shield_attack )
+	{
+		breachanim = "zm_riotshield_breakthrough";
+		if ( !self.has_legs )
+		{
+			breachanim += "_crawl";
+		}
+		self animscripted( self.origin, flat_angle( self.angles ), breachanim );
+	}
+}
+
+window_notetracks( msg, player )
+{
+	self endon( "death" );
+	while ( 1 )
+	{
+		self waittill( msg, notetrack );
+		if ( notetrack == "end" )
+		{
+			return;
+		}
+		if ( notetrack == "fire" )
+		{
+			player player_damage_shield( 100, 0 );
+		}
+	}
+}
+
+watchstuckzombies()
+{
+	self endon( "death" );
+	self endon( "disconnect" );
+	self endon( "start_riotshield_deploy" );
+	self endon( "destroy_riotshield" );
+	self endon( "deployed_riotshield" );
+	level endon( "intermission" );
+	self.riotshieldentity maps/mp/zombies/_zm_equipment::item_attract_zombies();
+}
+
+riotshield_active()
+{
+	return self maps/mp/zombies/_zm_equipment::is_equipment_active( "tomb_shield_zm" );
+}
+
+riotshield_debug_print( msg, color )
+{
+/#
+	if ( !getDvarInt( #"BF480CE9" ) )
+	{
+		return;
+	}
+	if ( !isDefined( color ) )
+	{
+		color = ( 0, 0, 1 );
+	}
+	print3d( self.origin + vectorScale( ( 0, 0, 1 ), 60 ), msg, color, 1, 1, 40 );
+#/
+}
+
+shield_zombie_attract_func( poi )
+{
+}
+
+shield_zombie_arrive_func( poi )
+{
+	self endon( "death" );
+	self endon( "zombie_acquire_enemy" );
+	self endon( "path_timer_done" );
+	self waittill( "goal" );
+	if ( isDefined( poi.owner ) )
+	{
+		poi.owner player_damage_shield( 100, 0 );
+		if ( isDefined( poi.owner.player_shield_apply_damage ) )
+		{
+			poi.owner [[ poi.owner.player_shield_apply_damage ]]( 100, 0 );
+		}
+	}
+}
+
+createriotshieldattractor()
+{
+	self create_zombie_point_of_interest( 50, 8, 0, 1, ::shield_zombie_attract_func, ::shield_zombie_arrive_func );
+	self thread create_zombie_point_of_interest_attractor_positions( 4, 15, 15 );
+	return get_zombie_point_of_interest( self.origin );
+}
+
+riotshield_zombie_damage_response( mod, hit_location, hit_origin, player, amount )
+{
+	if ( self is_riotshield_damage( mod, player, amount ) )
+	{
+		self riotshield_damage( amount );
+		return 1;
+	}
+	return 0;
+}
+
+watchriotshieldattractor()
+{
+	self endon( "death" );
+	self endon( "disconnect" );
+	self endon( "start_riotshield_deploy" );
+	self endon( "destroy_riotshield" );
+	self endon( "deployed_riotshield" );
+	poi = self.riotshieldentity createriotshieldattractor();
+}
+
+trackriotshieldattractor()
+{
+	self endon( "death" );
+	self endon( "disconnect" );
+	for ( ;; )
+	{
+		self waittill( "deployed_riotshield" );
+		self thread watchriotshieldattractor();
+	}
+}

zm_tomb_patch/maps/mp/zombies/_zm_weap_staff_air.gsc

@@ -0,0 +1,640 @@
+#include maps/mp/animscripts/shared;
+#include maps/mp/zombies/_zm_powerups;
+#include maps/mp/zombies/_zm_audio;
+#include maps/mp/zombies/_zm_spawner;
+#include maps/mp/zombies/_zm_ai_basic;
+#include maps/mp/zm_tomb_utility;
+#include maps/mp/zombies/_zm_net;
+#include maps/mp/zombies/_zm_utility;
+#include maps/mp/_utility;
+#include common_scripts/utility;
+
+init()
+{
+	level._effect[ "whirlwind" ] = loadfx( "weapon/zmb_staff/fx_zmb_staff_air_ug_impact_miss" );
+	registerclientfield( "scriptmover", "whirlwind_play_fx", 14000, 1, "int" );
+	registerclientfield( "actor", "air_staff_launch", 14000, 1, "int" );
+	registerclientfield( "allplayers", "air_staff_source", 14000, 1, "int" );
+	onplayerconnect_callback( ::onplayerconnect );
+	maps/mp/zombies/_zm_ai_basic::init_inert_zombies();
+	flag_init( "whirlwind_active" );
+	maps/mp/zombies/_zm_spawner::register_zombie_damage_callback( ::staff_air_zombie_damage_response );
+	maps/mp/zombies/_zm_spawner::register_zombie_death_event_callback( ::staff_air_death_event );
+}
+
+precache()
+{
+	precacheitem( "staff_air_melee_zm" );
+}
+
+onplayerconnect()
+{
+	self thread onplayerspawned();
+}
+
+onplayerspawned()
+{
+	self endon( "disconnect" );
+	self thread watch_staff_air_fired();
+	self thread watch_staff_air_impact();
+	self thread watch_staff_usage();
+}
+
+air_projectile_delete()
+{
+	self endon( "death" );
+	wait 0,75;
+	self delete();
+}
+
+watch_staff_air_fired()
+{
+	self endon( "disconnect" );
+	while ( 1 )
+	{
+		self waittill( "missile_fire", e_projectile, str_weapon );
+		if ( str_weapon == "staff_air_upgraded_zm" || str_weapon == "staff_air_zm" )
+		{
+			e_projectile thread air_projectile_delete();
+			wind_damage_cone( str_weapon );
+			self setclientfield( "air_staff_source", 1 );
+			wait_network_frame();
+			self setclientfield( "air_staff_source", 0 );
+		}
+	}
+}
+
+watch_staff_air_impact()
+{
+	self endon( "disconnect" );
+	while ( 1 )
+	{
+		self waittill( "projectile_impact", str_weap_name, v_explode_point, n_radius, projectile );
+		if ( str_weap_name == "staff_air_upgraded2_zm" || str_weap_name == "staff_air_upgraded3_zm" )
+		{
+			self thread staff_air_find_source( v_explode_point, str_weap_name );
+		}
+	}
+}
+
+staff_air_find_source( v_detonate, str_weapon )
+{
+	self endon( "disconnect" );
+	if ( !isDefined( v_detonate ) )
+	{
+		return;
+	}
+	a_zombies = getaiarray( level.zombie_team );
+	a_zombies = get_array_of_closest( v_detonate, a_zombies );
+	if ( a_zombies.size )
+	{
+		i = 0;
+		while ( i < a_zombies.size )
+		{
+			if ( isalive( a_zombies[ i ] ) )
+			{
+				if ( is_true( a_zombies[ i ].staff_hit ) )
+				{
+					i++;
+					continue;
+				}
+				else
+				{
+					if ( distance2dsquared( v_detonate, a_zombies[ i ].origin ) <= 10000 )
+					{
+						self thread staff_air_zombie_source( a_zombies[ 0 ], str_weapon );
+					}
+					else
+					{
+						self thread staff_air_position_source( v_detonate, str_weapon );
+					}
+					return;
+				}
+			}
+			i++;
+		}
+	}
+	else self thread staff_air_position_source( v_detonate, str_weapon );
+}
+
+staff_air_zombie_source( ai_zombie, str_weapon )
+{
+	self endon( "disconnect" );
+	ai_zombie.staff_hit = 1;
+	ai_zombie.is_source = 1;
+	v_whirlwind_pos = ai_zombie.origin;
+	self thread staff_air_position_source( v_whirlwind_pos, str_weapon );
+	if ( !isDefined( ai_zombie.is_mechz ) )
+	{
+		self thread source_zombie_death( ai_zombie );
+	}
+}
+
+staff_air_position_source( v_detonate, str_weapon )
+{
+	self endon( "disconnect" );
+	if ( !isDefined( v_detonate ) )
+	{
+		return;
+	}
+	if ( flag( "whirlwind_active" ) )
+	{
+		level notify( "whirlwind_stopped" );
+		while ( flag( "whirlwind_active" ) )
+		{
+			wait_network_frame();
+		}
+		wait 0,3;
+	}
+	flag_set( "whirlwind_active" );
+	n_time = self.chargeshotlevel * 3,5;
+	e_whirlwind = spawn( "script_model", v_detonate + vectorScale( ( 0, 0, 0 ), 100 ) );
+	e_whirlwind setmodel( "tag_origin" );
+	e_whirlwind.angles = vectorScale( ( 0, 0, 0 ), 90 );
+	e_whirlwind thread puzzle_debug_position( "X", vectorScale( ( 0, 0, 0 ), 255 ) );
+	e_whirlwind moveto( groundpos_ignore_water_new( e_whirlwind.origin ), 0,05 );
+	e_whirlwind waittill( "movedone" );
+	e_whirlwind setclientfield( "whirlwind_play_fx", 1 );
+	e_whirlwind thread whirlwind_rumble_nearby_players( "whirlwind_active" );
+	e_whirlwind thread whirlwind_timeout( n_time );
+	wait 0,5;
+	e_whirlwind.player_owner = self;
+	e_whirlwind thread whirlwind_seek_zombies( self.chargeshotlevel, str_weapon );
+}
+
+whirlwind_seek_zombies( n_level, str_weapon )
+{
+	self endon( "death" );
+	self.b_found_zombies = 0;
+	n_range = get_air_blast_range( n_level );
+	while ( 1 )
+	{
+		a_zombies = staff_air_zombie_range( self.origin, n_range );
+		if ( a_zombies.size )
+		{
+			self.b_found_zombies = 1;
+			self thread whirlwind_kill_zombies( n_level, str_weapon );
+			return;
+		}
+		else
+		{
+			wait 0,1;
+		}
+	}
+}
+
+whirlwind_timeout( n_time )
+{
+	self endon( "death" );
+	level waittill_any_or_timeout( n_time, "whirlwind_stopped" );
+	level notify( "whirlwind_stopped" );
+	self setclientfield( "whirlwind_play_fx", 0 );
+	self notify( "stop_debug_position" );
+	flag_clear( "whirlwind_active" );
+	wait 1,5;
+	self delete();
+}
+
+move_along_ground_position( v_position, n_time )
+{
+	v_diff = vectornormalize( v_position - self.origin );
+	v_newpos = self.origin + ( v_diff * 50 ) + vectorScale( ( 0, 0, 0 ), 50 );
+	v_ground = groundpos_ignore_water_new( v_newpos );
+	self moveto( v_ground, n_time );
+}
+
+whirlwind_kill_zombies( n_level, str_weapon )
+{
+	self endon( "death" );
+	n_range = get_air_blast_range( n_level );
+	self.n_charge_level = n_level;
+	while ( 1 )
+	{
+		a_zombies = staff_air_zombie_range( self.origin, n_range );
+		a_zombies = get_array_of_closest( self.origin, a_zombies );
+		i = 0;
+		while ( i < a_zombies.size )
+		{
+			if ( !isDefined( a_zombies[ i ] ) )
+			{
+				i++;
+				continue;
+			}
+			else if ( a_zombies[ i ].ai_state != "find_flesh" )
+			{
+				i++;
+				continue;
+			}
+			else if ( is_true( a_zombies[ i ].is_mechz ) )
+			{
+				i++;
+				continue;
+			}
+			else if ( is_true( self._whirlwind_attract_anim ) )
+			{
+				i++;
+				continue;
+			}
+			else v_offset = ( 10, 10, 32 );
+			if ( !bullet_trace_throttled( self.origin + v_offset, a_zombies[ i ].origin + v_offset, undefined ) )
+			{
+				i++;
+				continue;
+			}
+			else if ( !isDefined( a_zombies[ i ] ) || !isalive( a_zombies[ i ] ) )
+			{
+				i++;
+				continue;
+			}
+			else
+			{
+				v_offset = ( -10, -10, 64 );
+				if ( !bullet_trace_throttled( self.origin + v_offset, a_zombies[ i ].origin + v_offset, undefined ) )
+				{
+					i++;
+					continue;
+				}
+				else if ( !isDefined( a_zombies[ i ] ) || !isalive( a_zombies[ i ] ) )
+				{
+					i++;
+					continue;
+				}
+				else
+				{
+					a_zombies[ i ] thread whirlwind_drag_zombie( self, str_weapon );
+					wait 0,5;
+				}
+			}
+			i++;
+		}
+		wait_network_frame();
+	}
+}
+
+whirlwind_drag_zombie( e_whirlwind, str_weapon )
+{
+	if ( isDefined( self.e_linker ) )
+	{
+		return;
+	}
+	self whirlwind_move_zombie( e_whirlwind );
+	if ( isDefined( self ) && isDefined( e_whirlwind ) && flag( "whirlwind_active" ) )
+	{
+		player = e_whirlwind.player_owner;
+		self do_damage_network_safe( player, self.health, str_weapon, "MOD_IMPACT" );
+		level thread staff_air_gib( self );
+	}
+}
+
+whirlwind_move_zombie( e_whirlwind )
+{
+	if ( isDefined( self.e_linker ) )
+	{
+		return;
+	}
+	self.e_linker = spawn( "script_origin", ( 0, 0, 0 ) );
+	self.e_linker.origin = self.origin;
+	self.e_linker.angles = self.angles;
+	self linkto( self.e_linker );
+	self thread whirlwind_unlink( e_whirlwind );
+	if ( isDefined( e_whirlwind ) )
+	{
+		n_dist_sq = distance2dsquared( e_whirlwind.origin, self.origin );
+	}
+	n_fling_range_sq = 900;
+	while ( isalive( self ) && n_dist_sq > n_fling_range_sq && isDefined( e_whirlwind ) && flag( "whirlwind_active" ) )
+	{
+		n_dist_sq = distance2dsquared( e_whirlwind.origin, self.origin );
+		if ( isDefined( self.ai_state ) && self.ai_state == "find_flesh" )
+		{
+			b_supercharged = e_whirlwind.n_charge_level == 3;
+			self thread whirlwind_attract_anim( e_whirlwind.origin, b_supercharged );
+			n_movetime = 1;
+			if ( b_supercharged )
+			{
+				n_movetime = 0,8;
+			}
+			self.e_linker thread move_along_ground_position( e_whirlwind.origin, n_movetime );
+		}
+		else
+		{
+		}
+		wait 0,05;
+	}
+	self notify( "reached_whirlwind" );
+	self.e_linker delete();
+}
+
+whirlwind_unlink( e_whirlwind )
+{
+	self endon( "death" );
+	e_whirlwind waittill( "death" );
+	self unlink();
+}
+
+source_zombie_death( ai_zombie )
+{
+	self endon( "disconnect" );
+	n_range = get_air_blast_range( self.chargeshotlevel );
+	tag = "J_SpineUpper";
+	if ( ai_zombie.isdog )
+	{
+		tag = "J_Spine1";
+	}
+	v_source = ai_zombie gettagorigin( tag );
+	ai_zombie thread staff_air_fling_zombie( self );
+	a_zombies = staff_air_zombie_range( v_source, n_range );
+	if ( !isDefined( a_zombies ) )
+	{
+		return;
+	}
+	self thread staff_air_proximity_kill( a_zombies );
+}
+
+get_air_blast_range( n_charge )
+{
+	switch( n_charge )
+	{
+		case 1:
+			n_range = 100;
+			break;
+		default:
+			n_range = 250;
+			break;
+	}
+	return n_range;
+}
+
+staff_air_proximity_kill( a_zombies )
+{
+	self endon( "disconnect" );
+	if ( !isDefined( a_zombies ) )
+	{
+		return;
+	}
+	i = 0;
+	while ( i < a_zombies.size )
+	{
+		if ( isalive( a_zombies[ i ] ) )
+		{
+			a_zombies[ i ] thread staff_air_fling_zombie( self );
+			wait 0,05;
+		}
+		i++;
+	}
+}
+
+staff_air_zombie_range( v_source, n_range )
+{
+	a_enemies = [];
+	a_zombies = getaiarray( level.zombie_team );
+	a_zombies = get_array_of_closest( v_source, a_zombies );
+	n_range_sq = n_range * n_range;
+	while ( isDefined( a_zombies ) )
+	{
+		i = 0;
+		while ( i < a_zombies.size )
+		{
+			if ( !isDefined( a_zombies[ i ] ) )
+			{
+				i++;
+				continue;
+			}
+			else v_zombie_pos = a_zombies[ i ].origin;
+			if ( isDefined( a_zombies[ i ].staff_hit ) && a_zombies[ i ].staff_hit == 1 )
+			{
+				i++;
+				continue;
+			}
+			else
+			{
+				if ( distancesquared( v_source, v_zombie_pos ) > n_range_sq )
+				{
+					i++;
+					continue;
+				}
+				else
+				{
+					a_enemies[ a_enemies.size ] = a_zombies[ i ];
+				}
+			}
+			i++;
+		}
+	}
+	return a_enemies;
+}
+
+staff_air_fling_zombie( player )
+{
+	player endon( "disconnect" );
+	if ( !isalive( self ) )
+	{
+		return;
+	}
+	if ( isDefined( self.is_source ) || cointoss() )
+	{
+		self thread zombie_launch( player, "staff_air_upgraded_zm" );
+	}
+	else
+	{
+		self do_damage_network_safe( player, self.health, "staff_air_upgraded_zm", "MOD_IMPACT" );
+		level thread staff_air_gib( self );
+	}
+}
+
+zombie_launch( e_attacker, str_weapon )
+{
+	self do_damage_network_safe( e_attacker, self.health, str_weapon, "MOD_IMPACT" );
+	if ( isDefined( level.ragdoll_limit_check ) && !( [[ level.ragdoll_limit_check ]]() ) )
+	{
+		level thread staff_air_gib( self );
+	}
+	else
+	{
+		self startragdoll();
+		self setclientfield( "air_staff_launch", 1 );
+	}
+}
+
+determine_launch_vector( e_attacker, ai_target )
+{
+	v_launch = ( vectornormalize( ai_target.origin - e_attacker.origin ) * randomintrange( 125, 150 ) ) + ( 0, 0, randomintrange( 75, 150 ) );
+	return v_launch;
+}
+
+staff_air_gib( ai_zombie )
+{
+	if ( cointoss() )
+	{
+		ai_zombie thread zombie_gib_all();
+	}
+	ai_zombie thread zombie_gib_guts();
+}
+
+staff_air_zombie_damage_response( mod, hit_location, hit_origin, player, amount )
+{
+	if ( self is_staff_air_damage() && mod != "MOD_MELEE" )
+	{
+		self thread stun_zombie();
+		return 1;
+	}
+	return 0;
+}
+
+is_staff_air_damage()
+{
+	if ( isDefined( self.damageweapon ) && self.damageweapon != "staff_air_zm" && self.damageweapon == "staff_air_upgraded_zm" )
+	{
+		return !is_true( self.set_beacon_damage );
+	}
+}
+
+staff_air_death_event()
+{
+	if ( is_staff_air_damage() && self.damagemod != "MOD_MELEE" )
+	{
+		if ( is_true( self.is_mechz ) )
+		{
+			return;
+		}
+		self thread maps/mp/zombies/_zm_audio::do_zombies_playvocals( "death", self.animname );
+		self thread zombie_eye_glow_stop();
+		if ( isDefined( level.ragdoll_limit_check ) && !( [[ level.ragdoll_limit_check ]]() ) )
+		{
+			level thread staff_air_gib( self );
+			return;
+		}
+		else
+		{
+			self startragdoll();
+			self setclientfield( "air_staff_launch", 1 );
+		}
+	}
+}
+
+wind_damage_cone( str_weapon )
+{
+	fire_angles = self getplayerangles();
+	fire_origin = self getplayercamerapos();
+	a_targets = getaiarray( "axis" );
+	a_targets = get_array_of_closest( self.origin, a_targets, undefined, 12, 400 );
+	if ( str_weapon == "staff_air_upgraded_zm" )
+	{
+		n_damage = 3300;
+		n_fov = 60;
+	}
+	else
+	{
+		n_damage = 2050;
+		n_fov = 45;
+	}
+	_a675 = a_targets;
+	_k675 = getFirstArrayKey( _a675 );
+	while ( isDefined( _k675 ) )
+	{
+		target = _a675[ _k675 ];
+		if ( isai( target ) )
+		{
+			if ( within_fov( fire_origin, fire_angles, target gettagorigin( "j_spine4" ), cos( n_fov ) ) )
+			{
+				if ( self maps/mp/zombies/_zm_powerups::is_insta_kill_active() )
+				{
+					n_damage = target.health;
+				}
+				target do_damage_network_safe( self, n_damage, str_weapon, "MOD_IMPACT" );
+			}
+		}
+		_k675 = getNextArrayKey( _a675, _k675 );
+	}
+}
+
+stun_zombie()
+{
+	self endon( "death" );
+	if ( is_true( self.is_mechz ) )
+	{
+		return;
+	}
+	if ( is_true( self.is_electrocuted ) )
+	{
+		return;
+	}
+	if ( !isDefined( self.ai_state ) || self.ai_state != "find_flesh" )
+	{
+		return;
+	}
+	self.forcemovementscriptstate = 1;
+	self.ignoreall = 1;
+	self.is_electrocuted = 1;
+	tag = "J_SpineUpper";
+	if ( self.isdog )
+	{
+		tag = "J_Spine1";
+	}
+	self animscripted( self.origin, self.angles, "zm_electric_stun" );
+	self maps/mp/animscripts/shared::donotetracks( "stunned" );
+	self.forcemovementscriptstate = 0;
+	self.ignoreall = 0;
+	self.is_electrocuted = 0;
+}
+
+whirlwind_attract_anim_watch_cancel()
+{
+	self endon( "death" );
+	while ( flag( "whirlwind_active" ) )
+	{
+		wait_network_frame();
+	}
+	self.deathanim = undefined;
+	self stopanimscripted();
+	self._whirlwind_attract_anim = 0;
+}
+
+whirlwind_attract_anim( v_attract_point, b_move_fast )
+{
+	if ( !isDefined( b_move_fast ) )
+	{
+		b_move_fast = 0;
+	}
+	self endon( "death" );
+	level endon( "whirlwind_stopped" );
+	if ( is_true( self._whirlwind_attract_anim ) )
+	{
+		return;
+	}
+	v_angles_to_source = vectorToAngle( v_attract_point - self.origin );
+	v_source_to_target = vectorToAngle( self.origin - v_attract_point );
+	self.a.runblendtime = 0,9;
+	if ( self.has_legs )
+	{
+		self.needs_run_update = 1;
+		self._had_legs = 1;
+		if ( b_move_fast )
+		{
+			self animscripted( self.origin, v_source_to_target, "zm_move_whirlwind_fast" );
+		}
+		else
+		{
+			self animscripted( self.origin, v_source_to_target, "zm_move_whirlwind" );
+		}
+	}
+	else self.needs_run_update = 1;
+	self._had_legs = 0;
+	if ( b_move_fast )
+	{
+		self animscripted( self.origin, v_source_to_target, "zm_move_whirlwind_crawl" );
+	}
+	else
+	{
+		self animscripted( self.origin, v_source_to_target, "zm_move_whirlwind_fast_crawl" );
+	}
+	if ( is_true( self.nogravity ) )
+	{
+		self animmode( "none" );
+		self.nogravity = undefined;
+	}
+	self._whirlwind_attract_anim = 1;
+	self.a.runblendtime = self._normal_run_blend_time;
+	self thread whirlwind_attract_anim_watch_cancel();
+	self waittill( "reached_whirlwind" );
+}

zm_tomb_patch/maps/mp/zombies/_zm_weap_staff_fire.gsc

@@ -0,0 +1,452 @@
+#include maps/mp/zombies/_zm_powerups;
+#include maps/mp/zombies/_zm_audio;
+#include maps/mp/zombies/_zm_spawner;
+#include maps/mp/zombies/_zm_ai_basic;
+#include maps/mp/zm_tomb_utility;
+#include maps/mp/zombies/_zm_net;
+#include maps/mp/zombies/_zm_utility;
+#include maps/mp/_utility;
+#include common_scripts/utility;
+
+init()
+{
+	registerclientfield( "actor", "fire_char_fx", 14000, 1, "int" );
+	registerclientfield( "toplayer", "fire_muzzle_fx", 14000, 1, "int" );
+	onplayerconnect_callback( ::onplayerconnect );
+	maps/mp/zombies/_zm_ai_basic::init_inert_zombies();
+	maps/mp/zombies/_zm_spawner::register_zombie_damage_callback( ::staff_fire_zombie_damage_response );
+	maps/mp/zombies/_zm_spawner::register_zombie_death_event_callback( ::staff_fire_death_event );
+}
+
+precache()
+{
+	precacheitem( "staff_fire_melee_zm" );
+}
+
+onplayerconnect()
+{
+	self thread onplayerspawned();
+}
+
+onplayerspawned()
+{
+	self endon( "disconnect" );
+	while ( 1 )
+	{
+		self waittill( "spawned_player" );
+		self thread watch_staff_fire_upgrade_fired();
+		self thread watch_staff_fire_fired();
+		self thread watch_staff_usage();
+	}
+}
+
+watch_staff_fire_fired()
+{
+	self notify( "watch_staff_fired" );
+	self endon( "disconnect" );
+	self endon( "watch_staff_fired" );
+	while ( 1 )
+	{
+		self waittill( "missile_fire", e_projectile, str_weapon );
+		while ( is_true( e_projectile.additional_shot ) )
+		{
+			continue;
+		}
+		if ( str_weapon == "staff_fire_zm" || str_weapon == "staff_fire_upgraded_zm" )
+		{
+			self fire_spread_shots( str_weapon );
+		}
+	}
+}
+
+watch_staff_fire_upgrade_fired()
+{
+	self notify( "watch_staff_upgrade_fired" );
+	self endon( "disconnect" );
+	self endon( "watch_staff_upgrade_fired" );
+	while ( 1 )
+	{
+		self waittill( "grenade_fire", e_projectile, str_weapon );
+		while ( is_true( e_projectile.additional_shot ) )
+		{
+			continue;
+		}
+		if ( str_weapon == "staff_fire_upgraded2_zm" || str_weapon == "staff_fire_upgraded3_zm" )
+		{
+			e_projectile thread fire_staff_update_grenade_fuse();
+			e_projectile thread fire_staff_area_of_effect( self, str_weapon );
+			self fire_additional_shots( str_weapon );
+		}
+	}
+}
+
+fire_spread_shots( str_weapon )
+{
+	wait_network_frame();
+	wait_network_frame();
+	v_fwd = self getweaponforwarddir();
+	fire_angles = vectorToAngle( v_fwd );
+	fire_origin = self getweaponmuzzlepoint();
+	trace = bullettrace( fire_origin, fire_origin + ( v_fwd * 100 ), 0, undefined );
+	if ( trace[ "fraction" ] != 1 )
+	{
+		return;
+	}
+	v_left_angles = ( fire_angles[ 0 ], fire_angles[ 1 ] - 15, fire_angles[ 2 ] );
+	v_left = anglesToForward( v_left_angles );
+	e_proj = magicbullet( str_weapon, fire_origin + ( v_fwd * 50 ), fire_origin + ( v_left * 100 ), self );
+	e_proj.additional_shot = 1;
+	wait_network_frame();
+	wait_network_frame();
+	v_fwd = self getweaponforwarddir();
+	fire_angles = vectorToAngle( v_fwd );
+	fire_origin = self getweaponmuzzlepoint();
+	v_right_angles = ( fire_angles[ 0 ], fire_angles[ 1 ] + 15, fire_angles[ 2 ] );
+	v_right = anglesToForward( v_right_angles );
+	e_proj = magicbullet( str_weapon, fire_origin + ( v_fwd * 50 ), fire_origin + ( v_right * 100 ), self );
+	e_proj.additional_shot = 1;
+}
+
+fire_staff_area_of_effect( e_attacker, str_weapon )
+{
+	self waittill( "explode", v_pos );
+	ent = spawn( "script_origin", v_pos );
+	ent playloopsound( "wpn_firestaff_grenade_loop", 1 );
+/#
+	level thread puzzle_debug_position( "X", vectorScale( ( 0, 0, 0 ), 255 ), v_pos, undefined, 5 );
+#/
+	n_alive_time = 5;
+	aoe_radius = 80;
+	if ( str_weapon == "staff_fire_upgraded3_zm" )
+	{
+		aoe_radius = 100;
+	}
+	n_step_size = 0,2;
+	while ( n_alive_time > 0 )
+	{
+		if ( ( n_alive_time - n_step_size ) <= 0 )
+		{
+			aoe_radius *= 2;
+		}
+		a_targets = getaiarray( "axis" );
+		a_targets = get_array_of_closest( v_pos, a_targets, undefined, undefined, aoe_radius );
+		wait n_step_size;
+		n_alive_time -= n_step_size;
+		_a213 = a_targets;
+		_k213 = getFirstArrayKey( _a213 );
+		while ( isDefined( _k213 ) )
+		{
+			e_target = _a213[ _k213 ];
+			if ( isDefined( e_target ) && isalive( e_target ) )
+			{
+				if ( !is_true( self.is_on_fire ) )
+				{
+					e_target thread flame_damage_fx( str_weapon, e_attacker );
+				}
+			}
+			_k213 = getNextArrayKey( _a213, _k213 );
+		}
+	}
+	ent playsound( "wpn_firestaff_proj_impact" );
+	ent delete();
+}
+
+grenade_waittill_still_or_bounce()
+{
+	self endon( "death" );
+	self endon( "grenade_bounce" );
+	wait 0,5;
+	prev_origin = self.origin;
+	wait_network_frame();
+	wait_network_frame();
+}
+
+fire_staff_update_grenade_fuse()
+{
+	self endon( "death" );
+	self grenade_waittill_still_or_bounce();
+	self notify( "fire_aoe_start" );
+	self resetmissiledetonationtime( 0 );
+}
+
+fire_additional_shots( str_weapon )
+{
+	self endon( "disconnect" );
+	self endon( "weapon_change" );
+	n_shots = 1;
+	if ( str_weapon == "staff_fire_upgraded3_zm" )
+	{
+		n_shots = 2;
+	}
+	i = 1;
+	while ( i <= n_shots )
+	{
+		wait 0,35;
+		if ( isDefined( self ) && self getcurrentweapon() == "staff_fire_upgraded_zm" )
+		{
+			v_player_angles = vectorToAngle( self getweaponforwarddir() );
+			n_player_pitch = v_player_angles[ 0 ];
+			n_player_pitch += 5 * i;
+			n_player_yaw = v_player_angles[ 1 ] + randomfloatrange( -15, 15 );
+			v_shot_angles = ( n_player_pitch, n_player_yaw, v_player_angles[ 2 ] );
+			v_shot_start = self getweaponmuzzlepoint();
+			v_shot_end = v_shot_start + anglesToForward( v_shot_angles );
+			e_proj = magicbullet( str_weapon, v_shot_start, v_shot_end, self );
+			e_proj.additional_shot = 1;
+			e_proj thread fire_staff_update_grenade_fuse();
+			e_proj thread fire_staff_area_of_effect( self, str_weapon );
+			self setclientfieldtoplayer( "fire_muzzle_fx", 1 );
+			wait_network_frame();
+			self setclientfieldtoplayer( "fire_muzzle_fx", 0 );
+		}
+		i++;
+	}
+}
+
+staff_fire_zombie_damage_response( mod, hit_location, hit_origin, player, amount )
+{
+	if ( self is_staff_fire_damage() && mod != "MOD_MELEE" )
+	{
+		self thread staff_fire_zombie_hit_response_internal( mod, self.damageweapon, player, amount );
+		return 1;
+	}
+	return 0;
+}
+
+is_staff_fire_damage()
+{
+	if ( isDefined( self.damageweapon ) && self.damageweapon != "staff_fire_zm" && self.damageweapon != "staff_fire_upgraded_zm" && self.damageweapon != "staff_fire_upgraded2_zm" && self.damageweapon == "staff_fire_upgraded3_zm" )
+	{
+		return !is_true( self.set_beacon_damage );
+	}
+}
+
+staff_fire_zombie_hit_response_internal( mod, damageweapon, player, amount )
+{
+	player endon( "disconnect" );
+	if ( !isalive( self ) )
+	{
+		return;
+	}
+	if ( mod != "MOD_BURNED" && mod != "MOD_GRENADE_SPLASH" )
+	{
+		pct_from_center = ( amount - 1 ) / 10;
+		pct_damage = 0,5 + ( 0,5 * pct_from_center );
+		if ( is_true( self.is_mechz ) )
+		{
+			self thread mechz_flame_damage( damageweapon, player, pct_damage );
+			return;
+		}
+		self thread flame_damage_fx( damageweapon, player, pct_damage );
+	}
+}
+
+staff_fire_death_event()
+{
+	if ( is_staff_fire_damage() && self.damagemod != "MOD_MELEE" )
+	{
+		self setclientfield( "fire_char_fx", 1 );
+		self thread maps/mp/zombies/_zm_audio::do_zombies_playvocals( "death", self.animname );
+		self thread zombie_eye_glow_stop();
+	}
+}
+
+on_fire_timeout( n_duration )
+{
+	self endon( "death" );
+	wait n_duration;
+	self.is_on_fire = 0;
+	self notify( "stop_flame_damage" );
+}
+
+flame_damage_fx( damageweapon, e_attacker, pct_damage )
+{
+	if ( !isDefined( pct_damage ) )
+	{
+		pct_damage = 1;
+	}
+	was_on_fire = is_true( self.is_on_fire );
+	n_initial_dmg = get_impact_damage( damageweapon ) * pct_damage;
+	if ( damageweapon != "staff_fire_upgraded_zm" && damageweapon != "staff_fire_upgraded2_zm" )
+	{
+		is_upgraded = damageweapon == "staff_fire_upgraded3_zm";
+	}
+	if ( is_upgraded && pct_damage > 0,5 && n_initial_dmg > self.health && cointoss() )
+	{
+		self do_damage_network_safe( e_attacker, self.health, damageweapon, "MOD_BURNED" );
+		if ( cointoss() )
+		{
+			self thread zombie_gib_all();
+		}
+		else
+		{
+			self thread zombie_gib_guts();
+		}
+		return;
+	}
+	self endon( "death" );
+	if ( !was_on_fire )
+	{
+		self.is_on_fire = 1;
+		self thread zombie_set_and_restore_flame_state();
+		wait 0,5;
+		self thread flame_damage_over_time( e_attacker, damageweapon, pct_damage );
+	}
+	if ( n_initial_dmg > 0 )
+	{
+		self do_damage_network_safe( e_attacker, n_initial_dmg, damageweapon, "MOD_BURNED" );
+	}
+}
+
+_fire_stun_zombie_internal( do_stun, run_cycle )
+{
+	if ( !isalive( self ) )
+	{
+		return;
+	}
+	if ( is_true( self.has_legs ) )
+	{
+		self set_zombie_run_cycle( run_cycle );
+	}
+	if ( do_stun )
+	{
+		self animscripted( self.origin, self.angles, "zm_afterlife_stun" );
+	}
+}
+
+fire_stun_zombie_choked( do_stun, run_cycle )
+{
+	maps/mp/zombies/_zm_net::network_safe_init( "fire_stun", 2 );
+	self maps/mp/zombies/_zm_net::network_choke_action( "fire_stun", ::_fire_stun_zombie_internal, do_stun, run_cycle );
+}
+
+zombie_set_and_restore_flame_state()
+{
+	if ( !isalive( self ) )
+	{
+		return;
+	}
+	if ( is_true( self.is_mechz ) )
+	{
+		return;
+	}
+	self setclientfield( "fire_char_fx", 1 );
+	self.disablemelee = 1;
+	prev_run_cycle = self.zombie_move_speed;
+	if ( is_true( self.has_legs ) )
+	{
+		self.deathanim = "zm_death_fire";
+	}
+	if ( self.ai_state == "find_flesh" )
+	{
+		self fire_stun_zombie_choked( 1, "burned" );
+	}
+	self waittill( "stop_flame_damage" );
+	self.deathanim = undefined;
+	self.disablemelee = undefined;
+	if ( self.ai_state == "find_flesh" )
+	{
+		self fire_stun_zombie_choked( 0, prev_run_cycle );
+	}
+	self setclientfield( "fire_char_fx", 0 );
+}
+
+get_impact_damage( damageweapon )
+{
+	switch( damageweapon )
+	{
+		case "staff_fire_zm":
+			return 2050;
+		case "staff_fire_upgraded_zm":
+			return 3300;
+		case "staff_fire_upgraded2_zm":
+			return 11500;
+		case "staff_fire_upgraded3_zm":
+			return 20000;
+		case "one_inch_punch_fire_zm":
+			return 0;
+		default:
+			return 0;
+	}
+}
+
+get_damage_per_second( damageweapon )
+{
+	switch( damageweapon )
+	{
+		case "staff_fire_zm":
+			return 75;
+		case "staff_fire_upgraded_zm":
+			return 150;
+		case "staff_fire_upgraded2_zm":
+			return 300;
+		case "staff_fire_upgraded3_zm":
+			return 450;
+		case "one_inch_punch_fire_zm":
+			return 250;
+		default:
+			return self.health;
+	}
+}
+
+get_damage_duration( damageweapon )
+{
+	switch( damageweapon )
+	{
+		case "staff_fire_zm":
+			return 8;
+		case "staff_fire_upgraded_zm":
+			return 8;
+		case "staff_fire_upgraded2_zm":
+			return 8;
+		case "staff_fire_upgraded3_zm":
+			return 8;
+		case "one_inch_punch_fire_zm":
+			return 8;
+		default:
+			return 8;
+	}
+}
+
+flame_damage_over_time( e_attacker, damageweapon, pct_damage )
+{
+	e_attacker endon( "disconnect" );
+	self endon( "death" );
+	self endon( "stop_flame_damage" );
+	n_damage = get_damage_per_second( damageweapon );
+	n_duration = get_damage_duration( damageweapon );
+	n_damage *= pct_damage;
+	self thread on_fire_timeout( n_duration );
+	while ( 1 )
+	{
+		if ( isDefined( e_attacker ) && isplayer( e_attacker ) )
+		{
+			if ( e_attacker maps/mp/zombies/_zm_powerups::is_insta_kill_active() )
+			{
+				n_damage = self.health;
+			}
+		}
+		self do_damage_network_safe( e_attacker, n_damage, damageweapon, "MOD_BURNED" );
+		wait 1;
+	}
+}
+
+mechz_flame_damage( damageweapon, e_attacker, pct_damage )
+{
+	self endon( "death" );
+	n_initial_dmg = get_impact_damage( damageweapon );
+	if ( n_initial_dmg > 0 )
+	{
+		self do_damage_network_safe( e_attacker, n_initial_dmg, damageweapon, "MOD_BURNED" );
+	}
+}
+
+stop_zombie()
+{
+	e_linker = spawn( "script_origin", ( 0, 0, 0 ) );
+	e_linker.origin = self.origin;
+	e_linker.angles = self.angles;
+	self linkto( e_linker );
+	self waittill( "death" );
+	e_linker delete();
+}

zm_tomb_patch/maps/mp/zombies/_zm_weap_staff_lightning.gsc

@@ -0,0 +1,444 @@
+#include maps/mp/animscripts/shared;
+#include maps/mp/zombies/_zm_score;
+#include maps/mp/zombies/_zm_powerups;
+#include maps/mp/zombies/_zm_audio;
+#include maps/mp/zombies/_zm_spawner;
+#include maps/mp/zm_tomb_utility;
+#include maps/mp/zombies/_zm_net;
+#include maps/mp/zombies/_zm_utility;
+#include maps/mp/_utility;
+#include common_scripts/utility;
+
+init()
+{
+	level._effect[ "lightning_miss" ] = loadfx( "weapon/zmb_staff/fx_zmb_staff_elec_ug_impact_miss" );
+	level._effect[ "lightning_arc" ] = loadfx( "weapon/zmb_staff/fx_zmb_staff_elec_trail_bolt_cheap" );
+	level._effect[ "lightning_impact" ] = loadfx( "weapon/zmb_staff/fx_zmb_staff_elec_ug_impact_hit_torso" );
+	level._effect[ "tesla_shock_eyes" ] = loadfx( "maps/zombie/fx_zombie_tesla_shock_eyes" );
+	registerclientfield( "actor", "lightning_impact_fx", 14000, 1, "int" );
+	registerclientfield( "scriptmover", "lightning_miss_fx", 14000, 1, "int" );
+	registerclientfield( "actor", "lightning_arc_fx", 14000, 1, "int" );
+	set_zombie_var( "tesla_head_gib_chance", 50 );
+	onplayerconnect_callback( ::onplayerconnect );
+	maps/mp/zombies/_zm_spawner::register_zombie_damage_callback( ::staff_lightning_zombie_damage_response );
+	maps/mp/zombies/_zm_spawner::register_zombie_death_event_callback( ::staff_lightning_death_event );
+}
+
+precache()
+{
+	precacheitem( "staff_lightning_melee_zm" );
+}
+
+onplayerconnect()
+{
+	self thread onplayerspawned();
+}
+
+onplayerspawned()
+{
+	self endon( "disconnect" );
+	self thread watch_staff_lightning_fired();
+	self thread watch_staff_usage();
+}
+
+watch_staff_lightning_fired()
+{
+	self endon( "disconnect" );
+	while ( 1 )
+	{
+		self waittill( "missile_fire", e_projectile, str_weapon );
+		if ( str_weapon == "staff_lightning_upgraded2_zm" || str_weapon == "staff_lightning_upgraded3_zm" )
+		{
+			fire_angles = vectorToAngle( self getweaponforwarddir() );
+			fire_origin = self getweaponmuzzlepoint();
+			self thread staff_lightning_position_source( fire_origin, fire_angles, str_weapon );
+		}
+	}
+}
+
+lightning_ball_wait( n_lifetime_after_move )
+{
+	level endon( "lightning_ball_created" );
+	self waittill( "movedone" );
+	wait n_lifetime_after_move;
+	return 1;
+}
+
+staff_lightning_position_source( v_detonate, v_angles, str_weapon )
+{
+	self endon( "disconnect" );
+	level notify( "lightning_ball_created" );
+	if ( !isDefined( v_angles ) )
+	{
+		v_angles = ( 0, 0, 1 );
+	}
+	e_ball_fx = spawn( "script_model", v_detonate + ( anglesToForward( v_angles ) * 100 ) );
+	e_ball_fx.angles = v_angles;
+	e_ball_fx.str_weapon = str_weapon;
+	e_ball_fx setmodel( "tag_origin" );
+	e_ball_fx.n_range = get_lightning_blast_range( self.chargeshotlevel );
+	e_ball_fx.n_damage_per_sec = get_lightning_ball_damage_per_sec( self.chargeshotlevel );
+	e_ball_fx setclientfield( "lightning_miss_fx", 1 );
+	n_shot_range = staff_lightning_get_shot_range( self.chargeshotlevel );
+	v_end = v_detonate + ( anglesToForward( v_angles ) * n_shot_range );
+	trace = bullettrace( v_detonate, v_end, 0, undefined );
+	if ( trace[ "fraction" ] != 1 )
+	{
+		v_end = trace[ "position" ];
+	}
+	staff_lightning_ball_speed = n_shot_range / 8;
+	n_dist = distance( e_ball_fx.origin, v_end );
+	n_max_movetime_s = n_shot_range / staff_lightning_ball_speed;
+	n_movetime_s = n_dist / staff_lightning_ball_speed;
+	n_leftover_time = n_max_movetime_s - n_movetime_s;
+	e_ball_fx thread staff_lightning_ball_kill_zombies( self );
+/#
+	e_ball_fx thread puzzle_debug_position( "X", ( 175, 0, 255 ) );
+#/
+	e_ball_fx moveto( v_end, n_movetime_s );
+	finished_playing = e_ball_fx lightning_ball_wait( n_leftover_time );
+	e_ball_fx notify( "stop_killing" );
+	e_ball_fx notify( "stop_debug_position" );
+	if ( is_true( finished_playing ) )
+	{
+		wait 3;
+	}
+	if ( isDefined( e_ball_fx ) )
+	{
+		e_ball_fx delete();
+	}
+}
+
+staff_lightning_ball_kill_zombies( e_attacker )
+{
+	self endon( "death" );
+	self endon( "stop_killing" );
+	while ( 1 )
+	{
+		a_zombies = staff_lightning_get_valid_targets( e_attacker, self.origin );
+		while ( isDefined( a_zombies ) )
+		{
+			_a173 = a_zombies;
+			_k173 = getFirstArrayKey( _a173 );
+			while ( isDefined( _k173 ) )
+			{
+				zombie = _a173[ _k173 ];
+				if ( staff_lightning_is_target_valid( zombie ) )
+				{
+					e_attacker thread staff_lightning_arc_fx( self, zombie );
+					wait 0,2;
+				}
+				_k173 = getNextArrayKey( _a173, _k173 );
+			}
+		}
+		wait 0,5;
+	}
+}
+
+staff_lightning_get_valid_targets( player, v_source )
+{
+	player endon( "disconnect" );
+	a_enemies = [];
+	a_zombies = getaiarray( level.zombie_team );
+	a_zombies = get_array_of_closest( v_source, a_zombies, undefined, undefined, self.n_range );
+	while ( isDefined( a_zombies ) )
+	{
+		_a200 = a_zombies;
+		_k200 = getFirstArrayKey( _a200 );
+		while ( isDefined( _k200 ) )
+		{
+			ai_zombie = _a200[ _k200 ];
+			if ( staff_lightning_is_target_valid( ai_zombie ) )
+			{
+				a_enemies[ a_enemies.size ] = ai_zombie;
+			}
+			_k200 = getNextArrayKey( _a200, _k200 );
+		}
+	}
+	return a_enemies;
+}
+
+staff_lightning_get_shot_range( n_charge )
+{
+	switch( n_charge )
+	{
+		case 3:
+			return 1200;
+		default:
+			return 800;
+	}
+}
+
+get_lightning_blast_range( n_charge )
+{
+	switch( n_charge )
+	{
+		case 1:
+			n_range = 200;
+			break;
+		case 2:
+			n_range = 150;
+			break;
+		case 3:
+		default:
+			n_range = 250;
+			break;
+	}
+	return n_range;
+}
+
+get_lightning_ball_damage_per_sec( n_charge )
+{
+	if ( !isDefined( n_charge ) )
+	{
+		return 2500;
+	}
+	switch( n_charge )
+	{
+		case 3:
+			return 3500;
+		default:
+			return 2500;
+	}
+}
+
+staff_lightning_is_target_valid( ai_zombie )
+{
+	if ( !isDefined( ai_zombie ) )
+	{
+		return 0;
+	}
+	if ( is_true( ai_zombie.is_being_zapped ) )
+	{
+		return 0;
+	}
+	if ( is_true( ai_zombie.is_mechz ) )
+	{
+		return 0;
+	}
+	return 1;
+}
+
+staff_lightning_ball_damage_over_time( e_source, e_target, e_attacker )
+{
+	e_attacker endon( "disconnect" );
+	e_target setclientfield( "lightning_impact_fx", 1 );
+	e_target thread maps/mp/zombies/_zm_audio::do_zombies_playvocals( "electrocute", e_target.animname );
+	n_range_sq = e_source.n_range * e_source.n_range;
+	e_target.is_being_zapped = 1;
+	e_target setclientfield( "lightning_arc_fx", 1 );
+	wait 0,5;
+	if ( isDefined( e_source ) )
+	{
+		if ( !isDefined( e_source.n_damage_per_sec ) )
+		{
+			e_source.n_damage_per_sec = get_lightning_ball_damage_per_sec( e_attacker.chargeshotlevel );
+		}
+		n_damage_per_pulse = e_source.n_damage_per_sec * 1;
+	}
+	while ( isDefined( e_source ) && isalive( e_target ) )
+	{
+		e_target thread stun_zombie();
+		wait 1;
+		if ( !isDefined( e_source ) || !isalive( e_target ) )
+		{
+		}
+		else
+		{
+			n_dist_sq = distancesquared( e_source.origin, e_target.origin );
+			if ( n_dist_sq > n_range_sq )
+			{
+			}
+			else if ( isalive( e_target ) && isDefined( e_source ) )
+			{
+				instakill_on = e_attacker maps/mp/zombies/_zm_powerups::is_insta_kill_active();
+				if ( n_damage_per_pulse < e_target.health && !instakill_on )
+				{
+					e_target do_damage_network_safe( e_attacker, n_damage_per_pulse, e_source.str_weapon, "MOD_RIFLE_BULLET" );
+				}
+				else
+				{
+					e_target thread zombie_shock_eyes();
+					e_target thread staff_lightning_kill_zombie( e_attacker, e_source.str_weapon );
+				}
+			}
+			else
+			{
+			}
+		}
+	}
+	if ( isDefined( e_target ) )
+	{
+		e_target.is_being_zapped = 0;
+		e_target setclientfield( "lightning_arc_fx", 0 );
+	}
+}
+
+staff_lightning_arc_fx( e_source, ai_zombie )
+{
+	self endon( "disconnect" );
+	if ( !isDefined( ai_zombie ) )
+	{
+		return;
+	}
+	if ( !bullet_trace_throttled( e_source.origin, ai_zombie.origin + vectorScale( ( 0, 0, 1 ), 20 ), ai_zombie ) )
+	{
+		return;
+	}
+	if ( isDefined( e_source ) && isDefined( ai_zombie ) && isalive( ai_zombie ) )
+	{
+		level thread staff_lightning_ball_damage_over_time( e_source, ai_zombie, self );
+	}
+}
+
+staff_lightning_kill_zombie( player, str_weapon )
+{
+	player endon( "disconnect" );
+	if ( !isalive( self ) )
+	{
+		return;
+	}
+	if ( is_true( self.has_legs ) )
+	{
+		if ( !self hasanimstatefromasd( "zm_death_tesla" ) )
+		{
+			return;
+		}
+		self.deathanim = "zm_death_tesla";
+	}
+	else
+	{
+		if ( !self hasanimstatefromasd( "zm_death_tesla_crawl" ) )
+		{
+			return;
+		}
+		self.deathanim = "zm_death_tesla_crawl";
+	}
+	if ( is_true( self.is_traversing ) )
+	{
+		self.deathanim = undefined;
+	}
+	self do_damage_network_safe( player, self.health, str_weapon, "MOD_RIFLE_BULLET" );
+	player maps/mp/zombies/_zm_score::player_add_points( "death", "", "" );
+}
+
+staff_lightning_death_fx()
+{
+	if ( isDefined( self ) )
+	{
+		self setclientfield( "lightning_impact_fx", 1 );
+		self thread maps/mp/zombies/_zm_audio::do_zombies_playvocals( "electrocute", self.animname );
+		self thread zombie_shock_eyes();
+	}
+}
+
+zombie_shock_eyes_network_safe( fx, entity, tag )
+{
+	if ( network_entity_valid( entity ) )
+	{
+		if ( !is_true( self.head_gibbed ) )
+		{
+			playfxontag( fx, entity, tag );
+		}
+	}
+}
+
+zombie_shock_eyes()
+{
+	if ( isDefined( self.head_gibbed ) && self.head_gibbed )
+	{
+		return;
+	}
+	maps/mp/zombies/_zm_net::network_safe_init( "shock_eyes", 2 );
+	maps/mp/zombies/_zm_net::network_choke_action( "shock_eyes", ::zombie_shock_eyes_network_safe, level._effect[ "tesla_shock_eyes" ], self, "J_Eyeball_LE" );
+}
+
+staff_lightning_zombie_damage_response( mod, hit_location, hit_origin, player, amount )
+{
+	if ( self is_staff_lightning_damage() && self.damagemod != "MOD_RIFLE_BULLET" )
+	{
+		self thread stun_zombie();
+	}
+	return 0;
+}
+
+is_staff_lightning_damage()
+{
+	if ( isDefined( self.damageweapon ) && self.damageweapon != "staff_lightning_zm" && self.damageweapon == "staff_lightning_upgraded_zm" )
+	{
+		return !is_true( self.set_beacon_damage );
+	}
+}
+
+staff_lightning_death_event()
+{
+	if ( is_staff_lightning_damage() && self.damagemod != "MOD_MELEE" )
+	{
+		if ( is_true( self.is_mechz ) )
+		{
+			return;
+		}
+		self thread maps/mp/zombies/_zm_audio::do_zombies_playvocals( "death", self.animname );
+		self thread zombie_eye_glow_stop();
+		if ( is_true( self.has_legs ) )
+		{
+			if ( !self hasanimstatefromasd( "zm_death_tesla" ) )
+			{
+				return;
+			}
+			self.deathanim = "zm_death_tesla";
+		}
+		else
+		{
+			if ( !self hasanimstatefromasd( "zm_death_tesla_crawl" ) )
+			{
+				return;
+			}
+			self.deathanim = "zm_death_tesla_crawl";
+		}
+		if ( is_true( self.is_traversing ) )
+		{
+			self.deathanim = undefined;
+		}
+		tag = "J_SpineUpper";
+		self setclientfield( "lightning_impact_fx", 1 );
+		self thread maps/mp/zombies/_zm_audio::do_zombies_playvocals( "electrocute", self.animname );
+		self thread zombie_shock_eyes();
+		if ( isDefined( self.deathanim ) )
+		{
+			self waittillmatch( "death_anim" );
+			return "die";
+		}
+		self do_damage_network_safe( self.attacker, self.health, self.damageweapon, "MOD_RIFLE_BULLET" );
+	}
+}
+
+stun_zombie()
+{
+	self endon( "death" );
+	if ( is_true( self.is_mechz ) )
+	{
+		return;
+	}
+	if ( is_true( self.is_electrocuted ) )
+	{
+		return;
+	}
+	if ( !isDefined( self.ai_state ) || self.ai_state != "find_flesh" )
+	{
+		return;
+	}
+	self.forcemovementscriptstate = 1;
+	self.ignoreall = 1;
+	self.is_electrocuted = 1;
+	tag = "J_SpineUpper";
+	network_safe_play_fx_on_tag( "lightning_impact", 2, level._effect[ "lightning_impact" ], self, tag );
+	if ( is_true( self.has_legs ) )
+	{
+		self animscripted( self.origin, self.angles, "zm_electric_stun" );
+	}
+	self maps/mp/animscripts/shared::donotetracks( "stunned" );
+	self.forcemovementscriptstate = 0;
+	self.ignoreall = 0;
+	self.is_electrocuted = 0;
+}

zm_tomb_patch/maps/mp/zombies/_zm_weap_staff_revive.gsc

@@ -0,0 +1,74 @@
+#include maps/mp/zombies/_zm_laststand;
+#include maps/mp/zm_tomb_utility;
+#include maps/mp/zombies/_zm_net;
+#include maps/mp/zombies/_zm_utility;
+#include maps/mp/_utility;
+#include common_scripts/utility;
+
+init()
+{
+	onplayerconnect_callback( ::onplayerconnect );
+}
+
+onplayerconnect()
+{
+	self thread onplayerspawned();
+}
+
+onplayerspawned()
+{
+	self endon( "disconnect" );
+	while ( 1 )
+	{
+		self waittill( "spawned_player" );
+		self thread watch_staff_revive_fired();
+	}
+}
+
+watch_staff_revive_fired()
+{
+	self endon( "disconnect" );
+	while ( 1 )
+	{
+		self waittill( "missile_fire", e_projectile, str_weapon );
+		while ( str_weapon != "staff_revive_zm" )
+		{
+			continue;
+		}
+		self waittill( "projectile_impact", e_ent, v_explode_point, n_radius, str_name, n_impact );
+		self thread staff_revive_impact( v_explode_point );
+	}
+}
+
+staff_revive_impact( v_explode_point )
+{
+	self endon( "disconnect" );
+	e_closest_player = undefined;
+	n_closest_dist_sq = 1024;
+	playsoundatposition( "wpn_revivestaff_proj_impact", v_explode_point );
+	a_e_players = getplayers();
+	_a70 = a_e_players;
+	_k70 = getFirstArrayKey( _a70 );
+	while ( isDefined( _k70 ) )
+	{
+		e_player = _a70[ _k70 ];
+		if ( e_player == self || !e_player maps/mp/zombies/_zm_laststand::player_is_in_laststand() )
+		{
+		}
+		else
+		{
+			n_dist_sq = distancesquared( v_explode_point, e_player.origin );
+			if ( n_dist_sq < n_closest_dist_sq )
+			{
+				e_closest_player = e_player;
+			}
+		}
+		_k70 = getNextArrayKey( _a70, _k70 );
+	}
+	if ( isDefined( e_closest_player ) )
+	{
+		e_closest_player notify( "remote_revive" );
+		e_closest_player playsoundtoplayer( "wpn_revivestaff_revive_plr", e_player );
+		self notify( "revived_player_with_upgraded_staff" );
+	}
+}

zm_tomb_patch/maps/mp/zombies/_zm_weap_staff_water.gsc

@@ -0,0 +1,545 @@
+#include maps/mp/zombies/_zm_powerups;
+#include maps/mp/zombies/_zm_score;
+#include maps/mp/zombies/_zm_spawner;
+#include maps/mp/zm_tomb_utility;
+#include maps/mp/zombies/_zm_net;
+#include maps/mp/zombies/_zm_utility;
+#include maps/mp/_utility;
+#include common_scripts/utility;
+
+init()
+{
+	level._effect[ "staff_water_blizzard" ] = loadfx( "weapon/zmb_staff/fx_zmb_staff_ice_ug_impact_hit" );
+	level._effect[ "staff_water_ice_shard" ] = loadfx( "weapon/zmb_staff/fx_zmb_staff_ice_trail_bolt" );
+	level._effect[ "staff_water_shatter" ] = loadfx( "weapon/zmb_staff/fx_zmb_staff_ice_exp" );
+	registerclientfield( "scriptmover", "staff_blizzard_fx", 14000, 1, "int" );
+	registerclientfield( "actor", "anim_rate", 14000, 2, "float" );
+	registerclientfield( "actor", "attach_bullet_model", 14000, 1, "int" );
+	onplayerconnect_callback( ::onplayerconnect );
+	precacheitem( "staff_water_fake_dart_zm" );
+	precacheitem( "staff_water_dart_zm" );
+	flag_init( "blizzard_active" );
+	init_tag_array();
+	level thread water_dart_cleanup();
+	maps/mp/zombies/_zm_spawner::register_zombie_death_event_callback( ::staff_water_death_event );
+	maps/mp/zombies/_zm_spawner::add_cusom_zombie_spawn_logic( ::staff_water_on_zombie_spawned );
+}
+
+precache()
+{
+	precacheitem( "staff_water_melee_zm" );
+}
+
+init_tag_array()
+{
+	level.zombie_water_icicle_tag = [];
+	level.zombie_water_icicle_tag[ 0 ] = "j_hip_le";
+	level.zombie_water_icicle_tag[ 1 ] = "j_hip_ri";
+	level.zombie_water_icicle_tag[ 2 ] = "j_spine4";
+	level.zombie_water_icicle_tag[ 3 ] = "j_elbow_le";
+	level.zombie_water_icicle_tag[ 4 ] = "j_elbow_ri";
+	level.zombie_water_icicle_tag[ 5 ] = "j_clavicle_le";
+	level.zombie_water_icicle_tag[ 6 ] = "j_clavicle_ri";
+}
+
+water_dart_cleanup()
+{
+	while ( 1 )
+	{
+		a_grenades = getentarray( "grenade", "classname" );
+		_a73 = a_grenades;
+		_k73 = getFirstArrayKey( _a73 );
+		while ( isDefined( _k73 ) )
+		{
+			e_grenade = _a73[ _k73 ];
+			if ( isDefined( e_grenade.model ) && e_grenade.model == "p6_zm_tm_staff_projectile_ice" )
+			{
+				time = getTime();
+				if ( ( time - e_grenade.birthtime ) >= 1000 )
+				{
+					e_grenade delete();
+				}
+			}
+			_k73 = getNextArrayKey( _a73, _k73 );
+		}
+		wait 0,1;
+	}
+}
+
+onplayerconnect()
+{
+	self thread onplayerspawned();
+}
+
+onplayerspawned()
+{
+	self endon( "disconnect" );
+	self thread watch_staff_water_fired();
+	self thread watch_staff_water_impact();
+	self thread watch_staff_usage();
+}
+
+watch_staff_water_fired()
+{
+	self endon( "disconnect" );
+	while ( 1 )
+	{
+		self waittill( "missile_fire", e_projectile, str_weapon );
+		if ( str_weapon == "staff_water_zm" || str_weapon == "staff_water_upgraded_zm" )
+		{
+			wait_network_frame();
+			_icicle_locate_target( str_weapon );
+			wait_network_frame();
+			_icicle_locate_target( str_weapon );
+			wait_network_frame();
+			_icicle_locate_target( str_weapon );
+		}
+	}
+}
+
+watch_staff_water_impact()
+{
+	self endon( "disconnect" );
+	while ( 1 )
+	{
+		self waittill( "projectile_impact", str_weapon, v_explode_point, n_radius, str_name, n_impact );
+		if ( str_weapon == "staff_water_upgraded2_zm" || str_weapon == "staff_water_upgraded3_zm" )
+		{
+			n_lifetime = 6;
+			if ( str_weapon == "staff_water_upgraded3_zm" )
+			{
+				n_lifetime = 9;
+			}
+			self thread staff_water_position_source( v_explode_point, n_lifetime, str_weapon );
+		}
+	}
+}
+
+staff_water_kill_zombie( player, str_weapon )
+{
+	self freeze_zombie();
+	self do_damage_network_safe( player, self.health, str_weapon, "MOD_RIFLE_BULLET" );
+	if ( isDefined( self.deathanim ) )
+	{
+		self waittillmatch( "death_anim" );
+		return "shatter";
+	}
+	if ( isDefined( self ) )
+	{
+		self thread frozen_zombie_shatter();
+	}
+	player maps/mp/zombies/_zm_score::player_add_points( "death", "", "" );
+}
+
+freeze_zombie()
+{
+	if ( is_true( self.is_mechz ) )
+	{
+		return;
+	}
+	if ( !self.isdog )
+	{
+		if ( self.has_legs )
+		{
+			if ( !self hasanimstatefromasd( "zm_death_freeze" ) )
+			{
+				return;
+			}
+			self.deathanim = "zm_death_freeze";
+		}
+		else
+		{
+			if ( !self hasanimstatefromasd( "zm_death_freeze_crawl" ) )
+			{
+				return;
+			}
+			self.deathanim = "zm_death_freeze_crawl";
+		}
+	}
+	else
+	{
+		self.a.nodeath = undefined;
+	}
+	if ( is_true( self.is_traversing ) )
+	{
+		self.deathanim = undefined;
+	}
+}
+
+_network_safe_play_fx( fx, v_origin )
+{
+	playfx( fx, v_origin, ( 0, 0, 1 ), ( 0, 0, 1 ) );
+}
+
+network_safe_play_fx( id, max, fx, v_origin )
+{
+	network_safe_init( id, max );
+	network_choke_action( id, ::_network_safe_play_fx, fx, v_origin );
+}
+
+frozen_zombie_shatter()
+{
+	if ( is_true( self.is_mechz ) )
+	{
+		return;
+	}
+	if ( isDefined( self ) )
+	{
+		if ( is_mature() )
+		{
+			v_fx = self gettagorigin( "J_SpineLower" );
+			level thread network_safe_play_fx( "frozen_shatter", 2, level._effect[ "staff_water_shatter" ], v_fx );
+			self thread frozen_zombie_gib( "normal" );
+			return;
+		}
+		else
+		{
+			self startragdoll();
+		}
+	}
+}
+
+frozen_zombie_gib( gib_type )
+{
+	gibarray = [];
+	gibarray[ gibarray.size ] = level._zombie_gib_piece_index_all;
+	self gib( gib_type, gibarray );
+	self ghost();
+	wait 0,4;
+	if ( isDefined( self ) )
+	{
+		self self_delete();
+	}
+}
+
+staff_water_position_source( v_detonate, n_lifetime_sec, str_weapon )
+{
+	self endon( "disconnect" );
+	if ( isDefined( v_detonate ) )
+	{
+		level notify( "blizzard_shot" );
+		e_fx = spawn( "script_model", v_detonate + vectorScale( ( 0, 0, 1 ), 33 ) );
+		e_fx setmodel( "tag_origin" );
+		e_fx setclientfield( "staff_blizzard_fx", 1 );
+		e_fx thread puzzle_debug_position( "X", ( 0, 64, 255 ) );
+		wait 1;
+		flag_set( "blizzard_active" );
+		e_fx thread ice_staff_blizzard_do_kills( self, str_weapon );
+		e_fx thread whirlwind_rumble_nearby_players( "blizzard_active" );
+		e_fx thread ice_staff_blizzard_timeout( n_lifetime_sec );
+		e_fx thread ice_staff_blizzard_off();
+		e_fx waittill( "blizzard_off" );
+		flag_clear( "blizzard_active" );
+		e_fx notify( "stop_debug_position" );
+		wait 0,1;
+		e_fx setclientfield( "staff_blizzard_fx", 0 );
+		wait 0,1;
+		e_fx delete();
+	}
+}
+
+ice_staff_blizzard_do_kills( player, str_weapon )
+{
+	player endon( "disconnect" );
+	self endon( "blizzard_off" );
+	while ( 1 )
+	{
+		a_zombies = getaiarray( level.zombie_team );
+		_a317 = a_zombies;
+		_k317 = getFirstArrayKey( _a317 );
+		while ( isDefined( _k317 ) )
+		{
+			zombie = _a317[ _k317 ];
+			if ( !is_true( zombie.is_on_ice ) )
+			{
+				if ( distancesquared( self.origin, zombie.origin ) <= 30625 )
+				{
+					if ( is_true( zombie.is_mechz ) )
+					{
+						zombie thread ice_affect_mechz( player, 1 );
+						break;
+					}
+					else
+					{
+						if ( isalive( zombie ) )
+						{
+							zombie thread ice_affect_zombie( str_weapon, player, 1 );
+						}
+					}
+				}
+			}
+			_k317 = getNextArrayKey( _a317, _k317 );
+		}
+		wait 0,1;
+	}
+}
+
+ice_staff_blizzard_timeout( n_time )
+{
+	self endon( "death" );
+	self endon( "blizzard_off" );
+	wait n_time;
+	self notify( "blizzard_off" );
+}
+
+ice_staff_blizzard_off()
+{
+	self endon( "death" );
+	self endon( "blizzard_off" );
+	level waittill( "blizzard_shot" );
+	self notify( "blizzard_off" );
+}
+
+get_ice_blast_range( n_charge )
+{
+	switch( n_charge )
+	{
+		case 0:
+		case 1:
+			n_range = 250000;
+			break;
+		case 2:
+			n_range = 640000;
+			break;
+		case 3:
+			n_range = 1000000;
+			break;
+	}
+	return n_range;
+}
+
+staff_water_zombie_range( v_source, n_range )
+{
+	a_enemies = [];
+	a_zombies = getaiarray( level.zombie_team );
+	a_zombies = get_array_of_closest( v_source, a_zombies );
+	while ( isDefined( a_zombies ) )
+	{
+		i = 0;
+		while ( i < a_zombies.size )
+		{
+			if ( !isDefined( a_zombies[ i ] ) )
+			{
+				i++;
+				continue;
+			}
+			else v_zombie_pos = a_zombies[ i ] gettagorigin( "j_head" );
+			if ( distancesquared( v_source, v_zombie_pos ) > n_range )
+			{
+				i++;
+				continue;
+			}
+			else if ( !bullet_trace_throttled( v_source, v_zombie_pos, undefined ) )
+			{
+				i++;
+				continue;
+			}
+			else
+			{
+				if ( isDefined( a_zombies[ i ] ) && isalive( a_zombies[ i ] ) )
+				{
+					a_enemies[ a_enemies.size ] = a_zombies[ i ];
+				}
+			}
+			i++;
+		}
+	}
+	return a_enemies;
+}
+
+is_staff_water_damage()
+{
+	if ( isDefined( self.damageweapon ) && self.damageweapon != "staff_water_zm" && self.damageweapon != "staff_water_upgraded_zm" && self.damageweapon == "staff_water_fake_dart_zm" )
+	{
+		return !is_true( self.set_beacon_damage );
+	}
+}
+
+ice_affect_mechz( e_player, is_upgraded )
+{
+	if ( is_true( self.is_on_ice ) )
+	{
+		return;
+	}
+	self.is_on_ice = 1;
+	if ( is_upgraded )
+	{
+		self do_damage_network_safe( e_player, 3300, "staff_water_upgraded_zm", "MOD_RIFLE_BULLET" );
+	}
+	else
+	{
+		self do_damage_network_safe( e_player, 2050, "staff_water_zm", "MOD_RIFLE_BULLET" );
+	}
+	wait 1;
+	self.is_on_ice = 0;
+}
+
+ice_affect_zombie( str_weapon, e_player, always_kill, n_mod )
+{
+	if ( !isDefined( str_weapon ) )
+	{
+		str_weapon = "staff_water_zm";
+	}
+	if ( !isDefined( always_kill ) )
+	{
+		always_kill = 0;
+	}
+	if ( !isDefined( n_mod ) )
+	{
+		n_mod = 1;
+	}
+	self endon( "death" );
+	instakill_on = e_player maps/mp/zombies/_zm_powerups::is_insta_kill_active();
+	if ( str_weapon == "staff_water_zm" )
+	{
+		n_damage = 2050;
+	}
+	else if ( str_weapon != "staff_water_upgraded_zm" || str_weapon == "staff_water_upgraded2_zm" && str_weapon == "staff_water_upgraded3_zm" )
+	{
+		n_damage = 3300;
+	}
+	else
+	{
+		if ( str_weapon == "one_inch_punch_ice_zm" )
+		{
+			n_damage = 11275;
+		}
+	}
+	if ( is_true( self.is_on_ice ) )
+	{
+		return;
+	}
+	self.is_on_ice = 1;
+	self setclientfield( "attach_bullet_model", 1 );
+	n_speed = 0,3;
+	self set_anim_rate( 0,3 );
+	if ( instakill_on || always_kill )
+	{
+		wait randomfloatrange( 0,5, 0,7 );
+	}
+	else
+	{
+		wait randomfloatrange( 1,8, 2,3 );
+	}
+	if ( n_damage >= self.health || instakill_on && always_kill )
+	{
+		self set_anim_rate( 1 );
+		wait_network_frame();
+		if ( str_weapon != "one_inch_punch_ice_zm" )
+		{
+			staff_water_kill_zombie( e_player, str_weapon );
+		}
+	}
+	else
+	{
+		self do_damage_network_safe( e_player, n_damage, str_weapon, "MOD_RIFLE_BULLET" );
+		self.deathanim = undefined;
+		self setclientfield( "attach_bullet_model", 0 );
+		wait 0,5;
+		self set_anim_rate( 1 );
+		self.is_on_ice = 0;
+	}
+}
+
+set_anim_rate( n_speed )
+{
+	self setclientfield( "anim_rate", n_speed );
+	n_rate = self getclientfield( "anim_rate" );
+	self setentityanimrate( n_rate );
+	if ( n_speed != 1 )
+	{
+		self.preserve_asd_substates = 1;
+	}
+	wait_network_frame();
+	if ( !is_true( self.is_traversing ) )
+	{
+		self.needs_run_update = 1;
+		self notify( "needs_run_update" );
+	}
+	wait_network_frame();
+	if ( n_speed == 1 )
+	{
+		self.preserve_asd_substates = 0;
+	}
+}
+
+staff_water_on_zombie_spawned()
+{
+	self setclientfield( "anim_rate", 1 );
+	n_rate = self getclientfield( "anim_rate" );
+	self setentityanimrate( n_rate );
+}
+
+staff_water_death_event()
+{
+	if ( is_staff_water_damage() && self.damagemod != "MOD_MELEE" )
+	{
+		self.no_gib = 1;
+		self.nodeathragdoll = 1;
+		self freeze_zombie();
+		if ( isDefined( self.deathanim ) )
+		{
+			self waittillmatch( "death_anim" );
+			return "shatter";
+		}
+		self thread frozen_zombie_shatter();
+	}
+}
+
+_icicle_locate_target( str_weapon )
+{
+	is_upgraded = str_weapon == "staff_water_upgraded_zm";
+	fire_angles = self getplayerangles();
+	fire_origin = self getplayercamerapos();
+	a_targets = getaiarray( "axis" );
+	a_targets = get_array_of_closest( self.origin, a_targets, undefined, undefined, 600 );
+	_a592 = a_targets;
+	_k592 = getFirstArrayKey( _a592 );
+	while ( isDefined( _k592 ) )
+	{
+		target = _a592[ _k592 ];
+		if ( is_true( target.is_on_ice ) )
+		{
+		}
+		else
+		{
+			if ( within_fov( fire_origin, fire_angles, target gettagorigin( "j_spine4" ), cos( 25 ) ) )
+			{
+				if ( isai( target ) )
+				{
+					a_tags = [];
+					a_tags[ 0 ] = "j_hip_le";
+					a_tags[ 1 ] = "j_hip_ri";
+					a_tags[ 2 ] = "j_spine4";
+					a_tags[ 3 ] = "j_elbow_le";
+					a_tags[ 4 ] = "j_elbow_ri";
+					a_tags[ 5 ] = "j_clavicle_le";
+					a_tags[ 6 ] = "j_clavicle_ri";
+					str_tag = a_tags[ randomint( a_tags.size ) ];
+					b_trace_pass = bullet_trace_throttled( fire_origin, target gettagorigin( str_tag ), target );
+					if ( b_trace_pass && isDefined( target ) && isalive( target ) )
+					{
+						if ( is_true( target.is_mechz ) )
+						{
+							target thread ice_affect_mechz( self, is_upgraded );
+						}
+						else
+						{
+							target thread ice_affect_zombie( str_weapon, self );
+						}
+						return;
+					}
+				}
+			}
+		}
+		_k592 = getNextArrayKey( _a592, _k592 );
+	}
+}
+
+_icicle_get_spread( n_spread )
+{
+	n_x = randomintrange( n_spread * -1, n_spread );
+	n_y = randomintrange( n_spread * -1, n_spread );
+	n_z = randomintrange( n_spread * -1, n_spread );
+	return ( n_x, n_y, n_z );
+}

zm_tomb_patch/readme.md

@@ -10,4 +10,77 @@ zm_tomb_patch/maps/mp/zombies/_zm_perk_random.gsc
 
 ### The following scripts compile but cause a minidump or other severe error:
 
+### The following scripts have been checked, but they have not been tested yet
+```
+
+```
+
+### The following scripts are not checked yet, uploaded to setup a baseline:
+```
+maps/mp/zm_tomb.gsc
+maps/mp/zm_tomb_achivement.gsc
+maps/mp/zm_tomb_amb.gsc
+maps/mp/zm_tomb_ambient_scripts.gsc
+maps/mp/zm_tomb_capture_zones.gsc
+maps/mp/zm_tomb_capture_zones_ffotd.gsc
+maps/mp/zm_tomb_challenges.gsc
+maps/mp/zm_tomb_chamber.gsc
+maps/mp/zm_tomb_classic.gsc
+maps/mp/zm_tomb_craftables.gsc
+maps/mp/zm_tomb_dig.gsc
+maps/mp/zm_tomb_distance_tracking.gsc
+maps/mp/zm_tomb_ee_lights.gsc
+maps/mp/zm_tomb_ee_main.gsc
+maps/mp/zm_tomb_ee_main_step_1.gsc
+maps/mp/zm_tomb_ee_main_step_2.gsc
+maps/mp/zm_tomb_ee_main_step_3.gsc
+maps/mp/zm_tomb_ee_main_step_4.gsc
+maps/mp/zm_tomb_ee_main_step_5.gsc
+maps/mp/zm_tomb_ee_main_step_6.gsc
+maps/mp/zm_tomb_ee_main_step_7.gsc
+maps/mp/zm_tomb_ee_main_step_8.gsc
+maps/mp/zm_tomb_ee_side.gsc
+maps/mp/zm_tomb_ffotd.gsc
+maps/mp/zm_tomb_fx.gsc
+maps/mp/zm_tomb_gamemodes.gsc
+maps/mp/zm_tomb_giant_robot.gsc
+maps/mp/zm_tomb_giant_robot_ffotd.gsc
+maps/mp/zm_tomb_main_quest.gsc
+maps/mp/zm_tomb_quest_air.gsc
+maps/mp/zm_tomb_quest_crypt.gsc
+maps/mp/zm_tomb_quest_elec.gsc
+maps/mp/zm_tomb_quest_fire.gsc
+maps/mp/zm_tomb_quest_ice.gsc
+maps/mp/zm_tomb_standard.gsc
+maps/mp/zm_tomb_tank.gsc
+maps/mp/zm_tomb_teleporter.gsc
+maps/mp/zm_tomb_utility.gsc
+maps/mp/zm_tomb_vo.gsc
+maps/mp/gametypes_zm/zstandard.gsc
+maps/mp/zombies/_zm_ai_mechz.gsc
+maps/mp/zombies/_zm_ai_mechz_booster.gsc
+maps/mp/zombies/_zm_ai_mechz_claw.gsc
+maps/mp/zombies/_zm_ai_mechz_dev.gsc
+maps/mp/zombies/_zm_ai_mechz_ffotd.gsc
+maps/mp/zombies/_zm_ai_mechz_ft.gsc
+maps/mp/zombies/_zm_ai_quadrotor.gsc
+maps/mp/zombies/_zm_challenges.gsc
+maps/mp/zombies/_zm_craftables.gsc
+maps/mp/zombies/_zm_magicbox_tomb.gsc
+maps/mp/zombies/_zm_melee_weapon.gsc
+maps/mp/zombies/_zm_perk_divetonuke.gsc
+maps/mp/zombies/_zm_powerup_zombie_blood.gsc
+maps/mp/zombies/_zm_riotshield_tomb.gsc
+maps/mp/zombies/_zm_weap_ballistic_knife.gsc
+maps/mp/zombies/_zm_weap_beacon.gsc
+maps/mp/zombies/_zm_weap_claymore.gsc
+maps/mp/zombies/_zm_weap_one_inch_punch.gsc
+maps/mp/zombies/_zm_weap_riotshield.gsc
+maps/mp/zombies/_zm_weap_staff_air.gsc
+maps/mp/zombies/_zm_weap_staff_fire.gsc
+maps/mp/zombies/_zm_weap_staff_lightning.gsc
+maps/mp/zombies/_zm_weap_staff_revive.gsc
+maps/mp/zombies/_zm_weap_staff_water.gsc
+```
+
 ### notes: