diff --git a/patch_zm/maps/mp/zombies/_zm_audio.gsc b/patch_zm/maps/mp/zombies/_zm_audio.gsc
new file mode 100644
index 0000000..b56d94b
--- /dev/null
+++ b/patch_zm/maps/mp/zombies/_zm_audio.gsc
@@ -0,0 +1,1461 @@
+#include maps/mp/zombies/_zm_spawner;
+#include maps/mp/_music;
+#include maps/mp/zombies/_zm_laststand;
+#include maps/mp/zombies/_zm_audio;
+#include maps/mp/zombies/_zm_weapons;
+#include maps/mp/zombies/_zm_utility;
+#include maps/mp/_utility;
+#include common_scripts/utility;
+
+init()
+{
+	registerclientfield( "allplayers", "charindex", 1, 3, "int" );
+	registerclientfield( "toplayer", "isspeaking", 1, 1, "int" );
+	level.audio_get_mod_type = ::get_mod_type;
+	level zmbvox();
+	level init_music_states();
+	level maps/mp/zombies/_zm_audio_announcer::init();
+	onplayerconnect_callback( ::init_audio_functions );
+}
+
+setexertvoice( exert_id )
+{
+	self.player_exert_id = exert_id;
+	self setclientfield( "charindex", self.player_exert_id );
+}
+
+playerexert( exert )
+{
+	if ( isDefined( self.isspeaking ) || self.isspeaking && isDefined( self.isexerting ) && self.isexerting )
+	{
+		return;
+	}
+	id = level.exert_sounds[ 0 ][ exert ];
+	if ( isDefined( self.player_exert_id ) )
+	{
+		if ( isarray( level.exert_sounds[ self.player_exert_id ][ exert ] ) )
+		{
+			id = random( level.exert_sounds[ self.player_exert_id ][ exert ] );
+		}
+		else
+		{
+			id = level.exert_sounds[ self.player_exert_id ][ exert ];
+		}
+	}
+	self.isexerting = 1;
+	self thread exert_timer();
+	self playsound( id );
+}
+
+exert_timer()
+{
+	self endon( "disconnect" );
+	wait randomfloatrange( 1,5, 3 );
+	self.isexerting = 0;
+}
+
+zmbvox()
+{
+	level.votimer = [];
+	level.vox = zmbvoxcreate();
+	init_standard_response_chances();
+	level.vox zmbvoxadd( "player", "general", "crawl_spawn", "crawler_start", "resp_crawler_start" );
+	level.vox zmbvoxadd( "player", "general", "hr_resp_crawler_start", "hr_resp_crawler_start", undefined );
+	level.vox zmbvoxadd( "player", "general", "riv_resp_crawler_start", "riv_resp_crawler_start", undefined );
+	level.vox zmbvoxadd( "player", "general", "ammo_low", "ammo_low", undefined );
+	level.vox zmbvoxadd( "player", "general", "ammo_out", "ammo_out", undefined );
+	level.vox zmbvoxadd( "player", "general", "door_deny", "nomoney_generic", undefined );
+	level.vox zmbvoxadd( "player", "general", "perk_deny", "nomoney_perk", undefined );
+	level.vox zmbvoxadd( "player", "general", "shoot_arm", "kill_limb", undefined );
+	level.vox zmbvoxadd( "player", "general", "box_move", "box_move", undefined );
+	level.vox zmbvoxadd( "player", "general", "no_money", "nomoney", undefined );
+	level.vox zmbvoxadd( "player", "general", "oh_shit", "oh_shit", "resp_surrounded" );
+	level.vox zmbvoxadd( "player", "general", "hr_resp_surrounded", "hr_resp_surrounded", undefined );
+	level.vox zmbvoxadd( "player", "general", "riv_resp_surrounded", "riv_resp_surrounded", undefined );
+	level.vox zmbvoxadd( "player", "general", "revive_down", "revive_down", undefined );
+	level.vox zmbvoxadd( "player", "general", "revive_up", "revive_up", undefined );
+	level.vox zmbvoxadd( "player", "general", "crawl_hit", "crawler_attack", undefined );
+	level.vox zmbvoxadd( "player", "general", "sigh", "sigh", undefined );
+	level.vox zmbvoxadd( "player", "general", "round_5", "round_5", undefined );
+	level.vox zmbvoxadd( "player", "general", "round_20", "round_20", undefined );
+	level.vox zmbvoxadd( "player", "general", "round_10", "round_10", undefined );
+	level.vox zmbvoxadd( "player", "general", "round_35", "round_35", undefined );
+	level.vox zmbvoxadd( "player", "general", "round_50", "round_50", undefined );
+	level.vox zmbvoxadd( "player", "perk", "specialty_armorvest", "perk_jugga", undefined );
+	level.vox zmbvoxadd( "player", "perk", "specialty_quickrevive", "perk_revive", undefined );
+	level.vox zmbvoxadd( "player", "perk", "specialty_fastreload", "perk_speed", undefined );
+	level.vox zmbvoxadd( "player", "perk", "specialty_rof", "perk_doubletap", undefined );
+	level.vox zmbvoxadd( "player", "perk", "specialty_longersprint", "perk_stamine", undefined );
+	level.vox zmbvoxadd( "player", "perk", "specialty_flakjacket", "perk_phdflopper", undefined );
+	level.vox zmbvoxadd( "player", "perk", "specialty_deadshot", "perk_deadshot", undefined );
+	level.vox zmbvoxadd( "player", "perk", "specialty_finalstand", "perk_who", undefined );
+	level.vox zmbvoxadd( "player", "perk", "specialty_additionalprimaryweapon", "perk_mulekick", undefined );
+	level.vox zmbvoxadd( "player", "powerup", "nuke", "powerup_nuke", undefined );
+	level.vox zmbvoxadd( "player", "powerup", "insta_kill", "powerup_insta", undefined );
+	level.vox zmbvoxadd( "player", "powerup", "full_ammo", "powerup_ammo", undefined );
+	level.vox zmbvoxadd( "player", "powerup", "double_points", "powerup_double", undefined );
+	level.vox zmbvoxadd( "player", "powerup", "carpenter", "powerup_carp", undefined );
+	level.vox zmbvoxadd( "player", "powerup", "firesale", "powerup_firesale", undefined );
+	level.vox zmbvoxadd( "player", "powerup", "minigun", "powerup_minigun", undefined );
+	level.vox zmbvoxadd( "player", "kill", "melee", "kill_melee", undefined );
+	level.vox zmbvoxadd( "player", "kill", "melee_instakill", "kill_insta", undefined );
+	level.vox zmbvoxadd( "player", "kill", "weapon_instakill", "kill_insta", undefined );
+	level.vox zmbvoxadd( "player", "kill", "closekill", "kill_close", undefined );
+	level.vox zmbvoxadd( "player", "kill", "damage", "kill_damaged", undefined );
+	level.vox zmbvoxadd( "player", "kill", "streak", "kill_streak", undefined );
+	level.vox zmbvoxadd( "player", "kill", "headshot", "kill_headshot", "resp_kill_headshot" );
+	level.vox zmbvoxadd( "player", "kill", "hr_resp_kill_headshot", "hr_resp_kill_headshot", undefined );
+	level.vox zmbvoxadd( "player", "kill", "riv_resp_kill_headshot", "riv_resp_kill_headshot", undefined );
+	level.vox zmbvoxadd( "player", "kill", "explosive", "kill_explo", undefined );
+	level.vox zmbvoxadd( "player", "kill", "flame", "kill_flame", undefined );
+	level.vox zmbvoxadd( "player", "kill", "raygun", "kill_ray", undefined );
+	level.vox zmbvoxadd( "player", "kill", "bullet", "kill_streak", undefined );
+	level.vox zmbvoxadd( "player", "kill", "tesla", "kill_tesla", undefined );
+	level.vox zmbvoxadd( "player", "kill", "monkey", "kill_monkey", undefined );
+	level.vox zmbvoxadd( "player", "kill", "thundergun", "kill_thunder", undefined );
+	level.vox zmbvoxadd( "player", "kill", "freeze", "kill_freeze", undefined );
+	level.vox zmbvoxadd( "player", "kill", "crawler", "crawler_kill", undefined );
+	level.vox zmbvoxadd( "player", "kill", "hellhound", "kill_hellhound", undefined );
+	level.vox zmbvoxadd( "player", "kill", "quad", "kill_quad", undefined );
+	level.vox zmbvoxadd( "player", "weapon_pickup", "pistol", "wpck_crappy", undefined );
+	level.vox zmbvoxadd( "player", "weapon_pickup", "smg", "wpck_smg", undefined );
+	level.vox zmbvoxadd( "player", "weapon_pickup", "dualwield", "wpck_dual", undefined );
+	level.vox zmbvoxadd( "player", "weapon_pickup", "shotgun", "wpck_shotgun", undefined );
+	level.vox zmbvoxadd( "player", "weapon_pickup", "rifle", "wpck_sniper", undefined );
+	level.vox zmbvoxadd( "player", "weapon_pickup", "burstrifle", "wpck_mg", undefined );
+	level.vox zmbvoxadd( "player", "weapon_pickup", "assault", "wpck_mg", undefined );
+	level.vox zmbvoxadd( "player", "weapon_pickup", "sniper", "wpck_sniper", undefined );
+	level.vox zmbvoxadd( "player", "weapon_pickup", "mg", "wpck_mg", undefined );
+	level.vox zmbvoxadd( "player", "weapon_pickup", "launcher", "wpck_launcher", undefined );
+	level.vox zmbvoxadd( "player", "weapon_pickup", "grenade", "wpck_grenade", undefined );
+	level.vox zmbvoxadd( "player", "weapon_pickup", "bowie", "wpck_bowie", undefined );
+	level.vox zmbvoxadd( "player", "weapon_pickup", "raygun", "wpck_raygun", undefined );
+	level.vox zmbvoxadd( "player", "weapon_pickup", "monkey", "wpck_monkey", "resp_wpck_monkey" );
+	level.vox zmbvoxadd( "player", "weapon_pickup", "hr_resp_wpck_monkey", "hr_resp_wpck_monkey", undefined );
+	level.vox zmbvoxadd( "player", "weapon_pickup", "riv_resp_wpck_monkey", "riv_resp_wpck_monkey", undefined );
+	level.vox zmbvoxadd( "player", "weapon_pickup", "crossbow", "wpck_launcher", undefined );
+	level.vox zmbvoxadd( "player", "weapon_pickup", "upgrade", "wpck_upgrade", undefined );
+	level.vox zmbvoxadd( "player", "weapon_pickup", "favorite", "wpck_favorite", undefined );
+	level.vox zmbvoxadd( "player", "weapon_pickup", "favorite_upgrade", "wpck_favorite_upgrade", undefined );
+	level.vox zmbvoxadd( "player", "player_death", "player_death", "evt_player_final_hit", undefined );
+	level.zmb_vox = [];
+	level.zmb_vox[ "prefix" ] = "zmb_vocals_";
+	level.zmb_vox[ "zombie" ] = [];
+	level.zmb_vox[ "zombie" ][ "ambient" ] = "zombie_ambience";
+	level.zmb_vox[ "zombie" ][ "sprint" ] = "zombie_sprint";
+	level.zmb_vox[ "zombie" ][ "attack" ] = "zombie_attack";
+	level.zmb_vox[ "zombie" ][ "teardown" ] = "zombie_teardown";
+	level.zmb_vox[ "zombie" ][ "taunt" ] = "zombie_taunt";
+	level.zmb_vox[ "zombie" ][ "behind" ] = "zombie_behind";
+	level.zmb_vox[ "zombie" ][ "death" ] = "zombie_death";
+	level.zmb_vox[ "zombie" ][ "crawler" ] = "zombie_crawler";
+	level.zmb_vox[ "zombie" ][ "electrocute" ] = "zombie_electrocute";
+	level.zmb_vox[ "quad_zombie" ] = [];
+	level.zmb_vox[ "quad_zombie" ][ "ambient" ] = "quad_ambience";
+	level.zmb_vox[ "quad_zombie" ][ "sprint" ] = "quad_sprint";
+	level.zmb_vox[ "quad_zombie" ][ "attack" ] = "quad_attack";
+	level.zmb_vox[ "quad_zombie" ][ "behind" ] = "quad_behind";
+	level.zmb_vox[ "quad_zombie" ][ "death" ] = "quad_death";
+	level.zmb_vox[ "thief_zombie" ] = [];
+	level.zmb_vox[ "thief_zombie" ][ "ambient" ] = "thief_ambience";
+	level.zmb_vox[ "thief_zombie" ][ "sprint" ] = "thief_sprint";
+	level.zmb_vox[ "thief_zombie" ][ "steal" ] = "thief_steal";
+	level.zmb_vox[ "thief_zombie" ][ "death" ] = "thief_death";
+	level.zmb_vox[ "thief_zombie" ][ "anger" ] = "thief_anger";
+	level.zmb_vox[ "boss_zombie" ] = [];
+	level.zmb_vox[ "boss_zombie" ][ "ambient" ] = "boss_ambience";
+	level.zmb_vox[ "boss_zombie" ][ "sprint" ] = "boss_sprint";
+	level.zmb_vox[ "boss_zombie" ][ "attack" ] = "boss_attack";
+	level.zmb_vox[ "boss_zombie" ][ "behind" ] = "boss_behind";
+	level.zmb_vox[ "boss_zombie" ][ "death" ] = "boss_death";
+	level.zmb_vox[ "leaper_zombie" ] = [];
+	level.zmb_vox[ "leaper_zombie" ][ "ambient" ] = "leaper_ambience";
+	level.zmb_vox[ "leaper_zombie" ][ "sprint" ] = "leaper_ambience";
+	level.zmb_vox[ "leaper_zombie" ][ "attack" ] = "leaper_attack";
+	level.zmb_vox[ "leaper_zombie" ][ "behind" ] = "leaper_close";
+	level.zmb_vox[ "leaper_zombie" ][ "death" ] = "leaper_death";
+	level.zmb_vox[ "monkey_zombie" ] = [];
+	level.zmb_vox[ "monkey_zombie" ][ "ambient" ] = "monkey_ambience";
+	level.zmb_vox[ "monkey_zombie" ][ "sprint" ] = "monkey_sprint";
+	level.zmb_vox[ "monkey_zombie" ][ "attack" ] = "monkey_attack";
+	level.zmb_vox[ "monkey_zombie" ][ "behind" ] = "monkey_behind";
+	level.zmb_vox[ "monkey_zombie" ][ "death" ] = "monkey_death";
+	level.zmb_vox[ "capzomb" ] = [];
+	level.zmb_vox[ "capzomb" ][ "ambient" ] = "capzomb_ambience";
+	level.zmb_vox[ "capzomb" ][ "sprint" ] = "capzomb_sprint";
+	level.zmb_vox[ "capzomb" ][ "attack" ] = "capzomb_attack";
+	level.zmb_vox[ "capzomb" ][ "teardown" ] = "capzomb_ambience";
+	level.zmb_vox[ "capzomb" ][ "taunt" ] = "capzomb_ambience";
+	level.zmb_vox[ "capzomb" ][ "behind" ] = "capzomb_behind";
+	level.zmb_vox[ "capzomb" ][ "death" ] = "capzomb_death";
+	level.zmb_vox[ "capzomb" ][ "crawler" ] = "capzomb_crawler";
+	level.zmb_vox[ "capzomb" ][ "electrocute" ] = "zombie_electrocute";
+	if ( isDefined( level._zmbvoxlevelspecific ) )
+	{
+		level thread [[ level._zmbvoxlevelspecific ]]();
+	}
+	if ( isDefined( level._zmbvoxgametypespecific ) )
+	{
+		level thread [[ level._zmbvoxgametypespecific ]]();
+	}
+	announcer_ent = spawn( "script_origin", ( 0, 0, 0 ) );
+	level.vox zmbvoxinitspeaker( "announcer", "vox_zmba_", announcer_ent );
+	level.exert_sounds[ 0 ][ "burp" ] = "evt_belch";
+	level.exert_sounds[ 0 ][ "hitmed" ] = "null";
+	level.exert_sounds[ 0 ][ "hitlrg" ] = "null";
+	if ( isDefined( level.setupcustomcharacterexerts ) )
+	{
+		[[ level.setupcustomcharacterexerts ]]();
+	}
+}
+
+init_standard_response_chances()
+{
+	level.response_chances = [];
+	add_vox_response_chance( "sickle", 40 );
+	add_vox_response_chance( "melee", 40 );
+	add_vox_response_chance( "melee_instakill", 99 );
+	add_vox_response_chance( "weapon_instakill", 10 );
+	add_vox_response_chance( "explosive", 60 );
+	add_vox_response_chance( "monkey", 60 );
+	add_vox_response_chance( "flame", 60 );
+	add_vox_response_chance( "raygun", 75 );
+	add_vox_response_chance( "headshot", 15 );
+	add_vox_response_chance( "crawler", 30 );
+	add_vox_response_chance( "quad", 30 );
+	add_vox_response_chance( "astro", 99 );
+	add_vox_response_chance( "closekill", 15 );
+	add_vox_response_chance( "bullet", 1 );
+	add_vox_response_chance( "claymore", 99 );
+	add_vox_response_chance( "dolls", 99 );
+	add_vox_response_chance( "default", 1 );
+}
+
+init_audio_functions()
+{
+	self thread zombie_behind_vox();
+	self thread player_killstreak_timer();
+	if ( isDefined( level._custom_zombie_oh_shit_vox_func ) )
+	{
+		self thread [[ level._custom_zombie_oh_shit_vox_func ]]();
+	}
+	else
+	{
+		self thread oh_shit_vox();
+	}
+}
+
+zombie_behind_vox()
+{
+	self endon( "death_or_disconnect" );
+	if ( !isDefined( level._zbv_vox_last_update_time ) )
+	{
+		level._zbv_vox_last_update_time = 0;
+		level._audio_zbv_shared_ent_list = get_round_enemy_array();
+	}
+	while ( 1 )
+	{
+		wait 1;
+		t = getTime();
+		if ( t > ( level._zbv_vox_last_update_time + 1000 ) )
+		{
+			level._zbv_vox_last_update_time = t;
+			level._audio_zbv_shared_ent_list = get_round_enemy_array();
+		}
+		zombs = level._audio_zbv_shared_ent_list;
+		played_sound = 0;
+		i = 0;
+		while ( i < zombs.size )
+		{
+			if ( !isDefined( zombs[ i ] ) )
+			{
+				i++;
+				continue;
+			}
+			else if ( zombs[ i ].isdog )
+			{
+				i++;
+				continue;
+			}
+			else
+			{
+				dist = 200;
+				z_dist = 50;
+				alias = level.vox_behind_zombie;
+				if ( isDefined( zombs[ i ].zombie_move_speed ) )
+				{
+					switch( zombs[ i ].zombie_move_speed )
+					{
+						case "walk":
+							dist = 200;
+							break;
+						break;
+						case "run":
+							dist = 250;
+							break;
+						break;
+						case "sprint":
+							dist = 275;
+							break;
+						break;
+					}
+				}
+				if ( distancesquared( zombs[ i ].origin, self.origin ) < ( dist * dist ) )
+				{
+					yaw = self maps/mp/zombies/_zm_utility::getyawtospot( zombs[ i ].origin );
+					z_diff = self.origin[ 2 ] - zombs[ i ].origin[ 2 ];
+					if ( yaw < -95 && yaw > 95 && abs( z_diff ) < 50 )
+					{
+						zombs[ i ] thread maps/mp/zombies/_zm_audio::do_zombies_playvocals( "behind", zombs[ i ].animname );
+						played_sound = 1;
+						break;
+					}
+				}
+			}
+			else
+			{
+				i++;
+			}
+		}
+		if ( played_sound )
+		{
+			wait 5;
+		}
+	}
+}
+
+attack_vox_network_choke()
+{
+	while ( 1 )
+	{
+		level._num_attack_vox = 0;
+		wait_network_frame();
+	}
+}
+
+do_zombies_playvocals( alias_type, zombie_type )
+{
+	self endon( "death" );
+	if ( !isDefined( zombie_type ) )
+	{
+		zombie_type = "zombie";
+	}
+	if ( isDefined( self.shrinked ) && self.shrinked )
+	{
+		return;
+	}
+	if ( isDefined( self.is_inert ) && self.is_inert )
+	{
+		return;
+	}
+	if ( !isDefined( self.talking ) )
+	{
+		self.talking = 0;
+	}
+	if ( isDefined( level.script ) && level.script == "zm_tomb" )
+	{
+		if ( isDefined( self.script_int ) && self.script_int >= 2 )
+		{
+			zombie_type = "capzomb";
+			self.zmb_vocals_attack = "zmb_vocals_capzomb_attack";
+		}
+		else
+		{
+			if ( isDefined( self.sndname ) )
+			{
+				zombie_type = self.sndname;
+			}
+		}
+	}
+	if ( !isDefined( level.zmb_vox[ zombie_type ] ) )
+	{
+		return;
+	}
+	if ( !isDefined( level.zmb_vox[ zombie_type ][ alias_type ] ) )
+	{
+		return;
+	}
+	switch( alias_type )
+	{
+		case "ambient":
+		case "attack":
+		case "behind":
+		case "crawler":
+		case "death":
+		case "electrocute":
+		case "sprint":
+		case "teardown":
+			if ( !sndisnetworksafe() )
+			{
+				return;
+			}
+			break;
+	}
+	alias = level.zmb_vox[ "prefix" ] + level.zmb_vox[ zombie_type ][ alias_type ];
+	if ( alias_type != "attack" && alias_type != "behind" && alias_type != "death" && alias_type != "anger" && alias_type != "steal" || alias_type == "taunt" && alias_type == "teardown" )
+	{
+		if ( isDefined( level._custom_zombie_audio_func ) )
+		{
+			self [[ level._custom_zombie_audio_func ]]( alias, alias_type );
+		}
+		else
+		{
+			self playsound( alias );
+		}
+	}
+	else
+	{
+		if ( !self.talking )
+		{
+			self.talking = 1;
+			if ( self is_last_zombie() )
+			{
+				alias += "_loud";
+			}
+			self playsoundwithnotify( alias, "sounddone" );
+			self waittill( "sounddone" );
+			self.talking = 0;
+		}
+	}
+}
+
+sndisnetworksafe()
+{
+	if ( !isDefined( level._num_attack_vox ) )
+	{
+		level thread attack_vox_network_choke();
+	}
+	if ( level._num_attack_vox > 4 )
+	{
+		return 0;
+	}
+	level._num_attack_vox++;
+	return 1;
+}
+
+is_last_zombie()
+{
+	if ( get_current_zombie_count() <= 1 )
+	{
+		return 1;
+	}
+	return 0;
+}
+
+oh_shit_vox()
+{
+	self endon( "death_or_disconnect" );
+	while ( 1 )
+	{
+		wait 1;
+		players = get_players();
+		zombs = get_round_enemy_array();
+		if ( players.size > 1 )
+		{
+			close_zombs = 0;
+			i = 0;
+			while ( i < zombs.size )
+			{
+				if ( isDefined( zombs[ i ].favoriteenemy ) || zombs[ i ].favoriteenemy == self && !isDefined( zombs[ i ].favoriteenemy ) )
+				{
+					if ( distancesquared( zombs[ i ].origin, self.origin ) < 62500 )
+					{
+						close_zombs++;
+					}
+				}
+				i++;
+			}
+			if ( close_zombs > 4 )
+			{
+				if ( randomint( 100 ) > 75 && isDefined( self.isonbus ) && !self.isonbus )
+				{
+					self create_and_play_dialog( "general", "oh_shit" );
+					wait 4;
+				}
+			}
+		}
+	}
+}
+
+create_and_play_dialog( category, type, response, force_variant, override )
+{
+	waittime = 0,25;
+	if ( !isDefined( self.zmbvoxid ) )
+	{
+		return;
+	}
+	if ( isDefined( self.dontspeak ) && self.dontspeak )
+	{
+		return;
+	}
+	isresponse = 0;
+	alias_suffix = undefined;
+	index = undefined;
+	prefix = undefined;
+	if ( !isDefined( level.vox.speaker[ self.zmbvoxid ].alias[ category ][ type ] ) )
+	{
+		return;
+	}
+	prefix = level.vox.speaker[ self.zmbvoxid ].prefix;
+	alias_suffix = level.vox.speaker[ self.zmbvoxid ].alias[ category ][ type ];
+	if ( self is_player() )
+	{
+		if ( self.sessionstate != "playing" )
+		{
+			return;
+		}
+		if ( self maps/mp/zombies/_zm_laststand::player_is_in_laststand() || type != "revive_down" && type != "revive_up" )
+		{
+			return;
+		}
+		index = maps/mp/zombies/_zm_weapons::get_player_index( self );
+		prefix = prefix + index + "_";
+	}
+	if ( isDefined( response ) )
+	{
+		if ( isDefined( level.vox.speaker[ self.zmbvoxid ].response[ category ][ type ] ) )
+		{
+			alias_suffix = response + level.vox.speaker[ self.zmbvoxid ].response[ category ][ type ];
+		}
+		isresponse = 1;
+	}
+	sound_to_play = self zmbvoxgetlinevariant( prefix, alias_suffix, force_variant, override );
+	if ( isDefined( sound_to_play ) )
+	{
+		if ( isDefined( level._audio_custom_player_playvox ) )
+		{
+			self thread [[ level._audio_custom_player_playvox ]]( prefix, index, sound_to_play, waittime, category, type, override );
+		}
+		else
+		{
+			self thread do_player_or_npc_playvox( prefix, index, sound_to_play, waittime, category, type, override, isresponse );
+		}
+	}
+	else
+	{
+	}
+}
+
+do_player_or_npc_playvox( prefix, index, sound_to_play, waittime, category, type, override, isresponse )
+{
+	self endon( "death_or_disconnect" );
+	if ( isDefined( level.skit_vox_override ) && level.skit_vox_override && isDefined( override ) && !override )
+	{
+		return;
+	}
+	if ( !isDefined( self.isspeaking ) )
+	{
+		self.isspeaking = 0;
+	}
+	if ( isDefined( self.isspeaking ) && self.isspeaking )
+	{
+		return;
+	}
+	if ( !self arenearbyspeakersactive() || isDefined( self.ignorenearbyspkrs ) && self.ignorenearbyspkrs )
+	{
+		self.speakingline = sound_to_play;
+		self.isspeaking = 1;
+		if ( isplayer( self ) )
+		{
+			self setclientfieldtoplayer( "isspeaking", 1 );
+		}
+		self notify( "speaking" );
+		playbacktime = soundgetplaybacktime( prefix + sound_to_play );
+		if ( !isDefined( playbacktime ) )
+		{
+			return;
+		}
+		if ( playbacktime >= 0 )
+		{
+			playbacktime *= 0,001;
+		}
+		else
+		{
+			playbacktime = 1;
+		}
+		self playsoundontag( prefix + sound_to_play, "J_Head" );
+		wait playbacktime;
+		if ( isplayer( self ) && isDefined( isresponse ) && !isresponse && isDefined( self.last_vo_played_time ) )
+		{
+			if ( getTime() < ( self.last_vo_played_time + 5000 ) )
+			{
+				waittime = 15;
+			}
+		}
+		wait waittime;
+		self notify( "done_speaking" );
+		self.isspeaking = 0;
+		if ( isplayer( self ) )
+		{
+			self setclientfieldtoplayer( "isspeaking", 0 );
+		}
+		if ( isplayer( self ) )
+		{
+			self.last_vo_played_time = getTime();
+		}
+		if ( isDefined( isresponse ) && isresponse )
+		{
+			return;
+		}
+		if ( isDefined( level.vox.speaker[ self.zmbvoxid ].response ) && isDefined( level.vox.speaker[ self.zmbvoxid ].response[ category ] ) && isDefined( level.vox.speaker[ self.zmbvoxid ].response[ category ][ type ] ) )
+		{
+			if ( isDefined( self.isnpc ) || self.isnpc && !flag( "solo_game" ) )
+			{
+				if ( isDefined( level._audio_custom_response_line ) )
+				{
+					level thread [[ level._audio_custom_response_line ]]( self, index, category, type );
+				}
+				else
+				{
+					level thread setup_response_line( self, index, category, type );
+				}
+			}
+		}
+	}
+	else
+	{
+	}
+}
+
+setup_response_line( player, index, category, type )
+{
+	dempsey = 0;
+	nikolai = 1;
+	takeo = 2;
+	richtofen = 3;
+	switch( player.entity_num )
+	{
+		case 0:
+			level setup_hero_rival( player, nikolai, richtofen, category, type );
+			break;
+		case 1:
+			level setup_hero_rival( player, richtofen, takeo, category, type );
+			break;
+		case 2:
+			level setup_hero_rival( player, dempsey, nikolai, category, type );
+			break;
+		case 3:
+			level setup_hero_rival( player, takeo, dempsey, category, type );
+			break;
+	}
+	return;
+}
+
+setup_hero_rival( player, hero, rival, category, type )
+{
+	players = get_players();
+	hero_player = undefined;
+	rival_player = undefined;
+	_a803 = players;
+	_k803 = getFirstArrayKey( _a803 );
+	while ( isDefined( _k803 ) )
+	{
+		ent = _a803[ _k803 ];
+		if ( ent.characterindex == hero )
+		{
+			hero_player = ent;
+		}
+		else
+		{
+			if ( ent.characterindex == rival )
+			{
+				rival_player = ent;
+			}
+		}
+		_k803 = getNextArrayKey( _a803, _k803 );
+	}
+	if ( isDefined( hero_player ) && isDefined( rival_player ) )
+	{
+		if ( randomint( 100 ) > 50 )
+		{
+			hero_player = undefined;
+		}
+		else
+		{
+			rival_player = undefined;
+		}
+	}
+	if ( isDefined( hero_player ) && distancesquared( player.origin, hero_player.origin ) < 250000 )
+	{
+		hero_player create_and_play_dialog( category, type, "hr_" );
+	}
+	else
+	{
+		if ( isDefined( rival_player ) && distancesquared( player.origin, rival_player.origin ) < 250000 )
+		{
+			rival_player create_and_play_dialog( category, type, "riv_" );
+		}
+	}
+}
+
+do_announcer_playvox( category, type, team )
+{
+	if ( !isDefined( level.vox.speaker[ "announcer" ].alias[ category ] ) || !isDefined( level.vox.speaker[ "announcer" ].alias[ category ][ type ] ) )
+	{
+		return;
+	}
+	if ( !isDefined( level.devil_is_speaking ) )
+	{
+		level.devil_is_speaking = 0;
+	}
+	prefix = level.vox.speaker[ "announcer" ].prefix;
+	suffix = level.vox.speaker[ "announcer" ].ent zmbvoxgetlinevariant( prefix, level.vox.speaker[ "announcer" ].alias[ category ][ type ] );
+	if ( !isDefined( suffix ) )
+	{
+		return;
+	}
+	alias = prefix + suffix;
+	if ( level.devil_is_speaking == 0 )
+	{
+		level.devil_is_speaking = 1;
+		if ( !isDefined( team ) )
+		{
+			level.vox.speaker[ "announcer" ].ent playsoundwithnotify( alias, "sounddone" );
+		}
+		else
+		{
+			level thread zmbvoxannouncertoteam( category, type, team );
+		}
+		level.vox.speaker[ "announcer" ].ent waittill( "sounddone" );
+		level.devil_is_speaking = 0;
+	}
+}
+
+zmbvoxannouncertoteam( category, type, team )
+{
+	prefix = level.vox.speaker[ "announcer" ].prefix;
+	alias_to_team = prefix + level.vox.speaker[ "announcer" ].ent zmbvoxgetlinevariant( prefix, level.vox.speaker[ "announcer" ].alias[ category ][ type ] );
+	if ( isDefined( level.vox.speaker[ "announcer" ].response[ category ][ type ] ) )
+	{
+		alias_to_rival = prefix + level.vox.speaker[ "announcer" ].ent zmbvoxgetlinevariant( prefix, level.vox.speaker[ "announcer" ].response[ category ][ type ] );
+	}
+	players = get_players();
+	i = 0;
+	while ( i < players.size )
+	{
+		if ( !isDefined( players[ i ]._encounters_team ) )
+		{
+			i++;
+			continue;
+		}
+		else if ( players[ i ]._encounters_team == team )
+		{
+			level.vox.speaker[ "announcer" ].ent playsoundtoplayer( alias_to_team, players[ i ] );
+			i++;
+			continue;
+		}
+		else
+		{
+			if ( isDefined( alias_to_rival ) )
+			{
+				level.vox.speaker[ "announcer" ].ent playsoundtoplayer( alias_to_rival, players[ i ] );
+			}
+		}
+		i++;
+	}
+	wait 3;
+	level.vox.speaker[ "announcer" ].ent notify( "sounddone" );
+}
+
+player_killstreak_timer()
+{
+	self endon( "disconnect" );
+	self endon( "death" );
+	if ( getDvar( "zombie_kills" ) == "" )
+	{
+		setdvar( "zombie_kills", "7" );
+	}
+	if ( getDvar( "zombie_kill_timer" ) == "" )
+	{
+		setdvar( "zombie_kill_timer", "5" );
+	}
+	kills = getDvarInt( "zombie_kills" );
+	time = getDvarInt( "zombie_kill_timer" );
+	if ( !isDefined( self.timerisrunning ) )
+	{
+		self.timerisrunning = 0;
+		self.killcounter = 0;
+	}
+	while ( 1 )
+	{
+		self waittill( "zom_kill", zomb );
+		if ( isDefined( zomb._black_hole_bomb_collapse_death ) && zomb._black_hole_bomb_collapse_death == 1 )
+		{
+			continue;
+		}
+		if ( isDefined( zomb.microwavegun_death ) && zomb.microwavegun_death )
+		{
+			continue;
+		}
+		self.killcounter++;
+		if ( self.timerisrunning != 1 )
+		{
+			self.timerisrunning = 1;
+			self thread timer_actual( kills, time );
+		}
+	}
+}
+
+player_zombie_kill_vox( hit_location, player, mod, zombie )
+{
+	weapon = player getcurrentweapon();
+	dist = distancesquared( player.origin, zombie.origin );
+	if ( !isDefined( level.zombie_vars[ player.team ][ "zombie_insta_kill" ] ) )
+	{
+		level.zombie_vars[ player.team ][ "zombie_insta_kill" ] = 0;
+	}
+	instakill = level.zombie_vars[ player.team ][ "zombie_insta_kill" ];
+	death = [[ level.audio_get_mod_type ]]( hit_location, mod, weapon, zombie, instakill, dist, player );
+	chance = get_response_chance( death );
+	if ( chance > randomintrange( 1, 100 ) && isDefined( player.force_wait_on_kill_line ) && !player.force_wait_on_kill_line )
+	{
+		player.force_wait_on_kill_line = 1;
+		player create_and_play_dialog( "kill", death );
+		wait 2;
+		if ( isDefined( player ) )
+		{
+			player.force_wait_on_kill_line = 0;
+		}
+	}
+}
+
+get_response_chance( event )
+{
+	if ( !isDefined( level.response_chances[ event ] ) )
+	{
+		return 0;
+	}
+	return level.response_chances[ event ];
+}
+
+get_mod_type( impact, mod, weapon, zombie, instakill, dist, player )
+{
+	close_dist = 4096;
+	med_dist = 15376;
+	far_dist = 160000;
+	if ( isDefined( zombie._black_hole_bomb_collapse_death ) && zombie._black_hole_bomb_collapse_death == 1 )
+	{
+		return "default";
+	}
+	if ( zombie.animname == "screecher_zombie" && mod == "MOD_MELEE" )
+	{
+		return "killed_screecher";
+	}
+	if ( is_placeable_mine( weapon ) )
+	{
+		if ( !instakill )
+		{
+			return "claymore";
+		}
+		else
+		{
+			return "weapon_instakill";
+		}
+	}
+	if ( weapon == "jetgun_zm" || weapon == "jetgun_upgraded_zm" )
+	{
+		if ( instakill )
+		{
+			return "weapon_instakill";
+		}
+		else
+		{
+			return "jetgun_kill";
+		}
+	}
+	if ( weapon == "slipgun_zm" || weapon == "slipgun_upgraded_zm" )
+	{
+		if ( instakill )
+		{
+			return "weapon_instakill";
+		}
+		else
+		{
+			return "slipgun_kill";
+		}
+	}
+	if ( isDefined( zombie.damageweapon ) && zombie.damageweapon == "cymbal_monkey_zm" )
+	{
+		if ( instakill )
+		{
+			return "weapon_instakill";
+		}
+		else
+		{
+			return "monkey";
+		}
+	}
+	if ( is_headshot( weapon, impact, mod ) && dist >= far_dist )
+	{
+		return "headshot";
+	}
+	if ( mod != "MOD_MELEE" && mod != "MOD_BAYONET" && mod == "MOD_UNKNOWN" && dist < close_dist )
+	{
+		if ( !instakill )
+		{
+			if ( player hasweapon( "sickle_knife_zm" ) )
+			{
+				return "sickle";
+			}
+			else
+			{
+				return "melee";
+			}
+		}
+		else
+		{
+			return "melee_instakill";
+		}
+	}
+	if ( isDefined( zombie.damageweapon ) && zombie.damageweapon == "zombie_nesting_doll_single" )
+	{
+		if ( !instakill )
+		{
+			return "dolls";
+		}
+		else
+		{
+			return "weapon_instakill";
+		}
+	}
+	if ( is_explosive_damage( mod ) && weapon != "ray_gun_zm" && isDefined( zombie.is_on_fire ) && !zombie.is_on_fire )
+	{
+		if ( !instakill )
+		{
+			return "explosive";
+		}
+		else
+		{
+			return "weapon_instakill";
+		}
+	}
+	if ( !issubstr( weapon, "flame" ) && !issubstr( weapon, "molotov_" ) && issubstr( weapon, "napalmblob_" ) && mod != "MOD_BURNED" || mod == "MOD_GRENADE" && mod == "MOD_GRENADE_SPLASH" )
+	{
+		if ( !instakill )
+		{
+			return "flame";
+		}
+		else
+		{
+			return "weapon_instakill";
+		}
+	}
+	if ( weapon == "ray_gun_zm" && dist > far_dist )
+	{
+		if ( !instakill )
+		{
+			return "raygun";
+		}
+		else
+		{
+			return "weapon_instakill";
+		}
+	}
+	if ( !isDefined( impact ) )
+	{
+		impact = "";
+	}
+	if ( mod == "MOD_RIFLE_BULLET" || mod == "MOD_PISTOL_BULLET" )
+	{
+		if ( !instakill )
+		{
+			return "bullet";
+		}
+		else
+		{
+			return "weapon_instakill";
+		}
+	}
+	if ( instakill )
+	{
+		return "default";
+	}
+	if ( mod != "MOD_MELEE" && zombie.animname == "quad_zombie" )
+	{
+		return "quad";
+	}
+	if ( mod != "MOD_MELEE" && zombie.animname == "astro_zombie" )
+	{
+		return "astro";
+	}
+	if ( mod != "MOD_MELEE" && !zombie.has_legs )
+	{
+		return "crawler";
+	}
+	if ( mod != "MOD_BURNED" && dist < close_dist )
+	{
+		return "closekill";
+	}
+	return "default";
+}
+
+timer_actual( kills, time )
+{
+	self endon( "disconnect" );
+	self endon( "death" );
+	timer = getTime() + ( time * 1000 );
+	while ( getTime() < timer )
+	{
+		if ( self.killcounter > kills )
+		{
+			self create_and_play_dialog( "kill", "streak" );
+			wait 1;
+			self.killcounter = 0;
+			timer = -1;
+		}
+		wait 0,1;
+	}
+	wait 10;
+	self.killcounter = 0;
+	self.timerisrunning = 0;
+}
+
+perks_a_cola_jingle_timer()
+{
+	if ( isDefined( level.sndperksacolaloopoverride ) )
+	{
+		self thread [[ level.sndperksacolaloopoverride ]]();
+		return;
+	}
+	self endon( "death" );
+	self thread play_random_broken_sounds();
+	while ( 1 )
+	{
+		wait randomfloatrange( 31, 45 );
+		if ( randomint( 100 ) < 15 )
+		{
+			self thread play_jingle_or_stinger( self.script_sound );
+		}
+	}
+}
+
+play_jingle_or_stinger( perksacola )
+{
+	if ( isDefined( level.sndperksacolajingleoverride ) )
+	{
+		self thread [[ level.sndperksacolajingleoverride ]]();
+		return;
+	}
+	playsoundatposition( "evt_electrical_surge", self.origin );
+	if ( !isDefined( self.jingle_is_playing ) )
+	{
+		self.jingle_is_playing = 0;
+	}
+	if ( isDefined( perksacola ) )
+	{
+		if ( self.jingle_is_playing == 0 && level.music_override == 0 )
+		{
+			self.jingle_is_playing = 1;
+			self playsoundontag( perksacola, "tag_origin", "sound_done" );
+			if ( issubstr( perksacola, "sting" ) )
+			{
+				wait 10;
+			}
+			else if ( isDefined( self.longjinglewait ) )
+			{
+				wait 60;
+			}
+			else
+			{
+				wait 30;
+			}
+			self.jingle_is_playing = 0;
+		}
+	}
+}
+
+play_random_broken_sounds()
+{
+	self endon( "death" );
+	level endon( "jingle_playing" );
+	if ( !isDefined( self.script_sound ) )
+	{
+		self.script_sound = "null";
+	}
+	if ( self.script_sound == "mus_perks_revive_jingle" )
+	{
+		while ( 1 )
+		{
+			wait randomfloatrange( 7, 18 );
+			playsoundatposition( "zmb_perks_broken_jingle", self.origin );
+			playsoundatposition( "evt_electrical_surge", self.origin );
+		}
+	}
+	else while ( 1 )
+	{
+		wait randomfloatrange( 7, 18 );
+		playsoundatposition( "evt_electrical_surge", self.origin );
+	}
+}
+
+perk_vox( perk )
+{
+	self endon( "death" );
+	self endon( "disconnect" );
+	if ( !isDefined( level.vox.speaker[ "player" ].alias[ "perk" ][ perk ] ) )
+	{
+		return;
+	}
+	self create_and_play_dialog( "perk", perk );
+}
+
+dialog_debugger( category, type )
+{
+}
+
+init_music_states()
+{
+	level.music_override = 0;
+	level.music_round_override = 0;
+	level.old_music_state = undefined;
+	level.zmb_music_states = [];
+	level thread setupmusicstate( "round_start", "mus_zombie_round_start", 1, 1, 1, "WAVE" );
+	level thread setupmusicstate( "round_end", "mus_zombie_round_over", 1, 1, 1, "SILENCE" );
+	level thread setupmusicstate( "wave_loop", "WAVE", 0, 1, undefined, undefined );
+	level thread setupmusicstate( "game_over", "mus_zombie_game_over", 1, 0, undefined, "SILENCE" );
+	level thread setupmusicstate( "dog_start", "mus_zombie_dog_start", 1, 1, undefined, undefined );
+	level thread setupmusicstate( "dog_end", "mus_zombie_dog_end", 1, 1, undefined, undefined );
+	level thread setupmusicstate( "egg", "EGG", 0, 0, undefined, undefined );
+	level thread setupmusicstate( "egg_safe", "EGG_SAFE", 0, 0, undefined, undefined );
+	level thread setupmusicstate( "egg_a7x", "EGG_A7X", 0, 0, undefined, undefined );
+	level thread setupmusicstate( "sam_reveal", "SAM", 0, 0, undefined, undefined );
+	level thread setupmusicstate( "brutus_round_start", "mus_event_brutus_round_start", 1, 1, 0, "WAVE" );
+	level thread setupmusicstate( "last_life", "LAST_LIFE", 0, 1, undefined, undefined );
+}
+
+setupmusicstate( state, alias, is_alias, override, round_override, musicstate )
+{
+	if ( !isDefined( level.zmb_music_states[ state ] ) )
+	{
+		level.zmb_music_states[ state ] = spawnstruct();
+	}
+	level.zmb_music_states[ state ].music = alias;
+	level.zmb_music_states[ state ].is_alias = is_alias;
+	level.zmb_music_states[ state ].override = override;
+	level.zmb_music_states[ state ].round_override = round_override;
+	level.zmb_music_states[ state ].musicstate = musicstate;
+}
+
+change_zombie_music( state )
+{
+	wait 0,05;
+	m = level.zmb_music_states[ state ];
+	if ( !isDefined( m ) )
+	{
+		return;
+	}
+	do_logic = 1;
+	if ( !isDefined( level.old_music_state ) )
+	{
+		do_logic = 0;
+	}
+	if ( do_logic )
+	{
+		if ( level.old_music_state == m )
+		{
+			return;
+		}
+		else
+		{
+			if ( level.old_music_state.music == "mus_zombie_game_over" )
+			{
+				return;
+			}
+		}
+	}
+	if ( !isDefined( m.round_override ) )
+	{
+		m.round_override = 0;
+	}
+	if ( m.override == 1 && level.music_override == 1 )
+	{
+		return;
+	}
+	if ( m.round_override == 1 && level.music_round_override == 1 )
+	{
+		return;
+	}
+	if ( m.is_alias )
+	{
+		if ( isDefined( m.musicstate ) )
+		{
+			maps/mp/_music::setmusicstate( m.musicstate );
+		}
+		play_sound_2d( m.music );
+	}
+	else
+	{
+		maps/mp/_music::setmusicstate( m.music );
+	}
+	level.old_music_state = m;
+}
+
+weapon_toggle_vox( alias, weapon )
+{
+	self notify( "audio_activated_trigger" );
+	self endon( "audio_activated_trigger" );
+	prefix = "vox_pa_switcher_";
+	sound_to_play = prefix + alias;
+	type = undefined;
+	if ( isDefined( weapon ) )
+	{
+		type = get_weapon_num( weapon );
+		if ( !isDefined( type ) )
+		{
+			return;
+		}
+	}
+	self stopsounds();
+	wait 0,05;
+	if ( isDefined( type ) )
+	{
+		self playsoundwithnotify( ( prefix + "weapon_" ) + type, "sounddone" );
+		self waittill( "sounddone" );
+	}
+	self playsound( sound_to_play + "_0" );
+}
+
+get_weapon_num( weapon )
+{
+	weapon_num = undefined;
+	switch( weapon )
+	{
+		case "humangun_zm":
+			weapon_num = 0;
+			break;
+		case "sniper_explosive_zm":
+			weapon_num = 1;
+			break;
+		case "tesla_gun_zm":
+			weapon_num = 2;
+			break;
+	}
+	return weapon_num;
+}
+
+addasspeakernpc( ignorenearbyspeakers )
+{
+	if ( !isDefined( level.npcs ) )
+	{
+		level.npcs = [];
+	}
+	if ( isDefined( ignorenearbyspeakers ) && ignorenearbyspeakers )
+	{
+		self.ignorenearbyspkrs = 1;
+	}
+	else
+	{
+		self.ignorenearbyspkrs = 0;
+	}
+	self.isnpc = 1;
+	level.npcs[ level.npcs.size ] = self;
+}
+
+arenearbyspeakersactive()
+{
+	radius = 1000;
+	nearbyspeakeractive = 0;
+	speakers = get_players();
+	if ( isDefined( level.npcs ) )
+	{
+		speakers = arraycombine( speakers, level.npcs, 1, 0 );
+	}
+	_a1453 = speakers;
+	_k1453 = getFirstArrayKey( _a1453 );
+	while ( isDefined( _k1453 ) )
+	{
+		person = _a1453[ _k1453 ];
+		if ( self == person )
+		{
+		}
+		else if ( person is_player() )
+		{
+			if ( person.sessionstate != "playing" )
+			{
+			}
+			else if ( person maps/mp/zombies/_zm_laststand::player_is_in_laststand() )
+			{
+			}
+			else
+			{
+			}
+			if ( isDefined( person.isspeaking ) && person.isspeaking && isDefined( person.ignorenearbyspkrs ) && !person.ignorenearbyspkrs )
+			{
+				if ( distancesquared( self.origin, person.origin ) < ( radius * radius ) )
+				{
+					nearbyspeakeractive = 1;
+				}
+			}
+		}
+		_k1453 = getNextArrayKey( _a1453, _k1453 );
+	}
+	return nearbyspeakeractive;
+}
+
+zmbvoxcreate()
+{
+	vox = spawnstruct();
+	vox.speaker = [];
+	return vox;
+}
+
+zmbvoxinitspeaker( speaker, prefix, ent )
+{
+	ent.zmbvoxid = speaker;
+	if ( !isDefined( self.speaker[ speaker ] ) )
+	{
+		self.speaker[ speaker ] = spawnstruct();
+		self.speaker[ speaker ].alias = [];
+	}
+	self.speaker[ speaker ].prefix = prefix;
+	self.speaker[ speaker ].ent = ent;
+}
+
+zmbvoxadd( speaker, category, type, alias, response )
+{
+	if ( !isDefined( self.speaker[ speaker ] ) )
+	{
+		self.speaker[ speaker ] = spawnstruct();
+		self.speaker[ speaker ].alias = [];
+	}
+	if ( !isDefined( self.speaker[ speaker ].alias[ category ] ) )
+	{
+		self.speaker[ speaker ].alias[ category ] = [];
+	}
+	self.speaker[ speaker ].alias[ category ][ type ] = alias;
+	if ( isDefined( response ) )
+	{
+		if ( !isDefined( self.speaker[ speaker ].response ) )
+		{
+			self.speaker[ speaker ].response = [];
+		}
+		if ( !isDefined( self.speaker[ speaker ].response[ category ] ) )
+		{
+			self.speaker[ speaker ].response[ category ] = [];
+		}
+		self.speaker[ speaker ].response[ category ][ type ] = response;
+	}
+	create_vox_timer( type );
+}
+
+zmbvoxgetlinevariant( prefix, alias_suffix, force_variant, override )
+{
+	if ( !isDefined( self.sound_dialog ) )
+	{
+		self.sound_dialog = [];
+		self.sound_dialog_available = [];
+	}
+	if ( !isDefined( self.sound_dialog[ alias_suffix ] ) )
+	{
+		num_variants = maps/mp/zombies/_zm_spawner::get_number_variants( prefix + alias_suffix );
+		if ( num_variants <= 0 )
+		{
+			return undefined;
+		}
+		i = 0;
+		while ( i < num_variants )
+		{
+			self.sound_dialog[ alias_suffix ][ i ] = i;
+			i++;
+		}
+		self.sound_dialog_available[ alias_suffix ] = [];
+	}
+	while ( self.sound_dialog_available[ alias_suffix ].size <= 0 )
+	{
+		i = 0;
+		while ( i < self.sound_dialog[ alias_suffix ].size )
+		{
+			self.sound_dialog_available[ alias_suffix ][ i ] = self.sound_dialog[ alias_suffix ][ i ];
+			i++;
+		}
+	}
+	variation = random( self.sound_dialog_available[ alias_suffix ] );
+	arrayremovevalue( self.sound_dialog_available[ alias_suffix ], variation );
+	if ( isDefined( force_variant ) )
+	{
+		variation = force_variant;
+	}
+	if ( !isDefined( override ) )
+	{
+		override = 0;
+	}
+	return ( alias_suffix + "_" ) + variation;
+}
+
+zmbvoxcrowdonteam( alias, team, other_alias )
+{
+	alias = "vox_crowd_" + alias;
+	if ( !isDefined( team ) )
+	{
+		level play_sound_2d( alias );
+		return;
+	}
+	players = get_players();
+	i = 0;
+	while ( i < players.size )
+	{
+		if ( !isDefined( players[ i ]._encounters_team ) )
+		{
+			i++;
+			continue;
+		}
+		else if ( players[ i ]._encounters_team == team )
+		{
+			players[ i ] playsoundtoplayer( alias, players[ i ] );
+			i++;
+			continue;
+		}
+		else
+		{
+			if ( isDefined( other_alias ) )
+			{
+				players[ i ] playsoundtoplayer( other_alias, players[ i ] );
+			}
+		}
+		i++;
+	}
+}
+
+playvoxtoplayer( category, type, force_variant )
+{
+	if ( self.sessionstate != "playing" )
+	{
+		return;
+	}
+	if ( self maps/mp/zombies/_zm_laststand::player_is_in_laststand() )
+	{
+		return;
+	}
+	prefix = level.vox.speaker[ self.zmbvoxid ].prefix;
+	alias_suffix = level.vox.speaker[ self.zmbvoxid ].alias[ category ][ type ];
+	prefix = prefix + self.characterindex + "_";
+	if ( !isDefined( alias_suffix ) )
+	{
+		return;
+	}
+	sound_to_play = self zmbvoxgetlinevariant( prefix, alias_suffix, force_variant );
+	if ( isDefined( sound_to_play ) )
+	{
+		sound = prefix + sound_to_play;
+		self playsoundtoplayer( sound, self );
+	}
+}
+
+sndmusicstingerevent( type, player )
+{
+	if ( isDefined( level.sndmusicstingerevent ) )
+	{
+		[[ level.sndmusicstingerevent ]]( type, player );
+	}
+}
+
+custom_kill_damaged_vo( player )
+{
+	self notify( "sound_damage_player_updated" );
+	self endon( "death" );
+	self endon( "sound_damage_player_updated" );
+	self.sound_damage_player = player;
+	wait 5;
+	self.sound_damage_player = undefined;
+}
+
diff --git a/patch_zm/maps/mp/zombies/_zm_audio_announcer.gsc b/patch_zm/maps/mp/zombies/_zm_audio_announcer.gsc
new file mode 100644
index 0000000..1c2e1bc
--- /dev/null
+++ b/patch_zm/maps/mp/zombies/_zm_audio_announcer.gsc
@@ -0,0 +1,479 @@
+#include maps/mp/zombies/_zm_spawner;
+#include maps/mp/zombies/_zm_weapons;
+#include maps/mp/zombies/_zm_utility;
+#include maps/mp/_utility;
+#include common_scripts/utility;
+
+init()
+{
+	game[ "zmbdialog" ] = [];
+	game[ "zmbdialog" ][ "prefix" ] = "vox_zmba";
+	createvox( "carpenter", "powerup_carpenter" );
+	createvox( "insta_kill", "powerup_instakill" );
+	createvox( "double_points", "powerup_doublepoints" );
+	createvox( "nuke", "powerup_nuke" );
+	createvox( "full_ammo", "powerup_maxammo" );
+	createvox( "fire_sale", "powerup_firesale" );
+	createvox( "minigun", "powerup_death_machine" );
+	createvox( "zombie_blood", "powerup_zombie_blood" );
+	createvox( "boxmove", "event_magicbox" );
+	createvox( "dogstart", "event_dogstart" );
+	thread init_gamemodespecificvox( getDvar( "ui_gametype" ), getDvar( "ui_zm_mapstartlocation" ) );
+	level.allowzmbannouncer = 1;
+}
+
+init_gamemodespecificvox( mode, location )
+{
+	switch( mode )
+	{
+		case "zmeat":
+			init_meatvox( "meat" );
+			break;
+		case "zrace":
+			init_racevox( "race", location );
+			break;
+		case "zgrief":
+			init_griefvox( "grief" );
+			break;
+		case "zcleansed":
+			init_cleansed( location );
+			break;
+		default:
+			init_gamemodecommonvox();
+			break;
+	}
+}
+
+init_gamemodecommonvox( prefix )
+{
+	createvox( "rules", "rules", prefix );
+	createvox( "countdown", "intro", prefix );
+	createvox( "side_switch", "side_switch", prefix );
+	createvox( "round_win", "win_rd", prefix );
+	createvox( "round_lose", "lose_rd", prefix );
+	createvox( "round_tied", "tied_rd", prefix );
+	createvox( "match_win", "win", prefix );
+	createvox( "match_lose", "lose", prefix );
+	createvox( "match_tied", "tied", prefix );
+}
+
+init_griefvox( prefix )
+{
+	init_gamemodecommonvox( prefix );
+	createvox( "1_player_down", "1rivdown", prefix );
+	createvox( "2_player_down", "2rivdown", prefix );
+	createvox( "3_player_down", "3rivdown", prefix );
+	createvox( "4_player_down", "4rivdown", prefix );
+	createvox( "grief_restarted", "restart", prefix );
+	createvox( "grief_lost", "lose", prefix );
+	createvox( "grief_won", "win", prefix );
+	createvox( "1_player_left", "1rivup", prefix );
+	createvox( "2_player_left", "2rivup", prefix );
+	createvox( "3_player_left", "3rivup", prefix );
+	createvox( "last_player", "solo", prefix );
+}
+
+init_cleansed( prefix )
+{
+	init_gamemodecommonvox( prefix );
+	createvox( "dr_start_single_0", "dr_start_0" );
+	createvox( "dr_start_2", "dr_start_1" );
+	createvox( "dr_start_3", "dr_start_2" );
+	createvox( "dr_cure_found_line", "dr_cure_found" );
+	createvox( "dr_monkey_killer", "dr_monkey_0" );
+	createvox( "dr_monkey_killee", "dr_monkey_1" );
+	createvox( "dr_human_killed", "dr_kill_plr" );
+	createvox( "dr_human_killer", "dr_kill_plr_2" );
+	createvox( "dr_survival", "dr_plr_survive_0" );
+	createvox( "dr_zurvival", "dr_zmb_survive_2" );
+	createvox( "dr_countdown0", "dr_plr_survive_1" );
+	createvox( "dr_countdown1", "dr_plr_survive_2" );
+	createvox( "dr_countdown2", "dr_plr_survive_3" );
+	createvox( "dr_ending", "dr_time_0" );
+}
+
+init_meatvox( prefix )
+{
+	init_gamemodecommonvox( prefix );
+	createvox( "meat_drop", "drop", prefix );
+	createvox( "meat_grab", "grab", prefix );
+	createvox( "meat_grab_A", "team_cdc", prefix );
+	createvox( "meat_grab_B", "team_cia", prefix );
+	createvox( "meat_land", "land", prefix );
+	createvox( "meat_hold", "hold", prefix );
+	createvox( "meat_revive_1", "revive1", prefix );
+	createvox( "meat_revive_2", "revive2", prefix );
+	createvox( "meat_revive_3", "revive3", prefix );
+	createvox( "meat_ring_splitter", "ring_tripple", prefix );
+	createvox( "meat_ring_minigun", "ring_death", prefix );
+	createvox( "meat_ring_ammo", "ring_ammo", prefix );
+}
+
+init_racevox( prefix, location )
+{
+	init_gamemodecommonvox( prefix );
+	switch( location )
+	{
+		case "tunnel":
+			createvox( "rules", "rules_" + location, prefix );
+			createvox( "countdown", "intro_" + location, prefix );
+			break;
+		case "power":
+			createvox( "rules", "rules_" + location, prefix );
+			createvox( "countdown", "intro_" + location, prefix );
+			createvox( "lap1", "lap1", prefix );
+			createvox( "lap2", "lap2", prefix );
+			createvox( "lap_final", "lap_final", prefix );
+			break;
+		case "farm":
+			createvox( "rules", "rules_" + location, prefix );
+			createvox( "countdown", "intro_" + location, prefix );
+			createvox( "hoop_area", "hoop_area", prefix );
+			createvox( "hoop_miss", "hoop_miss", prefix );
+			break;
+		default:
+		createvox( "race_room_2_ally", "room2_ally", prefix );
+		createvox( "race_room_3_ally", "room3_ally", prefix );
+		createvox( "race_room_4_ally", "room4_ally", prefix );
+		createvox( "race_room_5_ally", "room5_ally", prefix );
+		createvox( "race_room_2_axis", "room2_axis", prefix );
+		createvox( "race_room_3_axis", "room3_axis", prefix );
+		createvox( "race_room_4_axis", "room4_axis", prefix );
+		createvox( "race_room_5_axis", "room5_axis", prefix );
+		createvox( "race_ahead_1_ally", "ahead1_ally", prefix );
+		createvox( "race_ahead_2_ally", "ahead2_ally", prefix );
+		createvox( "race_ahead_3_ally", "ahead3_ally", prefix );
+		createvox( "race_ahead_4_ally", "ahead4_ally", prefix );
+		createvox( "race_ahead_1_axis", "ahead1_axis", prefix );
+		createvox( "race_ahead_2_axis", "ahead2_axis", prefix );
+		createvox( "race_ahead_3_axis", "ahead3_axis", prefix );
+		createvox( "race_ahead_4_axis", "ahead4_axis", prefix );
+		createvox( "race_kill_15", "door15", prefix );
+		createvox( "race_kill_10", "door10", prefix );
+		createvox( "race_kill_5", "door5", prefix );
+		createvox( "race_kill_3", "door3", prefix );
+		createvox( "race_kill_1", "door1", prefix );
+		createvox( "race_door_open", "door_open", prefix );
+		createvox( "race_door_nag", "door_nag", prefix );
+		createvox( "race_grief_incoming", "grief_income_ammo", prefix );
+		createvox( "race_grief_land", "grief_land", prefix );
+		createvox( "race_laststand", "last_stand", prefix );
+	}
+}
+
+createvox( type, alias, gametype )
+{
+	if ( !isDefined( gametype ) )
+	{
+		gametype = "";
+	}
+	else
+	{
+		gametype += "_";
+	}
+	game[ "zmbdialog" ][ type ] = gametype + alias;
+}
+
+announceroundwinner( winner, delay )
+{
+	if ( isDefined( delay ) && delay > 0 )
+	{
+		wait delay;
+	}
+	if ( !isDefined( winner ) || isplayer( winner ) )
+	{
+		return;
+	}
+	if ( winner != "tied" )
+	{
+		players = get_players();
+		_a236 = players;
+		_k236 = getFirstArrayKey( _a236 );
+		while ( isDefined( _k236 ) )
+		{
+			player = _a236[ _k236 ];
+			if ( isDefined( player._encounters_team ) && player._encounters_team == winner )
+			{
+				winning_team = player.pers[ "team" ];
+				break;
+			}
+			else
+			{
+				_k236 = getNextArrayKey( _a236, _k236 );
+			}
+		}
+		losing_team = getotherteam( winning_team );
+		leaderdialog( "round_win", winning_team, undefined, 1 );
+		leaderdialog( "round_lose", losing_team, undefined, 1 );
+	}
+	else
+	{
+		leaderdialog( "round_tied", undefined, undefined, 1 );
+	}
+}
+
+announcematchwinner( winner, delay )
+{
+	if ( isDefined( delay ) && delay > 0 )
+	{
+		wait delay;
+	}
+	if ( !isDefined( winner ) || isplayer( winner ) )
+	{
+		return;
+	}
+	if ( winner != "tied" )
+	{
+		players = get_players();
+		_a267 = players;
+		_k267 = getFirstArrayKey( _a267 );
+		while ( isDefined( _k267 ) )
+		{
+			player = _a267[ _k267 ];
+			if ( isDefined( player._encounters_team ) && player._encounters_team == winner )
+			{
+				winning_team = player.pers[ "team" ];
+				break;
+			}
+			else
+			{
+				_k267 = getNextArrayKey( _a267, _k267 );
+			}
+		}
+		losing_team = getotherteam( winning_team );
+		leaderdialog( "match_win", winning_team, undefined, 1 );
+		leaderdialog( "match_lose", losing_team, undefined, 1 );
+	}
+	else
+	{
+		leaderdialog( "match_tied", undefined, undefined, 1 );
+	}
+}
+
+announcegamemoderules()
+{
+	if ( getDvar( "ui_zm_mapstartlocation" ) == "town" )
+	{
+		leaderdialog( "rules", undefined, undefined, undefined, 20 );
+	}
+}
+
+leaderdialog( dialog, team, group, queue, waittime )
+{
+/#
+	assert( isDefined( level.players ) );
+#/
+	if ( !isDefined( team ) )
+	{
+		leaderdialogbothteams( dialog, "allies", dialog, "axis", group, queue, waittime );
+		return;
+	}
+	if ( level.splitscreen )
+	{
+		if ( level.players.size )
+		{
+			level.players[ 0 ] leaderdialogonplayer( dialog, group, queue, waittime );
+		}
+		return;
+	}
+	i = 0;
+	while ( i < level.players.size )
+	{
+		player = level.players[ i ];
+		if ( isDefined( player.pers[ "team" ] ) && player.pers[ "team" ] == team )
+		{
+			player leaderdialogonplayer( dialog, group, queue, waittime );
+		}
+		i++;
+	}
+}
+
+leaderdialogbothteams( dialog1, team1, dialog2, team2, group, queue, waittime )
+{
+/#
+	assert( isDefined( level.players ) );
+#/
+	if ( level.splitscreen )
+	{
+		if ( level.players.size )
+		{
+			level.players[ 0 ] leaderdialogonplayer( dialog1, group, queue, waittime );
+		}
+		return;
+	}
+	i = 0;
+	while ( i < level.players.size )
+	{
+		player = level.players[ i ];
+		team = player.pers[ "team" ];
+		if ( !isDefined( team ) )
+		{
+			i++;
+			continue;
+		}
+		else if ( team == team1 )
+		{
+			player leaderdialogonplayer( dialog1, group, queue, waittime );
+			i++;
+			continue;
+		}
+		else
+		{
+			if ( team == team2 )
+			{
+				player leaderdialogonplayer( dialog2, group, queue, waittime );
+			}
+		}
+		i++;
+	}
+}
+
+leaderdialogonplayer( dialog, group, queue, waittime )
+{
+	team = self.pers[ "team" ];
+	if ( !isDefined( team ) )
+	{
+		return;
+	}
+	if ( team != "allies" && team != "axis" )
+	{
+		return;
+	}
+	if ( isDefined( group ) )
+	{
+		if ( self.zmbdialoggroup == group )
+		{
+			return;
+		}
+		hadgroupdialog = isDefined( self.zmbdialoggroups[ group ] );
+		self.zmbdialoggroups[ group ] = dialog;
+		dialog = group;
+		if ( hadgroupdialog )
+		{
+			return;
+		}
+	}
+	if ( !self.zmbdialogactive )
+	{
+		self thread playleaderdialogonplayer( dialog, team, waittime );
+	}
+	else
+	{
+		if ( isDefined( queue ) && queue )
+		{
+			self.zmbdialogqueue[ self.zmbdialogqueue.size ] = dialog;
+		}
+	}
+}
+
+playleaderdialogonplayer( dialog, team, waittime )
+{
+	self endon( "disconnect" );
+	if ( level.allowzmbannouncer )
+	{
+		if ( !isDefined( game[ "zmbdialog" ][ dialog ] ) )
+		{
+			return;
+		}
+	}
+	self.zmbdialogactive = 1;
+	if ( isDefined( self.zmbdialoggroups[ dialog ] ) )
+	{
+		group = dialog;
+		dialog = self.zmbdialoggroups[ group ];
+		self.zmbdialoggroup = group;
+	}
+	if ( level.allowzmbannouncer )
+	{
+		alias = game[ "zmbdialog" ][ "prefix" ] + "_" + game[ "zmbdialog" ][ dialog ];
+		variant = self getleaderdialogvariant( alias );
+		if ( !isDefined( variant ) )
+		{
+			full_alias = alias;
+		}
+		else
+		{
+			full_alias = ( alias + "_" ) + variant;
+		}
+		self playlocalsound( full_alias );
+	}
+	if ( isDefined( waittime ) )
+	{
+		wait waittime;
+	}
+	else
+	{
+		wait 4;
+	}
+	self.zmbdialogactive = 0;
+	self.zmbdialoggroup = "";
+	if ( self.zmbdialogqueue.size > 0 && level.allowzmbannouncer )
+	{
+		nextdialog = self.zmbdialogqueue[ 0 ];
+		i = 1;
+		while ( i < self.zmbdialogqueue.size )
+		{
+			self.zmbdialogqueue[ i - 1 ] = self.zmbdialogqueue[ i ];
+			i++;
+		}
+		self thread playleaderdialogonplayer( nextdialog, team );
+	}
+}
+
+getleaderdialogvariant( alias )
+{
+	if ( !isDefined( alias ) )
+	{
+		return;
+	}
+	if ( !isDefined( level.announcer_dialog ) )
+	{
+		level.announcer_dialog = [];
+		level.announcer_dialog_available = [];
+	}
+	num_variants = maps/mp/zombies/_zm_spawner::get_number_variants( alias );
+	if ( num_variants <= 0 )
+	{
+		return undefined;
+	}
+	i = 0;
+	while ( i < num_variants )
+	{
+		level.announcer_dialog[ alias ][ i ] = i;
+		i++;
+	}
+	level.announcer_dialog_available[ alias ] = [];
+	if ( level.announcer_dialog_available[ alias ].size <= 0 )
+	{
+		level.announcer_dialog_available[ alias ] = level.announcer_dialog[ alias ];
+	}
+	variation = random( level.announcer_dialog_available[ alias ] );
+	level.announcer_dialog_available[ alias ] = arrayremovevalue( level.announcer_dialog_available[ alias ], variation );
+	return variation;
+}
+
+getroundswitchdialog( switchtype )
+{
+	switch( switchtype )
+	{
+		case "halftime":
+			return "halftime";
+		case "overtime":
+			return "overtime";
+		default:
+			return "side_switch";
+	}
+}
+
+getotherteam( team )
+{
+	if ( team == "allies" )
+	{
+		return "axis";
+	}
+	else
+	{
+		return "allies";
+	}
+}
+