From 32659e87609a89ffcc5388b3ca30f3ddddeb1226 Mon Sep 17 00:00:00 2001
From: Ian <motolegacy.git@gmail.com>
Date: Wed, 29 Dec 2021 14:58:04 -0500
Subject: [PATCH] Update to v1.4.2

---
 README.md                             |    6 +-
 extended_credits.txt                  |    6 +-
 gamedata/audio/zm/zm_al_vox.csv       |   11 +-
 licensed_scripts.txt                  |    1 +
 scripts/zm/_zm.gsc                    |   30 +-
 scripts/zm/_zm_afterlife.csc          |   11 +
 scripts/zm/_zm_afterlife.gsc          |   90 +-
 scripts/zm/_zm_ai_brutus.gsc          |    1 +
 scripts/zm/_zm_magicbox.gsc           |    5 +-
 scripts/zm/_zm_perks.gsc              |    4 +-
 scripts/zm/_zm_powerup_carpenter.csc  |   20 +
 scripts/zm/_zm_powerup_carpenter.gsc  |  448 ++++
 scripts/zm/_zm_powerup_full_ammo.gsc  |   19 +-
 scripts/zm/_zm_spawner.gsc            | 3294 +++++++++++++++++++++++++
 scripts/zm/_zm_weap_blundersplat.cscc |  Bin
 scripts/zm/_zm_weap_blundersplat.gscc |  Bin
 scripts/zm/_zm_weap_blundersplat.gsh  |  102 +-
 scripts/zm/zm_alcatraz_amb.csc        |    2 +-
 scripts/zm/zm_alcatraz_amb.gsc        |  152 +-
 scripts/zm/zm_alcatraz_craftables.csc |    1 +
 scripts/zm/zm_alcatraz_craftables.gsc |  199 +-
 scripts/zm/zm_alcatraz_island.gsc     |   16 +
 scripts/zm/zm_alcatraz_perks.gsc      |   11 +-
 scripts/zm/zm_alcatraz_sq.gsc         |   59 +-
 scripts/zm/zm_alcatraz_sq_nixie.gsc   |   23 +
 scripts/zm/zm_alcatraz_utility.gsc    |  162 +-
 scripts/zm/zm_alcatraz_visions.gsc    |   90 +
 scripts/zm/zm_giant_cleanup_mgr.gsc   |    1 +
 scripts/zm/zm_prison_spoon.gsc        |    9 +-
 scripts/zm/zm_prison_sq_bg.gsc        |    6 +-
 scripts/zm/zm_prison_sq_final.csc     |   31 +
 scripts/zm/zm_prison_sq_final.gsc     |   87 +-
 scripts/zm/zm_prison_traps.gsc        |    4 +-
 scripts/zm/zm_prison_travel.gsc       |   11 +-
 scripts/zm/zm_prison_weap_quest.gsc   |   15 +-
 scripts/zm/zm_usermap.csc             |  189 ++
 scripts/zm/zm_usermap.gsc             |  472 +---
 scripts/zm/zm_weap_tomahawk.gsc       |   12 +-
 zone_source/zm_mod.zone               |   33 +
 39 files changed, 4898 insertions(+), 735 deletions(-)
 create mode 100755 scripts/zm/_zm_powerup_carpenter.csc
 create mode 100755 scripts/zm/_zm_powerup_carpenter.gsc
 create mode 100755 scripts/zm/_zm_spawner.gsc
 mode change 100644 => 100755 scripts/zm/_zm_weap_blundersplat.cscc
 mode change 100644 => 100755 scripts/zm/_zm_weap_blundersplat.gscc
 mode change 100644 => 100755 scripts/zm/_zm_weap_blundersplat.gsh
 create mode 100755 scripts/zm/zm_alcatraz_visions.gsc
 create mode 100755 scripts/zm/zm_prison_sq_final.csc
 create mode 100755 scripts/zm/zm_usermap.csc

diff --git a/README.md b/README.md
index 395fcad..c142c59 100644
--- a/README.md
+++ b/README.md
@@ -1,5 +1,5 @@
 <p align="center"><img src="images/icon.png" width="200"></p> 
-<h2 align="center"><b>Mob of the Dead Remastered Patch 1.3.2</b></h2>
+<h2 align="center"><b>Mob of the Dead Remastered Patch 1.4.2</b></h2>
 <h4 align="center">A Patch for the Mob of the Dead Remastered Workshop Item</h4>
 <hr>
 <p align="center">
@@ -21,7 +21,7 @@
 <hr>
 
 # About
-The following is the source/modtree, excluding raw audio and images, for the Call of Duty: Black Ops III Steam Workshop Item [Mob of the Dead Remastered Patch](https://steamcommunity.com/sharedfiles/filedetails/?id=1725568279), version 1.3.2. The repository will be updated to version 1.4.2 (latest) when possible.
+The following is the source/modtree, excluding raw audio and images, for the Call of Duty: Black Ops III Steam Workshop Item [Mob of the Dead Remastered Patch](https://steamcommunity.com/sharedfiles/filedetails/?id=1725568279), version 1.4.2. This is the last published version.
 
 <hr>
 
@@ -32,7 +32,7 @@ All original source files are licensed under the [MIT License](https://opensourc
 
 # Credits
 
-These are the credits specific to this patch, you can find the credits for the entire project, [Mob of The Dead Remastered](https://steamcommunity.com/workshop/filedetails/?id=1128166280), by clicking [here](extended_credits.txt).
+These are the credits **specific to this patch**, you can find the credits for the entire project, [Mob of The Dead Remastered](https://steamcommunity.com/workshop/filedetails/?id=1128166280), by clicking [here](extended_credits.txt).
 <ul>
     <li>JariKCoding - LUI, Scripting, and General Assistance.</li>
     <li>Scobalula - Greyhound, HydraX, Husky, Attempts to overcome Asset Limits.</li>
diff --git a/extended_credits.txt b/extended_credits.txt
index e15958c..5a3b1dc 100644
--- a/extended_credits.txt
+++ b/extended_credits.txt
@@ -42,4 +42,8 @@ IperBreach
 TitoPricus
 Azsry
 Prorevenge
-The Indestructable Mike Pence
\ No newline at end of file
+The Indestructable Mike Pence
+Easyskanka
+ProGamerzFTW
+TomBMX
+ZombieKid164
\ No newline at end of file
diff --git a/gamedata/audio/zm/zm_al_vox.csv b/gamedata/audio/zm/zm_al_vox.csv
index e03e727..09d631c 100644
--- a/gamedata/audio/zm/zm_al_vox.csv
+++ b/gamedata/audio/zm/zm_al_vox.csv
@@ -4,10 +4,11 @@ general,dog_spawn,spawn_hellhound,,,
 general,ammo_low,ammo_low,,,
 general,ammo_out,ammo_out,,,
 general,box_move,box_move,,,
+general,box_use,box_use,,,
 general,oh_shit,oh_shit,15,TRUE,
 general,revive_down,revive_down,,,
-general,revive_up,revive_thanks,,,
-general,revive_support,revive_support,,,
+general,revive_up,heal_revived,,,
+general,revive_support,revive_player,,,
 general,crawl_hit,crawler_attack,,,
 general,power_on,power_on,100,,
 general,rebuild_boards,rebuild_boards,,,
@@ -65,7 +66,7 @@ powerup,firesale,powerup_firesale,,,
 powerup,minigun,powerup_minigun,,,
 powerup,bonus_points_team,powerup_bonus,,,
 kill,melee,kill_melee,40,,
-kill,melee_instakill,kill_melee,,,
+kill,melee_instakill,kill_insta,,,
 kill,weapon_instakill,kill_insta,10,,
 kill,close,kill_close,15,,
 kill,damage,close_damaged,25,,
@@ -85,6 +86,10 @@ kill,blundergat,kill_blundergat,15,,
 kill,acidgat,kill_acidgat,15,,
 kill,death_machine,kill_death_machine,15,,
 kill,wolf_kill,wolf_kill,100,,
+kill,headshot_respond_to_plr_0,surrounded_respond_to_plr_0,100,,
+kill,headshot_respond_to_plr_1,surrounded_respond_to_plr_1,100,,
+kill,headshot_respond_to_plr_2,surrounded_respond_to_plr_2,100,,
+kill,headshot_respond_to_plr_3,surrounded_respond_to_plr_3,100,,
 weapon_pickup,generic,generic_wall_buy,,,
 weapon_pickup,pistol,generic_wall_buy,,,
 weapon_pickup,smg,generic_wall_buy,,,
diff --git a/licensed_scripts.txt b/licensed_scripts.txt
index 4ab34f6..3cca94f 100644
--- a/licensed_scripts.txt
+++ b/licensed_scripts.txt
@@ -8,6 +8,7 @@ scripts/zm/zm_alcatraz_hud_buildables.gsc
 scripts/zm/zm_alcatraz_island.csc
 scripts/zm/zm_alcatraz_island.gsc
 scripts/zm/zm_alcatraz_perks.gsc
+scripts/zm/zm_alctraz_visions.gsc
 scripts/zm/zm_prison_sq_clickbait.gsc
 scripts/zm/zm_usermap.gsc
 ui/uieditor/widgets/motdr/InventoryItem.lua
diff --git a/scripts/zm/_zm.gsc b/scripts/zm/_zm.gsc
index fbacc0d..09f85f8 100644
--- a/scripts/zm/_zm.gsc
+++ b/scripts/zm/_zm.gsc
@@ -6048,7 +6048,27 @@ function end_game()
 
 	util::clientnotify( "zesn" );
 	
-	level thread zm_audio::sndMusicSystem_PlayState( "game_over" );
+	//level thread zm_audio::sndMusicSystem_PlayState( "game_over" );
+
+	level.eatmelol = false;
+
+	foreach(player in GetPlayers())
+	{
+		if (level.easter_egg_completed == true)
+		{
+			if (level.winner == "weasel")
+				player PlaySoundToPlayer("mus_final_good", player);
+			else
+				player PlaySoundToPlayer("mus_final_bad", player);
+		}
+		else
+		{
+			level.eatmelol = true;
+		}
+	}
+
+	if (level.eatmelol == true)
+		level thread zm_audio::sndMusicSystem_PlayState( "game_over" );
 	
 	//AYERS: Turn off ANY last stand audio at the end of the game
 	players = GetPlayers();
@@ -6125,7 +6145,11 @@ function end_game()
 				game_over[i].alpha = 0;
 				game_over[i].color = ( 1.0, 1.0, 1.0 );
 				game_over[i].hidewheninmenu = true;
-				game_over[i] SetText( &"ZOMBIE_GAME_OVER" );
+
+				if (level.easter_egg_completed == true)
+					game_over[i] SetText("LIFE OVER");
+				else
+					game_over[i] SetText( &"ZOMBIE_GAME_OVER" );
 	
 				game_over[i] FadeOverTime( 1 );
 				game_over[i].alpha = 1;
@@ -6735,6 +6759,8 @@ function player_intermission()
 
 			self notify("player_intermission_spawned");
 			
+			//self MoveTo( point.origin + (0, -100, 0), 20, 20 );
+
 			if ( IsDefined(nextpoint) )
 			{
 				self zm_utility::create_streamer_hint( nextpoint.origin, nextpoint.angles, INTERMISSION_STREAMER_HINT_PRIORITY );
diff --git a/scripts/zm/_zm_afterlife.csc b/scripts/zm/_zm_afterlife.csc
index afaf468..0d84638 100644
--- a/scripts/zm/_zm_afterlife.csc
+++ b/scripts/zm/_zm_afterlife.csc
@@ -6,6 +6,7 @@
 #using scripts\shared\audio_shared;
 #using scripts\shared\util_shared;
 #using scripts\shared\postfx_shared;
+#using scripts\zm\zm_prison_sq_final;
 
 #using scripts\zm\_filter;
 
@@ -94,6 +95,7 @@ function toggle_player_afterlife( localclientnum, oldval, newval, bnewent, binit
 		//self thread afterlife_mana_rumble();
 		self thread afterlife_damage_fx();
 		self thread sndafterlifeleak( localclientnum );
+		self thread afterlife_ambientroom( localclientnum );
 	}
 	else
 	{
@@ -104,6 +106,15 @@ function toggle_player_afterlife( localclientnum, oldval, newval, bnewent, binit
 	}
 }
 
+function afterlife_ambientroom(localclientnum)
+{
+	self endon( "disconnect" );
+	level waittill( "al_e", localclientnum);
+	ForceAmbientRoom("sndHealth_LowHealth");
+	level waittill( "al_l", localclientnum);
+	ForceAmbientRoom("");
+}
+
 function afterlife_damage_fx()
 {
 	self endon( "disconnect" );
diff --git a/scripts/zm/_zm_afterlife.gsc b/scripts/zm/_zm_afterlife.gsc
index 9f99c56..03fb9be 100644
--- a/scripts/zm/_zm_afterlife.gsc
+++ b/scripts/zm/_zm_afterlife.gsc
@@ -9,10 +9,12 @@
 #using scripts\shared\laststand_shared;
 #using scripts\shared\math_shared;
 #using scripts\shared\scene_shared;
+#using scripts\shared\system_shared;
 #using scripts\shared\util_shared;
 #using scripts\shared\lui_shared;
 #using scripts\shared\spawner_shared;
 #using scripts\shared\hud_util_shared;
+#using scripts\shared\weapons\_weaponobjects;
 
 #using scripts\shared\visionset_mgr_shared;
 
@@ -32,6 +34,8 @@
 #using scripts\zm\_zm_powerups;
 #using scripts\zm\gametypes\_zm_gametype;
 #using scripts\shared\ai\zombie_utility;
+#using scripts\zm\_util;
+#using scripts\zm\_zm_weap_riotshield;
 
 #using scripts\zm\_zm_perk_electric_cherry;
 #using scripts\zm\zk_buyable_elevator_v2;
@@ -50,10 +54,12 @@
 
 //#using scripts\zm\_zm_ai_brutus;
 
+#insert scripts\zm\_zm_buildables.gsh;
 #insert scripts\shared\version.gsh;
 #insert scripts\shared\shared.gsh;
 #insert scripts\zm\_zm_utility.gsh;
 #insert scripts\zm\_zm_perks.gsh;
+#insert scripts\shared\archetype_shared\archetype_shared.gsh;
 
 #precache( "material", "afterlife_logo" );
 #precache( "material", "afterlife_logo_waypoint" );
@@ -91,6 +97,7 @@ function give_afterlife() {
     foreach(player in GetPlayers()) {
         if ( isdefined( player.afterlife ) && !player.afterlife ) {
             player thread fake_kill_player( n_start_pos );
+			player util::clientnotify( "al_e" );
             n_start_pos++;
         }
     }
@@ -485,7 +492,7 @@ function afterlife_player_damage_callback( einflictor, eattacker, idamage, idfla
 
 	if ( smeansofdeath != "MOD_PROJECTILE" && smeansofdeath != "MOD_PROJECTILE_SPLASH" || smeansofdeath == "MOD_GRENADE" && smeansofdeath == "MOD_GRENADE_SPLASH" )
 	{
-		if ( sweapon == GetWeapon("shotgun_acidgat_bullet") )
+		if ( sweapon == GetWeapon("bo2_acidgat_bullet") )
 		{
 			if ( self HasPerk( "specialty_flakjacket" ) )
 			{
@@ -550,6 +557,7 @@ function afterlife_enter()
 		//visionset_mgr::activate( "overlay", "afterlife_filter", self );
 		self.afterlife_visionset = 1;
 	}
+	self util::clientnotify( "al_e" );
 	self FreezeControls( 0 );
 	self thread zm_player_fake_death_cleanup();
 	self thread af_make_waypoint();
@@ -603,6 +611,7 @@ function afterlife_leave( b_revived )
 		self.progressBar Destroy();
 		self.progressText Destroy();
 	}
+	self util::clientnotify( "al_l" );
 	self.dontspeak = 0;
 	self.ghost_fx_link Delete();
 	self thread afterlife_doors_close();
@@ -671,6 +680,7 @@ function afterlife_leave( b_revived )
 	reset_all_afterlife_unitriggers();
 	wait 1;
 	self.ignoreme = 0;
+	wait 3;
 	self DisableInvulnerability();
 }
 
@@ -742,7 +752,16 @@ function afterlife_laststand( b_electric_chair, neworigin )
 		self util::clientnotify( "al_t" );
 		wait 1;
 		self thread lui::screen_flash( 0.5, 1, 0.5, 1, "white" );
+		//self AllowStand(1);
+		//self AllowCrouch(1);
+		//wait 0.1;
+		//self SetStance("stand");
 		wait 0.5;
+		self PlaySoundToPlayer( "zmb_afterlife_start", self );
+		self FreezeControls( 0 );
+		self SetStance("stand");
+		wait 0.1;
+		self FreezeControls( 1 );
 	}
 	self Ghost();
 	self.e_afterlife_corpse = self afterlife_spawn_corpse( neworigin );
@@ -752,6 +771,7 @@ function afterlife_laststand( b_electric_chair, neworigin )
 	self afterlife_enter();
 	self.e_afterlife_corpse clientfield::set( "player_corpse_id", self GetEntityNumber() + 1 );
 	wait 0.5;
+	//self SetStance("stand");
 	self Show();
 	self FreezeControls( 0 );
 	self DisableInvulnerability();
@@ -765,6 +785,7 @@ function afterlife_laststand( b_electric_chair, neworigin )
 	self.afterlife_revived = 1;
 	self EnableWeapons();
 	PlaySoundAtPosition( "zmb_afterlife_spawn_leave", self.e_afterlife_corpse.origin );
+	self PlaySound( "zmb_afterlife_end" );
 	self thread afterlife_revive_invincible();
 	self afterlife_leave();
 	self PlaySound( "zmb_afterlife_revived_gasp" );
@@ -998,6 +1019,16 @@ function afterlife_spawn_corpse( neworigin )
 	{
 		neworigin = self.origin;
 	}
+
+	// drop corpse origin to floor (in case of jump)
+	trace = bullettrace( neworigin, neworigin + (0,0,-256), false, undefined );
+	ground_pos = trace["position"];
+	if( isdefined(ground_pos) )
+	{
+		neworigin = ( neworigin[0], neworigin[1], ground_pos[2] );
+	}
+
+
 	if ( isdefined( self.is_on_gondola ) && self.is_on_gondola && level.e_gondola.destination == "roof" )
 	{
 		corpse = zm_alcatraz_sq::spawn_player_clone( self, neworigin, undefined );
@@ -1547,6 +1578,14 @@ function afterlife_save_loadout()
 		}
 		index = GetNextArrayKey( _a1516, index );
 	}
+	if (IS_TRUE(self.hasriotshield))
+	{
+		shield_health = self DamageRiotShield(0);
+		shield_damage = level.weaponRiotshield.weaponstarthitpoints - shield_health;
+
+		self.loadout.shielddamage = shield_damage;
+		//IPrintLnBold("dmg: " + self.loadout.shielddamage);
+	}
 	self.loadout.equipment = self zm_equipment::get_player_equipment();
 	if ( isdefined( self.loadout.equipment ) )
 	{
@@ -1567,6 +1606,14 @@ function afterlife_save_loadout()
 		self.loadout.hastomahawk = 1;
 		self clientfield::set_to_player( "tomahawk_in_use", 0 );
 	}
+	if ( self HasWeapon( GetWeapon("spoon_alcatraz") ) )
+	{
+		self.loadout.hasspoon = 1;
+	}
+	if ( self HasWeapon( GetWeapon("spork_alcatraz") ) )
+	{
+		self.loadout.hasspork = 1;
+	}
 	self.loadout.perks = afterlife_save_perks( self );
 	lethal_grenade = self zm_utility::get_player_lethal_grenade();
 	if ( self HasWeapon( lethal_grenade ) )
@@ -1662,6 +1709,23 @@ function afterlife_give_loadout()
 		self zm_utility::set_player_tactical_grenade( GetWeapon(self.current_tomahawk_weapon) );
 		self clientfield::set_to_player( "tomahawk_in_use", 1 );
 	}
+	if ( isdefined( loadout.hasspoon ) && loadout.hasspoon )
+	{
+		self TakeWeapon( self zm_utility::get_player_melee_weapon() );
+		self GiveWeapon( GetWeapon("spoon_alcatraz") );
+	}
+	if ( isdefined( loadout.hasspork ) && loadout.hasspork )
+	{
+		self TakeWeapon( self zm_utility::get_player_melee_weapon() );
+		self GiveWeapon( GetWeapon("spork_alcatraz") );
+	}
+	if (isdefined( loadout.shielddamage ) && loadout.shielddamage)
+	{
+		// restore shield health
+		//IPrintLnBold("damaging shield: " + loadout.shielddamage);
+		self DamageRiotShield(loadout.shielddamage);
+		self riotshield::player_set_shield_health(loadout.shielddamage, 1500);
+	}
 	self.score = loadout.score;
 	perk_array = self zm_perks::get_perk_array();
 	i = 0;
@@ -1717,18 +1781,22 @@ function afterlife_fake_death()
 	level notify( "fake_death" );
 	self notify( "fake_death" );
 	self TakeAllWeapons();
-	self AllowStand( 0 );
+	/*self AllowStand( 0 );
 	self AllowCrouch( 0 );
-	self AllowProne( 1 );
+	self AllowProne( 1 );*/
+	wait 0.1;
 	self SetStance( "prone" );
+	wait 0.1;
+	self FreezeControls( 1 );
+	SetDvar("cg_drawgun", 0);
 	while ( self zm_utility::is_jumping() )
 	{
 		wait 0.05;
 	}
 	PlayFX( level._effect[ "afterlife_enter" ], self.origin );
+	self PlaySoundToPlayer( "zmb_afterlife_death", self );
 	self.ignoreme = 1;
 	self EnableInvulnerability();
-	self FreezeControls( 1 );
 }
 
 function afterlife_fake_revive()
@@ -1748,13 +1816,14 @@ function afterlife_fake_revive()
 	{
 		PlaySoundAtPosition( "zmb_afterlife_spawn_enter", self.origin );
 	}
-	self AllowStand( 1 );
 	self AllowCrouch( 0 );
 	self AllowProne( 0 );
 	self AllowSlide( 0 );
 	self GiveWeapon( GetWeapon("lightning_hands") );
 	self SwitchToWeapon( GetWeapon("lightning_hands") );
+	self SetStance("stand");
 	self zm_score::minus_to_player_score(self.score);
+	SetDvar("cg_drawgun", 1);
 	wait 1;
 	self.ignoreme = 0;
 }
@@ -1881,7 +1950,7 @@ function afterlife_trigger_create( s_origin )
 	s_origin.unitrigger_stub.radius = 36;
 	s_origin.unitrigger_stub.height = 256;
 	s_origin.unitrigger_stub.script_unitrigger_type = "unitrigger_radius_use";
-	s_origin.unitrigger_stub.hint_string = "Press ^3&&1^7 to enter afterlife";
+	s_origin.unitrigger_stub.hint_string = "Press ^3&&1^7 to enter Afterlife";
 	s_origin.unitrigger_stub.cursor_hint = "HINT_NOICON";
 	s_origin.unitrigger_stub.require_look_at = 1;
 	s_origin.unitrigger_stub.prompt_and_visibility_func = &afterlife_trigger_visibility;
@@ -1909,11 +1978,11 @@ function afterlife_trigger_visibility( player )
 	self SetInvisibleToPlayer( player, b_is_invis );
 	if ( player.af_lives <= 0 )
 	{
-		self SetHintString( "No afterlife remaining" );
+		self SetHintString( "No Afterlife Remaining" );
 	}
 	else
 	{
-		self SetHintString( "Press ^3&&1^7 to enter afterlife" );
+		self SetHintString( "Press ^3&&1^7 to enter Afterlife" );
 		if ( !isdefined( player.has_played_afterlife_trigger_hint ) && player zm_utility::is_player_looking_at( self.stub.origin, 0.25 ) )
 		{
 			if ( isdefined( player.dontspeak ) && !player.dontspeak )
@@ -1961,7 +2030,7 @@ function afterlife_trigger_think()
 			PlayFXOnTag( level._effect[ "afterlife_kill_point_fx" ], e_fx, "tag_origin" );
 			wait 2;
 			e_fx Delete();
-			self SetHintString( "Press ^3&&1^7 to enter afterlife" );
+			self SetHintString( "Press ^3&&1^7 to enter Afterlife" );
 		}
 	}
 }
@@ -2427,7 +2496,8 @@ function zm_player_fake_death( vdir )
 		self AllowProne( 1 );
 		self AllowCrouch( 0 );
 		self AllowStand( 0 );
-		self SetStance("prone");
+		wait 0.1;
+		//self SetStance("prone");
 		wait 0.25;
 		self FreezeControls( 1 );
 	}
diff --git a/scripts/zm/_zm_ai_brutus.gsc b/scripts/zm/_zm_ai_brutus.gsc
index 6c1fd1f..3b386b0 100644
--- a/scripts/zm/_zm_ai_brutus.gsc
+++ b/scripts/zm/_zm_ai_brutus.gsc
@@ -322,6 +322,7 @@ function magicboxLock() {
 		return;
 	magic_box.zbarrier _zm_magicbox_prison::set_magic_box_zbarrier_state( "locking" );
 	self PlaySound( "zmb_brutus_clang" );
+	self thread sndBrutusVox( "zmb_vocals_brutus_lockbox" );
     self.priority_item.is_locked = true;
 	magic_box.locked_cost = getScalingLockCost( "magic_box", magic_box );
 	level.lockdown_track[ "magic_box" ] = 1;
diff --git a/scripts/zm/_zm_magicbox.gsc b/scripts/zm/_zm_magicbox.gsc
index e244e24..e4e0ba6 100644
--- a/scripts/zm/_zm_magicbox.gsc
+++ b/scripts/zm/_zm_magicbox.gsc
@@ -675,10 +675,11 @@ function treasure_chest_think()
 	user zm_stats::increment_challenge_stat( "SURVIVALIST_BUY_MAGIC_BOX" );
 	user zm_daily_challenges::increment_magic_box();
 	
-	if ( isDefined( level._magic_box_used_VO ) )
+	/*if ( isDefined( level._magic_box_used_VO ) )
 	{
 		user thread [[ level._magic_box_used_VO ]]();
-	}
+	}*/
+	user zm_utility::do_player_general_vox( "general", "box_use", undefined, 100 );
 	
 	self thread watch_for_emp_close();
 	if ( isDefined( level.using_locked_magicbox ) && level.using_locked_magicbox )
diff --git a/scripts/zm/_zm_perks.gsc b/scripts/zm/_zm_perks.gsc
index 6794eb0..968a552 100644
--- a/scripts/zm/_zm_perks.gsc
+++ b/scripts/zm/_zm_perks.gsc
@@ -266,9 +266,9 @@ function play_loop_on_machine()
 {
 	if( isdefined( level.sndPerksacolaLoopOverride ) )
 		return;
-	
+
 	sound_ent = spawn( "script_origin", self.origin );
-	sound_ent playloopsound("zmb_perks_machine_loop");
+	sound_ent playloopsound("perksacola_loop2");
 	sound_ent LinkTo( self );
 	self waittill( "stop_loopsound" );
 	sound_ent UnLink();
diff --git a/scripts/zm/_zm_powerup_carpenter.csc b/scripts/zm/_zm_powerup_carpenter.csc
new file mode 100755
index 0000000..aa07abc
--- /dev/null
+++ b/scripts/zm/_zm_powerup_carpenter.csc
@@ -0,0 +1,20 @@
+#using scripts\codescripts\struct;
+
+#using scripts\shared\system_shared;
+
+#insert scripts\shared\shared.gsh;
+
+#using scripts\zm\_zm_powerups;
+
+#insert scripts\zm\_zm_powerups.gsh;
+#insert scripts\zm\_zm_utility.gsh;
+
+#namespace zm_powerup_carpenter;
+
+REGISTER_SYSTEM( "zm_powerup_carpenter", &__init__, undefined )
+	
+function __init__()
+{
+	zm_powerups::include_zombie_powerup( "carpenter" );
+	zm_powerups::add_zombie_powerup( "carpenter" );
+}
diff --git a/scripts/zm/_zm_powerup_carpenter.gsc b/scripts/zm/_zm_powerup_carpenter.gsc
new file mode 100755
index 0000000..81d28ac
--- /dev/null
+++ b/scripts/zm/_zm_powerup_carpenter.gsc
@@ -0,0 +1,448 @@
+#using scripts\codescripts\struct;
+
+#using scripts\shared\clientfield_shared;
+#using scripts\shared\system_shared;
+#using scripts\shared\util_shared;
+
+#insert scripts\shared\shared.gsh;
+#insert scripts\shared\version.gsh;
+
+#using scripts\shared\ai\zombie_death;
+
+#using scripts\zm\_zm_blockers;
+#using scripts\zm\_zm_pers_upgrades;
+#using scripts\zm\_zm_pers_upgrades_functions;
+#using scripts\zm\_zm_powerups;
+#using scripts\zm\_zm_score;
+#using scripts\zm\_zm_spawner;
+#using scripts\zm\_zm_utility;
+#using scripts\zm\_zm_weap_riotshield;
+
+#insert scripts\zm\_zm_powerups.gsh;
+#insert scripts\zm\_zm_utility.gsh;
+
+#define BOARD_REPAIR_DISTANCE_SQUARED	750 * 750
+
+#precache( "string", "ZOMBIE_POWERUP_MAX_AMMO" );
+
+#namespace zm_powerup_carpenter;
+
+REGISTER_SYSTEM( "zm_powerup_carpenter", &__init__, undefined )
+
+//-----------------------------------------------------------------------------------
+// setup
+//-----------------------------------------------------------------------------------
+function __init__()
+{
+	zm_powerups::register_powerup( "carpenter", &grab_carpenter );
+	if( ToLower( GetDvarString( "g_gametype" ) ) != "zcleansed" )
+	{
+		zm_powerups::add_zombie_powerup( "carpenter", "p7_zm_power_up_carpenter", &"ZOMBIE_POWERUP_MAX_AMMO", &func_should_drop_carpenter, !POWERUP_ONLY_AFFECTS_GRABBER, !POWERUP_ANY_TEAM, !POWERUP_ZOMBIE_GRABBABLE );
+	}
+	
+	level.use_new_carpenter_func = &start_carpenter_new;
+}
+
+function grab_carpenter( player )
+{	
+	// Check for the carpenter persistent upgrade
+	if( zm_utility::is_Classic() )
+	{
+		player thread zm_pers_upgrades::persistent_carpenter_ability_check();
+	}
+	if( isDefined(level.use_new_carpenter_func) )
+	{
+		level thread [[level.use_new_carpenter_func]](self.origin);
+	}
+	else
+	{
+		level thread start_carpenter( self.origin );
+	}
+	player thread zm_powerups::powerup_vo( "carpenter" );
+}
+
+function start_carpenter( origin )
+{
+	window_boards = struct::get_array( "exterior_goal", "targetname" ); 
+	total = level.exterior_goals.size;
+	
+	//COLLIN
+	carp_ent = spawn("script_origin", (0,0,0));
+	carp_ent playloopsound( "evt_carpenter" );
+	
+	while(true)
+	{
+		windows = get_closest_window_repair(window_boards, origin);
+		if( !IsDefined( windows ) )
+		{
+			carp_ent stoploopsound( 1 );
+			carp_ent PlaySoundWithNotify( "evt_carpenter_end", "sound_done" );
+			carp_ent waittill( "sound_done" );
+			break;
+		}		
+		else
+		{
+			ArrayRemoveValue(window_boards, windows);
+		}
+
+
+		while( 1 )
+		{
+			if( zm_utility::all_chunks_intact( windows, windows.barrier_chunks ) )
+			{
+				break;
+			}
+
+			chunk = zm_utility::get_random_destroyed_chunk( windows, windows.barrier_chunks );
+
+			if( !IsDefined( chunk ) )
+			{
+				break;
+			}
+
+			windows thread zm_blockers::replace_chunk( windows, chunk, undefined, zm_powerups::is_carpenter_boards_upgraded(), true );
+			
+			if(isdefined(windows.clip))
+			{
+				windows.clip TriggerEnable( true );
+				windows.clip DisconnectPaths();
+			}
+			else
+			{
+				zm_blockers::blocker_disconnect_paths(windows.neg_start, windows.neg_end);
+			}
+			util::wait_network_frame();
+			WAIT_SERVER_FRAME;
+		}
+		 
+		util::wait_network_frame();
+	}
+	
+	players = GetPlayers();
+	for(i = 0; i < players.size; i++)
+	{
+		players[i] zm_score::player_add_points( "carpenter_powerup", 200 );
+
+		// refill shield health
+		if (players[i] HasWeapon(level.weaponRiotshield)) 
+		{
+			// get current shield health
+			shield_health = players[i] DamageRiotShield(0);
+			shield_health_to_max = level.weaponRiotshield.weaponstarthitpoints - shield_health;
+
+			// negative dmg to shield
+			players[i] DamageRiotShield(-shield_health_to_max);
+			players[i] riotshield::player_set_shield_health(1500, 1500);
+		}
+	}
+	
+	carp_ent delete();	
+}
+
+function get_closest_window_repair( windows, origin )
+{
+	current_window = undefined;
+	shortest_distance = undefined;
+	for( i = 0; i < windows.size; i++ )
+	{
+		if( zm_utility::all_chunks_intact(windows, windows[i].barrier_chunks ) )
+		{
+			continue;
+		}
+
+		if( !IsDefined( current_window ) )	
+		{
+			current_window = windows[i];
+			shortest_distance = DistanceSquared( current_window.origin, origin );			
+		}
+		else
+		{
+			if( DistanceSquared(windows[i].origin, origin) < shortest_distance )
+			{
+
+				current_window = windows[i];
+				shortest_distance =  DistanceSquared( windows[i].origin, origin );
+			}
+		}
+	}
+
+	return current_window;
+}
+
+function start_carpenter_new( origin )
+{
+	level.carpenter_powerup_active = true;
+
+	window_boards = struct::get_array( "exterior_goal", "targetname" ); 
+	
+	if(isdefined(level._additional_carpenter_nodes))
+	{
+		window_boards = ArrayCombine(window_boards, level._additional_carpenter_nodes, false, false);
+	}
+	
+	//COLLIN
+	carp_ent = spawn("script_origin", (0,0,0));
+	carp_ent playloopsound( "evt_carpenter" );	
+	
+	boards_near_players = get_near_boards(window_boards);
+	boards_far_from_players = get_far_boards(window_boards);	
+	
+	//instantly repair all 'far' boards
+	level repair_far_boards( boards_far_from_players, zm_powerups::is_carpenter_boards_upgraded() );
+
+	for(i=0;i<boards_near_players.size;i++)
+	{
+		window = boards_near_players[i];
+		
+		num_chunks_checked = 0;
+		
+		last_repaired_chunk = undefined;
+		
+		while( 1 )
+		{
+			if( zm_utility::all_chunks_intact( window, window.barrier_chunks ) )
+			{
+				break;
+			}
+
+			chunk = zm_utility::get_random_destroyed_chunk( window, window.barrier_chunks ); 
+
+			if( !IsDefined( chunk ) )
+				break;
+
+			window thread zm_blockers::replace_chunk( window, chunk, undefined, zm_powerups::is_carpenter_boards_upgraded(), true );
+			
+			last_repaired_chunk = chunk;
+			
+			if(IsDefined(window.clip))
+			{
+				window.clip TriggerEnable( true ); 
+				window.clip DisconnectPaths();
+			}
+			else
+			{
+				zm_blockers::blocker_disconnect_paths(window.neg_start, window.neg_end);
+			}
+			
+			util::wait_network_frame();
+			
+			num_chunks_checked++;
+			
+			if(num_chunks_checked >= 20)
+			{
+				break;	// Avoid staying in this while loop forever....
+			}
+		}
+		
+		//wait for the last window board to be repaired
+		
+		if(isdefined(window.zbarrier))
+		{
+			if(isdefined(last_repaired_chunk))
+			{
+				while(window.zbarrier GetZBarrierPieceState(last_repaired_chunk) == "closing")
+				{
+					WAIT_SERVER_FRAME;
+				}
+				
+				if(isdefined(window._post_carpenter_callback))
+				{
+					window [[window._post_carpenter_callback]]();
+				}
+			}
+		}
+		else
+		{
+			while((IsDefined(last_repaired_chunk)) && (last_repaired_chunk.state == "mid_repair"))
+			{
+				wait(.05);
+			}
+		}
+	}
+	
+	carp_ent stoploopsound( 1 );
+	carp_ent PlaySoundWithNotify( "evt_carpenter_end", "sound_done" );
+	carp_ent waittill( "sound_done" );
+
+	players = GetPlayers();
+	for(i = 0; i < players.size; i++)
+	{
+		players[i] zm_score::player_add_points( "carpenter_powerup", 200 ); 
+	}
+
+	carp_ent delete();
+
+	level notify( "carpenter_finished" );
+	level.carpenter_powerup_active = undefined;
+}
+
+function get_near_boards(windows)
+{
+	// get all boards that are farther than 500 units away from any player and put them into a list
+	players = GetPlayers();
+	boards_near_players = [];
+	
+	for(j =0;j<windows.size;j++)
+	{
+		close = false;
+		for(i=0;i<players.size;i++)
+		{
+			origin = undefined;
+			
+			if(isdefined(windows[j].zbarrier))
+			{
+				origin = windows[j].zbarrier.origin;
+			}
+			else
+			{
+				origin = windows[j].origin;
+			}
+			
+			if( distancesquared(players[i].origin, origin) <= BOARD_REPAIR_DISTANCE_SQUARED  )
+			{
+				close = true;
+				break;
+			}
+		}
+		if(close)
+		{
+			boards_near_players[boards_near_players.size] = windows[j];
+		}			
+	}
+	return boards_near_players;
+}
+
+function get_far_boards(windows)
+{
+	// get all boards that are farther than 500 units away from any player and put them into a list
+	players = GetPlayers();
+	boards_far_from_players = [];
+	
+	for(j =0;j<windows.size;j++)
+	{
+		close = false;
+		for(i=0;i<players.size;i++)
+		{
+			
+			origin = undefined;
+			
+			if(isdefined(windows[j].zbarrier))
+			{
+				origin = windows[j].zbarrier.origin;
+			}
+			else
+			{
+				origin = windows[j].origin;
+			}			
+			
+			if( distancesquared(players[i].origin, origin) >= BOARD_REPAIR_DISTANCE_SQUARED  )
+			{
+				close = true;
+				break;
+			}
+		}
+		
+		if(close)
+		{
+			boards_far_from_players[boards_far_from_players.size] = windows[j];
+		}			
+	}
+	return boards_far_from_players;
+}
+
+function repair_far_boards( barriers, upgrade )
+{
+	for(i=0;i<barriers.size;i++)
+	{
+		barrier = barriers[i];
+		if( zm_utility::all_chunks_intact( barrier, barrier.barrier_chunks ) )
+		{
+			continue;
+		}
+
+		if(isdefined(barrier.zbarrier))
+		{
+			a_pieces = barrier.zbarrier GetZBarrierPieceIndicesInState( "open" );
+			if( IsDefined(a_pieces) )
+			{
+				for( xx=0; xx<a_pieces.size; xx++ )
+				{
+					chunk = a_pieces[ xx ];
+
+					if(upgrade)
+					{
+						barrier.zbarrier ZBarrierPieceUseUpgradedModel(chunk);
+						barrier.zbarrier.chunk_health[chunk] = barrier.zbarrier GetUpgradedPieceNumLives(chunk);
+					}
+					else
+					{
+						barrier.zbarrier ZBarrierPieceUseDefaultModel(chunk);
+						barrier.zbarrier.chunk_health[chunk] = 0;
+					}
+				}
+			}
+
+			for(x = 0; x < barrier.zbarrier GetNumZBarrierPieces(); x ++)
+			{
+				barrier.zbarrier SetZBarrierPieceState(x, "closed");
+				barrier.zbarrier ShowZBarrierPiece(x);
+			}
+		}
+		
+		if(IsDefined(barrier.clip))
+		{
+			barrier.clip TriggerEnable( true ); 
+			barrier.clip DisconnectPaths();
+		}
+		else
+		{
+			zm_blockers::blocker_disconnect_paths(barrier.neg_start, barrier.neg_end);
+		}			
+		
+		if((i % 4) == 0)
+		{
+			util::wait_network_frame();
+		}		
+	}
+}
+
+function func_should_drop_carpenter()
+{
+	if(get_num_window_destroyed() < 5 )
+	{
+		return false;
+	}
+	return true;
+}
+
+function get_num_window_destroyed()
+{
+	num = 0;
+	for( i = 0; i < level.exterior_goals.size; i++ )
+	{
+		/*targets = getentarray(level.exterior_goals[i].target, "targetname");
+
+		barrier_chunks = []; 
+		for( j = 0; j < targets.size; j++ )
+		{
+			if( IsDefined( targets[j].script_noteworthy ) )
+			{
+				if( targets[j].script_noteworthy == "clip" )
+				{ 
+					continue; 
+				}
+			}
+
+			barrier_chunks[barrier_chunks.size] = targets[j];
+		}*/
+
+
+		if( zm_utility::all_chunks_destroyed( level.exterior_goals[i], level.exterior_goals[i].barrier_chunks ) )
+		{
+			num += 1;
+		}
+
+	}
+
+	return num;
+}
diff --git a/scripts/zm/_zm_powerup_full_ammo.gsc b/scripts/zm/_zm_powerup_full_ammo.gsc
index 087cf24..f25f866 100644
--- a/scripts/zm/_zm_powerup_full_ammo.gsc
+++ b/scripts/zm/_zm_powerup_full_ammo.gsc
@@ -16,6 +16,7 @@
 #using scripts\zm\_zm_powerups;
 #using scripts\zm\_zm_score;
 #using scripts\zm\_zm_spawner;
+#using scripts\zm\_zm_weapons;
 #using scripts\zm\_zm_utility;
 
 #insert scripts\zm\_zm_powerups.gsh;
@@ -109,20 +110,20 @@ function full_ammo_powerup( drop_item , player)
 			}
 
 			// Give ammo to players in Afterlife
-			/*if ( players[i].afterlife ) {
+			if ( players[i].afterlife ) {
+				//IPrintLnBold("in al");
 				loadout = players[i].loadout;
 
-				for (i = 0; i < loadout.weapons.size; i++) {
-					
-					weapon = loadout.weapons[i];
-					loadout.weapons.stockcount[i] = weapon.maxammo;
-
-					//players[i] GiveMaxAmmo( GetWeapon(weapon) );
+				i = 0;
+				while ( i < loadout.weapons.size )
+				{
+					// this is kinda shitty, but just set the stock ammo to 999, this will automatically adjust
+					loadout.stockcount[i] = 999;
+					i++;
 				}
-				//IPrintLnBold("in Afterlife");
 
 				players[i].loadout = loadout;
-			}*/
+			}
 			
 
 			if ( players[i] HasWeapon( primary_weapons[x] ) )
diff --git a/scripts/zm/_zm_spawner.gsc b/scripts/zm/_zm_spawner.gsc
new file mode 100755
index 0000000..f7ed88e
--- /dev/null
+++ b/scripts/zm/_zm_spawner.gsc
@@ -0,0 +1,3294 @@
+#using scripts\codescripts\struct;
+
+#using scripts\shared\array_shared;
+#using scripts\shared\clientfield_shared;
+#using scripts\shared\demo_shared;
+#using scripts\shared\flag_shared;
+#using scripts\shared\laststand_shared;
+#using scripts\shared\util_shared;
+
+#using scripts\shared\ai\zombie_death;
+#using scripts\shared\ai\zombie_shared;
+#using scripts\shared\ai\systems\gib;
+#using scripts\shared\ai\zombie_utility;
+
+#using scripts\zm\_util;
+#using scripts\zm\_zm;
+#using scripts\zm\_zm_audio;
+#using scripts\zm\_zm_behavior;
+#using scripts\zm\_zm_behavior_utility;
+#using scripts\zm\_zm_blockers;
+#using scripts\zm\_zm_bgb;
+#using scripts\zm\_zm_equipment;
+#using scripts\zm\_zm_laststand;
+#using scripts\zm\_zm_net;
+#using scripts\zm\_zm_pers_upgrades;
+#using scripts\zm\_zm_pers_upgrades_functions;
+#using scripts\zm\_zm_powerups;
+#using scripts\zm\_zm_puppet;
+#using scripts\zm\_zm_score;
+#using scripts\zm\_zm_stats;
+#using scripts\zm\_zm_utility;
+#using scripts\zm\_zm_weapons;
+
+#insert scripts\shared\shared.gsh;
+#insert scripts\shared\version.gsh;
+#insert scripts\shared\ai\zombie.gsh;
+#insert scripts\shared\ai\systems\gib.gsh;
+#insert scripts\zm\_zm.gsh;
+#insert scripts\zm\_zm_perks.gsh;
+
+#namespace zm_spawner;
+
+function init()
+{
+	level._CONTEXTUAL_GRAB_LERP_TIME = .3; // This is the time it takes to move into position for each bar.
+
+	level.zombie_spawners = GetEntArray( "zombie_spawner", "script_noteworthy" );
+	
+	// This will be an array of archetypes and the saved health of any entities cleaned up so that replacements can have the same health.
+	// We don't want people exploiting cleaned up zombies as a way to generate extra points by continually shooting fresh enemies.
+	level.a_zombie_respawn_health = [];	
+
+	// added functionality to respawn elemental type zombies cleaned up.
+	level.a_zombie_respawn_type = [];	
+
+	if(IS_TRUE(level.use_multiple_spawns))
+	{
+		level.zombie_spawn = [];
+		for ( i = 0; i < level.zombie_spawners.size; i++ )
+		{
+			if(IsDefined(level.zombie_spawners[i].script_int))
+			{
+				int = level.zombie_spawners[i].script_int;
+				if ( !IsDefined( level.zombie_spawn[int] ))
+				{
+					level.zombie_spawn[int] = [];
+				}
+				level.zombie_spawn[int][level.zombie_spawn[int].size] = level.zombie_spawners[i];
+			}
+		}
+	}
+	
+	if ( IsDefined( level.ignore_spawner_func ) )
+	{
+		for ( i = 0; i < level.zombie_spawners.size; i++ )
+		{
+			ignore = [[ level.ignore_spawner_func ]]( level.zombie_spawners[i] );
+			if ( ignore )
+			{
+				ArrayRemoveValue(level.zombie_spawners, level.zombie_spawners[i]);
+			}
+		}	
+	}
+ 	
+ 	if ( !IsDefined( level.attack_player_thru_boards_range ) )
+ 	{
+ 		level.attack_player_thru_boards_range = 109.8;
+ 	}
+ 	
+ 	if(isdefined(level._game_module_custom_spawn_init_func))
+ 	{
+ 		[[level._game_module_custom_spawn_init_func]]();
+ 	}
+}
+
+function player_attacks_enemy( player, amount, type, point, weapon, direction_vec, tagName, modelName, partName, dFlags, inflictor, chargeLevel )
+{
+	team = undefined;
+	if(isDefined(self._race_team))
+	{
+		team = self._race_team;
+	}
+	
+	if ( IS_TRUE( player.allow_zombie_to_target_ai) || !player util::is_ads() )
+	{
+		// defaults to empty_kill_func, for arcademode
+		[[ level.global_damage_func ]]( type, self.damagelocation, point, player, amount, team, weapon, direction_vec, tagName, modelName, partName, dFlags, inflictor, chargeLevel );
+		return false;
+	}
+		
+	if ( !zm_utility::bullet_attack( type ) )
+	{
+		// defaults to empty_kill_func, for arcademode
+		[[ level.global_damage_func ]]( type, self.damagelocation, point, player, amount, team, weapon, direction_vec, tagName, modelName, partName, dFlags, inflictor, chargeLevel );
+		return false;
+	}
+
+	// defaults to empty_kill_func, for arcademode
+	[[ level.global_damage_func_ads ]]( type, self.damagelocation, point, player, amount, team, weapon, direction_vec, tagName, modelName, partName, dFlags, inflictor, chargeLevel );
+		
+	return true;
+}
+
+
+function player_attacker( attacker )
+{
+	if ( IsPlayer(attacker) )
+	{
+		return true;
+	}
+	return false;
+}
+
+function enemy_death_detection()
+{
+	self endon ("death");
+	
+	for ( ;; )
+	{
+		self waittill( "damage", amount, attacker, direction_vec, point, type, tagName, modelName, partName, weapon, dFlags, inflictor, chargeLevel );
+		
+		if ( !isDefined(amount) )
+		{
+			continue;
+		}
+
+		if ( !isalive( self ) )
+		{
+			return;
+		}
+		
+		if ( !player_attacker( attacker ) && !IS_TRUE( attacker.allow_zombie_to_target_ai) )
+		{
+			continue;
+		}
+		
+		self.has_been_damaged_by_player = true;
+		
+		self player_attacks_enemy( attacker, amount, type, point, weapon, direction_vec, tagName, modelName, partName, dFlags, inflictor, chargeLevel );
+	}
+}
+
+
+function is_spawner_targeted_by_blocker( ent )
+{
+	if( IsDefined( ent.targetname ) )
+	{
+		targeters = GetEntArray( ent.targetname, "target" );
+
+		for( i = 0; i < targeters.size; i++ )
+		{
+			if( targeters[i].targetname == "zombie_door" || targeters[i].targetname == "zombie_debris" )
+			{
+				return true;
+			}
+
+			result = is_spawner_targeted_by_blocker( targeters[i] );
+			if( result )
+			{
+				return true;
+			}
+		}
+	}
+
+	return false;
+}
+
+function add_custom_zombie_spawn_logic(func)
+{
+	if(!IsDefined(level._zombie_custom_spawn_logic))
+	{
+		level._zombie_custom_spawn_logic = [];
+	}
+	
+	level._zombie_custom_spawn_logic[level._zombie_custom_spawn_logic.size] = func;
+}
+
+
+// set up zombie walk cycles
+function zombie_spawn_init( animname_set )
+{
+	if( !isDefined( animname_set ) )
+	{
+		animname_set = false;
+	}
+	
+	self.targetname = "zombie";
+	self.script_noteworthy = undefined;
+
+	//A zombie was spawned - recalculate zombie array
+	zm_utility::recalc_zombie_array();
+
+	if( !animname_set )
+	{
+		self.animname = "zombie"; 		
+	}
+	
+	//pre-spawn gamemodule init
+	if(isdefined(zm_utility::get_gamemode_var("pre_init_zombie_spawn_func")))
+	{
+		self [[zm_utility::get_gamemode_var("pre_init_zombie_spawn_func")]]();
+	}
+
+	self thread play_ambient_zombie_vocals();
+	self thread zm_audio::zmbAIVox_NotifyConvert();
+	self.zmb_vocals_attack = "zmb_vocals_zombie_attack";
+	 
+	self.ignoreme = false;
+	self.allowdeath = true; 			// allows death during animscripted calls
+	self.force_gib = true; 		// needed to make sure this guy does gibs
+	self.is_zombie = true; 			// needed for melee.gsc in the animscripts
+	self allowedStances( "stand" );
+	
+	//needed to make sure zombies don't distribute themselves amongst players
+	self.attackerCountThreatScale = 0;
+	//reduce the amount zombies favor their current enemy
+	self.currentEnemyThreatScale = 0;
+	//reduce the amount zombies target recent attackers
+	self.recentAttackerThreatScale = 0;
+	//zombies dont care about whether players are in cover
+	self.coverThreatScale = 0;
+	//make sure zombies have 360 degree visibility
+	self.fovcosine = 0;
+	self.fovcosinebusy = 0;
+	
+	self.zombie_damaged_by_bar_knockdown = false; // This tracks when I can knock down a zombie with a bar
+
+	self.gibbed = false; 
+	self.head_gibbed = false;
+	
+	// might need this so co-op zombie players cant block zombie pathing
+//	self PushPlayer( true ); 
+//	self.meleeRange = 128; 
+//	self.meleeRangeSq = anim.meleeRange * anim.meleeRange; 
+
+	self setPhysParams( 15, 0, 72 );
+	self.goalradius = 32;
+	
+	self.disableArrivals = true; 
+	self.disableExits = true; 
+	self.grenadeawareness = 0;
+	self.badplaceawareness = 0;
+
+	self.ignoreSuppression = true; 	
+	self.suppressionThreshold = 1; 
+	self.noDodgeMove = true; 
+	self.dontShootWhileMoving = true;
+	self.pathenemylookahead = 0;
+
+
+	self.holdfire			= true;	//no firing - performance gain
+
+	self.badplaceawareness = 0;
+	self.chatInitialized = false;
+	self.missingLegs = false;
+
+	if ( !isdefined( self.zombie_arms_position ) )
+	{
+		if(randomint( 2 ) == 0)
+			self.zombie_arms_position = "up";
+		else
+			self.zombie_arms_position = "down";
+	}
+
+	if ( randomint( 100 ) < ZM_CAN_STUMBLE )
+	{
+		self.canStumble = true;
+	}
+	
+	self.a.disablepain = true;
+	self zm_utility::disable_react(); // SUMEET - zombies dont use react feature.
+
+	if ( isdefined( level.zombie_health ) )
+	{
+		self.maxhealth = level.zombie_health; 
+		
+		if( IsDefined(level.a_zombie_respawn_health[ self.archetype ] ) && level.a_zombie_respawn_health[ self.archetype ].size > 0 )
+		{
+			self.health = level.a_zombie_respawn_health[ self.archetype ][0];
+			ArrayRemoveValue(level.a_zombie_respawn_health[ self.archetype ], level.a_zombie_respawn_health[ self.archetype ][0]);		
+		}
+		else
+		{
+			self.health = level.zombie_health;
+		}	 
+	}
+	else
+	{
+		self.maxhealth = level.zombie_vars["zombie_health_start"]; 
+		self.health = self.maxhealth; 
+	}
+
+	self.freezegun_damage = 0;
+
+	//setting avoidance parameters for zombies
+	self setAvoidanceMask( "avoid none" );
+
+	// wait for zombie to teleport into position before pathing
+	self PathMode( "dont move" );
+
+	level thread zombie_death_event( self );
+
+	// We need more script/code to get this to work properly
+//	self add_to_spectate_list();
+//	self random_tan(); 
+	self zm_utility::init_zombie_run_cycle(); 
+	self thread zombie_think(); 
+	self thread zombie_utility::zombie_gib_on_damage(); 
+	self thread zombie_damage_failsafe();
+	
+	self thread enemy_death_detection();
+
+	if(IsDefined(level._zombie_custom_spawn_logic))
+	{
+		if(IsArray(level._zombie_custom_spawn_logic))
+		{
+			for(i = 0; i < level._zombie_custom_spawn_logic.size; i ++)
+			{
+			self thread [[level._zombie_custom_spawn_logic[i]]]();
+			}
+		}
+		else
+		{
+			self thread [[level._zombie_custom_spawn_logic]]();
+		}
+	}
+	
+	if ( !isdefined( self.no_eye_glow ) || !self.no_eye_glow )
+	{
+		if ( !IS_TRUE( self.is_inert ) )
+		{
+			self thread zombie_utility::delayed_zombie_eye_glow();	// delayed eye glow for ground crawlers (the eyes floated above the ground before the anim started)
+		}
+	}
+	self.deathFunction = &zombie_death_animscript;
+	self.flame_damage_time = 0;
+
+	self.meleeDamage = 60;	// 45
+	self.no_powerups = true;
+	
+	self zombie_history( "zombie_spawn_init -> Spawned = " + self.origin );
+
+	self.thundergun_knockdown_func = level.basic_zombie_thundergun_knockdown;
+	self.tesla_head_gib_func = &zombie_tesla_head_gib;
+
+	self.team = level.zombie_team;
+	
+	// No sight update
+	self.updateSight = false;
+
+	self.heroweapon_kill_power = ZM_ZOMBIE_HERO_WEAPON_KILL_POWER;
+	self.sword_kill_power = ZM_ZOMBIE_HERO_WEAPON_KILL_POWER;
+
+	if ( isDefined(level.achievement_monitor_func) )
+	{
+		self [[level.achievement_monitor_func]]();
+	}
+
+	//gamemodule post init
+	if(isdefined(zm_utility::get_gamemode_var("post_init_zombie_spawn_func")))
+	{
+		self [[zm_utility::get_gamemode_var("post_init_zombie_spawn_func")]]();
+	}
+
+	if ( isDefined( level.zombie_init_done ) )
+	{
+		self [[ level.zombie_init_done ]]();
+	}
+	self.zombie_init_done = true;
+
+	self notify( "zombie_init_done" );
+}
+
+function zombie_damage_failsafe()
+{
+	self endon ("death");
+
+	continue_failsafe_damage = false;	
+	while (1)
+	{
+		//should only be for zombie exploits
+		wait 0.5;
+		
+		if ( !isdefined( self.enemy ) || !IsPlayer( self.enemy ) )
+		{
+			continue;
+		}
+		
+		if (self istouching(self.enemy))
+		{
+			old_org = self.origin;
+			if (!continue_failsafe_damage)
+			{
+				wait 5;
+			}
+			
+			//make sure player doesn't die instantly after getting touched by a zombie.
+			if (!isdefined(self.enemy) || !IsPlayer( self.enemy ) || self.enemy hasperk( PERK_JUGGERNOG ) )
+			{
+				continue;
+			}
+		
+		
+		if (self istouching(self.enemy) 
+				&& !self.enemy laststand::player_is_in_laststand()
+				&& isalive(self.enemy))
+			{
+				//TODO	THIS SHOULD NOT BE A PERMANENT FIX, ONLY TEMP TEST
+				//MM -10/13/09  This distance used to be 35
+				if (distancesquared(old_org, self.origin) < (60 * 60) ) 
+				{
+					self.enemy DoDamage( self.enemy.health + 1000, self.enemy.origin, self, self, "none", "MOD_RIFLE_BULLET" );
+				
+					continue_failsafe_damage = true;
+				}
+			}
+		}
+		else
+		{
+			continue_failsafe_damage = false;
+		}
+	}
+}
+
+
+function should_skip_teardown( find_flesh_struct_string )
+{
+	// Riser who spawns in the playable area
+	if( IsDefined(find_flesh_struct_string) && find_flesh_struct_string == "find_flesh" ) 
+	{
+		return true;
+	}
+	// Used on dogs...could be used on a zombie who spawns in and immediately chases player
+	if( isDefined( self.script_string ) && self.script_string == "find_flesh" ) 
+	{
+		return true;
+	}
+	
+	return false;
+}
+
+function zombie_findnodes()
+{
+	
+	node = undefined;
+
+	desired_nodes = [];
+	self.entrance_nodes = [];
+
+	if ( IsDefined( level.max_barrier_search_dist_override ) )
+	{
+		max_dist = level.max_barrier_search_dist_override;
+	}
+	else
+	{
+		max_dist = 500;
+	}
+
+	if( !IsDefined(self.find_flesh_struct_string) && IsDefined( self.target ) && self.target != "" )
+	{
+		desired_origin = zombie_utility::get_desired_origin();
+
+		assert( IsDefined( desired_origin ), "Spawner @ " + self.origin + " has a .target but did not find a target" );
+	
+		origin = desired_origin;
+			
+		node = ArrayGetClosest( origin, level.exterior_goals ); 	
+		self.entrance_nodes[self.entrance_nodes.size] = node;
+
+		self zombie_history( "zombie_think -> #1 entrance (script_forcegoal) origin = " + self.entrance_nodes[0].origin );
+	}
+	// JMA - this is used in swamp to spawn outdoor zombies and immediately rush the player
+	// JMA - if riser becomes a non-riser, make sure they go to a barrier first instead of chasing a player
+	else if ( self should_skip_teardown( self.find_flesh_struct_string ) )
+	{
+		self zombie_setup_attack_properties();
+		//if the zombie has a target, make them go there first
+		if (isDefined(self.target))
+		{
+			end_at_node = GetNode(self.target, "targetname");
+			if (isDefined(end_at_node))
+			{
+				self setgoalnode (end_at_node);
+				self waittill("goal");
+			}
+		}
+
+		if ( IS_TRUE( self.start_inert ) )
+		{
+			self zombie_complete_emerging_into_playable_area();
+		}
+		else
+		{
+			self thread zombie_entered_playable();
+		}
+		return;	
+	}
+	else if( IsDefined(self.find_flesh_struct_string) )
+	{
+		for( i=0; i<level.exterior_goals.size; i++ )
+		{
+			if( IsDefined(level.exterior_goals[i].script_string) && level.exterior_goals[i].script_string == self.find_flesh_struct_string )
+			{
+				node = level.exterior_goals[i];
+				break;
+			}
+		}
+		self.entrance_nodes[self.entrance_nodes.size] = node;
+		
+		self zombie_history( "zombie_think -> #1 entrance origin = " + node.origin );
+
+		// Incase the guy does not move from spawn, then go to the closest one instead
+		self thread zombie_assure_node();
+	}
+
+	assert( IsDefined( node ), "Did not find a node!!! [Should not see this!]" );
+
+	level thread zm_utility::draw_line_ent_to_pos( self, node.origin, "goal" );
+	
+	self.first_node = node; // This is the first locatin the zombies go to
+	
+}
+
+// JL 12/08/09 this is the main zombie think thread that starts when they spawn in
+function zombie_think()
+{
+	self endon( "death" ); 
+	assert( !self.isdog );
+	
+	self.ai_state = "zombie_think";
+	
+	//node = level.exterior_goals[randomint( level.exterior_goals.size )]; 
+	
+	// MM - 5/8/9 Add ability for risers to find_flesh immediately after spawning if the
+	//	rise struct has the script_noteworthy "find_flesh"
+	find_flesh_struct_string = undefined;
+
+	if ( IsDefined(level.zombie_custom_think_logic) )
+	{
+		shouldWait = self [[ level.zombie_custom_think_logic ]]();
+		if ( shouldWait )
+		{
+			self waittill("zombie_custom_think_done", find_flesh_struct_string);
+		}
+	}
+	else if ( IS_TRUE( self.start_inert ) )
+	{
+		find_flesh_struct_string = "find_flesh";
+	}
+	else
+	{
+		if ( isdefined( self.custom_location ) )
+		{
+			self thread [[ self.custom_location ]]();
+		}
+		else
+		{
+			// DCS 032612: find available structs to spawn at:
+			self thread do_zombie_spawn();
+		}
+		self waittill("risen", find_flesh_struct_string );
+	}
+	self.find_flesh_struct_string = find_flesh_struct_string;
+
+	// what is the zombies goal radius at this point
+	//self thread zombie_goto_entrance( self.first_node ); // sends the zombie to the node right in front of the window
+
+	self SetGoal( self.origin );
+	self PathMode( "move allowed" );
+	self.zombie_think_done = true;
+}
+
+function zombie_entered_playable()
+{
+	self endon( "death" );
+
+	if ( !IsDefined( level.playable_areas ) )
+	{
+		level.playable_areas = GetEntArray("player_volume", "script_noteworthy" );
+	}
+
+	while ( true )
+	{
+		foreach(area in level.playable_areas)
+		{
+			if(self IsTouching(area))
+			{
+				self zombie_complete_emerging_into_playable_area();
+				return;
+			}
+		}
+		wait(1);
+	}	 
+}	
+
+function zombie_goto_entrance( node, endon_bad_path )
+{
+	assert( !self.isdog );
+	
+	self endon( "death" );
+	self endon( "stop_zombie_goto_entrance" );
+	level endon( "intermission" );
+
+	self.ai_state = "zombie_goto_entrance";
+	
+	if( IsDefined( endon_bad_path ) && endon_bad_path )
+	{
+		// If we cannot go to the goal, then end...
+		// Used from find_flesh
+		self endon( "bad_path" );
+	}
+
+
+
+	self zombie_history( "zombie_goto_entrance -> start goto entrance " + node.origin );
+
+	self.got_to_entrance = false;
+	
+	
+	
+	// This is the goal radius while the zombies search for a window to attack
+	self.goalradius = 128; 
+	self SetGoal( node.origin );
+	self waittill( "goal" ); 
+	self.got_to_entrance = true;
+
+	self zombie_history( "zombie_goto_entrance -> reached goto entrance " + node.origin );
+
+	// Guy should get to goal and tear into building until all barrier chunks are gone
+	// They go into this function and do everything they and then comeback once all the barriers are removed
+	self tear_into_building();
+
+	if( isDefined( level.pre_aggro_pathfinding_func ) )
+	{
+		self [[ level.pre_aggro_pathfinding_func ]]();
+	}
+
+	barrier_pos = [];
+	barrier_pos[0] = "m";
+	barrier_pos[1] = "r";
+	barrier_pos[2] = "l";
+
+	self.barricade_enter = true;
+	animstate = zombie_utility::append_missing_legs_suffix( "zm_barricade_enter" );
+	//substate = "barrier_" + self.zombie_move_speed + "_" + barrier_pos[ self.attacking_spot_index ];
+	//self AnimScripted( self.first_node.zbarrier.origin, self.first_node.zbarrier.angles, animstate, substate );
+	self AnimScripted( "barricade_enter_anim", self.first_node.zbarrier.origin, self.first_node.zbarrier.angles, "ai_zombie_barricade_enter_m_v1" );
+	zombie_shared::DoNoteTracks( "barricade_enter_anim" );
+	
+	self zombie_setup_attack_properties();
+	
+	//self.pathEnemyFightDist = 4;	// make sure zombie gets out of the window
+
+	self zombie_complete_emerging_into_playable_area();
+	//self.pathEnemyFightDist = 64;	// restore
+	self.barricade_enter = false;
+}
+	
+
+// Here the zombies constantly search 
+function zombie_assure_node()
+{
+	self endon( "death" );
+	self endon( "goal" );
+	level endon( "intermission" );
+
+	start_pos = self.origin;
+	if(IsDefined(self.entrance_nodes))
+	{
+		for( i = 0; i < self.entrance_nodes.size; i++ )
+		{
+			if( self zombie_bad_path() )
+			{
+				self zombie_history( "zombie_assure_node -> assigned assured node = " + self.entrance_nodes[i].origin );
+	
+		
+				level thread zm_utility::draw_line_ent_to_pos( self, self.entrance_nodes[i].origin, "goal" );
+				self.first_node = self.entrance_nodes[i];
+				self SetGoal( self.entrance_nodes[i].origin );
+			}
+			else
+			{
+				return;
+			}
+		}
+	}		
+	wait(2);
+	// Get more nodes and try again
+	nodes = array::get_all_closest( self.origin, level.exterior_goals, undefined, 20 );
+	//nodes = ArraySort( level.exterior_goals, self.origin, true, 20 );
+
+	if(IsDefined(nodes))
+	{
+		self.entrance_nodes = nodes;
+		for( i = 0; i < self.entrance_nodes.size; i++ )
+		{
+			if( self zombie_bad_path() )
+			{
+				self zombie_history( "zombie_assure_node -> assigned assured node = " + self.entrance_nodes[i].origin );
+	
+		
+				level thread zm_utility::draw_line_ent_to_pos( self, self.entrance_nodes[i].origin, "goal" );
+				self.first_node = self.entrance_nodes[i];
+				self SetGoal( self.entrance_nodes[i].origin );
+			}
+			else
+			{
+				return;
+			}
+		}
+	}	
+
+	self zombie_history( "zombie_assure_node -> failed to find a good entrance point" );
+	
+	//assertmsg( "^1Zombie @ " + self.origin + " did not find a good entrance point... Please fix pathing or Entity setup" );
+	wait(20);
+	//iprintln( "^1Zombie @ " + self.origin + " did not find a good entrance point... Please fix pathing or Entity setup" );
+	
+	
+	self DoDamage( self.health + 10, self.origin );
+	
+	//add this zombie back into the spawner queue to be re-spawned, should only happen with a bad window.
+	if(IS_TRUE(level.put_timed_out_zombies_back_in_queue ) && !IS_TRUE(self.has_been_damaged_by_player))
+	{
+		level.zombie_total++;
+		level.zombie_total_subtract++;					
+	}
+	
+	//add this to the stats even tho he really didn't 'die' 
+	level.zombies_timeout_spawn++;
+	
+}
+
+function zombie_bad_path()
+{
+	self endon( "death" );
+	self endon( "goal" );
+
+	self thread zombie_bad_path_notify();
+	self thread zombie_bad_path_timeout();
+
+	self.zombie_bad_path = undefined;
+	while( !IsDefined( self.zombie_bad_path ) )
+	{
+		WAIT_SERVER_FRAME;
+	}
+
+	self notify( "stop_zombie_bad_path" );
+
+	return self.zombie_bad_path;
+}
+
+function zombie_bad_path_notify()
+{
+	self endon( "death" );
+	self endon( "stop_zombie_bad_path" );
+
+	self waittill( "bad_path" );
+	
+	
+	self.zombie_bad_path = true;
+}
+
+function zombie_bad_path_timeout()
+{
+	self endon( "death" );
+	self endon( "stop_zombie_bad_path" );
+
+	wait( 2 );
+	self.zombie_bad_path = false;
+}
+
+
+// This controls the zombies breaking into the building.
+// Self is a specific zombie
+// Node is the player's origin
+function tear_into_building()
+{
+	self endon( "death" ); // this is a zombie
+	self endon("teleporting");
+	self zombie_history( "tear_into_building -> start" ); // update history that they have started to tear in 
+
+	while( 1 )
+	{
+		//also check
+		//if( IsDefined( self.first_node) )
+		//{
+		
+			if( IsDefined( self.first_node.script_noteworthy ) )
+			{
+				if( self.first_node.script_noteworthy == "no_blocker" )
+				{
+					return; // if no blocker checks out ok... then allow the zombie to connect paths
+				}
+			}
+
+			if( !IsDefined( self.first_node.target ) )
+			{
+				return;
+			}
+
+			// barrier_chunks is the exterior_goal that has all the bars and boards connected to it.
+			// remember all_chunks_destroyed is in utility script _zombie_utility
+			if( zm_utility::all_chunks_destroyed( self.first_node, self.first_node.barrier_chunks ) ) // If barrier_chunks status says all chunks are destroyed then continue
+			{
+				// latest
+				// Send this notify but only accept the first time it comes through.
+				self zombie_history( "tear_into_building -> all chunks destroyed" ); // Enter the building if all chunks are gone. This is threaded for each zombie
+			}
+
+			// If an attacking_spot is availiable then they well grab one, if not they taunt.
+			// Jluyties (02/04/10)Added the ability for zombies to taunt while they wait to attack a window 
+			if( !get_attack_spot( self.first_node ) )
+			{	
+				self zombie_history( "tear_into_building -> Could not find an attack spot" );
+				//Print3d(self.origin+(0,0,70), "Hey I am waiting to attack, play random " );
+				//Print3d(self.origin+(0,0,70), "Hey I am waiting to attack", ( 1, 0.8, 0.5), 1, 1, 5);
+				//IPrintLnBold( "Hey I am waiting to attack " );
+				self thread  do_a_taunt();
+				wait( 0.5 );
+				continue;
+			}
+		
+			// This is where the zombie moves into position to tear down a board/bar
+			self.goalradius = 2;
+			//self maps\_zombiemode_utility:: lerp( chunk );
+			self.at_entrance_tear_spot = false;
+			if ( isdefined( level.tear_into_position ) )
+			{
+				self [[ level.tear_into_position ]]();
+			}
+			else
+			{
+				angles = self.first_node.zbarrier.angles;
+		
+				self SetGoal( self.attacking_spot );
+			}
+			self waittill( "goal" );
+			self.at_entrance_tear_spot = true;
+			//	MM- 05/09
+			//	If you wait for "orientdone", you NEED to also have a timeout.
+			//	Otherwise, zombies could get stuck waiting to do their facing.
+			if ( isdefined( level.tear_into_wait ) )
+			{
+				self [[ level.tear_into_wait ]]();
+			}
+			else
+			{
+				self util::waittill_any_ex( 1, "orientdone", "death", "teleporting" );
+			}
+	
+			self zombie_history( "tear_into_building -> Reach position and orientated" );		
+	
+			// chrisp - do one final check to make sure that the boards are still torn down
+			// this *mostly* prevents the zombies from coming through the windows as you are boarding them up. 
+			if( zm_utility::all_chunks_destroyed( self.first_node, self.first_node.barrier_chunks ) )
+			{
+				self zombie_history( "tear_into_building -> all chunks destroyed" );
+				for( i = 0; i < self.first_node.attack_spots_taken.size; i++ )
+				{
+					self.first_node.attack_spots_taken[i] = false;
+				}
+				return;
+			}
+		//}
+	
+		// Now tear down boards
+		while( 1 )
+		{
+			if ( isDefined( self.zombie_board_tear_down_callback ) )
+			{
+				self [[self.zombie_board_tear_down_callback]]();
+			}
+
+			// get_closest_non_destroyed_chunk calls into _zombiemode_utility and returns if any chunks are still there
+			self.chunk = zm_utility::get_closest_non_destroyed_chunk( self.origin, self.first_node, self.first_node.barrier_chunks );
+
+			if ( !IsDefined( self.chunk ) )
+			{
+				if( !zm_utility::all_chunks_destroyed( self.first_node, self.first_node.barrier_chunks ) )
+				{
+					attack = self should_attack_player_thru_boards();
+					if(isDefined(attack) && !attack && !self.missingLegs)
+					{
+						self do_a_taunt();
+					}
+					else
+					{
+						wait( 0.1 );
+					}
+					continue;
+				}
+
+
+				for( i = 0; i < self.first_node.attack_spots_taken.size; i++ )
+				{
+					self.first_node.attack_spots_taken[i] = false;
+				}
+				return; 
+			}
+
+			self zombie_history( "tear_into_building -> animating" );
+			
+			self.first_node.zbarrier SetZBarrierPieceState(self.chunk, "targetted_by_zombie");
+			self.first_node thread check_zbarrier_piece_for_zombie_inert(self.chunk, self.first_node.zbarrier, self);
+			self.first_node thread check_zbarrier_piece_for_zombie_death(self.chunk, self.first_node.zbarrier, self);
+			
+			self notify( "bhtn_action_notify", "teardown" );
+
+			/*if( isdefined( level.zbarrier_override_tear_in ) )
+			{
+				animStateBase = self [[ level.zbarrier_override_tear_in ]]( chunk );			
+			}
+			else
+			{
+				animStateBase = self.first_node.zbarrier GetZBarrierPieceAnimState(chunk);			
+			}
+			
+			animSubState = "spot_" + self.attacking_spot_index + "_piece_" + self.first_node.zbarrier GetZBarrierPieceAnimSubState(chunk);
+			
+			anim_sub_index	= self GetAnimSubStateFromASD( animStateBase + "_in", animSubState );				
+			*/
+			
+            //self AnimScripted( self.first_node.zbarrier.origin, self.first_node.zbarrier.angles, zombie_utility::append_missing_legs_suffix( animStateBase + "_in" ), anim_sub_index );
+			self AnimScripted( "tear_anim", self.first_node.zbarrier.origin, self.first_node.zbarrier.angles, "ai_zombie_boardtear_aligned_m_1_grab" );
+			
+				
+            self zombie_tear_notetracks( "tear_anim", self.chunk, self.first_node );
+			
+			while(0 < self.first_node.zbarrier.chunk_health[self.chunk])
+			{
+				//self AnimScripted( self.first_node.zbarrier.origin, self.first_node.zbarrier.angles, zombie_utility::append_missing_legs_suffix( animStateBase + "_loop" ), anim_sub_index );
+				self AnimScripted( "tear_anim", self.first_node.zbarrier.origin, self.first_node.zbarrier.angles, "ai_zombie_boardtear_aligned_m_1_hold" );
+				self zombie_tear_notetracks( "tear_anim", self.chunk, self.first_node );
+        		self.first_node.zbarrier.chunk_health[self.chunk]--;
+			}
+			
+            //self AnimScripted( self.first_node.zbarrier.origin, self.first_node.zbarrier.angles, zombie_utility::append_missing_legs_suffix( animStateBase + "_out" ), anim_sub_index );
+			self AnimScripted( "tear_anim", self.first_node.zbarrier.origin, self.first_node.zbarrier.angles, "ai_zombie_boardtear_aligned_m_1_pull" );
+			self waittill("temp proceed");
+			
+             //to prevent the zombie from being deleted by the failsafe system
+            self.lastchunk_destroy_time = GetTime();
+            
+            attack = self should_attack_player_thru_boards();
+            if ( isDefined( attack ) && !attack && !self.missingLegs )
+            {
+                self do_a_taunt();
+            }                
+
+			//chrisp - fix the extra tear anim bug
+			if ( zm_utility::all_chunks_destroyed( self.first_node, self.first_node.barrier_chunks ) )
+			{
+				for( i = 0; i < self.first_node.attack_spots_taken.size; i++ )
+				{
+					self.first_node.attack_spots_taken[i] = false;
+				}
+				
+				level notify( "last_board_torn", self.first_node.zbarrier.origin );
+				
+				return;
+			}	
+		}
+		
+		self zombie_utility::reset_attack_spot();
+	}		
+}
+
+
+/*------------------------------------
+function checks to see if the zombie should 
+function do a taunt when tearing thru the boards
+------------------------------------*/
+function do_a_taunt()
+{
+	self endon ("death"); // Jluyties 02/16/10 added death check, cause of crash 
+	if( self.missingLegs )
+	{
+		return false;
+	}
+
+	if(!self.first_node.zbarrier ZBarrierSupportsZombieTaunts())
+	{
+		return;
+	}
+	
+	self.old_origin = self.origin;
+	if(GetDvarString( "zombie_taunt_freq") == "")
+	{
+		SetDvar("zombie_taunt_freq","5");
+	}
+	freq = GetDvarInt( "zombie_taunt_freq");
+	
+	if( freq >= randomint(100) )
+	{
+		self notify( "bhtn_action_notify", "taunt" );
+		
+		tauntState = "zm_taunt";
+		
+		if(isdefined(self.first_node.zbarrier) && self.first_node.zbarrier GetZBarrierTauntAnimState() != "")
+		{
+			tauntState = self.first_node.zbarrier GetZBarrierTauntAnimState();
+		}
+		
+		//self animscripted( "anim_wait_done", self.origin, self.angles, tauntState );
+		self animscripted( "taunt_anim", self.origin, self.angles, "ai_zombie_taunts_4" );
+		self taunt_notetracks( "taunt_anim" );
+	}
+}
+
+function taunt_notetracks(msg)
+{
+	self endon("death");
+
+	while(1)
+	{
+		self waittill( msg, notetrack );
+
+		if( notetrack == "end" )
+		{
+			self ForceTeleport(self.old_origin);
+
+			return;
+		}
+	}
+}
+/*------------------------------------
+function checks to see if the players are near
+function the entrance and tries to attack them 
+function thru the boards. 50% chance
+function Self is a zombie
+------------------------------------*/
+function should_attack_player_thru_boards()
+{
+
+	//no board attacks if they are crawlers
+	if( self.missingLegs )
+	{
+		return false;
+	}
+	
+	if(isdefined(self.first_node.zbarrier))
+	{
+		if(!self.first_node.zbarrier ZBarrierSupportsZombieReachThroughAttacks())
+		{
+			return false;
+		}
+	}
+	
+	if(GetDvarString( "zombie_reachin_freq") == "")
+	{
+		SetDvar("zombie_reachin_freq","50");
+	}
+	freq = GetDvarInt( "zombie_reachin_freq");
+	
+	players = GetPlayers();
+	attack = false;
+
+    self.player_targets = [];
+    for(i=0;i<players.size;i++)
+    {
+    	if ( isAlive( players[i] ) && !isDefined( players[i].revivetrigger ) && distance2d( self.origin, players[i].origin ) <= level.attack_player_thru_boards_range && !IS_TRUE( players[i].zombie_vars[ "zombie_powerup_zombie_blood_on" ] ) )
+        {
+            self.player_targets[self.player_targets.size] = players[i];
+            attack = true;
+        }
+    }
+
+    if ( !attack || freq < randomint(100) )
+	{
+		return false;	
+	}
+
+	self.old_origin = self.origin;
+
+	attackAnimState = "zm_window_melee";
+	
+	if(isdefined(self.first_node.zbarrier) && self.first_node.zbarrier GetZBarrierReachThroughAttackAnimState() != "")
+	{
+		attackAnimState = self.first_node.zbarrier GetZBarrierReachThroughAttackAnimState();
+	}
+	
+	// index 0 is center, index 2 is left and index 1 is the right, so (0 - 1) results in randomizing between both options
+	self notify( "bhtn_action_notify", "attack" );
+	//self AnimScripted( self.origin, self.angles, attackAnimState, self.attacking_spot_index - 1 );
+	self AnimScripted( "window_melee_anim", self.origin, self.angles, "ai_zombie_window_attack_arm_l_out" ); 
+	self window_notetracks( "window_melee_anim" );
+
+	return true;
+}
+
+function window_notetracks(msg)
+{
+	self endon("death");
+
+	while(1)
+	{
+		self waittill( msg, notetrack );
+
+		if( notetrack == "end" )
+		{
+			//self waittill("end");
+			self teleport(self.old_origin);
+
+			return;
+		}
+		if( notetrack == "fire" )
+		{
+			if(self.ignoreall)
+			{
+				self.ignoreall = false;
+			}
+
+			// just hit a player
+			if ( isDefined( self.first_node ) )
+			{
+				_MELEE_DIST_SQ = 90*90;
+				
+				if ( IsDefined( level.attack_player_thru_boards_range ) )
+ 				{
+ 					_MELEE_DIST_SQ =  level.attack_player_thru_boards_range	* level.attack_player_thru_boards_range;
+				}
+				
+				_TRIGGER_DIST_SQ = 51*51;
+
+				for ( i = 0; i < self.player_targets.size; i++ )
+				{
+					playerDistSq = Distance2DSquared( self.player_targets[i].origin, self.origin );
+					heightDiff = abs( self.player_targets[i].origin[2] - self.origin[2] ); // be sure we're on the same floor
+					if ( playerDistSq < _MELEE_DIST_SQ && (heightDiff * heightDiff) < _MELEE_DIST_SQ )
+					{
+						triggerDistSq = Distance2DSquared( self.player_targets[i].origin, self.first_node.trigger_location.origin );
+						heightDiff = abs( self.player_targets[i].origin[2] - self.first_node.trigger_location.origin[2] ); // be sure we're on the same floor
+						if ( triggerDistSq < _TRIGGER_DIST_SQ && (heightDiff * heightDiff) < _TRIGGER_DIST_SQ )
+						{
+							self.player_targets[i] DoDamage( self.meleeDamage, self.origin, self, self, "none", "MOD_MELEE" );
+							break;
+						}
+					}
+				}
+			}
+			else
+			{
+				self melee();
+			}
+		}
+	}
+}
+
+function get_attack_spot( node )
+{
+	index = get_attack_spot_index( node );
+	if( !IsDefined( index ) )
+	{
+		return false;
+	}
+
+	self.attacking_node = node;
+	self.attacking_spot_index = index;
+	node.attack_spots_taken[index] = true;
+	self.attacking_spot = node.attack_spots[index];
+
+	return true;
+}
+
+function get_attack_spot_index( node )
+{
+	indexes = [];
+	DEFAULT(node.attack_spots,[]);
+	for( i = 0; i < node.attack_spots.size; i++ )
+	{
+		if( !node.attack_spots_taken[i] )
+		{
+			indexes[indexes.size] = i;
+		}
+	}
+
+	if( indexes.size == 0 )
+	{
+		return undefined;
+	}
+
+	return indexes[RandomInt( indexes.size )];
+}
+
+// Self is zombie
+function zombie_tear_notetracks( msg, chunk, node )
+{
+	self endon("death");
+	
+	while( 1 )
+	{
+		self waittill( msg, notetrack );
+
+		if ( notetrack == "end" )
+		{
+			return;
+		}
+		
+		if ( notetrack == "board" || notetrack == "destroy_piece" || notetrack == "bar")
+		{
+			if( isdefined( level.zbarrier_zombie_tear_notetrack_override ) )
+			{
+				self thread [[ level.zbarrier_zombie_tear_notetrack_override ]]( node, chunk );
+			}
+			node.zbarrier SetZBarrierPieceState(chunk, "opening");
+		}
+	}
+}
+
+// jl I am doing this so I can have an offset of timing for when the chunks come off to give it more life
+// 0.8 is too long
+// need to offset sound
+// need to add this to the boards
+function zombie_boardtear_offset_fx_horizontle( chunk, node )
+{
+	// DCS 090110: fx for breaking out glass or wall.
+	if ( IsDefined( chunk.script_parameters ) && ( chunk.script_parameters == "repair_board"  || chunk.script_parameters == "board") )
+	{
+		if(IsDefined(chunk.unbroken) && chunk.unbroken == true)
+		{ 
+			if(IsDefined(chunk.material) && chunk.material == "glass")
+			{
+				PlayFX( level._effect["glass_break"], chunk.origin, node.angles );
+				chunk.unbroken = false;
+			}
+			else if(IsDefined(chunk.material) && chunk.material == "metal")
+			{
+				PlayFX( level._effect["fx_zombie_bar_break"], chunk.origin );
+				chunk.unbroken = false;
+			}
+			else if(IsDefined(chunk.material) && chunk.material == "rock")
+			{
+				if(	IS_TRUE(level.use_clientside_rock_tearin_fx))
+				{
+					chunk clientfield::set( "tearin_rock_fx", 1 );
+				}
+				else
+				{
+					PlayFX( level._effect["wall_break"], chunk.origin );
+				}
+				chunk.unbroken = false;
+			}
+		}
+	}
+	if ( IsDefined( chunk.script_parameters ) && ( chunk.script_parameters == "barricade_vents" ) )
+	{
+		if(	IS_TRUE(level.use_clientside_board_fx))
+		{
+			chunk clientfield::set( "tearin_board_vertical_fx", 1);
+		}
+		else
+		{
+			PlayFX( level._effect["fx_zombie_bar_break"], chunk.origin );
+		}
+	}	
+	else if(IsDefined(chunk.material) && chunk.material == "rock")
+	{
+		if(	IS_TRUE(level.use_clientside_rock_tearin_fx))
+		{
+			chunk clientfield::set( "tearin_rock_fx", 1 );
+		}
+	}
+			
+	else
+	{	
+		if(isDefined(level.use_clientside_board_fx))
+		{
+			chunk clientfield::set( "tearin_board_vertical_fx", 1 );
+		}
+		else
+		{
+//			PlayFx( level._effect["wood_chunk_destory"], chunk.origin + (0, 0, 30));
+			wait( randomfloatrange( 0.2, 0.4 ));
+//			PlayFx( level._effect["wood_chunk_destory"], chunk.origin + (0, 0, -30));
+		}	
+	}
+}
+
+function zombie_boardtear_offset_fx_verticle( chunk, node )
+{
+	// DCS 090110: fx for breaking out glass or wall.
+	if ( IsDefined( chunk.script_parameters ) && ( chunk.script_parameters == "repair_board"  || chunk.script_parameters == "board") )
+	{
+		if(IsDefined(chunk.unbroken) && chunk.unbroken == true)
+		{ 
+			if(IsDefined(chunk.material) && chunk.material == "glass")
+			{
+				PlayFX( level._effect["glass_break"], chunk.origin, node.angles );
+				chunk.unbroken = false;
+			}
+			else if(IsDefined(chunk.material) && chunk.material == "metal")
+			{
+				PlayFX( level._effect["fx_zombie_bar_break"], chunk.origin );
+				chunk.unbroken = false;
+			}
+			else if(IsDefined(chunk.material) && chunk.material == "rock")
+			{
+				if(	IS_TRUE(level.use_clientside_rock_tearin_fx))
+				{
+					chunk clientfield::set( "tearin_rock_fx", 1 );
+				}
+				else
+				{
+					PlayFX( level._effect["wall_break"], chunk.origin );
+				}
+				chunk.unbroken = false;
+			}
+		}
+	}
+	if ( IsDefined( chunk.script_parameters ) && ( chunk.script_parameters == "barricade_vents" ) )
+	{
+		if(isDefined(level.use_clientside_board_fx))
+		{
+			chunk clientfield::set( "tearin_board_horizontal_fx", 1 );
+		}
+		else
+		{
+			PlayFX( level._effect["fx_zombie_bar_break"], chunk.origin );
+		}
+	}	
+	else if(IsDefined(chunk.material) && chunk.material == "rock")
+	{
+		if(	IS_TRUE(level.use_clientside_rock_tearin_fx))
+		{
+			chunk clientfield::set( "tearin_rock_fx", 1 );
+		}
+	}			
+	else	
+	{		
+		if(isDefined(level.use_clientside_board_fx))
+		{
+			chunk clientfield::set( "tearin_board_horizontal_fx", 1 );
+		}
+		else
+		{
+//			PlayFx( level._effect["wood_chunk_destory"], chunk.origin + (30, 0, 0));
+			wait( randomfloatrange( 0.2, 0.4 ));
+//			PlayFx( level._effect["wood_chunk_destory"], chunk.origin + (-30, 0, 0));
+		}
+	}
+}
+
+
+function zombie_bartear_offset_fx_verticle( chunk )
+{
+	if ( IsDefined ( chunk.script_parameters ) && ( chunk.script_parameters == "bar" ) || ( chunk.script_noteworthy == "board" ))
+	{
+		// array random grab for fx		
+		//point = points[i];
+		possible_tag_array_1 = [];
+		possible_tag_array_1[0] = "Tag_fx_top";
+		possible_tag_array_1[1] = "";
+		possible_tag_array_1[2] = "Tag_fx_top";
+		possible_tag_array_1[3] = "";
+
+		possible_tag_array_2 = [];
+		possible_tag_array_2[0] = "";
+		possible_tag_array_2[1] = "Tag_fx_bottom";
+		possible_tag_array_2[2] = "";
+		possible_tag_array_2[3] = "Tag_fx_bottom";
+		// now I need a random int between 0 and 3
+		possible_tag_array_2 = array::randomize( possible_tag_array_2 );
+
+		random_fx = [];
+		random_fx[0] = level._effect["fx_zombie_bar_break"];
+		random_fx[1] = level._effect["fx_zombie_bar_break_lite"];
+		random_fx[2] = level._effect["fx_zombie_bar_break"];
+		random_fx[3] = level._effect["fx_zombie_bar_break_lite"];
+		// now I need a random int between 0 and 3
+		random_fx = array::randomize( random_fx );   
+
+		switch( randomInt( 9 ) ) // This sets up random versions of the bars being pulled apart for variety
+		{
+			case 0:
+							PlayFXOnTag( level._effect["fx_zombie_bar_break_lite"], chunk, "Tag_fx_top" );
+							wait( randomfloatrange( 0.0, 0.3 ));
+							PlayFXOnTag( level._effect["fx_zombie_bar_break_lite"], chunk, "Tag_fx_bottom" );
+				break;
+
+			case 1:
+							PlayFXOnTag( level._effect["fx_zombie_bar_break"], chunk, "Tag_fx_top" );
+							wait( randomfloatrange( 0.0, 0.3 ));
+							PlayFXOnTag( level._effect["fx_zombie_bar_break"], chunk, "Tag_fx_bottom" );
+				break;
+
+			case 2:
+							PlayFXOnTag( level._effect["fx_zombie_bar_break_lite"], chunk, "Tag_fx_top" );
+							wait( randomfloatrange( 0.0, 0.3 ));
+							PlayFXOnTag( level._effect["fx_zombie_bar_break"], chunk, "Tag_fx_bottom" );
+				break;
+
+			case 3:
+							PlayFXOnTag( level._effect["fx_zombie_bar_break"], chunk, "Tag_fx_top" );
+							wait( randomfloatrange( 0.0, 0.3 ));
+							PlayFXOnTag( level._effect["fx_zombie_bar_break_lite"], chunk, "Tag_fx_bottom" );
+				break;
+
+			case 4:
+							PlayFXOnTag( level._effect["fx_zombie_bar_break_lite"], chunk, "Tag_fx_top" );
+							wait( randomfloatrange( 0.0, 0.3 ));
+							PlayFXOnTag( level._effect["fx_zombie_bar_break_lite"], chunk, "Tag_fx_bottom" );
+				break;
+
+			case 5:
+							PlayFXOnTag( level._effect["fx_zombie_bar_break_lite"], chunk, "Tag_fx_top" );
+				break;
+			case 6:
+							PlayFXOnTag( level._effect["fx_zombie_bar_break_lite"], chunk, "Tag_fx_bottom" );
+				break;
+			case 7:
+							PlayFXOnTag( level._effect["fx_zombie_bar_break"], chunk, "Tag_fx_top" );
+				break;
+			case 8:
+							PlayFXOnTag( level._effect["fx_zombie_bar_break"], chunk, "Tag_fx_bottom" );
+				break;
+		} 
+	}
+}
+
+//jl I am doing this so I can have an offset of timing for when the chunks come off to give it more life
+function zombie_bartear_offset_fx_horizontle( chunk )
+{
+	if ( IsDefined ( chunk.script_parameters ) && ( chunk.script_parameters == "bar" ) || ( chunk.script_noteworthy == "board" ))
+	{
+		switch( randomInt( 10 ) ) // This sets up random versions of the bars being pulled apart for variety
+		{
+			case 0:
+							PlayFXOnTag( level._effect["fx_zombie_bar_break_lite"], chunk, "Tag_fx_left" );
+							wait( randomfloatrange( 0.0, 0.3 ));
+							PlayFXOnTag( level._effect["fx_zombie_bar_break_lite"], chunk, "Tag_fx_right" );
+			break;
+				
+			case 1:
+							PlayFXOnTag( level._effect["fx_zombie_bar_break"], chunk, "Tag_fx_left" );
+							wait( randomfloatrange( 0.0, 0.3 ));
+							PlayFXOnTag( level._effect["fx_zombie_bar_break"], chunk, "Tag_fx_right" );
+			break;
+				
+			case 2:
+							PlayFXOnTag( level._effect["fx_zombie_bar_break_lite"], chunk, "Tag_fx_left" );
+							wait( randomfloatrange( 0.0, 0.3 ));
+							PlayFXOnTag( level._effect["fx_zombie_bar_break"], chunk, "Tag_fx_right" );
+			break;
+				
+			case 3:
+							PlayFXOnTag( level._effect["fx_zombie_bar_break"], chunk, "Tag_fx_left" );
+							wait( randomfloatrange( 0.0, 0.3 ));
+							PlayFXOnTag( level._effect["fx_zombie_bar_break_lite"], chunk, "Tag_fx_right" );
+			break;
+				
+			case 4:
+							PlayFXOnTag( level._effect["fx_zombie_bar_break_lite"], chunk, "Tag_fx_left" );
+							wait( randomfloatrange( 0.0, 0.3 ));
+							PlayFXOnTag( level._effect["fx_zombie_bar_break_lite"], chunk, "Tag_fx_right" );
+			break;
+				
+			case 5:
+							PlayFXOnTag( level._effect["fx_zombie_bar_break_lite"], chunk, "Tag_fx_left" );
+			break;
+			case 6:
+							PlayFXOnTag( level._effect["fx_zombie_bar_break_lite"], chunk, "Tag_fx_right" );
+			break;
+			case 7:
+							PlayFXOnTag( level._effect["fx_zombie_bar_break"], chunk, "Tag_fx_right" );
+			break;
+			case 8:
+							PlayFXOnTag( level._effect["fx_zombie_bar_break"], chunk, "Tag_fx_right" );
+			break;
+		} 
+	}
+}  
+
+function check_zbarrier_piece_for_zombie_inert(chunk_index, zbarrier, zombie)
+{
+	zombie endon( "completed_emerging_into_playable_area" );
+
+	zombie waittill( "stop_zombie_goto_entrance" );
+
+	if ( zbarrier GetZBarrierPieceState(chunk_index) == "targetted_by_zombie" )
+	{
+		zbarrier SetZBarrierPieceState(chunk_index, "closed");
+	}
+}
+
+function check_zbarrier_piece_for_zombie_death(chunk_index, zbarrier, zombie)
+{
+	while(1)
+	{
+		if(zbarrier GetZBarrierPieceState(chunk_index) != "targetted_by_zombie")
+		{
+			return;
+		}
+		
+		if(!isdefined(zombie) || !IsAlive(zombie))
+		{
+			zbarrier SetZBarrierPieceState(chunk_index, "closed");
+			return;
+		}
+		
+		WAIT_SERVER_FRAME;
+	}
+}
+
+function check_for_zombie_death(zombie)
+{
+	self endon("destroyed");
+	
+	wait(2.5);
+	self zm_blockers::update_states("repaired");
+}
+
+//
+function player_can_score_from_zombies() 
+{
+	if ( IsDefined(self) && IS_TRUE(self.inhibit_scoring_from_zombies) ) 
+	{
+		return false;
+	}
+	return true;
+}
+
+//
+//
+function zombie_can_drop_powerups( zombie )
+{
+	if( zm_utility::is_tactical_grenade( zombie.damageweapon ) || !level flag::get( "zombie_drop_powerups" ) )
+	{
+		return false;
+	}
+
+	if ( isdefined(zombie.no_powerups) && zombie.no_powerups )
+	{
+		return false;
+	}
+
+	if( IS_TRUE(level.no_powerups) )
+	{
+		return( false );
+	}
+
+	if ( IS_TRUE( level.use_powerup_volumes ) )
+	{
+		volumes = GetEntArray( "no_powerups", "targetname" );
+		foreach( volume in volumes )
+		{
+			if ( zombie IsTouching( volume ) )
+			{
+				return false;
+			}
+		}
+	}
+
+	return true;
+}
+
+function zombie_delay_powerup_drop(origin)
+{
+	util::wait_network_frame();
+	level thread zm_powerups::powerup_drop( origin );
+}
+
+//
+//	award points on death
+function zombie_death_points( origin, mod, hit_location, attacker, zombie,team )
+{
+	if( !IsDefined( attacker ) || !IsPlayer( attacker ) )
+	{
+		return; 
+	}
+
+	if ( !attacker player_can_score_from_zombies() )
+	{
+		zombie.marked_for_recycle = 1;
+		return;
+	}
+
+	if( zombie_can_drop_powerups( zombie ) )
+	{
+		// DCS 031611: hack to prevent risers from dropping powerups under the ground.
+		if(IsDefined(zombie.in_the_ground) && zombie.in_the_ground == true)
+		{
+			trace = BulletTrace(zombie.origin + (0, 0, 100), zombie.origin + (0, 0, -100), false, undefined);
+			origin = trace["position"];
+			level thread zombie_delay_powerup_drop( origin );
+		}
+		else
+		{	
+			trace = GroundTrace(zombie.origin + (0, 0, 5), zombie.origin + (0, 0, -300), false, undefined);
+			origin = trace["position"];
+			level thread zombie_delay_powerup_drop( origin );
+		}	
+	}
+
+	//AUDIO: Ayers - Decides what vox to play after killing a zombie
+	level thread zm_audio::player_zombie_kill_vox( hit_location, attacker, mod, zombie );
+
+	event = "death";
+	if ( zombie.damageweapon.isBallisticKnife && (mod == "MOD_MELEE" || mod == "MOD_IMPACT") )
+	{
+		event = "ballistic_knife_death";
+	}
+	
+	if(IS_TRUE(zombie.deathpoints_already_given))
+	{
+		return;
+	}
+	
+	zombie.deathpoints_already_given = true;
+	
+	if ( zm_equipment::is_equipment(zombie.damageweapon) )
+		return;
+
+	death_weapon = attacker.currentweapon;
+	if ( IsDefined( zombie.damageweapon ) )
+	{
+		death_weapon = zombie.damageweapon;
+	}
+	
+	if ( IsDefined(attacker) )
+	{
+		attacker zm_score::player_add_points( event, mod, hit_location, undefined, team, death_weapon );
+	}
+	
+	if( isdefined(level.hero_power_update))
+	{
+		level thread [[level.hero_power_update]](attacker, zombie);
+	}
+}
+
+function get_number_variants(aliasPrefix)
+{
+		for(i=0; i<100; i++)
+		{
+			if( !SoundExists( aliasPrefix + "_" + i) )
+			{
+				//iprintlnbold(aliasPrefix +"_" + i);
+				return i;
+			}
+		}
+}	
+
+
+function dragons_breath_flame_death_fx()
+{
+	if ( self.isdog )
+	{
+		return;
+	}
+
+	if( !IsDefined( level._effect ) || !IsDefined( level._effect["character_fire_death_sm"] ) )
+	{
+		return;
+	}
+
+	PlayFxOnTag( level._effect["character_fire_death_sm"], self, "J_SpineLower" );
+
+	tagArray = []; 
+	if( !IsDefined( self.a.gib_ref ) || self.a.gib_ref != "left_arm" )
+	{
+		tagArray[tagArray.size] = "J_Elbow_LE";
+		tagArray[tagArray.size] = "J_Wrist_LE";
+	}
+	if( !IsDefined( self.a.gib_ref ) || self.a.gib_ref != "right_arm" )
+	{
+		tagArray[tagArray.size] = "J_Elbow_RI";
+		tagArray[tagArray.size] = "J_Wrist_RI";
+	}
+	if( !IsDefined( self.a.gib_ref ) || (self.a.gib_ref != "no_legs" && self.a.gib_ref != "left_leg") )
+	{
+		tagArray[tagArray.size] = "J_Knee_LE";
+		tagArray[tagArray.size] = "J_Ankle_LE";
+	}
+	if( !IsDefined( self.a.gib_ref ) || (self.a.gib_ref != "no_legs" && self.a.gib_ref != "right_leg") )
+	{
+		tagArray[tagArray.size] = "J_Knee_RI";
+		tagArray[tagArray.size] = "J_Ankle_RI";
+	}
+
+	tagArray = array::randomize( tagArray ); 
+	PlayFxOnTag( level._effect["character_fire_death_sm"], self, tagArray[0] );
+}
+
+function zombie_ragdoll_then_explode( launchvector, attacker )
+{
+	if (!isdefined(self))
+		return; 
+	
+	self zombie_utility::zombie_eye_glow_stop();
+	self clientfield::set("zombie_ragdoll_explode", 1);
+	self notify( "exploding" );
+	self notify( "end_melee" );
+	self notify( "death", attacker );
+	
+	// Physics Launch off Window
+	//--------------------------
+	self.dont_die_on_me = true;
+	self.exploding = true;
+	self.a.nodeath = true;
+	self.dont_throw_gib = true;
+	self StartRagdoll();
+    self SetPlayerCollision(0);	
+	self zombie_utility::reset_attack_spot();
+
+	if (isdefined(launchvector))
+		self LaunchRagdoll( launchvector );
+	
+	wait 2.1;
+	if (isdefined(self))
+	{
+		self ghost();
+		self util::delay( 0.25, undefined, &zm_utility::self_delete );
+	}
+}
+
+
+
+// Called from animscripts\zm_death.gsc
+function zombie_death_animscript( eInflictor, attacker, iDamage, sMeansOfDeath, weapon, vDir, sHitLoc, psOffsetTime )
+{
+	team = undefined;
+
+	//A zombie died - recalculate zombie array
+	zm_utility::recalc_zombie_array();
+	
+	if(isDefined(self._race_team))
+	{
+		team = self._race_team;
+	}
+	
+	self zombie_utility::reset_attack_spot();
+
+	if( self check_zombie_death_animscript_callbacks() )
+	{
+		return false;
+	}
+
+	// animscript override
+	if( IsDefined( level.zombie_death_animscript_override ) )
+	{
+		self [ [ level.zombie_death_animscript_override ] ] ();
+	}
+
+	self.grenadeAmmo = 0;
+
+	// rsh090710 - nuked zombies don't give points but should still possibly drop powerups
+	if ( IsDefined( self.nuked ) )
+	{
+		if( zombie_can_drop_powerups( self ) )
+		{
+			// DCS 031611: hack to prevent risers from dropping powerups under the ground.
+			if(IsDefined(self.in_the_ground) && self.in_the_ground == true)
+			{
+				trace = BulletTrace(self.origin + (0, 0, 100), self.origin + (0, 0, -100), false, undefined);
+				origin = trace["position"];
+				level thread zombie_delay_powerup_drop( origin );
+			}
+			else
+			{	
+				trace = GroundTrace(self.origin + (0, 0, 5), self.origin + (0, 0, -300), false, undefined);
+				origin = trace["position"];
+				level thread zombie_delay_powerup_drop( self.origin );
+			}	
+		}
+	}
+	else
+	{
+		// Give attacker points
+		//ChrisP - 12/8/08 - added additional 'self' argument		
+		level zombie_death_points( self.origin, self.damagemod, self.damagelocation, self.attacker, self ,team);
+	}
+
+	// switch to inflictor when SP DoDamage supports it
+	if( isdefined( self.attacker ) && isai( self.attacker ) )
+	{
+		self.attacker notify( "killed", self );
+	}
+	
+
+	if( "rottweil72_upgraded" == self.damageweapon.name && "MOD_RIFLE_BULLET" == self.damagemod )
+	{
+		self thread dragons_breath_flame_death_fx();
+	}
+	if( "tazer_knuckles" == self.damageweapon.name && "MOD_MELEE" == self.damagemod )
+	{
+		self.is_on_fire = false;
+		self notify("stop_flame_damage");
+	}
+	if( self.damagemod == "MOD_BURNED" )
+	{
+		self thread zombie_death::flame_death_fx();
+	}
+	if( self.damagemod == "MOD_GRENADE" || self.damagemod == "MOD_GRENADE_SPLASH" ) 
+	{
+		level notify( "zombie_grenade_death", self.origin );
+	}
+
+	return false;
+}
+
+
+function check_zombie_death_animscript_callbacks()
+{
+	if ( !isdefined( level.zombie_death_animscript_callbacks ) )
+	{
+		return false;
+	}
+
+	for ( i = 0; i < level.zombie_death_animscript_callbacks.size; i++ )
+	{
+		if ( self [[ level.zombie_death_animscript_callbacks[i] ]]() )
+		{
+			return true;
+		}
+	}
+
+	return false;
+}
+
+
+function register_zombie_death_animscript_callback( func )
+{
+	if ( !isdefined( level.zombie_death_animscript_callbacks ) )
+	{
+		level.zombie_death_animscript_callbacks = [];
+	}
+
+	level.zombie_death_animscript_callbacks[level.zombie_death_animscript_callbacks.size] = func;
+}
+
+
+function damage_on_fire( player )
+{
+	self endon ("death");
+	self endon ("stop_flame_damage");
+	wait( 2 );
+	
+	while( isdefined( self.is_on_fire) && self.is_on_fire )
+	{
+		if( level.round_number < 6 )
+		{
+			dmg = level.zombie_health * RandomFloatRange( 0.2, 0.3 ); // 20% - 30%
+		}
+		else if( level.round_number < 9 )
+		{
+			dmg = level.zombie_health * RandomFloatRange( 0.15, 0.25 );
+		}
+		else if( level.round_number < 11 )
+		{
+			dmg = level.zombie_health * RandomFloatRange( 0.1, 0.2 );
+		}
+		else
+		{
+			dmg = level.zombie_health * RandomFloatRange( 0.1, 0.15 );
+		}
+
+		if ( Isdefined( player ) && Isalive( player ) )
+		{
+			self DoDamage( dmg, self.origin, player );
+		}
+		else
+		{
+			self DoDamage( dmg, self.origin, level );
+		}
+		
+		wait( randomfloatrange( 1.0, 3.0 ) );
+	}
+}
+
+function player_using_hi_score_weapon( player )
+{
+	if( IsPlayer( player) ) //check because robot companion can fire off this function, and internally requires a player
+	{
+		weapon = player GetCurrentWeapon();
+		
+		return (weapon == level.weaponNone || weapon.isSemiAuto);
+	}
+	
+	return false;
+}
+
+function zombie_damage( mod, hit_location, hit_origin, player, amount, team, weapon, direction_vec, tagName, modelName, partName, dFlags, inflictor, chargeLevel )
+{
+	if( zm_utility::is_magic_bullet_shield_enabled( self ) )
+	{
+		return;
+	}
+
+	//ChrisP - 12/8 - no points for killing gassed zombies!
+	player.use_weapon_type = mod;
+	if(isDefined(self.marked_for_death))
+	{
+		return;
+	}	
+
+	if( !IsDefined( player ) )
+	{
+		return; 
+	}
+
+	if (isdefined(hit_origin))
+		self.damagehit_origin = hit_origin;
+	else
+		self.damagehit_origin = player GetWeaponMuzzlePoint();
+
+	if ( self check_zombie_damage_callbacks( mod, hit_location, hit_origin, player, amount, weapon, direction_vec, tagName, modelName, partName, dFlags, inflictor, chargeLevel ) )
+	{
+		return;
+	}
+	else if ( !player player_can_score_from_zombies() )
+	{
+		
+	}
+	else if ( IsDefined(weapon) && weapon.isriotshield )
+	{
+	}
+	else if( self zombie_flame_damage( mod, player ) )
+	{
+		if( self zombie_give_flame_damage_points() )
+		{
+			player zm_score::player_add_points( "damage", mod, hit_location, self.isdog,team );
+		}
+	}
+	else
+	{
+		if( player_using_hi_score_weapon( player ) )
+		{
+			damage_type = "damage";
+		}
+		else
+		{
+			damage_type = "damage_light";
+		}
+
+		if ( !IS_TRUE( self.no_damage_points ) )
+		{
+			player zm_score::player_add_points( damage_type, mod, hit_location, self.isdog, team, weapon );
+		}
+	}
+
+	if ( IsDefined( self.zombie_damage_fx_func ) )
+	{
+		self [[ self.zombie_damage_fx_func ]]( mod, hit_location, hit_origin, player, direction_vec );
+	}
+
+	if ( "MOD_IMPACT" != mod && zm_utility::is_placeable_mine( weapon ) )
+	{
+		if ( IsDefined( self.zombie_damage_claymore_func ) )
+		{
+			self [[ self.zombie_damage_claymore_func ]]( mod, hit_location, hit_origin, player );
+		}
+		else if ( isdefined( player ) && isalive( player ) )
+		{
+			self DoDamage( level.round_number * randomintrange( 100, 200 ), self.origin, player, self, hit_location, mod, 0, weapon );
+		}
+		else
+		{
+			self DoDamage( level.round_number * randomintrange( 100, 200 ), self.origin, undefined, self, hit_location, mod, 0, weapon );
+		}
+	}
+	else if ( mod == "MOD_GRENADE" || mod == "MOD_GRENADE_SPLASH" )
+	{
+		if ( isdefined( player ) && isalive( player ) )
+		{
+			player.grenade_multiattack_count++;
+			player.grenade_multiattack_ent = self;
+
+			self DoDamage( level.round_number + randomintrange( 100, 200 ), self.origin, player, self, hit_location, mod, 0, weapon );
+		}
+		else
+		{
+			self DoDamage( level.round_number + randomintrange( 100, 200 ), self.origin, undefined, self, hit_location, mod, 0, weapon );
+		}
+	}
+	else if( mod == "MOD_PROJECTILE" || mod == "MOD_EXPLOSIVE" || mod == "MOD_PROJECTILE_SPLASH" )
+	{
+		if ( isdefined( player ) && isalive( player ) )
+		{
+			self DoDamage( level.round_number * randomintrange( 0, 100 ), self.origin, player, self, hit_location, mod, 0, weapon );
+		}
+		else
+		{
+			self DoDamage( level.round_number * randomintrange( 0, 100 ), self.origin, undefined, self, hit_location, mod, 0, weapon );
+		}
+	}
+	
+	//AUDIO Plays a sound when Crawlers are created
+	if( IS_TRUE( self.gibbed ))
+	{
+		if( IS_TRUE( self.missinglegs ) && isalive(self)  )
+		{
+			if ( isdefined( player ) )
+			{
+					player zm_audio::create_and_play_dialog( "general", "crawl_spawn" );
+			}
+		}
+		else if( IsDefined( self.a.gib_ref ) && ( (self.a.gib_ref == "right_arm") || (self.a.gib_ref == "left_arm") ) )
+		{
+			if( !self.missingLegs && isalive( self ) )
+			{
+				if ( isdefined( player ) )
+				{
+					rand = randomintrange(0, 100);
+					if(rand < 7)
+					{
+						player zm_audio::create_and_play_dialog( "general", "shoot_arm" );
+					}
+				}
+			}
+		}	
+	}
+	self thread zm_powerups::check_for_instakill( player, mod, hit_location );
+}
+
+function zombie_damage_ads( mod, hit_location, hit_origin, player, amount, team, weapon, direction_vec, tagName, modelName, partName, dFlags, inflictor, chargeLevel )
+{
+	
+	if( zm_utility::is_magic_bullet_shield_enabled( self ) )
+	{
+		return;
+	}
+
+	player.use_weapon_type = mod;
+	if( !IsDefined( player ) )
+	{
+		return; 
+	}
+
+	if (isdefined(hit_origin))
+		self.damagehit_origin = hit_origin;
+	else
+		self.damagehit_origin = player GetWeaponMuzzlePoint();
+
+	
+	if ( self check_zombie_damage_callbacks( mod, hit_location, hit_origin, player, amount, weapon, direction_vec, tagName, modelName, partName, dFlags, inflictor, chargeLevel ) )
+	{
+		return;
+	}
+	else if ( !player player_can_score_from_zombies() )
+	{
+	}
+	else if( self zombie_flame_damage( mod, player ) )
+	{
+		if( self zombie_give_flame_damage_points() )
+		{			
+			player zm_score::player_add_points( "damage_ads", mod, hit_location,undefined,team );
+		}
+	}
+	else
+	{
+		if( player_using_hi_score_weapon( player ) )
+		{
+			damage_type = "damage";
+		}
+		else
+		{
+			damage_type = "damage_light";
+		}
+
+		if ( !IS_TRUE( self.no_damage_points ) )
+		{				
+			player zm_score::player_add_points( damage_type, mod, hit_location, undefined, team, weapon );
+		}
+	}
+
+	if ( IsDefined( self.zombie_damage_fx_func ) )
+	{
+		self [[ self.zombie_damage_fx_func ]]( mod, hit_location, hit_origin, player, direction_vec );
+	}
+
+	self thread zm_powerups::check_for_instakill( player, mod, hit_location );
+}
+
+
+function check_zombie_damage_callbacks( mod, hit_location, hit_origin, player, amount, weapon, direction_vec, tagName, modelName, partName, dFlags, inflictor, chargeLevel )
+{
+	if ( !isdefined( level.zombie_damage_callbacks ) )
+	{
+		return false;
+	}
+
+	for ( i = 0; i < level.zombie_damage_callbacks.size; i++ )
+	{
+		if ( self [[ level.zombie_damage_callbacks[i] ]]( mod, hit_location, hit_origin, player, amount, weapon, direction_vec, tagName, modelName, partName, dFlags, inflictor, chargeLevel ) )
+		{
+			return true;
+		}
+	}
+
+	return false;
+}
+
+
+function register_zombie_damage_callback( func )
+{
+	if ( !isdefined( level.zombie_damage_callbacks ) )
+	{
+		level.zombie_damage_callbacks = [];
+	}
+
+	level.zombie_damage_callbacks[level.zombie_damage_callbacks.size] = func;
+}
+
+function zombie_give_flame_damage_points()
+{
+	if( !isDefined( self.flame_damage_time ) || GetTime() > self.flame_damage_time )
+	{
+		self.flame_damage_time = GetTime() + level.zombie_vars["zombie_flame_dmg_point_delay"];
+		return true;
+	}
+
+	return false;
+}
+
+function zombie_flame_damage( mod, player )
+{
+	if( mod == "MOD_BURNED" )
+	{
+		if( !IsDefined( self.is_on_fire ) || ( Isdefined( self.is_on_fire ) && !self.is_on_fire ) )
+		{
+			self thread damage_on_fire( player );
+		}
+
+		do_flame_death = true;
+		dist = 100 * 100;
+		ai = GetAiTeamArray( level.zombie_team );
+		for( i = 0; i < ai.size; i++ )
+		{
+			if( IsDefined( ai[i].is_on_fire ) && ai[i].is_on_fire )
+			{
+				if( DistanceSquared( ai[i].origin, self.origin ) < dist )
+				{
+					do_flame_death = false;
+					break;
+				}
+			}
+		}
+
+		if( do_flame_death )
+		{
+			self thread zombie_death::flame_death_fx();
+		}
+
+		return true;
+	}
+
+	return false;
+}
+
+function is_weapon_shotgun( weapon )
+{
+	return (weapon.weapClass == "spread");
+}
+
+function zombie_explodes_intopieces( random_gibs )
+{
+	if ( isdefined(self) && IsActor(self) )
+	{
+		if( (!random_gibs) || (randomint(100) < 50) )
+			gibserverutils::gibhead( self );
+		if( (!random_gibs) || (randomint(100) < 50) )
+			gibserverutils::gibleftarm( self );
+		if( (!random_gibs) || (randomint(100) < 50) )
+			gibserverutils::gibrightarm( self );
+		if( (!random_gibs) || (randomint(100) < 50) )
+			gibserverutils::giblegs( self );
+	}
+	//gibserverutils::Annihilate( zombie );
+}
+
+//*****************************************************************************
+// A zombie has been killed
+//*****************************************************************************
+
+function zombie_death_event( zombie )
+{
+	zombie.marked_for_recycle = 0;
+
+	force_explode = 0;
+	force_head_gib = 0;
+	
+	zombie waittill( "death", attacker);
+	time_of_death = gettime();
+	
+	if(isDefined(zombie))
+	{
+		zombie StopSounds();
+	}
+
+	// The Insta Kill Upgrade - Forces melee deaths on close proximity
+	if( IsDefined(zombie) && IsDefined(zombie.marked_for_insta_upgraded_death) )
+	{
+		force_head_gib = 1;
+	}
+
+	if ( IsDefined(zombie) && !isdefined( zombie.damagehit_origin ) && isdefined( attacker ) && IsAlive( attacker ) && !IsVehicle( attacker ) )
+	{
+		zombie.damagehit_origin = attacker GetWeaponMuzzlePoint();
+	}
+
+	//stat tracking
+	if(isDefined(attacker) && isPlayer(attacker) && attacker player_can_score_from_zombies() )
+	{
+		// If a zombie dies with the kvp (script_parameters), notify the attacker. script_parameter is inherited from the spawn location.
+		if( isdefined(zombie.script_parameters) )
+		{
+			attacker notify( "zombie_death_params", zombie.script_parameters, IS_TRUE(zombie.completed_emerging_into_playable_area) );
+		}
+
+		// Widows wine kill notify
+		if( isdefined(zombie.b_widows_wine_cocoon) && isdefined(zombie.e_widows_wine_player) )
+		{
+			attacker notify( "widows_wine_kill", zombie.e_widows_wine_player );
+		}
+		
+		// Carpenter - Persistent upgrade kills accumulator
+		if( IS_TRUE(level.pers_upgrade_carpenter) )
+		{
+			zm_pers_upgrades::pers_zombie_death_location_check( attacker, zombie.origin );
+		}
+
+		// Player "sniper" persistent ability tracking
+		if( IS_TRUE(level.pers_upgrade_sniper) )
+		{
+			attacker zm_pers_upgrades_functions::pers_upgrade_sniper_kill_check( zombie, attacker );
+		}
+
+		if(isDefined(zombie) && isDefined(zombie.damagelocation) )
+		{
+			if( zm_utility::is_headshot( zombie.damageweapon, zombie.damagelocation, zombie.damagemod ))
+			{
+				attacker.headshots++;
+				attacker zm_stats::increment_client_stat( "headshots" );	//headshots
+				attacker AddWeaponStat(zombie.damageWeapon, "headshots", 1);
+				attacker zm_stats::increment_player_stat( "headshots" );
+				attacker zm_stats::increment_challenge_stat( "ZOMBIE_HUNTER_KILL_HEADSHOT" );
+			
+				// Only in classic mode
+				if(zm_utility::is_Classic() )
+				{
+					//track pers upgrade				
+					attacker zm_pers_upgrades_functions::pers_check_for_pers_headshot( time_of_death, zombie );
+				}
+			}
+			else
+			{
+				attacker notify("zombie_death_no_headshot");
+			}
+			
+		}
+		if(isDefined(zombie) && isDefined(zombie.damagemod) && zombie.damagemod == "MOD_MELEE")
+		{
+			attacker zm_stats::increment_client_stat( "melee_kills" );	//melee kills
+			attacker zm_stats::increment_player_stat( "melee_kills" );
+			attacker notify( "melee_kill" );
+			attacker zm_stats::increment_challenge_stat( "ZOMBIE_HUNTER_KILL_MELEE" );
+
+			// If the insta_kill - force an explosive death of the zombies
+			if( attacker zm_pers_upgrades::is_insta_kill_upgraded_and_active() )
+			{
+				force_explode = 1;
+			}
+		}
+
+		attacker demo::add_actor_bookmark_kill_time();
+		attacker.kills++;
+		attacker zm_stats::increment_client_stat( "kills" );			//total kills
+		attacker zm_stats::increment_player_stat( "kills" );
+
+		// Persistent upgrade - pistol points
+		if ( IS_TRUE(level.pers_upgrade_pistol_points) )
+		{
+			attacker zm_pers_upgrades_functions::pers_upgrade_pistol_points_kill();
+		}
+		
+		if ( isDefined( zombie ) && isDefined( zombie.damageweapon ) )
+		{
+			attacker AddWeaponStat(zombie.damageWeapon, "kills", 1);
+						
+			if ( zm_weapons::is_weapon_upgraded(zombie.damageWeapon) )
+			{
+				attacker zm_stats::increment_challenge_stat( "ZOMBIE_HUNTER_KILL_PACKAPUNCH" );
+			}
+		}
+		
+		// If zombie is crawler notify the player of ther crawler kill
+		if ( isDefined( zombie ) && IS_TRUE( zombie.missingLegs ) )
+		{
+			attacker zm_stats::increment_challenge_stat( "ZOMBIE_HUNTER_KILL_CRAWLER" );
+		}
+					
+		// Check for persistant headshot upgrade and always gib the head no matter if it's a headshot or not
+		// Also check for a force head gib
+		if(	(attacker zm_pers_upgrades_functions::pers_mulit_kill_headshot_active()) || (force_head_gib) )
+		{
+			zombie zombie_utility::zombie_head_gib();
+		}
+
+		// Player "sniper" persistent ability tracking
+		if( IS_TRUE(level.pers_upgrade_nube) )
+		{
+			attacker notify( "pers_player_zombie_kill" );
+		}
+	}
+
+	//A zombie died - recalculate zombie array
+	zm_utility::recalc_zombie_array();
+
+	// Need to check in case he got deleted earlier
+	if ( !IsDefined( zombie ) )
+	{
+		return;
+	}
+	
+	//Track all zombies killed
+	level.global_zombies_killed++;
+
+	//track stats on zombies killed by traps 
+	if(isDefined(zombie.marked_for_death) && !isDefined(zombie.nuked))
+	{
+		level.zombie_trap_killed_count++;
+	}
+	
+	zombie check_zombie_death_event_callbacks( attacker );
+	zombie bgb::actor_death_override( attacker );
+	
+	// Need to check in case he got deleted in the callback
+	if ( !IsDefined( zombie ) )
+	{
+		return;
+	}
+	
+	name = zombie.animname;
+	if( isdefined( zombie.sndname ) )
+	{
+		name = zombie.sndname;
+	}
+	
+	self notify( "bhtn_action_notify", "death" );
+	zombie thread zombie_utility::zombie_eye_glow_stop();
+
+	if( IsActor( zombie ) )
+	{
+		if( IS_TRUE(zombie.damageweapon.doannihilate) )
+		{
+			zombie zombie_explodes_intopieces( false );
+		}
+		else
+		{
+			if(	(is_weapon_shotgun( zombie.damageweapon ) && zm_weapons::is_weapon_upgraded( zombie.damageweapon )) ||
+			   ( zm_utility::is_placeable_mine( zombie.damageweapon ) )||
+			     ( (zombie.damagemod === "MOD_GRENADE") || (zombie.damagemod === "MOD_GRENADE_SPLASH") || (zombie.damagemod === "MOD_EXPLOSIVE") || (force_explode == 1) ) )
+			{
+				splode_dist = 12 * 15;
+				if ( isdefined(zombie.damagehit_origin) && distancesquared(zombie.origin,zombie.damagehit_origin) < splode_dist * splode_dist )
+				{
+					tag = "J_SpineLower";
+					
+					
+					if ( IS_TRUE( zombie.isdog ) )
+					{
+						tag = "tag_origin";
+					}
+					
+					if (!IS_TRUE(zombie.is_on_fire) && !IS_TRUE(zombie.guts_explosion))
+					{
+						zombie thread zombie_utility::zombie_gut_explosion();
+					}
+					/*
+					else if( IsDefined( level._effect[ "zomb_gib" ] ) )
+					{
+						PlayFX( level._effect[ "zomb_gib" ], zombie GetTagOrigin( tag ) );
+					}
+					*/
+				}
+				
+				if ( isdefined(attacker) && IsPlayer( attacker ) && !is_weapon_shotgun( zombie.damageweapon ) )
+				{
+					attacker zm_stats::increment_challenge_stat( "ZOMBIE_HUNTER_KILL_EXPLOSIVES" );
+				}
+			}
+		}
+		
+		if ( zombie.damagemod === "MOD_GRENADE" || zombie.damagemod === "MOD_GRENADE_SPLASH" )
+		{
+			if ( isdefined( attacker ) && isalive( attacker )  &&isPlayer( attacker ) )
+			{
+				attacker.grenade_multiattack_count++;
+				attacker.grenade_multiattack_ent = zombie;
+				attacker.grenade_multikill_count++; // Black Ops 3 - TU1 Fix; track multikill count in addition to multiattack, for the Five-for-One Challenge
+			}
+		}
+	}
+	
+	// this is controlling killstreak voice over in the asylum.gsc
+	if ( !IS_TRUE(zombie.has_been_damaged_by_player) && IS_TRUE(zombie.marked_for_recycle))
+	{
+		level.zombie_total++;
+		level.zombie_total_subtract++;
+	}
+	else if(isdefined (zombie.attacker) && isplayer(zombie.attacker) )
+	{
+		
+		//this tracks the zombies killed by a player for stat tracking
+		level.zombie_player_killed_count++;		
+		
+		if ( IsDefined( zombie.sound_damage_player ) && zombie.sound_damage_player == zombie.attacker )
+		{	
+			zombie.attacker zm_audio::create_and_play_dialog( "kill", "damage" );	
+		}
+
+		zombie.attacker notify( "zom_kill", zombie );
+	}
+	else
+	{
+		if(zombie.ignoreall && !IS_TRUE(zombie.marked_for_death)  )
+		{
+			level.zombies_timeout_spawn++;
+		}
+	}
+		
+	level notify( "zom_kill" );
+	level.total_zombies_killed++;
+}
+
+//*****************************************************************************
+//*****************************************************************************
+
+function check_zombie_death_event_callbacks( attacker )
+{
+	if ( !isdefined( level.zombie_death_event_callbacks ) )
+	{
+		return;
+	}
+
+	for ( i = 0; i < level.zombie_death_event_callbacks.size; i++ )
+	{
+		self [[ level.zombie_death_event_callbacks[i] ]]( attacker );
+	}
+}
+
+
+function register_zombie_death_event_callback( func )
+{
+	if ( !isdefined( level.zombie_death_event_callbacks ) )
+	{
+		level.zombie_death_event_callbacks = [];
+	}
+
+	level.zombie_death_event_callbacks[level.zombie_death_event_callbacks.size] = func;
+}
+
+function deregister_zombie_death_event_callback( func )
+{
+	if (isdefined( level.zombie_death_event_callbacks ) )
+	{
+		ArrayRemoveValue(level.zombie_death_event_callbacks,func);
+	}	
+}
+
+
+// this is where zombies go into attack mode, and need different attributes set up
+function zombie_setup_attack_properties()
+{
+	self zombie_history( "zombie_setup_attack_properties()" );
+
+	// allows zombie to attack again
+	self.ignoreall = false; 
+
+	// push the player out of the way so they use traversals in the house.
+	//self PushPlayer( true ); 
+
+//	self.pathEnemyFightDist = 64;	//set in gdt now
+	self.meleeAttackDist = 64;
+	
+	//try to prevent always turning towards the enemy
+	self.maxsightdistsqrd = 128 * 128;
+
+	// turn off transition anims
+	self.disableArrivals = true; 
+	self.disableExits = true; 
+}
+
+
+//this lets them wake up and go after things like the monkey bomb immediately
+function attractors_generated_listener()
+{
+	self endon( "death" );
+	level endon( "intermission" );
+	self endon( "stop_find_flesh" );
+	self endon( "path_timer_done" );
+
+	level waittill( "attractor_positions_generated" );
+	self.zombie_path_timer = 0;
+}
+
+
+function zombie_pathing()
+{
+	self endon( "death" );
+	self endon( "zombie_acquire_enemy" );
+	level endon( "intermission" );
+
+	assert( IsDefined( self.favoriteenemy ) || IsDefined( self.enemyoverride ) );
+	
+	self._skip_pathing_first_delay = true;
+	self thread zombie_follow_enemy();
+	self waittill( "bad_path" );
+	
+	level.zombie_pathing_failed ++;
+
+	IPrintLnBold("ya this fails lol");
+	
+	//If we get here then we have a bad path and the zombie can't use the regular pathing system to find the player
+	//.....  crap!
+	
+	if( isDefined( self.enemyoverride ) ) 
+	{
+		zm_utility::debug_print( "Zombie couldn't path to point of interest at origin: " + self.enemyoverride[0] + " Falling back to breadcrumb system" );
+		if( isDefined( self.enemyoverride[1] ) )
+		{
+			self.enemyoverride = self.enemyoverride[1] zm_utility::invalidate_attractor_pos( self.enemyoverride, self );
+			self.zombie_path_timer = 0;
+			return;
+		}
+	}
+	else
+	{
+		if(isDefined(self.favoriteenemy))
+		{
+			zm_utility::debug_print( "Zombie couldn't path to player at origin: " + self.favoriteenemy.origin + " Falling back to breadcrumb system" );
+		}
+		else
+		{
+			zm_utility::debug_print( "Zombie couldn't path to a player ( the other 'prefered' player might be ignored for encounters mode ). Falling back to breadcrumb system" );
+		}
+	}
+	
+	if( !isDefined( self.favoriteenemy ) )
+	{
+		self.zombie_path_timer = 0;
+		return;
+	}
+	else
+	{
+		self.favoriteenemy endon( "disconnect" );
+	}
+	
+	//this is for selecting the valid player from the player to use for tracking purposes.
+	players = GetPlayers();
+	valid_player_num = 0;
+	for( i = 0; i < players.size; i++ )
+	{
+		if( zm_utility::is_player_valid( players[i], true ) ) 
+		{
+			valid_player_num += 1;
+		}
+	}
+	//PI_CHANGE_BEGIN - 7/2/2009 JV Reenabling change 274916 (from DLC3)
+	if( players.size > 1 )
+	{
+		if(isDefined(level._should_skip_ignore_player_logic) && [[level._should_skip_ignore_player_logic]]() )
+		{
+			self.zombie_path_timer = 0;
+			return;	
+		}
+		if( !IsInArray( self.ignore_player, self.favoriteenemy) )
+		{
+			self.ignore_player[self.ignore_player.size] = self.favoriteenemy;
+		}
+
+		if( self.ignore_player.size < valid_player_num )
+		{
+			self.zombie_path_timer = 0;
+			return;
+		}
+	}
+	//PI_CHANGE_END
+
+	crumb_list = self.favoriteenemy.zombie_breadcrumbs;
+	bad_crumbs = [];
+	
+	while( 1 )
+	{
+		if( !zm_utility::is_player_valid( self.favoriteenemy, true ) )
+		{
+			self.zombie_path_timer = 0;
+			return;
+		}
+
+		goal = zombie_pathing_get_breadcrumb( self.favoriteenemy.origin, crumb_list, bad_crumbs, ( RandomInt( 100 ) < 20 ) );
+		
+		if ( !IsDefined( goal ) )
+		{
+			zm_utility::debug_print( "Zombie exhausted breadcrumb search" );
+			
+			//zombies failed to get breadcrumbs
+			level.zombie_breadcrumb_failed ++;
+			
+			goal = self.favoriteenemy.spectator_respawn.origin;
+		}
+
+		zm_utility::debug_print( "Setting current breadcrumb to " + goal );
+
+		self.zombie_path_timer += 100;
+		self SetGoal( goal );
+		self waittill( "bad_path" );
+
+		zm_utility::debug_print( "Zombie couldn't path to breadcrumb at " + goal + " Finding next breadcrumb" );
+		for( i = 0; i < crumb_list.size; i++ )
+		{
+			if( goal == crumb_list[i] )
+			{
+				bad_crumbs[bad_crumbs.size] = i;
+				break;
+			}
+		}
+	}
+}
+
+function zombie_pathing_get_breadcrumb( origin, breadcrumbs, bad_crumbs, pick_random )
+{
+	assert( IsDefined( origin ) );
+	assert( IsDefined( breadcrumbs ) );
+	assert( IsArray( breadcrumbs ) );
+
+	for( i = 0; i < breadcrumbs.size; i++ )
+	{
+		if ( pick_random )
+		{
+			crumb_index = RandomInt( breadcrumbs.size );
+		}
+		else
+		{
+			crumb_index = i;
+		}
+				
+		if( crumb_is_bad( crumb_index, bad_crumbs ) )
+		{
+			continue;
+		}
+
+		return breadcrumbs[crumb_index];
+	}
+
+	return undefined;
+}
+
+function crumb_is_bad( crumb, bad_crumbs )
+{
+	for ( i = 0; i < bad_crumbs.size; i++ )
+	{
+		if ( bad_crumbs[i] == crumb )
+		{
+			return true;
+		}
+	}
+
+	return false;
+}
+
+function jitter_enemies_bad_breadcrumbs( start_crumb )
+{
+	trace_distance = 35;
+	jitter_distance = 2;
+	
+	index = start_crumb;
+	
+	while (isdefined(self.favoriteenemy.zombie_breadcrumbs[ index + 1 ]))
+	{
+		current_crumb = self.favoriteenemy.zombie_breadcrumbs[ index ];
+		next_crumb = self.favoriteenemy.zombie_breadcrumbs[ index + 1 ];
+		
+		angles = vectortoangles(current_crumb - next_crumb);
+		
+		right = anglestoright(angles);
+		left = anglestoright(angles + (0,180,0));
+		
+		dist_pos = current_crumb + VectorScale( right, trace_distance );
+		
+		trace = bulletTrace( current_crumb, dist_pos, true, undefined );
+		vector = trace["position"];
+		
+		if (distance(vector, current_crumb) < 17 )
+		{
+			self.favoriteenemy.zombie_breadcrumbs[ index ] = current_crumb + VectorScale( left, jitter_distance );
+			continue;
+		}
+		
+		
+		// try the other side
+		dist_pos = current_crumb + VectorScale( left, trace_distance );
+		
+		trace = bulletTrace( current_crumb, dist_pos, true, undefined );
+		vector = trace["position"];
+		
+		if (distance(vector, current_crumb) < 17 )
+		{
+			self.favoriteenemy.zombie_breadcrumbs[ index ] = current_crumb + VectorScale( right, jitter_distance );
+			continue;
+		}
+		
+		index++;
+	}
+	
+}
+
+function zombie_repath_notifier()
+{
+	note = 0;
+
+	notes = [];
+	
+	for(i = 0; i < 4; i ++)
+	{
+		notes[notes.size] = "zombie_repath_notify_"+i;
+	}
+	
+	while(1)
+	{
+		level notify(notes[note]);
+		
+		note = (note + 1) % 4;
+		WAIT_SERVER_FRAME;
+	}
+}
+
+function zombie_follow_enemy()
+{
+	self endon( "death" );
+	self endon( "zombie_acquire_enemy" );
+	self endon( "bad_path" );
+	
+	level endon( "intermission" );
+
+	if(!isdefined(level.repathNotifierStarted))
+	{
+		level.repathNotifierStarted = true;
+		
+		level thread zombie_repath_notifier();
+	}
+
+	if(!isdefined(self.zombie_repath_notify))
+	{
+		self.zombie_repath_notify = "zombie_repath_notify_" + (self getentitynumber() % 4);
+	}
+	
+	while( 1 )
+	{
+		if(!isdefined(self._skip_pathing_first_delay))
+		{
+			level waittill(self.zombie_repath_notify);
+		}
+		else
+		{
+			self._skip_pathing_first_delay = undefined;
+		}
+		
+		if( !IS_TRUE( self.ignore_enemyoverride ) && isDefined( self.enemyoverride ) && isDefined( self.enemyoverride[1] ) )
+		{
+			if( distanceSquared( self.origin, self.enemyoverride[0] ) > 1*1 )
+			{
+				self OrientMode( "face motion" );
+			}
+			else
+			{
+				self OrientMode( "face point", self.enemyoverride[1].origin );
+			}
+			self.ignoreall = true;
+
+			goalPos = self.enemyoverride[0];
+			if ( IsDefined( level.adjust_enemyoverride_func ) )
+			{
+				goalPos = self [[ level.adjust_enemyoverride_func ]]();
+			}
+			self SetGoal( goalPos );
+		}
+		else if( IsDefined( self.favoriteenemy ) )
+		{
+			self.ignoreall = false;
+
+			//TEMP Just to get us running for the playtest.  Need to kill this whole function later.
+			if ( IsDefined( level.enemy_location_override_func ) )
+			{
+				goalPos = [[ level.enemy_location_override_func ]]( self, self.favoriteenemy );
+	
+				if ( IsDefined( goalPos ) )
+				{
+					self SetGoal( goalPos );
+				}
+				else
+				{
+					self zm_behavior::zombieUpdateGoal();
+				}
+			}
+			else if( IS_TRUE(self.is_rat_test) )
+			{
+			}
+			else if ( zm_behavior::zombieShouldMoveAwayCondition( self ) )
+			{
+				WAIT_SERVER_FRAME;
+				continue;
+			}
+			else if ( IsDefined( self.favoriteenemy.last_valid_position ) )
+			{
+				self SetGoal( self.favoriteenemy.last_valid_position );		
+			}
+			else
+			{
+				//AssertMsg( "no last_valid_position" );
+			}
+
+			if ( !IsDefined( level.ignore_path_delays ) )
+			{
+				distSq = distanceSquared( self.origin, self.favoriteenemy.origin );
+			
+				if( distSq > 3200 * 3200 )
+				{
+					wait(2.0 + randomFloat( 1.0 ));
+				}
+				else if( distSq > 2200 * 2200 )
+				{
+					wait(1.0 + randomFloat( 0.5 ));
+				}
+				else if( distSq > 1200 * 1200 )
+				{
+					wait(0.5 + randomFloat( 0.5 ));
+				}
+			}
+		}
+
+		// LDS - changed this from a level specific catch function to a general one that can be overloaded based
+		//       on the conditions in a level that can render a player inaccessible to zombies.
+		if( isDefined( level.inaccesible_player_func ) )
+		{
+			self [[ level.inaccessible_player_func ]]();
+		}
+	}
+}
+
+//
+// DEBUG
+//
+
+function zombie_history( msg )
+{
+}
+
+function do_zombie_spawn()
+{
+	self endon("death");
+
+	spots = [];
+
+	// special case, seems to appear in gamemodules. 
+	if(isDefined(self._rise_spot))
+	{
+		spot = self._rise_spot;
+		self thread do_zombie_rise(spot);
+		return;
+	}
+	
+	// add spawner locations
+	if ( IS_TRUE( level.use_multiple_spawns ) && isdefined( self.script_int ) )
+	{
+		foreach( loc in level.zm_loc_types[ "zombie_location" ] )
+		{
+			if ( !(IsDefined( level.spawner_int ) && (level.spawner_int == self.script_int)) &&
+			    !(IsDefined( loc.script_int ) || IsDefined( level.zones[ loc.zone_name ].script_int )) )
+			{
+				continue;
+			}
+
+			if ( IsDefined( loc.script_int ) && ( loc.script_int != self.script_int ) )
+			{
+				continue;
+			}
+			else if ( IsDefined( level.zones[ loc.zone_name ].script_int ) && ( level.zones[ loc.zone_name ].script_int != self.script_int ) )
+			{
+				continue;
+			}
+			
+			spots[spots.size] = loc;
+		}	
+	}
+	else
+	{
+		spots = level.zm_loc_types[ "zombie_location" ];
+	}
+	
+		if ( GetDvarInt("scr_zombie_spawn_in_view") )
+		{
+			player = GetPlayers()[0];
+			spots = [];
+			max_dot = 0;
+			look_loc = undefined;
+			foreach ( loc in level.zm_loc_types[ "zombie_location" ] )
+			{
+				player_vec = VectorNormalize( AnglesToForward( player GetPlayerAngles() ) );
+				player_vec_2d = ( player_vec[0], player_vec[1], 0 );
+				player_spawn = VectorNormalize( loc.origin - player.origin );
+				player_spawn_2d = ( player_spawn[0], player_spawn[1], 0 );
+				dot = VectorDot( player_vec_2d, player_spawn_2d );
+				dist = Distance( loc.origin, player.origin );
+				if ( dot > 0.707 && dist <= GetDvarInt( "scr_zombie_spawn_in_view_dist" ) )
+				{
+					if ( dot > max_dot )
+					{
+						look_loc = loc;
+						max_dot = dot;
+					}
+					//spots[spots.size] = loc;
+				
+				}
+			}
+
+			if ( isdefined( look_loc ) )
+			{
+				spots[ spots.size ] = look_loc;
+			
+			}
+
+			if ( spots.size <= 0 )
+			{
+				spots[spots.size] = level.zm_loc_types[ "zombie_location" ][0];
+				iprintln( "no spawner in view" );
+			}
+		}
+
+	assert( spots.size > 0, "No spawn locations found" );
+	
+	if( isdefined(level.zm_custom_spawn_location_selection) )
+	{
+		spot = [[level.zm_custom_spawn_location_selection]](spots);
+	}
+	else
+	{
+		spot = array::random(spots);
+	}
+	self.spawn_point = spot;
+	
+	
+	self thread [[level.move_spawn_func]](spot);
+}
+
+function draw_zone_spawned_from()
+{
+}
+
+
+function do_zombie_rise(spot)
+{	
+	self endon("death");
+
+	self.in_the_ground = true;
+
+	if ( IsDefined( self.anchor ) )
+	{
+		self.anchor Delete();
+	}
+	
+	self.anchor = spawn("script_origin", self.origin);
+	self.anchor.angles = self.angles;
+	self linkto(self.anchor);
+
+	if( !isDefined( spot.angles ) )
+	{
+		spot.angles = (0, 0, 0);
+	}
+
+	anim_org = spot.origin;
+	anim_ang = spot.angles;
+
+	anim_org = anim_org + (0, 0, 0);	// start the animation 45 units below the ground
+
+	//self Teleport(anim_org, anim_ang);
+
+	self Ghost();
+	self.anchor moveto(anim_org, .05);
+	self.anchor waittill("movedone");
+
+	// face goal
+	target_org = zombie_utility::get_desired_origin();
+	if (IsDefined(target_org))
+	{
+		anim_ang = VectorToAngles(target_org - self.origin);
+		self.anchor RotateTo((0, anim_ang[1], 0), .05);
+		self.anchor waittill("rotatedone");
+	}
+
+	self unlink();
+	
+	if(isDefined(self.anchor))
+	{
+		self.anchor delete();
+	}
+
+	self thread zombie_utility::hide_pop();	// hack to hide the pop when the zombie gets to the start position before the anim starts
+
+	level thread zombie_utility::zombie_rise_death(self, spot);
+	spot thread zombie_rise_fx(self);
+
+	substate = 0;
+	if ( self.zombie_move_speed == "walk" )
+	{
+		substate = RandomInt( 2 );
+	}
+	else if ( self.zombie_move_speed == "run" )
+	{
+		substate = 2;
+	}
+	else if ( self.zombie_move_speed == "sprint" )
+	{
+		substate = 3;
+	}
+
+	self OrientMode( "face default" );
+	
+	if( isdefined( level.custom_riseanim ) )
+	{
+		self AnimScripted( "rise_anim", self.origin, spot.angles, level.custom_riseanim );	
+	}
+	else if( isdefined( level.custom_rise_func ) ) 
+	{
+		self [[ level.custom_rise_func ]]( spot );
+	}		
+	else
+	{
+		self AnimScripted( "rise_anim", self.origin, spot.angles, "ai_zombie_traverse_ground_climbout_fast" );		
+	}
+	//self AnimScripted( self.origin, spot.angles, "zm_rise", substate );
+	self zombie_shared::DoNoteTracks( "rise_anim", &zombie_utility::handle_rise_notetracks, spot );
+
+	self notify("rise_anim_finished");
+	spot notify("stop_zombie_rise_fx");
+	self.in_the_ground = false;
+	self notify("risen", spot.script_string );
+}
+
+/*
+function zombie_rise_fx:	 self is the script struct at the rise location
+function Play the fx as the zombie crawls out of the ground and thread another function to handle the dust falling
+function off when the zombie is out of the ground.
+*/
+function zombie_rise_fx(zombie)
+{
+	
+	if(!IS_TRUE(level.riser_fx_on_client))
+	{
+		self thread zombie_rise_dust_fx(zombie);
+		self thread zombie_rise_burst_fx(zombie);
+	}
+	else
+	{
+		self thread zombie_rise_burst_fx(zombie);
+	}
+	zombie endon("death");
+	self endon("stop_zombie_rise_fx");
+	wait 1;
+	if (zombie.zombie_move_speed != "sprint")
+	{
+		// wait longer before starting billowing fx if it's not a really fast animation
+		wait 1;
+	}
+}
+
+function zombie_rise_burst_fx(zombie)
+{
+	self endon("stop_zombie_rise_fx");
+	self endon("rise_anim_finished");
+	
+	if(IsDefined(self.script_parameters) && self.script_parameters == "in_water" && (!IS_TRUE(level._no_water_risers)) )
+	{
+			zombie clientfield::set("zombie_riser_fx_water", 1);
+	}
+	else if(IsDefined(self.script_parameters) && self.script_parameters == "in_foliage" && (IS_TRUE(level._foliage_risers)) )
+	{
+			zombie clientfield::set("zombie_riser_fx_foliage", 1);
+	}
+	else if(IsDefined(self.script_parameters) && self.script_parameters == "in_snow")
+	{
+	
+		// this needs to have "level.riser_type = "snow" set in the level script to work properly in snow levels!
+		zombie clientfield::set("zombie_riser_fx", 1);
+	}
+	else 
+	{
+		if(isDefined(zombie.zone_name ) && isDefined(level.zones[zombie.zone_name]) )
+		{
+			low_g_zones = getentarray(zombie.zone_name,"targetname");
+			
+			if(isDefined(low_g_zones[0].script_string) && low_g_zones[0].script_string == "lowgravity")
+			{
+				zombie clientfield::set("zombie_riser_fx_lowg", 1);
+			}
+			else
+			{
+
+				zombie clientfield::set("zombie_riser_fx", 1);
+
+			}
+		}
+		else
+		{
+
+			zombie clientfield::set("zombie_riser_fx", 1);
+
+		}
+	}	
+}
+
+function zombie_rise_dust_fx(zombie)
+{
+	dust_tag = "J_SpineUpper";
+	
+	self endon("stop_zombie_rise_dust_fx");
+	self thread stop_zombie_rise_dust_fx(zombie);
+	wait(2);
+	dust_time = 5.5; // play dust fx for a max time
+	dust_interval = .3; //randomfloatrange(.1,.25); // wait this time in between playing the effect
+	
+	//TODO - add rising dust stuff ere
+	if(IsDefined(self.script_parameters) && self.script_parameters == "in_water")
+	{
+
+		for (t = 0; t < dust_time; t += dust_interval)
+		{
+			PlayfxOnTag(level._effect["rise_dust_water"], zombie, dust_tag);
+			wait dust_interval;
+		}
+
+	}
+	else if(IsDefined(self.script_parameters) && self.script_parameters == "in_snow")
+	{
+
+		for (t = 0; t < dust_time; t += dust_interval)
+		{
+			PlayfxOnTag(level._effect["rise_dust_snow"], zombie, dust_tag);
+			wait dust_interval;
+		}
+
+	}
+	else if(IsDefined(self.script_parameters) && self.script_parameters == "in_foliage")
+	{
+
+		for (t = 0; t < dust_time; t += dust_interval)
+		{
+			PlayfxOnTag(level._effect["rise_dust_foliage"], zombie, dust_tag);
+			wait dust_interval;
+		}
+
+	}
+	else
+	{
+		for (t = 0; t < dust_time; t += dust_interval)
+		{
+		PlayfxOnTag(level._effect["rise_dust"], zombie, dust_tag);
+		wait dust_interval;
+		}
+	}
+}
+
+function stop_zombie_rise_dust_fx(zombie)
+{
+	zombie waittill("death");
+	self notify("stop_zombie_rise_dust_fx");
+}
+
+// for now only regular zombies can head gib from the tesla
+function zombie_tesla_head_gib()
+{
+	self endon("death");
+	
+	if(self.animname == "quad_zombie")
+	{
+		return;
+	}	
+	
+	if( RandomInt( 100 ) < level.zombie_vars["tesla_head_gib_chance"] )
+	{
+		wait( randomfloatrange( 0.53, 1.0 ) );
+		self zombie_utility::zombie_head_gib();
+	}
+	else
+	{
+		zm_net::network_safe_play_fx_on_tag( "tesla_death_fx", 2, level._effect["tesla_shock_eyes"], self, "J_Eyeball_LE" );
+	}
+}
+
+function play_ambient_zombie_vocals()
+{
+    self endon( "death" );
+    
+    while(1)
+    {
+        type = "ambient";
+        float = 4;
+        
+        if( isdefined( self.zombie_move_speed ) )
+        {
+	        switch(self.zombie_move_speed)
+		    {
+				case "walk":    type="ambient"; float=4;    break;
+				case "run":     type="sprint";  float=4;    break;
+				case "sprint":  type="sprint";  float=4;    break;
+			}
+        }
+		
+		if( self.animname == "zombie" && self.missingLegs )
+		{
+		    type = "crawler";
+		}
+		else if( self.animname == "thief_zombie" || self.animname == "leaper_zombie" )
+		{
+		    float = 1.2;
+		}
+		else if( self.voicePrefix == "keeper" )
+		{
+		    float = 1.2;
+		}
+		
+		name = self.animname;
+		if( isdefined( self.sndname ) )
+		{
+			name = self.sndname;
+		}
+		
+		
+		self notify( "bhtn_action_notify", type );
+		
+		wait(RandomFloatRange(1,float));
+    }
+}
+
+function zombie_complete_emerging_into_playable_area()
+{
+	self.should_turn = false;
+	self.completed_emerging_into_playable_area = true;
+	self.no_powerups = false;
+	self notify( "completed_emerging_into_playable_area" );
+	if( IsDefined( self.backedUpGoal ) )
+	{
+		self SetGoal( self.backedUpGoal );
+		self.backedUpGoal = undefined;
+	}
+	self thread zombie_free_cam_allowed();
+	self thread zombie_push();
+	self thread zm::update_zone_name();
+}
+
+function zombie_free_cam_allowed()
+{
+	self endon( "death" );
+
+	wait( 1.5 );
+	if ( !IsDefined( self ) )
+	{
+		return;
+	}
+	self SetFreeCameraLockOnAllowed( true );
+}
+
+function zombie_push()
+{
+	self endon( "death" );
+
+	wait( 5 );
+	if ( !IsDefined( self ) )
+	{
+		return;
+	}
+	self PushActors( true );
+}
+
diff --git a/scripts/zm/_zm_weap_blundersplat.cscc b/scripts/zm/_zm_weap_blundersplat.cscc
old mode 100644
new mode 100755
diff --git a/scripts/zm/_zm_weap_blundersplat.gscc b/scripts/zm/_zm_weap_blundersplat.gscc
old mode 100644
new mode 100755
diff --git a/scripts/zm/_zm_weap_blundersplat.gsh b/scripts/zm/_zm_weap_blundersplat.gsh
old mode 100644
new mode 100755
index c418e73..6e53229
--- a/scripts/zm/_zm_weap_blundersplat.gsh
+++ b/scripts/zm/_zm_weap_blundersplat.gsh
@@ -1,51 +1,51 @@
-/*#===================================================================###
-###                                                                   ###
-###                                                                   ###
-###         	 Harry Bo21s Black Ops 3 Acidgat v1.0.0	  	          ###
-###                                                                   ###
-###                                                                   ###
-###===================================================================#*/
-/*=======================================================================
-
-								CREDITS
-
-=========================================================================
-Lilrifa
-Easyskanka
-ProRevenge
-DTZxPorter
-Zeroy
-StevieWonder87
-BluntStuffy
-RedSpace200
-thezombieproject
-Smasher248
-JiffyNoodles
-MZSlayer
-AndyWhelen
-HitmanVere
-ProGamerzFTW
-Scobalula
-GerardS0406
-PCModder
-IperBreach
-TomBMX
-Treyarch and Activision
-AllModz
-=======================================================================*/
-	
-// SETTINGS
-// ======================================================================================================
-#define BLUNDERGAT_WEAPONFILE					"shotgun_blundergat"
-#define BLUNDERGAT_UPGRADED_WEAPONFILE			"shotgun_blundergat_upgraded"
-#define BLUNDERSPLAT_WEAPONFILE					"shotgun_acidgat"
-#define BLUNDERSPLAT_UPGRADED_WEAPONFILE		"shotgun_acidgat_upgraded"
-#define BLUNDERSPLAT_PROJECTILE_WEAPONFILE		"shotgun_acidgat_bullet"
-	
-// FX
-// ======================================================================================================
-#define SLIPGUN_AOE_FX							"harry/sliquifier/fx_sliquifier_aoe"
-#define SLIPGUN_EXPLODE_FX						"harry/sliquifier/fx_sliquifier_explode"
-#define SLIPGUN_SIZZLE_FX						"harry/sliquifier/fx_sliquifier_sizzle"
-
-
+/*#===================================================================###
+###                                                                   ###
+###                                                                   ###
+###         	 Harry Bo21s Black Ops 3 Acidgat v1.0.0	  	          ###
+###                                                                   ###
+###                                                                   ###
+###===================================================================#*/
+/*=======================================================================
+
+								CREDITS
+
+=========================================================================
+Lilrifa
+Easyskanka
+ProRevenge
+DTZxPorter
+Zeroy
+StevieWonder87
+BluntStuffy
+RedSpace200
+thezombieproject
+Smasher248
+JiffyNoodles
+MZSlayer
+AndyWhelen
+HitmanVere
+ProGamerzFTW
+Scobalula
+GerardS0406
+PCModder
+IperBreach
+TomBMX
+Treyarch and Activision
+AllModz
+=======================================================================*/
+	
+// SETTINGS
+// ======================================================================================================
+#define BLUNDERGAT_WEAPONFILE					"bo2_blundergat"
+#define BLUNDERGAT_UPGRADED_WEAPONFILE			"bo2_blundergat_upgraded"
+#define BLUNDERSPLAT_WEAPONFILE					"bo2_acidgat"
+#define BLUNDERSPLAT_UPGRADED_WEAPONFILE		"bo2_acidgat_upgraded"
+#define BLUNDERSPLAT_PROJECTILE_WEAPONFILE		"bo2_acidgat_bullet"
+	
+// FX
+// ======================================================================================================
+#define SLIPGUN_AOE_FX							"harry/sliquifier/fx_sliquifier_aoe"
+#define SLIPGUN_EXPLODE_FX						"harry/sliquifier/fx_sliquifier_explode"
+#define SLIPGUN_SIZZLE_FX						"harry/sliquifier/fx_sliquifier_sizzle"
+
+
diff --git a/scripts/zm/zm_alcatraz_amb.csc b/scripts/zm/zm_alcatraz_amb.csc
index 8af6449..eadcf3b 100644
--- a/scripts/zm/zm_alcatraz_amb.csc
+++ b/scripts/zm/zm_alcatraz_amb.csc
@@ -231,7 +231,7 @@ function snddefendeventscreams()
 	while(1)
 	{
 		level waittill( "sndFF" );
-		PlaySound( 0, "zmb_easteregg_scream", ( 2233, 10345, 1224 ) );
+		PlaySound( 0, "zmb_afterlife_end", ( 2233, 10345, 1224 ) );
 		wait 1;
 		PlaySound( 0, "zmb_easteregg_laugh", ( 1597, 10068, 1228 ) );
 	}
diff --git a/scripts/zm/zm_alcatraz_amb.gsc b/scripts/zm/zm_alcatraz_amb.gsc
index b79651b..b4b8012 100644
--- a/scripts/zm/zm_alcatraz_amb.gsc
+++ b/scripts/zm/zm_alcatraz_amb.gsc
@@ -52,12 +52,15 @@
 function autoexec main()
 {
 	level flag::wait_till( "initial_players_connected" );
-	level.sndperksacolaloopoverride = &sndperksacolaloop;
+	level thread cellblockambience();
+	//level.sndperksacolaloopoverride = &sndperksacolaloop;
 	level.sndperksacolajingleoverride = &sndperksacolajingle;
 	thread sndstingersetup();
 	thread sndlastlifesetup();
 	thread sndsetupendgamemusicstates();
 	thread sndspectatorsetup();
+	thread create_fire();
+	thread create_misc_amb();
 	//thread sndmusicegg();
 }
 
@@ -108,19 +111,20 @@ function sndperksacolajingle( perksacola )
 	if ( self.jingle_is_playing == 0 && level.music_override == 0 )
 	{
 		self.jingle_is_playing = 1;
-		self.sndent StopLoopSound( 1 );
+		//self.sndent StopLoopSound( 1 );
 		self.sndent PlaySoundWithNotify( self.script_sound, "sndJingleDone" );
 		self.sndent waittill( "sndJingleDone" );
-		self.sndent PlayLoopSound( "mus_perks_loop", 1 );
+		//self.sndent PlayLoopSound( "mus_perks_loop", 1 );
 		self.jingle_is_playing = 0;
 	}
 }
 
 function sndperksacolaloop()
 {
+	IPrintLnBold("playing phone loop shit");
 	self endon( "death" );
 	self.sndent = Spawn( "script_origin", self.origin );
-	self.sndent PlayLoopSound( "mus_perks_loop", 1 );
+	self.sndent PlayLoopSound( "perksacola_loop", 1 );
 	while ( 1 )
 	{
 		wait RandomFloatRange( 31, 45 );
@@ -800,4 +804,144 @@ function is_true(thing)
 		return 1;
 	else
 		return 0;
+}
+
+//
+// ambience
+//
+
+function cellblockambience()
+{
+	ambientEnt = Spawn("script_origin", (0, 0, 0));
+	ambientEnt.targetname = "ambient_tracker";
+	wait 10;
+	ambientEnt thread ambient_checker();
+	ambientEnt thread ambience_chains();
+	wait 2;
+	ambientEnt thread ambient_underscore();
+	ambientEnt thread ambience_thunder();
+}
+
+function ambient_underscore()
+{
+	//IPrintLnBold("starting underscore..");
+	for(;;)
+	{
+		sound = "mus_alcatraz_underscore";
+		self PlaySoundWithNotify(sound, sound + "wait");
+		self waittill (sound + "wait");
+		wait(0.05);
+	}
+}
+
+function ambient_checker()
+{
+	for(;;)
+	{
+		foreach(player in GetPlayers())
+		{
+			current_zone = player zm_zonemgr::get_player_zone();
+			//IPrintLnBold("got player: " + player.name + " | in zone: " + current_zone);
+
+			if (current_zone == "start_zone" || current_zone == "library_zone" || current_zone == "cellblock_rightside_zone" || current_zone == "cellblock_leftside_zone" || current_zone == "cellblock_hallway_zone" || current_zone == "cellblock_out_wardens_zone" || current_zone == "ug_docks_zone" || current_zone == "gondola_roof_zone" || current_zone == "top_dogfeeder_zone_b" || current_zone == "top_dogfeeder_zone_d" || current_zone == "cafe_stair_zone" || current_zone == "cellblock_dogfeeder_zone" || current_zone == "cellblock_dogfeeder_zone_b" || current_zone == "cellblock_dogfeeder_zone_c")
+			{
+				player.can_hear_thunder = true;
+				player.can_hear_chains = true;
+			}	
+			else if (current_zone == "cellblock_leftside_zone_b" || current_zone == "wardens_zone" || current_zone == "cellblock_out_wardens_zone_b" || current_zone == "underground_wo_zone" || current_zone == "underground_zone_c" || current_zone == "ug_docks_zone_c" || current_zone == "ug_docks_zone_d" || current_zone == "ug_docks_zone_e" || current_zone == "upper_docks_zone" || current_zone == "docks_zone" || current_zone == "docks_zone_c" || current_zone == "top_dogfeeder_zone_e" || current_zone == "infirmary_zone" || current_zone == "roof_zone")
+			{
+				player.can_hear_thunder = true;
+				player.can_hear_chains = false;
+			}
+			else if (current_zone == "shower_zone" || current_zone == "tunnel_zone_c" || current_zone == "infirmary_zone_b")
+			{
+				player.can_hear_thunder = false;
+				player.can_hear_chains = true;
+			}
+			else
+			{
+				player.can_hear_thunder = false;
+				player.can_hear_chains = false;
+			}
+		}
+		wait 3;
+	}
+}
+
+function ambience_chains()
+{
+	while(1)
+	{
+		//IPrintLnBold("running");
+		foreach(player in GetPlayers())
+		{
+			// no ambience in afterlife!
+			/*if (is_true(player.afterlife))
+				return;*/
+
+			if (is_true(player.can_hear_chains)) {
+				chain_num = RandomIntRange( 0, 3 );
+				sound = "amb_cellblock_hanging_" + chain_num;
+				player PlaySoundToPlayer( sound, player );
+				wait 2.4;
+			}
+		}
+		wait_timer = RandomIntRange( 2, 4 );
+		wait wait_timer;
+	}
+
+}
+
+function ambience_thunder()
+{
+	while(1)
+	{
+		foreach(player in GetPlayers()) {
+			if (is_true(player.can_hear_thunder)) {
+				thunder_num = RandomIntRange( 0, 5 );
+				sound = "amb_thunder_clap_" + thunder_num;
+				player PlaySoundToPlayer( sound, player );
+				wait 5;
+			}
+		}
+		wait_timer = RandomIntRange( 1, 15 );
+		wait wait_timer;
+	}
+
+}
+
+function create_fire()
+{
+	fire1 = Spawn("script_origin", (1666, -218, 5613));
+	fire1 PlayLoopSound("amb_hellfire");
+
+	fire2 = Spawn("script_origin", (1311, 145, 5615));
+	fire2 PlayLoopSound("amb_hellfire");
+
+	fire3 = Spawn("script_origin", (889, -20, 5607));
+	fire3 PlayLoopSound("amb_hellfire");
+
+	fire4 = Spawn("script_origin", (2108, -577, 5638));
+	fire4 PlayLoopSound("amb_hellfire");
+
+	fire5 = Spawn("script_origin", (1750, -700, 5607));
+	fire5 PlayLoopSound("amb_hellfire");
+
+	fire6 = Spawn("script_origin", (1746, -1247, 5612));
+	fire6 PlayLoopSound("amb_hellfire");
+}
+
+function create_misc_amb()
+{
+	nixie_loop = Spawn("script_origin", (70, -2108, 4560));
+	nixie_loop thread nixie_do_loop();
+}
+
+function nixie_do_loop()
+{
+	for(;;)
+	{
+		PlaySoundAtPosition("nixie_loop", self.origin);
+		wait 0.25;
+	}
 }
\ No newline at end of file
diff --git a/scripts/zm/zm_alcatraz_craftables.csc b/scripts/zm/zm_alcatraz_craftables.csc
index fcef513..ec5b0e5 100644
--- a/scripts/zm/zm_alcatraz_craftables.csc
+++ b/scripts/zm/zm_alcatraz_craftables.csc
@@ -34,6 +34,7 @@ function include_craftables()
 function register_clientfields()
 {
 	visionset_mgr::register_visionset_info( "afterlife", 9000, 1, "afterlife", "afterlife" );
+
 	//visionset_mgr::register_overlay_info_style_filter( "afterlife_filter", 9000, 1, 5, 0, "generic_filter_afterlife_alcatraz" );
 
 	bits = 1;
diff --git a/scripts/zm/zm_alcatraz_craftables.gsc b/scripts/zm/zm_alcatraz_craftables.gsc
index 9f53250..2c4dff1 100644
--- a/scripts/zm/zm_alcatraz_craftables.gsc
+++ b/scripts/zm/zm_alcatraz_craftables.gsc
@@ -364,7 +364,7 @@ function onpickup_plane( player ) {
 		level thread zm_alcatraz_amb::sndplaystinger( "piece_" + level.sndplanepieces );
 		level.sndplanepieces++;
 	}
-	player PlaySound( "zmb_craftable_pickup" );
+	//player PlaySound( "zmb_craftable_pickup" );
 	vo_alias_call = undefined;
 	vo_alias_response = undefined;
 	self pickupfrommover();
@@ -600,101 +600,116 @@ function fuel_hud_on_crafted() {
 }
 
 function ondrop_fuel( player ) {
-	level notify( "dropped_" + self.piecename );
-	self.piece_owner = undefined;
-	PlayFXOnTag( level._effect[ "quest_item_glow" ], self.model, "tag_origin" );
-	if ( isdefined( level.sndfuelpieces ) ) {
-		level.sndfuelpieces--;
-	}
-	switch( self.piecename ) {
-		case "fuel1":
-			field_name = "quest_state1";
-			break;
-		case "fuel2":
-			field_name = "quest_state2";
-			break;
-		case "fuel3":
-			field_name = "quest_state3";
-			break;
-		case "fuel4":
-			field_name = "quest_state4";
-			break;
-		case "fuel5":
-			field_name = "quest_state5";
-			break;
-	}
-	level clientfield::set( field_name, 5 );
-	if ( !level.is_forever_solo_game || GetPlayers().size > 1) {
-		level clientfield::set( "piece_player_" + self.piecename, 0 );
-	}
+    level notify( "dropped_" + self.piecename );
+    self.piece_owner = undefined;
+    PlayFXOnTag( level._effect[ "quest_item_glow" ], self.model, "tag_origin" );
+    if ( isdefined( level.sndfuelpieces ) ) {
+        level.sndfuelpieces--;
+    }
+    switch( self.piecename ) {
+        case "fuel1":
+            field_name = "quest_state1";
+            piece_name = "cloth";
+            break;
+        case "fuel2":
+            field_name = "quest_state2";
+            piece_name = "fueltanks";
+            break;
+        case "fuel3":
+            field_name = "quest_state3";
+            piece_name = "engine";
+            break;
+        case "fuel4":
+            field_name = "quest_state4";
+            piece_name = "steering";
+            break;
+        case "fuel5":
+            field_name = "quest_state5";
+            piece_name = "rigging";
+            break;
+    }
+    level clientfield::set( field_name, 5 );
+    if ( !level.is_forever_solo_game || GetPlayers().size > 1) {
+        level clientfield::set( "piece_player_" + piece_name, 0 );
+    }
 }
-
+ 
 function onpickup_fuel( player ) {
-	player PlaySound( "zmb_craftable_pickup" );
-	if ( !isdefined( level.sndfuelpieces ) || level.sndfuelpieces >= 5 ) {
-		level.sndfuelpieces = 0;
-	}
-	level.sndfuelpieces++;
-	level thread zm_alcatraz_amb::sndplaystinger( "gas_" + level.sndfuelpieces );
-	self pickupfrommover();
-	self.piece_owner = player;
-	if ( isdefined( player ) ) {
-		player zm_utility::do_player_general_vox( "quest", "fuel_pickup", undefined, 100 );
-	}
-	switch( self.piecename ) {
-		case "fuel1":
-			field_name = "quest_state1";
-			break;
-		case "fuel2":
-			field_name = "quest_state2";
-			break;
-		case "fuel3":
-			field_name = "quest_state3";
-			break;
-		case "fuel4":
-			field_name = "quest_state4";
-			break;
-		case "fuel5":
-			field_name = "quest_state5";
-			break;
-	}
-	level thread zm_alcatraz_hud_buildables::players_hud_fuel(self);
-	level clientfield::set( field_name, 6 );
-	if ( !level.is_forever_solo_game || GetPlayers().size > 1) {
-		level clientfield::set( "piece_player_" + self.piecename, player.characterIndex + 1 );
-	}
-	self thread ondisconnect_common( player );
+    //player PlaySound( "zmb_craftable_pickup" );
+    if ( !isdefined( level.sndfuelpieces ) || level.sndfuelpieces >= 5 ) {
+        level.sndfuelpieces = 0;
+    }
+    level.sndfuelpieces++;
+    level thread zm_alcatraz_amb::sndplaystinger( "gas_" + level.sndfuelpieces );
+    self pickupfrommover();
+    self.piece_owner = player;
+    if ( isdefined( player ) ) {
+        player zm_utility::do_player_general_vox( "quest", "fuel_pickup", undefined, 100 );
+    }
+    switch( self.piecename ) {
+        case "fuel1":
+            field_name = "quest_state1";
+            piece_name = "cloth";
+            break;
+        case "fuel2":
+            field_name = "quest_state2";
+            piece_name = "fueltanks";
+            break;
+        case "fuel3":
+            field_name = "quest_state3";
+            piece_name = "engine";
+            break;
+        case "fuel4":
+            field_name = "quest_state4";
+            piece_name = "steering";
+            break;
+        case "fuel5":
+            field_name = "quest_state5";
+            piece_name = "rigging";
+            break;
+    }
+    level thread zm_alcatraz_hud_buildables::players_hud_fuel(self);
+    level clientfield::set( field_name, 6 );
+    if ( !level.is_forever_solo_game || GetPlayers().size > 1) {
+        level clientfield::set( "piece_player_" + piece_name, player.characterIndex + 1 );
+    }
+    self thread ondisconnect_common( player );
 }
-
+ 
 function oncrafted_fuel( player ) {
-	level notify( "crafted_" + self.piecename );
-	level.n_plane_fuel_count++;
-	switch( self.piecename ) {
-		case "fuel1":
-			field_name = "quest_state1";
-			level.plane_fuel1_built = true;
-			break;
-		case "fuel2":
-			field_name = "quest_state2";
-			level.plane_fuel2_built = true;
-			break;
-		case "fuel3":
-			field_name = "quest_state3";
-			level.plane_fuel3_built = true;
-			break;
-		case "fuel4":
-			field_name = "quest_state4";
-			level.plane_fuel4_built = true;
-			break;
-		case "fuel5":
-			field_name = "quest_state5";
-			level.plane_fuel5_built = true;
-			break;
-	}
-	level clientfield::set( field_name, 7 );
-	if ( !level.is_forever_solo_game || GetPlayers().size > 1) {
-		level clientfield::set( "piece_player_" + self.piecename, 0 );
-	}
+    level notify( "crafted_" + self.piecename );
+    level.n_plane_fuel_count++;
+    switch( self.piecename ) {
+        case "fuel1":
+            field_name = "quest_state1";
+            piece_name = "cloth";
+            level.plane_fuel1_built = true;
+            break;
+        case "fuel2":
+            field_name = "quest_state2";
+            piece_name = "fueltanks";
+            level.plane_fuel2_built = true;
+            break;
+        case "fuel3":
+            field_name = "quest_state3";
+            piece_name = "engine";
+            level.plane_fuel3_built = true;
+            break;
+        case "fuel4":
+            field_name = "quest_state4";
+            piece_name = "steering";
+            level.plane_fuel4_built = true;
+            break;
+        case "fuel5":
+            field_name = "quest_state5";
+            piece_name = "rigging";
+            level.plane_fuel5_built = true;
+            break;
+    }
+    level clientfield::set( field_name, 7 );
+    if ( !level.is_forever_solo_game || GetPlayers().size > 1) {
+        level clientfield::set( "piece_player_" + piece_name, 0 );
+    }
 }
 
 function onfullycrafted_plane( player ) {
diff --git a/scripts/zm/zm_alcatraz_island.gsc b/scripts/zm/zm_alcatraz_island.gsc
index 2e65c63..e7fbc81 100644
--- a/scripts/zm/zm_alcatraz_island.gsc
+++ b/scripts/zm/zm_alcatraz_island.gsc
@@ -157,6 +157,8 @@ function main()
 
     zm_usermap::main();
 
+    level zm_usermap::perk_init();
+
     callback::on_spawned(&give_knife);
 
     callback::on_spawned( &bo2_deathhands );
@@ -164,6 +166,7 @@ function main()
     
     startingWeapon = "bo3_m1911";
     weapon = getWeapon(startingWeapon);
+    level.easter_egg_completed = false;
     level.start_weapon = (weapon);
     level._zombie_custom_add_weapons =&custom_add_weapons;
     
@@ -197,6 +200,19 @@ function main()
     level thread zm_perks::spare_change();
     level thread permapowerup();
     level thread fix_door_sounds();
+    level thread gondola_poi();
+
+    /*foreach(player in GetPlayers())
+    {
+        VisionSetNaked("zm_alcatraz_cellblock", 0);
+        player.vision_updated = 1;
+    }*/
+}
+
+function gondola_poi()
+{
+    gondola_point = Spawn( "script_origin", (545.878, -2324.34, 5824.69) );
+    gondola_point.targetname = "gondola_poi";
 }
 
 function fix_door_sounds()
diff --git a/scripts/zm/zm_alcatraz_perks.gsc b/scripts/zm/zm_alcatraz_perks.gsc
index ab06bb2..0cd4ab3 100644
--- a/scripts/zm/zm_alcatraz_perks.gsc
+++ b/scripts/zm/zm_alcatraz_perks.gsc
@@ -33,6 +33,7 @@
 #insert scripts\zm\_zm_perk_deadshot.gsh;
 #insert scripts\zm\_zm_perk_electric_cherry.gsh;
 
+// warp models (FIXME - need cherry and stamin warp)
 #precache( "xmodel", "p7_zm_vending_jugg_bo3_warp" );
 #precache( "xmodel", "p7_zm_vending_sleight_bo3_warp" );
 #precache( "xmodel", "p7_zm_vending_doubletap2_bo3_warp" );
@@ -53,7 +54,7 @@ function autoexec init()
 function jugg_warp_init()
 {
 	level waittill("juggernog_on");
-	self PlayLoopSound("perksacola_loop");
+	//self PlayLoopSound("perksacola_loop", 1);
 	jugg_model = GetEntArray("vending_jugg","targetname");
 	for ( i = 0; i < jugg_model.size; i++ )
 	{
@@ -64,7 +65,7 @@ function jugg_warp_init()
 function speed_warp_init()
 {
 	level waittill("sleight_on");
-	self PlayLoopSound("perksacola_loop");
+	//self PlayLoopSound("perksacola_loop", 1);
 	speed_model = GetEntArray("vending_sleight","targetname");
 	for ( i = 0; i < speed_model.size; i++ )
 	{
@@ -75,7 +76,7 @@ function speed_warp_init()
 function tap_warp_init()
 {
 	level waittill("doubletap_on");
-	self PlayLoopSound("perksacola_loop");
+	//self PlayLoopSound("perksacola_loop", 1);
 	tap_model = GetEntArray(DOUBLETAP2_RADIANT_MACHINE_NAME,"targetname");
 	for ( i = 0; i < tap_model.size; i++ )
 	{
@@ -86,7 +87,7 @@ function tap_warp_init()
 function ads_warp_init()
 {
 	level waittill("deadshot_on");
-	self PlayLoopSound("perksacola_loop");
+	//self PlayLoopSound("perksacola_loop", 1);
 	ads_model = GetEntArray(DEADSHOT_RADIANT_MACHINE_NAME,"targetname");
 	for ( i = 0; i < ads_model.size; i++ )
 	{
@@ -97,7 +98,7 @@ function ads_warp_init()
 function cherry_warp_init()
 {
 	level waittill("electric_cherry_on");
-	self PlayLoopSound("perksacola_loop");
+	//self PlayLoopSound("perksacola_loop", 1);
 	cherry_model = GetEntArray(ELECTRIC_CHERRY_RADIANT_MACHINE_NAME,"targetname");
 	for ( i = 0; i < cherry_model.size; i++ )
 	{
diff --git a/scripts/zm/zm_alcatraz_sq.gsc b/scripts/zm/zm_alcatraz_sq.gsc
index 680608f..102dfd6 100644
--- a/scripts/zm/zm_alcatraz_sq.gsc
+++ b/scripts/zm/zm_alcatraz_sq.gsc
@@ -374,7 +374,7 @@ function create_key_door_unitrigger( piece_num, width, height, length )
 	t_key_door.unitrigger_stub.origin = t_key_door.origin;
 	t_key_door.unitrigger_stub.angles = t_key_door.angles;
 	t_key_door.unitrigger_stub.script_unitrigger_type = "unitrigger_box_use";
-	t_key_door.unitrigger_stub.hint_string = "Need A Key";
+	t_key_door.unitrigger_stub.hint_string = "Need Warden's Key";
 	t_key_door.unitrigger_stub.cursor_hint = "HINT_NOICON";
 	t_key_door.unitrigger_stub.script_width = width;
 	t_key_door.unitrigger_stub.script_height = height;
@@ -398,7 +398,7 @@ function key_door_trigger_visibility( player )
 	self SetInvisibleToPlayer( player, b_is_invis );
 	if( level.key_found )
 	{
-		self SetHintString( "Hold ^3&&1^7 to Use Key" );
+		self SetHintString( "Hold ^3&&1^7 to open" );
 	}
 	else
 	{
@@ -625,7 +625,7 @@ function setup_dryer_challenge()
 {
 	t_dryer = GetEnt( "dryer_trigger", "targetname" );
 	t_dryer SetCursorHint( "HINT_NOICON" );
-	t_dryer SetHintString( "Hold ^3&&1^7 to Activate Dryer" );
+	t_dryer SetHintString( "Hold ^3&&1^7 to activate Laundry Machine" );
 	t_dryer thread dryer_trigger_thread();
 	t_dryer thread dryer_zombies_thread();
 	t_dryer TriggerEnable(false);
@@ -634,7 +634,8 @@ function setup_dryer_challenge()
 	IPrintLnBold( "dryer can now be activated" );
 #/
 	t_dryer TriggerEnable(true);
-	t_dryer PlaySound( "evt_dryer_rdy_bell" );
+	PlaySoundAtPosition("evt_dryer_rdy_bell", t_dryer.origin);
+	//t_dryer PlaySound( "evt_dryer_rdy_bell" );
 	wait 1;
 	players = GetPlayers();
 	_a900 = players;
@@ -664,7 +665,23 @@ function dryer_trigger_thread()
 	n_dryer_cycle_duration = 30;
 	a_dryer_spawns = [];
 	sndent = Spawn( "script_origin", ( 1613, 10599, 1203 ) );
-	self waittill( "trigger" );
+
+	can_activate = 0;
+
+	while(can_activate == 0)
+	{
+		self waittill( "trigger", player );
+
+		if ( isdefined( player.afterlife ) && player.afterlife )
+		{
+			can_activate = 0;
+		}
+		else
+		{
+			can_activate = 1;
+		}
+	}
+
 	self TriggerEnable(false);
 	level.fog_fx_laundry = [];
 	level thread spawn_laundry_fog();
@@ -673,6 +690,11 @@ function dryer_trigger_thread()
 	dryer_playerclip = GetEnt( "dryer_playerclip", "targetname" );
 	dryer_playerclip MoveTo( dryer_playerclip.origin + vectorScale( ( 0, 0, 0 ), 104 ), 0.05 );
 
+	// laugh and al death (notifier)
+	//level.zmb_laugh_alias
+	player PlaySoundToPlayer( "zmb_spooky_laugh", player );
+	player PlaySoundToPlayer( "zmb_afterlife_end", player );
+
 	collision1 = Spawn("script_model", (2079, -1370, 5607), 1);
 	collision1 SetModel("zm_collision_perks1");
 	collision1.script_noteworthy = "clip";
@@ -699,9 +721,10 @@ function dryer_trigger_thread()
 		level thread zm_alcatraz_amb::sndplaystinger( "laundry_defend" );
 	//}
 	exploder::exploder( 1000 );
-	sndent thread snddryercountdown( n_dryer_cycle_duration );
-	sndent PlaySound( "evt_dryer_start" );
-	sndent PlayLoopSound( "evt_dryer_lp" );
+	self thread snddryercountdown( n_dryer_cycle_duration );
+	PlaySoundAtPosition("evt_dryer_start", self.origin);
+	//sndent PlaySound( "evt_dryer_start" );
+	self PlayLoopSound( "evt_dryer_lp" );
 	level util::clientnotify( "fxanim_dryer_start" );
 	level flag::set( "dryer_cycle_active" );
 	wait (GetAnimLength( %fxanim_zom_al_industrial_dryer_start_anim ));
@@ -725,8 +748,9 @@ function dryer_trigger_thread()
 	dryer_playerclip = GetEnt( "dryer_playerclip", "targetname" );
 	dryer_playerclip Delete();
 	level thread delete_laundry_fog();
-	sndent StopLoopSound();
-	sndent PlaySound( "evt_dryer_stop" );
+	self StopLoopSound();
+	PlaySoundAtPosition("evt_dryer_stop", self.origin);
+	//sndent PlaySound( "evt_dryer_stop" );
 	if ( isdefined( sndset ) && sndset )
 	{
 		level.music_override = 0;
@@ -952,11 +976,13 @@ function snddryercountdown( num )
 	{
 		if ( i <= 10 )
 		{
-			ent PlaySound( "zmb_quest_nixie_count_final" );
+			PlaySoundAtPosition( "zmb_quest_nixie_count_final", ent.origin );
+			//ent PlaySound( "zmb_quest_nixie_count_final" );
 		}
 		else
 		{
-			ent PlaySound( "zmb_quest_nixie_count" );
+			PlaySoundAtPosition( "dryer_click", ent.origin );
+			//ent PlaySound( "zmb_quest_nixie_count" );
 		}
 		wait 1;
 		i--;
@@ -1165,7 +1191,7 @@ function toggle_inner_gate( n_gate_move_duration )
 function plane_fly_trigger_thread()
 {
 	self SetCursorHint( "HINT_NOICON" );
-	self SetHintString( "Hold ^3&&1^7 to takeoff plane" );
+	self SetHintString( "Hold ^3&&1^7 to Board Plane" );
 	//level flag::wait_till( "initial_players_connected" );
 	//flag::wait_till( "brutus_setup_complete" );
 	self TriggerEnable(false);
@@ -1174,7 +1200,7 @@ function plane_fly_trigger_thread()
 	//IPrintLnBold("hide plane");
 	m_plane_craftable = GetEnt( "plane_craftable", "targetname" );
 	m_plane_craftable Show();
-	m_plane_craftable HidePart( "tag_support_upper" );
+	/*m_plane_craftable HidePart( "tag_support_upper" );
 	m_plane_craftable HidePart( "tag_wing_skins_up" );
 	m_plane_craftable HidePart( "tag_engines_up" );
 	m_plane_craftable HidePart( "tag_feul_tanks" );
@@ -1182,7 +1208,7 @@ function plane_fly_trigger_thread()
 	m_plane_craftable HidePart( "tag_engine_ground" );
 	m_plane_craftable HidePart( "tag_clothes_ground" );
 	m_plane_craftable HidePart( "tag_fuel_hose" );
-	level waittill("plane_fully_build");
+	level waittill("plane_fully_build");*/
 	//IPrintLnBold("plane crafted");
 	zm_ai_brutus::transfer_plane_trigger( "build", "fly" );
 	self TriggerEnable(true);
@@ -1245,6 +1271,8 @@ function plane_boarding_thread()
 	veh_plane_flyable = GetEnt( "plane_flyable", "targetname" );
 	t_plane_fly = GetEnt( "plane_fly_trigger", "targetname" );
 	t_plane_fly SetHintString( "Hold ^3&&1^7 to Board Plane" );
+	self AllowCrouch( 1 );
+	self SetCharacterBodyStyle(1);
 	self EnableInvulnerability();
 	self PlayerLinkToDelta( m_plane_craftable, "tag_player_crouched_" + ( self.n_passenger_index + 1 ) );
 	self AllowStand( 0 );
@@ -1271,6 +1299,7 @@ function plane_boarding_thread()
 	str_current_weapon = self GetCurrentWeapon();
 	self GiveWeapon( GetWeapon("falling_hands") );
 	self SwitchToWeaponImmediate( GetWeapon("falling_hands") );
+	self SetCharacterBodyStyle(0);
 	players = GetPlayers();
 	_a1548 = players;
 	_k1548 = GetFirstArrayKey( _a1548 );
diff --git a/scripts/zm/zm_alcatraz_sq_nixie.gsc b/scripts/zm/zm_alcatraz_sq_nixie.gsc
index 9965f96..cd82af9 100644
--- a/scripts/zm/zm_alcatraz_sq_nixie.gsc
+++ b/scripts/zm/zm_alcatraz_sq_nixie.gsc
@@ -142,6 +142,7 @@ function generate_unrestricted_nixie_tube_solution()
 	a_restricted_solutions[ 4 ] = 101;
 	a_restricted_solutions[ 5 ] = 872;
 	a_restricted_solutions[ 6 ] = 666;
+	a_restricted_solutions[ 7 ] = 903;
 	a_numbers = [];
 	i = 0;
 	while ( i < 10 )
@@ -189,9 +190,11 @@ function nixie_tube_notifier()
 		level.a_important_codes[ level.a_important_codes.size ] = 115;
 		level.a_important_codes[ level.a_important_codes.size ] = 935;
 		level.a_important_codes[ level.a_important_codes.size ] = 666;
+		level.a_important_codes[ level.a_important_codes.size ] = 903;
 	}
 	level thread nixie_115();
 	level thread nixie_935();
+	level thread nixie_903();
 	level thread nixie_666();
 	while ( !isdefined( level.a_nixie_tube_code ) || !isdefined( level.a_nixie_tube_code[ 3 ] ) )
 	{
@@ -599,6 +602,18 @@ function nixie_935()
 	nixie_reset_control();
 }
 
+function nixie_903()
+{
+	level waittill( "nixie_" + 903 );
+	level notify( "kill_nixie_input" );
+	level flag::set( "nixie_puzzle_solved" );
+	level thread nixie_903_audio();
+	nixie_tube_win_effects_all_tubes( 5, 1, 1 );
+	level flag::set( "nixie_ee_flashing" );
+	level flag::clear( "nixie_puzzle_solved" );
+	nixie_reset_control();
+}
+
 function nixie_666()
 {
 	level waittill( "nixie_" + 666 );
@@ -634,6 +649,14 @@ function nixie_935_audio()
     }
 }
 
+function nixie_903_audio()
+{
+	foreach(player in GetPlayers())
+    {
+    	player PlaySoundToPlayer( "mus_zmb_secret_song_3", player );
+    }
+}
+
 function nixie_reset_control( b_reset_control )
 {
 	i = 1;
diff --git a/scripts/zm/zm_alcatraz_utility.gsc b/scripts/zm/zm_alcatraz_utility.gsc
index 9caa209..d97c342 100644
--- a/scripts/zm/zm_alcatraz_utility.gsc
+++ b/scripts/zm/zm_alcatraz_utility.gsc
@@ -37,6 +37,7 @@
 #using scripts\zm\_zm_spawner;
 #using scripts\zm\_zm_zonemgr;
 #using scripts\zm\craftables\_zm_craftables;
+#using scripts\zm\_zm_afterlife;
 
 #using scripts\zm\zm_prison_weap_quest;
 #using scripts\zm\zm_alcatraz_sq_vo;
@@ -372,6 +373,26 @@ function print_origin()
 	}
 }
 
+function body_testing()
+{
+	body = 0;
+	while(1)
+	{
+		if (body == 0)
+		{
+			IPrintLnBold("hide");
+			body = 1;
+		}
+		else
+		{
+			IPrintLnBold("show");
+			body = 0;
+		}
+		self SetCharacterBodyStyle(body);
+		wait 2;
+	}
+}
+
 function init_level_specific_audio()
 {
 	level.oh_shit_vo_cooldown = 0;
@@ -393,14 +414,21 @@ function init_level_specific_audio()
     foreach(player in GetPlayers())
 	{
         // Dev mode
-		/*if (player.name == "MotoLegacy" || player.name == "JariK") {
+		if (player.name == "MotoLegacy" || player.name == "JariK") {
 			player.score = 100000;
-			//player.af_lives = 999;
+			player.af_lives = -1;
+			player _zm_afterlife::afterlife_infinite_mana( 1 );
 			player thread print_origin();
-		}*/
+			//player thread body_testing();
+
+			//player GiveWeapon(level.weaponRiotshield);
+		}
 
 		// Fix the dumb extra 8 rounds in colt
 		player SetWeaponAmmoStock(level.start_weapon, 32);
+		wait 1;
+		player setClientUIVisibilityFlag( "hud_visible", 1 );
+		player setClientUIVisibilityFlag( "weapon_hud_visible", 1 );
 	}
     // END SPAWN FIXES
 	level notify( "Pack_A_Punch_on" );
@@ -412,96 +440,6 @@ function init_level_specific_audio()
 	level.custom_kill_damaged_vo = &zm_audio::custom_kill_damaged_vo;
 	level._custom_zombie_oh_shit_vox_func = &alcatraz_custom_zombie_oh_shit_vox;
 	level.gib_on_damage = &alcatraz_custom_crawler_spawned_vo;
-	/*alcatraz_add_player_dialogue( "player", "general", "no_money_weapon", "nomoney_generic", undefined );
-	alcatraz_add_player_dialogue( "player", "general", "no_money_box", "nomoney_generic", undefined );
-	alcatraz_add_player_dialogue( "player", "general", "perk_deny", "nomoney_generic", undefined );
-	alcatraz_add_player_dialogue( "player", "perk", "specialty_armorvest", "perk_generic", undefined, 100 );
-	alcatraz_add_player_dialogue( "player", "perk", "specialty_fastreload", "perk_generic", undefined, 100 );
-	alcatraz_add_player_dialogue( "player", "perk", "specialty_doubletap2", "perk_generic", undefined, 100 );
-	alcatraz_add_player_dialogue( "player", "perk", "specialty_deadshot", "perk_generic", undefined, 100 );
-	alcatraz_add_player_dialogue( "player", "perk", "specialty_electriccherry", "perk_generic", undefined, 100 );
-	alcatraz_add_player_dialogue( "player", "kill", "close", "kill_close", undefined, 15 );
-	alcatraz_add_player_dialogue( "player", "kill", "bullet", "kill_damaged", undefined, 50 );
-	alcatraz_add_player_dialogue( "player", "kill", "headshot", "kill_headshot", "resp_kill_headshot", 25 );
-	alcatraz_add_player_dialogue( "player", "kill", "headshot_respond_to_plr_0", "headshot_respond_to_plr_0", undefined, 100 );
-	alcatraz_add_player_dialogue( "player", "kill", "headshot_respond_to_plr_1", "headshot_respond_to_plr_1", undefined, 100 );
-	alcatraz_add_player_dialogue( "player", "kill", "headshot_respond_to_plr_2", "headshot_respond_to_plr_2", undefined, 100 );
-	alcatraz_add_player_dialogue( "player", "kill", "headshot_respond_to_plr_3", "headshot_respond_to_plr_3", undefined, 100 );
-	alcatraz_add_player_dialogue( "player", "kill", "headshot_respond_generic", "headshot_respond_generic", undefined, 100 );
-	alcatraz_add_player_dialogue( "player", "kill", "retriever", "kill_retriever", undefined, 15 );
-	alcatraz_add_player_dialogue( "player", "kill", "redeemer", "kill_redeemer", undefined, 15 );
-	alcatraz_add_player_dialogue( "player", "kill", "blundergat", "kill_blundergat", undefined, 15 );
-	alcatraz_add_player_dialogue( "player", "kill", "acidgat", "kill_acidgat", undefined, 15 );
-	alcatraz_add_player_dialogue( "player", "kill", "death_machine", "kill_death_machine", undefined, 15 );
-	alcatraz_add_player_dialogue( "player", "kill", "wolf_kill", "wolf_kill", undefined, 100 );
-	alcatraz_add_player_dialogue( "player", "general", "achievement", "earn_acheivement", undefined, 100 );
-	alcatraz_add_player_dialogue( "player", "general", "revive_up", "heal_revived", "revive_player", 100 );
-	alcatraz_add_player_dialogue( "player", "general", "revive_player", "revive_player", undefined, 100 );
-	alcatraz_add_player_dialogue( "player", "general", "exert_sigh", "exert_sigh", undefined, 100 );
-	alcatraz_add_player_dialogue( "player", "general", "exert_laugh", "exert_laugh", undefined, 100 );
-	alcatraz_add_player_dialogue( "player", "general", "pain_high", "pain_high", undefined, 100 );
-	alcatraz_add_player_dialogue( "player", "general", "build_pickup", "build_pickup", undefined, 100 );
-	alcatraz_add_player_dialogue( "player", "general", "build_swap", "build_swap", undefined, 100 );
-	alcatraz_add_player_dialogue( "player", "general", "build_add", "build_add", undefined, 100 );
-	alcatraz_add_player_dialogue( "player", "general", "build_final", "build_final", undefined, 100 );
-	alcatraz_add_player_dialogue( "player", "general", "build_bsm_pickup", "build_bsm_pickup", undefined, 100 );
-	alcatraz_add_player_dialogue( "player", "general", "build_bsm_final", "build_bsm_final", undefined, 100 );
-	alcatraz_add_player_dialogue( "player", "general", "player_recieves_blundersplat", "build_bsm_plc", undefined, 100 );
-	alcatraz_add_player_dialogue( "player", "general", "build_zs_pickup", "build_zs_pickup", undefined, 100 );
-	alcatraz_add_player_dialogue( "player", "general", "build_zs_final", "build_zs_final", undefined, 100 );
-	alcatraz_add_player_dialogue( "player", "general", "build_zs_plc", "build_zs_plc", undefined, 100 );
-	alcatraz_add_player_dialogue( "player", "general", "reboard", "rebuild_boards", undefined, 50 );
-	alcatraz_add_player_dialogue( "player", "general", "discover_box", "discover_box", undefined, 100 );
-	alcatraz_add_player_dialogue( "player", "general", "discover_wall_buy", "discover_wall_buy", undefined, 100 );
-	alcatraz_add_player_dialogue( "player", "general", "generic_wall_buy", "generic_wall_buy", undefined, 25 );
-	alcatraz_add_player_dialogue( "player", "general", "wpck_pap", "wpck_pap", undefined, 100 );
-	alcatraz_add_player_dialogue( "player", "general", "portal_clue", "portal_clue", undefined, 100 );
-	alcatraz_add_player_dialogue( "player", "general", "killswitch_clue", "killswitch_clue", undefined, 100 );
-	alcatraz_add_player_dialogue( "player", "general", "power_off", "power_off", undefined, 100 );
-	alcatraz_add_player_dialogue( "player", "general", "power_on", "power_on", undefined, 100 );
-	alcatraz_add_player_dialogue( "player", "general", "electric_zap", "electric_zap", undefined, 25 );
-	alcatraz_add_player_dialogue( "player", "general", "need_electricity", "need_electricity", undefined, 25 );
-	alcatraz_add_player_dialogue( "player", "general", "use_gondola", "use_gondola", undefined, 100 );
-	alcatraz_add_player_dialogue( "player", "general", "discover_trap", "discover_trap", undefined, 100 );
-	alcatraz_add_player_dialogue( "player", "general", "start_trap", "start_trap", undefined, 100 );
-	alcatraz_add_player_dialogue( "player", "general", "surrounded_respond_to_plr_0", "surrounded_respond_to_plr_0", undefined, 100 );
-	alcatraz_add_player_dialogue( "player", "general", "surrounded_respond_to_plr_1", "surrounded_respond_to_plr_1", undefined, 100 );
-	alcatraz_add_player_dialogue( "player", "general", "surrounded_respond_to_plr_2", "surrounded_respond_to_plr_2", undefined, 100 );
-	alcatraz_add_player_dialogue( "player", "general", "surrounded_respond_to_plr_3", "surrounded_respond_to_plr_3", undefined, 100 );
-	alcatraz_add_player_dialogue( "player", "general", "wolf_complete", "wolf_complete", undefined, 100 );
-	alcatraz_add_player_dialogue( "player", "general", "wolf_final", "wolf_final", undefined, 100 );
-	alcatraz_add_player_dialogue( "player", "general", "wolf_encounter", "wolf_encounter", undefined, 100 );
-	alcatraz_add_player_dialogue( "player", "general", "brutus_encounter", "brutus_encounter", undefined, 100 );
-	alcatraz_add_player_dialogue( "player", "general", "brutus_arrival", "brutus_arrival", undefined, 100 );
-	alcatraz_add_player_dialogue( "player", "general", "brutus_reaction", "brutus_reaction", undefined, 100 );
-	alcatraz_add_player_dialogue( "player", "general", "brutus_defeated", "brutus_defeated", undefined, 100 );
-	alcatraz_add_player_dialogue( "player", "quest", "find_map", "find_map", undefined, 100 );
-	alcatraz_add_player_dialogue( "player", "quest", "response_map", "response_map", undefined, 100 );
-	alcatraz_add_player_dialogue( "player", "quest", "sidequest_key", "sidequest_key", undefined, 100 );
-	alcatraz_add_player_dialogue( "player", "quest", "sidequest_key_response", "sidequest_key_response", undefined, 100 );
-	alcatraz_add_player_dialogue( "player", "quest", "sidequest_sheets", "sidequest_sheets", undefined, 100 );
-	alcatraz_add_player_dialogue( "player", "quest", "sidequest_valves", "sidequest_valves", undefined, 100 );
-	alcatraz_add_player_dialogue( "player", "quest", "sidequest_engine", "sidequest_engine", undefined, 100 );
-	alcatraz_add_player_dialogue( "player", "quest", "sidequest_rigging", "sidequest_rigging", undefined, 100 );
-	alcatraz_add_player_dialogue( "player", "quest", "sidequest_oxygen", "sidequest_oxygen", undefined, 100 );
-	alcatraz_add_player_dialogue( "player", "quest", "sidequest_parts1_prog", "sidequest_parts1_prog", undefined, 100 );
-	alcatraz_add_player_dialogue( "player", "quest", "sidequest_parts2_prog", "sidequest_parts2_prog", undefined, 100 );
-	alcatraz_add_player_dialogue( "player", "quest", "sidequest_parts3_prog", "sidequest_parts3_prog", undefined, 100 );
-	alcatraz_add_player_dialogue( "player", "quest", "sidequest_parts4_prog", "sidequest_parts4_prog", undefined, 100 );
-	alcatraz_add_player_dialogue( "player", "quest", "sidequest_all_parts", "sidequest_all_parts", undefined, 100 );
-	alcatraz_add_player_dialogue( "player", "quest", "sidequest_roof_nag", "sidequest_roof_nag", undefined, 100 );
-	alcatraz_add_player_dialogue( "player", "quest", "build_plane", "build_plane", undefined, 100 );
-	alcatraz_add_player_dialogue( "player", "quest", "plane_takeoff", "plane_takeoff", undefined, 100 );
-	alcatraz_add_player_dialogue( "player", "quest", "plane_flight", "plane_flight", undefined, 100 );
-	alcatraz_add_player_dialogue( "player", "quest", "plane_crash", "plane_crash", undefined, 100 );
-	alcatraz_add_player_dialogue( "player", "quest", "free_fall", "free_fall", undefined, 100 );
-	alcatraz_add_player_dialogue( "player", "quest", "zombie_arrive_gg", "zombie_arrive_gg", undefined, 100 );
-	alcatraz_add_player_dialogue( "player", "quest", "chair_electrocution", "chair_electrocution", undefined, 100 );
-	alcatraz_add_player_dialogue( "player", "quest", "fuel_pickup", "fuel_pickup", undefined, 100 );
-	alcatraz_add_player_dialogue( "player", "quest", "start_2", "start_2", undefined, 100 );
-	alcatraz_add_player_dialogue( "player", "quest", "pick_up_easter_egg", "pick_up_egg", undefined, 100 );
-	alcatraz_add_player_dialogue( "player", "quest", "secret_poster", "secret_poster", undefined, 100 );
-	alcatraz_add_player_dialogue( "player", "quest", "find_secret", "find_secret", undefined, 100 );*/
 }
 
 function alcatraz_add_player_dialogue( speaker, category, type, alias, response, chance )
@@ -532,18 +470,30 @@ function alcatraz_audio_get_mod_type_override( impact, mod, weapon, zombie, inst
 			//}
 		}
 	}
-	if ( weapon.name == "shotgun_blundergat" || weapon.name == "shotgun_blundergat_upgraded" )
+
+	/*if ( zombie.damagemod == "MOD_GRENADE" || zombie.damagemod == "MOD_GRENADE_SPLASH" ) {
+		if ( zombie.damageweapon.name == "bo2_acidgat_bullet" ) {
+			if ( IsPlayer( zombie.attacker ) ) {
+				IPrintLnBold("AAAAA");
+			}
+		}
+	}*/
+
+	if ( weapon.name == "bo2_blundergat" || weapon.name == "bo2_blundergat_upgraded" )
 	{
+		//IPrintLnBold("blunder");
 		a_str_mod[ a_str_mod.size ] = "blundergat";
 	}
-	if ( weapon.name == "shotgun_acidgat" || weapon.name == "shotgun_acidgat_upgraded" )
+	/*if ( weapon.name == "bo2_acidgat" || weapon.name == "bo2_acidgat_upgraded" )
 	{
+		IPrintLnBold("acid");
 		a_str_mod[ a_str_mod.size ] = "acidgat";
 	}
-	if ( isdefined( zombie.damageweapon ) && zombie.damageweapon == "shotgun_acidgat_bullet" )
+	if ( isdefined( zombie.damageweapon ) && zombie.damageweapon == "bo2_acidgat_bullet" )
 	{
+		IPrintLnBold("acid");
 		a_str_mod[ a_str_mod.size ] = "acidgat";
-	}
+	}*/
 	if ( isdefined( zombie.damageweapon.name ) && zombie.damageweapon.name == "zombie_tomahawk" )
 	{
 		a_str_mod[ a_str_mod.size ] = "retriever";
@@ -1111,23 +1061,23 @@ function play_vo_category_on_closest_player( category, type )
 
 function check_for_special_weapon_limit_exist( weapon )
 {
-	if ( weapon.name != "shotgun_blundergat" && weapon.name != "minigun_alcatraz" )
+	if ( weapon.name != "bo2_blundergat" && weapon.name != "minigun_alcatraz" )
 	{
 		return 1;
 	}
 	players = GetPlayers();
 	count = 0;
-	if ( weapon.name == "shotgun_blundergat" )
+	if ( weapon.name == "bo2_blundergat" )
 	{
-		if ( self zm_weapons::has_weapon_or_upgrade( "shotgun_acidgat" ) )
+		if ( self zm_weapons::has_weapon_or_upgrade( "bo2_acidgat" ) )
 		{
 			return 0;
 		}
-		if ( self afterlife_weapon_limit_check( "shotgun_blundergat" ) )
+		if ( self afterlife_weapon_limit_check( "bo2_blundergat" ) )
 		{
 			return 0;
 		}
-		limit = level.limited_weapons[ "shotgun_blundergat" ];
+		limit = level.limited_weapons[ "bo2_blundergat" ];
 	}
 	else
 	{
@@ -1140,9 +1090,9 @@ function check_for_special_weapon_limit_exist( weapon )
 	i = 0;
 	while ( i < players.size )
 	{
-		if ( weapon.name == "shotgun_blundergat" )
+		if ( weapon.name == "bo2_blundergat" )
 		{
-			if ( players[ i ] zm_weapons::has_weapon_or_upgrade( "shotgun_acidgat" ) || isdefined( players[ i ].is_pack_splatting ) && players[ i ].is_pack_splatting )
+			if ( players[ i ] zm_weapons::has_weapon_or_upgrade( "bo2_acidgat" ) || isdefined( players[ i ].is_pack_splatting ) && players[ i ].is_pack_splatting )
 			{
 				count++;
 				i++;
@@ -1169,14 +1119,14 @@ function afterlife_weapon_limit_check( limited_weapon )
 {
 	if ( isdefined( self.afterlife ) && self.afterlife )
 	{
-		if ( limited_weapon == "shotgun_blundergat" )
+		if ( limited_weapon == "bo2_blundergat" )
 		{
 			_a1577 = self.loadout;
 			_k1577 = GetFirstArrayKey( _a1577 );
 			while ( isdefined( _k1577 ) )
 			{
 				weapon = _a1577[ _k1577 ];
-				if ( weapon.name != "shotgun_blundergat" && weapon.name != "shotgun_blundergat_upgraded" || weapon.name == "shotgun_acidgat" && weapon.name == "shotgun_acidgat_upgraded" )
+				if ( weapon.name != "bo2_blundergat" && weapon.name != "bo2_blundergat_upgraded" || weapon.name == "bo2_acidgat" && weapon.name == "bo2_acidgat_upgraded" )
 				{
 					return 1;
 				}
diff --git a/scripts/zm/zm_alcatraz_visions.gsc b/scripts/zm/zm_alcatraz_visions.gsc
new file mode 100755
index 0000000..e0fb687
--- /dev/null
+++ b/scripts/zm/zm_alcatraz_visions.gsc
@@ -0,0 +1,90 @@
+//
+// MIT License
+//
+// Copyright (c) 2021 MotoLegacy, JariKCoding
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+// 
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+//
+
+#using scripts\shared\visionset_mgr_shared;
+#using scripts\shared\flag_shared;
+
+#using scripts\zm\_zm_zonemgr;
+
+#namespace zm_alcatraz_visions;
+
+function autoexec init()
+{
+    visionset_mgr::register_info( "visionset", "zm_alcatraz_cellblock", 9000, 120, 1, 1 );
+    visionset_mgr::register_info( "visionset", "zm_alcatraz_underground", 9000, 120, 1, 1 );
+    visionset_mgr::register_info( "visionset", "zm_alcatraz_outside", 9000, 120, 1, 1 );
+    //visionset_mgr::register_info( "visionset", "zm_alcatraz_bw", 9000, 120, 1, 1 );
+
+    level flag::wait_till( "initial_blackscreen_passed" );
+
+    foreach(player in GetPlayers())
+    {
+        player thread vision_zone_check();
+    }
+}
+
+function vision_zone_check()
+{
+    for(;;)
+    {
+        old_vision = self.current_vision;
+        current_zone = self zm_zonemgr::get_player_zone();
+
+        //IPrintLnBold("name: " + self.name + " | zone: " + current_zone);
+
+        switch(current_zone)
+        {
+            case "gondola_roof_zone":
+            case "upper_docks_zone":
+            case "roof_zone":
+            case "docks_zone":
+                self.current_vision = "zm_alcatraz_outside";
+                break;
+            case "shower_zone":
+            case "cellblock_out_wardens_zone_b":
+            case "ug_docks_zone_e":
+            case "docks_room_zone":
+                self.current_vision = "zm_alcatraz_underground";
+                break;
+            case "top_dogfeeder_zone_c":
+            case "cellblock_hallway_zone":
+            case "cellblock_out_wardens_zone":
+            case "cellblock_leftside_zone_b":
+            case "infirmary_zone_c":
+            case "start_zone":
+                self.current_vision = "zm_alcatraz_cellblock";
+                break;
+            default:
+                break;
+        }
+
+        /*if (self.current_vision != old_vision) {
+            IPrintLnBold("switching vision to: " + self.current_vision);
+            //visionset_mgr::deactivate( "visionset", old_vision, self );
+            //wait 0.05;
+            visionset_mgr::activate( "visionset", self.current_vision, self );
+        }*/
+        wait 1;
+    }
+}
\ No newline at end of file
diff --git a/scripts/zm/zm_giant_cleanup_mgr.gsc b/scripts/zm/zm_giant_cleanup_mgr.gsc
index 96d2102..0b7dc71 100644
--- a/scripts/zm/zm_giant_cleanup_mgr.gsc
+++ b/scripts/zm/zm_giant_cleanup_mgr.gsc
@@ -239,6 +239,7 @@ function private delete_zombie_noone_looking()
 	
 	self zombie_utility::reset_attack_spot();
 	self Kill(); 
+	self.did_bleed_out = true;
 	wait( 0.05 );	// allow death to process
 	
 	if ( isdefined( self ) )
diff --git a/scripts/zm/zm_prison_spoon.gsc b/scripts/zm/zm_prison_spoon.gsc
index 0562bb2..e7d1971 100644
--- a/scripts/zm/zm_prison_spoon.gsc
+++ b/scripts/zm/zm_prison_spoon.gsc
@@ -94,7 +94,7 @@ function spoon_easy_cleanup() {
 function extra_death_func_to_check_for_splat_death() {
 	self thread zm_spawner::zombie_death_animscript();
 	if ( self.damagemod == "MOD_GRENADE" || self.damagemod == "MOD_GRENADE_SPLASH" ) {
-		if ( self.damageweapon.name == "shotgun_acidgat_bullet" ) {
+		if ( self.damageweapon.name == "bo2_acidgat_bullet" ) {
 			if ( IsPlayer( self.attacker ) ) {
 				self notify( "killed_by_a_blundersplat" );
 			}
@@ -164,7 +164,7 @@ function wait_for_initial_conditions() {
 			b_spoon_shocked = 1;
 			t_spoon Delete();
 			m_spoon Delete();
-			player PlaySoundToPlayer( "zmb_laugh_child", player );
+			player PlaySoundToPlayer( "zmb_spooky_laugh", player );
 		}
 	}
 	m_spoon_pickup Show();
@@ -269,7 +269,10 @@ function dip_the_spoon() {
 	level flag::wait_till( "charged_spoon" );
 	//IPrintLnBold("changing done");
 	wait 1;
-	level.t_bathtub PlaySound( "zmb_laugh_child" );
+	foreach(player in GetPlayers()) {
+		player PlaySoundToPlayer("zmb_spooky_laugh", player);
+	}
+	//level.t_bathtub PlaySound( "zmb_spooky_laugh" );
 	self thread thrust_the_spork();
 }
 
diff --git a/scripts/zm/zm_prison_sq_bg.gsc b/scripts/zm/zm_prison_sq_bg.gsc
index 7ce3305..97875fa 100644
--- a/scripts/zm/zm_prison_sq_bg.gsc
+++ b/scripts/zm/zm_prison_sq_bg.gsc
@@ -164,16 +164,16 @@ function give_sq_bg_reward() {
 	if ( a_players.size == 1 ) {
 		if ( a_players[ 0 ] HasWeapon( blundergat ) ) {
 			str_reward_weapon = GetWeapon("bo2_acidgat");
-			str_loc = "Press ^2&&1^7 to get Acidgat";
+			str_loc = "Press ^3&&1^7 to get Acidgat";
 		}
 		else {
 			str_reward_weapon = blundergat;
-			str_loc = "Press ^2&&1^7 to get Blundergat";
+			str_loc = "Press ^3&&1^7 to get Blundergat";
 		}
 	}
 	else {
 		str_reward_weapon = blundergat;
-		str_loc = "Press ^2&&1^7 to get Blundergat";
+		str_loc = "Press ^3&&1^7 to get Blundergat";
 	}
 	m_reward_model = zm_utility::spawn_weapon_model( str_reward_weapon, undefined, s_reward_origin.origin, s_reward_origin.angles );
 	m_reward_model MoveTo( m_reward_model.origin + vectorScale( ( 0, 0, 1 ), 14 ), 5 );
diff --git a/scripts/zm/zm_prison_sq_final.csc b/scripts/zm/zm_prison_sq_final.csc
new file mode 100755
index 0000000..b27963f
--- /dev/null
+++ b/scripts/zm/zm_prison_sq_final.csc
@@ -0,0 +1,31 @@
+#using scripts\codescripts\struct;
+
+#using scripts\shared\clientfield_shared;
+#using scripts\shared\callbacks_shared;
+#using scripts\shared\system_shared;
+#using scripts\shared\audio_shared;
+#using scripts\shared\util_shared;
+#using scripts\shared\postfx_shared;
+
+#using scripts\zm\_filter;
+
+#using scripts\zm\_zm_magicbox_prison;
+
+#insert scripts\shared\shared.gsh;
+#insert scripts\shared\version.gsh;
+
+function autoexec init()
+{
+    clientfield::register( "toplayer", "player_listening_to_headset", VERSION_SHIP, 1,	"int",	&sq_ambientroom, !CF_HOST_ONLY, CF_CALLBACK_ZERO_ON_NEW_ENT );
+}
+
+function sq_ambientroom( localclientnum, oldval, newval, bnewent, binitialsnap, fieldname, bwasdemojump )
+{
+    SetUIModelValue( CreateUIModel( GetUIModelForController( localClientNum ), "listeningtoheadset" ), newVal );
+
+    if (newval == 1) {
+        ForceAmbientRoom("sndHealth_LastStand");
+    } else {
+        ForceAmbientRoom("");
+    }
+}
\ No newline at end of file
diff --git a/scripts/zm/zm_prison_sq_final.gsc b/scripts/zm/zm_prison_sq_final.gsc
index a362079..e01c848 100644
--- a/scripts/zm/zm_prison_sq_final.gsc
+++ b/scripts/zm/zm_prison_sq_final.gsc
@@ -29,16 +29,22 @@
 #using scripts\zm\_zm_afterlife;
 #using scripts\zm\_zm_ai_brutus;
 #using scripts\zm\zm_alcatraz_amb;
+#using scripts\zm\zm_alcatraz_visions;
 
 
 #precache( "xmodel", "p6_zm_al_audio_headset_icon" );
 #precache("material", "waypoint_kill_red");
 
+function autoexec init()
+{
+	clientfield::register( "toplayer", "player_listening_to_headset", VERSION_SHIP, 1, "int" );
+}
+
 function onplayerconnect_sq_final() {
 }
 
 function stage_one() {
-	//level thread stage_two();
+	level thread stage_two();
 
 	level flag::wait_till( "quest_completed_thrice" );
 	level flag::wait_till( "spoon_obtained" );
@@ -199,6 +205,13 @@ function nixie_tube_win_effects_all_tubes_final( goal_num_1, goal_num_2, goal_nu
 }
 
 function stage_two() {
+	wait 30;
+	t_plane_fly = GetEnt( "plane_fly_trigger", "targetname" );
+	t_plane_fly TriggerEnable(false);
+	t_plane_fuelable = GetEnt( "plane_fuelable_trigger", "targetname" );
+	t_plane_fuelable TriggerEnable(false);
+	t_plane_fly_afterlife = GetEnt( "plane_fly_afterlife_trigger", "script_noteworthy" );
+	t_plane_fly_afterlife TriggerEnable(true);
 	audio_logs = [];
 	audio_logs[ 0 ] = [];
 	audio_logs[ 0 ][ 0 ] = "vox_guar_tour_vo_1_0";
@@ -224,7 +237,7 @@ function stage_two() {
 	}
 	level.m_headphones Delete();
 	t_plane_fly_afterlife = GetEnt( "plane_fly_afterlife_trigger", "script_noteworthy" );
-	t_plane_fly_afterlife PlaySound( "zmb_laugh_child" );
+	t_plane_fly_afterlife PlaySound( "zmb_spooky_laugh" );
 	trigger_is_on = 0;
 	while ( 1 ) {
 		wait 0.1;
@@ -286,22 +299,55 @@ function play_sq_audio_log( num, a_vo, b_use_trig ) {
 		trigger Delete();
 	}
 	level.m_headphones TriggerEnable(false);
+	PlayFX( level._effect["powerup_grabbed"], level.m_headphones.origin );
+	level.m_headphones Delete();
+
+	dummy_bitch = Spawn( "script_origin", (0, 0, 0) );
+
 	//level setclientfield( "toggle_futz", 1 );
+
+	level.doloopshit = true;
+
 	foreach(player in GetPlayers()) {
-		VisionSetNaked( "zombie_noire", 0.05 ); 
+		player PlaySoundToPlayer("zmb_sq_headset_start", player);
+		player clientfield::set_to_player( "player_listening_to_headset", 1 );
+		player thread doAudioLoop();
+		VisionSetNaked( "zm_alcatraz_bw", 0 ); 
 	}
+
+	wait 1.1;
+
 	i = 0;
 	while ( i < a_vo.size ) {
-		level.m_headphones PlaySoundWithNotify( a_vo[ i ], "at_done" );
-		level.m_headphones waittill( "at_done" );
+		level thread doAudioLoop();
+		dummy_bitch PlaySoundWithNotify( a_vo[ i ], "at_done" );
+		dummy_bitch waittill( "at_done" );
 		wait 0.5;
 		i++;
 	}
-	//level setclientfield( "toggle_futz", 0 );
+
+	level.doloopshit = false;
+
 	foreach(player in GetPlayers()) {
-		VisionSetNaked( "zm_factory" ); 
+		//zm_alcatraz_visions::restore_vision(player);
+		VisionSetNaked( "zm_factory", 0 ); 
+		player StopSound("zmb_sq_headset_loop");
+		player clientfield::set_to_player( "player_listening_to_headset", 0 );
+		player PlaySoundToPlayer("zmb_sq_headset_stop", player);
 	}
-	level.m_headphones Delete();
+
+	dummy_bitch Delete();
+}
+
+function doAudioLoop()
+{
+	wait 1;
+	while(level.doloopshit == true)
+	{
+		self PlaySoundToPlayer("zmb_sq_headset_loop", self);
+		wait 4;
+	}
+	
 }
 
 function final_flight_setup() {
@@ -312,6 +358,7 @@ function final_flight_setup() {
 
 function final_flight_trigger() {
 	t_plane_fly = GetEnt( "plane_fly_trigger", "targetname" );
+	t_plane_fly TriggerEnable(false);
 	self SetCursorHint( "HINT_NOICON" );
 	self SetHintString( "" );
 	while ( 1 ) {
@@ -357,6 +404,10 @@ function final_flight_trigger() {
 function final_flight_player_thread()
 {
 	self endon( "death_or_disconnect" );
+	self AllowStand( 1 );
+	self AllowCrouch( 1 );
+	self AllowProne( 1 );
+	self AllowSlide( 1 );
 	self.on_a_plane = 1;
 	self.dontspeak = 1;
 	//self setclientfieldtoplayer( "isspeaking", 1 );
@@ -396,6 +447,8 @@ function final_flight_player_thread()
 	t_plane_fly SetHintString( str_hint_string );
 	self PlayerLinkToDelta( m_plane_craftable, "tag_player_crouched_" + ( self.n_passenger_index + 1 ) );
 	self AllowCrouch( 1 );
+	self AllowProne( 0 );
+	self AllowSlide( 0 );
 	self AllowStand( 0 );
 	self util::clientnotify( "sndFFCON" );
 	level flag::wait_till( "plane_departed" );
@@ -523,30 +576,32 @@ function stage_final() {
 	}
 	level.brutus_respawn_after_despawn = 0;
 	level thread clean_up_final_brutuses();
+	level.easter_egg_completed = true;
 	wait 2;
-	if ( level.winner == "weasel" ) 	{
+	if ( level.winner == "weasel" ) {
+		level.custom_intermission = &player_intermission_bridge;
 		foreach(player in GetPlayers()) {
 			player FreezeControls( 1 );
 			//player maps/mp/zombies/_zm_stats::increment_client_stat( "prison_ee_good_ending", 0 );
 			player thread lui::screen_flash( 0.5, 5, 0, 1, "white" );
 			player create_ending_message( "THE CYCLE IS BROKEN." );
 			player.client_hint.sort = 55;
-			player.client_hint.color = ( 1, 1, 1 );
-			PlaySoundAtPosition( "zmb_quest_final_white_good", ( 1, 1, 1 ) );
+			player.client_hint.color = ( 0, 0, 0 );
+			player PlaySoundToPlayer("mus_whitescreen", player);
+			//PlaySoundAtPosition( "zmb_quest_final_white_good", ( 1, 1, 1 ) );
 			level.sndgameovermusicoverride = "game_over_final_good";
 		}
-		level.custom_intermission = &player_intermission_bridge;
 	}
 	else {
-		a_players = GetPlayers();
 		foreach(player in GetPlayers()) {
 			player FreezeControls( 1 );
 			//player maps/mp/zombies/_zm_stats::increment_client_stat( "prison_ee_bad_ending", 0 );
 			player thread lui::screen_flash( 0.5, 5, 0, 1, "white" );
 			player create_ending_message( "THE CYCLE CONTINUES..." );
 			player.client_hint.sort = 55;
-			player.client_hint.color = ( 1, 1, 1 );
-			PlaySoundAtPosition( "zmb_quest_final_white_bad", ( 1, 1, 1 ) );
+			player.client_hint.color = ( 0, 0, 0 );
+			player PlaySoundToPlayer("mus_whitescreen", player);
+			//PlaySoundAtPosition( "zmb_quest_final_white_bad", ( 1, 1, 1 ) );
 			level.sndgameovermusicoverride = "game_over_final_bad";
 		}
 	}
@@ -785,6 +840,7 @@ function player_intermission_bridge() {
 function create_ending_message( str_msg ) {
 	if ( !isdefined( self.client_hint ) ) {
 		self.client_hint = NewClientHudElem( self );
+		self.client_hint.color = ( 0, 0, 0 );
 		self.client_hint.alignx = "center";
 		self.client_hint.aligny = "middle";
 		self.client_hint.horzalign = "center";
@@ -801,7 +857,6 @@ function create_ending_message( str_msg ) {
 		self.client_hint.alpha = 1;
 		self.client_hint.foreground = 1;
 		self.client_hint.hidewheninmenu = 1;
-		self.client_hint.color = ( 1, 1, 1 );
 	}
 	self.client_hint SetText( str_msg );
 }
diff --git a/scripts/zm/zm_prison_traps.gsc b/scripts/zm/zm_prison_traps.gsc
index 8975e6f..2cc0d2f 100644
--- a/scripts/zm/zm_prison_traps.gsc
+++ b/scripts/zm/zm_prison_traps.gsc
@@ -327,11 +327,11 @@ function acid_trap_think() {
 	self.zombie_dmg_trig.in_use = 0;
 	light_name = self get_trap_light_name();
 	zapper_light_red( light_name );
-	self SetHintString( &"ZOMBIE_NEED_POWER" );
+	self SetHintString( "Acid Trap Unavailable" );
 	level flag::wait_till( "enter_cafe_zone" );
 	//level flag::wait_till_any( "activate_cafeteria", "activate_infirmary" );
 	zapper_light_green( light_name );
-	self SetHintString( &"ZOMBIE_BUTTON_BUY_TRAP" , self.cost );
+	self SetHintString( "Hold ^3[{+activate}]^7 to activate Acid Trap [Cost: &&1]" , self.cost );
 	while ( 1 ) {
 		self waittill( "trigger", who );
 		if ( who zm_utility::in_revive_trigger() ) {
diff --git a/scripts/zm/zm_prison_travel.gsc b/scripts/zm/zm_prison_travel.gsc
index 80d0e57..893057e 100644
--- a/scripts/zm/zm_prison_travel.gsc
+++ b/scripts/zm/zm_prison_travel.gsc
@@ -153,7 +153,7 @@ function zipline_call_trigger_think()
 		self SetHintString( "" );
 		level flag::wait_till( "gondola_at_" + str_gondola_loc );
 		self notify( "available" );
-		self SetHintString( "Press &&1 to call gondola" );
+		self SetHintString( "Press ^3&&1^7 to call gondola" );
 		self waittill( "trigger", who );
 		if ( who zm_utility::in_revive_trigger() )
 		{
@@ -337,13 +337,13 @@ function zipline_move_trigger_think()
 	while ( 1 )
 	{
 		level flag::wait_till( "gondola_at_" + self.script_string );
-		self SetHintString( "Press &&1 to use gondola [Cost: "+self.cost+"]" );
+		self SetHintString( "Press ^3&&1^7 to use Gondola [Cost: "+self.cost+"]" );
 		self waittill( "trigger", who );
 		if ( who zm_utility::in_revive_trigger() )
 		{
 			wait 0.05;
 			continue;
-		}
+		} 
 		if ( !isDefined( self.is_available ) )
 		{
 			wait 0.05;
@@ -821,12 +821,12 @@ function gondola_cooldown()
 	a_t_call = GetEntArray( "gondola_call_trigger", "targetname" );
 	foreach(trigger in a_t_call)
 	{
-		trigger SetHintString( "Gondola is cooling down" );
+		trigger SetHintString( "The Gondola is recharging" );
 	}
 	a_t_move = GetEntArray( "gondola_move_trigger", "targetname" );
 	foreach(trigger in a_t_move)
 	{
-		trigger SetHintString( "Gondola is cooling down" );
+		trigger SetHintString( "The Gondola is recharging" );
 	}
 	wait 10;
 	gondola_lights_green();
@@ -846,6 +846,7 @@ function link_player_to_gondola()
 		e_origin.angles = self.angles;
 		level.hm_link_origins[ level.hm_link_origins.size ] = e_origin;
 		e_origin LinkTo( level.e_gondola );
+		//IPrintLnBold("on gondola");
 		self PlayerLinkTo( e_origin );
 	}
 }
diff --git a/scripts/zm/zm_prison_weap_quest.gsc b/scripts/zm/zm_prison_weap_quest.gsc
index 7bcc662..630352a 100644
--- a/scripts/zm/zm_prison_weap_quest.gsc
+++ b/scripts/zm/zm_prison_weap_quest.gsc
@@ -328,14 +328,12 @@ function wolfhead_depart( rune )
 
 function wolf_state_7(index)
 {
+	level.wolf_runes[index] PlayLoopSound( "evt_runeglow_loop" );
 	level.wolf_heads[index] Hide();
 	level.wolf_runes[index] Show();
 	level.wolf_bodies[index] Hide();
 	level.wolf_bodies[index].head Hide();
 	level.wolf_bodies[index].head.hat Hide();
-	level.wolf_runes[index] SetModel( "p6_zm_al_dream_catcher_on" );
-	PlayFXOnTag(  level._effect["soul_charged"], level.wolf_runes[index], "tag_origin" );
-	level.wolf_runes[index] PlayLoopSound( "evt_runeglow_loop" );
 }
 
 function wolf_state_eat(index , n_eating_anim ,zombie)
@@ -445,6 +443,8 @@ function grief_soul_catcher_state_manager( index )
 			level thread wolf_state_2(index);
 			self util::waittill_either( "fully_charged", "finished_eating" );
 		}
+		level.wolf_runes[index] SetModel( "p6_zm_al_dream_catcher_on" );
+		PlayFXOnTag(  level._effect["soul_charged"], level.wolf_runes[index], "tag_origin" );
 		level thread wolf_state_6(index);
 		anim_length = GetAnimLength( %o_zombie_dreamcatcher_outtro );
 		wait anim_length;
@@ -578,7 +578,7 @@ function watch_for_death()
 			{
 				return;
 			}
-			if(!isdefined(self))
+			if(!isdefined(self) || (isdefined(self.did_bleed_out) && self.did_bleed_out == true ))
 			{
 				return;
 			}
@@ -918,11 +918,12 @@ function tomahawk_upgrade_quest()
 	{
 		self waittill( "got_a_tomahawk_kill" );
 		self.tomahawk_upgrade_kills++;
+		//IPrintLnBold("kill: " + self.tomahawk_upgrade_kills);
 	}
 	wait 1;
 	level thread zm_alcatraz_amb::sndplaystinger( "quest_generic" );
 	e_org = Spawn( "script_origin", self.origin + vectorScale( ( 0, 0, 1 ), 64 ) );
-	e_org PlaySoundWithNotify( "zmb_easteregg_scream", "easteregg_scream_complete" );
+	e_org PlaySoundWithNotify( "zmb_afterlife_end", "easteregg_scream_complete" );
 	e_org waittill( "easteregg_scream_complete" );
 	e_org Delete();
 	while ( level.round_number < 10 )
@@ -956,7 +957,7 @@ function tomahawk_upgrade_quest()
 	}
 	level thread zm_alcatraz_amb::sndplaystinger( "quest_generic" );
 	e_org = Spawn( "script_origin", self.origin + vectorScale( ( 0, 0, 1 ), 64 ) );
-	e_org PlaySoundWithNotify( "zmb_easteregg_scream", "easteregg_scream_complete" );
+	e_org PlaySoundWithNotify( "zmb_afterlife_end", "easteregg_scream_complete" );
 	e_org waittill( "easteregg_scream_complete" );
 	e_org Delete();
 	self notify( "hellhole_time" );
@@ -976,7 +977,7 @@ function tomahawk_upgrade_quest()
 	self notify( "tomahawk_upgraded_swap" );
 	level thread zm_alcatraz_amb::sndplaystinger( "quest_generic" );
 	e_org = Spawn( "script_origin", self.origin + vectorScale( ( 0, 0, 1 ), 64 ) );
-	e_org PlaySoundWithNotify( "zmb_easteregg_scream", "easteregg_scream_complete" );
+	e_org PlaySoundWithNotify( "zmb_afterlife_end", "easteregg_scream_complete" );
 	e_org waittill( "easteregg_scream_complete" );
 	e_org Delete();
 	level waittill( "end_of_round" );
diff --git a/scripts/zm/zm_usermap.csc b/scripts/zm/zm_usermap.csc
new file mode 100755
index 0000000..047ef38
--- /dev/null
+++ b/scripts/zm/zm_usermap.csc
@@ -0,0 +1,189 @@
+#using scripts\codescripts\struct;
+#using scripts\shared\audio_shared;
+#using scripts\shared\callbacks_shared;
+#using scripts\shared\clientfield_shared;
+#using scripts\shared\exploder_shared;
+#using scripts\shared\flag_shared;
+#using scripts\shared\scene_shared;
+#using scripts\shared\util_shared;
+
+#insert scripts\shared\shared.gsh;
+#insert scripts\shared\version.gsh;
+
+#using scripts\zm\_load;
+#using scripts\zm\_zm_weapons;
+
+//Perks
+#using scripts\zm\_zm_pack_a_punch;
+#using scripts\zm\_zm_perk_additionalprimaryweapon;
+#using scripts\zm\_zm_perk_doubletap2;
+#using scripts\zm\_zm_perk_deadshot;
+#using scripts\zm\_zm_perk_juggernaut;
+#using scripts\zm\_zm_perk_quick_revive;
+#using scripts\zm\_zm_perk_sleight_of_hand;
+#using scripts\zm\_zm_perk_staminup;
+
+//Powerups
+#using scripts\zm\_zm_powerup_double_points;
+#using scripts\zm\_zm_powerup_carpenter;
+#using scripts\zm\_zm_powerup_fire_sale;
+#using scripts\zm\_zm_powerup_free_perk;
+#using scripts\zm\_zm_powerup_full_ammo;
+#using scripts\zm\_zm_powerup_insta_kill;
+#using scripts\zm\_zm_powerup_nuke;
+#using scripts\zm\_zm_powerup_weapon_minigun;
+
+//Traps
+#using scripts\zm\_zm_trap_electric;
+
+// Weapons
+#using scripts\zm\_zm_weap_bouncingbetty;
+#using scripts\zm\_zm_weap_cymbal_monkey;
+#using scripts\zm\_zm_weap_tesla;
+#using scripts\zm\_zm_weap_rocketshield;
+#using scripts\zm\_zm_weap_gravityspikes;
+#using scripts\zm\_zm_weap_thundergun;
+#using scripts\zm\_zm_weap_octobomb;
+#using scripts\zm\_zm_weap_raygun_mark3;
+
+// AI
+#using scripts\zm\_zm_ai_dogs;
+
+#insert scripts\zm\_zm_perks.gsh;
+
+#namespace zm_usermap; 
+
+#precache( "client_fx", "zombie/fx_glow_eye_orange" );
+#precache( "client_fx", "zombie/fx_bul_flesh_head_fatal_zmb" );
+#precache( "client_fx", "zombie/fx_bul_flesh_head_nochunks_zmb" );
+#precache( "client_fx", "zombie/fx_bul_flesh_neck_spurt_zmb" );
+#precache( "client_fx", "zombie/fx_blood_torso_explo_zmb" );
+#precache( "client_fx", "trail/fx_trail_blood_streak" );
+#precache( "client_fx", "dlc0/factory/fx_snow_player_os_factory" );
+
+#precache( "client_fx", "zombie/fx_perk_juggernaut_factory_zmb" );
+#precache( "client_fx", "zombie/fx_perk_quick_revive_factory_zmb" );
+#precache( "client_fx", "zombie/fx_perk_sleight_of_hand_factory_zmb" );
+#precache( "client_fx", "zombie/fx_perk_doubletap2_factory_zmb" );
+#precache( "client_fx", "zombie/fx_perk_daiquiri_factory_zmb" );
+#precache( "client_fx", "zombie/fx_perk_stamin_up_factory_zmb" );
+#precache( "client_fx", "zombie/fx_perk_mule_kick_factory_zmb" );
+
+function autoexec opt_in()
+{
+	DEFAULT(level.aat_in_use,true);
+	DEFAULT(level.bgb_in_use,true);
+}
+
+function main()
+{
+	// custom client side exert sounds for the special characters
+	level.setupCustomCharacterExerts =&setup_personality_character_exerts;
+	
+	level._effect["eye_glow"]				= "zombie/fx_glow_eye_orange";
+	level._effect["headshot"]				= "zombie/fx_bul_flesh_head_fatal_zmb";
+	level._effect["headshot_nochunks"]		= "zombie/fx_bul_flesh_head_nochunks_zmb";
+	level._effect["bloodspurt"]				= "zombie/fx_bul_flesh_neck_spurt_zmb";
+
+	level._effect["animscript_gib_fx"]		= "zombie/fx_blood_torso_explo_zmb"; 
+	level._effect["animscript_gibtrail_fx"]	= "trail/fx_trail_blood_streak"; 	
+
+	//If enabled then the zombies will get a keyline round them so we can see them through walls
+	level.debug_keyline_zombies = false;
+
+	include_weapons();
+	include_perks();
+
+	load::main();
+	
+	_zm_weap_cymbal_monkey::init();
+	_zm_weap_tesla::init();
+	
+}
+
+function include_weapons()
+{
+	zm_weapons::load_weapon_spec_from_table("gamedata/weapons/zm/zm_levelcommon_weapons.csv", 1);
+}
+
+#define JUGGERNAUT_MACHINE_LIGHT_FX				"jugger_light"		
+#define QUICK_REVIVE_MACHINE_LIGHT_FX			"revive_light"		
+#define STAMINUP_MACHINE_LIGHT_FX				"marathon_light"	
+#define WIDOWS_WINE_FX_MACHINE_LIGHT				"widow_light"
+#define SLEIGHT_OF_HAND_MACHINE_LIGHT_FX				"sleight_light"		
+#define DOUBLETAP2_MACHINE_LIGHT_FX				"doubletap2_light"		
+#define DEADSHOT_MACHINE_LIGHT_FX				"deadshot_light"		
+#define ADDITIONAL_PRIMARY_WEAPON_MACHINE_LIGHT_FX					"additionalprimaryweapon_light"
+
+function include_perks()
+{
+	level._effect[JUGGERNAUT_MACHINE_LIGHT_FX] = "zombie/fx_perk_juggernaut_factory_zmb";
+	level._effect[QUICK_REVIVE_MACHINE_LIGHT_FX] = "zombie/fx_perk_quick_revive_factory_zmb";
+	level._effect[SLEIGHT_OF_HAND_MACHINE_LIGHT_FX] = "zombie/fx_perk_sleight_of_hand_factory_zmb";
+	level._effect[DOUBLETAP2_MACHINE_LIGHT_FX] = "zombie/fx_perk_doubletap2_factory_zmb";
+	level._effect[DEADSHOT_MACHINE_LIGHT_FX] = "zombie/fx_perk_daiquiri_factory_zmb";
+	level._effect[STAMINUP_MACHINE_LIGHT_FX] = "zombie/fx_perk_stamin_up_factory_zmb";
+	level._effect[ADDITIONAL_PRIMARY_WEAPON_MACHINE_LIGHT_FX] = "zombie/fx_perk_mule_kick_factory_zmb";	
+
+	//level flag::wait_till( "initial_blackscreen_passed" );
+
+	//level._custom_perks[PERK_DOUBLETAP2].machine_light_effect = DOUBLETAP2_MACHINE_LIGHT_FX;
+}
+
+function setup_personality_character_exerts()
+{
+	// falling damage
+	level.exert_sounds[1]["falldamage"][0] = "vox_plr_0_exert_pain_0";
+	level.exert_sounds[1]["falldamage"][1] = "vox_plr_0_exert_pain_1";
+	level.exert_sounds[1]["falldamage"][2] = "vox_plr_0_exert_pain_2";
+	level.exert_sounds[1]["falldamage"][3] = "vox_plr_0_exert_pain_3";
+	level.exert_sounds[1]["falldamage"][4] = "vox_plr_0_exert_pain_4";
+	
+	level.exert_sounds[2]["falldamage"][0] = "vox_plr_1_exert_pain_0";
+	level.exert_sounds[2]["falldamage"][1] = "vox_plr_1_exert_pain_1";
+	level.exert_sounds[2]["falldamage"][2] = "vox_plr_1_exert_pain_2";
+	level.exert_sounds[2]["falldamage"][3] = "vox_plr_1_exert_pain_3";
+	level.exert_sounds[2]["falldamage"][4] = "vox_plr_1_exert_pain_4";
+	
+	level.exert_sounds[3]["falldamage"][0] = "vox_plr_2_exert_pain_0";
+	level.exert_sounds[3]["falldamage"][1] = "vox_plr_2_exert_pain_1";
+	level.exert_sounds[3]["falldamage"][2] = "vox_plr_2_exert_pain_2";
+	level.exert_sounds[3]["falldamage"][3] = "vox_plr_2_exert_pain_3";
+	level.exert_sounds[3]["falldamage"][4] = "vox_plr_2_exert_pain_4";
+	
+	level.exert_sounds[4]["falldamage"][0] = "vox_plr_3_exert_pain_0";
+	level.exert_sounds[4]["falldamage"][1] = "vox_plr_3_exert_pain_1";
+	level.exert_sounds[4]["falldamage"][2] = "vox_plr_3_exert_pain_2";
+	level.exert_sounds[4]["falldamage"][3] = "vox_plr_3_exert_pain_3";
+	level.exert_sounds[4]["falldamage"][4] = "vox_plr_3_exert_pain_4";
+	
+	// melee swipe
+	level.exert_sounds[1]["meleeswipesoundplayer"][0] = "vox_plr_0_exert_melee_0";
+	level.exert_sounds[1]["meleeswipesoundplayer"][1] = "vox_plr_0_exert_melee_1";
+	level.exert_sounds[1]["meleeswipesoundplayer"][2] = "vox_plr_0_exert_melee_2";
+	level.exert_sounds[1]["meleeswipesoundplayer"][3] = "vox_plr_0_exert_melee_3";
+	level.exert_sounds[1]["meleeswipesoundplayer"][4] = "vox_plr_0_exert_melee_4";
+	level.exert_sounds[1]["meleeswipesoundplayer"][5] = "vox_plr_0_exert_melee_5";
+	
+	level.exert_sounds[2]["meleeswipesoundplayer"][0] = "vox_plr_1_exert_melee_0";
+	level.exert_sounds[2]["meleeswipesoundplayer"][1] = "vox_plr_1_exert_melee_1";
+	level.exert_sounds[2]["meleeswipesoundplayer"][2] = "vox_plr_1_exert_melee_2";
+	level.exert_sounds[2]["meleeswipesoundplayer"][3] = "vox_plr_1_exert_melee_3";
+	level.exert_sounds[2]["meleeswipesoundplayer"][4] = "vox_plr_1_exert_melee_4";
+	level.exert_sounds[2]["meleeswipesoundplayer"][5] = "vox_plr_1_exert_melee_5";
+	
+	level.exert_sounds[3]["meleeswipesoundplayer"][0] = "vox_plr_2_exert_melee_0";
+	level.exert_sounds[3]["meleeswipesoundplayer"][1] = "vox_plr_2_exert_melee_1";
+	level.exert_sounds[3]["meleeswipesoundplayer"][2] = "vox_plr_2_exert_melee_2";
+	level.exert_sounds[3]["meleeswipesoundplayer"][3] = "vox_plr_2_exert_melee_3";
+	level.exert_sounds[3]["meleeswipesoundplayer"][4] = "vox_plr_2_exert_melee_4";
+	level.exert_sounds[3]["meleeswipesoundplayer"][5] = "vox_plr_2_exert_melee_5";	
+	
+	level.exert_sounds[4]["meleeswipesoundplayer"][0] = "vox_plr_3_exert_melee_0";
+	level.exert_sounds[4]["meleeswipesoundplayer"][1] = "vox_plr_3_exert_melee_1";
+	level.exert_sounds[4]["meleeswipesoundplayer"][2] = "vox_plr_3_exert_melee_2";
+	level.exert_sounds[4]["meleeswipesoundplayer"][3] = "vox_plr_3_exert_melee_3";
+	level.exert_sounds[4]["meleeswipesoundplayer"][4] = "vox_plr_3_exert_melee_4";	
+	level.exert_sounds[4]["meleeswipesoundplayer"][5] = "vox_plr_3_exert_melee_5";
+}
+
diff --git a/scripts/zm/zm_usermap.gsc b/scripts/zm/zm_usermap.gsc
index bddc991..9404c1e 100644
--- a/scripts/zm/zm_usermap.gsc
+++ b/scripts/zm/zm_usermap.gsc
@@ -23,35 +23,22 @@
 //
 
 #using scripts\codescripts\struct;
-
-#using scripts\shared\array_shared;
+#using scripts\shared\audio_shared;
 #using scripts\shared\callbacks_shared;
 #using scripts\shared\clientfield_shared;
-#using scripts\shared\compass;
 #using scripts\shared\exploder_shared;
 #using scripts\shared\flag_shared;
-#using scripts\shared\laststand_shared;
-#using scripts\shared\math_shared;
 #using scripts\shared\scene_shared;
 #using scripts\shared\util_shared;
 
 #insert scripts\shared\shared.gsh;
 #insert scripts\shared\version.gsh;
 
-#insert scripts\zm\_zm_utility.gsh;
-
 #using scripts\zm\_load;
-#using scripts\zm\_zm;
-#using scripts\zm\_zm_audio;
-#using scripts\zm\_zm_powerups;
-#using scripts\zm\_zm_utility;
 #using scripts\zm\_zm_weapons;
-#using scripts\zm\_zm_zonemgr;
-
 
 //Perks
 #using scripts\zm\_zm_pack_a_punch;
-#using scripts\zm\_zm_pack_a_punch_util;
 #using scripts\zm\_zm_perk_additionalprimaryweapon;
 #using scripts\zm\_zm_perk_doubletap2;
 #using scripts\zm\_zm_perk_deadshot;
@@ -70,50 +57,41 @@
 #using scripts\zm\_zm_powerup_nuke;
 #using scripts\zm\_zm_powerup_weapon_minigun;
 
+//Traps
+#using scripts\zm\_zm_trap_electric;
+
 // Weapons
-#using scripts\zm\_zm_weap_bowie;
 #using scripts\zm\_zm_weap_bouncingbetty;
 #using scripts\zm\_zm_weap_cymbal_monkey;
 #using scripts\zm\_zm_weap_tesla;
 #using scripts\zm\_zm_weap_rocketshield;
 #using scripts\zm\_zm_weap_gravityspikes;
-#using scripts\zm\_zm_weap_annihilator;
 #using scripts\zm\_zm_weap_thundergun;
 #using scripts\zm\_zm_weap_octobomb;
 #using scripts\zm\_zm_weap_raygun_mark3;
 
-//Traps
-#using scripts\zm\_zm_trap_electric;
-
 // AI
-#using scripts\shared\ai\zombie;
-#using scripts\shared\ai\behavior_zombie_dog;
-#using scripts\shared\ai\zombie_utility;
-
 #using scripts\zm\_zm_ai_dogs;
 
-#using scripts\zm\zm_usermap_ai;
-
-#precache( "fx", "misc/fx_zombie_eye_single" );
-#precache( "fx", "impacts/fx_flesh_hit" );
-#precache( "fx", "misc/fx_zombie_bloodsplat" );
-#precache( "fx", "misc/fx_zombie_bloodspurt" );
-#precache( "fx", "weapon/bullet/fx_flesh_gib_fatal_01" );
-#precache( "fx", "trail/fx_trail_blood_streak" );
-#precache( "fx", "zombie/fx_glow_eye_orange" );
-#precache( "fx", "zombie/fx_bul_flesh_head_fatal_zmb" );
-#precache( "fx", "zombie/fx_bul_flesh_head_nochunks_zmb" );
-#precache( "fx", "zombie/fx_bul_flesh_neck_spurt_zmb" );
-#precache( "fx", "zombie/fx_blood_torso_explo_zmb" );
-#precache( "fx", "trail/fx_trail_blood_streak" );
-#precache( "fx", "electric/fx_elec_sparks_directional_orange" );
-
+#insert scripts\zm\_zm_perks.gsh;
 
 #namespace zm_usermap; 
 
-//*****************************************************************************
-// MAIN
-//*****************************************************************************
+#precache( "client_fx", "zombie/fx_glow_eye_orange" );
+#precache( "client_fx", "zombie/fx_bul_flesh_head_fatal_zmb" );
+#precache( "client_fx", "zombie/fx_bul_flesh_head_nochunks_zmb" );
+#precache( "client_fx", "zombie/fx_bul_flesh_neck_spurt_zmb" );
+#precache( "client_fx", "zombie/fx_blood_torso_explo_zmb" );
+#precache( "client_fx", "trail/fx_trail_blood_streak" );
+#precache( "client_fx", "dlc0/factory/fx_snow_player_os_factory" );
+
+#precache( "client_fx", "zombie/fx_perk_juggernaut_factory_zmb" );
+#precache( "client_fx", "zombie/fx_perk_quick_revive_factory_zmb" );
+#precache( "client_fx", "zombie/fx_perk_sleight_of_hand_factory_zmb" );
+#precache( "client_fx", "zombie/fx_perk_doubletap2_factory_zmb" );
+#precache( "client_fx", "zombie/fx_perk_daiquiri_factory_zmb" );
+#precache( "client_fx", "zombie/fx_perk_stamin_up_factory_zmb" );
+#precache( "client_fx", "zombie/fx_perk_mule_kick_factory_zmb" );
 
 function autoexec opt_in()
 {
@@ -121,17 +99,10 @@ function autoexec opt_in()
 	DEFAULT(level.bgb_in_use,true);
 }
 
-function autoexec init_fx()
-{
-	clientfield::register( "clientuimodel", "player_lives", VERSION_SHIP, 2, "int" );
-}
-
 function main()
 {
-	level._uses_default_wallbuy_fx = 1;
-	
-	zm::init_fx();
-	level util::set_lighting_state( 1 );
+	// custom client side exert sounds for the special characters
+	level.setupCustomCharacterExerts =&setup_personality_character_exerts;
 	
 	level._effect["eye_glow"]				= "zombie/fx_glow_eye_orange";
 	level._effect["headshot"]				= "zombie/fx_bul_flesh_head_fatal_zmb";
@@ -140,330 +111,23 @@ function main()
 
 	level._effect["animscript_gib_fx"]		= "zombie/fx_blood_torso_explo_zmb"; 
 	level._effect["animscript_gibtrail_fx"]	= "trail/fx_trail_blood_streak"; 	
-	level._effect["switch_sparks"]			= "electric/fx_elec_sparks_directional_orange";
-
-	//Setup game mode defaults
-	level.default_start_location = "start_room";	
-	level.default_game_mode = "zclassic";	
-	
-	level.giveCustomLoadout =&giveCustomLoadout;
-	level.precacheCustomCharacters =&precacheCustomCharacters;
-	level.giveCustomCharacters =&giveCustomCharacters;
-	level thread setup_personality_character_exerts();
-	initCharacterStartIndex();
-
-	//Weapons and Equipment
-	level.register_offhand_weapons_for_level_defaults_override = &offhand_weapon_overrride;
-	level.zombiemode_offhand_weapon_give_override = &offhand_weapon_give_override;
 
-	DEFAULT(level._zombie_custom_add_weapons,&custom_add_weapons);
-	
-	level._allow_melee_weapon_switching = 1;
-	
-	level.zombiemode_reusing_pack_a_punch = true;
+	//If enabled then the zombies will get a keyline round them so we can see them through walls
+	level.debug_keyline_zombies = false;
 
-	//Level specific stuff
 	include_weapons();
+	include_perks();
 
 	load::main();
-
-	DEFAULT(level.dog_rounds_allowed,1);
-	if( level.dog_rounds_allowed )
-	{
-		zm_ai_dogs::enable_dog_rounds();
-	}
 	
 	_zm_weap_cymbal_monkey::init();
 	_zm_weap_tesla::init();
-	level._round_start_func = &zm::round_start;
-	
-	level thread sndFunctions();
-}
-
-function template_test_zone_init()
-{
-	level flag::init( "always_on" );
-	level flag::set( "always_on" );
-}	
-
-function offhand_weapon_overrride()
-{
-	zm_utility::register_lethal_grenade_for_level( "frag_grenade" );
-	level.zombie_lethal_grenade_player_init = GetWeapon( "frag_grenade" );
-
-	zm_utility::register_melee_weapon_for_level( level.weaponBaseMelee.name );
-	level.zombie_melee_weapon_player_init = level.weaponBaseMelee;
-
-	zm_utility::register_tactical_grenade_for_level( "cymbal_monkey" );
-
 	
-	level.zombie_equipment_player_init = undefined;
-}
-
-function offhand_weapon_give_override( weapon )
-{
-	self endon( "death" );
-	
-	if( zm_utility::is_tactical_grenade( weapon ) && IsDefined( self zm_utility::get_player_tactical_grenade() ) && !self zm_utility::is_player_tactical_grenade( weapon )  )
-	{
-		self SetWeaponAmmoClip( self zm_utility::get_player_tactical_grenade(), 0 );
-		self TakeWeapon( self zm_utility::get_player_tactical_grenade() );
-	}
-	return false;
 }
 
 function include_weapons()
 {
-	zm_weapons::load_weapon_spec_from_table("gamedata/weapons/zm/zm_motd_weapons.csv", 1);
-}
-
-function precacheCustomCharacters()
-{
-}
-
-function initCharacterStartIndex()
-{
-	level.characterStartIndex = RandomInt( 4 );
-}
-
-function selectCharacterIndexToUse()
-{
-	if( level.characterStartIndex>=4 )
-	level.characterStartIndex = 0;
-
-	self.characterIndex = level.characterStartIndex;
-	level.characterStartIndex++;
-
-	return self.characterIndex;
-}
-
-
-function assign_lowest_unused_character_index()
-{
-	//get the lowest unused character index
-	charindexarray = [];
-	charindexarray[0] = 0;// - Dempsey )
-	charindexarray[1] = 1;// - Nikolai )
-	charindexarray[2] = 2;// - Richtofen )
-	charindexarray[3] = 3;// - Takeo )
-	
-	players = GetPlayers();
-	if ( players.size == 1 )
-	{
-		charindexarray = array::randomize( charindexarray );
-		if ( charindexarray[0] == 3 )
-		{
-			level.has_richtofen = true;	
-		}
-
-		// SOLO EE
-		if (level.is_forever_solo_game)
-			return 3;
-		else
-			return charindexarray[0];
-	}
-	else // 2 or more players just assign the lowest unused value
-	{
-		n_characters_defined = 0;
-
-		foreach ( player in players )
-		{
-			if ( isDefined( player.characterIndex ) )
-			{
-				ArrayRemoveValue( charindexarray, player.characterIndex, false );
-				n_characters_defined++;
-			}
-		}
-		
-		if ( charindexarray.size > 0 )
-		{
-			// If this is the last guy and we don't have Richtofen in the group yet, make sure he's Richtofen
-			if ( n_characters_defined == (players.size - 1) )
-			{
-				if ( !IS_TRUE( level.has_richtofen ) )
-				{
-					level.has_richtofen = true;
-					return 3;
-				}	
-			}
-			
-			// Randomize the array
-			charindexarray = array::randomize(charindexarray);
-			if ( charindexarray[0] == 3 )
-			{
-				level.has_richtofen = true;	
-			}
-
-			return charindexarray[0];
-		}
-	}
-
-	//failsafe
-	return 0;
-}
-
-function giveCustomCharacters()
-{
-	if( isdefined(level.hotjoin_player_setup) && [[level.hotjoin_player_setup]]("c_zom_farmgirl_viewhands") )
-	{
-		return;
-	}
-	
-	self DetachAll();
-	
-	// Only Set Character Index If Not Defined, Since This Thread Gets Called Each Time Player Respawns
-	//-------------------------------------------------------------------------------------------------
-	if ( !isdefined( self.characterIndex ) )
-	{
-		self.characterIndex = assign_lowest_unused_character_index();
-	}
-	
-	self.favorite_wall_weapons_list = [];
-	self.talks_in_danger = false;	
-	
-	self SetCharacterBodyType( self.characterIndex );
-	self SetCharacterBodyStyle( 0 );
-	self SetCharacterHelmetStyle( 0 );
-	
-	switch( self.characterIndex )
-	{
-		case 1:
-		{
-				// Nikolai
-//				level.vox zm_audio::zmbVoxInitSpeaker( "player", "vox_plr_", self );				
-				self.favorite_wall_weapons_list[self.favorite_wall_weapons_list.size] = GetWeapon( "870mcs" );
-				self.character_name = "Sal";
-				break;
-		}
-		case 0:
-		{
-				// Dempsey
-
-//				level.vox zm_audio::zmbVoxInitSpeaker( "player", "vox_plr_", self );				
-				self.favorite_wall_weapons_list[self.favorite_wall_weapons_list.size] = GetWeapon( "frag_grenade" );
-				self.favorite_wall_weapons_list[self.favorite_wall_weapons_list.size] = GetWeapon( "bouncingbetty" );
-				self.character_name = "Finn";
-				break;
-		}
-		case 2:
-		{
-				// Takeo
-//				level.vox zm_audio::zmbVoxInitSpeaker( "player", "vox_plr_", self );
-				self.favorite_wall_weapons_list[self.favorite_wall_weapons_list.size] = GetWeapon( "hk416" );
-				self.character_name = "Billy";
-				break;
-		}
-		case 3:
-		{	
-				// Richtofen
-//				level.vox zm_audio::zmbVoxInitSpeaker( "player", "vox_plr_", self );
-				self.talks_in_danger = true;
-				level.rich_sq_player = self;
-				level.sndRadioA = self;
-				self.favorite_wall_weapons_list[self.favorite_wall_weapons_list.size] = GetWeapon( "pistol_standard" );
-				self.character_name = "Arlington";
-				break;
-		}
-	}	
-
-	self SetMoveSpeedScale( 1 );
-	self SetSprintDuration( 4 );
-	self SetSprintCooldown( 0 );	
-
-	//self zm_utility::set_player_tombstone_index();	
-	self thread set_exert_id();
-	
-}
-
-function set_exert_id()
-{
-	self endon("disconnect");
-	
-	util::wait_network_frame();
-	util::wait_network_frame();
-	
-	self zm_audio::SetExertVoice(self.characterIndex + 1);
-}
-
-function setup_personality_character_exerts()
-{
-	level.exert_sounds[1]["burp"][0] = "evt_belch";
-	level.exert_sounds[1]["burp"][1] = "evt_belch";
-	level.exert_sounds[1]["burp"][2] = "evt_belch";
-
-	level.exert_sounds[2]["burp"][0] = "evt_belch";
-	level.exert_sounds[2]["burp"][1] = "evt_belch";
-	level.exert_sounds[2]["burp"][2] = "evt_belch";
-
-	level.exert_sounds[3]["burp"][0] = "evt_belch";
-	level.exert_sounds[3]["burp"][1] = "evt_belch";
-	level.exert_sounds[3]["burp"][2] = "evt_belch";
-	
-	level.exert_sounds[4]["burp"][0] = "evt_belch";
-	level.exert_sounds[4]["burp"][1] = "evt_belch";
-	level.exert_sounds[4]["burp"][2] = "evt_belch";
-	
-
-	// medium hit
-	level.exert_sounds[1]["hitmed"][0] = "vox_plr_0_exert_pain_0";
-	level.exert_sounds[1]["hitmed"][1] = "vox_plr_0_exert_pain_1";
-	level.exert_sounds[1]["hitmed"][2] = "vox_plr_0_exert_pain_2";
-	level.exert_sounds[1]["hitmed"][3] = "vox_plr_0_exert_pain_3";
-	level.exert_sounds[1]["hitmed"][4] = "vox_plr_0_exert_pain_4";
-	
-	level.exert_sounds[2]["hitmed"][0] = "vox_plr_1_exert_pain_0";
-	level.exert_sounds[2]["hitmed"][1] = "vox_plr_1_exert_pain_1";
-	level.exert_sounds[2]["hitmed"][2] = "vox_plr_1_exert_pain_2";
-	level.exert_sounds[2]["hitmed"][3] = "vox_plr_1_exert_pain_3";
-	level.exert_sounds[2]["hitmed"][4] = "vox_plr_1_exert_pain_4";
-	
-	level.exert_sounds[3]["hitmed"][0] = "vox_plr_2_exert_pain_0";
-	level.exert_sounds[3]["hitmed"][1] = "vox_plr_2_exert_pain_1";
-	level.exert_sounds[3]["hitmed"][2] = "vox_plr_2_exert_pain_2";
-	level.exert_sounds[3]["hitmed"][3] = "vox_plr_2_exert_pain_3";
-	level.exert_sounds[3]["hitmed"][4] = "vox_plr_2_exert_pain_4";
-	
-	level.exert_sounds[4]["hitmed"][0] = "vox_plr_3_exert_pain_0";
-	level.exert_sounds[4]["hitmed"][1] = "vox_plr_3_exert_pain_1";
-	level.exert_sounds[4]["hitmed"][2] = "vox_plr_3_exert_pain_2";
-	level.exert_sounds[4]["hitmed"][3] = "vox_plr_3_exert_pain_3";
-	level.exert_sounds[4]["hitmed"][4] = "vox_plr_3_exert_pain_4";
-
-	// large hit
-	level.exert_sounds[1]["hitlrg"][0] = "vox_plr_0_exert_pain_0";
-	level.exert_sounds[1]["hitlrg"][1] = "vox_plr_0_exert_pain_1";
-	level.exert_sounds[1]["hitlrg"][2] = "vox_plr_0_exert_pain_2";
-	level.exert_sounds[1]["hitlrg"][3] = "vox_plr_0_exert_pain_3";
-	level.exert_sounds[1]["hitlrg"][4] = "vox_plr_0_exert_pain_4";
-	
-	level.exert_sounds[2]["hitlrg"][0] = "vox_plr_1_exert_pain_0";
-	level.exert_sounds[2]["hitlrg"][1] = "vox_plr_1_exert_pain_1";
-	level.exert_sounds[2]["hitlrg"][2] = "vox_plr_1_exert_pain_2";
-	level.exert_sounds[2]["hitlrg"][3] = "vox_plr_1_exert_pain_3";
-	level.exert_sounds[2]["hitlrg"][4] = "vox_plr_1_exert_pain_4";
-	
-	level.exert_sounds[3]["hitlrg"][0] = "vox_plr_2_exert_pain_0";
-	level.exert_sounds[3]["hitlrg"][1] = "vox_plr_2_exert_pain_1";
-	level.exert_sounds[3]["hitlrg"][2] = "vox_plr_2_exert_pain_2";
-	level.exert_sounds[3]["hitlrg"][3] = "vox_plr_2_exert_pain_3";
-	level.exert_sounds[3]["hitlrg"][4] = "vox_plr_2_exert_pain_4";
-	
-	level.exert_sounds[4]["hitlrg"][0] = "vox_plr_3_exert_pain_0";
-	level.exert_sounds[4]["hitlrg"][1] = "vox_plr_3_exert_pain_1";
-	level.exert_sounds[4]["hitlrg"][2] = "vox_plr_3_exert_pain_2";
-	level.exert_sounds[4]["hitlrg"][3] = "vox_plr_3_exert_pain_3";
-	level.exert_sounds[4]["hitlrg"][4] = "vox_plr_3_exert_pain_4";
-}
-
-function giveCustomLoadout( takeAllWeapons, alreadySpawned )
-{
-	self giveWeapon( level.weaponBaseMelee );
-	self zm_utility::give_start_weapon( true );
-}
-
-function custom_add_weapons()
-{
-	zm_weapons::load_weapon_spec_from_table("gamedata/weapons/zm/zm_levelcommon_weapons_testing.csv", 1);
+	zm_weapons::load_weapon_spec_from_table("gamedata/weapons/zm/zm_levelcommon_weapons.csv", 1);
 }
 
 #define JUGGERNAUT_MACHINE_LIGHT_FX				"jugger_light"		
@@ -475,41 +139,75 @@ function custom_add_weapons()
 #define DEADSHOT_MACHINE_LIGHT_FX				"deadshot_light"		
 #define ADDITIONAL_PRIMARY_WEAPON_MACHINE_LIGHT_FX					"additionalprimaryweapon_light"
 
-
-function perk_init()
+function include_perks()
 {
 	level._effect[JUGGERNAUT_MACHINE_LIGHT_FX] = "zombie/fx_perk_juggernaut_factory_zmb";
 	level._effect[QUICK_REVIVE_MACHINE_LIGHT_FX] = "zombie/fx_perk_quick_revive_factory_zmb";
 	level._effect[SLEIGHT_OF_HAND_MACHINE_LIGHT_FX] = "zombie/fx_perk_sleight_of_hand_factory_zmb";
-	level._effect[DOUBLETAP2_MACHINE_LIGHT_FX] = "zombie/fx_perk_doubletap2_factory_zmb";	
+	level._effect[DOUBLETAP2_MACHINE_LIGHT_FX] = "zombie/fx_perk_doubletap2_factory_zmb";
 	level._effect[DEADSHOT_MACHINE_LIGHT_FX] = "zombie/fx_perk_daiquiri_factory_zmb";
 	level._effect[STAMINUP_MACHINE_LIGHT_FX] = "zombie/fx_perk_stamin_up_factory_zmb";
-	level._effect[ADDITIONAL_PRIMARY_WEAPON_MACHINE_LIGHT_FX] = "zombie/fx_perk_mule_kick_factory_zmb";
-}
+	level._effect[ADDITIONAL_PRIMARY_WEAPON_MACHINE_LIGHT_FX] = "zombie/fx_perk_mule_kick_factory_zmb";	
 
+	//level flag::wait_till( "initial_blackscreen_passed" );
 
-function sndFunctions()
-{
-	level thread setupMusic();
+	//level._custom_perks[PERK_DOUBLETAP2].machine_light_effect = DOUBLETAP2_MACHINE_LIGHT_FX;
 }
 
-#define PLAYTYPE_REJECT 1
-#define PLAYTYPE_QUEUE 2
-#define PLAYTYPE_ROUND 3
-#define PLAYTYPE_SPECIAL 4
-#define PLAYTYPE_GAMEEND 5
-function setupMusic()
+function setup_personality_character_exerts()
 {
-	zm_audio::musicState_Create("round_start", PLAYTYPE_ROUND, "roundstart1", "roundstart2", "roundstart3", "roundstart4" );
-	//zm_audio::musicState_Create("round_start_afterlife", PLAYTYPE_ROUND, "alroundstart1", "alroundstart2", "alroundstart3", "alroundstart4", "alroundstart5", "alroundstart6" );
-	zm_audio::musicState_Create("round_start_short", PLAYTYPE_ROUND, "roundstart_short1", "roundstart_short2", "roundstart_short3", "roundstart_short4" );
-	zm_audio::musicState_Create("round_start_first", PLAYTYPE_ROUND, "roundstart_first" );
-	zm_audio::musicState_Create("round_end", PLAYTYPE_ROUND, "roundend1" );
-	zm_audio::musicState_Create("game_over", PLAYTYPE_GAMEEND, "gameover" );
-	zm_audio::musicState_Create("dog_start", PLAYTYPE_ROUND, "dogstart1" );
-	zm_audio::musicState_Create("dog_end", PLAYTYPE_ROUND, "dogend1" );
-	zm_audio::musicState_Create("timer", PLAYTYPE_ROUND, "timer" );
-	zm_audio::musicState_Create("power_on", PLAYTYPE_QUEUE, "poweron" );
+	// falling damage
+	level.exert_sounds[1]["falldamage"][0] = "vox_plr_0_exert_pain_0";
+	level.exert_sounds[1]["falldamage"][1] = "vox_plr_0_exert_pain_1";
+	level.exert_sounds[1]["falldamage"][2] = "vox_plr_0_exert_pain_2";
+	level.exert_sounds[1]["falldamage"][3] = "vox_plr_0_exert_pain_3";
+	level.exert_sounds[1]["falldamage"][4] = "vox_plr_0_exert_pain_4";
+	
+	level.exert_sounds[2]["falldamage"][0] = "vox_plr_1_exert_pain_0";
+	level.exert_sounds[2]["falldamage"][1] = "vox_plr_1_exert_pain_1";
+	level.exert_sounds[2]["falldamage"][2] = "vox_plr_1_exert_pain_2";
+	level.exert_sounds[2]["falldamage"][3] = "vox_plr_1_exert_pain_3";
+	level.exert_sounds[2]["falldamage"][4] = "vox_plr_1_exert_pain_4";
+	
+	level.exert_sounds[3]["falldamage"][0] = "vox_plr_2_exert_pain_0";
+	level.exert_sounds[3]["falldamage"][1] = "vox_plr_2_exert_pain_1";
+	level.exert_sounds[3]["falldamage"][2] = "vox_plr_2_exert_pain_2";
+	level.exert_sounds[3]["falldamage"][3] = "vox_plr_2_exert_pain_3";
+	level.exert_sounds[3]["falldamage"][4] = "vox_plr_2_exert_pain_4";
+	
+	level.exert_sounds[4]["falldamage"][0] = "vox_plr_3_exert_pain_0";
+	level.exert_sounds[4]["falldamage"][1] = "vox_plr_3_exert_pain_1";
+	level.exert_sounds[4]["falldamage"][2] = "vox_plr_3_exert_pain_2";
+	level.exert_sounds[4]["falldamage"][3] = "vox_plr_3_exert_pain_3";
+	level.exert_sounds[4]["falldamage"][4] = "vox_plr_3_exert_pain_4";
+	
+	// melee swipe
+	level.exert_sounds[1]["meleeswipesoundplayer"][0] = "vox_plr_0_exert_melee_0";
+	level.exert_sounds[1]["meleeswipesoundplayer"][1] = "vox_plr_0_exert_melee_1";
+	level.exert_sounds[1]["meleeswipesoundplayer"][2] = "vox_plr_0_exert_melee_2";
+	level.exert_sounds[1]["meleeswipesoundplayer"][3] = "vox_plr_0_exert_melee_3";
+	level.exert_sounds[1]["meleeswipesoundplayer"][4] = "vox_plr_0_exert_melee_4";
+	level.exert_sounds[1]["meleeswipesoundplayer"][5] = "vox_plr_0_exert_melee_5";
+	
+	level.exert_sounds[2]["meleeswipesoundplayer"][0] = "vox_plr_1_exert_melee_0";
+	level.exert_sounds[2]["meleeswipesoundplayer"][1] = "vox_plr_1_exert_melee_1";
+	level.exert_sounds[2]["meleeswipesoundplayer"][2] = "vox_plr_1_exert_melee_2";
+	level.exert_sounds[2]["meleeswipesoundplayer"][3] = "vox_plr_1_exert_melee_3";
+	level.exert_sounds[2]["meleeswipesoundplayer"][4] = "vox_plr_1_exert_melee_4";
+	level.exert_sounds[2]["meleeswipesoundplayer"][5] = "vox_plr_1_exert_melee_5";
+	
+	level.exert_sounds[3]["meleeswipesoundplayer"][0] = "vox_plr_2_exert_melee_0";
+	level.exert_sounds[3]["meleeswipesoundplayer"][1] = "vox_plr_2_exert_melee_1";
+	level.exert_sounds[3]["meleeswipesoundplayer"][2] = "vox_plr_2_exert_melee_2";
+	level.exert_sounds[3]["meleeswipesoundplayer"][3] = "vox_plr_2_exert_melee_3";
+	level.exert_sounds[3]["meleeswipesoundplayer"][4] = "vox_plr_2_exert_melee_4";
+	level.exert_sounds[3]["meleeswipesoundplayer"][5] = "vox_plr_2_exert_melee_5";	
+	
+	level.exert_sounds[4]["meleeswipesoundplayer"][0] = "vox_plr_3_exert_melee_0";
+	level.exert_sounds[4]["meleeswipesoundplayer"][1] = "vox_plr_3_exert_melee_1";
+	level.exert_sounds[4]["meleeswipesoundplayer"][2] = "vox_plr_3_exert_melee_2";
+	level.exert_sounds[4]["meleeswipesoundplayer"][3] = "vox_plr_3_exert_melee_3";
+	level.exert_sounds[4]["meleeswipesoundplayer"][4] = "vox_plr_3_exert_melee_4";	
+	level.exert_sounds[4]["meleeswipesoundplayer"][5] = "vox_plr_3_exert_melee_5";
 }
 
-
diff --git a/scripts/zm/zm_weap_tomahawk.gsc b/scripts/zm/zm_weap_tomahawk.gsc
index f74f109..d95f284 100644
--- a/scripts/zm/zm_weap_tomahawk.gsc
+++ b/scripts/zm/zm_weap_tomahawk.gsc
@@ -219,7 +219,7 @@ function tomahawk_thrown( grenade )
 			return;
 		}
 	}
-	if( level.tomahawk_poster == true)
+	if(level.tomahawk_poster == true)
 	{
 		complete = self zm_prison_spoon::tomahawk_the_poster(grenade, self);
 		if(complete == 1)
@@ -519,7 +519,7 @@ function tomahawk_pickup()
 		trigger.script_noteworthy = "retriever_pickup_trigger";
 		trigger useTriggerRequireLookAt();
 		trigger triggerIgnoreTeam();
-		trigger setHintString( "Hold ^3&&1^7 for Hell's Retriever" );
+		trigger setHintString( "Hold ^3&&1^7 to pick up Hell's Retriever" );
 		trigger setCursorHint( "HINT_NOICON" );
 	
 		trigger thread tomahawk_pickup_trigger( "zombie_tomahawk" );
@@ -531,7 +531,7 @@ function tomahawk_pickup()
 		trigger_upgraded triggerIgnoreTeam();
 		m_tomahawk clientfield::set( "play_tomahawk_fx", 2 );
 		trigger_upgraded.script_noteworthy = "redeemer_pickup_trigger";
-		trigger_upgraded setHintString( "Hold ^3&&1^7 for Hell's Redeemer" );
+		trigger_upgraded setHintString( "Hold ^3&&1^7 to pick up Hell's Redeemer" );
 		trigger_upgraded setCursorHint( "HINT_NOICON" );
 	
 		trigger_upgraded thread tomahawk_pickup_trigger( "zombie_tomahawk_upgraded" );
@@ -571,9 +571,9 @@ function tomahawk_pickup_trigger( tomahawk )
 		player.loadout.hastomahawk = 1;
 		player TakeWeapon( GetWeapon( tomahawk + "_flourish" ) );
 		
-		name = "Hell's Retriever";
+		name = "Retriever";
 		if ( tomahawk == "zombie_tomahawk_upgraded" )
-			name = "Hell's Redeemer";
+			name = "Redeemer";
 		
 		player thread tomahawk_tutorial_hint( name );
 		
@@ -640,7 +640,7 @@ function setting_tutorial_hud()
 function tomahawk_tutorial_hint( name )
 {
 	hud = setting_tutorial_hud();
-	hud setText( "Press [{+smoke}] to Throw the " + name );
+	hud setText( "Press ^3[{+smoke}]^7 to Throw the " + name );
 	self util::waittill_notify_or_timeout( "throwing_tomahawk", 5 );
 	wait 1;
 	hud destroy();
diff --git a/zone_source/zm_mod.zone b/zone_source/zm_mod.zone
index 011b0cb..e5889b1 100644
--- a/zone_source/zm_mod.zone
+++ b/zone_source/zm_mod.zone
@@ -14,21 +14,45 @@ localize,ZM_PRISON
 
 sound,zm_mod
 
+ttf,fonts/Agency.ttf
+
 rawfile,vision/afterlife.vision
+rawfile,vision/zm_alcatraz_cellblock.vision
+rawfile,vision/zm_alcatraz_underground.vision
+rawfile,vision/zm_alcatraz_outside.vision
+rawfile,vision/zm_alcatraz_bw.vision
+
+xanim,ai_actor_elec_chair_idle
+scriptbundle,ai_actor_chairshit
 
 fx,lensflares/fx_lensflare_fire_grime
 
+//fx,harry/zm_perks/fx_perk_doubletap_light
+
+//fx,zombie/fx_perk_doubletap2_factory_zmb
+//fx,dog/fx_perk_doubletap_light
+
+//fx,custom/fx_weapon_box_marker_zmb
+//fx,custom/fx_weapon_box_marker_fl_zmb
+
 scriptparsetree,scripts\zm\_zm.gsc
 scriptparsetree,scripts\zm\_zm.csc
 
+// scriptparsetree,scripts\zm\zm_prison_traps.gsc
+
 scriptparsetree,scripts\zm\_load.gsc
 scriptparsetree,scripts\zm\zm_giant_cleanup_mgr.gsc
 
 scriptparsetree,scripts/zm/_zm_perks.gsc
 
+scriptparsetree,scripts/zm/_zm_spawner.gsc
+
 scriptparsetree,scripts/zm/_zm_powerup_full_ammo.gsc
 scriptparsetree,scripts/zm/_zm_powerup_full_ammo.csc
 
+scriptparsetree,scripts/zm/_zm_powerup_carpenter.gsc
+scriptparsetree,scripts/zm/_zm_powerup_carpenter.csc
+
 stringtable,gamedata/audio/zm/zm_al_vox.csv
 stringtable,gamedata/weapons/zm/zm_motd_weapons.csv
 
@@ -49,9 +73,12 @@ scriptparsetree,scripts/zm/_zm_ai_brutus.gsc
 
 scriptparsetree,scripts/zm/zm_prison_sq_bg.gsc
 
+scriptparsetree,scripts/zm/zm_prison_weap_quest.gsc
+
 scriptparsetree,scripts/zm/zm_alcatraz_amb.gsc
 
 scriptparsetree,scripts/zm/zm_usermap.gsc
+scriptparsetree,scripts/zm/zm_usermap.csc
 
 scriptparsetree,scripts/zm/_zm_afterlife.gsc
 scriptparsetree,scripts/zm/_zm_afterlife.csc
@@ -63,6 +90,7 @@ weapon,lightning_hands_zm
 weapon,lightning_hands_revive_zm
 
 weapon,spoon_alcatraz_zm
+weapon,spork_alcatraz_zm
 
 //weapon,m1911dw_zm
 //weapon,pistol_m1911_zm
@@ -83,6 +111,8 @@ scriptparsetree,scripts/zm/zm_alcatraz_sq_vo.gsc
 scriptparsetree,scripts/zm/zm_alcatraz_utility.gsc
 scriptparsetree,scripts/zm/zm_alcatraz_hud_buildables.gsc
 
+//scriptparsetree,scripts/zm/_zm_powerups.gsc
+
 scriptparsetree,scripts/zm/zm_prison_travel.gsc
 
 scriptparsetree,scripts/zm/craftables/_zm_craft_shield.gsc
@@ -94,12 +124,15 @@ scriptparsetree,scripts/zm/_zm_magicbox_lock.gsc
 scriptparsetree,scripts/zm/_zm_magicbox_prison.gsc
 scriptparsetree,scripts/zm/_zm_magicbox_prison.csc
 scriptparsetree,scripts/zm/zm_prison_sq_final.gsc
+scriptparsetree,scripts/zm/zm_prison_sq_final.csc
 
 scriptparsetree,scripts/zm/zm_alcatraz_craftables.gsc
 scriptparsetree,scripts/zm/zm_alcatraz_craftables.csc
 
 scriptparsetree,scripts/zm/zm_alcatraz_island.gsc
 
+scriptparsetree,scripts/zm/zm_alcatraz_visions.gsc
+
 aitype,archetype_zm_cellbreaker
 aitype,variant_zm_cellbreaker
 aitype,spawner_zm_cellbreaker