uploading all of gametypes_zm as a baseline

Starting part 2 of patch_zm checking.

patch_zm/maps/mp/gametypes_zm/_callbacksetup.gsc

@@ -0,0 +1,207 @@
+#include maps/mp/gametypes_zm/_hostmigration;
+#include maps/mp/gametypes_zm/_globallogic_actor;
+#include maps/mp/gametypes_zm/_globallogic_player;
+#include maps/mp/gametypes_zm/_globallogic;
+#include maps/mp/_audio;
+#include maps/mp/_utility;
+
+codecallback_startgametype()
+{
+	if ( !isDefined( level.gametypestarted ) || !level.gametypestarted )
+	{
+		[[ level.callbackstartgametype ]]();
+		level.gametypestarted = 1;
+	}
+}
+
+codecallback_finalizeinitialization()
+{
+	maps/mp/_utility::callback( "on_finalize_initialization" );
+}
+
+codecallback_playerconnect()
+{
+	self endon( "disconnect" );
+	self thread maps/mp/_audio::monitor_player_sprint();
+	[[ level.callbackplayerconnect ]]();
+}
+
+codecallback_playerdisconnect()
+{
+	self notify( "disconnect" );
+	client_num = self getentitynumber();
+	[[ level.callbackplayerdisconnect ]]();
+}
+
+codecallback_hostmigration()
+{
+/#
+	println( "****CodeCallback_HostMigration****" );
+#/
+	[[ level.callbackhostmigration ]]();
+}
+
+codecallback_hostmigrationsave()
+{
+/#
+	println( "****CodeCallback_HostMigrationSave****" );
+#/
+	[[ level.callbackhostmigrationsave ]]();
+}
+
+codecallback_prehostmigrationsave()
+{
+/#
+	println( "****CodeCallback_PreHostMigrationSave****" );
+#/
+	[[ level.callbackprehostmigrationsave ]]();
+}
+
+codecallback_playermigrated()
+{
+/#
+	println( "****CodeCallback_PlayerMigrated****" );
+#/
+	[[ level.callbackplayermigrated ]]();
+}
+
+codecallback_playerdamage( einflictor, eattacker, idamage, idflags, smeansofdeath, sweapon, vpoint, vdir, shitloc, timeoffset, boneindex )
+{
+	self endon( "disconnect" );
+	[[ level.callbackplayerdamage ]]( einflictor, eattacker, idamage, idflags, smeansofdeath, sweapon, vpoint, vdir, shitloc, timeoffset, boneindex );
+}
+
+codecallback_playerkilled( einflictor, eattacker, idamage, smeansofdeath, sweapon, vdir, shitloc, timeoffset, deathanimduration )
+{
+	self endon( "disconnect" );
+	[[ level.callbackplayerkilled ]]( einflictor, eattacker, idamage, smeansofdeath, sweapon, vdir, shitloc, timeoffset, deathanimduration );
+}
+
+codecallback_playerlaststand( einflictor, eattacker, idamage, smeansofdeath, sweapon, vdir, shitloc, timeoffset, deathanimduration )
+{
+	self endon( "disconnect" );
+	[[ level.callbackplayerlaststand ]]( einflictor, eattacker, idamage, smeansofdeath, sweapon, vdir, shitloc, timeoffset, deathanimduration );
+}
+
+codecallback_playermelee( eattacker, idamage, sweapon, vorigin, vdir, boneindex, shieldhit )
+{
+	self endon( "disconnect" );
+	[[ level.callbackplayermelee ]]( eattacker, idamage, sweapon, vorigin, vdir, boneindex, shieldhit );
+}
+
+codecallback_actordamage( einflictor, eattacker, idamage, idflags, smeansofdeath, sweapon, vpoint, vdir, shitloc, timeoffset, boneindex )
+{
+	[[ level.callbackactordamage ]]( einflictor, eattacker, idamage, idflags, smeansofdeath, sweapon, vpoint, vdir, shitloc, timeoffset, boneindex );
+}
+
+codecallback_actorkilled( einflictor, eattacker, idamage, smeansofdeath, sweapon, vdir, shitloc, timeoffset )
+{
+	[[ level.callbackactorkilled ]]( einflictor, eattacker, idamage, smeansofdeath, sweapon, vdir, shitloc, timeoffset );
+}
+
+codecallback_vehicledamage( einflictor, eattacker, idamage, idflags, smeansofdeath, sweapon, vpoint, vdir, shitloc, timeoffset, damagefromunderneath, modelindex, partname )
+{
+	[[ level.callbackvehicledamage ]]( einflictor, eattacker, idamage, idflags, smeansofdeath, sweapon, vpoint, vdir, shitloc, timeoffset, damagefromunderneath, modelindex, partname );
+}
+
+codecallback_vehicleradiusdamage( einflictor, eattacker, idamage, finnerdamage, fouterdamage, idflags, smeansofdeath, sweapon, vpoint, fradius, fconeanglecos, vconedir, timeoffset )
+{
+}
+
+codecallback_faceeventnotify( notify_msg, ent )
+{
+	if ( isDefined( ent ) && isDefined( ent.do_face_anims ) && ent.do_face_anims )
+	{
+		if ( isDefined( level.face_event_handler ) && isDefined( level.face_event_handler.events[ notify_msg ] ) )
+		{
+			ent sendfaceevent( level.face_event_handler.events[ notify_msg ] );
+		}
+	}
+}
+
+codecallback_menuresponse( action, arg )
+{
+	if ( !isDefined( level.menuresponsequeue ) )
+	{
+		level.menuresponsequeue = [];
+		level thread menuresponsequeuepump();
+	}
+	index = level.menuresponsequeue.size;
+	level.menuresponsequeue[ index ] = spawnstruct();
+	level.menuresponsequeue[ index ].action = action;
+	level.menuresponsequeue[ index ].arg = arg;
+	level.menuresponsequeue[ index ].ent = self;
+	level notify( "menuresponse_queue" );
+}
+
+menuresponsequeuepump()
+{
+	while ( 1 )
+	{
+		level waittill( "menuresponse_queue" );
+		level.menuresponsequeue[ 0 ].ent notify( "menuresponse" );
+		arrayremoveindex( level.menuresponsequeue, 0, 0 );
+		wait 0,05;
+	}
+}
+
+setupcallbacks()
+{
+	setdefaultcallbacks();
+	level.idflags_radius = 1;
+	level.idflags_no_armor = 2;
+	level.idflags_no_knockback = 4;
+	level.idflags_penetration = 8;
+	level.idflags_destructible_entity = 16;
+	level.idflags_shield_explosive_impact = 32;
+	level.idflags_shield_explosive_impact_huge = 64;
+	level.idflags_shield_explosive_splash = 128;
+	level.idflags_no_team_protection = 256;
+	level.idflags_no_protection = 512;
+	level.idflags_passthru = 1024;
+}
+
+setdefaultcallbacks()
+{
+	level.callbackstartgametype = ::maps/mp/gametypes_zm/_globallogic::callback_startgametype;
+	level.callbackplayerconnect = ::maps/mp/gametypes_zm/_globallogic_player::callback_playerconnect;
+	level.callbackplayerdisconnect = ::maps/mp/gametypes_zm/_globallogic_player::callback_playerdisconnect;
+	level.callbackplayerdamage = ::maps/mp/gametypes_zm/_globallogic_player::callback_playerdamage;
+	level.callbackplayerkilled = ::maps/mp/gametypes_zm/_globallogic_player::callback_playerkilled;
+	level.callbackplayermelee = ::maps/mp/gametypes_zm/_globallogic_player::callback_playermelee;
+	level.callbackplayerlaststand = ::maps/mp/gametypes_zm/_globallogic_player::callback_playerlaststand;
+	level.callbackactordamage = ::maps/mp/gametypes_zm/_globallogic_actor::callback_actordamage;
+	level.callbackactorkilled = ::maps/mp/gametypes_zm/_globallogic_actor::callback_actorkilled;
+	level.callbackplayermigrated = ::maps/mp/gametypes_zm/_globallogic_player::callback_playermigrated;
+	level.callbackhostmigration = ::maps/mp/gametypes_zm/_hostmigration::callback_hostmigration;
+	level.callbackhostmigrationsave = ::maps/mp/gametypes_zm/_hostmigration::callback_hostmigrationsave;
+	level.callbackprehostmigrationsave = ::maps/mp/gametypes_zm/_hostmigration::callback_prehostmigrationsave;
+}
+
+abortlevel()
+{
+/#
+	println( "ERROR: Aborting level - gametype is not supported" );
+#/
+	level.callbackstartgametype = ::callbackvoid;
+	level.callbackplayerconnect = ::callbackvoid;
+	level.callbackplayerdisconnect = ::callbackvoid;
+	level.callbackplayerdamage = ::callbackvoid;
+	level.callbackplayerkilled = ::callbackvoid;
+	level.callbackplayermelee = ::callbackvoid;
+	level.callbackplayerlaststand = ::callbackvoid;
+	level.callbackactordamage = ::callbackvoid;
+	level.callbackactorkilled = ::callbackvoid;
+	level.callbackvehicledamage = ::callbackvoid;
+	setdvar( "g_gametype", "dm" );
+	exitlevel( 0 );
+}
+
+codecallback_glasssmash( pos, dir )
+{
+	level notify( "glass_smash" );
+}
+
+callbackvoid()
+{
+}

patch_zm/maps/mp/gametypes_zm/_damagefeedback.gsc

@@ -0,0 +1,160 @@
+
+init()
+{
+	precacheshader( "damage_feedback" );
+	precacheshader( "damage_feedback_flak" );
+	precacheshader( "damage_feedback_tac" );
+	level thread onplayerconnect();
+}
+
+onplayerconnect()
+{
+	for ( ;; )
+	{
+		level waittill( "connecting", player );
+		player.hud_damagefeedback = newdamageindicatorhudelem( player );
+		player.hud_damagefeedback.horzalign = "center";
+		player.hud_damagefeedback.vertalign = "middle";
+		player.hud_damagefeedback.x = -12;
+		player.hud_damagefeedback.y = -12;
+		player.hud_damagefeedback.alpha = 0;
+		player.hud_damagefeedback.archived = 1;
+		player.hud_damagefeedback setshader( "damage_feedback", 24, 48 );
+		player.hitsoundtracker = 1;
+	}
+}
+
+updatedamagefeedback( mod, inflictor, perkfeedback )
+{
+	if ( !isplayer( self ) || sessionmodeiszombiesgame() )
+	{
+		return;
+	}
+	if ( isDefined( mod ) && mod != "MOD_CRUSH" && mod != "MOD_GRENADE_SPLASH" && mod != "MOD_HIT_BY_OBJECT" )
+	{
+		if ( isDefined( inflictor ) && isDefined( inflictor.soundmod ) )
+		{
+			switch( inflictor.soundmod )
+			{
+				case "player":
+					self thread playhitsound( mod, "mpl_hit_alert" );
+					break;
+				case "heli":
+					self thread playhitsound( mod, "mpl_hit_alert_air" );
+					break;
+				case "hpm":
+					self thread playhitsound( mod, "mpl_hit_alert_hpm" );
+					break;
+				case "taser_spike":
+					self thread playhitsound( mod, "mpl_hit_alert_taser_spike" );
+					break;
+				case "dog":
+				case "straferun":
+					case "default_loud":
+						self thread playhitsound( mod, "mpl_hit_heli_gunner" );
+						break;
+					default:
+						self thread playhitsound( mod, "mpl_hit_alert_low" );
+						break;
+				}
+			}
+			else self thread playhitsound( mod, "mpl_hit_alert_low" );
+		}
+		if ( isDefined( perkfeedback ) )
+		{
+			switch( perkfeedback )
+			{
+				case "flakjacket":
+					self.hud_damagefeedback setshader( "damage_feedback_flak", 24, 48 );
+					break;
+				case "tacticalMask":
+					self.hud_damagefeedback setshader( "damage_feedback_tac", 24, 48 );
+					break;
+			}
+		}
+		else self.hud_damagefeedback setshader( "damage_feedback", 24, 48 );
+		self.hud_damagefeedback.alpha = 1;
+		self.hud_damagefeedback fadeovertime( 1 );
+		self.hud_damagefeedback.alpha = 0;
+	}
+}
+
+playhitsound( mod, alert )
+{
+	self endon( "disconnect" );
+	if ( self.hitsoundtracker )
+	{
+		self.hitsoundtracker = 0;
+		self playlocalsound( alert );
+		wait 0,05;
+		self.hitsoundtracker = 1;
+	}
+}
+
+updatespecialdamagefeedback( hitent )
+{
+	if ( !isplayer( self ) )
+	{
+		return;
+	}
+	if ( !isDefined( hitent ) )
+	{
+		return;
+	}
+	if ( !isplayer( hitent ) )
+	{
+		return;
+	}
+	wait 0,05;
+	if ( !isDefined( self.directionalhitarray ) )
+	{
+		self.directionalhitarray = [];
+		hitentnum = hitent getentitynumber();
+		self.directionalhitarray[ hitentnum ] = 1;
+		self thread sendhitspecialeventatframeend( hitent );
+	}
+	else
+	{
+		hitentnum = hitent getentitynumber();
+		self.directionalhitarray[ hitentnum ] = 1;
+	}
+}
+
+sendhitspecialeventatframeend( hitent )
+{
+	self endon( "disconnect" );
+	waittillframeend;
+	enemyshit = 0;
+	value = 1;
+	entbitarray0 = 0;
+	i = 0;
+	while ( i < 32 )
+	{
+		if ( isDefined( self.directionalhitarray[ i ] ) && self.directionalhitarray[ i ] != 0 )
+		{
+			entbitarray0 += value;
+			enemyshit++;
+		}
+		value *= 2;
+		i++;
+	}
+	entbitarray1 = 0;
+	i = 33;
+	while ( i < 64 )
+	{
+		if ( isDefined( self.directionalhitarray[ i ] ) && self.directionalhitarray[ i ] != 0 )
+		{
+			entbitarray1 += value;
+			enemyshit++;
+		}
+		value *= 2;
+		i++;
+	}
+	if ( enemyshit )
+	{
+		self directionalhitindicator( entbitarray0, entbitarray1 );
+	}
+	self.directionalhitarray = undefined;
+	entbitarray0 = 0;
+	entbitarray1 = 0;
+}

patch_zm/maps/mp/gametypes_zm/_dev.gsc

@@ -0,0 +1,102 @@
+#include maps/mp/_utility;
+#include common_scripts/utility;
+
+init()
+{
+/#
+	for ( ;; )
+	{
+		updatedevsettingszm();
+		wait 0,5;
+#/
+	}
+}
+
+updatedevsettingszm()
+{
+/#
+	if ( level.players.size > 0 )
+	{
+		if ( getDvar( "r_streamDumpDistance" ) == "3" )
+		{
+			if ( !isDefined( level.streamdumpteamindex ) )
+			{
+				level.streamdumpteamindex = 0;
+			}
+			else
+			{
+				level.streamdumpteamindex++;
+			}
+			numpoints = 0;
+			spawnpoints = [];
+			location = level.scr_zm_map_start_location;
+			if ( location != "default" && location == "" && isDefined( level.default_start_location ) )
+			{
+				location = level.default_start_location;
+			}
+			match_string = ( level.scr_zm_ui_gametype + "_" ) + location;
+			if ( level.streamdumpteamindex < level.teams.size )
+			{
+				structs = getstructarray( "initial_spawn", "script_noteworthy" );
+				while ( isDefined( structs ) )
+				{
+					_a46 = structs;
+					_k46 = getFirstArrayKey( _a46 );
+					while ( isDefined( _k46 ) )
+					{
+						struct = _a46[ _k46 ];
+						while ( isDefined( struct.script_string ) )
+						{
+							tokens = strtok( struct.script_string, " " );
+							_a51 = tokens;
+							_k51 = getFirstArrayKey( _a51 );
+							while ( isDefined( _k51 ) )
+							{
+								token = _a51[ _k51 ];
+								if ( token == match_string )
+								{
+									spawnpoints[ spawnpoints.size ] = struct;
+								}
+								_k51 = getNextArrayKey( _a51, _k51 );
+							}
+						}
+						_k46 = getNextArrayKey( _a46, _k46 );
+					}
+				}
+				if ( !isDefined( spawnpoints ) || spawnpoints.size == 0 )
+				{
+					spawnpoints = getstructarray( "initial_spawn_points", "targetname" );
+				}
+				if ( isDefined( spawnpoints ) )
+				{
+					numpoints = spawnpoints.size;
+				}
+			}
+			if ( numpoints == 0 )
+			{
+				setdvar( "r_streamDumpDistance", "0" );
+				level.streamdumpteamindex = -1;
+				return;
+			}
+			else
+			{
+				averageorigin = ( 0, 0, 0 );
+				averageangles = ( 0, 0, 0 );
+				_a80 = spawnpoints;
+				_k80 = getFirstArrayKey( _a80 );
+				while ( isDefined( _k80 ) )
+				{
+					spawnpoint = _a80[ _k80 ];
+					averageorigin += spawnpoint.origin / numpoints;
+					averageangles += spawnpoint.angles / numpoints;
+					_k80 = getNextArrayKey( _a80, _k80 );
+				}
+				level.players[ 0 ] setplayerangles( averageangles );
+				level.players[ 0 ] setorigin( averageorigin );
+				wait 0,05;
+				setdvar( "r_streamDumpDistance", "2" );
+#/
+			}
+		}
+	}
+}

patch_zm/maps/mp/gametypes_zm/_globallogic_actor.gsc

@@ -0,0 +1,207 @@
+#include maps/mp/_challenges;
+#include maps/mp/gametypes_zm/_damagefeedback;
+#include maps/mp/gametypes_zm/_weapons;
+#include maps/mp/gametypes_zm/_globallogic_utils;
+#include maps/mp/gametypes_zm/_globallogic_player;
+#include maps/mp/_utility;
+
+callback_actordamage( einflictor, eattacker, idamage, idflags, smeansofdeath, sweapon, vpoint, vdir, shitloc, psoffsettime, boneindex )
+{
+	if ( game[ "state" ] == "postgame" )
+	{
+		return;
+	}
+	if ( self.aiteam == "spectator" )
+	{
+		return;
+	}
+	if ( isDefined( eattacker ) && isplayer( eattacker ) && isDefined( eattacker.candocombat ) && !eattacker.candocombat )
+	{
+		return;
+	}
+	self.idflags = idflags;
+	self.idflagstime = getTime();
+	eattacker = maps/mp/gametypes_zm/_globallogic_player::figureoutattacker( eattacker );
+	if ( !isDefined( vdir ) )
+	{
+		idflags |= level.idflags_no_knockback;
+	}
+	friendly = 0;
+	if ( self.health == self.maxhealth || !isDefined( self.attackers ) )
+	{
+		self.attackers = [];
+		self.attackerdata = [];
+		self.attackerdamage = [];
+	}
+	if ( maps/mp/gametypes_zm/_globallogic_utils::isheadshot( sweapon, shitloc, smeansofdeath, einflictor ) )
+	{
+		smeansofdeath = "MOD_HEAD_SHOT";
+	}
+	if ( level.onlyheadshots )
+	{
+		if ( smeansofdeath == "MOD_PISTOL_BULLET" || smeansofdeath == "MOD_RIFLE_BULLET" )
+		{
+			return;
+		}
+		else
+		{
+			if ( smeansofdeath == "MOD_HEAD_SHOT" )
+			{
+				idamage = 150;
+			}
+		}
+	}
+	if ( sweapon == "none" && isDefined( einflictor ) )
+	{
+		if ( isDefined( einflictor.targetname ) && einflictor.targetname == "explodable_barrel" )
+		{
+			sweapon = "explodable_barrel_mp";
+		}
+		else
+		{
+			if ( isDefined( einflictor.destructible_type ) && issubstr( einflictor.destructible_type, "vehicle_" ) )
+			{
+				sweapon = "destructible_car_mp";
+			}
+		}
+	}
+	if ( idflags & level.idflags_no_protection )
+	{
+		if ( isplayer( eattacker ) )
+		{
+			eattacker.pers[ "participation" ]++;
+		}
+		prevhealthratio = self.health / self.maxhealth;
+		if ( level.teambased && isplayer( eattacker ) && self != eattacker && self.aiteam == eattacker.pers[ "team" ] )
+		{
+			if ( level.friendlyfire == 0 )
+			{
+				return;
+			}
+			else if ( level.friendlyfire == 1 )
+			{
+				if ( idamage < 1 )
+				{
+					idamage = 1;
+				}
+				self.lastdamagewasfromenemy = 0;
+				self finishactordamage( einflictor, eattacker, idamage, idflags, smeansofdeath, sweapon, vpoint, vdir, shitloc, psoffsettime, boneindex );
+			}
+			else if ( level.friendlyfire == 2 )
+			{
+				return;
+			}
+			else
+			{
+				if ( level.friendlyfire == 3 )
+				{
+					idamage = int( idamage * 0,5 );
+					if ( idamage < 1 )
+					{
+						idamage = 1;
+					}
+					self.lastdamagewasfromenemy = 0;
+					self finishactordamage( einflictor, eattacker, idamage, idflags, smeansofdeath, sweapon, vpoint, vdir, shitloc, psoffsettime, boneindex );
+				}
+			}
+			friendly = 1;
+		}
+		else
+		{
+			if ( isDefined( eattacker ) && isDefined( self.script_owner ) && eattacker == self.script_owner && !level.hardcoremode )
+			{
+				return;
+			}
+			if ( isDefined( eattacker ) && isDefined( self.script_owner ) && isDefined( eattacker.script_owner ) && eattacker.script_owner == self.script_owner )
+			{
+				return;
+			}
+			if ( idamage < 1 )
+			{
+				idamage = 1;
+			}
+			if ( isDefined( eattacker ) && isplayer( eattacker ) && isDefined( sweapon ) && !issubstr( smeansofdeath, "MOD_MELEE" ) )
+			{
+				eattacker thread maps/mp/gametypes_zm/_weapons::checkhit( sweapon );
+			}
+			if ( issubstr( smeansofdeath, "MOD_GRENADE" ) && isDefined( einflictor ) && isDefined( einflictor.iscooked ) )
+			{
+				self.wascooked = getTime();
+			}
+			else
+			{
+				self.wascooked = undefined;
+			}
+			if ( isDefined( eattacker ) )
+			{
+				self.lastdamagewasfromenemy = eattacker != self;
+			}
+			self finishactordamage( einflictor, eattacker, idamage, idflags, smeansofdeath, sweapon, vpoint, vdir, shitloc, psoffsettime, boneindex );
+		}
+		if ( isDefined( eattacker ) && eattacker != self )
+		{
+			if ( sweapon != "artillery_mp" || !isDefined( einflictor ) && !isai( einflictor ) )
+			{
+				if ( idamage > 0 )
+				{
+					eattacker thread maps/mp/gametypes_zm/_damagefeedback::updatedamagefeedback( smeansofdeath, einflictor );
+				}
+			}
+		}
+	}
+/#
+	if ( getDvarInt( "g_debugDamage" ) )
+	{
+		println( "actor:" + self getentitynumber() + " health:" + self.health + " attacker:" + eattacker.clientid + " inflictor is player:" + isplayer( einflictor ) + " damage:" + idamage + shitloc + ";" + boneindex + "\n" );
+#/
+	}
+	if ( 1 )
+	{
+		lpselfnum = self getentitynumber();
+		lpselfteam = self.aiteam;
+		lpattackerteam = "";
+		if ( isplayer( eattacker ) )
+		{
+			lpattacknum = eattacker getentitynumber();
+			lpattackguid = eattacker getguid();
+			lpattackname = eattacker.name;
+			lpattackerteam = eattacker.pers[ "team" ];
+		}
+		else
+		{
+			lpattacknum = -1;
+			lpattackguid = "";
+			lpattackname = "";
+			lpattackerteam = "world";
+		}
+		logprint( "AD;" + lpselfnum + ";" + lpselfteam + ";" + lpattackguid + ";" + lpattacknum + ";" + lpattackerteam + ";" + lpattackname + ";" + sweapon + ";" + idamage + ";" + smeansofdeath + ";" + shitloc + "\n" );
+	}
+}
+
+callback_actorkilled( einflictor, attacker, idamage, smeansofdeath, sweapon, vdir, shitloc, psoffsettime )
+{
+	if ( game[ "state" ] == "postgame" )
+	{
+		return;
+	}
+	if ( isai( attacker ) && isDefined( attacker.script_owner ) )
+	{
+		if ( attacker.script_owner.team != self.aiteam )
+		{
+			attacker = attacker.script_owner;
+		}
+	}
+	if ( attacker.classname == "script_vehicle" && isDefined( attacker.owner ) )
+	{
+		attacker = attacker.owner;
+	}
+	if ( isDefined( attacker ) && isplayer( attacker ) )
+	{
+		if ( !level.teambased || self.aiteam != attacker.pers[ "team" ] )
+		{
+			level.globalkillstreaksdestroyed++;
+			attacker addweaponstat( "dogs_mp", "destroyed", 1 );
+			attacker maps/mp/_challenges::killeddog();
+		}
+	}
+}

patch_zm/maps/mp/gametypes_zm/_globallogic_defaults.gsc

@@ -0,0 +1,230 @@
+#include maps/mp/gametypes_zm/_spawnlogic;
+#include maps/mp/gametypes_zm/_globallogic_audio;
+#include maps/mp/gametypes_zm/_globallogic_score;
+#include maps/mp/gametypes_zm/_globallogic;
+#include maps/mp/gametypes_zm/_globallogic_utils;
+#include maps/mp/_utility;
+#include common_scripts/utility;
+
+getwinningteamfromloser( losing_team )
+{
+	if ( level.multiteam )
+	{
+		return "tie";
+	}
+	else
+	{
+		if ( losing_team == "axis" )
+		{
+			return "allies";
+		}
+	}
+	return "axis";
+}
+
+default_onforfeit( team )
+{
+	level.gameforfeited = 1;
+	level notify( "forfeit in progress" );
+	level endon( "forfeit in progress" );
+	level endon( "abort forfeit" );
+	forfeit_delay = 20;
+	announcement( game[ "strings" ][ "opponent_forfeiting_in" ], forfeit_delay, 0 );
+	wait 10;
+	announcement( game[ "strings" ][ "opponent_forfeiting_in" ], 10, 0 );
+	wait 10;
+	endreason = &"";
+	if ( !isDefined( team ) )
+	{
+		setdvar( "ui_text_endreason", game[ "strings" ][ "players_forfeited" ] );
+		endreason = game[ "strings" ][ "players_forfeited" ];
+		winner = level.players[ 0 ];
+	}
+	else if ( isDefined( level.teams[ team ] ) )
+	{
+		endreason = game[ "strings" ][ team + "_forfeited" ];
+		setdvar( "ui_text_endreason", endreason );
+		winner = getwinningteamfromloser( team );
+	}
+	else
+	{
+/#
+		assert( isDefined( team ), "Forfeited team is not defined" );
+#/
+/#
+		assert( 0, "Forfeited team " + team + " is not allies or axis" );
+#/
+		winner = "tie";
+	}
+	level.forcedend = 1;
+	if ( isplayer( winner ) )
+	{
+		logstring( "forfeit, win: " + winner getxuid() + "(" + winner.name + ")" );
+	}
+	else
+	{
+		maps/mp/gametypes_zm/_globallogic_utils::logteamwinstring( "forfeit", winner );
+	}
+	thread maps/mp/gametypes_zm/_globallogic::endgame( winner, endreason );
+}
+
+default_ondeadevent( team )
+{
+	if ( isDefined( level.teams[ team ] ) )
+	{
+		eliminatedstring = game[ "strings" ][ team + "_eliminated" ];
+		iprintln( eliminatedstring );
+		makedvarserverinfo( "ui_text_endreason", eliminatedstring );
+		setdvar( "ui_text_endreason", eliminatedstring );
+		winner = getwinningteamfromloser( team );
+		maps/mp/gametypes_zm/_globallogic_utils::logteamwinstring( "team eliminated", winner );
+		thread maps/mp/gametypes_zm/_globallogic::endgame( winner, eliminatedstring );
+	}
+	else makedvarserverinfo( "ui_text_endreason", game[ "strings" ][ "tie" ] );
+	setdvar( "ui_text_endreason", game[ "strings" ][ "tie" ] );
+	maps/mp/gametypes_zm/_globallogic_utils::logteamwinstring( "tie" );
+	if ( level.teambased )
+	{
+		thread maps/mp/gametypes_zm/_globallogic::endgame( "tie", game[ "strings" ][ "tie" ] );
+	}
+	else
+	{
+		thread maps/mp/gametypes_zm/_globallogic::endgame( undefined, game[ "strings" ][ "tie" ] );
+	}
+}
+
+default_onalivecountchange( team )
+{
+}
+
+default_onroundendgame( winner )
+{
+	return winner;
+}
+
+default_ononeleftevent( team )
+{
+	if ( !level.teambased )
+	{
+		winner = maps/mp/gametypes_zm/_globallogic_score::gethighestscoringplayer();
+		if ( isDefined( winner ) )
+		{
+			logstring( "last one alive, win: " + winner.name );
+		}
+		else
+		{
+			logstring( "last one alive, win: unknown" );
+		}
+		thread maps/mp/gametypes_zm/_globallogic::endgame( winner, &"MP_ENEMIES_ELIMINATED" );
+	}
+	else
+	{
+		index = 0;
+		while ( index < level.players.size )
+		{
+			player = level.players[ index ];
+			if ( !isalive( player ) )
+			{
+				index++;
+				continue;
+			}
+			else if ( !isDefined( player.pers[ "team" ] ) || player.pers[ "team" ] != team )
+			{
+				index++;
+				continue;
+			}
+			else
+			{
+				player maps/mp/gametypes_zm/_globallogic_audio::leaderdialogonplayer( "sudden_death" );
+			}
+			index++;
+		}
+	}
+}
+
+default_ontimelimit()
+{
+	winner = undefined;
+	if ( level.teambased )
+	{
+		winner = maps/mp/gametypes_zm/_globallogic::determineteamwinnerbygamestat( "teamScores" );
+		maps/mp/gametypes_zm/_globallogic_utils::logteamwinstring( "time limit", winner );
+	}
+	else winner = maps/mp/gametypes_zm/_globallogic_score::gethighestscoringplayer();
+	if ( isDefined( winner ) )
+	{
+		logstring( "time limit, win: " + winner.name );
+	}
+	else
+	{
+		logstring( "time limit, tie" );
+	}
+	makedvarserverinfo( "ui_text_endreason", game[ "strings" ][ "time_limit_reached" ] );
+	setdvar( "ui_text_endreason", game[ "strings" ][ "time_limit_reached" ] );
+	thread maps/mp/gametypes_zm/_globallogic::endgame( winner, game[ "strings" ][ "time_limit_reached" ] );
+}
+
+default_onscorelimit()
+{
+	if ( !level.endgameonscorelimit )
+	{
+		return 0;
+	}
+	winner = undefined;
+	if ( level.teambased )
+	{
+		winner = maps/mp/gametypes_zm/_globallogic::determineteamwinnerbygamestat( "teamScores" );
+		maps/mp/gametypes_zm/_globallogic_utils::logteamwinstring( "scorelimit", winner );
+	}
+	else winner = maps/mp/gametypes_zm/_globallogic_score::gethighestscoringplayer();
+	if ( isDefined( winner ) )
+	{
+		logstring( "scorelimit, win: " + winner.name );
+	}
+	else
+	{
+		logstring( "scorelimit, tie" );
+	}
+	makedvarserverinfo( "ui_text_endreason", game[ "strings" ][ "score_limit_reached" ] );
+	setdvar( "ui_text_endreason", game[ "strings" ][ "score_limit_reached" ] );
+	thread maps/mp/gametypes_zm/_globallogic::endgame( winner, game[ "strings" ][ "score_limit_reached" ] );
+	return 1;
+}
+
+default_onspawnspectator( origin, angles )
+{
+	if ( isDefined( origin ) && isDefined( angles ) )
+	{
+		self spawn( origin, angles );
+		return;
+	}
+	spawnpointname = "mp_global_intermission";
+	spawnpoints = getentarray( spawnpointname, "classname" );
+/#
+	assert( spawnpoints.size, "There are no mp_global_intermission spawn points in the map.  There must be at least one." );
+#/
+	spawnpoint = maps/mp/gametypes_zm/_spawnlogic::getspawnpoint_random( spawnpoints );
+	self spawn( spawnpoint.origin, spawnpoint.angles );
+}
+
+default_onspawnintermission()
+{
+	spawnpointname = "mp_global_intermission";
+	spawnpoints = getentarray( spawnpointname, "classname" );
+	spawnpoint = spawnpoints[ 0 ];
+	if ( isDefined( spawnpoint ) )
+	{
+		self spawn( spawnpoint.origin, spawnpoint.angles );
+	}
+	else
+	{
+/#
+		maps/mp/_utility::error( "NO " + spawnpointname + " SPAWNPOINTS IN MAP" );
+#/
+	}
+}
+
+default_gettimelimit()
+{
+	return clamp( getgametypesetting( "timeLimit" ), level.timelimitmin, level.timelimitmax );
+}

patch_zm/maps/mp/gametypes_zm/_globallogic_score.gsc

@@ -0,0 +1,873 @@
+#include maps/mp/gametypes_zm/_globallogic_utils;
+#include maps/mp/_challenges;
+#include maps/mp/gametypes_zm/_globallogic_audio;
+#include maps/mp/gametypes_zm/_globallogic_score;
+#include maps/mp/gametypes_zm/_globallogic;
+#include maps/mp/_bb;
+#include maps/mp/_utility;
+#include common_scripts/utility;
+
+updatematchbonusscores( winner )
+{
+}
+
+givematchbonus( scoretype, score )
+{
+}
+
+doskillupdate( winner )
+{
+	skillupdate( winner, level.teambased );
+}
+
+gethighestscoringplayer()
+{
+	players = level.players;
+	winner = undefined;
+	tie = 0;
+	i = 0;
+	while ( i < players.size )
+	{
+		if ( !isDefined( players[ i ].score ) )
+		{
+			i++;
+			continue;
+		}
+		else if ( players[ i ].score < 1 )
+		{
+			i++;
+			continue;
+		}
+		else if ( !isDefined( winner ) || players[ i ].score > winner.score )
+		{
+			winner = players[ i ];
+			tie = 0;
+			i++;
+			continue;
+		}
+		else
+		{
+			if ( players[ i ].score == winner.score )
+			{
+				tie = 1;
+			}
+		}
+		i++;
+	}
+	if ( tie || !isDefined( winner ) )
+	{
+		return undefined;
+	}
+	else
+	{
+		return winner;
+	}
+}
+
+resetscorechain()
+{
+	self notify( "reset_score_chain" );
+	self.scorechain = 0;
+	self.rankupdatetotal = 0;
+}
+
+scorechaintimer()
+{
+	self notify( "score_chain_timer" );
+	self endon( "reset_score_chain" );
+	self endon( "score_chain_timer" );
+	self endon( "death" );
+	self endon( "disconnect" );
+	wait 20;
+	self thread resetscorechain();
+}
+
+roundtonearestfive( score )
+{
+	rounding = score % 5;
+	if ( rounding <= 2 )
+	{
+		return score - rounding;
+	}
+	else
+	{
+		return score + ( 5 - rounding );
+	}
+}
+
+giveplayermomentumnotification( score, label, descvalue, countstowardrampage )
+{
+	rampagebonus = 0;
+	if ( isDefined( level.usingrampage ) && level.usingrampage )
+	{
+		if ( countstowardrampage )
+		{
+			if ( !isDefined( self.scorechain ) )
+			{
+				self.scorechain = 0;
+			}
+			self.scorechain++;
+			self thread scorechaintimer();
+		}
+		if ( isDefined( self.scorechain ) && self.scorechain >= 999 )
+		{
+			rampagebonus = roundtonearestfive( int( ( score * level.rampagebonusscale ) + 0,5 ) );
+		}
+	}
+	if ( score != 0 )
+	{
+		self luinotifyevent( &"score_event", 3, label, score, rampagebonus );
+	}
+	score += rampagebonus;
+	if ( score > 0 && self hasperk( "specialty_earnmoremomentum" ) )
+	{
+		score = roundtonearestfive( int( ( score * getDvarFloat( "perk_killstreakMomentumMultiplier" ) ) + 0,5 ) );
+	}
+	_setplayermomentum( self, self.pers[ "momentum" ] + score );
+}
+
+resetplayermomentumondeath()
+{
+	if ( isDefined( level.usingscorestreaks ) && level.usingscorestreaks )
+	{
+		_setplayermomentum( self, 0 );
+		self thread resetscorechain();
+	}
+}
+
+giveplayermomentum( event, player, victim, weapon, descvalue )
+{
+}
+
+giveplayerscore( event, player, victim, weapon, descvalue )
+{
+	scorediff = 0;
+	momentum = player.pers[ "momentum" ];
+	giveplayermomentum( event, player, victim, weapon, descvalue );
+	newmomentum = player.pers[ "momentum" ];
+	if ( level.overrideplayerscore )
+	{
+		return 0;
+	}
+	pixbeginevent( "level.onPlayerScore" );
+	score = player.pers[ "score" ];
+	[[ level.onplayerscore ]]( event, player, victim );
+	newscore = player.pers[ "score" ];
+	pixendevent();
+	bbprint( "mpplayerscore", "spawnid %d gametime %d type %s player %s delta %d deltamomentum %d team %s", getplayerspawnid( player ), getTime(), event, player.name, newscore - score, newmomentum - momentum, player.team );
+	player maps/mp/_bb::bbaddtostat( "score", newscore - score );
+	if ( score == newscore )
+	{
+		return 0;
+	}
+	pixbeginevent( "givePlayerScore" );
+	recordplayerstats( player, "score", newscore );
+	scorediff = newscore - score;
+	player addplayerstatwithgametype( "score", scorediff );
+	if ( isDefined( player.pers[ "lastHighestScore" ] ) && newscore > player.pers[ "lastHighestScore" ] )
+	{
+		player setdstat( "HighestStats", "highest_score", newscore );
+	}
+	pixendevent();
+	return scorediff;
+}
+
+default_onplayerscore( event, player, victim )
+{
+}
+
+_setplayerscore( player, score )
+{
+}
+
+_getplayerscore( player )
+{
+	return player.pers[ "score" ];
+}
+
+_setplayermomentum( player, momentum )
+{
+	momentum = clamp( momentum, 0, 2000 );
+	oldmomentum = player.pers[ "momentum" ];
+	if ( momentum == oldmomentum )
+	{
+		return;
+	}
+	player maps/mp/_bb::bbaddtostat( "momentum", momentum - oldmomentum );
+	if ( momentum > oldmomentum )
+	{
+		highestmomentumcost = 0;
+		numkillstreaks = player.killstreak.size;
+		killstreaktypearray = [];
+	}
+	player.pers[ "momentum" ] = momentum;
+	player.momentum = player.pers[ "momentum" ];
+}
+
+_giveplayerkillstreakinternal( player, momentum, oldmomentum, killstreaktypearray )
+{
+}
+
+setplayermomentumdebug()
+{
+/#
+	setdvar( "sv_momentumPercent", 0 );
+	while ( 1 )
+	{
+		wait 1;
+		momentumpercent = getdvarfloatdefault( "sv_momentumPercent", 0 );
+		if ( momentumpercent != 0 )
+		{
+			player = gethostplayer();
+			if ( !isDefined( player ) )
+			{
+				return;
+			}
+			if ( isDefined( player.killstreak ) )
+			{
+				_setplayermomentum( player, int( 2000 * ( momentumpercent / 100 ) ) );
+			}
+		}
+#/
+	}
+}
+
+giveteamscore( event, team, player, victim )
+{
+	if ( level.overrideteamscore )
+	{
+		return;
+	}
+	pixbeginevent( "level.onTeamScore" );
+	teamscore = game[ "teamScores" ][ team ];
+	[[ level.onteamscore ]]( event, team );
+	pixendevent();
+	newscore = game[ "teamScores" ][ team ];
+	bbprint( "mpteamscores", "gametime %d event %s team %d diff %d score %d", getTime(), event, team, newscore - teamscore, newscore );
+	if ( teamscore == newscore )
+	{
+		return;
+	}
+	updateteamscores( team );
+	thread maps/mp/gametypes_zm/_globallogic::checkscorelimit();
+}
+
+giveteamscoreforobjective( team, score )
+{
+	teamscore = game[ "teamScores" ][ team ];
+	onteamscore( score, team );
+	newscore = game[ "teamScores" ][ team ];
+	bbprint( "mpteamobjscores", "gametime %d  team %d diff %d score %d", getTime(), team, newscore - teamscore, newscore );
+	if ( teamscore == newscore )
+	{
+		return;
+	}
+	updateteamscores( team );
+	thread maps/mp/gametypes_zm/_globallogic::checkscorelimit();
+}
+
+_setteamscore( team, teamscore )
+{
+	if ( teamscore == game[ "teamScores" ][ team ] )
+	{
+		return;
+	}
+	game[ "teamScores" ][ team ] = teamscore;
+	updateteamscores( team );
+	thread maps/mp/gametypes_zm/_globallogic::checkscorelimit();
+}
+
+resetteamscores()
+{
+	while ( isDefined( level.roundscorecarry ) || level.roundscorecarry == 0 && maps/mp/_utility::isfirstround() )
+	{
+		_a591 = level.teams;
+		_k591 = getFirstArrayKey( _a591 );
+		while ( isDefined( _k591 ) )
+		{
+			team = _a591[ _k591 ];
+			game[ "teamScores" ][ team ] = 0;
+			_k591 = getNextArrayKey( _a591, _k591 );
+		}
+	}
+	maps/mp/gametypes_zm/_globallogic_score::updateallteamscores();
+}
+
+resetallscores()
+{
+	resetteamscores();
+	resetplayerscores();
+}
+
+resetplayerscores()
+{
+	players = level.players;
+	winner = undefined;
+	tie = 0;
+	i = 0;
+	while ( i < players.size )
+	{
+		if ( isDefined( players[ i ].pers[ "score" ] ) )
+		{
+			_setplayerscore( players[ i ], 0 );
+		}
+		i++;
+	}
+}
+
+updateteamscores( team )
+{
+	setteamscore( team, game[ "teamScores" ][ team ] );
+	level thread maps/mp/gametypes_zm/_globallogic::checkteamscorelimitsoon( team );
+}
+
+updateallteamscores()
+{
+	_a629 = level.teams;
+	_k629 = getFirstArrayKey( _a629 );
+	while ( isDefined( _k629 ) )
+	{
+		team = _a629[ _k629 ];
+		updateteamscores( team );
+		_k629 = getNextArrayKey( _a629, _k629 );
+	}
+}
+
+_getteamscore( team )
+{
+	return game[ "teamScores" ][ team ];
+}
+
+gethighestteamscoreteam()
+{
+	score = 0;
+	winning_teams = [];
+	_a645 = level.teams;
+	_k645 = getFirstArrayKey( _a645 );
+	while ( isDefined( _k645 ) )
+	{
+		team = _a645[ _k645 ];
+		team_score = game[ "teamScores" ][ team ];
+		if ( team_score > score )
+		{
+			score = team_score;
+			winning_teams = [];
+		}
+		if ( team_score == score )
+		{
+			winning_teams[ team ] = team;
+		}
+		_k645 = getNextArrayKey( _a645, _k645 );
+	}
+	return winning_teams;
+}
+
+areteamarraysequal( teamsa, teamsb )
+{
+	if ( teamsa.size != teamsb.size )
+	{
+		return 0;
+	}
+	_a668 = teamsa;
+	_k668 = getFirstArrayKey( _a668 );
+	while ( isDefined( _k668 ) )
+	{
+		team = _a668[ _k668 ];
+		if ( !isDefined( teamsb[ team ] ) )
+		{
+			return 0;
+		}
+		_k668 = getNextArrayKey( _a668, _k668 );
+	}
+	return 1;
+}
+
+onteamscore( score, team )
+{
+	game[ "teamScores" ][ team ] += score;
+	if ( level.scorelimit && game[ "teamScores" ][ team ] > level.scorelimit )
+	{
+		game[ "teamScores" ][ team ] = level.scorelimit;
+	}
+	if ( level.splitscreen )
+	{
+		return;
+	}
+	if ( level.scorelimit == 1 )
+	{
+		return;
+	}
+	iswinning = gethighestteamscoreteam();
+	if ( iswinning.size == 0 )
+	{
+		return;
+	}
+	if ( ( getTime() - level.laststatustime ) < 5000 )
+	{
+		return;
+	}
+	if ( areteamarraysequal( iswinning, level.waswinning ) )
+	{
+		return;
+	}
+	level.laststatustime = getTime();
+	while ( iswinning.size == 1 )
+	{
+		_a707 = iswinning;
+		_k707 = getFirstArrayKey( _a707 );
+		while ( isDefined( _k707 ) )
+		{
+			team = _a707[ _k707 ];
+			if ( isDefined( level.waswinning[ team ] ) )
+			{
+				if ( level.waswinning.size == 1 )
+				{
+				}
+			}
+			else
+			{
+				maps/mp/gametypes_zm/_globallogic_audio::leaderdialog( "lead_taken", team, "status" );
+			}
+			_k707 = getNextArrayKey( _a707, _k707 );
+		}
+	}
+	while ( level.waswinning.size == 1 )
+	{
+		_a726 = level.waswinning;
+		_k726 = getFirstArrayKey( _a726 );
+		while ( isDefined( _k726 ) )
+		{
+			team = _a726[ _k726 ];
+			if ( isDefined( iswinning[ team ] ) )
+			{
+				if ( iswinning.size == 1 )
+				{
+				}
+				else if ( level.waswinning.size > 1 )
+				{
+				}
+			}
+			else
+			{
+				maps/mp/gametypes_zm/_globallogic_audio::leaderdialog( "lead_lost", team, "status" );
+			}
+			_k726 = getNextArrayKey( _a726, _k726 );
+		}
+	}
+	level.waswinning = iswinning;
+}
+
+default_onteamscore( event, team )
+{
+}
+
+initpersstat( dataname, record_stats, init_to_stat_value )
+{
+	if ( !isDefined( self.pers[ dataname ] ) )
+	{
+		self.pers[ dataname ] = 0;
+	}
+	if ( !isDefined( record_stats ) || record_stats == 1 )
+	{
+		recordplayerstats( self, dataname, int( self.pers[ dataname ] ) );
+	}
+	if ( isDefined( init_to_stat_value ) && init_to_stat_value == 1 )
+	{
+		self.pers[ dataname ] = self getdstat( "PlayerStatsList", dataname, "StatValue" );
+	}
+}
+
+getpersstat( dataname )
+{
+	return self.pers[ dataname ];
+}
+
+incpersstat( dataname, increment, record_stats, includegametype )
+{
+	pixbeginevent( "incPersStat" );
+	self.pers[ dataname ] += increment;
+	if ( isDefined( includegametype ) && includegametype )
+	{
+		self addplayerstatwithgametype( dataname, increment );
+	}
+	else
+	{
+		self addplayerstat( dataname, increment );
+	}
+	if ( !isDefined( record_stats ) || record_stats == 1 )
+	{
+		self thread threadedrecordplayerstats( dataname );
+	}
+	pixendevent();
+}
+
+threadedrecordplayerstats( dataname )
+{
+	self endon( "disconnect" );
+	waittillframeend;
+	recordplayerstats( self, dataname, self.pers[ dataname ] );
+}
+
+updatewinstats( winner )
+{
+}
+
+updatelossstats( loser )
+{
+	loser addplayerstatwithgametype( "losses", 1 );
+	loser updatestatratio( "wlratio", "wins", "losses" );
+	loser notify( "loss" );
+}
+
+updatetiestats( loser )
+{
+	loser addplayerstatwithgametype( "losses", -1 );
+	loser addplayerstatwithgametype( "ties", 1 );
+	loser updatestatratio( "wlratio", "wins", "losses" );
+	loser setdstat( "playerstatslist", "cur_win_streak", "StatValue", 0 );
+	loser notify( "tie" );
+}
+
+updatewinlossstats( winner )
+{
+	if ( !waslastround() && !level.hostforcedend )
+	{
+		return;
+	}
+	players = level.players;
+	if ( !isDefined( winner ) || isDefined( winner ) && !isplayer( winner ) && winner == "tie" )
+	{
+		i = 0;
+		while ( i < players.size )
+		{
+			if ( !isDefined( players[ i ].pers[ "team" ] ) )
+			{
+				i++;
+				continue;
+			}
+			else if ( level.hostforcedend && players[ i ] ishost() )
+			{
+				i++;
+				continue;
+			}
+			else
+			{
+				updatetiestats( players[ i ] );
+			}
+			i++;
+		}
+	}
+	else if ( isplayer( winner ) )
+	{
+		if ( level.hostforcedend && winner ishost() )
+		{
+			return;
+		}
+		updatewinstats( winner );
+	}
+	else
+	{
+		i = 0;
+		while ( i < players.size )
+		{
+			if ( !isDefined( players[ i ].pers[ "team" ] ) )
+			{
+				i++;
+				continue;
+			}
+			else if ( level.hostforcedend && players[ i ] ishost() )
+			{
+				i++;
+				continue;
+			}
+			else
+			{
+				if ( winner == "tie" )
+				{
+					updatetiestats( players[ i ] );
+					i++;
+					continue;
+				}
+				else if ( players[ i ].pers[ "team" ] == winner )
+				{
+					updatewinstats( players[ i ] );
+					i++;
+					continue;
+				}
+				else
+				{
+					players[ i ] setdstat( "playerstatslist", "cur_win_streak", "StatValue", 0 );
+				}
+			}
+			i++;
+		}
+	}
+}
+
+backupandclearwinstreaks()
+{
+}
+
+restorewinstreaks( winner )
+{
+}
+
+inckillstreaktracker( sweapon )
+{
+	self endon( "disconnect" );
+	waittillframeend;
+	if ( sweapon == "artillery_mp" )
+	{
+		self.pers[ "artillery_kills" ]++;
+	}
+	if ( sweapon == "dog_bite_mp" )
+	{
+		self.pers[ "dog_kills" ]++;
+	}
+}
+
+trackattackerkill( name, rank, xp, prestige, xuid )
+{
+	self endon( "disconnect" );
+	attacker = self;
+	waittillframeend;
+	pixbeginevent( "trackAttackerKill" );
+	if ( !isDefined( attacker.pers[ "killed_players" ][ name ] ) )
+	{
+		attacker.pers[ "killed_players" ][ name ] = 0;
+	}
+	if ( !isDefined( attacker.killedplayerscurrent[ name ] ) )
+	{
+		attacker.killedplayerscurrent[ name ] = 0;
+	}
+	if ( !isDefined( attacker.pers[ "nemesis_tracking" ][ name ] ) )
+	{
+		attacker.pers[ "nemesis_tracking" ][ name ] = 0;
+	}
+	attacker.pers[ "killed_players" ][ name ]++;
+	attacker.killedplayerscurrent[ name ]++;
+	attacker.pers[ "nemesis_tracking" ][ name ] += 1;
+	if ( attacker.pers[ "nemesis_name" ] == name )
+	{
+		attacker maps/mp/_challenges::killednemesis();
+	}
+	if ( attacker.pers[ "nemesis_name" ] == "" || attacker.pers[ "nemesis_tracking" ][ name ] > attacker.pers[ "nemesis_tracking" ][ attacker.pers[ "nemesis_name" ] ] )
+	{
+		attacker.pers[ "nemesis_name" ] = name;
+		attacker.pers[ "nemesis_rank" ] = rank;
+		attacker.pers[ "nemesis_rankIcon" ] = prestige;
+		attacker.pers[ "nemesis_xp" ] = xp;
+		attacker.pers[ "nemesis_xuid" ] = xuid;
+	}
+	else
+	{
+		if ( isDefined( attacker.pers[ "nemesis_name" ] ) && attacker.pers[ "nemesis_name" ] == name )
+		{
+			attacker.pers[ "nemesis_rank" ] = rank;
+			attacker.pers[ "nemesis_xp" ] = xp;
+		}
+	}
+	pixendevent();
+}
+
+trackattackeedeath( attackername, rank, xp, prestige, xuid )
+{
+	self endon( "disconnect" );
+	waittillframeend;
+	pixbeginevent( "trackAttackeeDeath" );
+	if ( !isDefined( self.pers[ "killed_by" ][ attackername ] ) )
+	{
+		self.pers[ "killed_by" ][ attackername ] = 0;
+	}
+	self.pers[ "killed_by" ][ attackername ]++;
+	if ( !isDefined( self.pers[ "nemesis_tracking" ][ attackername ] ) )
+	{
+		self.pers[ "nemesis_tracking" ][ attackername ] = 0;
+	}
+	self.pers[ "nemesis_tracking" ][ attackername ] += 1,5;
+	if ( self.pers[ "nemesis_name" ] == "" || self.pers[ "nemesis_tracking" ][ attackername ] > self.pers[ "nemesis_tracking" ][ self.pers[ "nemesis_name" ] ] )
+	{
+		self.pers[ "nemesis_name" ] = attackername;
+		self.pers[ "nemesis_rank" ] = rank;
+		self.pers[ "nemesis_rankIcon" ] = prestige;
+		self.pers[ "nemesis_xp" ] = xp;
+		self.pers[ "nemesis_xuid" ] = xuid;
+	}
+	else
+	{
+		if ( isDefined( self.pers[ "nemesis_name" ] ) && self.pers[ "nemesis_name" ] == attackername )
+		{
+			self.pers[ "nemesis_rank" ] = rank;
+			self.pers[ "nemesis_xp" ] = xp;
+		}
+	}
+	if ( self.pers[ "nemesis_name" ] == attackername && self.pers[ "nemesis_tracking" ][ attackername ] >= 2 )
+	{
+		self setclientuivisibilityflag( "killcam_nemesis", 1 );
+	}
+	else
+	{
+		self setclientuivisibilityflag( "killcam_nemesis", 0 );
+	}
+	pixendevent();
+}
+
+default_iskillboosting()
+{
+	return 0;
+}
+
+givekillstats( smeansofdeath, sweapon, evictim )
+{
+	self endon( "disconnect" );
+	waittillframeend;
+	if ( level.rankedmatch && self [[ level.iskillboosting ]]() )
+	{
+/#
+		self iprintlnbold( "GAMETYPE DEBUG: NOT GIVING YOU OFFENSIVE CREDIT AS BOOSTING PREVENTION" );
+#/
+		return;
+	}
+	pixbeginevent( "giveKillStats" );
+	self maps/mp/gametypes_zm/_globallogic_score::incpersstat( "kills", 1, 1, 1 );
+	self.kills = self maps/mp/gametypes_zm/_globallogic_score::getpersstat( "kills" );
+	self updatestatratio( "kdratio", "kills", "deaths" );
+	attacker = self;
+	if ( smeansofdeath == "MOD_HEAD_SHOT" )
+	{
+		attacker thread incpersstat( "headshots", 1, 1, 0 );
+		attacker.headshots = attacker.pers[ "headshots" ];
+		evictim recordkillmodifier( "headshot" );
+	}
+	pixendevent();
+}
+
+inctotalkills( team )
+{
+	if ( level.teambased && isDefined( level.teams[ team ] ) )
+	{
+		game[ "totalKillsTeam" ][ team ]++;
+	}
+	game[ "totalKills" ]++;
+}
+
+setinflictorstat( einflictor, eattacker, sweapon )
+{
+	if ( !isDefined( eattacker ) )
+	{
+		return;
+	}
+	if ( !isDefined( einflictor ) )
+	{
+		eattacker addweaponstat( sweapon, "hits", 1 );
+		return;
+	}
+	if ( !isDefined( einflictor.playeraffectedarray ) )
+	{
+		einflictor.playeraffectedarray = [];
+	}
+	foundnewplayer = 1;
+	i = 0;
+	while ( i < einflictor.playeraffectedarray.size )
+	{
+		if ( einflictor.playeraffectedarray[ i ] == self )
+		{
+			foundnewplayer = 0;
+			break;
+		}
+		else
+		{
+			i++;
+		}
+	}
+	if ( foundnewplayer )
+	{
+		einflictor.playeraffectedarray[ einflictor.playeraffectedarray.size ] = self;
+		if ( sweapon == "concussion_grenade_mp" || sweapon == "tabun_gas_mp" )
+		{
+			eattacker addweaponstat( sweapon, "used", 1 );
+		}
+		eattacker addweaponstat( sweapon, "hits", 1 );
+	}
+}
+
+processshieldassist( killedplayer )
+{
+	self endon( "disconnect" );
+	killedplayer endon( "disconnect" );
+	wait 0,05;
+	maps/mp/gametypes_zm/_globallogic_utils::waittillslowprocessallowed();
+	if ( !isDefined( level.teams[ self.pers[ "team" ] ] ) )
+	{
+		return;
+	}
+	if ( self.pers[ "team" ] == killedplayer.pers[ "team" ] )
+	{
+		return;
+	}
+	if ( !level.teambased )
+	{
+		return;
+	}
+	self maps/mp/gametypes_zm/_globallogic_score::incpersstat( "assists", 1, 1, 1 );
+	self.assists = self maps/mp/gametypes_zm/_globallogic_score::getpersstat( "assists" );
+}
+
+processassist( killedplayer, damagedone, weapon )
+{
+	self endon( "disconnect" );
+	killedplayer endon( "disconnect" );
+	wait 0,05;
+	maps/mp/gametypes_zm/_globallogic_utils::waittillslowprocessallowed();
+	if ( !isDefined( level.teams[ self.pers[ "team" ] ] ) )
+	{
+		return;
+	}
+	if ( self.pers[ "team" ] == killedplayer.pers[ "team" ] )
+	{
+		return;
+	}
+	if ( !level.teambased )
+	{
+		return;
+	}
+	assist_level = "assist";
+	assist_level_value = int( ceil( damagedone / 25 ) );
+	if ( assist_level_value < 1 )
+	{
+		assist_level_value = 1;
+	}
+	else
+	{
+		if ( assist_level_value > 3 )
+		{
+			assist_level_value = 3;
+		}
+	}
+	assist_level = ( assist_level + "_" ) + ( assist_level_value * 25 );
+	self maps/mp/gametypes_zm/_globallogic_score::incpersstat( "assists", 1, 1, 1 );
+	self.assists = self maps/mp/gametypes_zm/_globallogic_score::getpersstat( "assists" );
+	switch( weapon )
+	{
+		case "concussion_grenade_mp":
+			assist_level = "assist_concussion";
+			break;
+		case "flash_grenade_mp":
+			assist_level = "assist_flash";
+			break;
+		case "emp_grenade_mp":
+			assist_level = "assist_emp";
+			break;
+		case "proximity_grenade_aoe_mp":
+		case "proximity_grenade_mp":
+			assist_level = "assist_proximity";
+			break;
+	}
+	self maps/mp/_challenges::assisted();
+}
+
+xpratethread()
+{
+/#
+#/
+}

patch_zm/maps/mp/gametypes_zm/_globallogic_spawn.gsc

@@ -0,0 +1,959 @@
+#include maps/mp/gametypes_zm/_spawnlogic;
+#include maps/mp/gametypes_zm/_globallogic_defaults;
+#include maps/mp/gametypes_zm/_hostmigration;
+#include maps/mp/gametypes_zm/_spectating;
+#include maps/mp/zombies/_zm_perks;
+#include maps/mp/gametypes_zm/_globallogic_score;
+#include maps/mp/gametypes_zm/_globallogic_ui;
+#include maps/mp/gametypes_zm/_hud_util;
+#include maps/mp/gametypes_zm/_hud_message;
+#include maps/mp/gametypes_zm/_globallogic;
+#include maps/mp/gametypes_zm/_globallogic_utils;
+#include maps/mp/gametypes_zm/_globallogic_audio;
+#include maps/mp/gametypes_zm/_spawning;
+#include maps/mp/gametypes_zm/_globallogic_player;
+#include maps/mp/_utility;
+#include common_scripts/utility;
+
+timeuntilspawn( includeteamkilldelay )
+{
+	if ( level.ingraceperiod && !self.hasspawned )
+	{
+		return 0;
+	}
+	respawndelay = 0;
+	if ( self.hasspawned )
+	{
+		result = self [[ level.onrespawndelay ]]();
+		if ( isDefined( result ) )
+		{
+			respawndelay = result;
+		}
+		else
+		{
+			respawndelay = level.playerrespawndelay;
+		}
+		if ( includeteamkilldelay && isDefined( self.teamkillpunish ) && self.teamkillpunish )
+		{
+			respawndelay += maps/mp/gametypes_zm/_globallogic_player::teamkilldelay();
+		}
+	}
+	wavebased = level.waverespawndelay > 0;
+	if ( wavebased )
+	{
+		return self timeuntilwavespawn( respawndelay );
+	}
+	return respawndelay;
+}
+
+allteamshaveexisted()
+{
+	_a34 = level.teams;
+	_k34 = getFirstArrayKey( _a34 );
+	while ( isDefined( _k34 ) )
+	{
+		team = _a34[ _k34 ];
+		if ( !level.everexisted[ team ] )
+		{
+			return 0;
+		}
+		_k34 = getNextArrayKey( _a34, _k34 );
+	}
+	return 1;
+}
+
+mayspawn()
+{
+	if ( isDefined( level.mayspawn ) && !( self [[ level.mayspawn ]]() ) )
+	{
+		return 0;
+	}
+	if ( level.inovertime )
+	{
+		return 0;
+	}
+	if ( level.playerqueuedrespawn && !isDefined( self.allowqueuespawn ) && !level.ingraceperiod && !level.usestartspawns )
+	{
+		return 0;
+	}
+	if ( level.numlives )
+	{
+		if ( level.teambased )
+		{
+			gamehasstarted = allteamshaveexisted();
+		}
+		else
+		{
+			if ( level.maxplayercount > 1 )
+			{
+				if ( !isoneround() )
+				{
+					gamehasstarted = !isfirstround();
+				}
+			}
+		}
+		if ( !self.pers[ "lives" ] && gamehasstarted )
+		{
+			return 0;
+		}
+		else
+		{
+			if ( gamehasstarted )
+			{
+				if ( !level.ingraceperiod && !self.hasspawned && !level.wagermatch )
+				{
+					return 0;
+				}
+			}
+		}
+	}
+	return 1;
+}
+
+timeuntilwavespawn( minimumwait )
+{
+	earliestspawntime = getTime() + ( minimumwait * 1000 );
+	lastwavetime = level.lastwave[ self.pers[ "team" ] ];
+	wavedelay = level.wavedelay[ self.pers[ "team" ] ] * 1000;
+	if ( wavedelay == 0 )
+	{
+		return 0;
+	}
+	numwavespassedearliestspawntime = ( earliestspawntime - lastwavetime ) / wavedelay;
+	numwaves = ceil( numwavespassedearliestspawntime );
+	timeofspawn = lastwavetime + ( numwaves * wavedelay );
+	if ( isDefined( self.wavespawnindex ) )
+	{
+		timeofspawn += 50 * self.wavespawnindex;
+	}
+	return ( timeofspawn - getTime() ) / 1000;
+}
+
+stoppoisoningandflareonspawn()
+{
+	self endon( "disconnect" );
+	self.inpoisonarea = 0;
+	self.inburnarea = 0;
+	self.inflarevisionarea = 0;
+	self.ingroundnapalm = 0;
+}
+
+spawnplayerprediction()
+{
+	self endon( "disconnect" );
+	self endon( "end_respawn" );
+	self endon( "game_ended" );
+	self endon( "joined_spectators" );
+	self endon( "spawned" );
+	while ( 1 )
+	{
+		wait 0,5;
+		if ( isDefined( level.onspawnplayerunified ) && getDvarInt( #"CF6EEB8B" ) == 0 )
+		{
+			maps/mp/gametypes_zm/_spawning::onspawnplayer_unified( 1 );
+			continue;
+		}
+		else
+		{
+			self [[ level.onspawnplayer ]]( 1 );
+		}
+	}
+}
+
+giveloadoutlevelspecific( team, class )
+{
+	pixbeginevent( "giveLoadoutLevelSpecific" );
+	if ( isDefined( level.givecustomcharacters ) )
+	{
+		self [[ level.givecustomcharacters ]]();
+	}
+	if ( isDefined( level.givecustomloadout ) )
+	{
+		self [[ level.givecustomloadout ]]();
+	}
+	pixendevent();
+}
+
+spawnplayer()
+{
+	pixbeginevent( "spawnPlayer_preUTS" );
+	self endon( "disconnect" );
+	self endon( "joined_spectators" );
+	self notify( "spawned" );
+	level notify( "player_spawned" );
+	self notify( "end_respawn" );
+	self setspawnvariables();
+	if ( !self.hasspawned )
+	{
+		self.underscorechance = 70;
+		self thread maps/mp/gametypes_zm/_globallogic_audio::sndstartmusicsystem();
+	}
+	if ( level.teambased )
+	{
+		self.sessionteam = self.team;
+	}
+	else
+	{
+		self.sessionteam = "none";
+		self.ffateam = self.team;
+	}
+	hadspawned = self.hasspawned;
+	self.sessionstate = "playing";
+	self.spectatorclient = -1;
+	self.killcamentity = -1;
+	self.archivetime = 0;
+	self.psoffsettime = 0;
+	self.statusicon = "";
+	self.damagedplayers = [];
+	if ( getDvarInt( #"C8077F47" ) > 0 )
+	{
+		self.maxhealth = getDvarInt( #"C8077F47" );
+	}
+	else
+	{
+		self.maxhealth = level.playermaxhealth;
+	}
+	self.health = self.maxhealth;
+	self.friendlydamage = undefined;
+	self.hasspawned = 1;
+	self.spawntime = getTime();
+	self.afk = 0;
+	if ( self.pers[ "lives" ] || !isDefined( level.takelivesondeath ) && level.takelivesondeath == 0 )
+	{
+		self.pers[ "lives" ]--;
+
+		if ( self.pers[ "lives" ] == 0 )
+		{
+			level notify( "player_eliminated" );
+			self notify( "player_eliminated" );
+		}
+	}
+	self.laststand = undefined;
+	self.revivingteammate = 0;
+	self.burning = undefined;
+	self.nextkillstreakfree = undefined;
+	self.activeuavs = 0;
+	self.activecounteruavs = 0;
+	self.activesatellites = 0;
+	self.deathmachinekills = 0;
+	self.disabledweapon = 0;
+	self resetusability();
+	self maps/mp/gametypes_zm/_globallogic_player::resetattackerlist();
+	self.diedonvehicle = undefined;
+	if ( !self.wasaliveatmatchstart )
+	{
+		if ( level.ingraceperiod || maps/mp/gametypes_zm/_globallogic_utils::gettimepassed() < 20000 )
+		{
+			self.wasaliveatmatchstart = 1;
+		}
+	}
+	self setdepthoffield( 0, 0, 512, 512, 4, 0 );
+	self resetfov();
+	pixbeginevent( "onSpawnPlayer" );
+	if ( isDefined( level.onspawnplayerunified ) && getDvarInt( #"CF6EEB8B" ) == 0 )
+	{
+		self [[ level.onspawnplayerunified ]]();
+	}
+	else
+	{
+		self [[ level.onspawnplayer ]]( 0 );
+	}
+	if ( isDefined( level.playerspawnedcb ) )
+	{
+		self [[ level.playerspawnedcb ]]();
+	}
+	pixendevent();
+	pixendevent();
+	level thread maps/mp/gametypes_zm/_globallogic::updateteamstatus();
+	pixbeginevent( "spawnPlayer_postUTS" );
+	self thread stoppoisoningandflareonspawn();
+	self stopburning();
+/#
+	assert( maps/mp/gametypes_zm/_globallogic_utils::isvalidclass( self.class ) );
+#/
+	self giveloadoutlevelspecific( self.team, self.class );
+	if ( level.inprematchperiod )
+	{
+		self freeze_player_controls( 1 );
+		team = self.pers[ "team" ];
+		if ( isDefined( self.pers[ "music" ].spawn ) && self.pers[ "music" ].spawn == 0 )
+		{
+			if ( level.wagermatch )
+			{
+				music = "SPAWN_WAGER";
+			}
+			else
+			{
+				music = game[ "music" ][ "spawn_" + team ];
+			}
+			self thread maps/mp/gametypes_zm/_globallogic_audio::set_music_on_player( music, 0, 0 );
+			self.pers[ "music" ].spawn = 1;
+		}
+		if ( level.splitscreen )
+		{
+			if ( isDefined( level.playedstartingmusic ) )
+			{
+				music = undefined;
+			}
+			else
+			{
+				level.playedstartingmusic = 1;
+			}
+		}
+		if ( !isDefined( level.disableprematchmessages ) || level.disableprematchmessages == 0 )
+		{
+			thread maps/mp/gametypes_zm/_hud_message::showinitialfactionpopup( team );
+			hintmessage = getobjectivehinttext( self.pers[ "team" ] );
+			if ( isDefined( hintmessage ) )
+			{
+				self thread maps/mp/gametypes_zm/_hud_message::hintmessage( hintmessage );
+			}
+			if ( isDefined( game[ "dialog" ][ "gametype" ] ) || !level.splitscreen && self == level.players[ 0 ] )
+			{
+				if ( !isDefined( level.infinalfight ) || !level.infinalfight )
+				{
+					if ( level.hardcoremode )
+					{
+						self maps/mp/gametypes_zm/_globallogic_audio::leaderdialogonplayer( "gametype_hardcore" );
+					}
+					else
+					{
+						self maps/mp/gametypes_zm/_globallogic_audio::leaderdialogonplayer( "gametype" );
+					}
+				}
+			}
+			if ( team == game[ "attackers" ] )
+			{
+				self maps/mp/gametypes_zm/_globallogic_audio::leaderdialogonplayer( "offense_obj", "introboost" );
+			}
+			else
+			{
+				self maps/mp/gametypes_zm/_globallogic_audio::leaderdialogonplayer( "defense_obj", "introboost" );
+			}
+		}
+	}
+	else
+	{
+		self freeze_player_controls( 0 );
+		self enableweapons();
+		if ( !hadspawned && game[ "state" ] == "playing" )
+		{
+			pixbeginevent( "sound" );
+			team = self.team;
+			if ( isDefined( self.pers[ "music" ].spawn ) && self.pers[ "music" ].spawn == 0 )
+			{
+				self thread maps/mp/gametypes_zm/_globallogic_audio::set_music_on_player( "SPAWN_SHORT", 0, 0 );
+				self.pers[ "music" ].spawn = 1;
+			}
+			if ( level.splitscreen )
+			{
+				if ( isDefined( level.playedstartingmusic ) )
+				{
+					music = undefined;
+				}
+				else
+				{
+					level.playedstartingmusic = 1;
+				}
+			}
+			if ( !isDefined( level.disableprematchmessages ) || level.disableprematchmessages == 0 )
+			{
+				thread maps/mp/gametypes_zm/_hud_message::showinitialfactionpopup( team );
+				hintmessage = getobjectivehinttext( self.pers[ "team" ] );
+				if ( isDefined( hintmessage ) )
+				{
+					self thread maps/mp/gametypes_zm/_hud_message::hintmessage( hintmessage );
+				}
+				if ( isDefined( game[ "dialog" ][ "gametype" ] ) || !level.splitscreen && self == level.players[ 0 ] )
+				{
+					if ( !isDefined( level.infinalfight ) || !level.infinalfight )
+					{
+						if ( level.hardcoremode )
+						{
+							self maps/mp/gametypes_zm/_globallogic_audio::leaderdialogonplayer( "gametype_hardcore" );
+						}
+						else
+						{
+							self maps/mp/gametypes_zm/_globallogic_audio::leaderdialogonplayer( "gametype" );
+						}
+					}
+				}
+				if ( team == game[ "attackers" ] )
+				{
+					self maps/mp/gametypes_zm/_globallogic_audio::leaderdialogonplayer( "offense_obj", "introboost" );
+				}
+				else
+				{
+					self maps/mp/gametypes_zm/_globallogic_audio::leaderdialogonplayer( "defense_obj", "introboost" );
+				}
+			}
+			pixendevent();
+		}
+	}
+	if ( getDvar( "scr_showperksonspawn" ) == "" )
+	{
+		setdvar( "scr_showperksonspawn", "0" );
+	}
+	if ( level.hardcoremode )
+	{
+		setdvar( "scr_showperksonspawn", "0" );
+	}
+	if ( !level.splitscreen && getDvarInt( "scr_showperksonspawn" ) == 1 && game[ "state" ] != "postgame" )
+	{
+		pixbeginevent( "showperksonspawn" );
+		if ( level.perksenabled == 1 )
+		{
+			self maps/mp/gametypes_zm/_hud_util::showperks();
+		}
+		self thread maps/mp/gametypes_zm/_globallogic_ui::hideloadoutaftertime( 3 );
+		self thread maps/mp/gametypes_zm/_globallogic_ui::hideloadoutondeath();
+		pixendevent();
+	}
+	if ( isDefined( self.pers[ "momentum" ] ) )
+	{
+		self.momentum = self.pers[ "momentum" ];
+	}
+	pixendevent();
+	waittillframeend;
+	self notify( "spawned_player" );
+	self logstring( "S " + self.origin[ 0 ] + " " + self.origin[ 1 ] + " " + self.origin[ 2 ] );
+	setdvar( "scr_selecting_location", "" );
+/#
+	if ( getDvarInt( #"F8D00F60" ) > 0 )
+	{
+		self thread maps/mp/gametypes_zm/_globallogic_score::xpratethread();
+#/
+	}
+	self maps/mp/zombies/_zm_perks::perk_set_max_health_if_jugg( "health_reboot", 1, 0 );
+	if ( game[ "state" ] == "postgame" )
+	{
+/#
+		assert( !level.intermission );
+#/
+		self maps/mp/gametypes_zm/_globallogic_player::freezeplayerforroundend();
+	}
+}
+
+spawnspectator( origin, angles )
+{
+	self notify( "spawned" );
+	self notify( "end_respawn" );
+	in_spawnspectator( origin, angles );
+}
+
+respawn_asspectator( origin, angles )
+{
+	in_spawnspectator( origin, angles );
+}
+
+in_spawnspectator( origin, angles )
+{
+	pixmarker( "BEGIN: in_spawnSpectator" );
+	self setspawnvariables();
+	if ( self.pers[ "team" ] == "spectator" )
+	{
+		self clearlowermessage();
+	}
+	self.sessionstate = "spectator";
+	self.spectatorclient = -1;
+	self.killcamentity = -1;
+	self.archivetime = 0;
+	self.psoffsettime = 0;
+	self.friendlydamage = undefined;
+	if ( self.pers[ "team" ] == "spectator" )
+	{
+		self.statusicon = "";
+	}
+	else
+	{
+		self.statusicon = "hud_status_dead";
+	}
+	maps/mp/gametypes_zm/_spectating::setspectatepermissionsformachine();
+	[[ level.onspawnspectator ]]( origin, angles );
+	if ( level.teambased && !level.splitscreen )
+	{
+		self thread spectatorthirdpersonness();
+	}
+	level thread maps/mp/gametypes_zm/_globallogic::updateteamstatus();
+	pixmarker( "END: in_spawnSpectator" );
+}
+
+spectatorthirdpersonness()
+{
+	self endon( "disconnect" );
+	self endon( "spawned" );
+	self notify( "spectator_thirdperson_thread" );
+	self endon( "spectator_thirdperson_thread" );
+	self.spectatingthirdperson = 0;
+}
+
+forcespawn( time )
+{
+	self endon( "death" );
+	self endon( "disconnect" );
+	self endon( "spawned" );
+	if ( !isDefined( time ) )
+	{
+		time = 60;
+	}
+	wait time;
+	if ( self.hasspawned )
+	{
+		return;
+	}
+	if ( self.pers[ "team" ] == "spectator" )
+	{
+		return;
+	}
+	if ( !maps/mp/gametypes_zm/_globallogic_utils::isvalidclass( self.pers[ "class" ] ) )
+	{
+		self.pers[ "class" ] = "CLASS_CUSTOM1";
+		self.class = self.pers[ "class" ];
+	}
+	self maps/mp/gametypes_zm/_globallogic_ui::closemenus();
+	self thread [[ level.spawnclient ]]();
+}
+
+kickifdontspawn()
+{
+/#
+	if ( getDvarInt( "scr_hostmigrationtest" ) == 1 )
+	{
+		return;
+#/
+	}
+	if ( self ishost() )
+	{
+		return;
+	}
+	self kickifidontspawninternal();
+}
+
+kickifidontspawninternal()
+{
+	self endon( "death" );
+	self endon( "disconnect" );
+	self endon( "spawned" );
+	waittime = 90;
+	if ( getDvar( #"4257CF5C" ) != "" )
+	{
+		waittime = getDvarFloat( #"4257CF5C" );
+	}
+	mintime = 45;
+	if ( getDvar( #"0DF057E0" ) != "" )
+	{
+		mintime = getDvarFloat( #"0DF057E0" );
+	}
+	starttime = getTime();
+	kickwait( waittime );
+	timepassed = ( getTime() - starttime ) / 1000;
+	if ( timepassed < ( waittime - 0,1 ) && timepassed < mintime )
+	{
+		return;
+	}
+	if ( self.hasspawned )
+	{
+		return;
+	}
+	if ( sessionmodeisprivate() )
+	{
+		return;
+	}
+	if ( self.pers[ "team" ] == "spectator" )
+	{
+		return;
+	}
+	kick( self getentitynumber() );
+}
+
+kickwait( waittime )
+{
+	level endon( "game_ended" );
+	maps/mp/gametypes_zm/_hostmigration::waitlongdurationwithhostmigrationpause( waittime );
+}
+
+spawninterroundintermission()
+{
+	self notify( "spawned" );
+	self notify( "end_respawn" );
+	self setspawnvariables();
+	self clearlowermessage();
+	self freeze_player_controls( 0 );
+	self.sessionstate = "spectator";
+	self.spectatorclient = -1;
+	self.killcamentity = -1;
+	self.archivetime = 0;
+	self.psoffsettime = 0;
+	self.friendlydamage = undefined;
+	self maps/mp/gametypes_zm/_globallogic_defaults::default_onspawnintermission();
+	self setorigin( self.origin );
+	self setplayerangles( self.angles );
+	self setdepthoffield( 0, 128, 512, 4000, 6, 1,8 );
+}
+
+spawnintermission( usedefaultcallback )
+{
+	self notify( "spawned" );
+	self notify( "end_respawn" );
+	self endon( "disconnect" );
+	self setspawnvariables();
+	self clearlowermessage();
+	self freeze_player_controls( 0 );
+	if ( level.rankedmatch && waslastround() )
+	{
+		if ( !self.postgamemilestones || self.postgamecontracts && self.postgamepromotion )
+		{
+			if ( self.postgamepromotion )
+			{
+				self playlocalsound( "mus_level_up" );
+			}
+			else if ( self.postgamecontracts )
+			{
+				self playlocalsound( "mus_challenge_complete" );
+			}
+			else
+			{
+				if ( self.postgamemilestones )
+				{
+					self playlocalsound( "mus_contract_complete" );
+				}
+			}
+			self closeingamemenu();
+			self openmenu( game[ "menu_endgameupdate" ] );
+			waittime = 4;
+			while ( waittime )
+			{
+				wait 0,25;
+				waittime -= 0,25;
+				self openmenu( game[ "menu_endgameupdate" ] );
+			}
+			self closemenu();
+		}
+	}
+	self.sessionstate = "intermission";
+	self.spectatorclient = -1;
+	self.killcamentity = -1;
+	self.archivetime = 0;
+	self.psoffsettime = 0;
+	self.friendlydamage = undefined;
+	if ( isDefined( usedefaultcallback ) && usedefaultcallback )
+	{
+		maps/mp/gametypes_zm/_globallogic_defaults::default_onspawnintermission();
+	}
+	else
+	{
+		[[ level.onspawnintermission ]]();
+	}
+	self setdepthoffield( 0, 128, 512, 4000, 6, 1,8 );
+}
+
+spawnqueuedclientonteam( team )
+{
+	player_to_spawn = undefined;
+	i = 0;
+	while ( i < level.deadplayers[ team ].size )
+	{
+		player = level.deadplayers[ team ][ i ];
+		if ( player.waitingtospawn )
+		{
+			i++;
+			continue;
+		}
+		else
+		{
+			player_to_spawn = player;
+			break;
+		}
+		i++;
+	}
+	if ( isDefined( player_to_spawn ) )
+	{
+		player_to_spawn.allowqueuespawn = 1;
+		player_to_spawn maps/mp/gametypes_zm/_globallogic_ui::closemenus();
+		player_to_spawn thread [[ level.spawnclient ]]();
+	}
+}
+
+spawnqueuedclient( dead_player_team, killer )
+{
+	if ( !level.playerqueuedrespawn )
+	{
+		return;
+	}
+	maps/mp/gametypes_zm/_globallogic_utils::waittillslowprocessallowed();
+	spawn_team = undefined;
+	if ( isDefined( killer ) && isDefined( killer.team ) && isDefined( level.teams[ killer.team ] ) )
+	{
+		spawn_team = killer.team;
+	}
+	if ( isDefined( spawn_team ) )
+	{
+		spawnqueuedclientonteam( spawn_team );
+		return;
+	}
+	_a746 = level.teams;
+	_k746 = getFirstArrayKey( _a746 );
+	while ( isDefined( _k746 ) )
+	{
+		team = _a746[ _k746 ];
+		if ( team == dead_player_team )
+		{
+		}
+		else
+		{
+			spawnqueuedclientonteam( team );
+		}
+		_k746 = getNextArrayKey( _a746, _k746 );
+	}
+}
+
+allteamsnearscorelimit()
+{
+	if ( !level.teambased )
+	{
+		return 0;
+	}
+	if ( level.scorelimit <= 1 )
+	{
+		return 0;
+	}
+	_a763 = level.teams;
+	_k763 = getFirstArrayKey( _a763 );
+	while ( isDefined( _k763 ) )
+	{
+		team = _a763[ _k763 ];
+		if ( ( level.scorelimit - 1 ) < game[ "teamScores" ][ team ] )
+		{
+			return 0;
+		}
+		_k763 = getNextArrayKey( _a763, _k763 );
+	}
+	return 1;
+}
+
+shouldshowrespawnmessage()
+{
+	if ( waslastround() )
+	{
+		return 0;
+	}
+	if ( isoneround() )
+	{
+		return 0;
+	}
+	if ( isDefined( level.livesdonotreset ) && level.livesdonotreset )
+	{
+		return 0;
+	}
+	if ( allteamsnearscorelimit() )
+	{
+		return 0;
+	}
+	return 1;
+}
+
+default_spawnmessage()
+{
+	setlowermessage( game[ "strings" ][ "spawn_next_round" ] );
+	self thread maps/mp/gametypes_zm/_globallogic_ui::removespawnmessageshortly( 3 );
+}
+
+showspawnmessage()
+{
+	if ( shouldshowrespawnmessage() )
+	{
+		self thread [[ level.spawnmessage ]]();
+	}
+}
+
+spawnclient( timealreadypassed )
+{
+	pixbeginevent( "spawnClient" );
+/#
+	assert( isDefined( self.team ) );
+#/
+/#
+	assert( maps/mp/gametypes_zm/_globallogic_utils::isvalidclass( self.class ) );
+#/
+	if ( !self mayspawn() )
+	{
+		currentorigin = self.origin;
+		currentangles = self.angles;
+		self showspawnmessage();
+		self thread [[ level.spawnspectator ]]( currentorigin + vectorScale( ( 0, 0, 1 ), 60 ), currentangles );
+		pixendevent();
+		return;
+	}
+	if ( self.waitingtospawn )
+	{
+		pixendevent();
+		return;
+	}
+	self.waitingtospawn = 1;
+	self.allowqueuespawn = undefined;
+	self waitandspawnclient( timealreadypassed );
+	if ( isDefined( self ) )
+	{
+		self.waitingtospawn = 0;
+	}
+	pixendevent();
+}
+
+waitandspawnclient( timealreadypassed )
+{
+	self endon( "disconnect" );
+	self endon( "end_respawn" );
+	level endon( "game_ended" );
+	if ( !isDefined( timealreadypassed ) )
+	{
+		timealreadypassed = 0;
+	}
+	spawnedasspectator = 0;
+	if ( isDefined( self.teamkillpunish ) && self.teamkillpunish )
+	{
+		teamkilldelay = maps/mp/gametypes_zm/_globallogic_player::teamkilldelay();
+		if ( teamkilldelay > timealreadypassed )
+		{
+			teamkilldelay -= timealreadypassed;
+			timealreadypassed = 0;
+		}
+		else
+		{
+			timealreadypassed -= teamkilldelay;
+			teamkilldelay = 0;
+		}
+		if ( teamkilldelay > 0 )
+		{
+			setlowermessage( &"MP_FRIENDLY_FIRE_WILL_NOT", teamkilldelay );
+			self thread respawn_asspectator( self.origin + vectorScale( ( 0, 0, 1 ), 60 ), self.angles );
+			spawnedasspectator = 1;
+			wait teamkilldelay;
+		}
+		self.teamkillpunish = 0;
+	}
+	if ( !isDefined( self.wavespawnindex ) && isDefined( level.waveplayerspawnindex[ self.team ] ) )
+	{
+		self.wavespawnindex = level.waveplayerspawnindex[ self.team ];
+		level.waveplayerspawnindex[ self.team ]++;
+	}
+	timeuntilspawn = timeuntilspawn( 0 );
+	if ( timeuntilspawn > timealreadypassed )
+	{
+		timeuntilspawn -= timealreadypassed;
+		timealreadypassed = 0;
+	}
+	else
+	{
+		timealreadypassed -= timeuntilspawn;
+		timeuntilspawn = 0;
+	}
+	if ( timeuntilspawn > 0 )
+	{
+		if ( level.playerqueuedrespawn )
+		{
+			setlowermessage( game[ "strings" ][ "you_will_spawn" ], timeuntilspawn );
+		}
+		else if ( self issplitscreen() )
+		{
+			setlowermessage( game[ "strings" ][ "waiting_to_spawn_ss" ], timeuntilspawn, 1 );
+		}
+		else
+		{
+			setlowermessage( game[ "strings" ][ "waiting_to_spawn" ], timeuntilspawn );
+		}
+		if ( !spawnedasspectator )
+		{
+			spawnorigin = self.origin + vectorScale( ( 0, 0, 1 ), 60 );
+			spawnangles = self.angles;
+			if ( isDefined( level.useintermissionpointsonwavespawn ) && [[ level.useintermissionpointsonwavespawn ]]() == 1 )
+			{
+				spawnpoint = maps/mp/gametypes_zm/_spawnlogic::getrandomintermissionpoint();
+				if ( isDefined( spawnpoint ) )
+				{
+					spawnorigin = spawnpoint.origin;
+					spawnangles = spawnpoint.angles;
+				}
+			}
+			self thread respawn_asspectator( spawnorigin, spawnangles );
+		}
+		spawnedasspectator = 1;
+		self maps/mp/gametypes_zm/_globallogic_utils::waitfortimeornotify( timeuntilspawn, "force_spawn" );
+		self notify( "stop_wait_safe_spawn_button" );
+	}
+	wavebased = level.waverespawndelay > 0;
+	if ( !level.playerforcerespawn && self.hasspawned && !wavebased && !self.wantsafespawn && !level.playerqueuedrespawn )
+	{
+		setlowermessage( game[ "strings" ][ "press_to_spawn" ] );
+		if ( !spawnedasspectator )
+		{
+			self thread respawn_asspectator( self.origin + vectorScale( ( 0, 0, 1 ), 60 ), self.angles );
+		}
+		spawnedasspectator = 1;
+		self waitrespawnorsafespawnbutton();
+	}
+	self.waitingtospawn = 0;
+	self clearlowermessage();
+	self.wavespawnindex = undefined;
+	self.respawntimerstarttime = undefined;
+	self thread [[ level.spawnplayer ]]();
+}
+
+waitrespawnorsafespawnbutton()
+{
+	self endon( "disconnect" );
+	self endon( "end_respawn" );
+	while ( 1 )
+	{
+		if ( self usebuttonpressed() )
+		{
+			return;
+		}
+		else
+		{
+			wait 0,05;
+		}
+	}
+}
+
+waitinspawnqueue()
+{
+	self endon( "disconnect" );
+	self endon( "end_respawn" );
+	if ( !level.ingraceperiod && !level.usestartspawns )
+	{
+		currentorigin = self.origin;
+		currentangles = self.angles;
+		self thread [[ level.spawnspectator ]]( currentorigin + vectorScale( ( 0, 0, 1 ), 60 ), currentangles );
+		self waittill( "queue_respawn" );
+	}
+}
+
+setthirdperson( value )
+{
+	if ( !level.console )
+	{
+		return;
+	}
+	if ( !isDefined( self.spectatingthirdperson ) || value != self.spectatingthirdperson )
+	{
+		self.spectatingthirdperson = value;
+		if ( value )
+		{
+			self setclientthirdperson( 1 );
+			self setdepthoffield( 0, 128, 512, 4000, 6, 1,8 );
+		}
+		else
+		{
+			self setclientthirdperson( 0 );
+			self setdepthoffield( 0, 0, 512, 4000, 4, 0 );
+		}
+		self resetfov();
+	}
+}
+
+setspawnvariables()
+{
+	resettimeout();
+	self stopshellshock();
+	self stoprumble( "damage_heavy" );
+}

patch_zm/maps/mp/gametypes_zm/_globallogic_ui.gsc

@@ -0,0 +1,544 @@
+#include maps/mp/gametypes_zm/_globallogic_player;
+#include maps/mp/gametypes_zm/_spectating;
+#include maps/mp/gametypes_zm/_globallogic;
+#include maps/mp/gametypes_zm/_hud_util;
+#include maps/mp/_utility;
+
+init()
+{
+	precachestring( &"MP_HALFTIME" );
+	precachestring( &"MP_OVERTIME" );
+	precachestring( &"MP_ROUNDEND" );
+	precachestring( &"MP_INTERMISSION" );
+	precachestring( &"MP_SWITCHING_SIDES_CAPS" );
+	precachestring( &"MP_FRIENDLY_FIRE_WILL_NOT" );
+	precachestring( &"MP_RAMPAGE" );
+	precachestring( &"medal_received" );
+	precachestring( &"killstreak_received" );
+	precachestring( &"prox_grenade_notify" );
+	precachestring( &"player_callout" );
+	precachestring( &"score_event" );
+	precachestring( &"rank_up" );
+	precachestring( &"gun_level_complete" );
+	precachestring( &"challenge_complete" );
+	if ( sessionmodeiszombiesgame() )
+	{
+		precachestring( &"hud_update_survival_team" );
+	}
+	if ( level.splitscreen )
+	{
+		precachestring( &"MP_ENDED_GAME" );
+	}
+	else
+	{
+		precachestring( &"MP_HOST_ENDED_GAME" );
+	}
+}
+
+setupcallbacks()
+{
+	level.autoassign = ::menuautoassign;
+	level.spectator = ::menuspectator;
+	level.class = ::menuclass;
+	level.teammenu = ::menuteam;
+}
+
+hideloadoutaftertime( delay )
+{
+	self endon( "disconnect" );
+	self endon( "perks_hidden" );
+	wait delay;
+	self thread hideallperks( 0,4 );
+	self notify( "perks_hidden" );
+}
+
+hideloadoutondeath()
+{
+	self endon( "disconnect" );
+	self endon( "perks_hidden" );
+	self waittill( "death" );
+	self hideallperks();
+	self notify( "perks_hidden" );
+}
+
+hideloadoutonkill()
+{
+	self endon( "disconnect" );
+	self endon( "death" );
+	self endon( "perks_hidden" );
+	self waittill( "killed_player" );
+	self hideallperks();
+	self notify( "perks_hidden" );
+}
+
+freegameplayhudelems()
+{
+	while ( isDefined( self.perkicon ) )
+	{
+		numspecialties = 0;
+		while ( numspecialties < level.maxspecialties )
+		{
+			if ( isDefined( self.perkicon[ numspecialties ] ) )
+			{
+				self.perkicon[ numspecialties ] destroyelem();
+				self.perkname[ numspecialties ] destroyelem();
+			}
+			numspecialties++;
+		}
+	}
+	if ( isDefined( self.perkhudelem ) )
+	{
+		self.perkhudelem destroyelem();
+	}
+	if ( isDefined( self.killstreakicon ) )
+	{
+		if ( isDefined( self.killstreakicon[ 0 ] ) )
+		{
+			self.killstreakicon[ 0 ] destroyelem();
+		}
+		if ( isDefined( self.killstreakicon[ 1 ] ) )
+		{
+			self.killstreakicon[ 1 ] destroyelem();
+		}
+		if ( isDefined( self.killstreakicon[ 2 ] ) )
+		{
+			self.killstreakicon[ 2 ] destroyelem();
+		}
+		if ( isDefined( self.killstreakicon[ 3 ] ) )
+		{
+			self.killstreakicon[ 3 ] destroyelem();
+		}
+		if ( isDefined( self.killstreakicon[ 4 ] ) )
+		{
+			self.killstreakicon[ 4 ] destroyelem();
+		}
+	}
+	self notify( "perks_hidden" );
+	if ( isDefined( self.lowermessage ) )
+	{
+		self.lowermessage destroyelem();
+	}
+	if ( isDefined( self.lowertimer ) )
+	{
+		self.lowertimer destroyelem();
+	}
+	if ( isDefined( self.proxbar ) )
+	{
+		self.proxbar destroyelem();
+	}
+	if ( isDefined( self.proxbartext ) )
+	{
+		self.proxbartext destroyelem();
+	}
+	if ( isDefined( self.carryicon ) )
+	{
+		self.carryicon destroyelem();
+	}
+}
+
+teamplayercountsequal( playercounts )
+{
+	count = undefined;
+	_a150 = level.teams;
+	_k150 = getFirstArrayKey( _a150 );
+	while ( isDefined( _k150 ) )
+	{
+		team = _a150[ _k150 ];
+		if ( !isDefined( count ) )
+		{
+			count = playercounts[ team ];
+		}
+		else
+		{
+			if ( count != playercounts[ team ] )
+			{
+				return 0;
+			}
+		}
+		_k150 = getNextArrayKey( _a150, _k150 );
+	}
+	return 1;
+}
+
+teamwithlowestplayercount( playercounts, ignore_team )
+{
+	count = 9999;
+	lowest_team = undefined;
+	_a169 = level.teams;
+	_k169 = getFirstArrayKey( _a169 );
+	while ( isDefined( _k169 ) )
+	{
+		team = _a169[ _k169 ];
+		if ( count > playercounts[ team ] )
+		{
+			count = playercounts[ team ];
+			lowest_team = team;
+		}
+		_k169 = getNextArrayKey( _a169, _k169 );
+	}
+	return lowest_team;
+}
+
+menuautoassign( comingfrommenu )
+{
+	teamkeys = getarraykeys( level.teams );
+	assignment = teamkeys[ randomint( teamkeys.size ) ];
+	self closemenus();
+	if ( isDefined( level.forceallallies ) && level.forceallallies )
+	{
+		assignment = "allies";
+	}
+	else
+	{
+		if ( level.teambased )
+		{
+			if ( getDvarInt( "party_autoteams" ) == 1 )
+			{
+				if ( level.allow_teamchange == "1" || self.hasspawned && comingfrommenu )
+				{
+					assignment = "";
+					break;
+			}
+			else
+			{
+				team = getassignedteam( self );
+				switch( team )
+				{
+					case 1:
+						assignment = teamkeys[ 1 ];
+						break;
+					case 2:
+						assignment = teamkeys[ 0 ];
+						break;
+					case 3:
+						assignment = teamkeys[ 2 ];
+						break;
+					case 4:
+						if ( !isDefined( level.forceautoassign ) || !level.forceautoassign )
+						{
+							self setclientscriptmainmenu( game[ "menu_class" ] );
+							return;
+						}
+						default:
+							assignment = "";
+							if ( isDefined( level.teams[ team ] ) )
+							{
+								assignment = team;
+							}
+							else
+							{
+								if ( team == "spectator" && !level.forceautoassign )
+								{
+									self setclientscriptmainmenu( game[ "menu_class" ] );
+									return;
+								}
+							}
+					}
+				}
+			}
+			if ( assignment == "" || getDvarInt( "party_autoteams" ) == 0 )
+			{
+				if ( sessionmodeiszombiesgame() )
+				{
+					assignment = "allies";
+				}
+			}
+			if ( assignment == self.pers[ "team" ] || self.sessionstate == "playing" && self.sessionstate == "dead" )
+			{
+				self beginclasschoice();
+				return;
+			}
+		}
+		else if ( getDvarInt( "party_autoteams" ) == 1 )
+		{
+			if ( level.allow_teamchange != "1" || !self.hasspawned && !comingfrommenu )
+			{
+				team = getassignedteam( self );
+				if ( isDefined( level.teams[ team ] ) )
+				{
+					assignment = team;
+				}
+				else
+				{
+					if ( team == "spectator" && !level.forceautoassign )
+					{
+						self setclientscriptmainmenu( game[ "menu_class" ] );
+						return;
+					}
+				}
+			}
+		}
+	}
+	if ( assignment != self.pers[ "team" ] || self.sessionstate == "playing" && self.sessionstate == "dead" )
+	{
+		self.switching_teams = 1;
+		self.joining_team = assignment;
+		self.leaving_team = self.pers[ "team" ];
+		self suicide();
+	}
+	self.pers[ "team" ] = assignment;
+	self.team = assignment;
+	self.class = undefined;
+	self updateobjectivetext();
+	if ( level.teambased )
+	{
+		self.sessionteam = assignment;
+	}
+	else
+	{
+		self.sessionteam = "none";
+		self.ffateam = assignment;
+	}
+	if ( !isalive( self ) )
+	{
+		self.statusicon = "hud_status_dead";
+	}
+	self notify( "joined_team" );
+	level notify( "joined_team" );
+	self notify( "end_respawn" );
+	self beginclasschoice();
+	self setclientscriptmainmenu( game[ "menu_class" ] );
+}
+
+teamscoresequal()
+{
+	score = undefined;
+	_a413 = level.teams;
+	_k413 = getFirstArrayKey( _a413 );
+	while ( isDefined( _k413 ) )
+	{
+		team = _a413[ _k413 ];
+		if ( !isDefined( score ) )
+		{
+			score = getteamscore( team );
+		}
+		else
+		{
+			if ( score != getteamscore( team ) )
+			{
+				return 0;
+			}
+		}
+		_k413 = getNextArrayKey( _a413, _k413 );
+	}
+	return 1;
+}
+
+teamwithlowestscore()
+{
+	score = 99999999;
+	lowest_team = undefined;
+	_a432 = level.teams;
+	_k432 = getFirstArrayKey( _a432 );
+	while ( isDefined( _k432 ) )
+	{
+		team = _a432[ _k432 ];
+		if ( score > getteamscore( team ) )
+		{
+			lowest_team = team;
+		}
+		_k432 = getNextArrayKey( _a432, _k432 );
+	}
+	return lowest_team;
+}
+
+pickteamfromscores( teams )
+{
+	assignment = "allies";
+	if ( teamscoresequal() )
+	{
+		assignment = teams[ randomint( teams.size ) ];
+	}
+	else
+	{
+		assignment = teamwithlowestscore();
+	}
+	return assignment;
+}
+
+getsplitscreenteam()
+{
+	index = 0;
+	while ( index < level.players.size )
+	{
+		if ( !isDefined( level.players[ index ] ) )
+		{
+			index++;
+			continue;
+		}
+		else if ( level.players[ index ] == self )
+		{
+			index++;
+			continue;
+		}
+		else if ( !self isplayeronsamemachine( level.players[ index ] ) )
+		{
+			index++;
+			continue;
+		}
+		else
+		{
+			team = level.players[ index ].sessionteam;
+			if ( team != "spectator" )
+			{
+				return team;
+			}
+		}
+		index++;
+	}
+	return "";
+}
+
+updateobjectivetext()
+{
+	if ( sessionmodeiszombiesgame() || self.pers[ "team" ] == "spectator" )
+	{
+		self setclientcgobjectivetext( "" );
+		return;
+	}
+	if ( level.scorelimit > 0 )
+	{
+		self setclientcgobjectivetext( getobjectivescoretext( self.pers[ "team" ] ) );
+	}
+	else
+	{
+		self setclientcgobjectivetext( getobjectivetext( self.pers[ "team" ] ) );
+	}
+}
+
+closemenus()
+{
+	self closemenu();
+	self closeingamemenu();
+}
+
+beginclasschoice( forcenewchoice )
+{
+/#
+	assert( isDefined( level.teams[ self.pers[ "team" ] ] ) );
+#/
+	team = self.pers[ "team" ];
+	if ( level.disablecac == 1 )
+	{
+		self.pers[ "class" ] = level.defaultclass;
+		self.class = level.defaultclass;
+		if ( self.sessionstate != "playing" && game[ "state" ] == "playing" )
+		{
+			self thread [[ level.spawnclient ]]();
+		}
+		level thread maps/mp/gametypes_zm/_globallogic::updateteamstatus();
+		self thread maps/mp/gametypes_zm/_spectating::setspectatepermissionsformachine();
+		return;
+	}
+	if ( level.wagermatch )
+	{
+		self openmenu( game[ "menu_changeclass_wager" ] );
+	}
+	else if ( getDvarInt( "barebones_class_mode" ) )
+	{
+		self openmenu( game[ "menu_changeclass_barebones" ] );
+	}
+	else
+	{
+		self openmenu( game[ "menu_changeclass_" + team ] );
+	}
+}
+
+showmainmenuforteam()
+{
+/#
+	assert( isDefined( level.teams[ self.pers[ "team" ] ] ) );
+#/
+	team = self.pers[ "team" ];
+	if ( level.wagermatch )
+	{
+		self openmenu( game[ "menu_changeclass_wager" ] );
+	}
+	else
+	{
+		self openmenu( game[ "menu_changeclass_" + team ] );
+	}
+}
+
+menuteam( team )
+{
+	self closemenus();
+	if ( !level.console && level.allow_teamchange == "0" && isDefined( self.hasdonecombat ) && self.hasdonecombat )
+	{
+		return;
+	}
+	if ( self.pers[ "team" ] != team )
+	{
+		if ( level.ingraceperiod || !isDefined( self.hasdonecombat ) && !self.hasdonecombat )
+		{
+			self.hasspawned = 0;
+		}
+		if ( self.sessionstate == "playing" )
+		{
+			self.switching_teams = 1;
+			self.joining_team = team;
+			self.leaving_team = self.pers[ "team" ];
+			self suicide();
+		}
+		self.pers[ "team" ] = team;
+		self.team = team;
+		self.class = undefined;
+		self updateobjectivetext();
+		if ( level.teambased )
+		{
+			self.sessionteam = team;
+		}
+		else
+		{
+			self.sessionteam = "none";
+			self.ffateam = team;
+		}
+		self setclientscriptmainmenu( game[ "menu_class" ] );
+		self notify( "joined_team" );
+		level notify( "joined_team" );
+		self notify( "end_respawn" );
+	}
+	self beginclasschoice();
+}
+
+menuspectator()
+{
+	self closemenus();
+	if ( self.pers[ "team" ] != "spectator" )
+	{
+		if ( isalive( self ) )
+		{
+			self.switching_teams = 1;
+			self.joining_team = "spectator";
+			self.leaving_team = self.pers[ "team" ];
+			self suicide();
+		}
+		self.pers[ "team" ] = "spectator";
+		self.team = "spectator";
+		self.class = undefined;
+		self updateobjectivetext();
+		self.sessionteam = "spectator";
+		if ( !level.teambased )
+		{
+			self.ffateam = "spectator";
+		}
+		[[ level.spawnspectator ]]();
+		self thread maps/mp/gametypes_zm/_globallogic_player::spectate_player_watcher();
+		self setclientscriptmainmenu( game[ "menu_class" ] );
+		self notify( "joined_spectators" );
+	}
+}
+
+menuclass( response )
+{
+	self closemenus();
+}
+
+removespawnmessageshortly( delay )
+{
+	self endon( "disconnect" );
+	waittillframeend;
+	self endon( "end_respawn" );
+	wait delay;
+	self clearlowermessage( 2 );
+}

patch_zm/maps/mp/gametypes_zm/_globallogic_utils.gsc

@@ -0,0 +1,478 @@
+#include maps/mp/gametypes_zm/_globallogic_score;
+#include maps/mp/gametypes_zm/_hostmigration;
+#include maps/mp/gametypes_zm/_hud_message;
+#include maps/mp/_utility;
+
+waittillslowprocessallowed()
+{
+	while ( level.lastslowprocessframe == getTime() )
+	{
+		wait 0,05;
+	}
+	level.lastslowprocessframe = getTime();
+}
+
+testmenu()
+{
+	self endon( "death" );
+	self endon( "disconnect" );
+	for ( ;; )
+	{
+		wait 10;
+		notifydata = spawnstruct();
+		notifydata.titletext = &"MP_CHALLENGE_COMPLETED";
+		notifydata.notifytext = "wheee";
+		notifydata.sound = "mp_challenge_complete";
+		self thread maps/mp/gametypes_zm/_hud_message::notifymessage( notifydata );
+	}
+}
+
+testshock()
+{
+	self endon( "death" );
+	self endon( "disconnect" );
+	for ( ;; )
+	{
+		wait 3;
+		numshots = randomint( 6 );
+		i = 0;
+		while ( i < numshots )
+		{
+			iprintlnbold( numshots );
+			self shellshock( "frag_grenade_mp", 0,2 );
+			wait 0,1;
+			i++;
+		}
+	}
+}
+
+testhps()
+{
+	self endon( "death" );
+	self endon( "disconnect" );
+	hps = [];
+	hps[ hps.size ] = "radar_mp";
+	hps[ hps.size ] = "artillery_mp";
+	hps[ hps.size ] = "dogs_mp";
+	for ( ;; )
+	{
+		hp = "radar_mp";
+		wait 20;
+	}
+}
+
+timeuntilroundend()
+{
+	if ( level.gameended )
+	{
+		timepassed = ( getTime() - level.gameendtime ) / 1000;
+		timeremaining = level.postroundtime - timepassed;
+		if ( timeremaining < 0 )
+		{
+			return 0;
+		}
+		return timeremaining;
+	}
+	if ( level.inovertime )
+	{
+		return undefined;
+	}
+	if ( level.timelimit <= 0 )
+	{
+		return undefined;
+	}
+	if ( !isDefined( level.starttime ) )
+	{
+		return undefined;
+	}
+	timepassed = ( gettimepassed() - level.starttime ) / 1000;
+	timeremaining = ( level.timelimit * 60 ) - timepassed;
+	return timeremaining + level.postroundtime;
+}
+
+gettimeremaining()
+{
+	return ( ( level.timelimit * 60 ) * 1000 ) - gettimepassed();
+}
+
+registerpostroundevent( eventfunc )
+{
+	if ( !isDefined( level.postroundevents ) )
+	{
+		level.postroundevents = [];
+	}
+	level.postroundevents[ level.postroundevents.size ] = eventfunc;
+}
+
+executepostroundevents()
+{
+	if ( !isDefined( level.postroundevents ) )
+	{
+		return;
+	}
+	i = 0;
+	while ( i < level.postroundevents.size )
+	{
+		[[ level.postroundevents[ i ] ]]();
+		i++;
+	}
+}
+
+getvalueinrange( value, minvalue, maxvalue )
+{
+	if ( value > maxvalue )
+	{
+		return maxvalue;
+	}
+	else
+	{
+		if ( value < minvalue )
+		{
+			return minvalue;
+		}
+		else
+		{
+			return value;
+		}
+	}
+}
+
+assertproperplacement()
+{
+/#
+	numplayers = level.placement[ "all" ].size;
+	i = 0;
+	while ( i < ( numplayers - 1 ) )
+	{
+		if ( isDefined( level.placement[ "all" ][ i ] ) && isDefined( level.placement[ "all" ][ i + 1 ] ) )
+		{
+			if ( level.placement[ "all" ][ i ].score < level.placement[ "all" ][ i + 1 ].score )
+			{
+				println( "^1Placement array:" );
+				i = 0;
+				while ( i < numplayers )
+				{
+					player = level.placement[ "all" ][ i ];
+					println( "^1" + i + ". " + player.name + ": " + player.score );
+					i++;
+				}
+				assertmsg( "Placement array was not properly sorted" );
+				return;
+			}
+		}
+		else
+		{
+			i++;
+#/
+		}
+	}
+}
+
+isvalidclass( class )
+{
+	if ( level.oldschool || sessionmodeiszombiesgame() )
+	{
+/#
+		assert( !isDefined( class ) );
+#/
+		return 1;
+	}
+	if ( isDefined( class ) )
+	{
+		return class != "";
+	}
+}
+
+playtickingsound( gametype_tick_sound )
+{
+	self endon( "death" );
+	self endon( "stop_ticking" );
+	level endon( "game_ended" );
+	time = level.bombtimer;
+	while ( 1 )
+	{
+		self playsound( gametype_tick_sound );
+		if ( time > 10 )
+		{
+			time -= 1;
+			wait 1;
+		}
+		else if ( time > 4 )
+		{
+			time -= 0,5;
+			wait 0,5;
+		}
+		else if ( time > 1 )
+		{
+			time -= 0,4;
+			wait 0,4;
+		}
+		else
+		{
+			time -= 0,3;
+			wait 0,3;
+		}
+		maps/mp/gametypes_zm/_hostmigration::waittillhostmigrationdone();
+	}
+}
+
+stoptickingsound()
+{
+	self notify( "stop_ticking" );
+}
+
+gametimer()
+{
+	level endon( "game_ended" );
+	level waittill( "prematch_over" );
+	level.starttime = getTime();
+	level.discardtime = 0;
+	if ( isDefined( game[ "roundMillisecondsAlreadyPassed" ] ) )
+	{
+		level.starttime -= game[ "roundMillisecondsAlreadyPassed" ];
+	}
+	prevtime = getTime();
+	while ( game[ "state" ] == "playing" )
+	{
+		if ( !level.timerstopped )
+		{
+			game[ "timepassed" ] += getTime() - prevtime;
+		}
+		prevtime = getTime();
+		wait 1;
+	}
+}
+
+gettimepassed()
+{
+	if ( !isDefined( level.starttime ) )
+	{
+		return 0;
+	}
+	if ( level.timerstopped )
+	{
+		return level.timerpausetime - level.starttime - level.discardtime;
+	}
+	else
+	{
+		return getTime() - level.starttime - level.discardtime;
+	}
+}
+
+pausetimer()
+{
+	if ( level.timerstopped )
+	{
+		return;
+	}
+	level.timerstopped = 1;
+	level.timerpausetime = getTime();
+}
+
+resumetimer()
+{
+	if ( !level.timerstopped )
+	{
+		return;
+	}
+	level.timerstopped = 0;
+	level.discardtime += getTime() - level.timerpausetime;
+}
+
+getscoreremaining( team )
+{
+/#
+	if ( !isplayer( self ) )
+	{
+		assert( isDefined( team ) );
+	}
+#/
+	scorelimit = level.scorelimit;
+	if ( isplayer( self ) )
+	{
+		return scorelimit - maps/mp/gametypes_zm/_globallogic_score::_getplayerscore( self );
+	}
+	else
+	{
+		return scorelimit - getteamscore( team );
+	}
+}
+
+getscoreperminute( team )
+{
+/#
+	if ( !isplayer( self ) )
+	{
+		assert( isDefined( team ) );
+	}
+#/
+	scorelimit = level.scorelimit;
+	timelimit = level.timelimit;
+	minutespassed = ( gettimepassed() / 60000 ) + 0,0001;
+	if ( isplayer( self ) )
+	{
+		return maps/mp/gametypes_zm/_globallogic_score::_getplayerscore( self ) / minutespassed;
+	}
+	else
+	{
+		return getteamscore( team ) / minutespassed;
+	}
+}
+
+getestimatedtimeuntilscorelimit( team )
+{
+/#
+	if ( !isplayer( self ) )
+	{
+		assert( isDefined( team ) );
+	}
+#/
+	scoreperminute = self getscoreperminute( team );
+	scoreremaining = self getscoreremaining( team );
+	if ( !scoreperminute )
+	{
+		return 999999;
+	}
+	return scoreremaining / scoreperminute;
+}
+
+rumbler()
+{
+	self endon( "disconnect" );
+	while ( 1 )
+	{
+		wait 0,1;
+		self playrumbleonentity( "damage_heavy" );
+	}
+}
+
+waitfortimeornotify( time, notifyname )
+{
+	self endon( notifyname );
+	wait time;
+}
+
+waitfortimeornotifynoartillery( time, notifyname )
+{
+	self endon( notifyname );
+	wait time;
+	while ( isDefined( level.artilleryinprogress ) )
+	{
+/#
+		assert( level.artilleryinprogress );
+#/
+		wait 0,25;
+	}
+}
+
+isheadshot( sweapon, shitloc, smeansofdeath, einflictor )
+{
+	if ( shitloc != "head" && shitloc != "helmet" )
+	{
+		return 0;
+	}
+	switch( smeansofdeath )
+	{
+		case "MOD_BAYONET":
+		case "MOD_MELEE":
+			return 0;
+		case "MOD_IMPACT":
+			if ( sweapon != "knife_ballistic_mp" )
+			{
+				return 0;
+			}
+	}
+	return 1;
+}
+
+gethitlocheight( shitloc )
+{
+	switch( shitloc )
+	{
+		case "head":
+		case "helmet":
+		case "neck":
+			return 60;
+		case "gun":
+		case "left_arm_lower":
+		case "left_arm_upper":
+		case "left_hand":
+		case "right_arm_lower":
+		case "right_arm_upper":
+		case "right_hand":
+		case "torso_upper":
+			return 48;
+		case "torso_lower":
+			return 40;
+		case "left_leg_upper":
+		case "right_leg_upper":
+			return 32;
+		case "left_leg_lower":
+		case "right_leg_lower":
+			return 10;
+		case "left_foot":
+		case "right_foot":
+			return 5;
+	}
+	return 48;
+}
+
+debugline( start, end )
+{
+/#
+	i = 0;
+	while ( i < 50 )
+	{
+		line( start, end );
+		wait 0,05;
+		i++;
+#/
+	}
+}
+
+isexcluded( entity, entitylist )
+{
+	index = 0;
+	while ( index < entitylist.size )
+	{
+		if ( entity == entitylist[ index ] )
+		{
+			return 1;
+		}
+		index++;
+	}
+	return 0;
+}
+
+waitfortimeornotifies( desireddelay )
+{
+	startedwaiting = getTime();
+	waitedtime = ( getTime() - startedwaiting ) / 1000;
+	if ( waitedtime < desireddelay )
+	{
+		wait ( desireddelay - waitedtime );
+		return desireddelay;
+	}
+	else
+	{
+		return waitedtime;
+	}
+}
+
+logteamwinstring( wintype, winner )
+{
+	log_string = wintype;
+	if ( isDefined( winner ) )
+	{
+		log_string = ( log_string + ", win: " ) + winner;
+	}
+	_a469 = level.teams;
+	_k469 = getFirstArrayKey( _a469 );
+	while ( isDefined( _k469 ) )
+	{
+		team = _a469[ _k469 ];
+		log_string = ( log_string + ", " ) + team + ": " + game[ "teamScores" ][ team ];
+		_k469 = getNextArrayKey( _a469, _k469 );
+	}
+	logstring( log_string );
+}

patch_zm/maps/mp/gametypes_zm/_globallogic_vehicle.gsc

@@ -0,0 +1,471 @@
+#include maps/mp/gametypes_zm/_damagefeedback;
+#include maps/mp/gametypes_zm/_globallogic_player;
+#include maps/mp/gametypes_zm/_weapons;
+#include maps/mp/_utility;
+
+callback_vehicledamage( einflictor, eattacker, idamage, idflags, smeansofdeath, sweapon, vpoint, vdir, shitloc, psoffsettime, damagefromunderneath, modelindex, partname )
+{
+	self.idflags = idflags;
+	self.idflagstime = getTime();
+	if ( game[ "state" ] == "postgame" )
+	{
+		return;
+	}
+	if ( isDefined( eattacker ) && isplayer( eattacker ) && isDefined( eattacker.candocombat ) && !eattacker.candocombat )
+	{
+		return;
+	}
+	if ( !isDefined( vdir ) )
+	{
+		idflags |= level.idflags_no_knockback;
+	}
+	friendly = 0;
+	if ( isDefined( self.maxhealth ) || self.health == self.maxhealth && !isDefined( self.attackers ) )
+	{
+		self.attackers = [];
+		self.attackerdata = [];
+		self.attackerdamage = [];
+	}
+	if ( sweapon == "none" && isDefined( einflictor ) )
+	{
+		if ( isDefined( einflictor.targetname ) && einflictor.targetname == "explodable_barrel" )
+		{
+			sweapon = "explodable_barrel_mp";
+		}
+		else
+		{
+			if ( isDefined( einflictor.destructible_type ) && issubstr( einflictor.destructible_type, "vehicle_" ) )
+			{
+				sweapon = "destructible_car_mp";
+			}
+		}
+	}
+	if ( idflags & level.idflags_no_protection )
+	{
+		if ( self isvehicleimmunetodamage( idflags, smeansofdeath, sweapon ) )
+		{
+			return;
+		}
+		if ( smeansofdeath == "MOD_PISTOL_BULLET" || smeansofdeath == "MOD_RIFLE_BULLET" )
+		{
+		}
+		else
+		{
+			if ( smeansofdeath == "MOD_PROJECTILE" || smeansofdeath == "MOD_GRENADE" )
+			{
+				idamage *= getvehicleprojectilescalar( sweapon );
+				idamage = int( idamage );
+				if ( idamage == 0 )
+				{
+					return;
+				}
+			}
+			else
+			{
+				if ( smeansofdeath == "MOD_GRENADE_SPLASH" )
+				{
+					idamage *= getvehicleunderneathsplashscalar( sweapon );
+					idamage = int( idamage );
+					if ( idamage == 0 )
+					{
+						return;
+					}
+				}
+			}
+		}
+		idamage *= level.vehicledamagescalar;
+		idamage = int( idamage );
+		if ( isplayer( eattacker ) )
+		{
+			eattacker.pers[ "participation" ]++;
+		}
+		prevhealthratio = self.health / self.maxhealth;
+		if ( isDefined( self.owner ) && isplayer( self.owner ) )
+		{
+			team = self.owner.pers[ "team" ];
+		}
+		if ( level.teambased && isplayer( eattacker ) && team == eattacker.pers[ "team" ] )
+		{
+			if ( level.friendlyfire == 0 )
+			{
+				if ( !allowfriendlyfiredamage( einflictor, eattacker, smeansofdeath, sweapon ) )
+				{
+					return;
+				}
+				if ( idamage < 1 )
+				{
+					idamage = 1;
+				}
+				self.lastdamagewasfromenemy = 0;
+				self finishvehicledamage( einflictor, eattacker, idamage, idflags, smeansofdeath, sweapon, vpoint, vdir, shitloc, psoffsettime, damagefromunderneath, modelindex, partname, 1 );
+			}
+			else if ( level.friendlyfire == 1 )
+			{
+				if ( idamage < 1 )
+				{
+					idamage = 1;
+				}
+				self.lastdamagewasfromenemy = 0;
+				self finishvehicledamage( einflictor, eattacker, idamage, idflags, smeansofdeath, sweapon, vpoint, vdir, shitloc, psoffsettime, damagefromunderneath, modelindex, partname, 0 );
+			}
+			else if ( level.friendlyfire == 2 )
+			{
+				if ( !allowfriendlyfiredamage( einflictor, eattacker, smeansofdeath, sweapon ) )
+				{
+					return;
+				}
+				if ( idamage < 1 )
+				{
+					idamage = 1;
+				}
+				self.lastdamagewasfromenemy = 0;
+				self finishvehicledamage( einflictor, eattacker, idamage, idflags, smeansofdeath, sweapon, vpoint, vdir, shitloc, psoffsettime, damagefromunderneath, modelindex, partname, 1 );
+			}
+			else
+			{
+				if ( level.friendlyfire == 3 )
+				{
+					idamage = int( idamage * 0,5 );
+					if ( idamage < 1 )
+					{
+						idamage = 1;
+					}
+					self.lastdamagewasfromenemy = 0;
+					self finishvehicledamage( einflictor, eattacker, idamage, idflags, smeansofdeath, sweapon, vpoint, vdir, shitloc, psoffsettime, damagefromunderneath, modelindex, partname, 0 );
+				}
+			}
+			friendly = 1;
+		}
+		else
+		{
+			if ( !level.teambased && isDefined( self.targetname ) && self.targetname == "rcbomb" )
+			{
+			}
+			else
+			{
+				if ( isDefined( self.owner ) && isDefined( eattacker ) && self.owner == eattacker )
+				{
+					return;
+				}
+			}
+			if ( idamage < 1 )
+			{
+				idamage = 1;
+			}
+			if ( isDefined( eattacker ) && isplayer( eattacker ) && isDefined( sweapon ) )
+			{
+				eattacker thread maps/mp/gametypes_zm/_weapons::checkhit( sweapon );
+			}
+			if ( issubstr( smeansofdeath, "MOD_GRENADE" ) && isDefined( einflictor.iscooked ) )
+			{
+				self.wascooked = getTime();
+			}
+			else
+			{
+				self.wascooked = undefined;
+			}
+			attacker_seat = undefined;
+			if ( isDefined( eattacker ) )
+			{
+				attacker_seat = self getoccupantseat( eattacker );
+			}
+			if ( isDefined( eattacker ) )
+			{
+				self.lastdamagewasfromenemy = !isDefined( attacker_seat );
+			}
+			self finishvehicledamage( einflictor, eattacker, idamage, idflags, smeansofdeath, sweapon, vpoint, vdir, shitloc, psoffsettime, damagefromunderneath, modelindex, partname, 0 );
+			if ( level.gametype == "hack" && sweapon != "emp_grenade_mp" )
+			{
+				idamage = 0;
+			}
+		}
+		if ( isDefined( eattacker ) && eattacker != self )
+		{
+			if ( maps/mp/gametypes_zm/_globallogic_player::dodamagefeedback( sweapon, einflictor ) )
+			{
+				if ( idamage > 0 )
+				{
+					eattacker thread maps/mp/gametypes_zm/_damagefeedback::updatedamagefeedback( smeansofdeath, einflictor );
+				}
+			}
+		}
+	}
+/#
+	if ( getDvarInt( "g_debugDamage" ) )
+	{
+		println( "actor:" + self getentitynumber() + " health:" + self.health + " attacker:" + eattacker.clientid + " inflictor is player:" + isplayer( einflictor ) + " damage:" + idamage + " hitLoc:" + shitloc );
+#/
+	}
+	if ( 1 )
+	{
+		lpselfnum = self getentitynumber();
+		lpselfteam = "";
+		lpattackerteam = "";
+		if ( isplayer( eattacker ) )
+		{
+			lpattacknum = eattacker getentitynumber();
+			lpattackguid = eattacker getguid();
+			lpattackname = eattacker.name;
+			lpattackerteam = eattacker.pers[ "team" ];
+		}
+		else
+		{
+			lpattacknum = -1;
+			lpattackguid = "";
+			lpattackname = "";
+			lpattackerteam = "world";
+		}
+		logprint( "VD;" + lpselfnum + ";" + lpselfteam + ";" + lpattackguid + ";" + lpattacknum + ";" + lpattackerteam + ";" + lpattackname + ";" + sweapon + ";" + idamage + ";" + smeansofdeath + ";" + shitloc + "\n" );
+	}
+}
+
+callback_vehicleradiusdamage( einflictor, eattacker, idamage, finnerdamage, fouterdamage, idflags, smeansofdeath, sweapon, vpoint, fradius, fconeanglecos, vconedir, psoffsettime )
+{
+	idamage = 0;
+	finnerdamage = 0;
+	fouterdamage = 0;
+	self.idflags = idflags;
+	self.idflagstime = getTime();
+	if ( game[ "state" ] == "postgame" )
+	{
+		return;
+	}
+	if ( isDefined( eattacker ) && isplayer( eattacker ) && isDefined( eattacker.candocombat ) && !eattacker.candocombat )
+	{
+		return;
+	}
+	friendly = 0;
+	if ( idflags & level.idflags_no_protection )
+	{
+		if ( self isvehicleimmunetodamage( idflags, smeansofdeath, sweapon ) )
+		{
+			return;
+		}
+		if ( smeansofdeath != "MOD_PROJECTILE_SPLASH" || smeansofdeath == "MOD_GRENADE_SPLASH" && smeansofdeath == "MOD_EXPLOSIVE" )
+		{
+			scalar = getvehicleprojectilesplashscalar( sweapon );
+			idamage = int( idamage * scalar );
+			finnerdamage *= scalar;
+			fouterdamage *= scalar;
+			if ( finnerdamage == 0 )
+			{
+				return;
+			}
+			if ( idamage < 1 )
+			{
+				idamage = 1;
+			}
+		}
+		occupant_team = undefined;
+		if ( level.teambased && isplayer( eattacker ) && occupant_team == eattacker.pers[ "team" ] )
+		{
+			if ( level.friendlyfire == 0 )
+			{
+				if ( !allowfriendlyfiredamage( einflictor, eattacker, smeansofdeath, sweapon ) )
+				{
+					return;
+				}
+				if ( idamage < 1 )
+				{
+					idamage = 1;
+				}
+				self.lastdamagewasfromenemy = 0;
+				self finishvehicleradiusdamage( einflictor, eattacker, idamage, finnerdamage, fouterdamage, idflags, smeansofdeath, sweapon, vpoint, fradius, fconeanglecos, vconedir, psoffsettime );
+			}
+			else if ( level.friendlyfire == 1 )
+			{
+				if ( idamage < 1 )
+				{
+					idamage = 1;
+				}
+				self.lastdamagewasfromenemy = 0;
+				self finishvehicleradiusdamage( einflictor, eattacker, idamage, finnerdamage, fouterdamage, idflags, smeansofdeath, sweapon, vpoint, fradius, fconeanglecos, vconedir, psoffsettime );
+			}
+			else if ( level.friendlyfire == 2 )
+			{
+				if ( !allowfriendlyfiredamage( einflictor, eattacker, smeansofdeath, sweapon ) )
+				{
+					return;
+				}
+				if ( idamage < 1 )
+				{
+					idamage = 1;
+				}
+				self.lastdamagewasfromenemy = 0;
+				self finishvehicleradiusdamage( einflictor, eattacker, idamage, finnerdamage, fouterdamage, idflags, smeansofdeath, sweapon, vpoint, fradius, fconeanglecos, vconedir, psoffsettime );
+			}
+			else
+			{
+				if ( level.friendlyfire == 3 )
+				{
+					idamage = int( idamage * 0,5 );
+					if ( idamage < 1 )
+					{
+						idamage = 1;
+					}
+					self.lastdamagewasfromenemy = 0;
+					self finishvehicleradiusdamage( einflictor, eattacker, idamage, finnerdamage, fouterdamage, idflags, smeansofdeath, sweapon, vpoint, fradius, fconeanglecos, vconedir, psoffsettime );
+				}
+			}
+			friendly = 1;
+			return;
+		}
+		else
+		{
+			if ( idamage < 1 )
+			{
+				idamage = 1;
+			}
+			self finishvehicleradiusdamage( einflictor, eattacker, idamage, finnerdamage, fouterdamage, idflags, smeansofdeath, sweapon, vpoint, fradius, fconeanglecos, vconedir, psoffsettime );
+		}
+	}
+}
+
+vehiclecrush()
+{
+	self endon( "disconnect" );
+	if ( isDefined( level._effect ) && isDefined( level._effect[ "tanksquish" ] ) )
+	{
+		playfx( level._effect[ "tanksquish" ], self.origin + vectorScale( ( 0, 0, 1 ), 30 ) );
+	}
+	self playsound( "chr_crunch" );
+}
+
+getvehicleprojectilescalar( sweapon )
+{
+	if ( sweapon == "satchel_charge_mp" )
+	{
+		scale = 1;
+	}
+	else if ( sweapon == "sticky_grenade_mp" )
+	{
+		scale = 1;
+	}
+	else if ( sweapon == "claymore_mp" )
+	{
+		scale = 1;
+	}
+	else if ( sweapon == "remote_missile_missile_mp" )
+	{
+		scale = 10;
+	}
+	else if ( sweapon == "remote_mortar_missile_mp" )
+	{
+		scale = 10;
+	}
+	else if ( sweapon == "smaw_mp" )
+	{
+		scale = 0,2;
+	}
+	else if ( sweapon == "fhj18_mp" )
+	{
+		scale = 0,2;
+	}
+	else if ( issubstr( sweapon, "gl_" ) )
+	{
+		scale = 1;
+	}
+	else if ( issubstr( sweapon, "turret_mp" ) )
+	{
+		scale = 1;
+	}
+	else if ( issubstr( sweapon, "grenade" ) )
+	{
+		scale = 1;
+	}
+	else
+	{
+		scale = 1;
+	}
+	return scale;
+}
+
+getvehicleprojectilesplashscalar( sweapon )
+{
+	if ( sweapon == "satchel_charge_mp" )
+	{
+		scale = 1;
+	}
+	else if ( sweapon == "sticky_grenade_mp" )
+	{
+		scale = 1;
+	}
+	else if ( sweapon == "claymore_mp" )
+	{
+		scale = 1;
+	}
+	else if ( sweapon == "remote_missile_missile_mp" )
+	{
+		scale = 10;
+	}
+	else if ( sweapon == "remote_mortar_missile_mp" )
+	{
+		scale = 4;
+	}
+	else if ( sweapon == "chopper_minigun_mp" )
+	{
+		scale = 0,5;
+	}
+	else if ( issubstr( sweapon, "gl_" ) )
+	{
+		scale = 0,5;
+	}
+	else if ( issubstr( sweapon, "turrent_mp" ) )
+	{
+		scale = 0,1;
+	}
+	else if ( issubstr( sweapon, "grenade" ) )
+	{
+		scale = 1;
+	}
+	else
+	{
+		scale = 1;
+	}
+	return scale;
+}
+
+getvehicleunderneathsplashscalar( sweapon )
+{
+	if ( sweapon == "satchel_charge_mp" )
+	{
+		scale = 10;
+		scale *= 3;
+	}
+	else
+	{
+		scale = 1;
+	}
+	return scale;
+}
+
+getvehiclebulletdamage( sweapon )
+{
+	if ( issubstr( sweapon, "ptrs41_" ) )
+	{
+		idamage = 25;
+	}
+	else if ( issubstr( sweapon, "gunner" ) )
+	{
+		idamage = 5;
+	}
+	else if ( issubstr( sweapon, "mg42_bipod" ) || issubstr( sweapon, "30cal_bipod" ) )
+	{
+		idamage = 5;
+	}
+	else
+	{
+		idamage = 1;
+	}
+	return idamage;
+}
+
+allowfriendlyfiredamage( einflictor, eattacker, smeansofdeath, sweapon )
+{
+	if ( isDefined( self.allowfriendlyfiredamageoverride ) )
+	{
+		return [[ self.allowfriendlyfiredamageoverride ]]( einflictor, eattacker, smeansofdeath, sweapon );
+	}
+	vehicle = eattacker getvehicleoccupied();
+	return 0;
+}

patch_zm/maps/mp/gametypes_zm/_gv_actions.gsc

@@ -0,0 +1,995 @@
+#include maps/mp/gametypes_zm/_globallogic_ui;
+#include maps/mp/gametypes_zm/_hud_util;
+#include maps/mp/gametypes_zm/_globallogic_score;
+#include maps/mp/gametypes_zm/_globallogic;
+#include common_scripts/utility;
+#include maps/mp/_utility;
+
+initializeactionarray()
+{
+	level.gametypeactions = [];
+	level.gametypeactions[ "GiveAmmo" ] = ::dogiveammo;
+	level.gametypeactions[ "RemoveAmmo" ] = ::doremoveammo;
+	level.gametypeactions[ "PlaySound" ] = ::doplaysound;
+	level.gametypeactions[ "EnableUAV" ] = ::doenableuav;
+	level.gametypeactions[ "GiveScore" ] = ::dogivescore;
+	level.gametypeactions[ "RemoveScore" ] = ::doremovescore;
+	level.gametypeactions[ "SetHeader" ] = ::dosetheader;
+	level.gametypeactions[ "SetSubHeader" ] = ::dosetsubheader;
+	level.gametypeactions[ "DisplayMessage" ] = ::dodisplaymessage;
+	level.gametypeactions[ "GiveHealth" ] = ::dogivehealth;
+	level.gametypeactions[ "RemoveHealth" ] = ::doremovehealth;
+	level.gametypeactions[ "SetHealthRegen" ] = ::dosethealthregen;
+	level.gametypeactions[ "ChangeClass" ] = ::dochangeclass;
+	level.gametypeactions[ "ChangeTeam" ] = ::dochangeteam;
+	level.gametypeactions[ "GivePerk" ] = ::dogiveperk;
+	level.gametypeactions[ "RemovePerk" ] = ::doremoveperk;
+	level.gametypeactions[ "GiveInvuln" ] = ::dogiveinvuln;
+	level.gametypeactions[ "RemoveInvuln" ] = ::doremoveinvuln;
+	level.gametypeactions[ "SetDamageModifier" ] = ::dosetdamagemodifier;
+	level.gametypeactions[ "GiveKillstreak" ] = ::dogivekillstreak;
+	level.gametypeactions[ "RemoveKillstreak" ] = ::doremovekillstreak;
+	level.gametypeactions[ "GiveLives" ] = ::dogivelives;
+	level.gametypeactions[ "RemoveLives" ] = ::doremovelives;
+	level.gametypeactions[ "ScaleMoveSpeed" ] = ::doscalemovespeed;
+	level.gametypeactions[ "ShowOnRadar" ] = ::doshowonradar;
+	level.conditionals = [];
+	level.conditionals[ "Equals" ] = ::equals;
+	level.conditionals[ "==" ] = ::equals;
+	level.conditionals[ "!=" ] = ::notequals;
+	level.conditionals[ "<" ] = ::lessthan;
+	level.conditionals[ "<=" ] = ::lessthanequals;
+	level.conditionals[ ">" ] = ::greaterthan;
+	level.conditionals[ ">=" ] = ::greaterthanequals;
+	level.conditionals[ "InPlace" ] = ::inplace;
+	level.conditionallefthandside = [];
+	level.conditionallefthandside[ "PlayersLeft" ] = ::playersleft;
+	level.conditionallefthandside[ "RoundsPlayed" ] = ::roundsplayed;
+	level.conditionallefthandside[ "HitBy" ] = ::hitby;
+	level.conditionallefthandside[ "PlayersClass" ] = ::playersclass;
+	level.conditionallefthandside[ "VictimsClass" ] = ::playersclass;
+	level.conditionallefthandside[ "AttackersClass" ] = ::attackersclass;
+	level.conditionallefthandside[ "PlayersPlace" ] = ::playersplace;
+	level.conditionallefthandside[ "VictimsPlace" ] = ::playersplace;
+	level.conditionallefthandside[ "AttackersPlace" ] = ::attackersplace;
+	level.targets = [];
+	level.targets[ "Everyone" ] = ::gettargeteveryone;
+	level.targets[ "PlayersLeft" ] = ::gettargetplayersleft;
+	level.targets[ "PlayersEliminated" ] = ::gettargetplayerseliminated;
+	level.targets[ "PlayersTeam" ] = ::gettargetplayersteam;
+	level.targets[ "VictimsTeam" ] = ::gettargetplayersteam;
+	level.targets[ "OtherTeam" ] = ::gettargetotherteam;
+	level.targets[ "AttackersTeam" ] = ::gettargetotherteam;
+	level.targets[ "PlayersLeftOnPlayersTeam" ] = ::gettargetplayersleftonplayersteam;
+	level.targets[ "PlayersLeftOnOtherTeam" ] = ::gettargetplayersleftonotherteam;
+	level.targets[ "PlayersLeftOnVictimsTeam" ] = ::gettargetplayersleftonplayersteam;
+	level.targets[ "PlayersLeftOnAttackersTeam" ] = ::gettargetplayersleftonotherteam;
+	level.targets[ "PlayersEliminatedOnPlayersTeam" ] = ::gettargetplayerseliminatedonplayersteam;
+	level.targets[ "PlayersEliminatedOnOtherTeam" ] = ::gettargetplayerseliminatedonotherteam;
+	level.targets[ "PlayersEliminatedOnVictimsTeam" ] = ::gettargetplayerseliminatedonplayersteam;
+	level.targets[ "PlayersEliminatedOnAttackersTeam" ] = ::gettargetplayerseliminatedonotherteam;
+	level.targets[ "AssistingPlayers" ] = ::getassistingplayers;
+}
+
+equals( param1, param2 )
+{
+	return param1 == param2;
+}
+
+notequals( param1, param2 )
+{
+	return param1 != param2;
+}
+
+lessthan( param1, param2 )
+{
+	return param1 < param2;
+}
+
+lessthanequals( param1, param2 )
+{
+	return param1 <= param2;
+}
+
+greaterthan( param1, param2 )
+{
+	return param1 > param2;
+}
+
+greaterthanequals( param1, param2 )
+{
+	return param1 >= param2;
+}
+
+inplace( param1, param2 )
+{
+	if ( param1 == param2 )
+	{
+		return 1;
+	}
+	if ( param2 == "top3" && param1 == "first" )
+	{
+		return 1;
+	}
+	return 0;
+}
+
+playersleft( rule )
+{
+	return 0;
+}
+
+roundsplayed( rule )
+{
+	return game[ "roundsplayed" ] + 1;
+}
+
+hitby( rule )
+{
+	meansofdeath = rule.target[ "MeansOfDeath" ];
+	weapon = rule.target[ "Weapon" ];
+	if ( !isDefined( meansofdeath ) || !isDefined( weapon ) )
+	{
+		return undefined;
+	}
+	switch( weapon )
+	{
+		case "knife_ballistic_mp":
+			return "knife";
+	}
+	switch( meansofdeath )
+	{
+		case "MOD_PISTOL_BULLET":
+		case "MOD_RIFLE_BULLET":
+			return "bullet";
+		case "MOD_BAYONET":
+		case "MOD_MELEE":
+			return "knife";
+		case "MOD_HEAD_SHOT":
+			return "headshot";
+		case "MOD_EXPLOSIVE":
+		case "MOD_GRENADE":
+		case "MOD_GRENADE_SPLASH":
+		case "MOD_PROJECTILE":
+		case "MOD_PROJECTILE_SPLASH":
+			return "explosive";
+	}
+	return undefined;
+}
+
+getplayersclass( player )
+{
+	return player.pers[ "class" ];
+}
+
+playersclass( rule )
+{
+	player = rule.target[ "Player" ];
+	return getplayersclass( player );
+}
+
+attackersclass( rule )
+{
+	player = rule.target[ "Attacker" ];
+	return getplayersclass( player );
+}
+
+getplayersplace( player )
+{
+	maps/mp/gametypes_zm/_globallogic::updateplacement();
+	if ( !isDefined( level.placement[ "all" ] ) )
+	{
+		return;
+	}
+	place = 0;
+	while ( place < level.placement[ "all" ].size )
+	{
+		if ( level.placement[ "all" ][ place ] == player )
+		{
+			place++;
+			continue;
+		}
+		else
+		{
+			place++;
+		}
+	}
+	place++;
+	if ( place == 1 )
+	{
+		return "first";
+	}
+	else
+	{
+		if ( place <= 3 )
+		{
+			return "top3";
+		}
+		else
+		{
+			if ( place == level.placement[ "all" ].size )
+			{
+				return "last";
+			}
+		}
+	}
+	return "middle";
+}
+
+playersplace( rule )
+{
+	player = rule.target[ "Player" ];
+	return getplayersplace( player );
+}
+
+attackersplace( rule )
+{
+	player = rule.target[ "Attacker" ];
+	return getplayersplace( player );
+}
+
+gettargeteveryone( rule )
+{
+	return level.players;
+}
+
+gettargetplayersleft( rule )
+{
+	return 0;
+}
+
+gettargetplayerseliminated( rule )
+{
+	return 0;
+}
+
+gettargetplayersteam( rule )
+{
+	player = rule.target[ "Player" ];
+	if ( !isDefined( player ) )
+	{
+		return [];
+	}
+	return getplayersonteam( level.players, player.pers[ "team" ] );
+}
+
+gettargetotherteam( rule )
+{
+	player = rule.target[ "Player" ];
+	if ( !isDefined( player ) )
+	{
+		return [];
+	}
+	return getplayersonteam( level.players, getotherteam( player.pers[ "team" ] ) );
+}
+
+gettargetplayersleftonplayersteam( rule )
+{
+	return [];
+}
+
+gettargetplayersleftonotherteam( rule )
+{
+	return [];
+}
+
+gettargetplayerseliminatedonplayersteam( rule )
+{
+	return [];
+}
+
+gettargetplayerseliminatedonotherteam( rule )
+{
+	return [];
+}
+
+getassistingplayers( rule )
+{
+	assisters = [];
+	attacker = rule.target[ "Attacker" ];
+	if ( !isDefined( rule.target[ "Assisters" ] ) || !isDefined( attacker ) )
+	{
+		return assisters;
+	}
+	j = 0;
+	while ( j < rule.target[ "Assisters" ].size )
+	{
+		player = rule.target[ "Assisters" ][ j ];
+		if ( !isDefined( player ) )
+		{
+			j++;
+			continue;
+		}
+		else if ( player == attacker )
+		{
+			j++;
+			continue;
+		}
+		else
+		{
+			assisters[ assisters.size ] = player;
+		}
+		j++;
+	}
+	return assisters;
+}
+
+executegametypeeventrule( rule )
+{
+	if ( !aregametypeeventruleconditionalsmet( rule ) )
+	{
+		return;
+	}
+	if ( !isDefined( level.gametypeactions[ rule.action ] ) )
+	{
+/#
+		error( "GAMETYPE VARIANTS - unknown action:  " + rule.action + "!" );
+#/
+		return;
+	}
+	thread internalexecuterule( rule );
+}
+
+internalexecuterule( rule )
+{
+}
+
+aregametypeeventruleconditionalsmet( rule )
+{
+	if ( !isDefined( rule.conditionals ) || rule.conditionals.size == 0 )
+	{
+		return 1;
+	}
+	combinedresult = 1;
+	if ( rule.conditionaleval == "OR" )
+	{
+		combinedresult = 0;
+	}
+	i = 0;
+	while ( i < rule.conditionals.size )
+	{
+		conditionalresult = evaluategametypeeventruleconditional( rule, rule.conditionals[ i ] );
+		switch( rule.conditionaleval )
+		{
+			case "AND":
+				if ( combinedresult )
+				{
+					combinedresult = conditionalresult;
+				}
+				break;
+			case "OR":
+				if ( !combinedresult )
+				{
+					combinedresult = conditionalresult;
+				}
+				break;
+		}
+		if ( rule.conditionaleval == "AND" && !combinedresult )
+		{
+			break;
+		}
+		else
+		{
+			if ( rule.conditionaleval == "OR" && combinedresult )
+			{
+				break;
+			}
+			else
+			{
+				i++;
+			}
+		}
+	}
+	return combinedresult;
+}
+
+evaluategametypeeventruleconditional( rule, conditional )
+{
+	if ( isDefined( conditional.lhs ) || !isDefined( conditional.operand ) && !isDefined( conditional.rhs ) )
+	{
+		return 0;
+	}
+	if ( !isDefined( level.conditionallefthandside[ conditional.lhs ] ) )
+	{
+		return 0;
+	}
+	lhsvalue = [[ level.conditionallefthandside[ conditional.lhs ] ]]( rule );
+	if ( !isDefined( lhsvalue ) || !isDefined( level.conditionals[ conditional.operand ] ) )
+	{
+		return 0;
+	}
+	return [[ level.conditionals[ conditional.operand ] ]]( lhsvalue, conditional.rhs );
+}
+
+getplayersonteam( players, team )
+{
+	playersonteam = [];
+	i = 0;
+	while ( i < players.size )
+	{
+		player = players[ i ];
+		if ( player.pers[ "team" ] == team )
+		{
+			playersonteam[ playersonteam.size ] = player;
+		}
+		i++;
+	}
+	return playersonteam;
+}
+
+gettargetsforgametypeeventrule( rule )
+{
+	targets = [];
+	if ( !isDefined( rule.targetname ) )
+	{
+		return targets;
+	}
+	if ( isDefined( rule.target[ rule.targetname ] ) )
+	{
+		targets[ targets.size ] = rule.target[ rule.targetname ];
+	}
+	else
+	{
+		if ( isDefined( level.targets[ rule.targetname ] ) )
+		{
+			targets = [[ level.targets[ rule.targetname ] ]]( rule );
+		}
+	}
+	return targets;
+}
+
+doesrulehavevalidparam( rule )
+{
+	if ( isDefined( rule.params ) && isarray( rule.params ) )
+	{
+		return rule.params.size > 0;
+	}
+}
+
+sortplayersbylivesdescending( players )
+{
+	if ( !isDefined( players ) )
+	{
+		return undefined;
+	}
+	swapped = 1;
+	n = players.size;
+	while ( swapped )
+	{
+		swapped = 0;
+		i = 0;
+		while ( i < ( n - 1 ) )
+		{
+			if ( players[ i ].pers[ "lives" ] < players[ i + 1 ].pers[ "lives" ] )
+			{
+				temp = players[ i ];
+				players[ i ] = players[ i + 1 ];
+				players[ i + 1 ] = temp;
+				swapped = 1;
+			}
+			i++;
+		}
+		n--;
+
+	}
+	return players;
+}
+
+giveammo( players, amount )
+{
+	i = 0;
+	while ( i < players.size )
+	{
+		wait 0,5;
+		player = players[ i ];
+		currentweapon = player getcurrentweapon();
+		clipammo = player getweaponammoclip( currentweapon );
+		player setweaponammoclip( currentweapon, clipammo + amount );
+		i++;
+	}
+}
+
+dogiveammo( rule )
+{
+	if ( !doesrulehavevalidparam( rule ) )
+	{
+		return;
+	}
+	targets = gettargetsforgametypeeventrule( rule );
+	giveammo( targets, rule.params[ 0 ] );
+}
+
+doremoveammo( rule )
+{
+	if ( !doesrulehavevalidparam( rule ) )
+	{
+		return;
+	}
+	targets = gettargetsforgametypeeventrule( rule );
+	giveammo( targets, 0 - rule.params[ 0 ] );
+}
+
+doplaysound( rule )
+{
+	if ( doesrulehavevalidparam( rule ) )
+	{
+		playsoundonplayers( rule.params[ 0 ] );
+	}
+}
+
+doenableuav( rule )
+{
+	targets = gettargetsforgametypeeventrule( rule );
+	targetindex = 0;
+	while ( targetindex < targets.size )
+	{
+		targets[ targetindex ].pers[ "hasRadar" ] = 1;
+		targets[ targetindex ].hasspyplane = 1;
+		targetindex++;
+	}
+}
+
+givescore( players, amount )
+{
+	i = 0;
+	while ( i < players.size )
+	{
+		player = players[ i ];
+		score = maps/mp/gametypes_zm/_globallogic_score::_getplayerscore( player );
+		maps/mp/gametypes_zm/_globallogic_score::_setplayerscore( player, score + amount );
+		i++;
+	}
+}
+
+dogivescore( rule )
+{
+	if ( !doesrulehavevalidparam( rule ) )
+	{
+		return;
+	}
+	targets = gettargetsforgametypeeventrule( rule );
+	givescore( targets, rule.params[ 0 ] );
+}
+
+doremovescore( rule )
+{
+	if ( !doesrulehavevalidparam( rule ) )
+	{
+		return;
+	}
+	targets = gettargetsforgametypeeventrule( rule );
+	givescore( targets, 0 - rule.params[ 0 ] );
+}
+
+dosetheader( rule )
+{
+	if ( !doesrulehavevalidparam( rule ) )
+	{
+		return;
+	}
+	targets = gettargetsforgametypeeventrule( rule );
+	targetindex = 0;
+	while ( targetindex < targets.size )
+	{
+		target = targets[ targetindex ];
+		displaytextonhudelem( target, target.customgametypeheader, rule.params[ 0 ], rule.params[ 1 ], "gv_header", rule.params[ 2 ] );
+		targetindex++;
+	}
+}
+
+dosetsubheader( rule )
+{
+	if ( !doesrulehavevalidparam( rule ) )
+	{
+		return;
+	}
+	targets = gettargetsforgametypeeventrule( rule );
+	targetindex = 0;
+	while ( targetindex < targets.size )
+	{
+		target = targets[ targetindex ];
+		displaytextonhudelem( target, target.customgametypesubheader, rule.params[ 0 ], rule.params[ 1 ], "gv_subheader", rule.params[ 2 ] );
+		targetindex++;
+	}
+}
+
+displaytextonhudelem( target, texthudelem, text, secondstodisplay, notifyname, valueparam )
+{
+	texthudelem.alpha = 1;
+	if ( isDefined( valueparam ) )
+	{
+		texthudelem settext( text, valueparam );
+	}
+	else
+	{
+		texthudelem settext( text );
+	}
+	if ( !isDefined( secondstodisplay ) || secondstodisplay <= 0 )
+	{
+		target.doingnotify = 0;
+		target notify( notifyname );
+		return;
+	}
+	target thread fadecustomgametypehudelem( texthudelem, secondstodisplay, notifyname );
+}
+
+fadecustomgametypehudelem( hudelem, seconds, notifyname )
+{
+	self endon( "disconnect" );
+	self notify( notifyname );
+	self endon( notifyname );
+	if ( seconds <= 0 )
+	{
+		return;
+	}
+	self.doingnotify = 1;
+	wait seconds;
+	while ( hudelem.alpha > 0 )
+	{
+		hudelem.alpha -= 0,05;
+		if ( hudelem.alpha < 0 )
+		{
+			hudelem.alpha = 0;
+		}
+		wait 0,05;
+	}
+	self.doingnotify = 0;
+}
+
+dodisplaymessage( rule )
+{
+	if ( !doesrulehavevalidparam( rule ) )
+	{
+		return;
+	}
+	targets = gettargetsforgametypeeventrule( rule );
+	targetindex = 0;
+	while ( targetindex < targets.size )
+	{
+		thread announcemessage( targets[ targetindex ], rule.params[ 0 ], 2 );
+		targetindex++;
+	}
+}
+
+announcemessage( target, messagetext, time )
+{
+	target endon( "disconnect" );
+	clientannouncement( target, messagetext, int( time * 1000 ) );
+	if ( time == 0 )
+	{
+		time = getDvarFloat( #"E8C4FC20" );
+	}
+	target.doingnotify = 1;
+	wait time;
+	target.doingnotify = 0;
+}
+
+givehealth( players, amount )
+{
+	i = 0;
+	while ( i < players.size )
+	{
+		player = players[ i ];
+		player.health += amount;
+		i++;
+	}
+}
+
+dogivehealth( rule )
+{
+	if ( !doesrulehavevalidparam( rule ) )
+	{
+		return;
+	}
+	givehealth( gettargetsforgametypeeventrule( rule ), rule.params[ 0 ] );
+}
+
+doremovehealth( rule )
+{
+	if ( !doesrulehavevalidparam( rule ) )
+	{
+		return;
+	}
+	givehealth( gettargetsforgametypeeventrule( rule ), 0 - rule.params[ 0 ] );
+}
+
+dosethealthregen( rule )
+{
+	targets = gettargetsforgametypeeventrule( rule );
+	targetindex = 0;
+	while ( targetindex < targets.size )
+	{
+		player = targets[ targetindex ];
+		player.regenrate = rule.params[ 0 ];
+		targetindex++;
+	}
+}
+
+dochangeclass( rule )
+{
+	if ( !doesrulehavevalidparam( rule ) )
+	{
+		return;
+	}
+}
+
+dochangeteam( rule )
+{
+	if ( !doesrulehavevalidparam( rule ) )
+	{
+		return;
+	}
+	team = rule.params[ 0 ];
+	teamkeys = getarraykeys( level.teams );
+	targets = gettargetsforgametypeeventrule( rule );
+	targetindex = 0;
+	while ( targetindex < targets.size )
+	{
+		target = targets[ targetindex ];
+		if ( target.pers[ "team" ] == team )
+		{
+			targetindex++;
+			continue;
+		}
+		else
+		{
+			while ( team == "toggle" )
+			{
+				team = teamkeys[ randomint( teamkeys.size ) ];
+				teamindex = 0;
+				while ( teamindex < teamkeys.size )
+				{
+					if ( target.pers[ "team" ] == teamkeys[ teamindex ] )
+					{
+						team = teamkeys[ ( teamindex + 1 ) % teamkeys.size ];
+						break;
+					}
+					else
+					{
+						teamindex++;
+					}
+				}
+			}
+			target.pers[ "team" ] = team;
+			target.team = team;
+			if ( level.teambased )
+			{
+				target.sessionteam = team;
+			}
+			else
+			{
+				target.sessionteam = "none";
+			}
+			target notify( "joined_team" );
+			level notify( "joined_team" );
+		}
+		targetindex++;
+	}
+}
+
+displayperk( player, imagename )
+{
+	index = 0;
+	if ( isDefined( player.perkicon ) )
+	{
+		index = -1;
+		i = 0;
+		while ( i < player.perkicon.size )
+		{
+			if ( player.perkicon[ i ].alpha == 0 )
+			{
+				index = i;
+				break;
+			}
+			else
+			{
+				i++;
+			}
+		}
+		if ( index == -1 )
+		{
+			return;
+		}
+	}
+	player maps/mp/gametypes_zm/_hud_util::showperk( index, imagename, 10 );
+	player thread maps/mp/gametypes_zm/_globallogic_ui::hideloadoutaftertime( 3 );
+	player thread maps/mp/gametypes_zm/_globallogic_ui::hideloadoutondeath();
+}
+
+setorunsetperk( players, perks, shouldset )
+{
+	if ( level.perksenabled == 0 )
+	{
+		return;
+	}
+	if ( perks.size < 2 )
+	{
+		return;
+	}
+	hasperkalready = 0;
+	imagename = perks[ perks.size - 1 ];
+	i = 0;
+	while ( i < players.size )
+	{
+		player = players[ i ];
+		perkindex = 0;
+		while ( perkindex < ( perks.size - 1 ) )
+		{
+			perk = perks[ perkindex ];
+			if ( player hasperk( perk ) )
+			{
+				hasperkalready = 1;
+			}
+			if ( shouldset )
+			{
+				player setperk( perk );
+				perkindex++;
+				continue;
+			}
+			else
+			{
+				player unsetperk( perk );
+			}
+			perkindex++;
+		}
+		if ( shouldset && !hasperkalready && getDvarInt( "scr_showperksonspawn" ) == 1 )
+		{
+			displayperk( player, imagename );
+		}
+		i++;
+	}
+}
+
+dogiveperk( rule )
+{
+	if ( !doesrulehavevalidparam( rule ) )
+	{
+		return;
+	}
+	setorunsetperk( gettargetsforgametypeeventrule( rule ), rule.params, 1 );
+}
+
+doremoveperk( rule )
+{
+	if ( !doesrulehavevalidparam( rule ) )
+	{
+		return;
+	}
+	setorunsetperk( gettargetsforgametypeeventrule( rule ), rule.params, 0 );
+}
+
+giveorremovekillstreak( rule, shouldgive )
+{
+}
+
+dogivekillstreak( rule )
+{
+	giveorremovekillstreak( rule, 1 );
+}
+
+doremovekillstreak( rule )
+{
+	giveorremovekillstreak( rule, 0 );
+}
+
+givelives( players, amount )
+{
+	i = 0;
+	while ( i < players.size )
+	{
+		player = players[ i ];
+		player.pers[ "lives" ] += amount;
+		if ( player.pers[ "lives" ] < 0 )
+		{
+			player.pers[ "lives" ] = 0;
+		}
+		i++;
+	}
+}
+
+dogivelives( rule )
+{
+	if ( !doesrulehavevalidparam( rule ) )
+	{
+		return;
+	}
+	givelives( gettargetsforgametypeeventrule( rule ), rule.params[ 0 ] );
+}
+
+doremovelives( rule )
+{
+	if ( !doesrulehavevalidparam( rule ) )
+	{
+		return;
+	}
+	givelives( gettargetsforgametypeeventrule( rule ), 0 - rule.params[ 0 ] );
+}
+
+giveorremoveinvuln( players, shouldgiveinvuln )
+{
+	i = 0;
+	while ( i < players.size )
+	{
+		player = players[ i ];
+		i++;
+	}
+}
+
+dogiveinvuln( rule )
+{
+	giveorremoveinvuln( gettargetsforgametypeeventrule( rule ), 1 );
+}
+
+doremoveinvuln( rule )
+{
+	giveorremoveinvuln( gettargetsforgametypeeventrule( rule ), 0 );
+}
+
+dosetdamagemodifier( rule )
+{
+	if ( !doesrulehavevalidparam( rule ) )
+	{
+		return;
+	}
+	players = gettargetsforgametypeeventrule( rule );
+	i = 0;
+	while ( i < players.size )
+	{
+		player = players[ i ];
+		player.damagemodifier = rule.params[ 0 ];
+		i++;
+	}
+}
+
+doscalemovespeed( rule )
+{
+	if ( !doesrulehavevalidparam( rule ) )
+	{
+		return;
+	}
+	movespeedscale = rule.params[ 0 ];
+	targets = gettargetsforgametypeeventrule( rule );
+	targetindex = 0;
+	while ( targetindex < targets.size )
+	{
+		target = targets[ targetindex ];
+		target.movementspeedmodifier = movespeedscale * target getmovespeedscale();
+		if ( target.movementspeedmodifier < 0,1 )
+		{
+			target.movementspeedmodifier = 0,1;
+		}
+		else
+		{
+			if ( target.movementspeedmodifier > 4 )
+			{
+				target.movementspeedmodifier = 4;
+			}
+		}
+		target setmovespeedscale( target.movementspeedmodifier );
+		targetindex++;
+	}
+}
+
+doshowonradar( rule )
+{
+	if ( !doesrulehavevalidparam( rule ) )
+	{
+		return;
+	}
+	targets = gettargetsforgametypeeventrule( rule );
+	targetindex = 0;
+	while ( targetindex < targets.size )
+	{
+		if ( rule.params[ 0 ] == "enable" )
+		{
+			targets[ targetindex ] setperk( "specialty_showonradar" );
+			targetindex++;
+			continue;
+		}
+		else
+		{
+			targets[ targetindex ] unsetperk( "specialty_showonradar" );
+		}
+		targetindex++;
+	}
+}

patch_zm/maps/mp/gametypes_zm/_healthoverlay.gsc

@@ -0,0 +1,288 @@
+#include maps/mp/gametypes_zm/_globallogic_player;
+
+init()
+{
+	precacheshader( "overlay_low_health" );
+	level.healthoverlaycutoff = 0,55;
+	regentime = level.playerhealthregentime;
+	level.playerhealth_regularregendelay = regentime * 1000;
+	level.healthregendisabled = level.playerhealth_regularregendelay <= 0;
+	level thread onplayerconnect();
+}
+
+onplayerconnect()
+{
+	for ( ;; )
+	{
+		level waittill( "connecting", player );
+		player thread onplayerspawned();
+		player thread onplayerkilled();
+		player thread onjoinedteam();
+		player thread onjoinedspectators();
+		player thread onplayerdisconnect();
+	}
+}
+
+onjoinedteam()
+{
+	self endon( "disconnect" );
+	for ( ;; )
+	{
+		self waittill( "joined_team" );
+		self notify( "end_healthregen" );
+	}
+}
+
+onjoinedspectators()
+{
+	self endon( "disconnect" );
+	for ( ;; )
+	{
+		self waittill( "joined_spectators" );
+		self notify( "end_healthregen" );
+	}
+}
+
+onplayerspawned()
+{
+	self endon( "disconnect" );
+	for ( ;; )
+	{
+		self waittill( "spawned_player" );
+		self thread playerhealthregen();
+	}
+}
+
+onplayerkilled()
+{
+	self endon( "disconnect" );
+	for ( ;; )
+	{
+		self waittill( "killed_player" );
+		self notify( "end_healthregen" );
+	}
+}
+
+onplayerdisconnect()
+{
+	self waittill( "disconnect" );
+	self notify( "end_healthregen" );
+}
+
+playerhealthregen()
+{
+	self endon( "end_healthregen" );
+	if ( self.health <= 0 )
+	{
+/#
+		assert( !isalive( self ) );
+#/
+		return;
+	}
+	maxhealth = self.health;
+	oldhealth = maxhealth;
+	player = self;
+	health_add = 0;
+	regenrate = 0,1;
+	usetrueregen = 0;
+	veryhurt = 0;
+	player.breathingstoptime = -10000;
+	thread playerbreathingsound( maxhealth * 0,35 );
+	thread playerheartbeatsound( maxhealth * 0,35 );
+	lastsoundtime_recover = 0;
+	hurttime = 0;
+	newhealth = 0;
+	for ( ;; )
+	{
+		wait 0,05;
+		if ( isDefined( player.regenrate ) )
+		{
+			regenrate = player.regenrate;
+			usetrueregen = 1;
+		}
+		if ( player.health == maxhealth )
+		{
+			veryhurt = 0;
+			self.atbrinkofdeath = 0;
+			continue;
+		}
+		else if ( player.health <= 0 )
+		{
+			return;
+		}
+		if ( isDefined( player.laststand ) && player.laststand )
+		{
+			continue;
+		}
+		else
+		{
+			wasveryhurt = veryhurt;
+			ratio = player.health / maxhealth;
+			if ( ratio <= level.healthoverlaycutoff )
+			{
+				veryhurt = 1;
+				self.atbrinkofdeath = 1;
+				if ( !wasveryhurt )
+				{
+					hurttime = getTime();
+				}
+			}
+			if ( player.health >= oldhealth )
+			{
+				regentime = level.playerhealth_regularregendelay;
+				if ( player hasperk( "specialty_healthregen" ) )
+				{
+					regentime = int( regentime / getDvarFloat( "perk_healthRegenMultiplier" ) );
+				}
+				if ( ( getTime() - hurttime ) < regentime )
+				{
+					break;
+				}
+				else if ( level.healthregendisabled )
+				{
+					break;
+				}
+				else if ( ( getTime() - lastsoundtime_recover ) > regentime )
+				{
+					lastsoundtime_recover = getTime();
+					self notify( "snd_breathing_better" );
+				}
+				if ( veryhurt )
+				{
+					newhealth = ratio;
+					veryhurttime = 3000;
+					if ( player hasperk( "specialty_healthregen" ) )
+					{
+						veryhurttime = int( veryhurttime / getDvarFloat( "perk_healthRegenMultiplier" ) );
+					}
+					if ( getTime() > ( hurttime + veryhurttime ) )
+					{
+						newhealth += regenrate;
+					}
+				}
+				else if ( usetrueregen )
+				{
+					newhealth = ratio + regenrate;
+				}
+				else
+				{
+					newhealth = 1;
+				}
+				if ( newhealth >= 1 )
+				{
+					self maps/mp/gametypes_zm/_globallogic_player::resetattackerlist();
+					newhealth = 1;
+				}
+				if ( newhealth <= 0 )
+				{
+					return;
+				}
+				player setnormalhealth( newhealth );
+				change = player.health - oldhealth;
+				if ( change > 0 )
+				{
+					player decayplayerdamages( change );
+				}
+				oldhealth = player.health;
+				break;
+			}
+			else
+			{
+				oldhealth = player.health;
+				health_add = 0;
+				hurttime = getTime();
+				player.breathingstoptime = hurttime + 6000;
+			}
+		}
+	}
+}
+
+decayplayerdamages( decay )
+{
+	if ( !isDefined( self.attackerdamage ) )
+	{
+		return;
+	}
+	i = 0;
+	while ( i < self.attackerdamage.size )
+	{
+		if ( !isDefined( self.attackerdamage[ i ] ) || !isDefined( self.attackerdamage[ i ].damage ) )
+		{
+			i++;
+			continue;
+		}
+		else
+		{
+			self.attackerdamage[ i ].damage -= decay;
+			if ( self.attackerdamage[ i ].damage < 0 )
+			{
+				self.attackerdamage[ i ].damage = 0;
+			}
+		}
+		i++;
+	}
+}
+
+playerbreathingsound( healthcap )
+{
+	self endon( "end_healthregen" );
+	wait 2;
+	player = self;
+	for ( ;; )
+	{
+		wait 0,2;
+		if ( player.health <= 0 )
+		{
+			return;
+		}
+		if ( player.health >= healthcap )
+		{
+			continue;
+		}
+		else if ( level.healthregendisabled && getTime() > player.breathingstoptime )
+		{
+			continue;
+		}
+		else
+		{
+			player notify( "snd_breathing_hurt" );
+			wait 0,784;
+			wait ( 0,1 + randomfloat( 0,8 ) );
+		}
+	}
+}
+
+playerheartbeatsound( healthcap )
+{
+	self endon( "end_healthregen" );
+	self.hearbeatwait = 0,2;
+	wait 2;
+	player = self;
+	for ( ;; )
+	{
+		wait 0,2;
+		if ( player.health <= 0 )
+		{
+			return;
+		}
+		if ( player.health >= healthcap )
+		{
+			self.hearbeatwait = 0,3;
+			continue;
+		}
+		else if ( level.healthregendisabled && getTime() > player.breathingstoptime )
+		{
+			self.hearbeatwait = 0,3;
+			continue;
+		}
+		else
+		{
+			player playlocalsound( "mpl_player_heartbeat" );
+			wait self.hearbeatwait;
+			if ( self.hearbeatwait <= 0,6 )
+			{
+				self.hearbeatwait += 0,1;
+			}
+		}
+	}
+}

patch_zm/maps/mp/gametypes_zm/_hostmigration.gsc

@@ -0,0 +1,546 @@
+#include maps/mp/zombies/_zm;
+#include maps/mp/gametypes_zm/_hud;
+#include maps/mp/zombies/_zm_utility;
+#include maps/mp/gametypes_zm/_hud_util;
+#include common_scripts/utility;
+#include maps/mp/_utility;
+
+debug_script_structs()
+{
+/#
+	if ( isDefined( level.struct ) )
+	{
+		println( "*** Num structs " + level.struct.size );
+		println( "" );
+		i = 0;
+		while ( i < level.struct.size )
+		{
+			struct = level.struct[ i ];
+			if ( isDefined( struct.targetname ) )
+			{
+				println( "---" + i + " : " + struct.targetname );
+				i++;
+				continue;
+			}
+			else
+			{
+				println( "---" + i + " : " + "NONE" );
+			}
+			i++;
+		}
+	}
+	else println( "*** No structs defined." );
+#/
+}
+
+updatetimerpausedness()
+{
+	shouldbestopped = isDefined( level.hostmigrationtimer );
+	if ( !level.timerstopped && shouldbestopped )
+	{
+		level.timerstopped = 1;
+		level.timerpausetime = getTime();
+	}
+	else
+	{
+		if ( level.timerstopped && !shouldbestopped )
+		{
+			level.timerstopped = 0;
+			level.discardtime += getTime() - level.timerpausetime;
+		}
+	}
+}
+
+callback_hostmigrationsave()
+{
+}
+
+callback_prehostmigrationsave()
+{
+	undo_link_changes();
+	disablezombies( 1 );
+	if ( is_true( level._hm_should_pause_spawning ) )
+	{
+		flag_set( "spawn_zombies" );
+	}
+	i = 0;
+	while ( i < level.players.size )
+	{
+		level.players[ i ] enableinvulnerability();
+		i++;
+	}
+}
+
+pausetimer()
+{
+	level.migrationtimerpausetime = getTime();
+}
+
+resumetimer()
+{
+	level.discardtime += getTime() - level.migrationtimerpausetime;
+}
+
+locktimer()
+{
+	level endon( "host_migration_begin" );
+	level endon( "host_migration_end" );
+	for ( ;; )
+	{
+		currtime = getTime();
+		wait 0,05;
+		if ( !level.timerstopped && isDefined( level.discardtime ) )
+		{
+			level.discardtime += getTime() - currtime;
+		}
+	}
+}
+
+callback_hostmigration()
+{
+	redo_link_changes();
+	setslowmotion( 1, 1, 0 );
+	makedvarserverinfo( "ui_guncycle", 0 );
+	level.hostmigrationreturnedplayercount = 0;
+	if ( level.gameended )
+	{
+/#
+		println( "Migration starting at time " + getTime() + ", but game has ended, so no countdown." );
+#/
+		return;
+	}
+	sethostmigrationstatus( 1 );
+	level notify( "host_migration_begin" );
+	i = 0;
+	while ( i < level.players.size )
+	{
+		if ( isDefined( level.hostmigration_link_entity_callback ) )
+		{
+			if ( !isDefined( level.players[ i ]._host_migration_link_entity ) )
+			{
+				level.players[ i ]._host_migration_link_entity = level.players[ i ] [[ level.hostmigration_link_entity_callback ]]();
+			}
+		}
+		level.players[ i ] thread hostmigrationtimerthink();
+		i++;
+	}
+	while ( isDefined( level.hostmigration_ai_link_entity_callback ) )
+	{
+		zombies = getaiarray( level.zombie_team );
+		while ( isDefined( zombies ) && zombies.size > 0 )
+		{
+			_a133 = zombies;
+			_k133 = getFirstArrayKey( _a133 );
+			while ( isDefined( _k133 ) )
+			{
+				zombie = _a133[ _k133 ];
+				if ( !isDefined( zombie._host_migration_link_entity ) )
+				{
+					zombie._host_migration_link_entity = zombie [[ level.hostmigration_ai_link_entity_callback ]]();
+				}
+				_k133 = getNextArrayKey( _a133, _k133 );
+			}
+		}
+	}
+	if ( level.inprematchperiod )
+	{
+		level waittill( "prematch_over" );
+	}
+/#
+	println( "Migration starting at time " + getTime() );
+#/
+	level.hostmigrationtimer = 1;
+	thread locktimer();
+	zombies = getaiarray( level.zombie_team );
+	while ( isDefined( zombies ) && zombies.size > 0 )
+	{
+		_a156 = zombies;
+		_k156 = getFirstArrayKey( _a156 );
+		while ( isDefined( _k156 ) )
+		{
+			zombie = _a156[ _k156 ];
+			if ( isDefined( zombie._host_migration_link_entity ) )
+			{
+				ent = spawn( "script_origin", zombie.origin );
+				ent.angles = zombie.angles;
+				zombie linkto( ent );
+				ent linkto( zombie._host_migration_link_entity, "tag_origin", zombie._host_migration_link_entity worldtolocalcoords( ent.origin ), ent.angles + zombie._host_migration_link_entity.angles );
+				zombie._host_migration_link_helper = ent;
+				zombie linkto( zombie._host_migration_link_helper );
+			}
+			_k156 = getNextArrayKey( _a156, _k156 );
+		}
+	}
+	level endon( "host_migration_begin" );
+	level._hm_should_pause_spawning = flag( "spawn_zombies" );
+	if ( level._hm_should_pause_spawning )
+	{
+		flag_clear( "spawn_zombies" );
+	}
+	hostmigrationwait();
+	_a185 = level.players;
+	_k185 = getFirstArrayKey( _a185 );
+	while ( isDefined( _k185 ) )
+	{
+		player = _a185[ _k185 ];
+		player thread post_migration_become_vulnerable();
+		_k185 = getNextArrayKey( _a185, _k185 );
+	}
+	zombies = getaiarray( level.zombie_team );
+	while ( isDefined( zombies ) && zombies.size > 0 )
+	{
+		_a193 = zombies;
+		_k193 = getFirstArrayKey( _a193 );
+		while ( isDefined( _k193 ) )
+		{
+			zombie = _a193[ _k193 ];
+			if ( isDefined( zombie._host_migration_link_entity ) )
+			{
+				zombie unlink();
+				zombie._host_migration_link_helper delete();
+				zombie._host_migration_link_helper = undefined;
+				zombie._host_migration_link_entity = undefined;
+			}
+			_k193 = getNextArrayKey( _a193, _k193 );
+		}
+	}
+	enablezombies( 1 );
+	if ( level._hm_should_pause_spawning )
+	{
+		flag_set( "spawn_zombies" );
+	}
+	level.hostmigrationtimer = undefined;
+	level._hm_should_pause_spawning = undefined;
+	sethostmigrationstatus( 0 );
+/#
+	println( "Migration finished at time " + getTime() );
+#/
+	level notify( "host_migration_end" );
+}
+
+post_migration_become_vulnerable()
+{
+	self endon( "disconnect" );
+	wait 3;
+	self disableinvulnerability();
+}
+
+matchstarttimerconsole_internal( counttime, matchstarttimer )
+{
+	waittillframeend;
+	level endon( "match_start_timer_beginning" );
+	while ( counttime > 0 && !level.gameended )
+	{
+		matchstarttimer thread maps/mp/gametypes_zm/_hud::fontpulse( level );
+		wait ( matchstarttimer.inframes * 0,05 );
+		matchstarttimer setvalue( counttime );
+		counttime--;
+
+		wait ( 1 - ( matchstarttimer.inframes * 0,05 ) );
+	}
+}
+
+matchstarttimerconsole( type, duration )
+{
+	level notify( "match_start_timer_beginning" );
+	wait 0,05;
+	matchstarttext = createserverfontstring( "objective", 1,5 );
+	matchstarttext setpoint( "CENTER", "CENTER", 0, -40 );
+	matchstarttext.sort = 1001;
+	matchstarttext settext( game[ "strings" ][ "waiting_for_teams" ] );
+	matchstarttext.foreground = 0;
+	matchstarttext.hidewheninmenu = 1;
+	matchstarttext settext( game[ "strings" ][ type ] );
+	matchstarttimer = createserverfontstring( "objective", 2,2 );
+	matchstarttimer setpoint( "CENTER", "CENTER", 0, 0 );
+	matchstarttimer.sort = 1001;
+	matchstarttimer.color = ( 1, 1, 0 );
+	matchstarttimer.foreground = 0;
+	matchstarttimer.hidewheninmenu = 1;
+	matchstarttimer maps/mp/gametypes_zm/_hud::fontpulseinit();
+	counttime = int( duration );
+	if ( counttime >= 2 )
+	{
+		matchstarttimerconsole_internal( counttime, matchstarttimer );
+	}
+	matchstarttimer destroyelem();
+	matchstarttext destroyelem();
+}
+
+hostmigrationwait()
+{
+	level endon( "game_ended" );
+	if ( level.hostmigrationreturnedplayercount < ( ( level.players.size * 2 ) / 3 ) )
+	{
+		thread matchstarttimerconsole( "waiting_for_teams", 20 );
+		hostmigrationwaitforplayers();
+	}
+	thread matchstarttimerconsole( "match_starting_in", 5 );
+	wait 5;
+}
+
+hostmigrationwaitforplayers()
+{
+	level endon( "hostmigration_enoughplayers" );
+	wait 15;
+}
+
+hostmigrationtimerthink_internal()
+{
+	level endon( "host_migration_begin" );
+	level endon( "host_migration_end" );
+	self.hostmigrationcontrolsfrozen = 0;
+	while ( !isalive( self ) )
+	{
+		self waittill( "spawned" );
+	}
+	if ( isDefined( self._host_migration_link_entity ) )
+	{
+		ent = spawn( "script_origin", self.origin );
+		ent.angles = self.angles;
+		self linkto( ent );
+		ent linkto( self._host_migration_link_entity, "tag_origin", self._host_migration_link_entity worldtolocalcoords( ent.origin ), ent.angles + self._host_migration_link_entity.angles );
+		self._host_migration_link_helper = ent;
+/#
+		println( "Linking player to ent " + self._host_migration_link_entity.targetname );
+#/
+	}
+	self.hostmigrationcontrolsfrozen = 1;
+	self freezecontrols( 1 );
+	level waittill( "host_migration_end" );
+}
+
+hostmigrationtimerthink()
+{
+	self endon( "disconnect" );
+	level endon( "host_migration_begin" );
+	hostmigrationtimerthink_internal();
+	if ( self.hostmigrationcontrolsfrozen )
+	{
+		self freezecontrols( 0 );
+		self.hostmigrationcontrolsfrozen = 0;
+/#
+		println( " Host migration unfreeze controls" );
+#/
+	}
+	if ( isDefined( self._host_migration_link_entity ) )
+	{
+		self unlink();
+		self._host_migration_link_helper delete();
+		self._host_migration_link_helper = undefined;
+		if ( isDefined( self._host_migration_link_entity._post_host_migration_thread ) )
+		{
+			self thread [[ self._host_migration_link_entity._post_host_migration_thread ]]( self._host_migration_link_entity );
+		}
+		self._host_migration_link_entity = undefined;
+	}
+}
+
+waittillhostmigrationdone()
+{
+	if ( !isDefined( level.hostmigrationtimer ) )
+	{
+		return 0;
+	}
+	starttime = getTime();
+	level waittill( "host_migration_end" );
+	return getTime() - starttime;
+}
+
+waittillhostmigrationstarts( duration )
+{
+	if ( isDefined( level.hostmigrationtimer ) )
+	{
+		return;
+	}
+	level endon( "host_migration_begin" );
+	wait duration;
+}
+
+waitlongdurationwithhostmigrationpause( duration )
+{
+	if ( duration == 0 )
+	{
+		return;
+	}
+/#
+	assert( duration > 0 );
+#/
+	starttime = getTime();
+	endtime = getTime() + ( duration * 1000 );
+	while ( getTime() < endtime )
+	{
+		waittillhostmigrationstarts( ( endtime - getTime() ) / 1000 );
+		if ( isDefined( level.hostmigrationtimer ) )
+		{
+			timepassed = waittillhostmigrationdone();
+			endtime += timepassed;
+		}
+	}
+	if ( getTime() != endtime )
+	{
+/#
+		println( "SCRIPT WARNING: gettime() = " + getTime() + " NOT EQUAL TO endtime = " + endtime );
+#/
+	}
+	waittillhostmigrationdone();
+	return getTime() - starttime;
+}
+
+waitlongdurationwithgameendtimeupdate( duration )
+{
+	if ( duration == 0 )
+	{
+		return;
+	}
+/#
+	assert( duration > 0 );
+#/
+	starttime = getTime();
+	endtime = getTime() + ( duration * 1000 );
+	while ( getTime() < endtime )
+	{
+		waittillhostmigrationstarts( ( endtime - getTime() ) / 1000 );
+		while ( isDefined( level.hostmigrationtimer ) )
+		{
+			endtime += 1000;
+			setgameendtime( int( endtime ) );
+			wait 1;
+		}
+	}
+/#
+	if ( getTime() != endtime )
+	{
+		println( "SCRIPT WARNING: gettime() = " + getTime() + " NOT EQUAL TO endtime = " + endtime );
+#/
+	}
+	while ( isDefined( level.hostmigrationtimer ) )
+	{
+		endtime += 1000;
+		setgameendtime( int( endtime ) );
+		wait 1;
+	}
+	return getTime() - starttime;
+}
+
+find_alternate_player_place( v_origin, min_radius, max_radius, max_height, ignore_targetted_nodes )
+{
+	found_node = undefined;
+	a_nodes = getnodesinradiussorted( v_origin, max_radius, min_radius, max_height, "pathnodes" );
+	while ( isDefined( a_nodes ) && a_nodes.size > 0 )
+	{
+		a_player_volumes = getentarray( "player_volume", "script_noteworthy" );
+		index = a_nodes.size - 1;
+		i = index;
+		while ( i >= 0 )
+		{
+			n_node = a_nodes[ i ];
+			if ( ignore_targetted_nodes == 1 )
+			{
+				if ( isDefined( n_node.target ) )
+				{
+					i--;
+					continue;
+				}
+			}
+			else
+			{
+				if ( !positionwouldtelefrag( n_node.origin ) )
+				{
+					if ( maps/mp/zombies/_zm_utility::check_point_in_enabled_zone( n_node.origin, 1, a_player_volumes ) )
+					{
+						v_start = ( n_node.origin[ 0 ], n_node.origin[ 1 ], n_node.origin[ 2 ] + 30 );
+						v_end = ( n_node.origin[ 0 ], n_node.origin[ 1 ], n_node.origin[ 2 ] - 30 );
+						trace = bullettrace( v_start, v_end, 0, undefined );
+						if ( trace[ "fraction" ] < 1 )
+						{
+							override_abort = 0;
+							if ( isDefined( level._chugabud_reject_node_override_func ) )
+							{
+								override_abort = [[ level._chugabud_reject_node_override_func ]]( v_origin, n_node );
+							}
+							if ( !override_abort )
+							{
+								found_node = n_node;
+								break;
+							}
+						}
+					}
+				}
+			}
+			else
+			{
+				i--;
+
+			}
+		}
+	}
+	return found_node;
+}
+
+hostmigration_put_player_in_better_place()
+{
+	spawnpoint = undefined;
+	spawnpoint = find_alternate_player_place( self.origin, 50, 150, 64, 1 );
+	if ( !isDefined( spawnpoint ) )
+	{
+		spawnpoint = find_alternate_player_place( self.origin, 150, 400, 64, 1 );
+	}
+	if ( !isDefined( spawnpoint ) )
+	{
+		spawnpoint = find_alternate_player_place( self.origin, 50, 400, 256, 0 );
+	}
+	if ( !isDefined( spawnpoint ) )
+	{
+		spawnpoint = maps/mp/zombies/_zm::check_for_valid_spawn_near_team( self, 1 );
+	}
+	if ( !isDefined( spawnpoint ) )
+	{
+		match_string = "";
+		location = level.scr_zm_map_start_location;
+		if ( location != "default" && location == "" && isDefined( level.default_start_location ) )
+		{
+			location = level.default_start_location;
+		}
+		match_string = ( level.scr_zm_ui_gametype + "_" ) + location;
+		spawnpoints = [];
+		structs = getstructarray( "initial_spawn", "script_noteworthy" );
+		while ( isDefined( structs ) )
+		{
+			_a559 = structs;
+			_k559 = getFirstArrayKey( _a559 );
+			while ( isDefined( _k559 ) )
+			{
+				struct = _a559[ _k559 ];
+				while ( isDefined( struct.script_string ) )
+				{
+					tokens = strtok( struct.script_string, " " );
+					_a565 = tokens;
+					_k565 = getFirstArrayKey( _a565 );
+					while ( isDefined( _k565 ) )
+					{
+						token = _a565[ _k565 ];
+						if ( token == match_string )
+						{
+							spawnpoints[ spawnpoints.size ] = struct;
+						}
+						_k565 = getNextArrayKey( _a565, _k565 );
+					}
+				}
+				_k559 = getNextArrayKey( _a559, _k559 );
+			}
+		}
+		if ( !isDefined( spawnpoints ) || spawnpoints.size == 0 )
+		{
+			spawnpoints = getstructarray( "initial_spawn_points", "targetname" );
+		}
+/#
+		assert( isDefined( spawnpoints ), "Could not find initial spawn points!" );
+#/
+		spawnpoint = maps/mp/zombies/_zm::getfreespawnpoint( spawnpoints, self );
+	}
+	if ( isDefined( spawnpoint ) )
+	{
+		self setorigin( spawnpoint.origin );
+	}
+}

patch_zm/maps/mp/gametypes_zm/_hud.gsc

@@ -0,0 +1,167 @@
+
+init()
+{
+	precacheshader( "progress_bar_bg" );
+	precacheshader( "progress_bar_fg" );
+	precacheshader( "progress_bar_fill" );
+	precacheshader( "score_bar_bg" );
+	level.uiparent = spawnstruct();
+	level.uiparent.horzalign = "left";
+	level.uiparent.vertalign = "top";
+	level.uiparent.alignx = "left";
+	level.uiparent.aligny = "top";
+	level.uiparent.x = 0;
+	level.uiparent.y = 0;
+	level.uiparent.width = 0;
+	level.uiparent.height = 0;
+	level.uiparent.children = [];
+	level.fontheight = 12;
+	_a103 = level.teams;
+	_k103 = getFirstArrayKey( _a103 );
+	while ( isDefined( _k103 ) )
+	{
+		team = _a103[ _k103 ];
+		level.hud[ team ] = spawnstruct();
+		_k103 = getNextArrayKey( _a103, _k103 );
+	}
+	level.primaryprogressbary = -61;
+	level.primaryprogressbarx = 0;
+	level.primaryprogressbarheight = 9;
+	level.primaryprogressbarwidth = 120;
+	level.primaryprogressbartexty = -75;
+	level.primaryprogressbartextx = 0;
+	level.primaryprogressbarfontsize = 1,4;
+	level.primaryprogressbarx_ss = 20;
+	level.primaryprogressbartextx_ss = 20;
+	level.primaryprogressbary_ss = 30;
+	level.primaryprogressbartexty_ss = 33;
+	level.primaryprogressbarheight_ss = 2;
+	level.secondaryprogressbary = -85;
+	level.secondaryprogressbarx = 0;
+	level.secondaryprogressbarheight = 9;
+	level.secondaryprogressbarwidth = 120;
+	level.secondaryprogressbartexty = -100;
+	level.secondaryprogressbartextx = 0;
+	level.secondaryprogressbarfontsize = 1,4;
+	level.secondaryprogressbarx_ss = 20;
+	level.secondaryprogressbartextx_ss = 20;
+	level.secondaryprogressbary_ss = 15;
+	level.secondaryprogressbartexty_ss = 0;
+	level.secondaryprogressbarheight_ss = 2;
+	level.teamprogressbary = 32;
+	level.teamprogressbarheight = 14;
+	level.teamprogressbarwidth = 192;
+	level.teamprogressbartexty = 8;
+	level.teamprogressbarfontsize = 1,65;
+	setdvar( "ui_generic_status_bar", 0 );
+	level.lowertextyalign = "BOTTOM";
+	level.lowertexty = -42;
+	level.lowertextfontsize = 1,4;
+	level.lowertextyalign_ss = "CENTER";
+	level.lowertexty_ss = 40;
+	level.lowertextfontsize_ss = 1,4;
+}
+
+fontpulseinit()
+{
+	self.basefontscale = self.fontscale;
+	self.maxfontscale = self.fontscale * 2;
+	self.inframes = 1,5;
+	self.outframes = 3;
+}
+
+fontpulse( player )
+{
+	self notify( "fontPulse" );
+	self endon( "fontPulse" );
+	self endon( "death" );
+	player endon( "disconnect" );
+	player endon( "joined_team" );
+	player endon( "joined_spectators" );
+	if ( self.outframes == 0 )
+	{
+		self.fontscale = 0,01;
+	}
+	else
+	{
+		self.fontscale = self.fontscale;
+	}
+	if ( self.inframes > 0 )
+	{
+		self changefontscaleovertime( self.inframes * 0,05 );
+		self.fontscale = self.maxfontscale;
+		wait ( self.inframes * 0,05 );
+	}
+	else
+	{
+		self.fontscale = self.maxfontscale;
+		self.alpha = 0;
+		self fadeovertime( self.outframes * 0,05 );
+		self.alpha = 1;
+	}
+	if ( self.outframes > 0 )
+	{
+		self changefontscaleovertime( self.outframes * 0,05 );
+		self.fontscale = self.basefontscale;
+	}
+}
+
+fadetoblackforxsec( startwait, blackscreenwait, fadeintime, fadeouttime, shadername, n_sort )
+{
+	if ( !isDefined( n_sort ) )
+	{
+		n_sort = 50;
+	}
+	wait startwait;
+	if ( !isDefined( self ) )
+	{
+		return;
+	}
+	if ( !isDefined( self.blackscreen ) )
+	{
+		self.blackscreen = newclienthudelem( self );
+	}
+	self.blackscreen.x = 0;
+	self.blackscreen.y = 0;
+	self.blackscreen.horzalign = "fullscreen";
+	self.blackscreen.vertalign = "fullscreen";
+	self.blackscreen.foreground = 0;
+	self.blackscreen.hidewhendead = 0;
+	self.blackscreen.hidewheninmenu = 1;
+	self.blackscreen.sort = n_sort;
+	if ( isDefined( shadername ) )
+	{
+		self.blackscreen setshader( shadername, 640, 480 );
+	}
+	else
+	{
+		self.blackscreen setshader( "black", 640, 480 );
+	}
+	self.blackscreen.alpha = 0;
+	if ( fadeintime > 0 )
+	{
+		self.blackscreen fadeovertime( fadeintime );
+	}
+	self.blackscreen.alpha = 1;
+	wait fadeintime;
+	if ( !isDefined( self.blackscreen ) )
+	{
+		return;
+	}
+	wait blackscreenwait;
+	if ( !isDefined( self.blackscreen ) )
+	{
+		return;
+	}
+	if ( fadeouttime > 0 )
+	{
+		self.blackscreen fadeovertime( fadeouttime );
+	}
+	self.blackscreen.alpha = 0;
+	wait fadeouttime;
+	if ( isDefined( self.blackscreen ) )
+	{
+		self.blackscreen destroy();
+		self.blackscreen = undefined;
+	}
+}

patch_zm/maps/mp/gametypes_zm/_menus.gsc

@@ -0,0 +1,175 @@
+#include maps/mp/gametypes_zm/_rank;
+#include maps/mp/gametypes_zm/_globallogic;
+#include maps/mp/_utility;
+
+init()
+{
+	precachestring( &"open_ingame_menu" );
+	game[ "menu_team" ] = "team_marinesopfor";
+	game[ "menu_initteam_allies" ] = "initteam_marines";
+	game[ "menu_initteam_axis" ] = "initteam_opfor";
+	game[ "menu_class" ] = "class";
+	game[ "menu_changeclass" ] = "changeclass";
+	game[ "menu_changeclass_offline" ] = "changeclass";
+	game[ "menu_wager_side_bet" ] = "sidebet";
+	game[ "menu_wager_side_bet_player" ] = "sidebet_player";
+	game[ "menu_changeclass_wager" ] = "changeclass_wager";
+	game[ "menu_changeclass_custom" ] = "changeclass_custom";
+	game[ "menu_changeclass_barebones" ] = "changeclass_barebones";
+	_a18 = level.teams;
+	_k18 = getFirstArrayKey( _a18 );
+	while ( isDefined( _k18 ) )
+	{
+		team = _a18[ _k18 ];
+		game[ "menu_changeclass_" + team ] = "changeclass";
+		_k18 = getNextArrayKey( _a18, _k18 );
+	}
+	game[ "menu_controls" ] = "ingame_controls";
+	game[ "menu_options" ] = "ingame_options";
+	game[ "menu_leavegame" ] = "popup_leavegame";
+	precachemenu( game[ "menu_controls" ] );
+	precachemenu( game[ "menu_options" ] );
+	precachemenu( game[ "menu_leavegame" ] );
+	precachemenu( "scoreboard" );
+	precachemenu( "spectate" );
+	precachemenu( game[ "menu_team" ] );
+	precachemenu( game[ "menu_changeclass_allies" ] );
+	precachemenu( game[ "menu_initteam_allies" ] );
+	precachemenu( game[ "menu_changeclass_axis" ] );
+	precachemenu( game[ "menu_class" ] );
+	precachemenu( game[ "menu_changeclass" ] );
+	precachemenu( game[ "menu_initteam_axis" ] );
+	precachemenu( game[ "menu_changeclass_offline" ] );
+	precachemenu( game[ "menu_changeclass_wager" ] );
+	precachemenu( game[ "menu_changeclass_custom" ] );
+	precachemenu( game[ "menu_changeclass_barebones" ] );
+	precachemenu( game[ "menu_wager_side_bet" ] );
+	precachemenu( game[ "menu_wager_side_bet_player" ] );
+	precachestring( &"MP_HOST_ENDED_GAME" );
+	precachestring( &"MP_HOST_ENDGAME_RESPONSE" );
+	level thread onplayerconnect();
+}
+
+onplayerconnect()
+{
+	for ( ;; )
+	{
+		level waittill( "connecting", player );
+		player thread onmenuresponse();
+	}
+}
+
+onmenuresponse()
+{
+	self endon( "disconnect" );
+	for ( ;; )
+	{
+		self waittill( "menuresponse", menu, response );
+		if ( response == "back" )
+		{
+			self closemenu();
+			self closeingamemenu();
+			if ( level.console )
+			{
+				if ( game[ "menu_changeclass" ] != menu && game[ "menu_changeclass_offline" ] != menu || menu == game[ "menu_team" ] && menu == game[ "menu_controls" ] )
+				{
+					if ( isDefined( level.teams[ self.pers[ "team" ] ] ) )
+					{
+						self openmenu( game[ "menu_class" ] );
+					}
+				}
+			}
+			continue;
+		}
+		else if ( response == "changeteam" && level.allow_teamchange == "1" )
+		{
+			self closemenu();
+			self closeingamemenu();
+			self openmenu( game[ "menu_team" ] );
+		}
+		if ( response == "changeclass_marines_splitscreen" )
+		{
+			self openmenu( "changeclass_marines_splitscreen" );
+		}
+		if ( response == "changeclass_opfor_splitscreen" )
+		{
+			self openmenu( "changeclass_opfor_splitscreen" );
+		}
+		if ( response == "endgame" )
+		{
+			if ( self issplitscreen() )
+			{
+				level.skipvote = 1;
+				if ( !level.gameended )
+				{
+					level thread maps/mp/gametypes_zm/_globallogic::forceend();
+				}
+			}
+			continue;
+		}
+		else if ( response == "killserverpc" )
+		{
+			level thread maps/mp/gametypes_zm/_globallogic::killserverpc();
+			continue;
+		}
+		else if ( response == "endround" )
+		{
+			if ( !level.gameended )
+			{
+				level thread maps/mp/gametypes_zm/_globallogic::forceend();
+			}
+			else
+			{
+				self closemenu();
+				self closeingamemenu();
+				self iprintln( &"MP_HOST_ENDGAME_RESPONSE" );
+			}
+			continue;
+		}
+		else if ( menu == game[ "menu_team" ] && level.allow_teamchange == "1" )
+		{
+			switch( response )
+			{
+				case "autoassign":
+					self [[ level.autoassign ]]( 1 );
+					break;
+				case "spectator":
+					self [[ level.spectator ]]();
+					break;
+				default:
+					self [[ level.teammenu ]]( response );
+					break;
+			}
+			continue;
+		}
+		else
+		{
+			if ( game[ "menu_changeclass" ] != menu && game[ "menu_changeclass_offline" ] != menu && game[ "menu_changeclass_wager" ] != menu || menu == game[ "menu_changeclass_custom" ] && menu == game[ "menu_changeclass_barebones" ] )
+			{
+				self closemenu();
+				self closeingamemenu();
+				if ( level.rankedmatch && issubstr( response, "custom" ) )
+				{
+					if ( self isitemlocked( maps/mp/gametypes_zm/_rank::getitemindex( "feature_cac" ) ) )
+					{
+						kick( self getentitynumber() );
+					}
+				}
+				self.selectedclass = 1;
+				self [[ level.class ]]( response );
+				break;
+			}
+			else
+			{
+				if ( menu == "spectate" )
+				{
+					player = getplayerfromclientnum( int( response ) );
+					if ( isDefined( player ) )
+					{
+						self setcurrentspectatorclient( player );
+					}
+				}
+			}
+		}
+	}
+}

patch_zm/maps/mp/gametypes_zm/_perplayer.gsc

@@ -0,0 +1,196 @@
+#include maps/mp/_utility;
+
+init( id, playerbegincallback, playerendcallback )
+{
+	precacheshader( "objpoint_default" );
+	handler = spawnstruct();
+	handler.id = id;
+	handler.playerbegincallback = playerbegincallback;
+	handler.playerendcallback = playerendcallback;
+	handler.enabled = 0;
+	handler.players = [];
+	thread onplayerconnect( handler );
+	level.handlerglobalflagval = 0;
+	return handler;
+}
+
+enable( handler )
+{
+	if ( handler.enabled )
+	{
+		return;
+	}
+	handler.enabled = 1;
+	level.handlerglobalflagval++;
+	players = get_players();
+	i = 0;
+	while ( i < players.size )
+	{
+		players[ i ].handlerflagval = level.handlerglobalflagval;
+		i++;
+	}
+	players = handler.players;
+	i = 0;
+	while ( i < players.size )
+	{
+		if ( players[ i ].handlerflagval != level.handlerglobalflagval )
+		{
+			i++;
+			continue;
+		}
+		else
+		{
+			if ( players[ i ].handlers[ handler.id ].ready )
+			{
+				players[ i ] handleplayer( handler );
+			}
+		}
+		i++;
+	}
+}
+
+disable( handler )
+{
+	if ( !handler.enabled )
+	{
+		return;
+	}
+	handler.enabled = 0;
+	level.handlerglobalflagval++;
+	players = get_players();
+	i = 0;
+	while ( i < players.size )
+	{
+		players[ i ].handlerflagval = level.handlerglobalflagval;
+		i++;
+	}
+	players = handler.players;
+	i = 0;
+	while ( i < players.size )
+	{
+		if ( players[ i ].handlerflagval != level.handlerglobalflagval )
+		{
+			i++;
+			continue;
+		}
+		else
+		{
+			if ( players[ i ].handlers[ handler.id ].ready )
+			{
+				players[ i ] unhandleplayer( handler, 0, 0 );
+			}
+		}
+		i++;
+	}
+}
+
+onplayerconnect( handler )
+{
+	for ( ;; )
+	{
+		level waittill( "connecting", player );
+		if ( !isDefined( player.handlers ) )
+		{
+			player.handlers = [];
+		}
+		player.handlers[ handler.id ] = spawnstruct();
+		player.handlers[ handler.id ].ready = 0;
+		player.handlers[ handler.id ].handled = 0;
+		player.handlerflagval = -1;
+		handler.players[ handler.players.size ] = player;
+		player thread onplayerdisconnect( handler );
+		player thread onplayerspawned( handler );
+		player thread onjoinedteam( handler );
+		player thread onjoinedspectators( handler );
+		player thread onplayerkilled( handler );
+	}
+}
+
+onplayerdisconnect( handler )
+{
+	self waittill( "disconnect" );
+	newplayers = [];
+	i = 0;
+	while ( i < handler.players.size )
+	{
+		if ( handler.players[ i ] != self )
+		{
+			newplayers[ newplayers.size ] = handler.players[ i ];
+		}
+		i++;
+	}
+	handler.players = newplayers;
+	self thread unhandleplayer( handler, 1, 1 );
+}
+
+onjoinedteam( handler )
+{
+	self endon( "disconnect" );
+	for ( ;; )
+	{
+		self waittill( "joined_team" );
+		self thread unhandleplayer( handler, 1, 0 );
+	}
+}
+
+onjoinedspectators( handler )
+{
+	self endon( "disconnect" );
+	for ( ;; )
+	{
+		self waittill( "joined_spectators" );
+		self thread unhandleplayer( handler, 1, 0 );
+	}
+}
+
+onplayerspawned( handler )
+{
+	self endon( "disconnect" );
+	for ( ;; )
+	{
+		self waittill( "spawned_player" );
+		self thread handleplayer( handler );
+	}
+}
+
+onplayerkilled( handler )
+{
+	self endon( "disconnect" );
+	for ( ;; )
+	{
+		self waittill( "killed_player" );
+		self thread unhandleplayer( handler, 1, 0 );
+	}
+}
+
+handleplayer( handler )
+{
+	self.handlers[ handler.id ].ready = 1;
+	if ( !handler.enabled )
+	{
+		return;
+	}
+	if ( self.handlers[ handler.id ].handled )
+	{
+		return;
+	}
+	self.handlers[ handler.id ].handled = 1;
+	self thread [[ handler.playerbegincallback ]]();
+}
+
+unhandleplayer( handler, unsetready, disconnected )
+{
+	if ( !disconnected && unsetready )
+	{
+		self.handlers[ handler.id ].ready = 0;
+	}
+	if ( !self.handlers[ handler.id ].handled )
+	{
+		return;
+	}
+	if ( !disconnected )
+	{
+		self.handlers[ handler.id ].handled = 0;
+	}
+	self thread [[ handler.playerendcallback ]]( disconnected );
+}

patch_zm/maps/mp/gametypes_zm/_serversettings.gsc

@@ -0,0 +1,207 @@
+
+init()
+{
+	level.hostname = getDvar( "sv_hostname" );
+	if ( level.hostname == "" )
+	{
+		level.hostname = "CoDHost";
+	}
+	setdvar( "sv_hostname", level.hostname );
+	setdvar( "ui_hostname", level.hostname );
+	makedvarserverinfo( "ui_hostname", "CoDHost" );
+	level.motd = getDvar( "scr_motd" );
+	if ( level.motd == "" )
+	{
+		level.motd = "";
+	}
+	setdvar( "scr_motd", level.motd );
+	setdvar( "ui_motd", level.motd );
+	makedvarserverinfo( "ui_motd", "" );
+	level.allowvote = getDvar( "g_allowVote" );
+	if ( level.allowvote == "" )
+	{
+		level.allowvote = "1";
+	}
+	setdvar( "g_allowvote", level.allowvote );
+	setdvar( "ui_allowvote", level.allowvote );
+	makedvarserverinfo( "ui_allowvote", "1" );
+	level.allow_teamchange = "0";
+	if ( sessionmodeisprivate() || !sessionmodeisonlinegame() )
+	{
+		level.allow_teamchange = "1";
+	}
+	setdvar( "ui_allow_teamchange", level.allow_teamchange );
+	level.friendlyfire = getgametypesetting( "friendlyfiretype" );
+	setdvar( "ui_friendlyfire", level.friendlyfire );
+	makedvarserverinfo( "ui_friendlyfire", "0" );
+	if ( getDvar( "scr_mapsize" ) == "" )
+	{
+		setdvar( "scr_mapsize", "64" );
+	}
+	else if ( getDvarFloat( "scr_mapsize" ) >= 64 )
+	{
+		setdvar( "scr_mapsize", "64" );
+	}
+	else if ( getDvarFloat( "scr_mapsize" ) >= 32 )
+	{
+		setdvar( "scr_mapsize", "32" );
+	}
+	else if ( getDvarFloat( "scr_mapsize" ) >= 16 )
+	{
+		setdvar( "scr_mapsize", "16" );
+	}
+	else
+	{
+		setdvar( "scr_mapsize", "8" );
+	}
+	level.mapsize = getDvarFloat( "scr_mapsize" );
+	constraingametype( getDvar( "g_gametype" ) );
+	constrainmapsize( level.mapsize );
+	for ( ;; )
+	{
+		updateserversettings();
+		wait 5;
+	}
+}
+
+updateserversettings()
+{
+	sv_hostname = getDvar( "sv_hostname" );
+	if ( level.hostname != sv_hostname )
+	{
+		level.hostname = sv_hostname;
+		setdvar( "ui_hostname", level.hostname );
+	}
+	scr_motd = getDvar( "scr_motd" );
+	if ( level.motd != scr_motd )
+	{
+		level.motd = scr_motd;
+		setdvar( "ui_motd", level.motd );
+	}
+	g_allowvote = getDvar( "g_allowVote" );
+	if ( level.allowvote != g_allowvote )
+	{
+		level.allowvote = g_allowvote;
+		setdvar( "ui_allowvote", level.allowvote );
+	}
+	scr_friendlyfire = getgametypesetting( "friendlyfiretype" );
+	if ( level.friendlyfire != scr_friendlyfire )
+	{
+		level.friendlyfire = scr_friendlyfire;
+		setdvar( "ui_friendlyfire", level.friendlyfire );
+	}
+}
+
+constraingametype( gametype )
+{
+	entities = getentarray();
+	i = 0;
+	while ( i < entities.size )
+	{
+		entity = entities[ i ];
+		if ( gametype == "dm" )
+		{
+			if ( isDefined( entity.script_gametype_dm ) && entity.script_gametype_dm != "1" )
+			{
+				entity delete();
+			}
+			i++;
+			continue;
+		}
+		else if ( gametype == "tdm" )
+		{
+			if ( isDefined( entity.script_gametype_tdm ) && entity.script_gametype_tdm != "1" )
+			{
+				entity delete();
+			}
+			i++;
+			continue;
+		}
+		else if ( gametype == "ctf" )
+		{
+			if ( isDefined( entity.script_gametype_ctf ) && entity.script_gametype_ctf != "1" )
+			{
+				entity delete();
+			}
+			i++;
+			continue;
+		}
+		else if ( gametype == "hq" )
+		{
+			if ( isDefined( entity.script_gametype_hq ) && entity.script_gametype_hq != "1" )
+			{
+				entity delete();
+			}
+			i++;
+			continue;
+		}
+		else if ( gametype == "sd" )
+		{
+			if ( isDefined( entity.script_gametype_sd ) && entity.script_gametype_sd != "1" )
+			{
+				entity delete();
+			}
+			i++;
+			continue;
+		}
+		else
+		{
+			if ( gametype == "koth" )
+			{
+				if ( isDefined( entity.script_gametype_koth ) && entity.script_gametype_koth != "1" )
+				{
+					entity delete();
+				}
+			}
+		}
+		i++;
+	}
+}
+
+constrainmapsize( mapsize )
+{
+	entities = getentarray();
+	i = 0;
+	while ( i < entities.size )
+	{
+		entity = entities[ i ];
+		if ( int( mapsize ) == 8 )
+		{
+			if ( isDefined( entity.script_mapsize_08 ) && entity.script_mapsize_08 != "1" )
+			{
+				entity delete();
+			}
+			i++;
+			continue;
+		}
+		else if ( int( mapsize ) == 16 )
+		{
+			if ( isDefined( entity.script_mapsize_16 ) && entity.script_mapsize_16 != "1" )
+			{
+				entity delete();
+			}
+			i++;
+			continue;
+		}
+		else if ( int( mapsize ) == 32 )
+		{
+			if ( isDefined( entity.script_mapsize_32 ) && entity.script_mapsize_32 != "1" )
+			{
+				entity delete();
+			}
+			i++;
+			continue;
+		}
+		else
+		{
+			if ( int( mapsize ) == 64 )
+			{
+				if ( isDefined( entity.script_mapsize_64 ) && entity.script_mapsize_64 != "1" )
+				{
+					entity delete();
+				}
+			}
+		}
+		i++;
+	}
+}

patch_zm/maps/mp/gametypes_zm/_spectating.gsc

@@ -0,0 +1,276 @@
+
+init()
+{
+	_a3 = level.teams;
+	_k3 = getFirstArrayKey( _a3 );
+	while ( isDefined( _k3 ) )
+	{
+		team = _a3[ _k3 ];
+		level.spectateoverride[ team ] = spawnstruct();
+		_k3 = getNextArrayKey( _a3, _k3 );
+	}
+	level thread onplayerconnect();
+}
+
+onplayerconnect()
+{
+	for ( ;; )
+	{
+		level waittill( "connecting", player );
+		player thread onjoinedteam();
+		player thread onjoinedspectators();
+		player thread onplayerspawned();
+	}
+}
+
+onplayerspawned()
+{
+	self endon( "disconnect" );
+	for ( ;; )
+	{
+		self waittill( "spawned_player" );
+		self setspectatepermissions();
+	}
+}
+
+onjoinedteam()
+{
+	self endon( "disconnect" );
+	for ( ;; )
+	{
+		self waittill( "joined_team" );
+		self setspectatepermissionsformachine();
+	}
+}
+
+onjoinedspectators()
+{
+	self endon( "disconnect" );
+	for ( ;; )
+	{
+		self waittill( "joined_spectators" );
+		self setspectatepermissionsformachine();
+	}
+}
+
+updatespectatesettings()
+{
+	level endon( "game_ended" );
+	index = 0;
+	while ( index < level.players.size )
+	{
+		level.players[ index ] setspectatepermissions();
+		index++;
+	}
+}
+
+getsplitscreenteam()
+{
+	index = 0;
+	while ( index < level.players.size )
+	{
+		if ( !isDefined( level.players[ index ] ) )
+		{
+			index++;
+			continue;
+		}
+		else if ( level.players[ index ] == self )
+		{
+			index++;
+			continue;
+		}
+		else if ( !self isplayeronsamemachine( level.players[ index ] ) )
+		{
+			index++;
+			continue;
+		}
+		else
+		{
+			team = level.players[ index ].sessionteam;
+			if ( team != "spectator" )
+			{
+				return team;
+			}
+		}
+		index++;
+	}
+	return self.sessionteam;
+}
+
+otherlocalplayerstillalive()
+{
+	index = 0;
+	while ( index < level.players.size )
+	{
+		if ( !isDefined( level.players[ index ] ) )
+		{
+			index++;
+			continue;
+		}
+		else if ( level.players[ index ] == self )
+		{
+			index++;
+			continue;
+		}
+		else if ( !self isplayeronsamemachine( level.players[ index ] ) )
+		{
+			index++;
+			continue;
+		}
+		else
+		{
+			if ( isalive( level.players[ index ] ) )
+			{
+				return 1;
+			}
+		}
+		index++;
+	}
+	return 0;
+}
+
+allowspectateallteams( allow )
+{
+	_a114 = level.teams;
+	_k114 = getFirstArrayKey( _a114 );
+	while ( isDefined( _k114 ) )
+	{
+		team = _a114[ _k114 ];
+		self allowspectateteam( team, allow );
+		_k114 = getNextArrayKey( _a114, _k114 );
+	}
+}
+
+allowspectateallteamsexceptteam( skip_team, allow )
+{
+	_a122 = level.teams;
+	_k122 = getFirstArrayKey( _a122 );
+	while ( isDefined( _k122 ) )
+	{
+		team = _a122[ _k122 ];
+		if ( team == skip_team )
+		{
+		}
+		else
+		{
+			self allowspectateteam( team, allow );
+		}
+		_k122 = getNextArrayKey( _a122, _k122 );
+	}
+}
+
+setspectatepermissions()
+{
+	team = self.sessionteam;
+	if ( team == "spectator" )
+	{
+		if ( self issplitscreen() && !level.splitscreen )
+		{
+			team = getsplitscreenteam();
+		}
+		if ( team == "spectator" )
+		{
+			self allowspectateallteams( 1 );
+			self allowspectateteam( "freelook", 0 );
+			self allowspectateteam( "none", 1 );
+			self allowspectateteam( "localplayers", 1 );
+			return;
+		}
+	}
+	spectatetype = level.spectatetype;
+	switch( spectatetype )
+	{
+		case 0:
+			self allowspectateallteams( 0 );
+			self allowspectateteam( "freelook", 0 );
+			self allowspectateteam( "none", 1 );
+			self allowspectateteam( "localplayers", 0 );
+			break;
+		case 3:
+			if ( self issplitscreen() && self otherlocalplayerstillalive() )
+			{
+				self allowspectateallteams( 0 );
+				self allowspectateteam( "none", 0 );
+				self allowspectateteam( "freelook", 0 );
+				self allowspectateteam( "localplayers", 1 );
+				break;
+		}
+		else
+		{
+			case 1:
+				if ( !level.teambased )
+				{
+					self allowspectateallteams( 1 );
+					self allowspectateteam( "none", 1 );
+					self allowspectateteam( "freelook", 0 );
+					self allowspectateteam( "localplayers", 1 );
+				}
+				else if ( isDefined( team ) && isDefined( level.teams[ team ] ) )
+				{
+					self allowspectateteam( team, 1 );
+					self allowspectateallteamsexceptteam( team, 0 );
+					self allowspectateteam( "freelook", 0 );
+					self allowspectateteam( "none", 0 );
+					self allowspectateteam( "localplayers", 1 );
+				}
+				else
+				{
+					self allowspectateallteams( 0 );
+					self allowspectateteam( "freelook", 0 );
+					self allowspectateteam( "none", 0 );
+					self allowspectateteam( "localplayers", 1 );
+				}
+				break;
+			case 2:
+				self allowspectateallteams( 1 );
+				self allowspectateteam( "freelook", 1 );
+				self allowspectateteam( "none", 1 );
+				self allowspectateteam( "localplayers", 1 );
+				break;
+		}
+	}
+	if ( isDefined( team ) && isDefined( level.teams[ team ] ) )
+	{
+		if ( isDefined( level.spectateoverride[ team ].allowfreespectate ) )
+		{
+			self allowspectateteam( "freelook", 1 );
+		}
+		if ( isDefined( level.spectateoverride[ team ].allowenemyspectate ) )
+		{
+			self allowspectateallteamsexceptteam( team, 1 );
+		}
+	}
+}
+
+setspectatepermissionsformachine()
+{
+	self setspectatepermissions();
+	if ( !self issplitscreen() )
+	{
+		return;
+	}
+	index = 0;
+	while ( index < level.players.size )
+	{
+		if ( !isDefined( level.players[ index ] ) )
+		{
+			index++;
+			continue;
+		}
+		else if ( level.players[ index ] == self )
+		{
+			index++;
+			continue;
+		}
+		else if ( !self isplayeronsamemachine( level.players[ index ] ) )
+		{
+			index++;
+			continue;
+		}
+		else
+		{
+			level.players[ index ] setspectatepermissions();
+		}
+		index++;
+	}
+}

patch_zm/maps/mp/gametypes_zm/_tweakables.gsc

@@ -0,0 +1,394 @@
+#include maps/mp/_utility;
+
+gettweakabledvarvalue( category, name )
+{
+	switch( category )
+	{
+		case "rule":
+			dvar = level.rules[ name ].dvar;
+			break;
+		case "game":
+			dvar = level.gametweaks[ name ].dvar;
+			break;
+		case "team":
+			dvar = level.teamtweaks[ name ].dvar;
+			break;
+		case "player":
+			dvar = level.playertweaks[ name ].dvar;
+			break;
+		case "class":
+			dvar = level.classtweaks[ name ].dvar;
+			break;
+		case "weapon":
+			dvar = level.weapontweaks[ name ].dvar;
+			break;
+		case "killstreak":
+			dvar = level.hardpointtweaks[ name ].dvar;
+			break;
+		case "hud":
+			dvar = level.hudtweaks[ name ].dvar;
+			break;
+		default:
+			dvar = undefined;
+			break;
+	}
+/#
+	assert( isDefined( dvar ) );
+#/
+	value = getDvarInt( dvar );
+	return value;
+}
+
+gettweakabledvar( category, name )
+{
+	switch( category )
+	{
+		case "rule":
+			value = level.rules[ name ].dvar;
+			break;
+		case "game":
+			value = level.gametweaks[ name ].dvar;
+			break;
+		case "team":
+			value = level.teamtweaks[ name ].dvar;
+			break;
+		case "player":
+			value = level.playertweaks[ name ].dvar;
+			break;
+		case "class":
+			value = level.classtweaks[ name ].dvar;
+			break;
+		case "weapon":
+			value = level.weapontweaks[ name ].dvar;
+			break;
+		case "killstreak":
+			value = level.hardpointtweaks[ name ].dvar;
+			break;
+		case "hud":
+			value = level.hudtweaks[ name ].dvar;
+			break;
+		default:
+			value = undefined;
+			break;
+	}
+/#
+	assert( isDefined( value ) );
+#/
+	return value;
+}
+
+gettweakablevalue( category, name )
+{
+	switch( category )
+	{
+		case "rule":
+			value = level.rules[ name ].value;
+			break;
+		case "game":
+			value = level.gametweaks[ name ].value;
+			break;
+		case "team":
+			value = level.teamtweaks[ name ].value;
+			break;
+		case "player":
+			value = level.playertweaks[ name ].value;
+			break;
+		case "class":
+			value = level.classtweaks[ name ].value;
+			break;
+		case "weapon":
+			value = level.weapontweaks[ name ].value;
+			break;
+		case "killstreak":
+			value = level.hardpointtweaks[ name ].value;
+			break;
+		case "hud":
+			value = level.hudtweaks[ name ].value;
+			break;
+		default:
+			value = undefined;
+			break;
+	}
+	overridedvar = "scr_" + level.gametype + "_" + category + "_" + name;
+	if ( getDvar( overridedvar ) != "" )
+	{
+		return getDvarInt( overridedvar );
+	}
+/#
+	assert( isDefined( value ) );
+#/
+	return value;
+}
+
+gettweakablelastvalue( category, name )
+{
+	switch( category )
+	{
+		case "rule":
+			value = level.rules[ name ].lastvalue;
+			break;
+		case "game":
+			value = level.gametweaks[ name ].lastvalue;
+			break;
+		case "team":
+			value = level.teamtweaks[ name ].lastvalue;
+			break;
+		case "player":
+			value = level.playertweaks[ name ].lastvalue;
+			break;
+		case "class":
+			value = level.classtweaks[ name ].lastvalue;
+			break;
+		case "weapon":
+			value = level.weapontweaks[ name ].lastvalue;
+			break;
+		case "killstreak":
+			value = level.hardpointtweaks[ name ].lastvalue;
+			break;
+		case "hud":
+			value = level.hudtweaks[ name ].lastvalue;
+			break;
+		default:
+			value = undefined;
+			break;
+	}
+/#
+	assert( isDefined( value ) );
+#/
+	return value;
+}
+
+settweakablevalue( category, name, value )
+{
+	switch( category )
+	{
+		case "rule":
+			dvar = level.rules[ name ].dvar;
+			break;
+		case "game":
+			dvar = level.gametweaks[ name ].dvar;
+			break;
+		case "team":
+			dvar = level.teamtweaks[ name ].dvar;
+			break;
+		case "player":
+			dvar = level.playertweaks[ name ].dvar;
+			break;
+		case "class":
+			dvar = level.classtweaks[ name ].dvar;
+			break;
+		case "weapon":
+			dvar = level.weapontweaks[ name ].dvar;
+			break;
+		case "killstreak":
+			dvar = level.hardpointtweaks[ name ].dvar;
+			break;
+		case "hud":
+			dvar = level.hudtweaks[ name ].dvar;
+			break;
+		default:
+			dvar = undefined;
+			break;
+	}
+	setdvar( dvar, value );
+}
+
+settweakablelastvalue( category, name, value )
+{
+	switch( category )
+	{
+		case "rule":
+			level.rules[ name ].lastvalue = value;
+			break;
+		case "game":
+			level.gametweaks[ name ].lastvalue = value;
+			break;
+		case "team":
+			level.teamtweaks[ name ].lastvalue = value;
+			break;
+		case "player":
+			level.playertweaks[ name ].lastvalue = value;
+			break;
+		case "class":
+			level.classtweaks[ name ].lastvalue = value;
+			break;
+		case "weapon":
+			level.weapontweaks[ name ].lastvalue = value;
+			break;
+		case "killstreak":
+			level.hardpointtweaks[ name ].lastvalue = value;
+			break;
+		case "hud":
+			level.hudtweaks[ name ].lastvalue = value;
+			break;
+		default:
+		}
+	}
+}
+
+registertweakable( category, name, dvar, value )
+{
+	if ( isstring( value ) )
+	{
+		if ( getDvar( dvar ) == "" )
+		{
+			setdvar( dvar, value );
+		}
+		else
+		{
+			value = getDvar( dvar );
+		}
+	}
+	else if ( getDvar( dvar ) == "" )
+	{
+		setdvar( dvar, value );
+	}
+	else
+	{
+		value = getDvarInt( dvar );
+	}
+	switch( category )
+	{
+		case "rule":
+			if ( !isDefined( level.rules[ name ] ) )
+			{
+				level.rules[ name ] = spawnstruct();
+			}
+			level.rules[ name ].value = value;
+			level.rules[ name ].lastvalue = value;
+			level.rules[ name ].dvar = dvar;
+			break;
+		case "game":
+			if ( !isDefined( level.gametweaks[ name ] ) )
+			{
+				level.gametweaks[ name ] = spawnstruct();
+			}
+			level.gametweaks[ name ].value = value;
+			level.gametweaks[ name ].lastvalue = value;
+			level.gametweaks[ name ].dvar = dvar;
+			break;
+		case "team":
+			if ( !isDefined( level.teamtweaks[ name ] ) )
+			{
+				level.teamtweaks[ name ] = spawnstruct();
+			}
+			level.teamtweaks[ name ].value = value;
+			level.teamtweaks[ name ].lastvalue = value;
+			level.teamtweaks[ name ].dvar = dvar;
+			break;
+		case "player":
+			if ( !isDefined( level.playertweaks[ name ] ) )
+			{
+				level.playertweaks[ name ] = spawnstruct();
+			}
+			level.playertweaks[ name ].value = value;
+			level.playertweaks[ name ].lastvalue = value;
+			level.playertweaks[ name ].dvar = dvar;
+			break;
+		case "class":
+			if ( !isDefined( level.classtweaks[ name ] ) )
+			{
+				level.classtweaks[ name ] = spawnstruct();
+			}
+			level.classtweaks[ name ].value = value;
+			level.classtweaks[ name ].lastvalue = value;
+			level.classtweaks[ name ].dvar = dvar;
+			break;
+		case "weapon":
+			if ( !isDefined( level.weapontweaks[ name ] ) )
+			{
+				level.weapontweaks[ name ] = spawnstruct();
+			}
+			level.weapontweaks[ name ].value = value;
+			level.weapontweaks[ name ].lastvalue = value;
+			level.weapontweaks[ name ].dvar = dvar;
+			break;
+		case "killstreak":
+			if ( !isDefined( level.hardpointtweaks[ name ] ) )
+			{
+				level.hardpointtweaks[ name ] = spawnstruct();
+			}
+			level.hardpointtweaks[ name ].value = value;
+			level.hardpointtweaks[ name ].lastvalue = value;
+			level.hardpointtweaks[ name ].dvar = dvar;
+			break;
+		case "hud":
+			if ( !isDefined( level.hudtweaks[ name ] ) )
+			{
+				level.hudtweaks[ name ] = spawnstruct();
+			}
+			level.hudtweaks[ name ].value = value;
+			level.hudtweaks[ name ].lastvalue = value;
+			level.hudtweaks[ name ].dvar = dvar;
+			break;
+	}
+}
+
+init()
+{
+	level.clienttweakables = [];
+	level.tweakablesinitialized = 1;
+	level.rules = [];
+	level.gametweaks = [];
+	level.teamtweaks = [];
+	level.playertweaks = [];
+	level.classtweaks = [];
+	level.weapontweaks = [];
+	level.hardpointtweaks = [];
+	level.hudtweaks = [];
+	registertweakable( "game", "arcadescoring", "scr_game_arcadescoring", 0 );
+	registertweakable( "game", "difficulty", "scr_game_difficulty", 1 );
+	registertweakable( "game", "pinups", "scr_game_pinups", 0 );
+	registertweakable( "team", "teamkillerplaylistbanquantum", "scr_team_teamkillerplaylistbanquantum", 0 );
+	registertweakable( "team", "teamkillerplaylistbanpenalty", "scr_team_teamkillerplaylistbanpenalty", 0 );
+	registertweakable( "player", "allowrevive", "scr_player_allowrevive", 1 );
+	registertweakable( "weapon", "allowfrag", "scr_weapon_allowfrags", 1 );
+	registertweakable( "weapon", "allowsmoke", "scr_weapon_allowsmoke", 1 );
+	registertweakable( "weapon", "allowflash", "scr_weapon_allowflash", 1 );
+	registertweakable( "weapon", "allowc4", "scr_weapon_allowc4", 1 );
+	registertweakable( "weapon", "allowsatchel", "scr_weapon_allowsatchel", 1 );
+	registertweakable( "weapon", "allowbetty", "scr_weapon_allowbetty", 1 );
+	registertweakable( "weapon", "allowrpgs", "scr_weapon_allowrpgs", 1 );
+	registertweakable( "weapon", "allowmines", "scr_weapon_allowmines", 1 );
+	registertweakable( "hud", "showobjicons", "ui_hud_showobjicons", 1 );
+	setclienttweakable( "hud", "showobjicons" );
+	registertweakable( "killstreak", "allowradar", "scr_hardpoint_allowradar", 1 );
+	registertweakable( "killstreak", "allowradardirection", "scr_hardpoint_allowradardirection", 1 );
+	registertweakable( "killstreak", "allowcounteruav", "scr_hardpoint_allowcounteruav", 1 );
+	registertweakable( "killstreak", "allowdogs", "scr_hardpoint_allowdogs", 1 );
+	registertweakable( "killstreak", "allowhelicopter_comlink", "scr_hardpoint_allowhelicopter_comlink", 1 );
+	registertweakable( "killstreak", "allowrcbomb", "scr_hardpoint_allowrcbomb", 1 );
+	registertweakable( "killstreak", "allowauto_turret", "scr_hardpoint_allowauto_turret", 1 );
+	level thread updateuitweakables();
+}
+
+setclienttweakable( category, name )
+{
+	level.clienttweakables[ level.clienttweakables.size ] = name;
+}
+
+updateuitweakables()
+{
+	for ( ;; )
+	{
+		index = 0;
+		while ( index < level.clienttweakables.size )
+		{
+			clienttweakable = level.clienttweakables[ index ];
+			curvalue = gettweakabledvarvalue( "hud", clienttweakable );
+			lastvalue = gettweakablelastvalue( "hud", clienttweakable );
+			if ( curvalue != lastvalue )
+			{
+				updateserverdvar( gettweakabledvar( "hud", clienttweakable ), curvalue );
+				settweakablelastvalue( "hud", clienttweakable, curvalue );
+			}
+			index++;
+		}
+		wait 1;
+	}
+}
+
+updateserverdvar( dvar, value )
+{
+	makedvarserverinfo( dvar, value );
+}

patch_zm/maps/mp/gametypes_zm/_weapon_utils.gsc

@@ -0,0 +1,119 @@
+#include maps/mp/_utility;
+#include common_scripts/utility;
+
+isgrenadelauncherweapon( weapon )
+{
+	if ( getsubstr( weapon, 0, 3 ) == "gl_" )
+	{
+		return 1;
+	}
+	switch( weapon )
+	{
+		case "china_lake_mp":
+		case "xm25_mp":
+			return 1;
+		default:
+			return 0;
+	}
+}
+
+isdumbrocketlauncherweapon( weapon )
+{
+	switch( weapon )
+	{
+		case "m220_tow_mp":
+		case "rpg_mp":
+			return 1;
+		default:
+			return 0;
+	}
+}
+
+isguidedrocketlauncherweapon( weapon )
+{
+	switch( weapon )
+	{
+		case "fhj18_mp":
+		case "javelin_mp":
+		case "m202_flash_mp":
+		case "m72_law_mp":
+		case "smaw_mp":
+			return 1;
+		default:
+			return 0;
+	}
+}
+
+isrocketlauncherweapon( weapon )
+{
+	if ( isdumbrocketlauncherweapon( weapon ) )
+	{
+		return 1;
+	}
+	if ( isguidedrocketlauncherweapon( weapon ) )
+	{
+		return 1;
+	}
+	return 0;
+}
+
+islauncherweapon( weapon )
+{
+	if ( isrocketlauncherweapon( weapon ) )
+	{
+		return 1;
+	}
+	if ( isgrenadelauncherweapon( weapon ) )
+	{
+		return 1;
+	}
+	return 0;
+}
+
+isreducedteamkillweapon( weapon )
+{
+	switch( weapon )
+	{
+		case "planemortar_mp":
+			return 1;
+		default:
+			return 0;
+	}
+}
+
+ishackweapon( weapon )
+{
+	return 0;
+}
+
+ispistol( weapon )
+{
+	return isDefined( level.side_arm_array[ weapon ] );
+}
+
+isflashorstunweapon( weapon )
+{
+	if ( isDefined( weapon ) )
+	{
+		switch( weapon )
+		{
+			case "concussion_grenade_mp":
+			case "flash_grenade_mp":
+			case "proximity_grenade_aoe_mp":
+			case "proximity_grenade_mp":
+				return 1;
+		}
+	}
+	return 0;
+}
+
+isflashorstundamage( weapon, meansofdeath )
+{
+	if ( isflashorstunweapon( weapon ) )
+	{
+		if ( meansofdeath != "MOD_GRENADE_SPLASH" )
+		{
+			return meansofdeath == "MOD_GAS";
+		}
+	}
+}