I've decided to start working on mp scripts

I am intending on checking both the gametypes_zm and gametypes scripts at the same time. If I am correct they should be very similar to each other so this should be killing 2 birds with 1 stone.

patch_mp/maps/mp/gametypes/_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_mp/maps/mp/gametypes/_clientids.gsc

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

patch_mp/maps/mp/gametypes/_copter.gsc

@@ -0,0 +1,811 @@
+
+init()
+{
+	level.coptermodel = "vehicle_cobra_helicopter_fly";
+	precachemodel( level.coptermodel );
+	level.copter_maxaccel = 200;
+	level.copter_maxvel = 700;
+	level.copter_rotspeed = 90;
+	level.copter_accellookahead = 2;
+	level.coptercenteroffset = vectorScale( ( 0, 0, -1 ), 72 );
+	level.coptertargetoffset = vectorScale( ( 0, 0, -1 ), 45 );
+	level.copterexplosion = loadfx( "explosions/fx_default_explosion" );
+	level.copterfinalexplosion = loadfx( "explosions/fx_large_vehicle_explosion" );
+}
+
+getabovebuildingslocation( location )
+{
+	trace = bullettrace( location + vectorScale( ( 0, 0, -1 ), 10000 ), location, 0, undefined );
+	startorigin = trace[ "position" ] + vectorScale( ( 0, 0, -1 ), 514 );
+	zpos = 0;
+	maxxpos = 13;
+	maxypos = 13;
+	xpos = 0;
+	while ( xpos < maxxpos )
+	{
+		ypos = 0;
+		while ( ypos < maxypos )
+		{
+			thisstartorigin = startorigin + ( ( ( xpos / ( maxxpos - 1 ) ) - 0,5 ) * 1024, ( ( ypos / ( maxypos - 1 ) ) - 0,5 ) * 1024, 0 );
+			thisorigin = bullettrace( thisstartorigin, thisstartorigin + vectorScale( ( 0, 0, -1 ), 10000 ), 0, undefined );
+			zpos += thisorigin[ "position" ][ 2 ];
+			ypos++;
+		}
+		xpos++;
+	}
+	zpos /= maxxpos * maxypos;
+	zpos += 850;
+	return ( location[ 0 ], location[ 1 ], zpos );
+}
+
+vectorangle( v1, v2 )
+{
+	dot = vectordot( v1, v2 );
+	if ( dot >= 1 )
+	{
+		return 0;
+	}
+	else
+	{
+		if ( dot <= -1 )
+		{
+			return 180;
+		}
+	}
+	return acos( dot );
+}
+
+vectortowardsothervector( v1, v2, angle )
+{
+	dot = vectordot( v1, v2 );
+	if ( dot <= -1 )
+	{
+		return v1;
+	}
+	v3 = vectornormalize( v2 - vectorScale( v1, dot ) );
+	return vectorScale( v1, cos( angle ) ) + vectorScale( v3, sin( angle ) );
+}
+
+veclength( v )
+{
+	return distance( ( 0, 0, -1 ), v );
+}
+
+createcopter( location, team, damagetrig )
+{
+	location = getabovebuildingslocation( location );
+	scriptorigin = spawn( "script_origin", location );
+	scriptorigin.angles = vectorToAngle( ( 0, 0, -1 ) );
+	copter = spawn( "script_model", location );
+	copter.angles = vectorToAngle( ( 0, 0, -1 ) );
+	copter linkto( scriptorigin );
+	scriptorigin.copter = copter;
+	copter setmodel( level.coptermodel );
+	copter playloopsound( "mp_copter_ambience" );
+	damagetrig.origin = scriptorigin.origin;
+	damagetrig thread mylinkto( scriptorigin );
+	scriptorigin.damagetrig = damagetrig;
+	scriptorigin.finaldest = location;
+	scriptorigin.finalzdest = location[ 2 ];
+	scriptorigin.desireddir = ( 0, 0, -1 );
+	scriptorigin.desireddirentity = undefined;
+	scriptorigin.desireddirentityoffset = ( 0, 0, -1 );
+	scriptorigin.vel = ( 0, 0, -1 );
+	scriptorigin.dontascend = 0;
+	scriptorigin.health = 2000;
+	if ( getDvar( #"A8262D2E" ) != "" )
+	{
+		scriptorigin.health = getDvarFloat( #"A8262D2E" );
+	}
+	scriptorigin.team = team;
+	scriptorigin thread copterai();
+	scriptorigin thread copterdamage( damagetrig );
+	return scriptorigin;
+}
+
+makecopterpassive()
+{
+	self.damagetrig notify( "unlink" );
+	self.damagetrig = undefined;
+	self notify( "passive" );
+	self.desireddirentity = undefined;
+	self.desireddir = undefined;
+}
+
+makecopteractive( damagetrig )
+{
+	damagetrig.origin = self.origin;
+	damagetrig thread mylinkto( self );
+	self.damagetrig = damagetrig;
+	self thread copterai();
+	self thread copterdamage( damagetrig );
+}
+
+mylinkto( obj )
+{
+	self endon( "unlink" );
+	while ( 1 )
+	{
+		self.angles = obj.angles;
+		self.origin = obj.origin;
+		wait 0,1;
+	}
+}
+
+setcopterdefensearea( areaent )
+{
+	self.areaent = areaent;
+	self.areadescentpoints = [];
+	if ( isDefined( areaent.target ) )
+	{
+		self.areadescentpoints = getentarray( areaent.target, "targetname" );
+	}
+	i = 0;
+	while ( i < self.areadescentpoints.size )
+	{
+		self.areadescentpoints[ i ].targetent = getent( self.areadescentpoints[ i ].target, "targetname" );
+		i++;
+	}
+}
+
+copterai()
+{
+	self thread coptermove();
+	self thread coptershoot();
+	self endon( "death" );
+	self endon( "passive" );
+	flying = 1;
+	descendingent = undefined;
+	reacheddescendingent = 0;
+	returningtoarea = 0;
+	while ( 1 )
+	{
+		while ( !isDefined( self.areaent ) )
+		{
+			wait 1;
+		}
+		players = level.players;
+		enemytargets = [];
+		while ( self.team != "neutral" )
+		{
+			i = 0;
+			while ( i < players.size )
+			{
+				if ( isalive( players[ i ] ) && isDefined( players[ i ].pers[ "team" ] ) && players[ i ].pers[ "team" ] != self.team && !isDefined( players[ i ].usingobj ) )
+				{
+					playerorigin = players[ i ].origin;
+					playerorigin = ( playerorigin[ 0 ], playerorigin[ 1 ], self.areaent.origin[ 2 ] );
+					if ( distance( playerorigin, self.areaent.origin ) < self.areaent.radius )
+					{
+						enemytargets[ enemytargets.size ] = players[ i ];
+					}
+				}
+				i++;
+			}
+		}
+		insidetargets = [];
+		outsidetargets = [];
+		skyheight = bullettrace( self.origin, self.origin + vectorScale( ( 0, 0, -1 ), 10000 ), 0, undefined )[ "position" ][ 2 ] - 10;
+		besttarget = undefined;
+		bestweight = 0;
+		i = 0;
+		while ( i < enemytargets.size )
+		{
+			inside = 0;
+			trace = bullettrace( enemytargets[ i ].origin + vectorScale( ( 0, 0, -1 ), 10 ), enemytargets[ i ].origin + vectorScale( ( 0, 0, -1 ), 10000 ), 0, undefined );
+			if ( trace[ "position" ][ 2 ] >= skyheight )
+			{
+				outsidetargets[ outsidetargets.size ] = enemytargets[ i ];
+				i++;
+				continue;
+			}
+			else
+			{
+				insidetargets[ insidetargets.size ] = enemytargets[ i ];
+			}
+			i++;
+		}
+		gotopos = undefined;
+		calcedgotopos = 0;
+		olddescendingent = undefined;
+		if ( flying )
+		{
+			if ( outsidetargets.size == 0 && insidetargets.size > 0 && self.areadescentpoints.size > 0 )
+			{
+				flying = 0;
+				result = determinebestent( insidetargets, self.areadescentpoints, self.origin );
+				descendingent = result[ "descendEnt" ];
+				if ( isDefined( descendingent ) )
+				{
+					gotopos = result[ "position" ];
+					break;
+				}
+				else
+				{
+					flying = 1;
+				}
+			}
+		}
+		else olddescendingent = descendingent;
+		if ( insidetargets.size == 0 )
+		{
+			flying = 1;
+		}
+		else
+		{
+			if ( outsidetargets.size > 0 )
+			{
+				if ( !isDefined( descendingent ) )
+				{
+					flying = 1;
+					break;
+				}
+				else
+				{
+					calcedgotopos = 1;
+					gotopos = determinebestpos( insidetargets, descendingent, self.origin );
+					if ( !isDefined( gotopos ) )
+					{
+						flying = 1;
+					}
+				}
+			}
+			if ( isDefined( descendingent ) )
+			{
+				if ( !calcedgotopos )
+				{
+					gotopos = determinebestpos( insidetargets, descendingent, self.origin );
+				}
+			}
+			if ( !isDefined( gotopos ) )
+			{
+				result = determinebestent( insidetargets, self.areadescentpoints, self.origin );
+				if ( isDefined( result[ "descendEnt" ] ) )
+				{
+					descendingent = result[ "descendEnt" ];
+					gotopos = result[ "position" ];
+					reacheddescendingent = 0;
+					break;
+				}
+				else if ( isDefined( descendingent ) )
+				{
+					if ( isDefined( self.finaldest ) )
+					{
+						gotopos = self.finaldest;
+					}
+					else
+					{
+						gotopos = descendingent.origin;
+					}
+					break;
+				}
+				else
+				{
+					gotopos = undefined;
+				}
+			}
+			if ( !isDefined( gotopos ) )
+			{
+				flying = 1;
+			}
+		}
+		if ( flying )
+		{
+			desireddist = 2560;
+			disttoarea = distance( ( self.origin[ 0 ], self.origin[ 1 ], self.areaent.origin[ 2 ] ), self.areaent.origin );
+			if ( outsidetargets.size == 0 && disttoarea > ( self.areaent.radius + ( desireddist * 0,25 ) ) )
+			{
+				returningtoarea = 1;
+			}
+			else
+			{
+				if ( disttoarea < ( self.areaent.radius * 0,5 ) )
+				{
+					returningtoarea = 0;
+				}
+			}
+			while ( outsidetargets.size == 0 && !returningtoarea )
+			{
+				while ( self.team != "neutral" )
+				{
+					i = 0;
+					while ( i < players.size )
+					{
+						if ( isalive( players[ i ] ) && isDefined( players[ i ].pers[ "team" ] ) && players[ i ].pers[ "team" ] != self.team && !isDefined( players[ i ].usingobj ) )
+						{
+							playerorigin = players[ i ].origin;
+							playerorigin = ( playerorigin[ 0 ], playerorigin[ 1 ], self.areaent.origin[ 2 ] );
+							if ( distance( players[ i ].origin, self.areaent.origin ) > self.areaent.radius )
+							{
+								outsidetargets[ outsidetargets.size ] = players[ i ];
+							}
+						}
+						i++;
+					}
+				}
+			}
+			best = undefined;
+			bestdist = 0;
+			i = 0;
+			while ( i < outsidetargets.size )
+			{
+				dist = abs( distance( outsidetargets[ i ].origin, self.origin ) - desireddist );
+				if ( !isDefined( best ) || dist < bestdist )
+				{
+					best = outsidetargets[ i ];
+					bestdist = dist;
+				}
+				i++;
+			}
+			if ( isDefined( best ) )
+			{
+				attackpos = best.origin + level.coptertargetoffset;
+				gotopos = determinebestattackpos( attackpos, self.origin, desireddist );
+				self setcopterdest( gotopos, 0 );
+				self.desireddir = vectornormalize( attackpos - gotopos );
+				self.desireddirentity = best;
+				self.desireddirentityoffset = level.coptertargetoffset;
+				wait 1;
+			}
+			else
+			{
+				gotopos = getrandompos( self.areaent.origin, self.areaent.radius );
+				self setcopterdest( gotopos, 0 );
+				self.desireddir = undefined;
+				self.desireddirentity = undefined;
+				wait 1;
+			}
+			continue;
+		}
+		else if ( distance( self.origin, descendingent.origin ) < descendingent.radius )
+		{
+			reacheddescendingent = 1;
+		}
+		if ( isDefined( olddescendingent ) )
+		{
+			godirectly = olddescendingent == descendingent;
+		}
+		if ( godirectly )
+		{
+			godirectly = reacheddescendingent;
+		}
+		self.desireddir = vectornormalize( descendingent.targetent.origin - gotopos - level.coptercenteroffset );
+		self.desireddirentity = descendingent.targetent;
+		self.desireddirentityoffset = ( 0, 0, -1 );
+		if ( gotopos != self.origin )
+		{
+			self setcopterdest( gotopos - level.coptercenteroffset, 1, godirectly );
+			wait 0,3;
+			continue;
+		}
+		else
+		{
+			wait 0,3;
+		}
+	}
+}
+
+determinebestpos( targets, descendent, startorigin )
+{
+	targetpos = descendent.targetent.origin;
+	circleradius = distance( targetpos, descendent.origin );
+	bestpoint = undefined;
+	bestdist = 0;
+	i = 0;
+	while ( i < targets.size )
+	{
+		enemypos = targets[ i ].origin + level.coptertargetoffset;
+		passed = bullettracepassed( enemypos, targetpos, 0, undefined );
+		if ( passed )
+		{
+			dir = targetpos - enemypos;
+			dir = ( dir[ 0 ], dir[ 1 ], 0 );
+			isect = vectorScale( vectornormalize( dir ), circleradius ) + targetpos;
+			isect = ( isect[ 0 ], isect[ 1 ], descendent.origin[ 2 ] );
+			dist = distance( isect, descendent.origin );
+			if ( dist <= descendent.radius )
+			{
+				dist = distance( isect, startorigin );
+				if ( !isDefined( bestpoint ) || dist < bestdist )
+				{
+					bestdist = dist;
+					bestpoint = isect;
+				}
+			}
+		}
+		i++;
+	}
+	return bestpoint;
+}
+
+determinebestent( targets, descendents, startorigin )
+{
+	result = [];
+	bestpos = undefined;
+	bestent = 0;
+	bestdist = 0;
+	i = 0;
+	while ( i < descendents.size )
+	{
+		thispos = determinebestpos( targets, descendents[ i ], startorigin );
+		if ( isDefined( thispos ) )
+		{
+			thisdist = distance( thispos, startorigin );
+			if ( !isDefined( bestpos ) || thisdist < bestdist )
+			{
+				bestpos = thispos;
+				bestent = i;
+				bestdist = thisdist;
+			}
+		}
+		i++;
+	}
+	if ( isDefined( bestpos ) )
+	{
+		result[ "descendEnt" ] = descendents[ bestent ];
+		result[ "position" ] = bestpos;
+		return result;
+	}
+	return result;
+}
+
+determinebestattackpos( targetpos, curpos, desireddist )
+{
+	targetposcopterheight = ( targetpos[ 0 ], targetpos[ 1 ], curpos[ 2 ] );
+	attackdirx = curpos - targetposcopterheight;
+	attackdirx = vectornormalize( attackdirx );
+	attackdiry = ( 0 - attackdirx[ 1 ], attackdirx[ 0 ], 0 );
+	bestpos = undefined;
+	bestdist = 0;
+	i = 0;
+	while ( i < 8 )
+	{
+		theta = ( i / 8 ) * 360;
+		thisdir = vectorScale( attackdirx, cos( theta ) ) + vectorScale( attackdiry, sin( theta ) );
+		traceend = targetposcopterheight + vectorScale( thisdir, desireddist );
+		losexists = bullettracepassed( targetpos, traceend, 0, undefined );
+		if ( losexists )
+		{
+			thisdist = distance( traceend, curpos );
+			if ( !isDefined( bestpos ) || thisdist < bestdist )
+			{
+				bestpos = traceend;
+				bestdist = thisdist;
+			}
+		}
+		i++;
+	}
+	gotopos = undefined;
+	if ( isDefined( bestpos ) )
+	{
+		gotopos = bestpos;
+	}
+	else dist = distance( targetposcopterheight, curpos );
+	if ( dist > desireddist )
+	{
+		gotopos = self.origin + vectorScale( vectornormalize( attackdirx ), 0 - dist - desireddist );
+	}
+	else
+	{
+		gotopos = self.origin;
+	}
+	return gotopos;
+}
+
+getrandompos( origin, radius )
+{
+	pos = origin + ( ( randomfloat( 2 ) - 1 ) * radius, ( randomfloat( 2 ) - 1 ) * radius, 0 );
+	while ( distancesquared( pos, origin ) > ( radius * radius ) )
+	{
+		pos = origin + ( ( randomfloat( 2 ) - 1 ) * radius, ( randomfloat( 2 ) - 1 ) * radius, 0 );
+	}
+	return pos;
+}
+
+coptershoot()
+{
+	self endon( "death" );
+	self endon( "passive" );
+	costhreshold = cos( 10 );
+	while ( 1 )
+	{
+		if ( isDefined( self.desireddirentity ) && isDefined( self.desireddirentity.origin ) )
+		{
+			mypos = self.origin + level.coptercenteroffset;
+			enemypos = self.desireddirentity.origin + self.desireddirentityoffset;
+			curdir = anglesToForward( self.angles );
+			enemydirraw = enemypos - mypos;
+			enemydir = vectornormalize( enemydirraw );
+			if ( vectordot( curdir, enemydir ) > costhreshold )
+			{
+				canseetarget = bullettracepassed( mypos, enemypos, 0, undefined );
+				if ( !canseetarget && isplayer( self.desireddirentity ) && isalive( self.desireddirentity ) )
+				{
+					canseetarget = bullettracepassed( mypos, self.desireddirentity geteye(), 0, undefined );
+				}
+				if ( canseetarget )
+				{
+					self playsound( "mp_copter_shoot" );
+					numshots = 20;
+					i = 0;
+					while ( i < numshots )
+					{
+						mypos = self.origin + level.coptercenteroffset;
+						dir = anglesToForward( self.angles );
+						dir += ( ( randomfloat( 2 ) - 1 ) * 0,015, ( randomfloat( 2 ) - 1 ) * 0,015, ( randomfloat( 2 ) - 1 ) * 0,015 );
+						dir = vectornormalize( dir );
+						self mymagicbullet( mypos, dir );
+						wait 0,075;
+						i++;
+					}
+					wait 0,25;
+				}
+			}
+		}
+		wait 0,25;
+	}
+}
+
+mymagicbullet( pos, dir )
+{
+	damage = 20;
+	if ( getDvar( #"9E8F8CB7" ) != "" )
+	{
+		damage = getDvarInt( #"9E8F8CB7" );
+	}
+	trace = bullettrace( pos, pos + vectorScale( dir, 10000 ), 1, undefined );
+	if ( isDefined( trace[ "entity" ] ) && isplayer( trace[ "entity" ] ) && isalive( trace[ "entity" ] ) )
+	{
+		trace[ "entity" ] thread [[ level.callbackplayerdamage ]]( self, self, damage, 0, "MOD_RIFLE_BULLET", "copter", self.origin, dir, "none", 0, 0 );
+	}
+}
+
+setcopterdest( newlocation, descend, dontascend )
+{
+	self.finaldest = getabovebuildingslocation( newlocation );
+	if ( isDefined( descend ) && descend )
+	{
+		self.finalzdest = newlocation[ 2 ];
+	}
+	else
+	{
+		self.finalzdest = self.finaldest[ 2 ];
+	}
+	self.intransit = 1;
+	self.dontascend = 0;
+	if ( isDefined( dontascend ) )
+	{
+		self.dontascend = dontascend;
+	}
+}
+
+notifyarrived()
+{
+	wait 0,05;
+	self notify( "arrived" );
+}
+
+coptermove()
+{
+	self endon( "death" );
+	if ( isDefined( self.coptermoverunning ) )
+	{
+		return;
+	}
+	self.coptermoverunning = 1;
+	self.intransit = 0;
+	interval = 0,15;
+	zinterp = 0,1;
+	tiltamnt = 0;
+	while ( 1 )
+	{
+		horizdistsquared = distancesquared( ( self.origin[ 0 ], self.origin[ 1 ], 0 ), ( self.finaldest[ 0 ], self.finaldest[ 1 ], 0 ) );
+		donemoving = horizdistsquared < 100;
+		neardest = horizdistsquared < 65536;
+		self.intransit = 1;
+		desiredz = 0;
+		movinghorizontally = 1;
+		movingvertically = 0;
+		if ( self.dontascend )
+		{
+			movingvertically = 1;
+		}
+		else if ( !neardest )
+		{
+			desiredz = getabovebuildingslocation( self.origin )[ 2 ];
+			movinghorizontally = abs( self.origin[ 2 ] - desiredz ) <= 256;
+			movingvertically = !movinghorizontally;
+		}
+		else
+		{
+			movingvertically = 1;
+		}
+		if ( movinghorizontally )
+		{
+			if ( movingvertically )
+			{
+				thisdest = ( self.finaldest[ 0 ], self.finaldest[ 1 ], self.finalzdest );
+			}
+			else
+			{
+				thisdest = self.finaldest;
+			}
+		}
+		else
+		{
+/#
+			assert( movingvertically );
+#/
+			thisdest = ( self.origin[ 0 ], self.origin[ 1 ], desiredz );
+		}
+		movevec = thisdest - self.origin;
+		idealaccel = vectorScale( thisdest - ( self.origin + vectorScale( self.vel, level.copter_accellookahead ) ), interval );
+		vlen = veclength( idealaccel );
+		if ( vlen > level.copter_maxaccel )
+		{
+			idealaccel = vectorScale( idealaccel, level.copter_maxaccel / vlen );
+		}
+		self.vel += idealaccel;
+		vlen = veclength( self.vel );
+		if ( vlen > level.copter_maxvel )
+		{
+			self.vel = vectorScale( self.vel, level.copter_maxvel / vlen );
+		}
+		thisdest = self.origin + vectorScale( self.vel, interval );
+		self moveto( thisdest, interval * 0,999 );
+		speed = veclength( self.vel );
+		if ( isDefined( self.desireddirentity ) && isDefined( self.desireddirentity.origin ) )
+		{
+			self.destdir = vectornormalize( ( self.desireddirentity.origin + self.desireddirentityoffset ) - ( self.origin + level.coptercenteroffset ) );
+		}
+		else
+		{
+			if ( isDefined( self.desireddir ) )
+			{
+				self.destdir = self.desireddir;
+				break;
+			}
+			else if ( movingvertically )
+			{
+				self.destdir = anglesToForward( self.angles );
+				self.destdir = vectornormalize( ( self.destdir[ 0 ], self.destdir[ 1 ], 0 ) );
+				break;
+			}
+			else
+			{
+				tiltamnt = speed / level.copter_maxvel;
+				tiltamnt = ( tiltamnt - 0,1 ) / 0,9;
+				if ( tiltamnt < 0 )
+				{
+					tiltamnt = 0;
+				}
+				self.destdir = movevec;
+				self.destdir = vectornormalize( ( self.destdir[ 0 ], self.destdir[ 1 ], 0 ) );
+				tiltamnt *= 1 - ( vectorangle( anglesToForward( self.angles ), self.destdir ) / 180 );
+				self.destdir = vectornormalize( ( self.destdir[ 0 ], self.destdir[ 1 ], tiltamnt * -0,4 ) );
+			}
+		}
+		newdir = self.destdir;
+		if ( newdir[ 2 ] < -0,4 )
+		{
+			newdir = vectornormalize( ( newdir[ 0 ], newdir[ 1 ], -0,4 ) );
+		}
+		copterangles = self.angles;
+		copterangles = combineangles( copterangles, vectorScale( ( 0, 0, -1 ), 90 ) );
+		olddir = anglesToForward( copterangles );
+		thisrotspeed = level.copter_rotspeed;
+		olddir2d = vectornormalize( ( olddir[ 0 ], olddir[ 1 ], 0 ) );
+		newdir2d = vectornormalize( ( newdir[ 0 ], newdir[ 1 ], 0 ) );
+		angle = vectorangle( olddir2d, newdir2d );
+		angle3d = vectorangle( olddir, newdir );
+		if ( angle > 0,001 && thisrotspeed > 0,001 )
+		{
+			thisangle = thisrotspeed * interval;
+			if ( thisangle > angle )
+			{
+				thisangle = angle;
+			}
+			newdir2d = vectortowardsothervector( olddir2d, newdir2d, thisangle );
+			oldz = olddir[ 2 ] / veclength( ( olddir[ 0 ], olddir[ 1 ], 0 ) );
+			newz = newdir[ 2 ] / veclength( ( newdir[ 0 ], newdir[ 1 ], 0 ) );
+			interpz = oldz + ( ( newz - oldz ) * ( thisangle / angle ) );
+			newdir = vectornormalize( ( newdir2d[ 0 ], newdir2d[ 1 ], interpz ) );
+			copterangles = vectorToAngle( newdir );
+			copterangles = combineangles( copterangles, vectorScale( ( 0, 0, -1 ), 90 ) );
+			self rotateto( copterangles, interval * 0,999 );
+		}
+		else
+		{
+			if ( angle3d > 0,001 && thisrotspeed > 0,001 )
+			{
+				thisangle = thisrotspeed * interval;
+				if ( thisangle > angle3d )
+				{
+					thisangle = angle3d;
+				}
+				newdir = vectortowardsothervector( olddir, newdir, thisangle );
+				newdir = vectornormalize( newdir );
+				copterangles = vectorToAngle( newdir );
+				copterangles = combineangles( copterangles, vectorScale( ( 0, 0, -1 ), 90 ) );
+				self rotateto( copterangles, interval * 0,999 );
+			}
+		}
+		wait interval;
+	}
+}
+
+copterdamage( damagetrig )
+{
+	self endon( "passive" );
+	while ( 1 )
+	{
+		damagetrig waittill( "damage", amount, attacker );
+		while ( isDefined( attacker ) && isplayer( attacker ) && isDefined( attacker.pers[ "team" ] ) && attacker.pers[ "team" ] == self.team )
+		{
+			continue;
+		}
+		self.health -= amount;
+		if ( self.health <= 0 )
+		{
+			self thread copterdie();
+			return;
+		}
+	}
+}
+
+copterdie()
+{
+	self endon( "passive" );
+	self death_notify_wrapper();
+	self.dead = 1;
+	self thread copterexplodefx();
+	interval = 0,2;
+	rottime = 15;
+	self rotateyaw( 360 + randomfloat( 360 ), rottime );
+	self rotatepitch( 360 + randomfloat( 360 ), rottime );
+	self rotateroll( 360 + randomfloat( 360 ), rottime );
+	while ( 1 )
+	{
+		self.vel += vectorScale( vectorScale( ( 0, 0, -1 ), 200 ), interval );
+		newpos = self.origin + vectorScale( self.vel, interval );
+		pathclear = bullettracepassed( self.origin, newpos, 0, undefined );
+		if ( !pathclear )
+		{
+			break;
+		}
+		else
+		{
+			self moveto( newpos, interval * 0,999 );
+			wait interval;
+		}
+	}
+	playfx( level.copterfinalexplosion, self.origin );
+	fakeself = spawn( "script_origin", self.origin );
+	fakeself playsound( "mp_copter_explosion" );
+	self notify( "finaldeath" );
+	deletecopter();
+	wait 2;
+	fakeself delete();
+}
+
+deletecopter()
+{
+	if ( isDefined( self.damagetrig ) )
+	{
+		self.damagetrig notify( "unlink" );
+		self.damagetrig = undefined;
+	}
+	self.copter delete();
+	self delete();
+}
+
+copterexplodefx()
+{
+	self endon( "finaldeath" );
+	while ( 1 )
+	{
+		playfx( level.copterexplosion, self.origin );
+		self playsound( "mp_copter_explosion" );
+		wait ( 0,5 + randomfloat( 1 ) );
+	}
+}

patch_mp/maps/mp/gametypes/_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_mp/maps/mp/gametypes/_deathicons.gsc

@@ -0,0 +1,98 @@
+#include maps/mp/gametypes/_deathicons;
+#include maps/mp/gametypes/_globallogic_utils;
+
+init()
+{
+	if ( !isDefined( level.ragdoll_override ) )
+	{
+		level.ragdoll_override = ::ragdoll_override;
+	}
+	if ( !level.teambased )
+	{
+		return;
+	}
+	precacheshader( "headicon_dead" );
+	level thread onplayerconnect();
+}
+
+onplayerconnect()
+{
+	for ( ;; )
+	{
+		level waittill( "connecting", player );
+		player.selfdeathicons = [];
+	}
+}
+
+updatedeathiconsenabled()
+{
+}
+
+adddeathicon( entity, dyingplayer, team, timeout )
+{
+	if ( !level.teambased )
+	{
+		return;
+	}
+	iconorg = entity.origin;
+	dyingplayer endon( "spawned_player" );
+	dyingplayer endon( "disconnect" );
+	wait 0,05;
+	maps/mp/gametypes/_globallogic_utils::waittillslowprocessallowed();
+/#
+	assert( isDefined( level.teams[ team ] ) );
+#/
+	if ( getDvar( "ui_hud_showdeathicons" ) == "0" )
+	{
+		return;
+	}
+	if ( level.hardcoremode )
+	{
+		return;
+	}
+	if ( isDefined( self.lastdeathicon ) )
+	{
+		self.lastdeathicon destroy();
+	}
+	newdeathicon = newteamhudelem( team );
+	newdeathicon.x = iconorg[ 0 ];
+	newdeathicon.y = iconorg[ 1 ];
+	newdeathicon.z = iconorg[ 2 ] + 54;
+	newdeathicon.alpha = 0,61;
+	newdeathicon.archived = 1;
+	if ( level.splitscreen )
+	{
+		newdeathicon setshader( "headicon_dead", 14, 14 );
+	}
+	else
+	{
+		newdeathicon setshader( "headicon_dead", 7, 7 );
+	}
+	newdeathicon setwaypoint( 1 );
+	self.lastdeathicon = newdeathicon;
+	newdeathicon thread destroyslowly( timeout );
+}
+
+destroyslowly( timeout )
+{
+	self endon( "death" );
+	wait timeout;
+	self fadeovertime( 1 );
+	self.alpha = 0;
+	wait 1;
+	self destroy();
+}
+
+ragdoll_override( idamage, smeansofdeath, sweapon, shitloc, vdir, vattackerorigin, deathanimduration, einflictor, ragdoll_jib, body )
+{
+	if ( smeansofdeath == "MOD_FALLING" && self isonground() == 1 )
+	{
+		body startragdoll();
+		if ( !isDefined( self.switching_teams ) )
+		{
+			thread maps/mp/gametypes/_deathicons::adddeathicon( body, self, self.team, 5 );
+		}
+		return 1;
+	}
+	return 0;
+}

patch_mp/maps/mp/gametypes/_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_mp/maps/mp/gametypes/_dev_class.gsc

@@ -0,0 +1,580 @@
+#include maps/mp/gametypes/_dev;
+#include maps/mp/_utility;
+
+dev_cac_init()
+{
+/#
+	dev_cac_overlay = 0;
+	dev_cac_camera_on = 0;
+	level thread dev_cac_gdt_update_think();
+	for ( ;; )
+	{
+		wait 0,5;
+		reset = 1;
+		if ( getDvar( #"E6D8B517" ) != "" )
+		{
+			continue;
+		}
+		else
+		{
+			host = gethostplayer();
+			if ( !isDefined( level.dev_cac_player ) )
+			{
+				level.dev_cac_player = host;
+			}
+			switch( getDvar( "devgui_dev_cac" ) )
+			{
+				case "":
+					reset = 0;
+					break;
+				case "dpad_body":
+					host thread dev_cac_dpad_think( "body", ::dev_cac_cycle_body, "" );
+					break;
+				case "dpad_head":
+					host thread dev_cac_dpad_think( "head", ::dev_cac_cycle_head, "" );
+					break;
+				case "dpad_character":
+					host thread dev_cac_dpad_think( "character", ::dev_cac_cycle_character, "" );
+					break;
+				case "next_player":
+					dev_cac_cycle_player( 1 );
+					break;
+				case "prev_player":
+					dev_cac_cycle_player( 0 );
+					break;
+				case "cac_overlay":
+					level notify( "dev_cac_overlay_think" );
+					if ( !dev_cac_overlay )
+					{
+						level thread dev_cac_overlay_think();
+					}
+					dev_cac_overlay = !dev_cac_overlay;
+					break;
+				case "best_bullet_armor":
+					dev_cac_set_model_range( ::sort_greatest, "armor_bullet" );
+					break;
+				case "worst_bullet_armor":
+					dev_cac_set_model_range( ::sort_least, "armor_bullet" );
+					break;
+				case "best_explosive_armor":
+					dev_cac_set_model_range( ::sort_greatest, "armor_explosive" );
+					break;
+				case "worst_explosive_armor":
+					dev_cac_set_model_range( ::sort_least, "armor_explosive" );
+					break;
+				case "best_mobility":
+					dev_cac_set_model_range( ::sort_greatest, "mobility" );
+					break;
+				case "worst_mobility":
+					dev_cac_set_model_range( ::sort_least, "mobility" );
+					break;
+				case "camera":
+					dev_cac_camera_on = !dev_cac_camera_on;
+					dev_cac_camera( dev_cac_camera_on );
+					break;
+				case "dpad_camo":
+					host thread dev_cac_dpad_think( "camo", ::dev_cac_cycle_render_options, "camo" );
+					break;
+				case "dpad_meleecamo":
+					host thread dev_cac_dpad_think( "meleecamo", ::dev_cac_cycle_render_options, "meleecamo" );
+					break;
+				case "dpad_lens":
+					host thread dev_cac_dpad_think( "lens", ::dev_cac_cycle_render_options, "lens" );
+					break;
+				case "dpad_reticle":
+					host thread dev_cac_dpad_think( "reticle", ::dev_cac_cycle_render_options, "reticle" );
+					break;
+				case "dpad_reticle_color":
+					host thread dev_cac_dpad_think( "reticle color", ::dev_cac_cycle_render_options, "reticle_color" );
+					break;
+				case "dpad_emblem":
+					host thread dev_cac_dpad_think( "emblem", ::dev_cac_cycle_render_options, "emblem" );
+					break;
+				case "dpad_tag":
+					host thread dev_cac_dpad_think( "tag", ::dev_cac_cycle_render_options, "tag" );
+					break;
+				case "dpad_facepaint_pattern":
+					host thread dev_cac_dpad_think( "facepaint pattern", ::dev_cac_cycle_render_options, "facepaint_pattern" );
+					break;
+				case "dpad_facepaint_color":
+					host thread dev_cac_dpad_think( "facepaint color", ::dev_cac_cycle_render_options, "facepaint_color" );
+					break;
+				case "dpad_reset":
+					host notify( "dev_cac_dpad_think" );
+					break;
+			}
+			if ( reset )
+			{
+				setdvar( "devgui_dev_cac", "" );
+			}
+		}
+#/
+	}
+}
+
+dev_cac_camera( on )
+{
+/#
+	if ( on )
+	{
+		self setclientthirdperson( 1 );
+		setdvar( "cg_thirdPersonAngle", "185" );
+		setdvar( "cg_thirdPersonRange", "138" );
+		setdvar( "cg_fov", "20" );
+	}
+	else
+	{
+		self setclientthirdperson( 0 );
+		setdvar( "cg_fov", getDvar( "cg_fov_default" ) );
+#/
+	}
+}
+
+dev_cac_dpad_think( part_name, cycle_function, tag )
+{
+/#
+	self notify( "dev_cac_dpad_think" );
+	self endon( "dev_cac_dpad_think" );
+	self endon( "disconnect" );
+	iprintln( "Previous " + part_name + " bound to D-Pad Left" );
+	iprintln( "Next " + part_name + " bound to D-Pad Right" );
+	dpad_left = 0;
+	dpad_right = 0;
+	level.dev_cac_player thread highlight_player();
+	for ( ;; )
+	{
+		self setactionslot( 3, "" );
+		self setactionslot( 4, "" );
+		if ( !dpad_left && self buttonpressed( "DPAD_LEFT" ) )
+		{
+			[[ cycle_function ]]( 0, tag );
+			dpad_left = 1;
+		}
+		else
+		{
+			if ( !self buttonpressed( "DPAD_LEFT" ) )
+			{
+				dpad_left = 0;
+			}
+		}
+		if ( !dpad_right && self buttonpressed( "DPAD_RIGHT" ) )
+		{
+			[[ cycle_function ]]( 1, tag );
+			dpad_right = 1;
+		}
+		else
+		{
+			if ( !self buttonpressed( "DPAD_RIGHT" ) )
+			{
+				dpad_right = 0;
+			}
+		}
+		wait 0,05;
+#/
+	}
+}
+
+next_in_list( value, list )
+{
+/#
+	if ( !isDefined( value ) )
+	{
+		return list[ 0 ];
+	}
+	i = 0;
+	while ( i < list.size )
+	{
+		if ( value == list[ i ] )
+		{
+			if ( isDefined( list[ i + 1 ] ) )
+			{
+				value = list[ i + 1 ];
+			}
+			else
+			{
+				value = list[ 0 ];
+			}
+			break;
+		}
+		else
+		{
+			i++;
+		}
+	}
+	return value;
+#/
+}
+
+prev_in_list( value, list )
+{
+/#
+	if ( !isDefined( value ) )
+	{
+		return list[ 0 ];
+	}
+	i = 0;
+	while ( i < list.size )
+	{
+		if ( value == list[ i ] )
+		{
+			if ( isDefined( list[ i - 1 ] ) )
+			{
+				value = list[ i - 1 ];
+			}
+			else
+			{
+				value = list[ list.size - 1 ];
+			}
+			break;
+		}
+		else
+		{
+			i++;
+		}
+	}
+	return value;
+#/
+}
+
+dev_cac_set_player_model()
+{
+/#
+	self.tag_stowed_back = undefined;
+	self.tag_stowed_hip = undefined;
+#/
+}
+
+dev_cac_cycle_body( forward, tag )
+{
+/#
+	if ( !dev_cac_player_valid() )
+	{
+		return;
+	}
+	player = level.dev_cac_player;
+	keys = getarraykeys( level.cac_functions[ "set_body_model" ] );
+	if ( forward )
+	{
+		player.cac_body_type = next_in_list( player.cac_body_type, keys );
+	}
+	else
+	{
+		player.cac_body_type = prev_in_list( player.cac_body_type, keys );
+	}
+	player dev_cac_set_player_model();
+#/
+}
+
+dev_cac_cycle_head( forward, tag )
+{
+/#
+	if ( !dev_cac_player_valid() )
+	{
+		return;
+	}
+	player = level.dev_cac_player;
+	keys = getarraykeys( level.cac_functions[ "set_head_model" ] );
+	if ( forward )
+	{
+		player.cac_head_type = next_in_list( player.cac_head_type, keys );
+	}
+	else
+	{
+		player.cac_head_type = prev_in_list( player.cac_head_type, keys );
+	}
+	player.cac_hat_type = "none";
+	player dev_cac_set_player_model();
+#/
+}
+
+dev_cac_cycle_character( forward, tag )
+{
+/#
+	if ( !dev_cac_player_valid() )
+	{
+		return;
+	}
+	player = level.dev_cac_player;
+	keys = getarraykeys( level.cac_functions[ "set_body_model" ] );
+	if ( forward )
+	{
+		player.cac_body_type = next_in_list( player.cac_body_type, keys );
+	}
+	else
+	{
+		player.cac_body_type = prev_in_list( player.cac_body_type, keys );
+	}
+	player.cac_hat_type = "none";
+	player dev_cac_set_player_model();
+#/
+}
+
+dev_cac_cycle_render_options( forward, tag )
+{
+/#
+	if ( !dev_cac_player_valid() )
+	{
+		return;
+	}
+	level.dev_cac_player nextplayerrenderoption( tag, forward );
+#/
+}
+
+dev_cac_player_valid()
+{
+/#
+	if ( isDefined( level.dev_cac_player ) )
+	{
+		return level.dev_cac_player.sessionstate == "playing";
+#/
+	}
+}
+
+dev_cac_cycle_player( forward )
+{
+/#
+	players = get_players();
+	i = 0;
+	while ( i < players.size )
+	{
+		if ( forward )
+		{
+			level.dev_cac_player = next_in_list( level.dev_cac_player, players );
+		}
+		else
+		{
+			level.dev_cac_player = prev_in_list( level.dev_cac_player, players );
+		}
+		if ( dev_cac_player_valid() )
+		{
+			level.dev_cac_player thread highlight_player();
+			return;
+		}
+		i++;
+	}
+	level.dev_cac_player = undefined;
+#/
+}
+
+highlight_player()
+{
+/#
+	self sethighlighted( 1 );
+	wait 1;
+	self sethighlighted( 0 );
+#/
+}
+
+dev_cac_overlay_think()
+{
+/#
+	hud = dev_cac_overlay_create();
+	level thread dev_cac_overlay_update( hud );
+	level waittill( "dev_cac_overlay_think" );
+	dev_cac_overlay_destroy( hud );
+#/
+}
+
+dev_cac_overlay_update( hud )
+{
+/#
+#/
+}
+
+dev_cac_overlay_destroy( hud )
+{
+/#
+	i = 0;
+	while ( i < hud.menu.size )
+	{
+		hud.menu[ i ] destroy();
+		i++;
+	}
+	hud destroy();
+	setdvar( "player_debugSprint", "0" );
+#/
+}
+
+dev_cac_overlay_create()
+{
+/#
+	x = -80;
+	y = 140;
+	menu_name = "dev_cac_debug";
+	hud = maps/mp/gametypes/_dev::new_hud( menu_name, undefined, x, y, 1 );
+	hud setshader( "white", 185, 285 );
+	hud.alignx = "left";
+	hud.aligny = "top";
+	hud.sort = 10;
+	hud.alpha = 0,6;
+	hud.color = vectorScale( ( 0, 0, 0 ), 0,5 );
+	x_offset = 100;
+	hud.menu[ 0 ] = maps/mp/gametypes/_dev::new_hud( menu_name, "NAME", x + 5, y + 10, 1,3 );
+	hud.menu[ 1 ] = maps/mp/gametypes/_dev::new_hud( menu_name, "MODELS", x + 5, y + 25, 1 );
+	hud.menu[ 2 ] = maps/mp/gametypes/_dev::new_hud( menu_name, "  Body:", x + 5, y + 35, 1 );
+	hud.menu[ 3 ] = maps/mp/gametypes/_dev::new_hud( menu_name, "  Head:", x + 5, y + 45, 1 );
+	hud.menu[ 4 ] = maps/mp/gametypes/_dev::new_hud( menu_name, "  Head Gear:", x + 5, y + 55, 1 );
+	hud.menu[ 5 ] = maps/mp/gametypes/_dev::new_hud( menu_name, "MOBILITY", x + 5, y + 70, 1 );
+	hud.menu[ 6 ] = maps/mp/gametypes/_dev::new_hud( menu_name, "  Body:", x + 5, y + 80, 1 );
+	hud.menu[ 7 ] = maps/mp/gametypes/_dev::new_hud( menu_name, "  Head Gear:", x + 5, y + 90, 1 );
+	hud.menu[ 8 ] = maps/mp/gametypes/_dev::new_hud( menu_name, "  Speed Scale:", x + 5, y + 100, 1 );
+	hud.menu[ 9 ] = maps/mp/gametypes/_dev::new_hud( menu_name, "  Sprint Duration:", x + 5, y + 110, 1 );
+	hud.menu[ 10 ] = maps/mp/gametypes/_dev::new_hud( menu_name, "  Sprint Cooldown:", x + 5, y + 120, 1 );
+	hud.menu[ 11 ] = maps/mp/gametypes/_dev::new_hud( menu_name, "ARMOR - BULLET", x + 5, y + 135, 1 );
+	hud.menu[ 12 ] = maps/mp/gametypes/_dev::new_hud( menu_name, "  Body:", x + 5, y + 145, 1 );
+	hud.menu[ 13 ] = maps/mp/gametypes/_dev::new_hud( menu_name, "  Head Gear:", x + 5, y + 155, 1 );
+	hud.menu[ 14 ] = maps/mp/gametypes/_dev::new_hud( menu_name, "ARMOR - EXPLOSIVE", x + 5, y + 170, 1 );
+	hud.menu[ 15 ] = maps/mp/gametypes/_dev::new_hud( menu_name, "  Body:", x + 5, y + 180, 1 );
+	hud.menu[ 16 ] = maps/mp/gametypes/_dev::new_hud( menu_name, "  Head Gear:", x + 5, y + 190, 1 );
+	hud.menu[ 17 ] = maps/mp/gametypes/_dev::new_hud( menu_name, "DAMAGE", x + 5, y + 205, 1 );
+	hud.menu[ 18 ] = maps/mp/gametypes/_dev::new_hud( menu_name, "  Type:", x + 5, y + 215, 1 );
+	hud.menu[ 19 ] = maps/mp/gametypes/_dev::new_hud( menu_name, "  Original:", x + 5, y + 225, 1 );
+	hud.menu[ 20 ] = maps/mp/gametypes/_dev::new_hud( menu_name, "  Final:", x + 5, y + 235, 1 );
+	hud.menu[ 21 ] = maps/mp/gametypes/_dev::new_hud( menu_name, "  Gain/Loss:", x + 5, y + 245, 1 );
+	hud.menu[ 22 ] = maps/mp/gametypes/_dev::new_hud( menu_name, "  Location:", x + 5, y + 255, 1 );
+	hud.menu[ 23 ] = maps/mp/gametypes/_dev::new_hud( menu_name, "  Weapon:", x + 5, y + 265, 1 );
+	hud.menu[ 24 ] = maps/mp/gametypes/_dev::new_hud( menu_name, "  Range:", x + 5, y + 275, 1 );
+	x_offset = 65;
+	hud.menu[ 25 ] = maps/mp/gametypes/_dev::new_hud( menu_name, "", x + x_offset, y + 35, 1 );
+	hud.menu[ 26 ] = maps/mp/gametypes/_dev::new_hud( menu_name, "", x + x_offset, y + 45, 1 );
+	hud.menu[ 27 ] = maps/mp/gametypes/_dev::new_hud( menu_name, "", x + x_offset, y + 55, 1 );
+	x_offset = 100;
+	hud.menu[ 28 ] = maps/mp/gametypes/_dev::new_hud( menu_name, "", x + x_offset, y + 80, 1 );
+	hud.menu[ 29 ] = maps/mp/gametypes/_dev::new_hud( menu_name, "", x + x_offset, y + 90, 1 );
+	hud.menu[ 30 ] = maps/mp/gametypes/_dev::new_hud( menu_name, "", x + x_offset, y + 100, 1 );
+	hud.menu[ 31 ] = maps/mp/gametypes/_dev::new_hud( menu_name, "", x + x_offset, y + 110, 1 );
+	hud.menu[ 32 ] = maps/mp/gametypes/_dev::new_hud( menu_name, "", x + x_offset, y + 120, 1 );
+	hud.menu[ 33 ] = maps/mp/gametypes/_dev::new_hud( menu_name, "", x + x_offset, y + 145, 1 );
+	hud.menu[ 34 ] = maps/mp/gametypes/_dev::new_hud( menu_name, "", x + x_offset, y + 155, 1 );
+	hud.menu[ 35 ] = maps/mp/gametypes/_dev::new_hud( menu_name, "", x + x_offset, y + 180, 1 );
+	hud.menu[ 36 ] = maps/mp/gametypes/_dev::new_hud( menu_name, "", x + x_offset, y + 190, 1 );
+	x_offset = 65;
+	hud.menu[ 37 ] = maps/mp/gametypes/_dev::new_hud( menu_name, "", x + x_offset, y + 215, 1 );
+	hud.menu[ 38 ] = maps/mp/gametypes/_dev::new_hud( menu_name, "", x + x_offset, y + 225, 1 );
+	hud.menu[ 39 ] = maps/mp/gametypes/_dev::new_hud( menu_name, "", x + x_offset, y + 235, 1 );
+	hud.menu[ 40 ] = maps/mp/gametypes/_dev::new_hud( menu_name, "", x + x_offset, y + 245, 1 );
+	hud.menu[ 41 ] = maps/mp/gametypes/_dev::new_hud( menu_name, "", x + x_offset, y + 255, 1 );
+	hud.menu[ 42 ] = maps/mp/gametypes/_dev::new_hud( menu_name, "", x + x_offset, y + 265, 1 );
+	hud.menu[ 43 ] = maps/mp/gametypes/_dev::new_hud( menu_name, "", x + x_offset, y + 275, 1 );
+	return hud;
+#/
+}
+
+color( value )
+{
+/#
+	r = 1;
+	g = 1;
+	b = 0;
+	color = ( 0, 0, 0 );
+	if ( value > 0 )
+	{
+		r -= value;
+	}
+	else
+	{
+		g += value;
+	}
+	c = ( r, g, b );
+	return c;
+#/
+}
+
+dev_cac_gdt_update_think()
+{
+/#
+	for ( ;; )
+	{
+		level waittill( "gdt_update", asset, keyvalue );
+		keyvalue = strtok( keyvalue, "\\" );
+		key = keyvalue[ 0 ];
+		switch( key )
+		{
+			case "armorBullet":
+				key = "armor_bullet";
+				break;
+			case "armorExplosive":
+				key = "armor_explosive";
+				break;
+			case "moveSpeed":
+				key = "mobility";
+				break;
+			case "sprintTimeTotal":
+				key = "sprint_time_total";
+				break;
+			case "sprintTimeCooldown":
+				key = "sprint_time_cooldown";
+				break;
+			default:
+				key = undefined;
+				break;
+		}
+		if ( !isDefined( key ) )
+		{
+			continue;
+		}
+		else
+		{
+			value = float( keyvalue[ 1 ] );
+			level.cac_attributes[ key ][ asset ] = value;
+			players = get_players();
+			i = 0;
+			while ( i < players.size )
+			{
+				i++;
+			}
+		}
+#/
+	}
+}
+
+sort_greatest( function, attribute, greatest )
+{
+/#
+	keys = getarraykeys( level.cac_functions[ function ] );
+	greatest = keys[ 0 ];
+	i = 0;
+	while ( i < keys.size )
+	{
+		if ( level.cac_attributes[ attribute ][ keys[ i ] ] > level.cac_attributes[ attribute ][ greatest ] )
+		{
+			greatest = keys[ i ];
+		}
+		i++;
+	}
+	return greatest;
+#/
+}
+
+sort_least( function, attribute, least )
+{
+/#
+	keys = getarraykeys( level.cac_functions[ function ] );
+	least = keys[ 0 ];
+	i = 0;
+	while ( i < keys.size )
+	{
+		if ( level.cac_attributes[ attribute ][ keys[ i ] ] < level.cac_attributes[ attribute ][ least ] )
+		{
+			least = keys[ i ];
+		}
+		i++;
+	}
+	return least;
+#/
+}
+
+dev_cac_set_model_range( sort_function, attribute )
+{
+/#
+	if ( !dev_cac_player_valid() )
+	{
+		return;
+	}
+	player = level.dev_cac_player;
+	player.cac_body_type = [[ sort_function ]]( "set_body_model", attribute );
+	player.cac_head_type = [[ sort_function ]]( "set_head_model", attribute );
+	player.cac_hat_type = [[ sort_function ]]( "set_hat_model", attribute );
+	player dev_cac_set_player_model();
+#/
+}

patch_mp/maps/mp/gametypes/_friendicons.gsc

@@ -0,0 +1,113 @@
+
+init()
+{
+	if ( level.createfx_enabled || sessionmodeiszombiesgame() )
+	{
+		return;
+	}
+	if ( getDvar( "scr_drawfriend" ) == "" )
+	{
+		setdvar( "scr_drawfriend", "0" );
+	}
+	level.drawfriend = getDvarInt( "scr_drawfriend" );
+/#
+	assert( isDefined( game[ "headicon_allies" ] ), "Allied head icons are not defined.  Check the team set for the level." );
+#/
+/#
+	assert( isDefined( game[ "headicon_axis" ] ), "Axis head icons are not defined.  Check the team set for the level." );
+#/
+	precacheheadicon( game[ "headicon_allies" ] );
+	precacheheadicon( game[ "headicon_axis" ] );
+	level thread onplayerconnect();
+	for ( ;; )
+	{
+		updatefriendiconsettings();
+		wait 5;
+	}
+}
+
+onplayerconnect()
+{
+	for ( ;; )
+	{
+		level waittill( "connecting", player );
+		player thread onplayerspawned();
+		player thread onplayerkilled();
+	}
+}
+
+onplayerspawned()
+{
+	self endon( "disconnect" );
+	for ( ;; )
+	{
+		self waittill( "spawned_player" );
+		self thread showfriendicon();
+	}
+}
+
+onplayerkilled()
+{
+	self endon( "disconnect" );
+	for ( ;; )
+	{
+		self waittill( "killed_player" );
+		self.headicon = "";
+	}
+}
+
+showfriendicon()
+{
+	if ( level.drawfriend )
+	{
+		team = self.pers[ "team" ];
+		self.headicon = game[ "headicon_" + team ];
+		self.headiconteam = team;
+	}
+}
+
+updatefriendiconsettings()
+{
+	drawfriend = getDvarFloat( "scr_drawfriend" );
+	if ( level.drawfriend != drawfriend )
+	{
+		level.drawfriend = drawfriend;
+		updatefriendicons();
+	}
+}
+
+updatefriendicons()
+{
+	players = level.players;
+	i = 0;
+	while ( i < players.size )
+	{
+		player = players[ i ];
+		while ( isDefined( player.pers[ "team" ] ) && player.pers[ "team" ] != "spectator" && player.sessionstate == "playing" )
+		{
+			if ( level.drawfriend )
+			{
+				team = self.pers[ "team" ];
+				self.headicon = game[ "headicon_" + team ];
+				self.headiconteam = team;
+				i++;
+				continue;
+			}
+			else
+			{
+				players = level.players;
+				i = 0;
+				while ( i < players.size )
+				{
+					player = players[ i ];
+					if ( isDefined( player.pers[ "team" ] ) && player.pers[ "team" ] != "spectator" && player.sessionstate == "playing" )
+					{
+						player.headicon = "";
+					}
+					i++;
+				}
+			}
+		}
+		i++;
+	}
+}

patch_mp/maps/mp/gametypes/_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_mp/maps/mp/gametypes/_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_mp/maps/mp/gametypes/_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_mp/maps/mp/gametypes/_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_mp/maps/mp/gametypes/_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_mp/maps/mp/gametypes/_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_mp/maps/mp/gametypes/_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_mp/maps/mp/gametypes/_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_mp/maps/mp/gametypes/_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_mp/maps/mp/gametypes/_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_mp/maps/mp/gametypes/_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_mp/maps/mp/gametypes/_killcam.gsc

@@ -0,0 +1,789 @@
+#include maps/mp/gametypes/_globallogic_spawn;
+#include maps/mp/gametypes/_spectating;
+#include maps/mp/_tacticalinsertion;
+#include maps/mp/_challenges;
+#include maps/mp/gametypes/_globallogic;
+#include maps/mp/gametypes/_hud_util;
+#include maps/mp/_utility;
+
+init()
+{
+	precachestring( &"PLATFORM_PRESS_TO_SKIP" );
+	precachestring( &"PLATFORM_PRESS_TO_RESPAWN" );
+	precacheshader( "white" );
+	level.killcam = getgametypesetting( "allowKillcam" );
+	level.finalkillcam = getgametypesetting( "allowFinalKillcam" );
+	initfinalkillcam();
+}
+
+initfinalkillcam()
+{
+	level.finalkillcamsettings = [];
+	initfinalkillcamteam( "none" );
+	_a23 = level.teams;
+	_k23 = getFirstArrayKey( _a23 );
+	while ( isDefined( _k23 ) )
+	{
+		team = _a23[ _k23 ];
+		initfinalkillcamteam( team );
+		_k23 = getNextArrayKey( _a23, _k23 );
+	}
+	level.finalkillcam_winner = undefined;
+}
+
+initfinalkillcamteam( team )
+{
+	level.finalkillcamsettings[ team ] = spawnstruct();
+	clearfinalkillcamteam( team );
+}
+
+clearfinalkillcamteam( team )
+{
+	level.finalkillcamsettings[ team ].spectatorclient = undefined;
+	level.finalkillcamsettings[ team ].weapon = undefined;
+	level.finalkillcamsettings[ team ].deathtime = undefined;
+	level.finalkillcamsettings[ team ].deathtimeoffset = undefined;
+	level.finalkillcamsettings[ team ].offsettime = undefined;
+	level.finalkillcamsettings[ team ].entityindex = undefined;
+	level.finalkillcamsettings[ team ].targetentityindex = undefined;
+	level.finalkillcamsettings[ team ].entitystarttime = undefined;
+	level.finalkillcamsettings[ team ].perks = undefined;
+	level.finalkillcamsettings[ team ].killstreaks = undefined;
+	level.finalkillcamsettings[ team ].attacker = undefined;
+}
+
+recordkillcamsettings( spectatorclient, targetentityindex, sweapon, deathtime, deathtimeoffset, offsettime, entityindex, entitystarttime, perks, killstreaks, attacker )
+{
+	if ( level.teambased && isDefined( attacker.team ) && isDefined( level.teams[ attacker.team ] ) )
+	{
+		team = attacker.team;
+		level.finalkillcamsettings[ team ].spectatorclient = spectatorclient;
+		level.finalkillcamsettings[ team ].weapon = sweapon;
+		level.finalkillcamsettings[ team ].deathtime = deathtime;
+		level.finalkillcamsettings[ team ].deathtimeoffset = deathtimeoffset;
+		level.finalkillcamsettings[ team ].offsettime = offsettime;
+		level.finalkillcamsettings[ team ].entityindex = entityindex;
+		level.finalkillcamsettings[ team ].targetentityindex = targetentityindex;
+		level.finalkillcamsettings[ team ].entitystarttime = entitystarttime;
+		level.finalkillcamsettings[ team ].perks = perks;
+		level.finalkillcamsettings[ team ].killstreaks = killstreaks;
+		level.finalkillcamsettings[ team ].attacker = attacker;
+	}
+	level.finalkillcamsettings[ "none" ].spectatorclient = spectatorclient;
+	level.finalkillcamsettings[ "none" ].weapon = sweapon;
+	level.finalkillcamsettings[ "none" ].deathtime = deathtime;
+	level.finalkillcamsettings[ "none" ].deathtimeoffset = deathtimeoffset;
+	level.finalkillcamsettings[ "none" ].offsettime = offsettime;
+	level.finalkillcamsettings[ "none" ].entityindex = entityindex;
+	level.finalkillcamsettings[ "none" ].targetentityindex = targetentityindex;
+	level.finalkillcamsettings[ "none" ].entitystarttime = entitystarttime;
+	level.finalkillcamsettings[ "none" ].perks = perks;
+	level.finalkillcamsettings[ "none" ].killstreaks = killstreaks;
+	level.finalkillcamsettings[ "none" ].attacker = attacker;
+}
+
+erasefinalkillcam()
+{
+	clearfinalkillcamteam( "none" );
+	_a89 = level.teams;
+	_k89 = getFirstArrayKey( _a89 );
+	while ( isDefined( _k89 ) )
+	{
+		team = _a89[ _k89 ];
+		clearfinalkillcamteam( team );
+		_k89 = getNextArrayKey( _a89, _k89 );
+	}
+	level.finalkillcam_winner = undefined;
+}
+
+finalkillcamwaiter()
+{
+	if ( !isDefined( level.finalkillcam_winner ) )
+	{
+		return 0;
+	}
+	level waittill( "final_killcam_done" );
+	return 1;
+}
+
+postroundfinalkillcam()
+{
+	if ( isDefined( level.sidebet ) && level.sidebet )
+	{
+		return;
+	}
+	level notify( "play_final_killcam" );
+	maps/mp/gametypes/_globallogic::resetoutcomeforallplayers();
+	finalkillcamwaiter();
+}
+
+dofinalkillcam()
+{
+	level waittill( "play_final_killcam" );
+	level.infinalkillcam = 1;
+	winner = "none";
+	if ( isDefined( level.finalkillcam_winner ) )
+	{
+		winner = level.finalkillcam_winner;
+	}
+	if ( !isDefined( level.finalkillcamsettings[ winner ].targetentityindex ) )
+	{
+		level.infinalkillcam = 0;
+		level notify( "final_killcam_done" );
+		return;
+	}
+	if ( isDefined( level.finalkillcamsettings[ winner ].attacker ) )
+	{
+		maps/mp/_challenges::getfinalkill( level.finalkillcamsettings[ winner ].attacker );
+	}
+	visionsetnaked( getDvar( "mapname" ), 0 );
+	players = level.players;
+	index = 0;
+	while ( index < players.size )
+	{
+		player = players[ index ];
+		player closemenu();
+		player closeingamemenu();
+		player thread finalkillcam( winner );
+		index++;
+	}
+	wait 0,1;
+	while ( areanyplayerswatchingthekillcam() )
+	{
+		wait 0,05;
+	}
+	level notify( "final_killcam_done" );
+	level.infinalkillcam = 0;
+}
+
+startlastkillcam()
+{
+}
+
+areanyplayerswatchingthekillcam()
+{
+	players = level.players;
+	index = 0;
+	while ( index < players.size )
+	{
+		player = players[ index ];
+		if ( isDefined( player.killcam ) )
+		{
+			return 1;
+		}
+		index++;
+	}
+	return 0;
+}
+
+killcam( attackernum, targetnum, killcamentity, killcamentityindex, killcamentitystarttime, sweapon, deathtime, deathtimeoffset, offsettime, respawn, maxtime, perks, killstreaks, attacker )
+{
+	self endon( "disconnect" );
+	self endon( "spawned" );
+	level endon( "game_ended" );
+	if ( attackernum < 0 )
+	{
+		return;
+	}
+	postdeathdelay = ( getTime() - deathtime ) / 1000;
+	predelay = postdeathdelay + deathtimeoffset;
+	camtime = calckillcamtime( sweapon, killcamentitystarttime, predelay, respawn, maxtime );
+	postdelay = calcpostdelay();
+	killcamlength = camtime + postdelay;
+	if ( isDefined( maxtime ) && killcamlength > maxtime )
+	{
+		if ( maxtime < 2 )
+		{
+			return;
+		}
+		if ( ( maxtime - camtime ) >= 1 )
+		{
+			postdelay = maxtime - camtime;
+		}
+		else
+		{
+			postdelay = 1;
+			camtime = maxtime - 1;
+		}
+		killcamlength = camtime + postdelay;
+	}
+	killcamoffset = camtime + predelay;
+	self notify( "begin_killcam" );
+	killcamstarttime = getTime() - ( killcamoffset * 1000 );
+	self.sessionstate = "spectator";
+	self.spectatorclient = attackernum;
+	self.killcamentity = -1;
+	if ( killcamentityindex >= 0 )
+	{
+		self thread setkillcamentity( killcamentityindex, killcamentitystarttime - killcamstarttime - 100 );
+	}
+	self.killcamtargetentity = targetnum;
+	self.archivetime = killcamoffset;
+	self.killcamlength = killcamlength;
+	self.psoffsettime = offsettime;
+	recordkillcamsettings( attackernum, targetnum, sweapon, deathtime, deathtimeoffset, offsettime, killcamentityindex, killcamentitystarttime, perks, killstreaks, attacker );
+	_a268 = level.teams;
+	_k268 = getFirstArrayKey( _a268 );
+	while ( isDefined( _k268 ) )
+	{
+		team = _a268[ _k268 ];
+		self allowspectateteam( team, 1 );
+		_k268 = getNextArrayKey( _a268, _k268 );
+	}
+	self allowspectateteam( "freelook", 1 );
+	self allowspectateteam( "none", 1 );
+	self thread endedkillcamcleanup();
+	wait 0,05;
+	if ( self.archivetime <= predelay )
+	{
+		self.sessionstate = "dead";
+		self.spectatorclient = -1;
+		self.killcamentity = -1;
+		self.archivetime = 0;
+		self.psoffsettime = 0;
+		self notify( "end_killcam" );
+		return;
+	}
+	self thread checkforabruptkillcamend();
+	self.killcam = 1;
+	self addkillcamskiptext( respawn );
+	if ( !self issplitscreen() && level.perksenabled == 1 )
+	{
+		self addkillcamtimer( camtime );
+		self maps/mp/gametypes/_hud_util::showperks();
+	}
+	self thread spawnedkillcamcleanup();
+	self thread waitskipkillcambutton();
+	self thread waitteamchangeendkillcam();
+	self thread waitkillcamtime();
+	self thread maps/mp/_tacticalinsertion::cancel_button_think();
+	self waittill( "end_killcam" );
+	self endkillcam( 0 );
+	self.sessionstate = "dead";
+	self.spectatorclient = -1;
+	self.killcamentity = -1;
+	self.archivetime = 0;
+	self.psoffsettime = 0;
+}
+
+setkillcamentity( killcamentityindex, delayms )
+{
+	self endon( "disconnect" );
+	self endon( "end_killcam" );
+	self endon( "spawned" );
+	if ( delayms > 0 )
+	{
+		wait ( delayms / 1000 );
+	}
+	self.killcamentity = killcamentityindex;
+}
+
+waitkillcamtime()
+{
+	self endon( "disconnect" );
+	self endon( "end_killcam" );
+	wait ( self.killcamlength - 0,05 );
+	self notify( "end_killcam" );
+}
+
+waitfinalkillcamslowdown( deathtime, starttime )
+{
+	self endon( "disconnect" );
+	self endon( "end_killcam" );
+	secondsuntildeath = ( deathtime - starttime ) / 1000;
+	deathtime = getTime() + ( secondsuntildeath * 1000 );
+	waitbeforedeath = 2;
+	maps/mp/_utility::setclientsysstate( "levelNotify", "fkcb" );
+	wait max( 0, secondsuntildeath - waitbeforedeath );
+	setslowmotion( 1, 0,25, waitbeforedeath );
+	wait ( waitbeforedeath + 0,5 );
+	setslowmotion( 0,25, 1, 1 );
+	wait 0,5;
+	maps/mp/_utility::setclientsysstate( "levelNotify", "fkce" );
+}
+
+waitskipkillcambutton()
+{
+	self endon( "disconnect" );
+	self endon( "end_killcam" );
+	while ( self usebuttonpressed() )
+	{
+		wait 0,05;
+	}
+	while ( !self usebuttonpressed() )
+	{
+		wait 0,05;
+	}
+	self notify( "end_killcam" );
+	self clientnotify( "fkce" );
+}
+
+waitteamchangeendkillcam()
+{
+	self endon( "disconnect" );
+	self endon( "end_killcam" );
+	self waittill( "changed_class" );
+	endkillcam( 0 );
+}
+
+waitskipkillcamsafespawnbutton()
+{
+	self endon( "disconnect" );
+	self endon( "end_killcam" );
+	while ( self fragbuttonpressed() )
+	{
+		wait 0,05;
+	}
+	while ( !self fragbuttonpressed() )
+	{
+		wait 0,05;
+	}
+	self.wantsafespawn = 1;
+	self notify( "end_killcam" );
+}
+
+endkillcam( final )
+{
+	if ( isDefined( self.kc_skiptext ) )
+	{
+		self.kc_skiptext.alpha = 0;
+	}
+	if ( isDefined( self.kc_timer ) )
+	{
+		self.kc_timer.alpha = 0;
+	}
+	self.killcam = undefined;
+	if ( !self issplitscreen() )
+	{
+		self hideallperks();
+	}
+	self thread maps/mp/gametypes/_spectating::setspectatepermissions();
+}
+
+checkforabruptkillcamend()
+{
+	self endon( "disconnect" );
+	self endon( "end_killcam" );
+	while ( 1 )
+	{
+		if ( self.archivetime <= 0 )
+		{
+			break;
+		}
+		else
+		{
+			wait 0,05;
+		}
+	}
+	self notify( "end_killcam" );
+}
+
+spawnedkillcamcleanup()
+{
+	self endon( "end_killcam" );
+	self endon( "disconnect" );
+	self waittill( "spawned" );
+	self endkillcam( 0 );
+}
+
+spectatorkillcamcleanup( attacker )
+{
+	self endon( "end_killcam" );
+	self endon( "disconnect" );
+	attacker endon( "disconnect" );
+	attacker waittill( "begin_killcam", attackerkcstarttime );
+	waittime = max( 0, attackerkcstarttime - self.deathtime - 50 );
+	wait waittime;
+	self endkillcam( 0 );
+}
+
+endedkillcamcleanup()
+{
+	self endon( "end_killcam" );
+	self endon( "disconnect" );
+	level waittill( "game_ended" );
+	self endkillcam( 0 );
+}
+
+endedfinalkillcamcleanup()
+{
+	self endon( "end_killcam" );
+	self endon( "disconnect" );
+	level waittill( "game_ended" );
+	self endkillcam( 1 );
+}
+
+cancelkillcamusebutton()
+{
+	return self usebuttonpressed();
+}
+
+cancelkillcamsafespawnbutton()
+{
+	return self fragbuttonpressed();
+}
+
+cancelkillcamcallback()
+{
+	self.cancelkillcam = 1;
+}
+
+cancelkillcamsafespawncallback()
+{
+	self.cancelkillcam = 1;
+	self.wantsafespawn = 1;
+}
+
+cancelkillcamonuse()
+{
+	self thread cancelkillcamonuse_specificbutton( ::cancelkillcamusebutton, ::cancelkillcamcallback );
+}
+
+cancelkillcamonuse_specificbutton( pressingbuttonfunc, finishedfunc )
+{
+	self endon( "death_delay_finished" );
+	self endon( "disconnect" );
+	level endon( "game_ended" );
+	for ( ;; )
+	{
+		if ( !( self [[ pressingbuttonfunc ]]() ) )
+		{
+			wait 0,05;
+			continue;
+		}
+		else buttontime = 0;
+		while ( self [[ pressingbuttonfunc ]]() )
+		{
+			buttontime += 0,05;
+			wait 0,05;
+		}
+		if ( buttontime >= 0,5 )
+		{
+			continue;
+		}
+		else buttontime = 0;
+		while ( !( self [[ pressingbuttonfunc ]]() ) && buttontime < 0,5 )
+		{
+			buttontime += 0,05;
+			wait 0,05;
+		}
+		if ( buttontime >= 0,5 )
+		{
+			continue;
+		}
+		else
+		{
+			self [[ finishedfunc ]]();
+			return;
+		}
+	}
+}
+
+finalkillcam( winner )
+{
+	self endon( "disconnect" );
+	level endon( "game_ended" );
+	if ( waslastround() )
+	{
+		setmatchflag( "final_killcam", 1 );
+		setmatchflag( "round_end_killcam", 0 );
+	}
+	else
+	{
+		setmatchflag( "final_killcam", 0 );
+		setmatchflag( "round_end_killcam", 1 );
+	}
+/#
+	if ( getDvarInt( "scr_force_finalkillcam" ) == 1 )
+	{
+		setmatchflag( "final_killcam", 1 );
+		setmatchflag( "round_end_killcam", 0 );
+#/
+	}
+	if ( level.console )
+	{
+		self maps/mp/gametypes/_globallogic_spawn::setthirdperson( 0 );
+	}
+	killcamsettings = level.finalkillcamsettings[ winner ];
+	postdeathdelay = ( getTime() - killcamsettings.deathtime ) / 1000;
+	predelay = postdeathdelay + killcamsettings.deathtimeoffset;
+	camtime = calckillcamtime( killcamsettings.weapon, killcamsettings.entitystarttime, predelay, 0, undefined );
+	postdelay = calcpostdelay();
+	killcamoffset = camtime + predelay;
+	killcamlength = ( camtime + postdelay ) - 0,05;
+	killcamstarttime = getTime() - ( killcamoffset * 1000 );
+	self notify( "begin_killcam" );
+	self.sessionstate = "spectator";
+	self.spectatorclient = killcamsettings.spectatorclient;
+	self.killcamentity = -1;
+	if ( killcamsettings.entityindex >= 0 )
+	{
+		self thread setkillcamentity( killcamsettings.entityindex, killcamsettings.entitystarttime - killcamstarttime - 100 );
+	}
+	self.killcamtargetentity = killcamsettings.targetentityindex;
+	self.archivetime = killcamoffset;
+	self.killcamlength = killcamlength;
+	self.psoffsettime = killcamsettings.offsettime;
+	_a613 = level.teams;
+	_k613 = getFirstArrayKey( _a613 );
+	while ( isDefined( _k613 ) )
+	{
+		team = _a613[ _k613 ];
+		self allowspectateteam( team, 1 );
+		_k613 = getNextArrayKey( _a613, _k613 );
+	}
+	self allowspectateteam( "freelook", 1 );
+	self allowspectateteam( "none", 1 );
+	self thread endedfinalkillcamcleanup();
+	wait 0,05;
+	if ( self.archivetime <= predelay )
+	{
+		self.sessionstate = "dead";
+		self.spectatorclient = -1;
+		self.killcamentity = -1;
+		self.archivetime = 0;
+		self.psoffsettime = 0;
+		self notify( "end_killcam" );
+		return;
+	}
+	self thread checkforabruptkillcamend();
+	self.killcam = 1;
+	if ( !self issplitscreen() )
+	{
+		self addkillcamtimer( camtime );
+	}
+	self thread waitkillcamtime();
+	self thread waitfinalkillcamslowdown( level.finalkillcamsettings[ winner ].deathtime, killcamstarttime );
+	self waittill( "end_killcam" );
+	self endkillcam( 1 );
+	setmatchflag( "final_killcam", 0 );
+	setmatchflag( "round_end_killcam", 0 );
+	self spawnendoffinalkillcam();
+}
+
+spawnendoffinalkillcam()
+{
+	[[ level.spawnspectator ]]();
+	self freezecontrols( 1 );
+}
+
+iskillcamentityweapon( sweapon )
+{
+	if ( sweapon == "planemortar_mp" )
+	{
+		return 1;
+	}
+	return 0;
+}
+
+iskillcamgrenadeweapon( sweapon )
+{
+	if ( sweapon == "frag_grenade_mp" )
+	{
+		return 1;
+	}
+	else
+	{
+		if ( sweapon == "frag_grenade_short_mp" )
+		{
+			return 1;
+		}
+		else
+		{
+			if ( sweapon == "sticky_grenade_mp" )
+			{
+				return 1;
+			}
+			else
+			{
+				if ( sweapon == "tabun_gas_mp" )
+				{
+					return 1;
+				}
+			}
+		}
+	}
+	return 0;
+}
+
+calckillcamtime( sweapon, entitystarttime, predelay, respawn, maxtime )
+{
+	camtime = 0;
+	if ( getDvar( #"C45D9077" ) == "" )
+	{
+		if ( iskillcamentityweapon( sweapon ) )
+		{
+			camtime = ( ( getTime() - entitystarttime ) / 1000 ) - predelay - 0,1;
+		}
+		else if ( !respawn )
+		{
+			camtime = 5;
+		}
+		else if ( iskillcamgrenadeweapon( sweapon ) )
+		{
+			camtime = 4,25;
+		}
+		else
+		{
+			camtime = 2,5;
+		}
+	}
+	else
+	{
+		camtime = getDvarFloat( #"C45D9077" );
+	}
+	if ( isDefined( maxtime ) )
+	{
+		if ( camtime > maxtime )
+		{
+			camtime = maxtime;
+		}
+		if ( camtime < 0,05 )
+		{
+			camtime = 0,05;
+		}
+	}
+	return camtime;
+}
+
+calcpostdelay()
+{
+	postdelay = 0;
+	if ( getDvar( #"0D34D95D" ) == "" )
+	{
+		postdelay = 2;
+	}
+	else
+	{
+		postdelay = getDvarFloat( #"0D34D95D" );
+		if ( postdelay < 0,05 )
+		{
+			postdelay = 0,05;
+		}
+	}
+	return postdelay;
+}
+
+addkillcamskiptext( respawn )
+{
+	if ( !isDefined( self.kc_skiptext ) )
+	{
+		self.kc_skiptext = newclienthudelem( self );
+		self.kc_skiptext.archived = 0;
+		self.kc_skiptext.x = 0;
+		self.kc_skiptext.alignx = "center";
+		self.kc_skiptext.aligny = "middle";
+		self.kc_skiptext.horzalign = "center";
+		self.kc_skiptext.vertalign = "bottom";
+		self.kc_skiptext.sort = 1;
+		self.kc_skiptext.font = "objective";
+	}
+	if ( self issplitscreen() )
+	{
+		self.kc_skiptext.y = -100;
+		self.kc_skiptext.fontscale = 1,4;
+	}
+	else
+	{
+		self.kc_skiptext.y = -120;
+		self.kc_skiptext.fontscale = 2;
+	}
+	if ( respawn )
+	{
+		self.kc_skiptext settext( &"PLATFORM_PRESS_TO_RESPAWN" );
+	}
+	else
+	{
+		self.kc_skiptext settext( &"PLATFORM_PRESS_TO_SKIP" );
+	}
+	self.kc_skiptext.alpha = 1;
+}
+
+addkillcamtimer( camtime )
+{
+}
+
+initkcelements()
+{
+	if ( !isDefined( self.kc_skiptext ) )
+	{
+		self.kc_skiptext = newclienthudelem( self );
+		self.kc_skiptext.archived = 0;
+		self.kc_skiptext.x = 0;
+		self.kc_skiptext.alignx = "center";
+		self.kc_skiptext.aligny = "top";
+		self.kc_skiptext.horzalign = "center_adjustable";
+		self.kc_skiptext.vertalign = "top_adjustable";
+		self.kc_skiptext.sort = 1;
+		self.kc_skiptext.font = "default";
+		self.kc_skiptext.foreground = 1;
+		self.kc_skiptext.hidewheninmenu = 1;
+		if ( self issplitscreen() )
+		{
+			self.kc_skiptext.y = 20;
+			self.kc_skiptext.fontscale = 1,2;
+		}
+		else
+		{
+			self.kc_skiptext.y = 32;
+			self.kc_skiptext.fontscale = 1,8;
+		}
+	}
+	if ( !isDefined( self.kc_othertext ) )
+	{
+		self.kc_othertext = newclienthudelem( self );
+		self.kc_othertext.archived = 0;
+		self.kc_othertext.y = 48;
+		self.kc_othertext.alignx = "left";
+		self.kc_othertext.aligny = "top";
+		self.kc_othertext.horzalign = "center";
+		self.kc_othertext.vertalign = "middle";
+		self.kc_othertext.sort = 10;
+		self.kc_othertext.font = "small";
+		self.kc_othertext.foreground = 1;
+		self.kc_othertext.hidewheninmenu = 1;
+		if ( self issplitscreen() )
+		{
+			self.kc_othertext.x = 16;
+			self.kc_othertext.fontscale = 1,2;
+		}
+		else
+		{
+			self.kc_othertext.x = 32;
+			self.kc_othertext.fontscale = 1,6;
+		}
+	}
+	if ( !isDefined( self.kc_icon ) )
+	{
+		self.kc_icon = newclienthudelem( self );
+		self.kc_icon.archived = 0;
+		self.kc_icon.x = 16;
+		self.kc_icon.y = 16;
+		self.kc_icon.alignx = "left";
+		self.kc_icon.aligny = "top";
+		self.kc_icon.horzalign = "center";
+		self.kc_icon.vertalign = "middle";
+		self.kc_icon.sort = 1;
+		self.kc_icon.foreground = 1;
+		self.kc_icon.hidewheninmenu = 1;
+	}
+	if ( !self issplitscreen() )
+	{
+		if ( !isDefined( self.kc_timer ) )
+		{
+			self.kc_timer = createfontstring( "hudbig", 1 );
+			self.kc_timer.archived = 0;
+			self.kc_timer.x = 0;
+			self.kc_timer.alignx = "center";
+			self.kc_timer.aligny = "middle";
+			self.kc_timer.horzalign = "center_safearea";
+			self.kc_timer.vertalign = "top_adjustable";
+			self.kc_timer.y = 42;
+			self.kc_timer.sort = 1;
+			self.kc_timer.font = "hudbig";
+			self.kc_timer.foreground = 1;
+			self.kc_timer.color = vectorScale( ( 1, 1, 1 ), 0,85 );
+			self.kc_timer.hidewheninmenu = 1;
+		}
+	}
+}

patch_mp/maps/mp/gametypes/_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_mp/maps/mp/gametypes/_objpoints.gsc

@@ -0,0 +1,175 @@
+#include maps/mp/gametypes/_hud_util;
+#include maps/mp/_utility;
+
+init()
+{
+	precacheshader( "objpoint_default" );
+	level.objpointnames = [];
+	level.objpoints = [];
+	if ( level.splitscreen )
+	{
+		level.objpointsize = 15;
+	}
+	else
+	{
+		level.objpointsize = 8;
+	}
+	level.objpoint_alpha_default = 0,5;
+	level.objpointscale = 1;
+}
+
+createteamobjpoint( name, origin, team, shader, alpha, scale )
+{
+/#
+	if ( !isDefined( level.teams[ team ] ) )
+	{
+		assert( team == "all" );
+	}
+#/
+	objpoint = getobjpointbyname( name );
+	if ( isDefined( objpoint ) )
+	{
+		deleteobjpoint( objpoint );
+	}
+	if ( !isDefined( shader ) )
+	{
+		shader = "objpoint_default";
+	}
+	if ( !isDefined( scale ) )
+	{
+		scale = 1;
+	}
+	if ( team != "all" )
+	{
+		objpoint = newteamhudelem( team );
+	}
+	else
+	{
+		objpoint = newhudelem();
+	}
+	objpoint.name = name;
+	objpoint.x = origin[ 0 ];
+	objpoint.y = origin[ 1 ];
+	objpoint.z = origin[ 2 ];
+	objpoint.team = team;
+	objpoint.isflashing = 0;
+	objpoint.isshown = 1;
+	objpoint.fadewhentargeted = 1;
+	objpoint.archived = 0;
+	objpoint setshader( shader, level.objpointsize, level.objpointsize );
+	objpoint setwaypoint( 1 );
+	if ( isDefined( alpha ) )
+	{
+		objpoint.alpha = alpha;
+	}
+	else
+	{
+		objpoint.alpha = level.objpoint_alpha_default;
+	}
+	objpoint.basealpha = objpoint.alpha;
+	objpoint.index = level.objpointnames.size;
+	level.objpoints[ name ] = objpoint;
+	level.objpointnames[ level.objpointnames.size ] = name;
+	return objpoint;
+}
+
+deleteobjpoint( oldobjpoint )
+{
+/#
+	assert( level.objpoints.size == level.objpointnames.size );
+#/
+	if ( level.objpoints.size == 1 )
+	{
+/#
+		assert( level.objpointnames[ 0 ] == oldobjpoint.name );
+#/
+/#
+		assert( isDefined( level.objpoints[ oldobjpoint.name ] ) );
+#/
+		level.objpoints = [];
+		level.objpointnames = [];
+		oldobjpoint destroy();
+		return;
+	}
+	newindex = oldobjpoint.index;
+	oldindex = level.objpointnames.size - 1;
+	objpoint = getobjpointbyindex( oldindex );
+	level.objpointnames[ newindex ] = objpoint.name;
+	objpoint.index = newindex;
+	oldobjpoint destroy();
+}
+
+updateorigin( origin )
+{
+	if ( self.x != origin[ 0 ] )
+	{
+		self.x = origin[ 0 ];
+	}
+	if ( self.y != origin[ 1 ] )
+	{
+		self.y = origin[ 1 ];
+	}
+	if ( self.z != origin[ 2 ] )
+	{
+		self.z = origin[ 2 ];
+	}
+}
+
+setoriginbyname( name, origin )
+{
+	objpoint = getobjpointbyname( name );
+	objpoint updateorigin( origin );
+}
+
+getobjpointbyname( name )
+{
+	if ( isDefined( level.objpoints[ name ] ) )
+	{
+		return level.objpoints[ name ];
+	}
+	else
+	{
+		return undefined;
+	}
+}
+
+getobjpointbyindex( index )
+{
+	if ( isDefined( level.objpointnames[ index ] ) )
+	{
+		return level.objpoints[ level.objpointnames[ index ] ];
+	}
+	else
+	{
+		return undefined;
+	}
+}
+
+startflashing()
+{
+	self endon( "stop_flashing_thread" );
+	if ( self.isflashing )
+	{
+		return;
+	}
+	self.isflashing = 1;
+	while ( self.isflashing )
+	{
+		self fadeovertime( 0,75 );
+		self.alpha = 0,35 * self.basealpha;
+		wait 0,75;
+		self fadeovertime( 0,75 );
+		self.alpha = self.basealpha;
+		wait 0,75;
+	}
+	self.alpha = self.basealpha;
+}
+
+stopflashing()
+{
+	if ( !self.isflashing )
+	{
+		return;
+	}
+	self.isflashing = 0;
+}

patch_mp/maps/mp/gametypes/_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_mp/maps/mp/gametypes/_persistence.gsc

@@ -0,0 +1,499 @@
+#include maps/mp/gametypes/_persistence;
+#include maps/mp/gametypes/_globallogic;
+#include maps/mp/bots/_bot;
+#include maps/mp/_utility;
+
+init()
+{
+	level.persistentdatainfo = [];
+	level.maxrecentstats = 10;
+	level.maxhitlocations = 19;
+	maps/mp/gametypes/_class::init();
+	maps/mp/gametypes/_rank::init();
+	level thread maps/mp/_challenges::init();
+	level thread maps/mp/_medals::init();
+	level thread maps/mp/_scoreevents::init();
+	maps/mp/_popups::init();
+	level thread onplayerconnect();
+	level thread initializestattracking();
+	level thread uploadglobalstatcounters();
+}
+
+onplayerconnect()
+{
+	for ( ;; )
+	{
+		level waittill( "connected", player );
+		player.enabletext = 1;
+	}
+}
+
+initializestattracking()
+{
+	level.globalexecutions = 0;
+	level.globalchallenges = 0;
+	level.globalsharepackages = 0;
+	level.globalcontractsfailed = 0;
+	level.globalcontractspassed = 0;
+	level.globalcontractscppaid = 0;
+	level.globalkillstreakscalled = 0;
+	level.globalkillstreaksdestroyed = 0;
+	level.globalkillstreaksdeathsfrom = 0;
+	level.globallarryskilled = 0;
+	level.globalbuzzkills = 0;
+	level.globalrevives = 0;
+	level.globalafterlifes = 0;
+	level.globalcomebacks = 0;
+	level.globalpaybacks = 0;
+	level.globalbackstabs = 0;
+	level.globalbankshots = 0;
+	level.globalskewered = 0;
+	level.globalteammedals = 0;
+	level.globalfeetfallen = 0;
+	level.globaldistancesprinted = 0;
+	level.globaldembombsprotected = 0;
+	level.globaldembombsdestroyed = 0;
+	level.globalbombsdestroyed = 0;
+	level.globalfraggrenadesfired = 0;
+	level.globalsatchelchargefired = 0;
+	level.globalshotsfired = 0;
+	level.globalcrossbowfired = 0;
+	level.globalcarsdestroyed = 0;
+	level.globalbarrelsdestroyed = 0;
+	level.globalbombsdestroyedbyteam = [];
+	_a67 = level.teams;
+	_k67 = getFirstArrayKey( _a67 );
+	while ( isDefined( _k67 ) )
+	{
+		team = _a67[ _k67 ];
+		level.globalbombsdestroyedbyteam[ team ] = 0;
+		_k67 = getNextArrayKey( _a67, _k67 );
+	}
+}
+
+uploadglobalstatcounters()
+{
+	level waittill( "game_ended" );
+	if ( !level.rankedmatch && !level.wagermatch )
+	{
+		return;
+	}
+	totalkills = 0;
+	totaldeaths = 0;
+	totalassists = 0;
+	totalheadshots = 0;
+	totalsuicides = 0;
+	totaltimeplayed = 0;
+	totalflagscaptured = 0;
+	totalflagsreturned = 0;
+	totalhqsdestroyed = 0;
+	totalhqscaptured = 0;
+	totalsddefused = 0;
+	totalsdplants = 0;
+	totalhumiliations = 0;
+	totalsabdestroyedbyteam = [];
+	_a95 = level.teams;
+	_k95 = getFirstArrayKey( _a95 );
+	while ( isDefined( _k95 ) )
+	{
+		team = _a95[ _k95 ];
+		totalsabdestroyedbyteam[ team ] = 0;
+		_k95 = getNextArrayKey( _a95, _k95 );
+	}
+	switch( level.gametype )
+	{
+		case "dem":
+			bombzonesleft = 0;
+			index = 0;
+			while ( index < level.bombzones.size )
+			{
+				if ( !isDefined( level.bombzones[ index ].bombexploded ) || !level.bombzones[ index ].bombexploded )
+				{
+					level.globaldembombsprotected++;
+					index++;
+					continue;
+				}
+				else
+				{
+					level.globaldembombsdestroyed++;
+				}
+				index++;
+			}
+			case "sab":
+				_a117 = level.teams;
+				_k117 = getFirstArrayKey( _a117 );
+				while ( isDefined( _k117 ) )
+				{
+					team = _a117[ _k117 ];
+					totalsabdestroyedbyteam[ team ] = level.globalbombsdestroyedbyteam[ team ];
+					_k117 = getNextArrayKey( _a117, _k117 );
+				}
+			}
+			players = get_players();
+			i = 0;
+			while ( i < players.size )
+			{
+				player = players[ i ];
+				totaltimeplayed += min( player.timeplayed[ "total" ], level.timeplayedcap );
+				i++;
+			}
+			incrementcounter( "global_executions", level.globalexecutions );
+			incrementcounter( "global_sharedpackagemedals", level.globalsharepackages );
+			incrementcounter( "global_dem_bombsdestroyed", level.globaldembombsdestroyed );
+			incrementcounter( "global_dem_bombsprotected", level.globaldembombsprotected );
+			incrementcounter( "global_contracts_failed", level.globalcontractsfailed );
+			incrementcounter( "global_killstreaks_called", level.globalkillstreakscalled );
+			incrementcounter( "global_killstreaks_destroyed", level.globalkillstreaksdestroyed );
+			incrementcounter( "global_killstreaks_deathsfrom", level.globalkillstreaksdeathsfrom );
+			incrementcounter( "global_buzzkills", level.globalbuzzkills );
+			incrementcounter( "global_revives", level.globalrevives );
+			incrementcounter( "global_afterlifes", level.globalafterlifes );
+			incrementcounter( "global_comebacks", level.globalcomebacks );
+			incrementcounter( "global_paybacks", level.globalpaybacks );
+			incrementcounter( "global_backstabs", level.globalbackstabs );
+			incrementcounter( "global_bankshots", level.globalbankshots );
+			incrementcounter( "global_skewered", level.globalskewered );
+			incrementcounter( "global_teammedals", level.globalteammedals );
+			incrementcounter( "global_fraggrenadesthrown", level.globalfraggrenadesfired );
+			incrementcounter( "global_c4thrown", level.globalsatchelchargefired );
+			incrementcounter( "global_shotsfired", level.globalshotsfired );
+			incrementcounter( "global_crossbowfired", level.globalcrossbowfired );
+			incrementcounter( "global_carsdestroyed", level.globalcarsdestroyed );
+			incrementcounter( "global_barrelsdestroyed", level.globalbarrelsdestroyed );
+			incrementcounter( "global_challenges_finished", level.globalchallenges );
+			incrementcounter( "global_contractscppaid", level.globalcontractscppaid );
+			incrementcounter( "global_distancesprinted100inches", int( level.globaldistancesprinted ) );
+			incrementcounter( "global_combattraining_botskilled", level.globallarryskilled );
+			incrementcounter( "global_distancefeetfallen", int( level.globalfeetfallen ) );
+			incrementcounter( "global_minutes", int( totaltimeplayed / 60 ) );
+			if ( !waslastround() )
+			{
+				return;
+			}
+			wait 0,05;
+			players = get_players();
+			i = 0;
+			while ( i < players.size )
+			{
+				player = players[ i ];
+				totalkills += player.kills;
+				totaldeaths += player.deaths;
+				totalassists += player.assists;
+				totalheadshots += player.headshots;
+				totalsuicides += player.suicides;
+				totalhumiliations += player.humiliated;
+				totaltimeplayed += int( min( player.timeplayed[ "alive" ], level.timeplayedcap ) );
+				switch( level.gametype )
+				{
+					case "ctf":
+						totalflagscaptured += player.captures;
+						totalflagsreturned += player.returns;
+						break;
+					i++;
+					continue;
+					case "koth":
+						totalhqsdestroyed += player.destructions;
+						totalhqscaptured += player.captures;
+						break;
+					i++;
+					continue;
+					case "sd":
+						totalsddefused += player.defuses;
+						totalsdplants += player.plants;
+						break;
+					i++;
+					continue;
+					case "sab":
+						if ( isDefined( player.team ) && isDefined( level.teams[ player.team ] ) )
+						{
+							totalsabdestroyedbyteam[ player.team ] += player.destructions;
+						}
+						break;
+					i++;
+					continue;
+				}
+				i++;
+			}
+			if ( maps/mp/bots/_bot::is_bot_ranked_match() )
+			{
+				incrementcounter( "global_combattraining_gamesplayed", 1 );
+			}
+			incrementcounter( "global_kills", totalkills );
+			incrementcounter( "global_deaths", totaldeaths );
+			incrementcounter( "global_assists", totalassists );
+			incrementcounter( "global_headshots", totalheadshots );
+			incrementcounter( "global_suicides", totalsuicides );
+			incrementcounter( "global_games", 1 );
+			incrementcounter( "global_ctf_flagscaptured", totalflagscaptured );
+			incrementcounter( "global_ctf_flagsreturned", totalflagsreturned );
+			incrementcounter( "global_hq_destroyed", totalhqsdestroyed );
+			incrementcounter( "global_hq_captured", totalhqscaptured );
+			incrementcounter( "global_snd_defuses", totalsddefused );
+			incrementcounter( "global_snd_plants", totalsdplants );
+			incrementcounter( "global_sab_destroyedbyops", totalsabdestroyedbyteam[ "allies" ] );
+			incrementcounter( "global_sab_destroyedbycommunists", totalsabdestroyedbyteam[ "axis" ] );
+			incrementcounter( "global_humiliations", totalhumiliations );
+			if ( isDefined( game[ "wager_pot" ] ) )
+			{
+				incrementcounter( "global_wageredcp", game[ "wager_pot" ] );
+			}
+		}
+	}
+}
+
+statgetwithgametype( dataname )
+{
+	if ( isDefined( level.nopersistence ) && level.nopersistence )
+	{
+		return 0;
+	}
+	if ( !level.onlinegame )
+	{
+		return 0;
+	}
+	return self getdstat( "PlayerStatsByGameType", getgametypename(), dataname, "StatValue" );
+}
+
+getgametypename()
+{
+	if ( !isDefined( level.fullgametypename ) )
+	{
+		if ( isDefined( level.hardcoremode ) && level.hardcoremode && ispartygamemode() == 0 )
+		{
+			prefix = "HC";
+		}
+		else
+		{
+			prefix = "";
+		}
+		level.fullgametypename = tolower( prefix + level.gametype );
+	}
+	return level.fullgametypename;
+}
+
+ispartygamemode()
+{
+	switch( level.gametype )
+	{
+		case "gun":
+		case "oic":
+		case "sas":
+		case "shrp":
+			return 1;
+		}
+		return 0;
+	}
+}
+
+isstatmodifiable( dataname )
+{
+	if ( !level.rankedmatch )
+	{
+		return level.wagermatch;
+	}
+}
+
+statsetwithgametype( dataname, value, incvalue )
+{
+	if ( isDefined( level.nopersistence ) && level.nopersistence )
+	{
+		return 0;
+	}
+	if ( !isstatmodifiable( dataname ) )
+	{
+		return;
+	}
+	if ( level.disablestattracking )
+	{
+		return;
+	}
+	self setdstat( "PlayerStatsByGameType", getgametypename(), dataname, "StatValue", value );
+}
+
+adjustrecentstats()
+{
+/#
+	if ( getDvarInt( "scr_writeConfigStrings" ) == 1 || getDvarInt( "scr_hostmigrationtest" ) == 1 )
+	{
+		return;
+#/
+	}
+	initializematchstats();
+}
+
+getrecentstat( isglobal, index, statname )
+{
+	if ( level.wagermatch )
+	{
+		return self getdstat( "RecentEarnings", index, statname );
+	}
+	else
+	{
+		if ( isglobal )
+		{
+			modename = maps/mp/gametypes/_globallogic::getcurrentgamemode();
+			return self getdstat( "gameHistory", modename, "matchHistory", index, statname );
+		}
+		else
+		{
+			return self getdstat( "PlayerStatsByGameType", getgametypename(), "prevScores", index, statname );
+		}
+	}
+}
+
+setrecentstat( isglobal, index, statname, value )
+{
+	if ( isDefined( level.nopersistence ) && level.nopersistence )
+	{
+		return;
+	}
+	if ( !level.onlinegame )
+	{
+		return;
+	}
+	if ( !isstatmodifiable( statname ) )
+	{
+		return;
+	}
+	if ( index < 0 || index > 9 )
+	{
+		return;
+	}
+	if ( level.wagermatch )
+	{
+		self setdstat( "RecentEarnings", index, statname, value );
+	}
+	else if ( isglobal )
+	{
+		modename = maps/mp/gametypes/_globallogic::getcurrentgamemode();
+		self setdstat( "gameHistory", modename, "matchHistory", "" + index, statname, value );
+		return;
+	}
+	else
+	{
+		self setdstat( "PlayerStatsByGameType", getgametypename(), "prevScores", index, statname, value );
+		return;
+	}
+}
+
+addrecentstat( isglobal, index, statname, value )
+{
+	if ( isDefined( level.nopersistence ) && level.nopersistence )
+	{
+		return;
+	}
+	if ( !level.onlinegame )
+	{
+		return;
+	}
+	if ( !isstatmodifiable( statname ) )
+	{
+		return;
+	}
+	currstat = getrecentstat( isglobal, index, statname );
+	setrecentstat( isglobal, index, statname, currstat + value );
+}
+
+setmatchhistorystat( statname, value )
+{
+	modename = maps/mp/gametypes/_globallogic::getcurrentgamemode();
+	historyindex = self getdstat( "gameHistory", modename, "currentMatchHistoryIndex" );
+	setrecentstat( 1, historyindex, statname, value );
+}
+
+addmatchhistorystat( statname, value )
+{
+	modename = maps/mp/gametypes/_globallogic::getcurrentgamemode();
+	historyindex = self getdstat( "gameHistory", modename, "currentMatchHistoryIndex" );
+	addrecentstat( 1, historyindex, statname, value );
+}
+
+initializematchstats()
+{
+	if ( isDefined( level.nopersistence ) && level.nopersistence )
+	{
+		return;
+	}
+	if ( !level.onlinegame )
+	{
+		return;
+	}
+	if ( !level.rankedmatch && !level.wagermatch && !level.leaguematch )
+	{
+		return;
+	}
+	self.pers[ "lastHighestScore" ] = self getdstat( "HighestStats", "highest_score" );
+	currgametype = maps/mp/gametypes/_persistence::getgametypename();
+	self gamehistorystartmatch( getgametypeenumfromname( currgametype, level.hardcoremode ) );
+}
+
+setafteractionreportstat( statname, value, index )
+{
+	if ( self is_bot() )
+	{
+		return;
+	}
+/#
+	if ( getDvarInt( "scr_writeConfigStrings" ) == 1 || getDvarInt( "scr_hostmigrationtest" ) == 1 )
+	{
+		return;
+#/
+	}
+	if ( !level.rankedmatch || level.wagermatch && level.leaguematch )
+	{
+		if ( isDefined( index ) )
+		{
+			self setdstat( "AfterActionReportStats", statname, index, value );
+			return;
+		}
+		else
+		{
+			self setdstat( "AfterActionReportStats", statname, value );
+		}
+	}
+}
+
+codecallback_challengecomplete( rewardxp, maxval, row, tablenumber, challengetype, itemindex, challengeindex )
+{
+	self luinotifyevent( &"challenge_complete", 7, challengeindex, itemindex, challengetype, tablenumber, row, maxval, rewardxp );
+	self luinotifyeventtospectators( &"challenge_complete", 7, challengeindex, itemindex, challengetype, tablenumber, row, maxval, rewardxp );
+}
+
+codecallback_gunchallengecomplete( rewardxp, attachmentindex, itemindex, rankid )
+{
+	self luinotifyevent( &"gun_level_complete", 4, rankid, itemindex, attachmentindex, rewardxp );
+	self luinotifyeventtospectators( &"gun_level_complete", 4, rankid, itemindex, attachmentindex, rewardxp );
+}
+
+checkcontractexpirations()
+{
+}
+
+incrementcontracttimes( timeinc )
+{
+}
+
+addcontracttoqueue( index, passed )
+{
+}
+
+uploadstatssoon()
+{
+	self notify( "upload_stats_soon" );
+	self endon( "upload_stats_soon" );
+	self endon( "disconnect" );
+	wait 1;
+	uploadstats( self );
+}
+
+codecallback_onaddplayerstat( dataname, value )
+{
+}
+
+codecallback_onaddweaponstat( weapname, dataname, value )
+{
+}
+
+processcontractsonaddstat( stattype, dataname, value, weapname )
+{
+}

patch_mp/maps/mp/gametypes/_pregame.gsc

@@ -0,0 +1,300 @@
+#include maps/mp/gametypes/_globallogic_score;
+#include maps/mp/gametypes/_globallogic_utils;
+#include maps/mp/gametypes/_globallogic_ui;
+#include maps/mp/gametypes/_hud;
+#include maps/mp/gametypes/_globallogic_player;
+#include maps/mp/gametypes/_spawning;
+#include maps/mp/gametypes/_spawnlogic;
+#include maps/mp/gametypes/_hud_util;
+#include maps/mp/_utility;
+
+main()
+{
+	level.pregame = 1;
+/#
+	println( "Pregame main() level.pregame = " + level.pregame + "\n" );
+#/
+	maps/mp/gametypes/_globallogic::init();
+	maps/mp/gametypes/_callbacksetup::setupcallbacks();
+	maps/mp/gametypes/_globallogic::setupcallbacks();
+	registertimelimit( 0, 1440 );
+	registerscorelimit( 0, 5000 );
+	registerroundlimit( 0, 1 );
+	registerroundwinlimit( 0, 0 );
+	registernumlives( 0, 0 );
+	level.onstartgametype = ::onstartgametype;
+	level.onspawnplayer = ::onspawnplayer;
+	level.onspawnplayerunified = ::onspawnplayerunified;
+	level.onendgame = ::onendgame;
+	level.ontimelimit = ::ontimelimit;
+	game[ "dialog" ][ "gametype" ] = "pregame_start";
+	game[ "dialog" ][ "offense_obj" ] = "generic_boost";
+	game[ "dialog" ][ "defense_obj" ] = "generic_boost";
+	setscoreboardcolumns( "score", "kills", "deaths", "kdratio", "assists" );
+	if ( getDvar( "party_minplayers" ) == "" )
+	{
+		setdvar( "party_minplayers", 4 );
+	}
+	level.pregame_minplayers = getDvarInt( "party_minplayers" );
+	setmatchtalkflag( "EveryoneHearsEveryone", 1 );
+}
+
+onstartgametype()
+{
+	setclientnamemode( "auto_change" );
+	level.spawnmins = ( 1, 1, 1 );
+	level.spawnmaxs = ( 1, 1, 1 );
+	_a85 = level.teams;
+	_k85 = getFirstArrayKey( _a85 );
+	while ( isDefined( _k85 ) )
+	{
+		team = _a85[ _k85 ];
+		setobjectivetext( team, &"OBJECTIVES_PREGAME" );
+		setobjectivehinttext( team, &"OBJECTIVES_PREGAME_HINT" );
+		if ( level.splitscreen )
+		{
+			setobjectivescoretext( team, &"OBJECTIVES_PREGAME" );
+		}
+		else
+		{
+			setobjectivescoretext( team, &"OBJECTIVES_PREGAME_SCORE" );
+		}
+		maps/mp/gametypes/_spawnlogic::addspawnpoints( team, "mp_dm_spawn" );
+		_k85 = getNextArrayKey( _a85, _k85 );
+	}
+	maps/mp/gametypes/_spawning::updateallspawnpoints();
+	level.mapcenter = maps/mp/gametypes/_spawnlogic::findboxcenter( level.spawnmins, level.spawnmaxs );
+	setmapcenter( level.mapcenter );
+	spawnpoint = maps/mp/gametypes/_spawnlogic::getrandomintermissionpoint();
+	setdemointermissionpoint( spawnpoint.origin, spawnpoint.angles );
+	level.usestartspawns = 0;
+	level.teambased = 0;
+	level.overrideteamscore = 1;
+	level.rankenabled = 0;
+	level.medalsenabled = 0;
+	allowed[ 0 ] = "dm";
+	maps/mp/gametypes/_gameobjects::main( allowed );
+	maps/mp/gametypes/_spawning::create_map_placed_influencers();
+	level.killcam = 0;
+	level.finalkillcam = 0;
+	level.killstreaksenabled = 0;
+	startpregame();
+}
+
+startpregame()
+{
+	game[ "strings" ][ "waiting_for_players" ] = &"MP_WAITING_FOR_X_PLAYERS";
+	game[ "strings" ][ "pregame" ] = &"MP_PREGAME";
+	game[ "strings" ][ "pregameover" ] = &"MP_MATCHSTARTING";
+	game[ "strings" ][ "pregame_time_limit_reached" ] = &"MP_PREGAME_TIME_LIMIT";
+	precachestring( game[ "strings" ][ "waiting_for_players" ] );
+	precachestring( game[ "strings" ][ "pregame" ] );
+	precachestring( game[ "strings" ][ "pregameover" ] );
+	precachestring( game[ "strings" ][ "pregame_time_limit_reached" ] );
+	thread pregamemain();
+}
+
+onspawnplayerunified()
+{
+	maps/mp/gametypes/_spawning::onspawnplayer_unified();
+}
+
+onspawnplayer( predictedspawn )
+{
+	spawnpoints = maps/mp/gametypes/_spawnlogic::getteamspawnpoints( self.pers[ "team" ] );
+	spawnpoint = maps/mp/gametypes/_spawnlogic::getspawnpoint_dm( spawnpoints );
+	if ( predictedspawn )
+	{
+		self predictspawnpoint( spawnpoint.origin, spawnpoint.angles );
+	}
+	else
+	{
+		self spawn( spawnpoint.origin, spawnpoint.angles, "dm" );
+	}
+}
+
+onplayerclasschange( response )
+{
+	self.pregameclassresponse = response;
+}
+
+endpregame()
+{
+	level.pregame = 0;
+	players = level.players;
+	index = 0;
+	while ( index < players.size )
+	{
+		player = players[ index ];
+		player maps/mp/gametypes/_globallogic_player::freezeplayerforroundend();
+		index++;
+	}
+	setmatchtalkflag( "EveryoneHearsEveryone", 0 );
+	level.pregameplayercount destroyelem();
+	level.pregamesubtitle destroyelem();
+	level.pregametitle destroyelem();
+}
+
+getplayersneededcount()
+{
+	players = level.players;
+	count = 0;
+	i = 0;
+	while ( i < players.size )
+	{
+		player = players[ i ];
+		team = player.team;
+		class = player.class;
+		if ( team != "spectator" )
+		{
+			count++;
+		}
+		i++;
+	}
+	return int( level.pregame_minplayers - count );
+}
+
+saveplayerspregameinfo()
+{
+	players = level.players;
+	i = 0;
+	while ( i < players.size )
+	{
+		player = players[ i ];
+		team = player.team;
+		class = player.pregameclassresponse;
+		if ( isDefined( team ) && team != "" )
+		{
+			player setpregameteam( team );
+		}
+		if ( isDefined( class ) && class != "" )
+		{
+			player setpregameclass( class );
+		}
+		i++;
+	}
+}
+
+pregamemain()
+{
+	level endon( "game_ended" );
+	green = ( 0,6, 0,9, 0,6 );
+	red = ( 0,7, 0,3, 0,2 );
+	yellow = ( 1, 1, 1 );
+	white = ( 1, 1, 1 );
+	titlesize = 3;
+	textsize = 2;
+	iconsize = 70;
+	spacing = 30;
+	font = "objective";
+	level.pregametitle = createserverfontstring( font, titlesize );
+	level.pregametitle setpoint( "TOP", undefined, 0, 70 );
+	level.pregametitle.glowalpha = 1;
+	level.pregametitle.foreground = 1;
+	level.pregametitle.hidewheninmenu = 1;
+	level.pregametitle.archived = 0;
+	level.pregametitle settext( game[ "strings" ][ "pregame" ] );
+	level.pregametitle.color = red;
+	level.pregamesubtitle = createserverfontstring( font, 2 );
+	level.pregamesubtitle setparent( level.pregametitle );
+	level.pregamesubtitle setpoint( "TOP", "BOTTOM", 0, 0 );
+	level.pregamesubtitle.glowalpha = 1;
+	level.pregamesubtitle.foreground = 0;
+	level.pregamesubtitle.hidewheninmenu = 1;
+	level.pregamesubtitle.archived = 1;
+	level.pregamesubtitle settext( game[ "strings" ][ "waiting_for_players" ] );
+	level.pregamesubtitle.color = green;
+	level.pregameplayercount = createserverfontstring( font, 2,2 );
+	level.pregameplayercount setparent( level.pregametitle );
+	level.pregameplayercount setpoint( "TOP", "BOTTOM", -11, 0 );
+	level.pregamesubtitle.glowalpha = 1;
+	level.pregameplayercount.sort = 1001;
+	level.pregameplayercount.foreground = 0;
+	level.pregameplayercount.hidewheninmenu = 1;
+	level.pregameplayercount.archived = 1;
+	level.pregameplayercount.color = yellow;
+	level.pregameplayercount maps/mp/gametypes/_hud::fontpulseinit();
+	oldcount = -1;
+	for ( ;; )
+	{
+		wait 1;
+		count = getplayersneededcount();
+		if ( count < 0 )
+		{
+			break;
+		}
+		else /#
+		if ( getDvarInt( "scr_pregame_abort" ) > 0 )
+		{
+			setdvar( "scr_pregame_abort", 0 );
+			break;
+#/
+		}
+		else
+		{
+			if ( oldcount != count )
+			{
+				level.pregameplayercount setvalue( count );
+				level.pregameplayercount thread maps/mp/gametypes/_hud::fontpulse( level );
+				oldcount = count;
+			}
+		}
+	}
+	level.pregameplayercount settext( "" );
+	level.pregamesubtitle settext( game[ "strings" ][ "pregameover" ] );
+	players = level.players;
+	index = 0;
+	while ( index < players.size )
+	{
+		player = players[ index ];
+		player maps/mp/gametypes/_globallogic_player::freezeplayerforroundend();
+		player maps/mp/gametypes/_globallogic_ui::freegameplayhudelems();
+		index++;
+	}
+	visionsetnaked( "mpIntro", 3 );
+	wait 4;
+	endpregame();
+	pregamestartgame();
+	saveplayerspregameinfo();
+	map_restart( 0 );
+}
+
+onendgame( winner )
+{
+	endpregame();
+}
+
+ontimelimit()
+{
+	winner = undefined;
+	if ( level.teambased )
+	{
+		winner = maps/mp/gametypes/_globallogic::determineteamwinnerbygamestat( "teamScores" );
+		maps/mp/gametypes/_globallogic_utils::logteamwinstring( "time limit", winner );
+	}
+	else winner = maps/mp/gametypes/_globallogic_score::gethighestscoringplayer();
+	if ( isDefined( winner ) )
+	{
+		logstring( "time limit, win: " + winner.name );
+	}
+	else
+	{
+		logstring( "time limit, tie" );
+	}
+	makedvarserverinfo( "ui_text_endreason", game[ "strings" ][ "pregame_time_limit_reached" ] );
+	setdvar( "ui_text_endreason", game[ "strings" ][ "time_limit_reached" ] );
+	thread maps/mp/gametypes/_globallogic::endgame( winner, game[ "strings" ][ "pregame_time_limit_reached" ] );
+}
+
+get_pregame_class()
+{
+	pclass = self getpregameclass();
+	if ( isDefined( pclass ) && pclass[ 0 ] != "" )
+	{
+		return pclass;
+	}
+	else
+	{
+		return "smg_mp,0";
+	}
+}

patch_mp/maps/mp/gametypes/_rank.gsc

@@ -0,0 +1,847 @@
+#include maps/mp/gametypes/_globallogic;
+#include maps/mp/gametypes/_hud;
+#include maps/mp/gametypes/_hud_util;
+#include maps/mp/_scoreevents;
+#include maps/mp/_utility;
+#include common_scripts/utility;
+
+init()
+{
+	level.scoreinfo = [];
+	level.xpscale = getDvarFloat( "scr_xpscale" );
+	level.codpointsxpscale = getDvarFloat( "scr_codpointsxpscale" );
+	level.codpointsmatchscale = getDvarFloat( "scr_codpointsmatchscale" );
+	level.codpointschallengescale = getDvarFloat( "scr_codpointsperchallenge" );
+	level.rankxpcap = getDvarInt( "scr_rankXpCap" );
+	level.codpointscap = getDvarInt( "scr_codPointsCap" );
+	level.usingmomentum = 1;
+	level.usingscorestreaks = getDvarInt( "scr_scorestreaks" ) != 0;
+	level.scorestreaksmaxstacking = getDvarInt( "scr_scorestreaks_maxstacking" );
+	level.maxinventoryscorestreaks = getdvarintdefault( "scr_maxinventory_scorestreaks", 3 );
+	if ( isDefined( level.usingscorestreaks ) )
+	{
+		level.usingrampage = !level.usingscorestreaks;
+	}
+	level.rampagebonusscale = getDvarFloat( "scr_rampagebonusscale" );
+	level.ranktable = [];
+	precacheshader( "white" );
+	precachestring( &"RANK_PLAYER_WAS_PROMOTED_N" );
+	precachestring( &"RANK_PLAYER_WAS_PROMOTED" );
+	precachestring( &"RANK_PROMOTED" );
+	precachestring( &"MP_PLUS" );
+	precachestring( &"RANK_ROMANI" );
+	precachestring( &"RANK_ROMANII" );
+	precachestring( &"MP_SCORE_KILL" );
+	if ( !sessionmodeiszombiesgame() )
+	{
+		initscoreinfo();
+	}
+	level.maxrank = int( tablelookup( "mp/rankTable.csv", 0, "maxrank", 1 ) );
+	level.maxprestige = int( tablelookup( "mp/rankIconTable.csv", 0, "maxprestige", 1 ) );
+	pid = 0;
+	rid = 0;
+	pid = 0;
+	while ( pid <= level.maxprestige )
+	{
+		rid = 0;
+		while ( rid <= level.maxrank )
+		{
+			precacheshader( tablelookup( "mp/rankIconTable.csv", 0, rid, pid + 1 ) );
+			rid++;
+		}
+		pid++;
+	}
+	rankid = 0;
+	rankname = tablelookup( "mp/ranktable.csv", 0, rankid, 1 );
+/#
+	if ( isDefined( rankname ) )
+	{
+		assert( rankname != "" );
+	}
+#/
+	while ( isDefined( rankname ) && rankname != "" )
+	{
+		level.ranktable[ rankid ][ 1 ] = tablelookup( "mp/ranktable.csv", 0, rankid, 1 );
+		level.ranktable[ rankid ][ 2 ] = tablelookup( "mp/ranktable.csv", 0, rankid, 2 );
+		level.ranktable[ rankid ][ 3 ] = tablelookup( "mp/ranktable.csv", 0, rankid, 3 );
+		level.ranktable[ rankid ][ 7 ] = tablelookup( "mp/ranktable.csv", 0, rankid, 7 );
+		level.ranktable[ rankid ][ 14 ] = tablelookup( "mp/ranktable.csv", 0, rankid, 14 );
+		precachestring( tablelookupistring( "mp/ranktable.csv", 0, rankid, 16 ) );
+		rankid++;
+		rankname = tablelookup( "mp/ranktable.csv", 0, rankid, 1 );
+	}
+	level thread onplayerconnect();
+}
+
+initscoreinfo()
+{
+	scoreinfotableid = getscoreeventtableid();
+/#
+	assert( isDefined( scoreinfotableid ) );
+#/
+	if ( !isDefined( scoreinfotableid ) )
+	{
+		return;
+	}
+	scorecolumn = getscoreeventcolumn( level.gametype );
+	xpcolumn = getxpeventcolumn( level.gametype );
+/#
+	assert( scorecolumn >= 0 );
+#/
+	if ( scorecolumn < 0 )
+	{
+		return;
+	}
+/#
+	assert( xpcolumn >= 0 );
+#/
+	if ( xpcolumn < 0 )
+	{
+		return;
+	}
+	row = 1;
+	while ( row < 512 )
+	{
+		type = tablelookupcolumnforrow( scoreinfotableid, row, 0 );
+		if ( type != "" )
+		{
+			labelstring = tablelookupcolumnforrow( scoreinfotableid, row, 1 );
+			label = undefined;
+			if ( labelstring != "" )
+			{
+				label = tablelookupistring( scoreinfotableid, 0, type, 1 );
+			}
+			scorevalue = int( tablelookupcolumnforrow( scoreinfotableid, row, scorecolumn ) );
+			registerscoreinfo( type, scorevalue, label );
+			if ( maps/mp/_utility::getroundsplayed() == 0 )
+			{
+				xpvalue = float( tablelookupcolumnforrow( scoreinfotableid, row, xpcolumn ) );
+				setddlstat = tablelookupcolumnforrow( scoreinfotableid, row, 5 );
+				addplayerstat = 0;
+				if ( setddlstat == "TRUE" )
+				{
+					addplayerstat = 1;
+				}
+				ismedal = 0;
+				istring = tablelookupistring( scoreinfotableid, 0, type, 2 );
+				if ( isDefined( istring ) && istring != &"" )
+				{
+					ismedal = 1;
+				}
+				demobookmarkpriority = int( tablelookupcolumnforrow( scoreinfotableid, row, 6 ) );
+				if ( !isDefined( demobookmarkpriority ) )
+				{
+					demobookmarkpriority = 0;
+				}
+				registerxp( type, xpvalue, addplayerstat, ismedal, demobookmarkpriority, row );
+			}
+			allowkillstreakweapons = tablelookupcolumnforrow( scoreinfotableid, row, 4 );
+			if ( allowkillstreakweapons == "TRUE" )
+			{
+				level.scoreinfo[ type ][ "allowKillstreakWeapons" ] = 1;
+			}
+		}
+		row++;
+	}
+}
+
+getrankxpcapped( inrankxp )
+{
+	if ( isDefined( level.rankxpcap ) && level.rankxpcap && level.rankxpcap <= inrankxp )
+	{
+		return level.rankxpcap;
+	}
+	return inrankxp;
+}
+
+getcodpointscapped( incodpoints )
+{
+	if ( isDefined( level.codpointscap ) && level.codpointscap && level.codpointscap <= incodpoints )
+	{
+		return level.codpointscap;
+	}
+	return incodpoints;
+}
+
+registerscoreinfo( type, value, label )
+{
+	overridedvar = "scr_" + level.gametype + "_score_" + type;
+	if ( getDvar( overridedvar ) != "" )
+	{
+		value = getDvarInt( overridedvar );
+	}
+	if ( type == "kill" )
+	{
+		multiplier = getgametypesetting( "killEventScoreMultiplier" );
+		level.scoreinfo[ type ][ "value" ] = int( ( multiplier + 1 ) * value );
+	}
+	else
+	{
+		level.scoreinfo[ type ][ "value" ] = value;
+	}
+	if ( isDefined( label ) )
+	{
+		precachestring( label );
+		level.scoreinfo[ type ][ "label" ] = label;
+	}
+}
+
+getscoreinfovalue( type )
+{
+	if ( isDefined( level.scoreinfo[ type ] ) )
+	{
+		return level.scoreinfo[ type ][ "value" ];
+	}
+}
+
+getscoreinfolabel( type )
+{
+	return level.scoreinfo[ type ][ "label" ];
+}
+
+killstreakweaponsallowedscore( type )
+{
+	if ( isDefined( level.scoreinfo[ type ][ "allowKillstreakWeapons" ] ) && level.scoreinfo[ type ][ "allowKillstreakWeapons" ] == 1 )
+	{
+		return 1;
+	}
+	else
+	{
+		return 0;
+	}
+}
+
+doesscoreinfocounttowardrampage( type )
+{
+	if ( isDefined( level.scoreinfo[ type ][ "rampage" ] ) )
+	{
+		return level.scoreinfo[ type ][ "rampage" ];
+	}
+}
+
+getrankinfominxp( rankid )
+{
+	return int( level.ranktable[ rankid ][ 2 ] );
+}
+
+getrankinfoxpamt( rankid )
+{
+	return int( level.ranktable[ rankid ][ 3 ] );
+}
+
+getrankinfomaxxp( rankid )
+{
+	return int( level.ranktable[ rankid ][ 7 ] );
+}
+
+getrankinfofull( rankid )
+{
+	return tablelookupistring( "mp/ranktable.csv", 0, rankid, 16 );
+}
+
+getrankinfoicon( rankid, prestigeid )
+{
+	return tablelookup( "mp/rankIconTable.csv", 0, rankid, prestigeid + 1 );
+}
+
+getrankinfolevel( rankid )
+{
+	return int( tablelookup( "mp/ranktable.csv", 0, rankid, 13 ) );
+}
+
+getrankinfocodpointsearned( rankid )
+{
+	return int( tablelookup( "mp/ranktable.csv", 0, rankid, 17 ) );
+}
+
+shouldkickbyrank()
+{
+	if ( self ishost() )
+	{
+		return 0;
+	}
+	if ( level.rankcap > 0 && self.pers[ "rank" ] > level.rankcap )
+	{
+		return 1;
+	}
+	if ( level.rankcap > 0 && level.minprestige == 0 && self.pers[ "plevel" ] > 0 )
+	{
+		return 1;
+	}
+	if ( level.minprestige > self.pers[ "plevel" ] )
+	{
+		return 1;
+	}
+	return 0;
+}
+
+getcodpointsstat()
+{
+	codpoints = self getdstat( "playerstatslist", "CODPOINTS", "StatValue" );
+	codpointscapped = getcodpointscapped( codpoints );
+	if ( codpoints > codpointscapped )
+	{
+		self setcodpointsstat( codpointscapped );
+	}
+	return codpointscapped;
+}
+
+setcodpointsstat( codpoints )
+{
+	self setdstat( "PlayerStatsList", "CODPOINTS", "StatValue", getcodpointscapped( codpoints ) );
+}
+
+getrankxpstat()
+{
+	rankxp = self getdstat( "playerstatslist", "RANKXP", "StatValue" );
+	rankxpcapped = getrankxpcapped( rankxp );
+	if ( rankxp > rankxpcapped )
+	{
+		self setdstat( "playerstatslist", "RANKXP", "StatValue", rankxpcapped );
+	}
+	return rankxpcapped;
+}
+
+onplayerconnect()
+{
+	for ( ;; )
+	{
+		level waittill( "connected", player );
+		player.pers[ "rankxp" ] = player getrankxpstat();
+		player.pers[ "codpoints" ] = player getcodpointsstat();
+		player.pers[ "currencyspent" ] = player getdstat( "playerstatslist", "currencyspent", "StatValue" );
+		rankid = player getrankforxp( player getrankxp() );
+		player.pers[ "rank" ] = rankid;
+		player.pers[ "plevel" ] = player getdstat( "playerstatslist", "PLEVEL", "StatValue" );
+		if ( player shouldkickbyrank() )
+		{
+			kick( player getentitynumber() );
+			continue;
+		}
+		else
+		{
+			if ( !isDefined( player.pers[ "participation" ] ) || level.gametype == "twar" && game[ "roundsplayed" ] >= 0 && player.pers[ "participation" ] >= 0 )
+			{
+				player.pers[ "participation" ] = 0;
+			}
+			player.rankupdatetotal = 0;
+			player.cur_ranknum = rankid;
+/#
+			assert( isDefined( player.cur_ranknum ), "rank: " + rankid + " does not have an index, check mp/ranktable.csv" );
+#/
+			prestige = player getdstat( "playerstatslist", "plevel", "StatValue" );
+			player setrank( rankid, prestige );
+			player.pers[ "prestige" ] = prestige;
+			if ( !isDefined( player.pers[ "summary" ] ) )
+			{
+				player.pers[ "summary" ] = [];
+				player.pers[ "summary" ][ "xp" ] = 0;
+				player.pers[ "summary" ][ "score" ] = 0;
+				player.pers[ "summary" ][ "challenge" ] = 0;
+				player.pers[ "summary" ][ "match" ] = 0;
+				player.pers[ "summary" ][ "misc" ] = 0;
+				player.pers[ "summary" ][ "codpoints" ] = 0;
+			}
+			if ( !level.rankedmatch || level.wagermatch && level.leaguematch )
+			{
+				player setdstat( "AfterActionReportStats", "lobbyPopup", "none" );
+			}
+			if ( level.rankedmatch )
+			{
+				player setdstat( "playerstatslist", "rank", "StatValue", rankid );
+				player setdstat( "playerstatslist", "minxp", "StatValue", getrankinfominxp( rankid ) );
+				player setdstat( "playerstatslist", "maxxp", "StatValue", getrankinfomaxxp( rankid ) );
+				player setdstat( "playerstatslist", "lastxp", "StatValue", getrankxpcapped( player.pers[ "rankxp" ] ) );
+			}
+			player.explosivekills[ 0 ] = 0;
+			player thread onplayerspawned();
+			player thread onjoinedteam();
+			player thread onjoinedspectators();
+		}
+	}
+}
+
+onjoinedteam()
+{
+	self endon( "disconnect" );
+	for ( ;; )
+	{
+		self waittill( "joined_team" );
+		self thread removerankhud();
+	}
+}
+
+onjoinedspectators()
+{
+	self endon( "disconnect" );
+	for ( ;; )
+	{
+		self waittill( "joined_spectators" );
+		self thread removerankhud();
+	}
+}
+
+onplayerspawned()
+{
+	self endon( "disconnect" );
+	for ( ;; )
+	{
+		self waittill( "spawned_player" );
+		if ( !isDefined( self.hud_rankscroreupdate ) )
+		{
+			self.hud_rankscroreupdate = newscorehudelem( self );
+			self.hud_rankscroreupdate.horzalign = "center";
+			self.hud_rankscroreupdate.vertalign = "middle";
+			self.hud_rankscroreupdate.alignx = "center";
+			self.hud_rankscroreupdate.aligny = "middle";
+			self.hud_rankscroreupdate.x = 0;
+			if ( self issplitscreen() )
+			{
+				self.hud_rankscroreupdate.y = -15;
+			}
+			else
+			{
+				self.hud_rankscroreupdate.y = -60;
+			}
+			self.hud_rankscroreupdate.font = "default";
+			self.hud_rankscroreupdate.fontscale = 2;
+			self.hud_rankscroreupdate.archived = 0;
+			self.hud_rankscroreupdate.color = ( 1, 1, 0,5 );
+			self.hud_rankscroreupdate.alpha = 0;
+			self.hud_rankscroreupdate.sort = 50;
+			self.hud_rankscroreupdate maps/mp/gametypes/_hud::fontpulseinit();
+		}
+	}
+}
+
+inccodpoints( amount )
+{
+	if ( !isrankenabled() )
+	{
+		return;
+	}
+	if ( !level.rankedmatch )
+	{
+		return;
+	}
+	newcodpoints = getcodpointscapped( self.pers[ "codpoints" ] + amount );
+	if ( newcodpoints > self.pers[ "codpoints" ] )
+	{
+		self.pers[ "summary" ][ "codpoints" ] += newcodpoints - self.pers[ "codpoints" ];
+	}
+	self.pers[ "codpoints" ] = newcodpoints;
+	setcodpointsstat( int( newcodpoints ) );
+}
+
+atleastoneplayeroneachteam()
+{
+	_a507 = level.teams;
+	_k507 = getFirstArrayKey( _a507 );
+	while ( isDefined( _k507 ) )
+	{
+		team = _a507[ _k507 ];
+		if ( !level.playercount[ team ] )
+		{
+			return 0;
+		}
+		_k507 = getNextArrayKey( _a507, _k507 );
+	}
+	return 1;
+}
+
+giverankxp( type, value, devadd )
+{
+	self endon( "disconnect" );
+	if ( sessionmodeiszombiesgame() )
+	{
+		return;
+	}
+	if ( level.teambased && !atleastoneplayeroneachteam() && !isDefined( devadd ) )
+	{
+		return;
+	}
+	else
+	{
+		if ( !level.teambased && maps/mp/gametypes/_globallogic::totalplayercount() < 2 && !isDefined( devadd ) )
+		{
+			return;
+		}
+	}
+	if ( !isrankenabled() )
+	{
+		return;
+	}
+	pixbeginevent( "giveRankXP" );
+	if ( !isDefined( value ) )
+	{
+		value = getscoreinfovalue( type );
+	}
+	if ( level.rankedmatch )
+	{
+		bbprint( "mpplayerxp", "gametime %d, player %s, type %s, delta %d", getTime(), self.name, type, value );
+	}
+	switch( type )
+	{
+		case "assault":
+		case "assault_assist":
+		case "assist":
+		case "assist_25":
+		case "assist_50":
+		case "assist_75":
+		case "capture":
+		case "defend":
+		case "defuse":
+		case "destroyer":
+		case "dogassist":
+		case "dogkill":
+		case "headshot":
+		case "helicopterassist":
+		case "helicopterassist_25":
+		case "helicopterassist_50":
+		case "helicopterassist_75":
+		case "helicopterkill":
+		case "kill":
+		case "medal":
+		case "pickup":
+		case "plant":
+		case "rcbombdestroy":
+		case "return":
+		case "revive":
+		case "spyplaneassist":
+		case "spyplanekill":
+			value = int( value * level.xpscale );
+			break;
+		default:
+			if ( level.xpscale == 0 )
+			{
+				value = 0;
+			}
+			break;
+	}
+	xpincrease = self incrankxp( value );
+	if ( level.rankedmatch )
+	{
+		self updaterank();
+	}
+	if ( value != 0 )
+	{
+		self syncxpstat();
+	}
+	if ( isDefined( self.enabletext ) && self.enabletext && !level.hardcoremode )
+	{
+		if ( type == "teamkill" )
+		{
+			self thread updaterankscorehud( 0 - getscoreinfovalue( "kill" ) );
+		}
+		else
+		{
+			self thread updaterankscorehud( value );
+		}
+	}
+	switch( type )
+	{
+		case "assault":
+		case "assist":
+		case "assist_25":
+		case "assist_50":
+		case "assist_75":
+		case "capture":
+		case "defend":
+		case "headshot":
+		case "helicopterassist":
+		case "helicopterassist_25":
+		case "helicopterassist_50":
+		case "helicopterassist_75":
+		case "kill":
+		case "medal":
+		case "pickup":
+		case "return":
+		case "revive":
+		case "suicide":
+		case "teamkill":
+			self.pers[ "summary" ][ "score" ] += value;
+			inccodpoints( round_this_number( value * level.codpointsxpscale ) );
+			break;
+		case "loss":
+		case "tie":
+		case "win":
+			self.pers[ "summary" ][ "match" ] += value;
+			inccodpoints( round_this_number( value * level.codpointsmatchscale ) );
+			break;
+		case "challenge":
+			self.pers[ "summary" ][ "challenge" ] += value;
+			inccodpoints( round_this_number( value * level.codpointschallengescale ) );
+			break;
+		default:
+			self.pers[ "summary" ][ "misc" ] += value;
+			self.pers[ "summary" ][ "match" ] += value;
+			inccodpoints( round_this_number( value * level.codpointsmatchscale ) );
+			break;
+	}
+	self.pers[ "summary" ][ "xp" ] += xpincrease;
+	pixendevent();
+}
+
+round_this_number( value )
+{
+	value = int( value + 0,5 );
+	return value;
+}
+
+updaterank()
+{
+	newrankid = self getrank();
+	if ( newrankid == self.pers[ "rank" ] )
+	{
+		return 0;
+	}
+	oldrank = self.pers[ "rank" ];
+	rankid = self.pers[ "rank" ];
+	self.pers[ "rank" ] = newrankid;
+	while ( rankid <= newrankid )
+	{
+		self setdstat( "playerstatslist", "rank", "StatValue", rankid );
+		self setdstat( "playerstatslist", "minxp", "StatValue", int( level.ranktable[ rankid ][ 2 ] ) );
+		self setdstat( "playerstatslist", "maxxp", "StatValue", int( level.ranktable[ rankid ][ 7 ] ) );
+		self.setpromotion = 1;
+		if ( level.rankedmatch && level.gameended && !self issplitscreen() )
+		{
+			self setdstat( "AfterActionReportStats", "lobbyPopup", "promotion" );
+		}
+		if ( rankid != oldrank )
+		{
+			codpointsearnedforrank = getrankinfocodpointsearned( rankid );
+			inccodpoints( codpointsearnedforrank );
+			if ( !isDefined( self.pers[ "rankcp" ] ) )
+			{
+				self.pers[ "rankcp" ] = 0;
+			}
+			self.pers[ "rankcp" ] += codpointsearnedforrank;
+		}
+		rankid++;
+	}
+	self logstring( "promoted from " + oldrank + " to " + newrankid + " timeplayed: " + self getdstat( "playerstatslist", "time_played_total", "StatValue" ) );
+	self setrank( newrankid );
+	return 1;
+}
+
+codecallback_rankup( rank, prestige, unlocktokensadded )
+{
+	if ( rank > 8 )
+	{
+		self giveachievement( "MP_MISC_1" );
+	}
+	self luinotifyevent( &"rank_up", 3, rank, prestige, unlocktokensadded );
+	self luinotifyeventtospectators( &"rank_up", 3, rank, prestige, unlocktokensadded );
+}
+
+getitemindex( refstring )
+{
+	itemindex = int( tablelookup( "mp/statstable.csv", 4, refstring, 0 ) );
+/#
+	assert( itemindex > 0, "statsTable refstring " + refstring + " has invalid index: " + itemindex );
+#/
+	return itemindex;
+}
+
+endgameupdate()
+{
+	player = self;
+}
+
+updaterankscorehud( amount )
+{
+	self endon( "disconnect" );
+	self endon( "joined_team" );
+	self endon( "joined_spectators" );
+	if ( isDefined( level.usingmomentum ) && level.usingmomentum )
+	{
+		return;
+	}
+	if ( amount == 0 )
+	{
+		return;
+	}
+	self notify( "update_score" );
+	self endon( "update_score" );
+	self.rankupdatetotal += amount;
+	wait 0,05;
+	if ( isDefined( self.hud_rankscroreupdate ) )
+	{
+		if ( self.rankupdatetotal < 0 )
+		{
+			self.hud_rankscroreupdate.label = &"";
+			self.hud_rankscroreupdate.color = ( 0,73, 0,19, 0,19 );
+		}
+		else
+		{
+			self.hud_rankscroreupdate.label = &"MP_PLUS";
+			self.hud_rankscroreupdate.color = ( 1, 1, 0,5 );
+		}
+		self.hud_rankscroreupdate setvalue( self.rankupdatetotal );
+		self.hud_rankscroreupdate.alpha = 0,85;
+		self.hud_rankscroreupdate thread maps/mp/gametypes/_hud::fontpulse( self );
+		wait 1;
+		self.hud_rankscroreupdate fadeovertime( 0,75 );
+		self.hud_rankscroreupdate.alpha = 0;
+		self.rankupdatetotal = 0;
+	}
+}
+
+updatemomentumhud( amount, reason, reasonvalue )
+{
+	self endon( "disconnect" );
+	self endon( "joined_team" );
+	self endon( "joined_spectators" );
+	if ( amount == 0 )
+	{
+		return;
+	}
+	self notify( "update_score" );
+	self endon( "update_score" );
+	self.rankupdatetotal += amount;
+	if ( isDefined( self.hud_rankscroreupdate ) )
+	{
+		if ( self.rankupdatetotal < 0 )
+		{
+			self.hud_rankscroreupdate.label = &"";
+			self.hud_rankscroreupdate.color = ( 0,73, 0,19, 0,19 );
+		}
+		else
+		{
+			self.hud_rankscroreupdate.label = &"MP_PLUS";
+			self.hud_rankscroreupdate.color = ( 1, 1, 0,5 );
+		}
+		self.hud_rankscroreupdate setvalue( self.rankupdatetotal );
+		self.hud_rankscroreupdate.alpha = 0,85;
+		self.hud_rankscroreupdate thread maps/mp/gametypes/_hud::fontpulse( self );
+		if ( isDefined( self.hud_momentumreason ) )
+		{
+			if ( isDefined( reason ) )
+			{
+				if ( isDefined( reasonvalue ) )
+				{
+					self.hud_momentumreason.label = reason;
+					self.hud_momentumreason setvalue( reasonvalue );
+				}
+				else
+				{
+					self.hud_momentumreason.label = reason;
+					self.hud_momentumreason setvalue( amount );
+				}
+				self.hud_momentumreason.alpha = 0,85;
+				self.hud_momentumreason thread maps/mp/gametypes/_hud::fontpulse( self );
+			}
+			else
+			{
+				self.hud_momentumreason fadeovertime( 0,01 );
+				self.hud_momentumreason.alpha = 0;
+			}
+		}
+		wait 1;
+		self.hud_rankscroreupdate fadeovertime( 0,75 );
+		self.hud_rankscroreupdate.alpha = 0;
+		if ( isDefined( self.hud_momentumreason ) && isDefined( reason ) )
+		{
+			self.hud_momentumreason fadeovertime( 0,75 );
+			self.hud_momentumreason.alpha = 0;
+		}
+		wait 0,75;
+		self.rankupdatetotal = 0;
+	}
+}
+
+removerankhud()
+{
+	if ( isDefined( self.hud_rankscroreupdate ) )
+	{
+		self.hud_rankscroreupdate.alpha = 0;
+	}
+	if ( isDefined( self.hud_momentumreason ) )
+	{
+		self.hud_momentumreason.alpha = 0;
+	}
+}
+
+getrank()
+{
+	rankxp = getrankxpcapped( self.pers[ "rankxp" ] );
+	rankid = self.pers[ "rank" ];
+	if ( rankxp < ( getrankinfominxp( rankid ) + getrankinfoxpamt( rankid ) ) )
+	{
+		return rankid;
+	}
+	else
+	{
+		return self getrankforxp( rankxp );
+	}
+}
+
+getrankforxp( xpval )
+{
+	rankid = 0;
+	rankname = level.ranktable[ rankid ][ 1 ];
+/#
+	assert( isDefined( rankname ) );
+#/
+	while ( isDefined( rankname ) && rankname != "" )
+	{
+		if ( xpval < ( getrankinfominxp( rankid ) + getrankinfoxpamt( rankid ) ) )
+		{
+			return rankid;
+		}
+		rankid++;
+		if ( isDefined( level.ranktable[ rankid ] ) )
+		{
+			rankname = level.ranktable[ rankid ][ 1 ];
+			continue;
+		}
+		else
+		{
+			rankname = undefined;
+		}
+	}
+	rankid--;
+
+	return rankid;
+}
+
+getspm()
+{
+	ranklevel = self getrank() + 1;
+	return ( 3 + ( ranklevel * 0,5 ) ) * 10;
+}
+
+getrankxp()
+{
+	return getrankxpcapped( self.pers[ "rankxp" ] );
+}
+
+incrankxp( amount )
+{
+	if ( !level.rankedmatch )
+	{
+		return 0;
+	}
+	xp = self getrankxp();
+	newxp = getrankxpcapped( xp + amount );
+	if ( self.pers[ "rank" ] == level.maxrank && newxp >= getrankinfomaxxp( level.maxrank ) )
+	{
+		newxp = getrankinfomaxxp( level.maxrank );
+	}
+	xpincrease = getrankxpcapped( newxp ) - self.pers[ "rankxp" ];
+	if ( xpincrease < 0 )
+	{
+		xpincrease = 0;
+	}
+	self.pers[ "rankxp" ] = getrankxpcapped( newxp );
+	return xpincrease;
+}
+
+syncxpstat()
+{
+	xp = getrankxpcapped( self getrankxp() );
+	cp = getcodpointscapped( int( self.pers[ "codpoints" ] ) );
+	self setdstat( "playerstatslist", "rankxp", "StatValue", xp );
+	self setdstat( "playerstatslist", "codpoints", "StatValue", cp );
+}

patch_mp/maps/mp/gametypes/_scoreboard.gsc

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

patch_mp/maps/mp/gametypes/_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_mp/maps/mp/gametypes/_shellshock.gsc

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

patch_mp/maps/mp/gametypes/_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_mp/maps/mp/gametypes/_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_mp/maps/mp/gametypes/_wager.gsc

@@ -0,0 +1,988 @@
+#include maps/mp/killstreaks/_killstreaks;
+#include maps/mp/gametypes/_class;
+#include maps/mp/gametypes/_globallogic_audio;
+#include maps/mp/teams/_teams;
+#include maps/mp/gametypes/_globallogic;
+#include maps/mp/gametypes/_persistence;
+#include maps/mp/gametypes/_rank;
+#include maps/mp/gametypes/_hud_util;
+#include maps/mp/gametypes/_globallogic_score;
+#include common_scripts/utility;
+#include maps/mp/_utility;
+
+init()
+{
+	precachestring( &"MP_HEADS_UP" );
+	precachestring( &"MP_U2_ONLINE" );
+	precachestring( &"MP_BONUS_ACQUIRED" );
+	if ( gamemodeismode( level.gamemode_wager_match ) && !ispregame() )
+	{
+		level.wagermatch = 1;
+		if ( !isDefined( game[ "wager_pot" ] ) )
+		{
+			game[ "wager_pot" ] = 0;
+			game[ "wager_initial_pot" ] = 0;
+		}
+		game[ "dialog" ][ "wm_u2_online" ] = "boost_gen_02";
+		game[ "dialog" ][ "wm_in_the_money" ] = "boost_gen_06";
+		game[ "dialog" ][ "wm_oot_money" ] = "boost_gen_07";
+		level.poweruplist = [];
+		level thread onplayerconnect();
+		level thread helpgameend();
+	}
+	else
+	{
+		level.wagermatch = 0;
+	}
+	level.takelivesondeath = 1;
+}
+
+onplayerconnect()
+{
+	for ( ;; )
+	{
+		level waittill( "connected", player );
+		player thread ondisconnect();
+		player thread initwagerplayer();
+	}
+}
+
+initwagerplayer()
+{
+	self endon( "disconnect" );
+	self waittill( "spawned_player" );
+	if ( !isDefined( self.pers[ "wager" ] ) )
+	{
+		self.pers[ "wager" ] = 1;
+		self.pers[ "wager_sideBetWinnings" ] = 0;
+		self.pers[ "wager_sideBetLosses" ] = 0;
+	}
+	if ( isDefined( level.inthemoneyonradar ) || level.inthemoneyonradar && isDefined( level.firstplaceonradar ) && level.firstplaceonradar )
+	{
+		self.pers[ "hasRadar" ] = 1;
+		self.hasspyplane = 1;
+	}
+	else
+	{
+		self.pers[ "hasRadar" ] = 0;
+		self.hasspyplane = 0;
+	}
+	self thread deductplayerante();
+}
+
+ondisconnect()
+{
+	level endon( "game_ended" );
+	self endon( "player_eliminated" );
+	self waittill( "disconnect" );
+	level notify( "player_eliminated" );
+}
+
+deductplayerante()
+{
+	if ( isDefined( self.pers[ "hasPaidWagerAnte" ] ) )
+	{
+		return;
+	}
+	waittillframeend;
+	codpoints = self maps/mp/gametypes/_rank::getcodpointsstat();
+	wagerbet = getDvarInt( "scr_wagerBet" );
+	if ( wagerbet > codpoints )
+	{
+		wagerbet = codpoints;
+	}
+	codpoints -= wagerbet;
+	self maps/mp/gametypes/_rank::setcodpointsstat( codpoints );
+	if ( !self islocaltohost() )
+	{
+		self incrementescrowforplayer( wagerbet );
+	}
+	game[ "wager_pot" ] += wagerbet;
+	game[ "wager_initial_pot" ] += wagerbet;
+	self.pers[ "hasPaidWagerAnte" ] = 1;
+	self addplayerstat( "LIFETIME_BUYIN", wagerbet );
+	self addrecentearningstostat( 0 - wagerbet );
+	if ( isDefined( level.onwagerplayerante ) )
+	{
+		[[ level.onwagerplayerante ]]( self, wagerbet );
+	}
+	self thread maps/mp/gametypes/_persistence::uploadstatssoon();
+}
+
+incrementescrowforplayer( amount )
+{
+	if ( !isDefined( self ) || !isplayer( self ) )
+	{
+		return;
+	}
+	if ( !isDefined( game[ "escrows" ] ) )
+	{
+		game[ "escrows" ] = [];
+	}
+	playerxuid = self getxuid();
+	if ( !isDefined( playerxuid ) )
+	{
+		return;
+	}
+	escrowstruct = spawnstruct();
+	escrowstruct.xuid = playerxuid;
+	escrowstruct.amount = amount;
+	game[ "escrows" ][ game[ "escrows" ].size ] = escrowstruct;
+}
+
+clearescrows()
+{
+	if ( !isDefined( game[ "escrows" ] ) )
+	{
+		return;
+	}
+	escrows = game[ "escrows" ];
+	numescrows = escrows.size;
+	i = 0;
+	while ( i < numescrows )
+	{
+		escrowstruct = escrows[ i ];
+		i++;
+	}
+	game[ "escrows" ] = [];
+}
+
+addrecentearningstostat( recentearnings )
+{
+	currearnings = self maps/mp/gametypes/_persistence::getrecentstat( 1, 0, "score" );
+	self maps/mp/gametypes/_persistence::setrecentstat( 1, 0, "score", currearnings + recentearnings );
+}
+
+prematchperiod()
+{
+	if ( !level.wagermatch )
+	{
+		return;
+	}
+}
+
+finalizewagerround()
+{
+	if ( level.wagermatch == 0 )
+	{
+		return;
+	}
+	determinewagerwinnings();
+	if ( isDefined( level.onwagerfinalizeround ) )
+	{
+		[[ level.onwagerfinalizeround ]]();
+	}
+}
+
+determinewagerwinnings()
+{
+	if ( isDefined( level.dontcalcwagerwinnings ) )
+	{
+		shouldcalculatewinnings = !level.dontcalcwagerwinnings;
+	}
+	if ( !shouldcalculatewinnings )
+	{
+		return;
+	}
+	if ( !level.teambased )
+	{
+		calculatefreeforallpayouts();
+	}
+	else
+	{
+		calculateteampayouts();
+	}
+}
+
+calculatefreeforallpayouts()
+{
+	playerrankings = level.placement[ "all" ];
+	payoutpercentages = array( 0,5, 0,3, 0,2 );
+	if ( playerrankings.size == 2 )
+	{
+		payoutpercentages = array( 0,7, 0,3 );
+	}
+	else
+	{
+		if ( playerrankings.size == 1 )
+		{
+			payoutpercentages = array( 1 );
+		}
+	}
+	setwagerwinningsonplayers( level.players, 0 );
+	if ( isDefined( level.hostforcedend ) && level.hostforcedend )
+	{
+		wagerbet = getDvarInt( "scr_wagerBet" );
+		i = 0;
+		while ( i < playerrankings.size )
+		{
+			if ( !playerrankings[ i ] islocaltohost() )
+			{
+				playerrankings[ i ].wagerwinnings = wagerbet;
+			}
+			i++;
+		}
+	}
+	else if ( level.players.size == 1 )
+	{
+		return;
+	}
+	else
+	{
+		currentpayoutpercentage = 0;
+		cumulativepayoutpercentage = payoutpercentages[ 0 ];
+		playergroup = [];
+		playergroup[ playergroup.size ] = playerrankings[ 0 ];
+		i = 1;
+		while ( i < playerrankings.size )
+		{
+			if ( playerrankings[ i ].pers[ "score" ] < playergroup[ 0 ].pers[ "score" ] )
+			{
+				setwagerwinningsonplayers( playergroup, int( ( game[ "wager_pot" ] * cumulativepayoutpercentage ) / playergroup.size ) );
+				playergroup = [];
+				cumulativepayoutpercentage = 0;
+			}
+			playergroup[ playergroup.size ] = playerrankings[ i ];
+			currentpayoutpercentage++;
+			if ( isDefined( payoutpercentages[ currentpayoutpercentage ] ) )
+			{
+				cumulativepayoutpercentage += payoutpercentages[ currentpayoutpercentage ];
+			}
+			i++;
+		}
+		setwagerwinningsonplayers( playergroup, int( ( game[ "wager_pot" ] * cumulativepayoutpercentage ) / playergroup.size ) );
+	}
+}
+
+calculateplacesbasedonscore()
+{
+	level.playerplaces = array( [], [], [] );
+	playerrankings = level.placement[ "all" ];
+	placementscores = array( playerrankings[ 0 ].pers[ "score" ], -1, -1 );
+	currentplace = 0;
+	index = 0;
+	while ( index < playerrankings.size && currentplace < placementscores.size )
+	{
+		player = playerrankings[ index ];
+		if ( player.pers[ "score" ] < placementscores[ currentplace ] )
+		{
+			currentplace++;
+			if ( currentplace >= level.playerplaces.size )
+			{
+				return;
+			}
+			else
+			{
+				placementscores[ currentplace ] = player.pers[ "score" ];
+			}
+			level.playerplaces[ currentplace ][ level.playerplaces[ currentplace ].size ] = player;
+			index++;
+		}
+	}
+}
+
+calculateteampayouts()
+{
+	winner = maps/mp/gametypes/_globallogic::determineteamwinnerbygamestat( "teamScores" );
+	if ( winner == "tie" )
+	{
+		calculatefreeforallpayouts();
+		return;
+	}
+	playersonwinningteam = [];
+	index = 0;
+	while ( index < level.players.size )
+	{
+		player = level.players[ index ];
+		player.wagerwinnings = 0;
+		if ( player.pers[ "team" ] == winner )
+		{
+			playersonwinningteam[ playersonwinningteam.size ] = player;
+		}
+		index++;
+	}
+	if ( playersonwinningteam.size == 0 )
+	{
+		setwagerwinningsonplayers( level.players, getDvarInt( "scr_wagerBet" ) );
+		return;
+	}
+	winningssplit = int( game[ "wager_pot" ] / playersonwinningteam.size );
+	setwagerwinningsonplayers( playersonwinningteam, winningssplit );
+}
+
+setwagerwinningsonplayers( players, amount )
+{
+	index = 0;
+	while ( index < players.size )
+	{
+		players[ index ].wagerwinnings = amount;
+		index++;
+	}
+}
+
+finalizewagergame()
+{
+	level.wagergamefinalized = 1;
+	if ( level.wagermatch == 0 )
+	{
+		return;
+	}
+	determinewagerwinnings();
+	determinetopearners();
+	players = level.players;
+	wait 0,5;
+	playerrankings = level.wagertopearners;
+	index = 0;
+	while ( index < players.size )
+	{
+		player = players[ index ];
+		if ( isDefined( player.pers[ "wager_sideBetWinnings" ] ) )
+		{
+			payoutwagerwinnings( player, player.wagerwinnings + player.pers[ "wager_sideBetWinnings" ] );
+		}
+		else
+		{
+			payoutwagerwinnings( player, player.wagerwinnings );
+		}
+		if ( player.wagerwinnings > 0 )
+		{
+			maps/mp/gametypes/_globallogic_score::updatewinstats( player );
+		}
+		index++;
+	}
+	clearescrows();
+}
+
+payoutwagerwinnings( player, winnings )
+{
+	if ( winnings == 0 )
+	{
+		return;
+	}
+	codpoints = player maps/mp/gametypes/_rank::getcodpointsstat();
+	player maps/mp/gametypes/_rank::setcodpointsstat( codpoints + winnings );
+	player addplayerstat( "LIFETIME_EARNINGS", winnings );
+	player addrecentearningstostat( winnings );
+}
+
+determinetopearners()
+{
+	topwinnings = array( -1, -1, -1 );
+	level.wagertopearners = [];
+	index = 0;
+	while ( index < level.players.size )
+	{
+		player = level.players[ index ];
+		if ( !isDefined( player.wagerwinnings ) )
+		{
+			player.wagerwinnings = 0;
+		}
+		if ( player.wagerwinnings > topwinnings[ 0 ] )
+		{
+			topwinnings[ 2 ] = topwinnings[ 1 ];
+			topwinnings[ 1 ] = topwinnings[ 0 ];
+			topwinnings[ 0 ] = player.wagerwinnings;
+			level.wagertopearners[ 2 ] = level.wagertopearners[ 1 ];
+			level.wagertopearners[ 1 ] = level.wagertopearners[ 0 ];
+			level.wagertopearners[ 0 ] = player;
+			index++;
+			continue;
+		}
+		else if ( player.wagerwinnings > topwinnings[ 1 ] )
+		{
+			topwinnings[ 2 ] = topwinnings[ 1 ];
+			topwinnings[ 1 ] = player.wagerwinnings;
+			level.wagertopearners[ 2 ] = level.wagertopearners[ 1 ];
+			level.wagertopearners[ 1 ] = player;
+			index++;
+			continue;
+		}
+		else
+		{
+			if ( player.wagerwinnings > topwinnings[ 2 ] )
+			{
+				topwinnings[ 2 ] = player.wagerwinnings;
+				level.wagertopearners[ 2 ] = player;
+			}
+		}
+		index++;
+	}
+}
+
+postroundsidebet()
+{
+	if ( isDefined( level.sidebet ) && level.sidebet )
+	{
+		level notify( "side_bet_begin" );
+		level waittill( "side_bet_end" );
+	}
+}
+
+sidebettimer()
+{
+	level endon( "side_bet_end" );
+	secondstowait = ( level.sidebetendtime - getTime() ) / 1000;
+	if ( secondstowait < 0 )
+	{
+		secondstowait = 0;
+	}
+	wait secondstowait;
+	playerindex = 0;
+	while ( playerindex < level.players.size )
+	{
+		if ( isDefined( level.players[ playerindex ] ) )
+		{
+			level.players[ playerindex ] closemenu();
+		}
+		playerindex++;
+	}
+	level notify( "side_bet_end" );
+}
+
+sidebetallbetsplaced()
+{
+	secondsleft = ( level.sidebetendtime - getTime() ) / 1000;
+	if ( secondsleft <= 3 )
+	{
+		return;
+	}
+	level.sidebetendtime = getTime() + 3000;
+	wait 3;
+	playerindex = 0;
+	while ( playerindex < level.players.size )
+	{
+		if ( isDefined( level.players[ playerindex ] ) )
+		{
+			level.players[ playerindex ] closemenu();
+		}
+		playerindex++;
+	}
+	level notify( "side_bet_end" );
+}
+
+setupblankrandomplayer( takeweapons, chooserandombody, weapon )
+{
+	if ( !isDefined( chooserandombody ) || chooserandombody )
+	{
+		if ( !isDefined( self.pers[ "wagerBodyAssigned" ] ) )
+		{
+			self assignrandombody();
+			self.pers[ "wagerBodyAssigned" ] = 1;
+		}
+		self maps/mp/teams/_teams::set_player_model( self.team, weapon );
+	}
+	self clearperks();
+	self.killstreak = [];
+	self.pers[ "killstreaks" ] = [];
+	self.pers[ "killstreak_has_been_used" ] = [];
+	self.pers[ "killstreak_unique_id" ] = [];
+	if ( !isDefined( takeweapons ) || takeweapons )
+	{
+		self takeallweapons();
+	}
+	if ( isDefined( self.pers[ "hasRadar" ] ) && self.pers[ "hasRadar" ] )
+	{
+		self.hasspyplane = 1;
+	}
+	while ( isDefined( self.powerups ) && isDefined( self.powerups.size ) )
+	{
+		i = 0;
+		while ( i < self.powerups.size )
+		{
+			self applypowerup( self.powerups[ i ] );
+			i++;
+		}
+	}
+	self setradarvisibility();
+}
+
+assignrandombody()
+{
+}
+
+queuewagerpopup( message, points, submessage, announcement )
+{
+	self endon( "disconnect" );
+	size = self.wagernotifyqueue.size;
+	self.wagernotifyqueue[ size ] = spawnstruct();
+	self.wagernotifyqueue[ size ].message = message;
+	self.wagernotifyqueue[ size ].points = points;
+	self.wagernotifyqueue[ size ].submessage = submessage;
+	self.wagernotifyqueue[ size ].announcement = announcement;
+	self notify( "received award" );
+}
+
+helpgameend()
+{
+	level endon( "game_ended" );
+	for ( ;; )
+	{
+		level waittill( "player_eliminated" );
+		if ( !isDefined( level.numlives ) || !level.numlives )
+		{
+			continue;
+		}
+		else
+		{
+			wait 0,05;
+			players = level.players;
+			playersleft = 0;
+			i = 0;
+			while ( i < players.size )
+			{
+				if ( isDefined( players[ i ].pers[ "lives" ] ) && players[ i ].pers[ "lives" ] > 0 )
+				{
+					playersleft++;
+				}
+				i++;
+			}
+			while ( playersleft == 2 )
+			{
+				i = 0;
+				while ( i < players.size )
+				{
+					players[ i ] queuewagerpopup( &"MP_HEADS_UP", 0, &"MP_U2_ONLINE", "wm_u2_online" );
+					players[ i ].pers[ "hasRadar" ] = 1;
+					players[ i ].hasspyplane = 1;
+					level.activeuavs[ players[ i ] getentitynumber() ]++;
+					i++;
+				}
+			}
+		}
+	}
+}
+
+setradarvisibility()
+{
+	prevscoreplace = self.prevscoreplace;
+	if ( !isDefined( prevscoreplace ) )
+	{
+		prevscoreplace = 1;
+	}
+	if ( isDefined( level.inthemoneyonradar ) && level.inthemoneyonradar )
+	{
+		if ( prevscoreplace <= 3 && isDefined( self.score ) && self.score > 0 )
+		{
+			self unsetperk( "specialty_gpsjammer" );
+		}
+		else
+		{
+			self setperk( "specialty_gpsjammer" );
+		}
+	}
+	else
+	{
+		if ( isDefined( level.firstplaceonradar ) && level.firstplaceonradar )
+		{
+			if ( prevscoreplace == 1 && isDefined( self.score ) && self.score > 0 )
+			{
+				self unsetperk( "specialty_gpsjammer" );
+				return;
+			}
+			else
+			{
+				self setperk( "specialty_gpsjammer" );
+			}
+		}
+	}
+}
+
+playerscored()
+{
+	self notify( "wager_player_scored" );
+	self endon( "wager_player_scored" );
+	wait 0,05;
+	maps/mp/gametypes/_globallogic::updateplacement();
+	i = 0;
+	while ( i < level.placement[ "all" ].size )
+	{
+		prevscoreplace = level.placement[ "all" ][ i ].prevscoreplace;
+		if ( !isDefined( prevscoreplace ) )
+		{
+			prevscoreplace = 1;
+		}
+		currentscoreplace = i + 1;
+		j = i - 1;
+		while ( j >= 0 )
+		{
+			if ( level.placement[ "all" ][ i ].score == level.placement[ "all" ][ j ].score )
+			{
+				currentscoreplace--;
+
+			}
+			j--;
+
+		}
+		wasinthemoney = prevscoreplace <= 3;
+		isinthemoney = currentscoreplace <= 3;
+		if ( !wasinthemoney && isinthemoney )
+		{
+			level.placement[ "all" ][ i ] wagerannouncer( "wm_in_the_money" );
+		}
+		else
+		{
+			if ( wasinthemoney && !isinthemoney )
+			{
+				level.placement[ "all" ][ i ] wagerannouncer( "wm_oot_money" );
+			}
+		}
+		level.placement[ "all" ][ i ].prevscoreplace = currentscoreplace;
+		level.placement[ "all" ][ i ] setradarvisibility();
+		i++;
+	}
+}
+
+wagerannouncer( dialog, group )
+{
+	self maps/mp/gametypes/_globallogic_audio::leaderdialogonplayer( dialog, group );
+}
+
+createpowerup( name, type, displayname, iconmaterial )
+{
+	powerup = spawnstruct();
+	powerup.name = [];
+	powerup.name[ 0 ] = name;
+	powerup.type = type;
+	powerup.displayname = displayname;
+	powerup.iconmaterial = iconmaterial;
+	return powerup;
+}
+
+addpowerup( name, type, displayname, iconmaterial )
+{
+	if ( !isDefined( level.poweruplist ) )
+	{
+		level.poweruplist = [];
+	}
+	i = 0;
+	while ( i < level.poweruplist.size )
+	{
+		if ( level.poweruplist[ i ].displayname == displayname )
+		{
+			level.poweruplist[ i ].name[ level.poweruplist[ i ].name.size ] = name;
+			return;
+		}
+		i++;
+	}
+	powerup = createpowerup( name, type, displayname, iconmaterial );
+	level.poweruplist[ level.poweruplist.size ] = powerup;
+}
+
+copypowerup( powerup )
+{
+	return createpowerup( powerup.name[ 0 ], powerup.type, powerup.displayname, powerup.iconmaterial );
+}
+
+applypowerup( powerup )
+{
+	switch( powerup.type )
+	{
+		case "primary":
+			self giveweapon( powerup.name[ 0 ] );
+			self switchtoweapon( powerup.name[ 0 ] );
+			break;
+		case "secondary":
+			self giveweapon( powerup.name[ 0 ] );
+			break;
+		case "equipment":
+			self giveweapon( powerup.name[ 0 ] );
+			self maps/mp/gametypes/_class::setweaponammooverall( powerup.name[ 0 ], 1 );
+			self setactionslot( 1, "weapon", powerup.name[ 0 ] );
+			break;
+		case "primary_grenade":
+			self setoffhandprimaryclass( powerup.name[ 0 ] );
+			self giveweapon( powerup.name[ 0 ] );
+			self setweaponammoclip( powerup.name[ 0 ], 2 );
+			break;
+		case "secondary_grenade":
+			self setoffhandsecondaryclass( powerup.name[ 0 ] );
+			self giveweapon( powerup.name[ 0 ] );
+			self setweaponammoclip( powerup.name[ 0 ], 2 );
+			break;
+		case "perk":
+			i = 0;
+			while ( i < powerup.name.size )
+			{
+				self setperk( powerup.name[ i ] );
+				i++;
+			}
+			case "killstreak":
+				self maps/mp/killstreaks/_killstreaks::givekillstreak( powerup.name[ 0 ] );
+				break;
+			case "score_multiplier":
+				self.scoremultiplier = powerup.name[ 0 ];
+				break;
+		}
+	}
+}
+
+givepowerup( powerup, doanimation )
+{
+	if ( !isDefined( self.powerups ) )
+	{
+		self.powerups = [];
+	}
+	powerupindex = self.powerups.size;
+	self.powerups[ powerupindex ] = copypowerup( powerup );
+	i = 0;
+	while ( i < powerup.name.size )
+	{
+		self.powerups[ powerupindex ].name[ self.powerups[ powerupindex ].name.size ] = powerup.name[ i ];
+		i++;
+	}
+	self applypowerup( self.powerups[ powerupindex ] );
+	self thread showpowerupmessage( powerupindex, doanimation );
+}
+
+pulsepowerupicon( powerupindex )
+{
+	if ( isDefined( self ) && isDefined( self.powerups ) || !isDefined( self.powerups[ powerupindex ] ) && !isDefined( self.powerups[ powerupindex ].hud_elem_icon ) )
+	{
+		return;
+	}
+	self endon( "disconnect" );
+	self endon( "delete" );
+	self endon( "clearing_powerups" );
+	pulsepercent = 1,5;
+	pulsetime = 0,5;
+	hud_elem = self.powerups[ powerupindex ].hud_elem_icon;
+	if ( isDefined( hud_elem.animating ) && hud_elem.animating )
+	{
+		return;
+	}
+	origx = hud_elem.x;
+	origy = hud_elem.y;
+	origwidth = hud_elem.width;
+	origheight = hud_elem.height;
+	bigwidth = origwidth * pulsepercent;
+	bigheight = origheight * pulsepercent;
+	xoffset = ( bigwidth - origwidth ) / 2;
+	yoffset = ( bigheight - origheight ) / 2;
+	hud_elem scaleovertime( 0,05, int( bigwidth ), int( bigheight ) );
+	hud_elem moveovertime( 0,05 );
+	hud_elem.x = origx - xoffset;
+	hud_elem.y = origy - yoffset;
+	wait 0,05;
+	hud_elem scaleovertime( pulsetime, origwidth, origheight );
+	hud_elem moveovertime( pulsetime );
+	hud_elem.x = origx;
+	hud_elem.y = origy;
+}
+
+showpowerupmessage( powerupindex, doanimation )
+{
+	self endon( "disconnect" );
+	self endon( "delete" );
+	self endon( "clearing_powerups" );
+	if ( !isDefined( doanimation ) )
+	{
+		doanimation = 1;
+	}
+	wasinprematch = level.inprematchperiod;
+	powerupstarty = 320;
+	powerupspacing = 40;
+	if ( self issplitscreen() )
+	{
+		powerupstarty = 120;
+		powerupspacing = 35;
+	}
+	if ( isDefined( self.powerups[ powerupindex ].hud_elem ) )
+	{
+		self.powerups[ powerupindex ].hud_elem destroy();
+	}
+	self.powerups[ powerupindex ].hud_elem = newclienthudelem( self );
+	self.powerups[ powerupindex ].hud_elem.fontscale = 1,5;
+	self.powerups[ powerupindex ].hud_elem.x = -125;
+	self.powerups[ powerupindex ].hud_elem.y = powerupstarty - ( powerupspacing * powerupindex );
+	self.powerups[ powerupindex ].hud_elem.alignx = "left";
+	self.powerups[ powerupindex ].hud_elem.aligny = "middle";
+	self.powerups[ powerupindex ].hud_elem.horzalign = "user_right";
+	self.powerups[ powerupindex ].hud_elem.vertalign = "user_top";
+	self.powerups[ powerupindex ].hud_elem.color = ( 1, 1, 1 );
+	self.powerups[ powerupindex ].hud_elem.foreground = 1;
+	self.powerups[ powerupindex ].hud_elem.hidewhendead = 0;
+	self.powerups[ powerupindex ].hud_elem.hidewheninmenu = 1;
+	self.powerups[ powerupindex ].hud_elem.hidewheninkillcam = 1;
+	self.powerups[ powerupindex ].hud_elem.archived = 0;
+	self.powerups[ powerupindex ].hud_elem.alpha = 0;
+	self.powerups[ powerupindex ].hud_elem settext( self.powerups[ powerupindex ].displayname );
+	bigiconsize = 40;
+	iconsize = 32;
+	if ( isDefined( self.powerups[ powerupindex ].hud_elem_icon ) )
+	{
+		self.powerups[ powerupindex ].hud_elem_icon destroy();
+	}
+	if ( doanimation )
+	{
+		self.powerups[ powerupindex ].hud_elem_icon = self createicon( self.powerups[ powerupindex ].iconmaterial, bigiconsize, bigiconsize );
+		self.powerups[ powerupindex ].hud_elem_icon.animating = 1;
+	}
+	else
+	{
+		self.powerups[ powerupindex ].hud_elem_icon = self createicon( self.powerups[ powerupindex ].iconmaterial, iconsize, iconsize );
+	}
+	self.powerups[ powerupindex ].hud_elem_icon.x = ( ( self.powerups[ powerupindex ].hud_elem.x - 5 ) - ( iconsize / 2 ) ) - ( bigiconsize / 2 );
+	self.powerups[ powerupindex ].hud_elem_icon.y = ( powerupstarty - ( powerupspacing * powerupindex ) ) - ( bigiconsize / 2 );
+	self.powerups[ powerupindex ].hud_elem_icon.horzalign = "user_right";
+	self.powerups[ powerupindex ].hud_elem_icon.vertalign = "user_top";
+	self.powerups[ powerupindex ].hud_elem_icon.color = ( 1, 1, 1 );
+	self.powerups[ powerupindex ].hud_elem_icon.foreground = 1;
+	self.powerups[ powerupindex ].hud_elem_icon.hidewhendead = 0;
+	self.powerups[ powerupindex ].hud_elem_icon.hidewheninmenu = 1;
+	self.powerups[ powerupindex ].hud_elem_icon.hidewheninkillcam = 1;
+	self.powerups[ powerupindex ].hud_elem_icon.archived = 0;
+	self.powerups[ powerupindex ].hud_elem_icon.alpha = 1;
+	if ( !wasinprematch && doanimation )
+	{
+		self thread queuewagerpopup( self.powerups[ powerupindex ].displayname, 0, &"MP_BONUS_ACQUIRED" );
+	}
+	pulsetime = 0,5;
+	if ( doanimation )
+	{
+		self.powerups[ powerupindex ].hud_elem fadeovertime( pulsetime );
+		self.powerups[ powerupindex ].hud_elem_icon scaleovertime( pulsetime, iconsize, iconsize );
+		self.powerups[ powerupindex ].hud_elem_icon.width = iconsize;
+		self.powerups[ powerupindex ].hud_elem_icon.height = iconsize;
+		self.powerups[ powerupindex ].hud_elem_icon moveovertime( pulsetime );
+	}
+	self.powerups[ powerupindex ].hud_elem.alpha = 1;
+	self.powerups[ powerupindex ].hud_elem_icon.x = ( self.powerups[ powerupindex ].hud_elem.x - 5 ) - iconsize;
+	self.powerups[ powerupindex ].hud_elem_icon.y = ( powerupstarty - ( powerupspacing * powerupindex ) ) - ( iconsize / 2 );
+	if ( doanimation )
+	{
+		wait pulsetime;
+	}
+	if ( level.inprematchperiod )
+	{
+		level waittill( "prematch_over" );
+	}
+	else
+	{
+		if ( doanimation )
+		{
+			wait pulsetime;
+		}
+	}
+	if ( wasinprematch && doanimation )
+	{
+		self thread queuewagerpopup( self.powerups[ powerupindex ].displayname, 0, &"MP_BONUS_ACQUIRED" );
+	}
+	wait 1,5;
+	i = 0;
+	while ( i <= powerupindex )
+	{
+		self.powerups[ i ].hud_elem fadeovertime( 0,25 );
+		self.powerups[ i ].hud_elem.alpha = 0;
+		i++;
+	}
+	wait 0,25;
+	i = 0;
+	while ( i <= powerupindex )
+	{
+		self.powerups[ i ].hud_elem_icon moveovertime( 0,25 );
+		self.powerups[ i ].hud_elem_icon.x = 0 - iconsize;
+		self.powerups[ i ].hud_elem_icon.horzalign = "user_right";
+		i++;
+	}
+	self.powerups[ powerupindex ].hud_elem_icon.animating = 0;
+}
+
+clearpowerups()
+{
+	self notify( "clearing_powerups" );
+	while ( isDefined( self.powerups ) && isDefined( self.powerups.size ) )
+	{
+		i = 0;
+		while ( i < self.powerups.size )
+		{
+			if ( isDefined( self.powerups[ i ].hud_elem ) )
+			{
+				self.powerups[ i ].hud_elem destroy();
+			}
+			if ( isDefined( self.powerups[ i ].hud_elem_icon ) )
+			{
+				self.powerups[ i ].hud_elem_icon destroy();
+			}
+			i++;
+		}
+	}
+	self.powerups = [];
+}
+
+trackwagerweaponusage( name, incvalue, statname )
+{
+	if ( !isDefined( self.wagerweaponusage ) )
+	{
+		self.wagerweaponusage = [];
+	}
+	if ( !isDefined( self.wagerweaponusage[ name ] ) )
+	{
+		self.wagerweaponusage[ name ] = [];
+	}
+	if ( !isDefined( self.wagerweaponusage[ name ][ statname ] ) )
+	{
+		self.wagerweaponusage[ name ][ statname ] = 0;
+	}
+	self.wagerweaponusage[ name ][ statname ] += incvalue;
+}
+
+gethighestwagerweaponusage( statname )
+{
+	if ( !isDefined( self.wagerweaponusage ) )
+	{
+		return undefined;
+	}
+	bestweapon = undefined;
+	highestvalue = 0;
+	wagerweaponsused = getarraykeys( self.wagerweaponusage );
+	i = 0;
+	while ( i < wagerweaponsused.size )
+	{
+		weaponstats = self.wagerweaponusage[ wagerweaponsused[ i ] ];
+		if ( !isDefined( weaponstats[ statname ] ) || !getbaseweaponitemindex( wagerweaponsused[ i ] ) )
+		{
+			i++;
+			continue;
+		}
+		else if ( !isDefined( bestweapon ) || weaponstats[ statname ] > highestvalue )
+		{
+			bestweapon = wagerweaponsused[ i ];
+			highestvalue = weaponstats[ statname ];
+		}
+		i++;
+	}
+	return bestweapon;
+}
+
+setwagerafteractionreportstats()
+{
+	topweapon = self gethighestwagerweaponusage( "kills" );
+	topkills = 0;
+	if ( isDefined( topweapon ) )
+	{
+		topkills = self.wagerweaponusage[ topweapon ][ "kills" ];
+	}
+	else
+	{
+		topweapon = self gethighestwagerweaponusage( "timeUsed" );
+	}
+	if ( !isDefined( topweapon ) )
+	{
+		topweapon = "";
+	}
+	self maps/mp/gametypes/_persistence::setafteractionreportstat( "topWeaponItemIndex", getbaseweaponitemindex( topweapon ) );
+	self maps/mp/gametypes/_persistence::setafteractionreportstat( "topWeaponKills", topkills );
+	if ( isDefined( level.onwagerawards ) )
+	{
+		self [[ level.onwagerawards ]]();
+	}
+	else
+	{
+		i = 0;
+		while ( i < 3 )
+		{
+			self maps/mp/gametypes/_persistence::setafteractionreportstat( "wagerAwards", 0, i );
+			i++;
+		}
+	}
+}

patch_mp/maps/mp/gametypes/_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";
+		}
+	}
+}

patch_mp/maps/mp/gametypes/conf.gsc

@@ -0,0 +1,521 @@
+#include maps/mp/gametypes/_hostmigration;
+#include maps/mp/_scoreevents;
+#include maps/mp/gametypes/_globallogic_audio;
+#include maps/mp/gametypes/_objpoints;
+#include maps/mp/gametypes/_globallogic_score;
+#include maps/mp/gametypes/_spawning;
+#include maps/mp/gametypes/_spawnlogic;
+#include common_scripts/utility;
+#include maps/mp/gametypes/_hud_util;
+#include maps/mp/_utility;
+
+main()
+{
+	maps/mp/gametypes/_globallogic::init();
+	maps/mp/gametypes/_callbacksetup::setupcallbacks();
+	maps/mp/gametypes/_globallogic::setupcallbacks();
+	registertimelimit( 0, 1440 );
+	registerscorelimit( 0, 50000 );
+	registerroundlimit( 0, 10 );
+	registerroundswitch( 0, 9 );
+	registerroundwinlimit( 0, 10 );
+	registernumlives( 0, 100 );
+	maps/mp/gametypes/_globallogic::registerfriendlyfiredelay( level.gametype, 15, 0, 1440 );
+	level.scoreroundbased = 1;
+	level.teambased = 1;
+	level.onprecachegametype = ::onprecachegametype;
+	level.onstartgametype = ::onstartgametype;
+	level.onspawnplayer = ::onspawnplayer;
+	level.onspawnplayerunified = ::onspawnplayerunified;
+	level.onroundendgame = ::onroundendgame;
+	level.onplayerkilled = ::onplayerkilled;
+	level.onroundswitch = ::onroundswitch;
+	level.overrideteamscore = 1;
+	level.teamscoreperkill = getgametypesetting( "teamScorePerKill" );
+	level.teamscoreperkillconfirmed = getgametypesetting( "teamScorePerKillConfirmed" );
+	level.teamscoreperkilldenied = getgametypesetting( "teamScorePerKillDenied" );
+	level.antiboostdistance = getgametypesetting( "antiBoostDistance" );
+	game[ "dialog" ][ "gametype" ] = "kc_start";
+	game[ "dialog" ][ "gametype_hardcore" ] = "kc_start";
+	game[ "dialog" ][ "offense_obj" ] = "generic_boost";
+	game[ "dialog" ][ "defense_obj" ] = "generic_boost";
+	game[ "dialog" ][ "kc_deny" ] = "kc_deny";
+	game[ "dialog" ][ "kc_start" ] = "kc_start";
+	game[ "dialog" ][ "kc_denied" ] = "mpl_kc_killdeny";
+	level.conf_fx[ "vanish" ] = loadfx( "maps/mp_maps/fx_mp_kill_confirmed_vanish" );
+	if ( !sessionmodeissystemlink() && !sessionmodeisonlinegame() && issplitscreen() )
+	{
+		setscoreboardcolumns( "score", "kills", "killsconfirmed", "killsdenied", "deaths" );
+	}
+	else
+	{
+		setscoreboardcolumns( "score", "kills", "deaths", "killsconfirmed", "killsdenied" );
+	}
+}
+
+onprecachegametype()
+{
+	precachemodel( "p6_dogtags" );
+	precachemodel( "p6_dogtags_friend" );
+	precacheshader( "waypoint_dogtags" );
+	precachestring( &"MP_KILL_DENIED" );
+}
+
+onstartgametype()
+{
+	setclientnamemode( "auto_change" );
+	if ( !isDefined( game[ "switchedsides" ] ) )
+	{
+		game[ "switchedsides" ] = 0;
+	}
+	if ( game[ "switchedsides" ] )
+	{
+		oldattackers = game[ "attackers" ];
+		olddefenders = game[ "defenders" ];
+		game[ "attackers" ] = olddefenders;
+		game[ "defenders" ] = oldattackers;
+	}
+	allowed[ 0 ] = level.gametype;
+	maps/mp/gametypes/_gameobjects::main( allowed );
+	level.spawnmins = ( 0, 0, 1 );
+	level.spawnmaxs = ( 0, 0, 1 );
+	_a109 = level.teams;
+	_k109 = getFirstArrayKey( _a109 );
+	while ( isDefined( _k109 ) )
+	{
+		team = _a109[ _k109 ];
+		setobjectivetext( team, &"OBJECTIVES_CONF" );
+		setobjectivehinttext( team, &"OBJECTIVES_CONF_HINT" );
+		if ( level.splitscreen )
+		{
+			setobjectivescoretext( team, &"OBJECTIVES_CONF" );
+		}
+		else
+		{
+			setobjectivescoretext( team, &"OBJECTIVES_CONF_SCORE" );
+		}
+		maps/mp/gametypes/_spawnlogic::placespawnpoints( maps/mp/gametypes/_spawning::gettdmstartspawnname( team ) );
+		maps/mp/gametypes/_spawnlogic::addspawnpoints( team, "mp_tdm_spawn" );
+		_k109 = getNextArrayKey( _a109, _k109 );
+	}
+	maps/mp/gametypes/_spawning::updateallspawnpoints();
+	level.spawn_start = [];
+	_a131 = level.teams;
+	_k131 = getFirstArrayKey( _a131 );
+	while ( isDefined( _k131 ) )
+	{
+		team = _a131[ _k131 ];
+		level.spawn_start[ team ] = maps/mp/gametypes/_spawnlogic::getspawnpointarray( maps/mp/gametypes/_spawning::gettdmstartspawnname( team ) );
+		_k131 = getNextArrayKey( _a131, _k131 );
+	}
+	level.mapcenter = maps/mp/gametypes/_spawnlogic::findboxcenter( level.spawnmins, level.spawnmaxs );
+	setmapcenter( level.mapcenter );
+	spawnpoint = maps/mp/gametypes/_spawnlogic::getrandomintermissionpoint();
+	setdemointermissionpoint( spawnpoint.origin, spawnpoint.angles );
+	level.dogtags = [];
+	if ( !isoneround() )
+	{
+		level.displayroundendtext = 1;
+		if ( isscoreroundbased() )
+		{
+			maps/mp/gametypes/_globallogic_score::resetteamscores();
+		}
+	}
+}
+
+onplayerkilled( einflictor, attacker, idamage, smeansofdeath, sweapon, vdir, shitloc, psoffsettime, deathanimduration )
+{
+	if ( !isplayer( attacker ) || attacker.team == self.team )
+	{
+		return;
+	}
+	level thread spawndogtags( self, attacker );
+	attacker maps/mp/gametypes/_globallogic_score::giveteamscoreforobjective( attacker.team, level.teamscoreperkill );
+}
+
+spawndogtags( victim, attacker )
+{
+	if ( isDefined( level.dogtags[ victim.entnum ] ) )
+	{
+		playfx( level.conf_fx[ "vanish" ], level.dogtags[ victim.entnum ].curorigin );
+		level.dogtags[ victim.entnum ] notify( "reset" );
+	}
+	else
+	{
+		visuals[ 0 ] = spawn( "script_model", ( 0, 0, 1 ) );
+		visuals[ 0 ] setmodel( "p6_dogtags" );
+		visuals[ 1 ] = spawn( "script_model", ( 0, 0, 1 ) );
+		visuals[ 1 ] setmodel( "p6_dogtags_friend" );
+		trigger = spawn( "trigger_radius", ( 0, 0, 1 ), 0, 32, 32 );
+		level.dogtags[ victim.entnum ] = maps/mp/gametypes/_gameobjects::createuseobject( "any", trigger, visuals, vectorScale( ( 0, 0, 1 ), 16 ) );
+		_a189 = level.teams;
+		_k189 = getFirstArrayKey( _a189 );
+		while ( isDefined( _k189 ) )
+		{
+			team = _a189[ _k189 ];
+			objective_delete( level.dogtags[ victim.entnum ].objid[ team ] );
+			maps/mp/gametypes/_gameobjects::releaseobjid( level.dogtags[ victim.entnum ].objid[ team ] );
+			maps/mp/gametypes/_objpoints::deleteobjpoint( level.dogtags[ victim.entnum ].objpoints[ team ] );
+			_k189 = getNextArrayKey( _a189, _k189 );
+		}
+		level.dogtags[ victim.entnum ] maps/mp/gametypes/_gameobjects::setusetime( 0 );
+		level.dogtags[ victim.entnum ].onuse = ::onuse;
+		level.dogtags[ victim.entnum ].victim = victim;
+		level.dogtags[ victim.entnum ].victimteam = victim.team;
+		level.dogtags[ victim.entnum ].objid = maps/mp/gametypes/_gameobjects::getnextobjid();
+		objective_add( level.dogtags[ victim.entnum ].objid, "invisible", ( 0, 0, 1 ) );
+		objective_icon( level.dogtags[ victim.entnum ].objid, "waypoint_dogtags" );
+		level thread clearonvictimdisconnect( victim );
+		victim thread tagteamupdater( level.dogtags[ victim.entnum ] );
+	}
+	pos = victim.origin + vectorScale( ( 0, 0, 1 ), 14 );
+	level.dogtags[ victim.entnum ].curorigin = pos;
+	level.dogtags[ victim.entnum ].trigger.origin = pos;
+	level.dogtags[ victim.entnum ].visuals[ 0 ].origin = pos;
+	level.dogtags[ victim.entnum ].visuals[ 1 ].origin = pos;
+	level.dogtags[ victim.entnum ] maps/mp/gametypes/_gameobjects::allowuse( "any" );
+	level.dogtags[ victim.entnum ].visuals[ 0 ] thread showtoteam( level.dogtags[ victim.entnum ], attacker.team );
+	level.dogtags[ victim.entnum ].visuals[ 1 ] thread showtoenemyteams( level.dogtags[ victim.entnum ], attacker.team );
+	level.dogtags[ victim.entnum ].attacker = attacker;
+	level.dogtags[ victim.entnum ].attackerteam = attacker.team;
+	level.dogtags[ victim.entnum ].unreachable = undefined;
+	level.dogtags[ victim.entnum ].tacinsert = 0;
+	objective_position( level.dogtags[ victim.entnum ].objid, pos );
+	objective_state( level.dogtags[ victim.entnum ].objid, "active" );
+	objective_setinvisibletoall( level.dogtags[ victim.entnum ].objid );
+	objective_setvisibletoplayer( level.dogtags[ victim.entnum ].objid, attacker );
+	level.dogtags[ victim.entnum ] thread bounce();
+	level notify( "dogtag_spawned" );
+}
+
+showtoteam( gameobject, team )
+{
+	gameobject endon( "death" );
+	gameobject endon( "reset" );
+	self hide();
+	_a245 = level.players;
+	_k245 = getFirstArrayKey( _a245 );
+	while ( isDefined( _k245 ) )
+	{
+		player = _a245[ _k245 ];
+		if ( player.team == team )
+		{
+			self showtoplayer( player );
+		}
+		_k245 = getNextArrayKey( _a245, _k245 );
+	}
+	for ( ;; )
+	{
+		level waittill( "joined_team" );
+		self hide();
+		_a256 = level.players;
+		_k256 = getFirstArrayKey( _a256 );
+		while ( isDefined( _k256 ) )
+		{
+			player = _a256[ _k256 ];
+			if ( player.team == team )
+			{
+				self showtoplayer( player );
+			}
+			if ( gameobject.victimteam == player.team && player == gameobject.attacker )
+			{
+				objective_state( gameobject.objid, "invisible" );
+			}
+			_k256 = getNextArrayKey( _a256, _k256 );
+		}
+	}
+}
+
+showtoenemyteams( gameobject, friend_team )
+{
+	gameobject endon( "death" );
+	gameobject endon( "reset" );
+	self hide();
+	_a274 = level.players;
+	_k274 = getFirstArrayKey( _a274 );
+	while ( isDefined( _k274 ) )
+	{
+		player = _a274[ _k274 ];
+		if ( player.team != friend_team )
+		{
+			self showtoplayer( player );
+		}
+		_k274 = getNextArrayKey( _a274, _k274 );
+	}
+	for ( ;; )
+	{
+		level waittill( "joined_team" );
+		self hide();
+		_a285 = level.players;
+		_k285 = getFirstArrayKey( _a285 );
+		while ( isDefined( _k285 ) )
+		{
+			player = _a285[ _k285 ];
+			if ( player.team != friend_team )
+			{
+				self showtoplayer( player );
+			}
+			if ( gameobject.victimteam == player.team && player == gameobject.attacker )
+			{
+				objective_state( gameobject.objid, "invisible" );
+			}
+			_k285 = getNextArrayKey( _a285, _k285 );
+		}
+	}
+}
+
+onuse( player )
+{
+	tacinsertboost = 0;
+	if ( player.team != self.attackerteam )
+	{
+		self.trigger playsound( "mpl_killconfirm_tags_pickup" );
+		player addplayerstat( "KILLSDENIED", 1 );
+		player recordgameevent( "return" );
+		if ( self.victim == player )
+		{
+			if ( self.tacinsert == 0 )
+			{
+				event = "retrieve_own_tags";
+				splash = &"SPLASHES_TAGS_RETRIEVED";
+			}
+			else
+			{
+				tacinsertboost = 1;
+			}
+		}
+		else
+		{
+			event = "kill_denied";
+			splash = &"SPLASHES_KILL_DENIED";
+		}
+		if ( isDefined( self.attacker ) && self.attacker.team == self.attackerteam )
+		{
+			self.attacker luinotifyevent( &"player_callout", 2, &"MP_KILL_DENIED", player.entnum );
+			self.attacker playlocalsound( game[ "dialog" ][ "kc_denied" ] );
+		}
+		if ( !tacinsertboost )
+		{
+			player maps/mp/gametypes/_globallogic_audio::leaderdialogonplayer( "kc_deny" );
+			player maps/mp/gametypes/_globallogic_score::giveteamscoreforobjective( player.team, level.teamscoreperkilldenied );
+			player.pers[ "killsdenied" ]++;
+			player.killsdenied = player.pers[ "killsdenied" ];
+		}
+	}
+	else
+	{
+		self.trigger playsound( "mpl_killconfirm_tags_pickup" );
+		event = "kill_confirmed";
+		splash = &"SPLASHES_KILL_CONFIRMED";
+		player addplayerstat( "KILLSCONFIRMED", 1 );
+		player recordgameevent( "capture" );
+/#
+		assert( isDefined( player.lastkillconfirmedtime ) );
+		assert( isDefined( player.lastkillconfirmedcount ) );
+#/
+		if ( self.attacker != player )
+		{
+			self.attacker thread onpickup( "teammate_kill_confirmed", splash );
+		}
+		player maps/mp/gametypes/_globallogic_audio::leaderdialogonplayer( "kc_start" );
+		player.pers[ "killsconfirmed" ]++;
+		player.killsconfirmed = player.pers[ "killsconfirmed" ];
+		player maps/mp/gametypes/_globallogic_score::giveteamscoreforobjective( player.team, level.teamscoreperkillconfirmed );
+	}
+	if ( !tacinsertboost )
+	{
+		player thread onpickup( event, splash );
+		currenttime = getTime();
+		if ( ( player.lastkillconfirmedtime + 1000 ) > currenttime )
+		{
+			player.lastkillconfirmedcount++;
+			if ( player.lastkillconfirmedcount >= 3 )
+			{
+				maps/mp/_scoreevents::processscoreevent( "kill_confirmed_multi", player );
+				player.lastkillconfirmedcount = 0;
+			}
+		}
+		else
+		{
+			player.lastkillconfirmedcount = 1;
+		}
+		player.lastkillconfirmedtime = currenttime;
+	}
+	self resettags();
+}
+
+onpickup( event, splash )
+{
+	level endon( "game_ended" );
+	self endon( "disconnect" );
+	while ( !isDefined( self.pers ) )
+	{
+		wait 0,05;
+	}
+	maps/mp/_scoreevents::processscoreevent( event, self );
+}
+
+resettags()
+{
+	self.attacker = undefined;
+	self.unreachable = undefined;
+	self notify( "reset" );
+	self.visuals[ 0 ] hide();
+	self.visuals[ 1 ] hide();
+	self.curorigin = vectorScale( ( 0, 0, 1 ), 1000 );
+	self.trigger.origin = vectorScale( ( 0, 0, 1 ), 1000 );
+	self.visuals[ 0 ].origin = vectorScale( ( 0, 0, 1 ), 1000 );
+	self.visuals[ 1 ].origin = vectorScale( ( 0, 0, 1 ), 1000 );
+	self.tacinsert = 0;
+	self maps/mp/gametypes/_gameobjects::allowuse( "none" );
+	objective_state( self.objid, "invisible" );
+}
+
+bounce()
+{
+	level endon( "game_ended" );
+	self endon( "reset" );
+	bottompos = self.curorigin;
+	toppos = self.curorigin + vectorScale( ( 0, 0, 1 ), 12 );
+	while ( 1 )
+	{
+		self.visuals[ 0 ] moveto( toppos, 0,5, 0,15, 0,15 );
+		self.visuals[ 0 ] rotateyaw( 180, 0,5 );
+		self.visuals[ 1 ] moveto( toppos, 0,5, 0,15, 0,15 );
+		self.visuals[ 1 ] rotateyaw( 180, 0,5 );
+		wait 0,5;
+		self.visuals[ 0 ] moveto( bottompos, 0,5, 0,15, 0,15 );
+		self.visuals[ 0 ] rotateyaw( 180, 0,5 );
+		self.visuals[ 1 ] moveto( bottompos, 0,5, 0,15, 0,15 );
+		self.visuals[ 1 ] rotateyaw( 180, 0,5 );
+		wait 0,5;
+	}
+}
+
+timeout( victim )
+{
+	level endon( "game_ended" );
+	victim endon( "disconnect" );
+	self notify( "timeout" );
+	self endon( "timeout" );
+	level maps/mp/gametypes/_hostmigration::waitlongdurationwithhostmigrationpause( 30 );
+	self.visuals[ 0 ] hide();
+	self.visuals[ 1 ] hide();
+	self.curorigin = vectorScale( ( 0, 0, 1 ), 1000 );
+	self.trigger.origin = vectorScale( ( 0, 0, 1 ), 1000 );
+	self.visuals[ 0 ].origin = vectorScale( ( 0, 0, 1 ), 1000 );
+	self.visuals[ 1 ].origin = vectorScale( ( 0, 0, 1 ), 1000 );
+	self.tacinsert = 0;
+	self maps/mp/gametypes/_gameobjects::allowuse( "none" );
+}
+
+tagteamupdater( tags )
+{
+	level endon( "game_ended" );
+	self endon( "disconnect" );
+	while ( 1 )
+	{
+		self waittill( "joined_team" );
+		tags.victimteam = self.team;
+		tags resettags();
+	}
+}
+
+clearonvictimdisconnect( victim )
+{
+	level endon( "game_ended" );
+	guid = victim.entnum;
+	victim waittill( "disconnect" );
+	if ( isDefined( level.dogtags[ guid ] ) )
+	{
+		level.dogtags[ guid ] maps/mp/gametypes/_gameobjects::allowuse( "none" );
+		playfx( level.conf_fx[ "vanish" ], level.dogtags[ guid ].curorigin );
+		level.dogtags[ guid ] notify( "reset" );
+		wait 0,05;
+		if ( isDefined( level.dogtags[ guid ] ) )
+		{
+			objective_delete( level.dogtags[ guid ].objid );
+			level.dogtags[ guid ].trigger delete();
+			i = 0;
+			while ( i < level.dogtags[ guid ].visuals.size )
+			{
+				level.dogtags[ guid ].visuals[ i ] delete();
+				i++;
+			}
+			level.dogtags[ guid ] notify( "deleted" );
+		}
+	}
+}
+
+onspawnplayerunified()
+{
+	self.usingobj = undefined;
+	if ( level.usestartspawns && !level.ingraceperiod )
+	{
+		level.usestartspawns = 0;
+	}
+	self.lastkillconfirmedtime = 0;
+	self.lastkillconfirmedcount = 0;
+	maps/mp/gametypes/_spawning::onspawnplayer_unified();
+	if ( level.rankedmatch || level.leaguematch )
+	{
+		if ( isDefined( self.tacticalinsertiontime ) && ( self.tacticalinsertiontime + 100 ) > getTime() )
+		{
+			mindist = level.antiboostdistance;
+			mindistsqr = mindist * mindist;
+			distsqr = distancesquared( self.origin, level.dogtags[ self.entnum ].curorigin );
+			if ( distsqr < mindistsqr )
+			{
+				level.dogtags[ self.entnum ].tacinsert = 1;
+			}
+		}
+	}
+}
+
+onspawnplayer( predictedspawn )
+{
+	pixbeginevent( "TDM:onSpawnPlayer" );
+	self.usingobj = undefined;
+	spawnteam = self.pers[ "team" ];
+	if ( level.ingraceperiod )
+	{
+		spawnpoints = maps/mp/gametypes/_spawnlogic::getspawnpointarray( maps/mp/gametypes/_spawning::gettdmstartspawnname( spawnteam ) );
+		if ( !spawnpoints.size )
+		{
+			spawnpoints = maps/mp/gametypes/_spawnlogic::getspawnpointarray( maps/mp/gametypes/_spawning::gettdmstartspawnname( spawnteam ) );
+		}
+		if ( !spawnpoints.size )
+		{
+			spawnpoints = maps/mp/gametypes/_spawnlogic::getteamspawnpoints( spawnteam );
+			spawnpoint = maps/mp/gametypes/_spawnlogic::getspawnpoint_nearteam( spawnpoints );
+		}
+		else
+		{
+			spawnpoint = maps/mp/gametypes/_spawnlogic::getspawnpoint_random( spawnpoints );
+		}
+	}
+	else
+	{
+		spawnpoints = maps/mp/gametypes/_spawnlogic::getteamspawnpoints( spawnteam );
+		spawnpoint = maps/mp/gametypes/_spawnlogic::getspawnpoint_nearteam( spawnpoints );
+	}
+	if ( predictedspawn )
+	{
+		self predictspawnpoint( spawnpoint.origin, spawnpoint.angles );
+	}
+	else
+	{
+		self spawn( spawnpoint.origin, spawnpoint.angles, "tdm" );
+	}
+	pixendevent();
+}
+
+onroundswitch()
+{
+	game[ "switchedsides" ] = !game[ "switchedsides" ];
+}
+
+onroundendgame( roundwinner )
+{
+	return maps/mp/gametypes/_globallogic::determineteamwinnerbygamestat( "roundswon" );
+}

patch_mp/maps/mp/gametypes/dm.gsc

@@ -0,0 +1,133 @@
+#include maps/mp/gametypes/_globallogic_score;
+#include maps/mp/gametypes/_globallogic_audio;
+#include maps/mp/gametypes/_spawnlogic;
+#include maps/mp/gametypes/_spawning;
+#include maps/mp/gametypes/_hud_util;
+#include maps/mp/_utility;
+
+main()
+{
+	maps/mp/gametypes/_globallogic::init();
+	maps/mp/gametypes/_callbacksetup::setupcallbacks();
+	maps/mp/gametypes/_globallogic::setupcallbacks();
+	registertimelimit( 0, 1440 );
+	registerscorelimit( 0, 50000 );
+	registerroundlimit( 0, 10 );
+	registerroundwinlimit( 0, 10 );
+	registernumlives( 0, 100 );
+	maps/mp/gametypes/_globallogic::registerfriendlyfiredelay( level.gametype, 0, 0, 1440 );
+	level.scoreroundbased = getgametypesetting( "roundscorecarry" ) == 0;
+	level.teamscoreperkill = getgametypesetting( "teamScorePerKill" );
+	level.teamscoreperdeath = getgametypesetting( "teamScorePerDeath" );
+	level.teamscoreperheadshot = getgametypesetting( "teamScorePerHeadshot" );
+	level.onstartgametype = ::onstartgametype;
+	level.onspawnplayer = ::onspawnplayer;
+	level.onspawnplayerunified = ::onspawnplayerunified;
+	level.onplayerkilled = ::onplayerkilled;
+	game[ "dialog" ][ "gametype" ] = "ffa_start";
+	game[ "dialog" ][ "gametype_hardcore" ] = "hcffa_start";
+	game[ "dialog" ][ "offense_obj" ] = "generic_boost";
+	game[ "dialog" ][ "defense_obj" ] = "generic_boost";
+	setscoreboardcolumns( "pointstowin", "kills", "deaths", "headshots", "score" );
+}
+
+onstartgametype()
+{
+	setclientnamemode( "auto_change" );
+	setobjectivetext( "allies", &"OBJECTIVES_DM" );
+	setobjectivetext( "axis", &"OBJECTIVES_DM" );
+	if ( level.splitscreen )
+	{
+		setobjectivescoretext( "allies", &"OBJECTIVES_DM" );
+		setobjectivescoretext( "axis", &"OBJECTIVES_DM" );
+	}
+	else
+	{
+		setobjectivescoretext( "allies", &"OBJECTIVES_DM_SCORE" );
+		setobjectivescoretext( "axis", &"OBJECTIVES_DM_SCORE" );
+	}
+	setobjectivehinttext( "allies", &"OBJECTIVES_DM_HINT" );
+	setobjectivehinttext( "axis", &"OBJECTIVES_DM_HINT" );
+	allowed[ 0 ] = "dm";
+	maps/mp/gametypes/_gameobjects::main( allowed );
+	maps/mp/gametypes/_spawning::create_map_placed_influencers();
+	level.spawnmins = ( 0, 0, 0 );
+	level.spawnmaxs = ( 0, 0, 0 );
+	maps/mp/gametypes/_spawnlogic::addspawnpoints( "allies", "mp_dm_spawn" );
+	maps/mp/gametypes/_spawnlogic::addspawnpoints( "axis", "mp_dm_spawn" );
+	maps/mp/gametypes/_spawning::updateallspawnpoints();
+	level.mapcenter = maps/mp/gametypes/_spawnlogic::findboxcenter( level.spawnmins, level.spawnmaxs );
+	setmapcenter( level.mapcenter );
+	spawnpoint = maps/mp/gametypes/_spawnlogic::getrandomintermissionpoint();
+	setdemointermissionpoint( spawnpoint.origin, spawnpoint.angles );
+	level.usestartspawns = 0;
+	level.displayroundendtext = 0;
+	level thread onscoreclosemusic();
+	if ( !isoneround() )
+	{
+		level.displayroundendtext = 1;
+	}
+}
+
+onspawnplayerunified()
+{
+	maps/mp/gametypes/_spawning::onspawnplayer_unified();
+}
+
+onspawnplayer( predictedspawn )
+{
+	spawnpoints = maps/mp/gametypes/_spawnlogic::getteamspawnpoints( self.pers[ "team" ] );
+	spawnpoint = maps/mp/gametypes/_spawnlogic::getspawnpoint_dm( spawnpoints );
+	if ( predictedspawn )
+	{
+		self predictspawnpoint( spawnpoint.origin, spawnpoint.angles );
+	}
+	else
+	{
+		self spawn( spawnpoint.origin, spawnpoint.angles, "dm" );
+	}
+}
+
+onendgame( winningplayer )
+{
+	if ( isDefined( winningplayer ) && isplayer( winningplayer ) )
+	{
+		[[ level._setplayerscore ]]( winningplayer, winningplayer [[ level._getplayerscore ]]() + 1 );
+	}
+}
+
+onscoreclosemusic()
+{
+	while ( !level.gameended )
+	{
+		scorelimit = level.scorelimit;
+		scorethreshold = scorelimit * 0,9;
+		i = 0;
+		while ( i < level.players.size )
+		{
+			scorecheck = [[ level._getplayerscore ]]( level.players[ i ] );
+			if ( scorecheck >= scorethreshold )
+			{
+				thread maps/mp/gametypes/_globallogic_audio::set_music_on_team( "TIME_OUT", "both" );
+				thread maps/mp/gametypes/_globallogic_audio::actionmusicset();
+				return;
+			}
+			i++;
+		}
+		wait 0,5;
+	}
+}
+
+onplayerkilled( einflictor, attacker, idamage, smeansofdeath, sweapon, vdir, shitloc, psoffsettime, deathanimduration )
+{
+	if ( !isplayer( attacker ) || self == attacker )
+	{
+		return;
+	}
+	attacker maps/mp/gametypes/_globallogic_score::givepointstowin( level.teamscoreperkill );
+	self maps/mp/gametypes/_globallogic_score::givepointstowin( level.teamscoreperdeath * -1 );
+	if ( smeansofdeath == "MOD_HEAD_SHOT" )
+	{
+		attacker maps/mp/gametypes/_globallogic_score::givepointstowin( level.teamscoreperheadshot );
+	}
+}

patch_mp/maps/mp/gametypes/gun.gsc

@@ -0,0 +1,406 @@
+#include maps/mp/gametypes/_persistence;
+#include maps/mp/gametypes/_spawnlogic;
+#include maps/mp/gametypes/_spawning;
+#include maps/mp/gametypes/_rank;
+#include maps/mp/gametypes/_globallogic_audio;
+#include maps/mp/_scoreevents;
+#include maps/mp/gametypes/_globallogic_score;
+#include maps/mp/gametypes/_wager;
+#include maps/mp/gametypes/_hud_util;
+#include maps/mp/_utility;
+
+main()
+{
+	maps/mp/gametypes/_globallogic::init();
+	maps/mp/gametypes/_callbacksetup::setupcallbacks();
+	maps/mp/gametypes/_globallogic::setupcallbacks();
+	level.onstartgametype = ::onstartgametype;
+	level.onspawnplayer = ::onspawnplayer;
+	level.onspawnplayerunified = ::onspawnplayerunified;
+	level.onplayerkilled = ::onplayerkilled;
+	level.onwagerawards = ::onwagerawards;
+	level.onendgame = ::onendgame;
+	game[ "dialog" ][ "gametype" ] = "gg_start";
+	game[ "dialog" ][ "wm_promoted" ] = "gg_promote";
+	game[ "dialog" ][ "wm_humiliation" ] = "mpl_wager_humiliate";
+	game[ "dialog" ][ "wm_humiliated" ] = "sns_hum";
+	level.givecustomloadout = ::givecustomloadout;
+	precachestring( &"MPUI_PLAYER_KILLED" );
+	precachestring( &"MP_GUN_NEXT_LEVEL" );
+	precachestring( &"MP_GUN_PREV_LEVEL" );
+	precachestring( &"MP_GUN_PREV_LEVEL_OTHER" );
+	precachestring( &"MP_HUMILIATION" );
+	precachestring( &"MP_HUMILIATED" );
+	precacheitem( "minigun_wager_mp" );
+	precacheitem( "m32_wager_mp" );
+	level.setbacksperdemotion = getgametypesetting( "setbacks" );
+	gunlist = getgametypesetting( "gunSelection" );
+	if ( gunlist == 3 )
+	{
+		gunlist = randomintrange( 0, 3 );
+	}
+	switch( gunlist )
+	{
+		case 0:
+			addguntoprogression( "beretta93r_mp+tacknife" );
+			addguntoprogression( "kard_dw_mp" );
+			addguntoprogression( "judge_mp+steadyaim" );
+			addguntoprogression( "ksg_mp+fastads" );
+			addguntoprogression( "srm1216_mp+extclip" );
+			addguntoprogression( "insas_mp+grip" );
+			addguntoprogression( "evoskorpion_mp+steadyaim" );
+			addguntoprogression( "qcw05_mp+reflex" );
+			addguntoprogression( "hk416_mp+mms" );
+			addguntoprogression( "xm8_mp+holo" );
+			addguntoprogression( "saritch_mp+acog" );
+			addguntoprogression( "qbb95_mp+rangefinder" );
+			addguntoprogression( "mk48_mp+dualoptic", "dualoptic_mk48_mp+dualoptic" );
+			addguntoprogression( "svu_mp+ir" );
+			addguntoprogression( "dsr50_mp+vzoom" );
+			addguntoprogression( "ballista_mp+is" );
+			addguntoprogression( "smaw_mp" );
+			addguntoprogression( "usrpg_mp" );
+			addguntoprogression( "crossbow_mp" );
+			addguntoprogression( "knife_ballistic_mp" );
+			break;
+		case 1:
+			addguntoprogression( "fiveseven_mp" );
+			addguntoprogression( "fnp45_mp" );
+			addguntoprogression( "kard_mp" );
+			addguntoprogression( "beretta93r_mp" );
+			addguntoprogression( "judge_mp" );
+			addguntoprogression( "ksg_mp" );
+			addguntoprogression( "870mcs_mp" );
+			addguntoprogression( "saiga12_mp" );
+			addguntoprogression( "srm1216_mp" );
+			addguntoprogression( "mp7_mp" );
+			addguntoprogression( "evoskorpion_mp" );
+			addguntoprogression( "pdw57_mp" );
+			addguntoprogression( "insas_mp" );
+			addguntoprogression( "vector_mp" );
+			addguntoprogression( "qcw05_mp" );
+			addguntoprogression( "m32_wager_mp" );
+			addguntoprogression( "smaw_mp" );
+			addguntoprogression( "usrpg_mp" );
+			addguntoprogression( "crossbow_mp" );
+			addguntoprogression( "knife_ballistic_mp" );
+			break;
+		case 2:
+			addguntoprogression( "hk416_mp" );
+			addguntoprogression( "scar_mp" );
+			addguntoprogression( "tar21_mp" );
+			addguntoprogression( "an94_mp" );
+			addguntoprogression( "type95_mp" );
+			addguntoprogression( "xm8_mp" );
+			addguntoprogression( "sig556_mp" );
+			addguntoprogression( "sa58_mp" );
+			addguntoprogression( "saritch_mp" );
+			addguntoprogression( "hamr_mp" );
+			addguntoprogression( "lsat_mp" );
+			addguntoprogression( "qbb95_mp" );
+			addguntoprogression( "mk48_mp" );
+			addguntoprogression( "svu_mp" );
+			addguntoprogression( "as50_mp" );
+			addguntoprogression( "dsr50_mp" );
+			addguntoprogression( "ballista_mp+is" );
+			addguntoprogression( "usrpg_mp" );
+			addguntoprogression( "crossbow_mp" );
+			addguntoprogression( "knife_ballistic_mp" );
+			break;
+	}
+	registertimelimit( 0, 1440 );
+	registerroundlimit( 0, 10 );
+	registerroundwinlimit( 0, 10 );
+	registernumlives( 0, 100 );
+	setscoreboardcolumns( "pointstowin", "kills", "deaths", "stabs", "humiliated" );
+}
+
+addguntoprogression( gunname, altname )
+{
+	if ( !isDefined( level.gunprogression ) )
+	{
+		level.gunprogression = [];
+	}
+	newweapon = spawnstruct();
+	newweapon.names = [];
+	newweapon.names[ newweapon.names.size ] = gunname;
+	if ( isDefined( altname ) )
+	{
+		newweapon.names[ newweapon.names.size ] = altname;
+	}
+	level.gunprogression[ level.gunprogression.size ] = newweapon;
+}
+
+givecustomloadout( takeallweapons, alreadyspawned )
+{
+	chooserandombody = 0;
+	if ( !isDefined( alreadyspawned ) || !alreadyspawned )
+	{
+		chooserandombody = 1;
+	}
+	if ( !isDefined( self.gunprogress ) )
+	{
+		self.gunprogress = 0;
+	}
+	currentweapon = level.gunprogression[ self.gunprogress ].names[ 0 ];
+	self maps/mp/gametypes/_wager::setupblankrandomplayer( takeallweapons, chooserandombody, currentweapon );
+	self disableweaponcycling();
+	self giveweapon( currentweapon );
+	self switchtoweapon( currentweapon );
+	self giveweapon( "knife_mp" );
+	if ( !isDefined( alreadyspawned ) || !alreadyspawned )
+	{
+		self setspawnweapon( currentweapon );
+	}
+	if ( isDefined( takeallweapons ) && !takeallweapons )
+	{
+		self thread takeoldweapons( currentweapon );
+	}
+	else
+	{
+		self enableweaponcycling();
+	}
+	return currentweapon;
+}
+
+takeoldweapons( currentweapon )
+{
+	self endon( "disconnect" );
+	self endon( "death" );
+	for ( ;; )
+	{
+		self waittill( "weapon_change", newweapon );
+		if ( newweapon != "none" )
+		{
+			break;
+		}
+		else
+		{
+		}
+	}
+	weaponslist = self getweaponslist();
+	i = 0;
+	while ( i < weaponslist.size )
+	{
+		if ( weaponslist[ i ] != currentweapon && weaponslist[ i ] != "knife_mp" )
+		{
+			self takeweapon( weaponslist[ i ] );
+		}
+		i++;
+	}
+	self enableweaponcycling();
+}
+
+promoteplayer( weaponused )
+{
+	self endon( "disconnect" );
+	self endon( "cancel_promotion" );
+	level endon( "game_ended" );
+	wait 0,05;
+	i = 0;
+	while ( i < level.gunprogression[ self.gunprogress ].names.size )
+	{
+		if ( weaponused == level.gunprogression[ self.gunprogress ].names[ i ] || weaponused == "explosive_bolt_mp" && level.gunprogression[ self.gunprogress ].names[ i ] != "crossbow_mp" || level.gunprogression[ self.gunprogress ].names[ i ] == "crossbow_mp+reflex" && level.gunprogression[ self.gunprogress ].names[ i ] == "crossbow_mp+acog" )
+		{
+			if ( self.gunprogress < ( level.gunprogression.size - 1 ) )
+			{
+				self.gunprogress++;
+				if ( isalive( self ) )
+				{
+					self thread givecustomloadout( 0, 1 );
+				}
+				self thread maps/mp/gametypes/_wager::queuewagerpopup( &"MPUI_PLAYER_KILLED", 0, &"MP_GUN_NEXT_LEVEL" );
+			}
+			pointstowin = self.pers[ "pointstowin" ];
+			if ( pointstowin < level.scorelimit )
+			{
+				self maps/mp/gametypes/_globallogic_score::givepointstowin( level.gungamekillscore );
+				maps/mp/_scoreevents::processscoreevent( "kill_gun", self );
+			}
+			self.lastpromotiontime = getTime();
+			return;
+		}
+		i++;
+	}
+}
+
+demoteplayer()
+{
+	self endon( "disconnect" );
+	self notify( "cancel_promotion" );
+	startinggunprogress = self.gunprogress;
+	i = 0;
+	while ( i < level.setbacksperdemotion )
+	{
+		if ( self.gunprogress <= 0 )
+		{
+			break;
+		}
+		else
+		{
+			self maps/mp/gametypes/_globallogic_score::givepointstowin( level.gungamekillscore * -1 );
+			self.gunprogress--;
+
+			i++;
+		}
+	}
+	if ( startinggunprogress != self.gunprogress && isalive( self ) )
+	{
+		self thread givecustomloadout( 0, 1 );
+	}
+	self.pers[ "humiliated" ]++;
+	self.humiliated = self.pers[ "humiliated" ];
+	self thread maps/mp/gametypes/_wager::queuewagerpopup( &"MP_HUMILIATED", 0, &"MP_GUN_PREV_LEVEL", "wm_humiliated" );
+	self playlocalsound( game[ "dialog" ][ "wm_humiliation" ] );
+	self maps/mp/gametypes/_globallogic_audio::leaderdialogonplayer( "wm_humiliated" );
+}
+
+onplayerkilled( einflictor, attacker, idamage, smeansofdeath, sweapon, vdir, shitloc, psoffsettime, deathanimduration )
+{
+	if ( smeansofdeath == "MOD_SUICIDE" || smeansofdeath == "MOD_TRIGGER_HURT" )
+	{
+		self thread demoteplayer();
+		return;
+	}
+	if ( isDefined( attacker ) && isplayer( attacker ) )
+	{
+		if ( attacker == self )
+		{
+			self thread demoteplayer();
+			return;
+		}
+		if ( isDefined( attacker.lastpromotiontime ) && ( attacker.lastpromotiontime + 3000 ) > getTime() )
+		{
+			maps/mp/_scoreevents::processscoreevent( "kill_in_3_seconds_gun", attacker, self, sweapon );
+		}
+		if ( smeansofdeath == "MOD_MELEE" )
+		{
+			if ( maps/mp/gametypes/_globallogic::istopscoringplayer( self ) )
+			{
+				maps/mp/_scoreevents::processscoreevent( "knife_leader_gun", attacker, self, sweapon );
+			}
+			else
+			{
+				maps/mp/_scoreevents::processscoreevent( "humiliation_gun", attacker, self, sweapon );
+			}
+			attacker playlocalsound( game[ "dialog" ][ "wm_humiliation" ] );
+			self thread demoteplayer();
+			return;
+		}
+		else
+		{
+			attacker thread promoteplayer( sweapon );
+		}
+	}
+}
+
+onstartgametype()
+{
+	level.gungamekillscore = maps/mp/gametypes/_rank::getscoreinfovalue( "kill_gun" );
+	registerscorelimit( level.gunprogression.size * level.gungamekillscore, level.gunprogression.size * level.gungamekillscore );
+	setdvar( "scr_xpscale", 0 );
+	setdvar( "ui_weapon_tiers", level.gunprogression.size );
+	makedvarserverinfo( "ui_weapon_tiers", level.gunprogression.size );
+	setclientnamemode( "auto_change" );
+	setobjectivetext( "allies", &"OBJECTIVES_GUN" );
+	setobjectivetext( "axis", &"OBJECTIVES_GUN" );
+	if ( level.splitscreen )
+	{
+		setobjectivescoretext( "allies", &"OBJECTIVES_GUN" );
+		setobjectivescoretext( "axis", &"OBJECTIVES_GUN" );
+	}
+	else
+	{
+		setobjectivescoretext( "allies", &"OBJECTIVES_GUN_SCORE" );
+		setobjectivescoretext( "axis", &"OBJECTIVES_GUN_SCORE" );
+	}
+	setobjectivehinttext( "allies", &"OBJECTIVES_GUN_HINT" );
+	setobjectivehinttext( "axis", &"OBJECTIVES_GUN_HINT" );
+	allowed[ 0 ] = "gun";
+	maps/mp/gametypes/_gameobjects::main( allowed );
+	maps/mp/gametypes/_spawning::create_map_placed_influencers();
+	level.spawnmins = ( 0, 0, 0 );
+	level.spawnmaxs = ( 0, 0, 0 );
+	newspawns = getentarray( "mp_wager_spawn", "classname" );
+	if ( newspawns.size > 0 )
+	{
+		maps/mp/gametypes/_spawnlogic::addspawnpoints( "allies", "mp_wager_spawn" );
+		maps/mp/gametypes/_spawnlogic::addspawnpoints( "axis", "mp_wager_spawn" );
+	}
+	else
+	{
+		maps/mp/gametypes/_spawnlogic::addspawnpoints( "allies", "mp_dm_spawn" );
+		maps/mp/gametypes/_spawnlogic::addspawnpoints( "axis", "mp_dm_spawn" );
+	}
+	maps/mp/gametypes/_spawning::updateallspawnpoints();
+	level.mapcenter = maps/mp/gametypes/_spawnlogic::findboxcenter( level.spawnmins, level.spawnmaxs );
+	setmapcenter( level.mapcenter );
+	spawnpoint = maps/mp/gametypes/_spawnlogic::getrandomintermissionpoint();
+	setdemointermissionpoint( spawnpoint.origin, spawnpoint.angles );
+	level.usestartspawns = 0;
+	level.displayroundendtext = 0;
+	level.quickmessagetoall = 1;
+}
+
+onspawnplayerunified()
+{
+	maps/mp/gametypes/_spawning::onspawnplayer_unified();
+	self thread infiniteammo();
+}
+
+onspawnplayer( predictedspawn )
+{
+	spawnpoints = maps/mp/gametypes/_spawnlogic::getteamspawnpoints( self.pers[ "team" ] );
+	spawnpoint = maps/mp/gametypes/_spawnlogic::getspawnpoint_dm( spawnpoints );
+	if ( predictedspawn )
+	{
+		self predictspawnpoint( spawnpoint.origin, spawnpoint.angles );
+	}
+	else
+	{
+		self spawn( spawnpoint.origin, spawnpoint.angles, "gun" );
+		self thread infiniteammo();
+	}
+}
+
+infiniteammo()
+{
+	self endon( "death" );
+	self endon( "disconnect" );
+	for ( ;; )
+	{
+		wait 0,1;
+		weapon = self getcurrentweapon();
+		self givemaxammo( weapon );
+	}
+}
+
+onwagerawards()
+{
+	stabs = self maps/mp/gametypes/_globallogic_score::getpersstat( "stabs" );
+	if ( !isDefined( stabs ) )
+	{
+		stabs = 0;
+	}
+	self maps/mp/gametypes/_persistence::setafteractionreportstat( "wagerAwards", stabs, 0 );
+	headshots = self maps/mp/gametypes/_globallogic_score::getpersstat( "headshots" );
+	if ( !isDefined( headshots ) )
+	{
+		headshots = 0;
+	}
+	self maps/mp/gametypes/_persistence::setafteractionreportstat( "wagerAwards", headshots, 1 );
+	bestkillstreak = self maps/mp/gametypes/_globallogic_score::getpersstat( "best_kill_streak" );
+	if ( !isDefined( bestkillstreak ) )
+	{
+		bestkillstreak = 0;
+	}
+	self maps/mp/gametypes/_persistence::setafteractionreportstat( "wagerAwards", bestkillstreak, 2 );
+}
+
+onendgame( winningplayer )
+{
+	if ( isDefined( winningplayer ) && isplayer( winningplayer ) )
+	{
+		[[ level._setplayerscore ]]( winningplayer, [[ level._getplayerscore ]]( winningplayer ) + level.gungamekillscore );
+	}
+}

patch_mp/maps/mp/gametypes/oic.gsc

@@ -0,0 +1,361 @@
+#include maps/mp/gametypes/_persistence;
+#include maps/mp/_scoreevents;
+#include maps/mp/gametypes/_globallogic_score;
+#include maps/mp/gametypes/_spawnlogic;
+#include maps/mp/gametypes/_spawning;
+#include maps/mp/gametypes/_wager;
+#include maps/mp/gametypes/_hud_util;
+#include maps/mp/_utility;
+#include common_scripts/utility;
+
+main()
+{
+	maps/mp/gametypes/_globallogic::init();
+	maps/mp/gametypes/_callbacksetup::setupcallbacks();
+	maps/mp/gametypes/_globallogic::setupcallbacks();
+	level.pointsperweaponkill = getgametypesetting( "pointsPerWeaponKill" );
+	level.pointspermeleekill = getgametypesetting( "pointsPerMeleeKill" );
+	level.pointsforsurvivalbonus = getgametypesetting( "pointsForSurvivalBonus" );
+	registertimelimit( 0, 1440 );
+	registerscorelimit( 0, 50000 );
+	registerroundlimit( 0, 10 );
+	registerroundwinlimit( 0, 10 );
+	registernumlives( 1, 100 );
+	level.onstartgametype = ::onstartgametype;
+	level.onspawnplayer = ::onspawnplayer;
+	level.onspawnplayerunified = ::onspawnplayerunified;
+	level.givecustomloadout = ::givecustomloadout;
+	level.onplayerkilled = ::onplayerkilled;
+	level.onplayerdamage = ::onplayerdamage;
+	level.onwagerawards = ::onwagerawards;
+	game[ "dialog" ][ "gametype" ] = "oic_start";
+	game[ "dialog" ][ "wm_2_lives" ] = "oic_2life";
+	game[ "dialog" ][ "wm_final_life" ] = "oic_last";
+	precachestring( &"MPUI_PLAYER_KILLED" );
+	precachestring( &"MP_PLUS_ONE_BULLET" );
+	precachestring( &"MP_OIC_SURVIVOR_BONUS" );
+	precacheitem( "kard_wager_mp" );
+	setscoreboardcolumns( "pointstowin", "kills", "deaths", "stabs", "survived" );
+}
+
+onplayerdamage( einflictor, eattacker, idamage, idflags, smeansofdeath, sweapon, vpoint, vdir, shitloc, psoffsettime )
+{
+	if ( smeansofdeath != "MOD_PISTOL_BULLET" || smeansofdeath == "MOD_RIFLE_BULLET" && smeansofdeath == "MOD_HEAD_SHOT" )
+	{
+		idamage = self.maxhealth + 1;
+	}
+	return idamage;
+}
+
+givecustomloadout()
+{
+	weapon = "kard_wager_mp";
+	self maps/mp/gametypes/_wager::setupblankrandomplayer( 1, 1, weapon );
+	self giveweapon( weapon );
+	self giveweapon( "knife_mp" );
+	self switchtoweapon( weapon );
+	clipammo = 1;
+	if ( isDefined( self.pers[ "clip_ammo" ] ) )
+	{
+		clipammo = self.pers[ "clip_ammo" ];
+	}
+	self setweaponammoclip( weapon, clipammo );
+	stockammo = 0;
+	if ( isDefined( self.pers[ "stock_ammo" ] ) )
+	{
+		stockammo = self.pers[ "stock_ammo" ];
+	}
+	self setweaponammostock( weapon, stockammo );
+	self setspawnweapon( weapon );
+	self setperk( "specialty_unlimitedsprint" );
+	self setperk( "specialty_movefaster" );
+	return weapon;
+}
+
+onstartgametype()
+{
+	setclientnamemode( "auto_change" );
+	setobjectivetext( "allies", &"OBJECTIVES_DM" );
+	setobjectivetext( "axis", &"OBJECTIVES_DM" );
+	if ( level.splitscreen )
+	{
+		setobjectivescoretext( "allies", &"OBJECTIVES_DM" );
+		setobjectivescoretext( "axis", &"OBJECTIVES_DM" );
+	}
+	else
+	{
+		setobjectivescoretext( "allies", &"OBJECTIVES_DM_SCORE" );
+		setobjectivescoretext( "axis", &"OBJECTIVES_DM_SCORE" );
+	}
+	allowed[ 0 ] = "oic";
+	maps/mp/gametypes/_gameobjects::main( allowed );
+	maps/mp/gametypes/_spawning::create_map_placed_influencers();
+	level.spawnmins = ( 0, 0, 0 );
+	level.spawnmaxs = ( 0, 0, 0 );
+	newspawns = getentarray( "mp_wager_spawn", "classname" );
+	if ( newspawns.size > 0 )
+	{
+		maps/mp/gametypes/_spawnlogic::addspawnpoints( "allies", "mp_wager_spawn" );
+		maps/mp/gametypes/_spawnlogic::addspawnpoints( "axis", "mp_wager_spawn" );
+	}
+	else
+	{
+		maps/mp/gametypes/_spawnlogic::addspawnpoints( "allies", "mp_dm_spawn" );
+		maps/mp/gametypes/_spawnlogic::addspawnpoints( "axis", "mp_dm_spawn" );
+	}
+	maps/mp/gametypes/_spawning::updateallspawnpoints();
+	level.mapcenter = maps/mp/gametypes/_spawnlogic::findboxcenter( level.spawnmins, level.spawnmaxs );
+	setmapcenter( level.mapcenter );
+	spawnpoint = maps/mp/gametypes/_spawnlogic::getrandomintermissionpoint();
+	setdemointermissionpoint( spawnpoint.origin, spawnpoint.angles );
+	level.usestartspawns = 0;
+	level.displayroundendtext = 0;
+	if ( level.roundlimit != 1 && level.numlives )
+	{
+		level.overrideplayerscore = 1;
+		level.displayroundendtext = 1;
+		level.onendgame = ::onendgame;
+	}
+	level thread watchelimination();
+	setobjectivehinttext( "allies", &"OBJECTIVES_OIC_HINT" );
+	setobjectivehinttext( "axis", &"OBJECTIVES_OIC_HINT" );
+}
+
+onspawnplayerunified()
+{
+	maps/mp/gametypes/_spawning::onspawnplayer_unified();
+	livesleft = self.pers[ "lives" ];
+	if ( livesleft == 2 )
+	{
+		self maps/mp/gametypes/_wager::wagerannouncer( "wm_2_lives" );
+	}
+	else
+	{
+		if ( livesleft == 1 )
+		{
+			self maps/mp/gametypes/_wager::wagerannouncer( "wm_final_life" );
+		}
+	}
+}
+
+onspawnplayer( predictedspawn )
+{
+	spawnpoints = maps/mp/gametypes/_spawnlogic::getteamspawnpoints( self.pers[ "team" ] );
+	spawnpoint = maps/mp/gametypes/_spawnlogic::getspawnpoint_dm( spawnpoints );
+	if ( predictedspawn )
+	{
+		self predictspawnpoint( spawnpoint.origin, spawnpoint.angles );
+	}
+	else
+	{
+		self spawn( spawnpoint.origin, spawnpoint.angles, "oic" );
+	}
+}
+
+onendgame( winningplayer )
+{
+	if ( isDefined( winningplayer ) && isplayer( winningplayer ) )
+	{
+		[[ level._setplayerscore ]]( winningplayer, [[ level._getplayerscore ]]( winningplayer ) + 1 );
+	}
+}
+
+onstartwagersidebets()
+{
+	thread saveoffallplayersammo();
+}
+
+saveoffallplayersammo()
+{
+	wait 1;
+	playerindex = 0;
+	while ( playerindex < level.players.size )
+	{
+		player = level.players[ playerindex ];
+		if ( !isDefined( player ) )
+		{
+			playerindex++;
+			continue;
+		}
+		else if ( player.pers[ "lives" ] == 0 )
+		{
+			playerindex++;
+			continue;
+		}
+		else
+		{
+			currentweapon = player getcurrentweapon();
+			player.pers[ "clip_ammo" ] = player getweaponammoclip( currentweapon );
+			player.pers[ "stock_ammo" ] = player getweaponammostock( currentweapon );
+		}
+		playerindex++;
+	}
+}
+
+isplayereliminated( player )
+{
+	if ( isDefined( player.pers[ "eliminated" ] ) )
+	{
+		return player.pers[ "eliminated" ];
+	}
+}
+
+getplayersleft()
+{
+	playersremaining = [];
+	playerindex = 0;
+	while ( playerindex < level.players.size )
+	{
+		player = level.players[ playerindex ];
+		if ( !isDefined( player ) )
+		{
+			playerindex++;
+			continue;
+		}
+		else
+		{
+			if ( !isplayereliminated( player ) )
+			{
+				playersremaining[ playersremaining.size ] = player;
+			}
+		}
+		playerindex++;
+	}
+	return playersremaining;
+}
+
+onwagerfinalizeround()
+{
+	playersleft = getplayersleft();
+	lastmanstanding = playersleft[ 0 ];
+	sidebetpool = 0;
+	sidebetwinners = [];
+	players = level.players;
+	playerindex = 0;
+	while ( playerindex < players.size )
+	{
+		if ( isDefined( players[ playerindex ].pers[ "sideBetMade" ] ) )
+		{
+			sidebetpool += getDvarInt( "scr_wagerSideBet" );
+			if ( players[ playerindex ].pers[ "sideBetMade" ] == lastmanstanding.name )
+			{
+				sidebetwinners[ sidebetwinners.size ] = players[ playerindex ];
+			}
+		}
+		playerindex++;
+	}
+	if ( sidebetwinners.size == 0 )
+	{
+		return;
+	}
+	sidebetpayout = int( sidebetpool / sidebetwinners.size );
+	index = 0;
+	while ( index < sidebetwinners.size )
+	{
+		player = sidebetwinners[ index ];
+		player.pers[ "wager_sideBetWinnings" ] += sidebetpayout;
+		index++;
+	}
+}
+
+onplayerkilled( einflictor, attacker, idamage, smeansofdeath, sweapon, vdir, shitloc, psoffsettime, deathanimduration )
+{
+	if ( isDefined( attacker ) && isplayer( attacker ) && self != attacker )
+	{
+		attackerammo = attacker getammocount( "kard_wager_mp" );
+		victimammo = self getammocount( "kard_wager_mp" );
+		attacker giveammo( 1 );
+		attacker thread maps/mp/gametypes/_wager::queuewagerpopup( &"MPUI_PLAYER_KILLED", 0, &"MP_PLUS_ONE_BULLET" );
+		attacker playlocalsound( "mpl_oic_bullet_pickup" );
+		if ( smeansofdeath == "MOD_MELEE" )
+		{
+			attacker maps/mp/gametypes/_globallogic_score::givepointstowin( level.pointspermeleekill );
+			if ( attackerammo > 0 )
+			{
+				maps/mp/_scoreevents::processscoreevent( "knife_with_ammo_oic", attacker, self, sweapon );
+			}
+			if ( victimammo > attackerammo )
+			{
+				maps/mp/_scoreevents::processscoreevent( "kill_enemy_with_more_ammo_oic", attacker, self, sweapon );
+			}
+		}
+		else
+		{
+			attacker maps/mp/gametypes/_globallogic_score::givepointstowin( level.pointsperweaponkill );
+			if ( victimammo > ( attackerammo + 1 ) )
+			{
+				maps/mp/_scoreevents::processscoreevent( "kill_enemy_with_more_ammo_oic", attacker, self, sweapon );
+			}
+		}
+		if ( self.pers[ "lives" ] == 0 )
+		{
+			maps/mp/_scoreevents::processscoreevent( "eliminate_oic", attacker, self, sweapon );
+		}
+	}
+}
+
+giveammo( amount )
+{
+	currentweapon = self getcurrentweapon();
+	clipammo = self getweaponammoclip( currentweapon );
+	self setweaponammoclip( currentweapon, clipammo + amount );
+}
+
+shouldreceivesurvivorbonus()
+{
+	if ( isalive( self ) )
+	{
+		return 1;
+	}
+	if ( self.hasspawned && self.pers[ "lives" ] > 0 )
+	{
+		return 1;
+	}
+	return 0;
+}
+
+watchelimination()
+{
+	level endon( "game_ended" );
+	for ( ;; )
+	{
+		level waittill( "player_eliminated" );
+		players = level.players;
+		i = 0;
+		while ( i < players.size )
+		{
+			if ( isDefined( players[ i ] ) && players[ i ] shouldreceivesurvivorbonus() )
+			{
+				players[ i ].pers[ "survived" ]++;
+				players[ i ].survived = players[ i ].pers[ "survived" ];
+				players[ i ] thread maps/mp/gametypes/_wager::queuewagerpopup( &"MP_OIC_SURVIVOR_BONUS", 10 );
+				score = maps/mp/gametypes/_globallogic_score::_getplayerscore( players[ i ] );
+				maps/mp/_scoreevents::processscoreevent( "survivor", players[ i ] );
+				players[ i ] maps/mp/gametypes/_globallogic_score::givepointstowin( level.pointsforsurvivalbonus );
+			}
+			i++;
+		}
+	}
+}
+
+onwagerawards()
+{
+	stabs = self maps/mp/gametypes/_globallogic_score::getpersstat( "stabs" );
+	if ( !isDefined( stabs ) )
+	{
+		stabs = 0;
+	}
+	self maps/mp/gametypes/_persistence::setafteractionreportstat( "wagerAwards", stabs, 0 );
+	longshots = self maps/mp/gametypes/_globallogic_score::getpersstat( "longshots" );
+	if ( !isDefined( longshots ) )
+	{
+		longshots = 0;
+	}
+	self maps/mp/gametypes/_persistence::setafteractionreportstat( "wagerAwards", longshots, 1 );
+	bestkillstreak = self maps/mp/gametypes/_globallogic_score::getpersstat( "best_kill_streak" );
+	if ( !isDefined( bestkillstreak ) )
+	{
+		bestkillstreak = 0;
+	}
+	self maps/mp/gametypes/_persistence::setafteractionreportstat( "wagerAwards", bestkillstreak, 2 );
+}

patch_mp/maps/mp/gametypes/sas.gsc

@@ -0,0 +1,273 @@
+#include maps/mp/gametypes/_persistence;
+#include maps/mp/gametypes/_spawnlogic;
+#include maps/mp/gametypes/_spawning;
+#include maps/mp/gametypes/_globallogic_audio;
+#include maps/mp/_scoreevents;
+#include maps/mp/gametypes/_globallogic_score;
+#include maps/mp/gametypes/_wager;
+#include maps/mp/gametypes/_hud_util;
+#include maps/mp/_utility;
+
+main()
+{
+	maps/mp/gametypes/_globallogic::init();
+	maps/mp/gametypes/_callbacksetup::setupcallbacks();
+	maps/mp/gametypes/_globallogic::setupcallbacks();
+	registertimelimit( 0, 1440 );
+	registerscorelimit( 0, 5000 );
+	registerroundlimit( 0, 10 );
+	registerroundwinlimit( 0, 10 );
+	registernumlives( 0, 100 );
+	level.onstartgametype = ::onstartgametype;
+	level.onspawnplayer = ::onspawnplayer;
+	level.onspawnplayerunified = ::onspawnplayerunified;
+	level.onplayerdamage = ::onplayerdamage;
+	level.onplayerkilled = ::onplayerkilled;
+	level.onwagerawards = ::onwagerawards;
+	level.pointsperprimarykill = getgametypesetting( "pointsPerPrimaryKill" );
+	level.pointspersecondarykill = getgametypesetting( "pointsPerSecondaryKill" );
+	level.pointsperprimarygrenadekill = getgametypesetting( "pointsPerPrimaryGrenadeKill" );
+	level.pointspermeleekill = getgametypesetting( "pointsPerMeleeKill" );
+	level.setbacks = getgametypesetting( "setbacks" );
+	switch( getgametypesetting( "gunSelection" ) )
+	{
+		case 0:
+			level.setbackweapon = undefined;
+			break;
+		case 1:
+			level.setbackweapon = getreffromitemindex( getbaseweaponitemindex( "hatchet_mp" ) ) + "_mp";
+			break;
+		case 2:
+			level.setbackweapon = getreffromitemindex( getbaseweaponitemindex( "crossbow_mp" ) ) + "_mp";
+			break;
+		case 3:
+			level.setbackweapon = getreffromitemindex( getbaseweaponitemindex( "knife_ballistic_mp" ) ) + "_mp";
+			break;
+		default:
+/#
+			assert( 1, "Invalid setting for gunSelection" );
+#/
+			break;
+	}
+	game[ "dialog" ][ "gametype" ] = "sns_start";
+	game[ "dialog" ][ "wm_humiliation" ] = "mpl_wager_bankrupt";
+	game[ "dialog" ][ "wm_humiliated" ] = "sns_hum";
+	level.givecustomloadout = ::givecustomloadout;
+	precachestring( &"MP_HUMILIATION" );
+	precachestring( &"MP_HUMILIATED" );
+	precachestring( &"MP_BANKRUPTED" );
+	precachestring( &"MP_BANKRUPTED_OTHER" );
+	precacheshader( "hud_acoustic_sensor" );
+	precacheshader( "hud_us_stungrenade" );
+	setscoreboardcolumns( "pointstowin", "kills", "deaths", "tomahawks", "humiliated" );
+}
+
+givecustomloadout()
+{
+	self notify( "sas_spectator_hud" );
+	defaultweapon = "crossbow_mp";
+	self maps/mp/gametypes/_wager::setupblankrandomplayer( 1, 1, defaultweapon );
+	self giveweapon( defaultweapon );
+	self setweaponammoclip( defaultweapon, 3 );
+	self setweaponammostock( defaultweapon, 3 );
+	secondaryweapon = "knife_ballistic_mp";
+	self giveweapon( secondaryweapon );
+	self setweaponammostock( secondaryweapon, 2 );
+	offhandprimary = "hatchet_mp";
+	self setoffhandprimaryclass( offhandprimary );
+	self giveweapon( offhandprimary );
+	self setweaponammoclip( offhandprimary, 1 );
+	self setweaponammostock( offhandprimary, 1 );
+	self giveweapon( "knife_mp" );
+	self switchtoweapon( defaultweapon );
+	self setspawnweapon( defaultweapon );
+	self.killswithsecondary = 0;
+	self.killswithprimary = 0;
+	self.killswithbothawarded = 0;
+	return defaultweapon;
+}
+
+onplayerdamage( einflictor, eattacker, idamage, idflags, smeansofdeath, sweapon, vpoint, vdir, shitloc, psoffsettime )
+{
+	if ( sweapon == "crossbow_mp" && smeansofdeath == "MOD_IMPACT" )
+	{
+		if ( isDefined( eattacker ) && isplayer( eattacker ) )
+		{
+			if ( !isDefined( eattacker.pers[ "sticks" ] ) )
+			{
+				eattacker.pers[ "sticks" ] = 1;
+			}
+			else
+			{
+				eattacker.pers[ "sticks" ]++;
+			}
+			eattacker.sticks = eattacker.pers[ "sticks" ];
+		}
+	}
+	return idamage;
+}
+
+onplayerkilled( einflictor, attacker, idamage, smeansofdeath, sweapon, vdir, shitloc, psoffsettime, deathanimduration )
+{
+	if ( isDefined( attacker ) && isplayer( attacker ) && attacker != self )
+	{
+		baseweaponname = getreffromitemindex( getbaseweaponitemindex( sweapon ) ) + "_mp";
+		if ( smeansofdeath == "MOD_MELEE" )
+		{
+			attacker maps/mp/gametypes/_globallogic_score::givepointstowin( level.pointspermeleekill );
+		}
+		else if ( baseweaponname == "crossbow_mp" )
+		{
+			attacker.killswithprimary++;
+			if ( attacker.killswithbothawarded == 0 && attacker.killswithsecondary > 0 )
+			{
+				attacker.killswithbothawarded = 1;
+				maps/mp/_scoreevents::processscoreevent( "kill_with_crossbow_and_ballistic_sas", attacker, self, sweapon );
+			}
+			attacker maps/mp/gametypes/_globallogic_score::givepointstowin( level.pointsperprimarykill );
+		}
+		else if ( baseweaponname == "hatchet_mp" )
+		{
+			if ( maps/mp/gametypes/_globallogic::istopscoringplayer( self ) )
+			{
+				maps/mp/_scoreevents::processscoreevent( "kill_leader_with_axe_sas", attacker, self, sweapon );
+			}
+			else
+			{
+				maps/mp/_scoreevents::processscoreevent( "kill_with_axe_sas", attacker, self, sweapon );
+			}
+			attacker maps/mp/gametypes/_globallogic_score::givepointstowin( level.pointsperprimarygrenadekill );
+		}
+		else
+		{
+			if ( baseweaponname == "knife_ballistic_mp" )
+			{
+				attacker.killswithsecondary++;
+				if ( attacker.killswithbothawarded == 0 && attacker.killswithprimary > 0 )
+				{
+					attacker.killswithbothawarded = 1;
+					maps/mp/_scoreevents::processscoreevent( "kill_with_crossbow_and_ballistic_sas", attacker, self, sweapon );
+				}
+			}
+			attacker maps/mp/gametypes/_globallogic_score::givepointstowin( level.pointspersecondarykill );
+		}
+		if ( isDefined( level.setbackweapon ) && baseweaponname == level.setbackweapon )
+		{
+			self.pers[ "humiliated" ]++;
+			self.humiliated = self.pers[ "humiliated" ];
+			if ( level.setbacks == 0 )
+			{
+				self maps/mp/gametypes/_globallogic_score::setpointstowin( 0 );
+			}
+			else
+			{
+				self maps/mp/gametypes/_globallogic_score::givepointstowin( level.setbacks * -1 );
+			}
+			attacker playlocalsound( game[ "dialog" ][ "wm_humiliation" ] );
+			self playlocalsound( game[ "dialog" ][ "wm_humiliation" ] );
+			self maps/mp/gametypes/_globallogic_audio::leaderdialogonplayer( "wm_humiliated" );
+		}
+	}
+	else
+	{
+		self.pers[ "humiliated" ]++;
+		self.humiliated = self.pers[ "humiliated" ];
+		if ( level.setbacks == 0 )
+		{
+			self maps/mp/gametypes/_globallogic_score::setpointstowin( 0 );
+		}
+		else
+		{
+			self maps/mp/gametypes/_globallogic_score::givepointstowin( level.setbacks * -1 );
+		}
+		self thread maps/mp/gametypes/_wager::queuewagerpopup( &"MP_HUMILIATED", 0, &"MP_BANKRUPTED", "wm_humiliated" );
+		self playlocalsound( game[ "dialog" ][ "wm_humiliated" ] );
+	}
+}
+
+onstartgametype()
+{
+	setdvar( "scr_xpscale", 0 );
+	setclientnamemode( "auto_change" );
+	setobjectivetext( "allies", &"OBJECTIVES_SAS" );
+	setobjectivetext( "axis", &"OBJECTIVES_SAS" );
+	if ( level.splitscreen )
+	{
+		setobjectivescoretext( "allies", &"OBJECTIVES_SAS" );
+		setobjectivescoretext( "axis", &"OBJECTIVES_SAS" );
+	}
+	else
+	{
+		setobjectivescoretext( "allies", &"OBJECTIVES_SAS_SCORE" );
+		setobjectivescoretext( "axis", &"OBJECTIVES_SAS_SCORE" );
+	}
+	setobjectivehinttext( "allies", &"OBJECTIVES_SAS_HINT" );
+	setobjectivehinttext( "axis", &"OBJECTIVES_SAS_HINT" );
+	allowed[ 0 ] = "sas";
+	maps/mp/gametypes/_gameobjects::main( allowed );
+	maps/mp/gametypes/_spawning::create_map_placed_influencers();
+	level.spawnmins = ( 0, 0, 0 );
+	level.spawnmaxs = ( 0, 0, 0 );
+	newspawns = getentarray( "mp_wager_spawn", "classname" );
+	if ( newspawns.size > 0 )
+	{
+		maps/mp/gametypes/_spawnlogic::addspawnpoints( "allies", "mp_wager_spawn" );
+		maps/mp/gametypes/_spawnlogic::addspawnpoints( "axis", "mp_wager_spawn" );
+	}
+	else
+	{
+		maps/mp/gametypes/_spawnlogic::addspawnpoints( "allies", "mp_dm_spawn" );
+		maps/mp/gametypes/_spawnlogic::addspawnpoints( "axis", "mp_dm_spawn" );
+	}
+	maps/mp/gametypes/_spawning::updateallspawnpoints();
+	level.mapcenter = maps/mp/gametypes/_spawnlogic::findboxcenter( level.spawnmins, level.spawnmaxs );
+	setmapcenter( level.mapcenter );
+	spawnpoint = maps/mp/gametypes/_spawnlogic::getrandomintermissionpoint();
+	setdemointermissionpoint( spawnpoint.origin, spawnpoint.angles );
+	level.usestartspawns = 0;
+	level.displayroundendtext = 0;
+	if ( isDefined( game[ "roundsplayed" ] ) && game[ "roundsplayed" ] > 0 )
+	{
+	}
+}
+
+onspawnplayerunified()
+{
+	maps/mp/gametypes/_spawning::onspawnplayer_unified();
+}
+
+onspawnplayer( predictedspawn )
+{
+	spawnpoints = maps/mp/gametypes/_spawnlogic::getteamspawnpoints( self.pers[ "team" ] );
+	spawnpoint = maps/mp/gametypes/_spawnlogic::getspawnpoint_dm( spawnpoints );
+	if ( predictedspawn )
+	{
+		self predictspawnpoint( spawnpoint.origin, spawnpoint.angles );
+	}
+	else
+	{
+		self spawn( spawnpoint.origin, spawnpoint.angles, "sas" );
+	}
+}
+
+onwagerawards()
+{
+	tomahawks = self maps/mp/gametypes/_globallogic_score::getpersstat( "tomahawks" );
+	if ( !isDefined( tomahawks ) )
+	{
+		tomahawks = 0;
+	}
+	self maps/mp/gametypes/_persistence::setafteractionreportstat( "wagerAwards", tomahawks, 0 );
+	sticks = self maps/mp/gametypes/_globallogic_score::getpersstat( "sticks" );
+	if ( !isDefined( sticks ) )
+	{
+		sticks = 0;
+	}
+	self maps/mp/gametypes/_persistence::setafteractionreportstat( "wagerAwards", sticks, 1 );
+	bestkillstreak = self maps/mp/gametypes/_globallogic_score::getpersstat( "best_kill_streak" );
+	if ( !isDefined( bestkillstreak ) )
+	{
+		bestkillstreak = 0;
+	}
+	self maps/mp/gametypes/_persistence::setafteractionreportstat( "wagerAwards", bestkillstreak, 2 );
+}

patch_mp/maps/mp/gametypes/sd.gsc

@@ -0,0 +1,997 @@
+#include maps/mp/gametypes/_hostmigration;
+#include maps/mp/gametypes/_globallogic_utils;
+#include maps/mp/_demo;
+#include maps/mp/_popups;
+#include maps/mp/gametypes/_battlechatter_mp;
+#include maps/mp/gametypes/_globallogic_audio;
+#include maps/mp/gametypes/_globallogic_score;
+#include maps/mp/gametypes/_spectating;
+#include maps/mp/_medals;
+#include maps/mp/_scoreevents;
+#include maps/mp/gametypes/_spawnlogic;
+#include maps/mp/gametypes/_spawning;
+#include maps/mp/gametypes/_rank;
+#include maps/mp/gametypes/_globallogic_defaults;
+#include maps/mp/gametypes/_hud_util;
+#include common_scripts/utility;
+
+main()
+{
+	if ( getDvar( "mapname" ) == "mp_background" )
+	{
+		return;
+	}
+	maps/mp/gametypes/_globallogic::init();
+	maps/mp/gametypes/_callbacksetup::setupcallbacks();
+	maps/mp/gametypes/_globallogic::setupcallbacks();
+	registerroundswitch( 0, 9 );
+	registertimelimit( 0, 1440 );
+	registerscorelimit( 0, 500 );
+	registerroundlimit( 0, 12 );
+	registerroundwinlimit( 0, 10 );
+	registernumlives( 0, 100 );
+	maps/mp/gametypes/_globallogic::registerfriendlyfiredelay( level.gametype, 15, 0, 1440 );
+	level.teambased = 1;
+	level.overrideteamscore = 1;
+	level.onprecachegametype = ::onprecachegametype;
+	level.onstartgametype = ::onstartgametype;
+	level.onspawnplayer = ::onspawnplayer;
+	level.onspawnplayerunified = ::onspawnplayerunified;
+	level.playerspawnedcb = ::sd_playerspawnedcb;
+	level.onplayerkilled = ::onplayerkilled;
+	level.ondeadevent = ::ondeadevent;
+	level.ononeleftevent = ::ononeleftevent;
+	level.ontimelimit = ::ontimelimit;
+	level.onroundswitch = ::onroundswitch;
+	level.getteamkillpenalty = ::sd_getteamkillpenalty;
+	level.getteamkillscore = ::sd_getteamkillscore;
+	level.iskillboosting = ::sd_iskillboosting;
+	level.endgameonscorelimit = 0;
+	game[ "dialog" ][ "gametype" ] = "sd_start";
+	game[ "dialog" ][ "gametype_hardcore" ] = "hcsd_start";
+	game[ "dialog" ][ "offense_obj" ] = "destroy_start";
+	game[ "dialog" ][ "defense_obj" ] = "defend_start";
+	game[ "dialog" ][ "sudden_death" ] = "generic_boost";
+	game[ "dialog" ][ "last_one" ] = "encourage_last";
+	game[ "dialog" ][ "halftime" ] = "sd_halftime";
+	if ( !sessionmodeissystemlink() && !sessionmodeisonlinegame() && issplitscreen() )
+	{
+		setscoreboardcolumns( "score", "kills", "plants", "defuses", "deaths" );
+	}
+	else
+	{
+		setscoreboardcolumns( "score", "kills", "deaths", "plants", "defuses" );
+	}
+}
+
+onprecachegametype()
+{
+	game[ "bomb_dropped_sound" ] = "mpl_flag_drop_plr";
+	game[ "bomb_recovered_sound" ] = "mpl_flag_pickup_plr";
+	precacheshader( "waypoint_bomb" );
+	precacheshader( "hud_suitcase_bomb" );
+	precacheshader( "waypoint_target" );
+	precacheshader( "waypoint_target_a" );
+	precacheshader( "waypoint_target_b" );
+	precacheshader( "waypoint_defend" );
+	precacheshader( "waypoint_defend_a" );
+	precacheshader( "waypoint_defend_b" );
+	precacheshader( "waypoint_defuse" );
+	precacheshader( "waypoint_defuse_a" );
+	precacheshader( "waypoint_defuse_b" );
+	precacheshader( "compass_waypoint_target" );
+	precacheshader( "compass_waypoint_target_a" );
+	precacheshader( "compass_waypoint_target_b" );
+	precacheshader( "compass_waypoint_defend" );
+	precacheshader( "compass_waypoint_defend_a" );
+	precacheshader( "compass_waypoint_defend_b" );
+	precacheshader( "compass_waypoint_defuse" );
+	precacheshader( "compass_waypoint_defuse_a" );
+	precacheshader( "compass_waypoint_defuse_b" );
+	precachestring( &"MP_EXPLOSIVES_BLOWUP_BY" );
+	precachestring( &"MP_EXPLOSIVES_RECOVERED_BY" );
+	precachestring( &"MP_EXPLOSIVES_DROPPED_BY" );
+	precachestring( &"MP_EXPLOSIVES_PLANTED_BY" );
+	precachestring( &"MP_EXPLOSIVES_DEFUSED_BY" );
+	precachestring( &"PLATFORM_HOLD_TO_PLANT_EXPLOSIVES" );
+	precachestring( &"PLATFORM_HOLD_TO_DEFUSE_EXPLOSIVES" );
+	precachestring( &"MP_CANT_PLANT_WITHOUT_BOMB" );
+	precachestring( &"MP_PLANTING_EXPLOSIVE" );
+	precachestring( &"MP_DEFUSING_EXPLOSIVE" );
+}
+
+sd_getteamkillpenalty( einflictor, attacker, smeansofdeath, sweapon )
+{
+	teamkill_penalty = maps/mp/gametypes/_globallogic_defaults::default_getteamkillpenalty( einflictor, attacker, smeansofdeath, sweapon );
+	if ( isDefined( self.isdefusing ) || self.isdefusing && isDefined( self.isplanting ) && self.isplanting )
+	{
+		teamkill_penalty *= level.teamkillpenaltymultiplier;
+	}
+	return teamkill_penalty;
+}
+
+sd_getteamkillscore( einflictor, attacker, smeansofdeath, sweapon )
+{
+	teamkill_score = maps/mp/gametypes/_rank::getscoreinfovalue( "team_kill" );
+	if ( isDefined( self.isdefusing ) || self.isdefusing && isDefined( self.isplanting ) && self.isplanting )
+	{
+		teamkill_score *= level.teamkillscoremultiplier;
+	}
+	return int( teamkill_score );
+}
+
+onroundswitch()
+{
+	if ( !isDefined( game[ "switchedsides" ] ) )
+	{
+		game[ "switchedsides" ] = 0;
+	}
+	if ( game[ "teamScores" ][ "allies" ] == ( level.scorelimit - 1 ) && game[ "teamScores" ][ "axis" ] == ( level.scorelimit - 1 ) )
+	{
+		aheadteam = getbetterteam();
+		if ( aheadteam != game[ "defenders" ] )
+		{
+			game[ "switchedsides" ] = !game[ "switchedsides" ];
+		}
+		level.halftimetype = "overtime";
+	}
+	else
+	{
+		level.halftimetype = "halftime";
+		game[ "switchedsides" ] = !game[ "switchedsides" ];
+	}
+}
+
+getbetterteam()
+{
+	kills[ "allies" ] = 0;
+	kills[ "axis" ] = 0;
+	deaths[ "allies" ] = 0;
+	deaths[ "axis" ] = 0;
+	i = 0;
+	while ( i < level.players.size )
+	{
+		player = level.players[ i ];
+		team = player.pers[ "team" ];
+		if ( isDefined( team ) || team == "allies" && team == "axis" )
+		{
+			kills[ team ] += player.kills;
+			deaths[ team ] += player.deaths;
+		}
+		i++;
+	}
+	if ( kills[ "allies" ] > kills[ "axis" ] )
+	{
+		return "allies";
+	}
+	else
+	{
+		if ( kills[ "axis" ] > kills[ "allies" ] )
+		{
+			return "axis";
+		}
+	}
+	if ( deaths[ "allies" ] < deaths[ "axis" ] )
+	{
+		return "allies";
+	}
+	else
+	{
+		if ( deaths[ "axis" ] < deaths[ "allies" ] )
+		{
+			return "axis";
+		}
+	}
+	if ( randomint( 2 ) == 0 )
+	{
+		return "allies";
+	}
+	return "axis";
+}
+
+onstartgametype()
+{
+	setbombtimer( "A", 0 );
+	setmatchflag( "bomb_timer_a", 0 );
+	setbombtimer( "B", 0 );
+	setmatchflag( "bomb_timer_b", 0 );
+	if ( !isDefined( game[ "switchedsides" ] ) )
+	{
+		game[ "switchedsides" ] = 0;
+	}
+	if ( game[ "switchedsides" ] )
+	{
+		oldattackers = game[ "attackers" ];
+		olddefenders = game[ "defenders" ];
+		game[ "attackers" ] = olddefenders;
+		game[ "defenders" ] = oldattackers;
+	}
+	setclientnamemode( "manual_change" );
+	game[ "strings" ][ "target_destroyed" ] = &"MP_TARGET_DESTROYED";
+	game[ "strings" ][ "bomb_defused" ] = &"MP_BOMB_DEFUSED";
+	precachestring( game[ "strings" ][ "target_destroyed" ] );
+	precachestring( game[ "strings" ][ "bomb_defused" ] );
+	level._effect[ "bombexplosion" ] = loadfx( "maps/mp_maps/fx_mp_exp_bomb" );
+	setobjectivetext( game[ "attackers" ], &"OBJECTIVES_SD_ATTACKER" );
+	setobjectivetext( game[ "defenders" ], &"OBJECTIVES_SD_DEFENDER" );
+	if ( level.splitscreen )
+	{
+		setobjectivescoretext( game[ "attackers" ], &"OBJECTIVES_SD_ATTACKER" );
+		setobjectivescoretext( game[ "defenders" ], &"OBJECTIVES_SD_DEFENDER" );
+	}
+	else
+	{
+		setobjectivescoretext( game[ "attackers" ], &"OBJECTIVES_SD_ATTACKER_SCORE" );
+		setobjectivescoretext( game[ "defenders" ], &"OBJECTIVES_SD_DEFENDER_SCORE" );
+	}
+	setobjectivehinttext( game[ "attackers" ], &"OBJECTIVES_SD_ATTACKER_HINT" );
+	setobjectivehinttext( game[ "defenders" ], &"OBJECTIVES_SD_DEFENDER_HINT" );
+	allowed[ 0 ] = "sd";
+	allowed[ 1 ] = "bombzone";
+	allowed[ 2 ] = "blocker";
+	maps/mp/gametypes/_gameobjects::main( allowed );
+	maps/mp/gametypes/_spawning::create_map_placed_influencers();
+	level.spawnmins = ( 0, 0, 1 );
+	level.spawnmaxs = ( 0, 0, 1 );
+	maps/mp/gametypes/_spawnlogic::placespawnpoints( "mp_sd_spawn_attacker" );
+	maps/mp/gametypes/_spawnlogic::placespawnpoints( "mp_sd_spawn_defender" );
+	level.mapcenter = maps/mp/gametypes/_spawnlogic::findboxcenter( level.spawnmins, level.spawnmaxs );
+	setmapcenter( level.mapcenter );
+	spawnpoint = maps/mp/gametypes/_spawnlogic::getrandomintermissionpoint();
+	setdemointermissionpoint( spawnpoint.origin, spawnpoint.angles );
+	level.spawn_start = [];
+	level.spawn_start[ "axis" ] = maps/mp/gametypes/_spawnlogic::getspawnpointarray( "mp_sd_spawn_defender" );
+	level.spawn_start[ "allies" ] = maps/mp/gametypes/_spawnlogic::getspawnpointarray( "mp_sd_spawn_attacker" );
+	thread updategametypedvars();
+	thread bombs();
+}
+
+onspawnplayerunified()
+{
+	self.isplanting = 0;
+	self.isdefusing = 0;
+	self.isbombcarrier = 0;
+	maps/mp/gametypes/_spawning::onspawnplayer_unified();
+}
+
+onspawnplayer( predictedspawn )
+{
+	if ( !predictedspawn )
+	{
+		self.isplanting = 0;
+		self.isdefusing = 0;
+		self.isbombcarrier = 0;
+	}
+	if ( self.pers[ "team" ] == game[ "attackers" ] )
+	{
+		spawnpointname = "mp_sd_spawn_attacker";
+	}
+	else
+	{
+		spawnpointname = "mp_sd_spawn_defender";
+	}
+	spawnpoints = maps/mp/gametypes/_spawnlogic::getspawnpointarray( spawnpointname );
+/#
+	assert( spawnpoints.size );
+#/
+	spawnpoint = maps/mp/gametypes/_spawnlogic::getspawnpoint_random( spawnpoints );
+	if ( predictedspawn )
+	{
+		self predictspawnpoint( spawnpoint.origin, spawnpoint.angles );
+	}
+	else
+	{
+		self spawn( spawnpoint.origin, spawnpoint.angles, "sd" );
+	}
+}
+
+sd_playerspawnedcb()
+{
+	level notify( "spawned_player" );
+}
+
+onplayerkilled( einflictor, attacker, idamage, smeansofdeath, sweapon, vdir, shitloc, psoffsettime, deathanimduration )
+{
+	thread checkallowspectating();
+	if ( isplayer( attacker ) && attacker.pers[ "team" ] != self.pers[ "team" ] )
+	{
+		maps/mp/_scoreevents::processscoreevent( "kill_sd", attacker, self, sweapon );
+	}
+	inbombzone = 0;
+	index = 0;
+	while ( index < level.bombzones.size )
+	{
+		dist = distance2d( self.origin, level.bombzones[ index ].curorigin );
+		if ( dist < level.defaultoffenseradius )
+		{
+			inbombzone = 1;
+		}
+		index++;
+	}
+	if ( inbombzone && isplayer( attacker ) && attacker.pers[ "team" ] != self.pers[ "team" ] )
+	{
+		if ( game[ "defenders" ] == self.pers[ "team" ] )
+		{
+			attacker maps/mp/_medals::offenseglobalcount();
+			attacker addplayerstatwithgametype( "OFFENDS", 1 );
+			self recordkillmodifier( "defending" );
+			maps/mp/_scoreevents::processscoreevent( "killed_defender", attacker, self, sweapon );
+		}
+		else
+		{
+			if ( isDefined( attacker.pers[ "defends" ] ) )
+			{
+				attacker.pers[ "defends" ]++;
+				attacker.defends = attacker.pers[ "defends" ];
+			}
+			attacker maps/mp/_medals::defenseglobalcount();
+			attacker addplayerstatwithgametype( "DEFENDS", 1 );
+			self recordkillmodifier( "assaulting" );
+			maps/mp/_scoreevents::processscoreevent( "killed_attacker", attacker, self, sweapon );
+		}
+	}
+	if ( isplayer( attacker ) && attacker.pers[ "team" ] != self.pers[ "team" ] && isDefined( self.isbombcarrier ) && self.isbombcarrier == 1 )
+	{
+		self recordkillmodifier( "carrying" );
+	}
+	if ( self.isplanting == 1 )
+	{
+		self recordkillmodifier( "planting" );
+	}
+	if ( self.isdefusing == 1 )
+	{
+		self recordkillmodifier( "defusing" );
+	}
+}
+
+checkallowspectating()
+{
+	self endon( "disconnect" );
+	wait 0,05;
+	update = 0;
+	if ( level.numliveslivesleft = self.pers[ "lives" ];
+	 && !level.alivecount[ game[ "attackers" ] ] && !livesleft )
+	{
+		level.spectateoverride[ game[ "attackers" ] ].allowenemyspectate = 1;
+		update = 1;
+	}
+	if ( !level.alivecount[ game[ "defenders" ] ] && !livesleft )
+	{
+		level.spectateoverride[ game[ "defenders" ] ].allowenemyspectate = 1;
+		update = 1;
+	}
+	if ( update )
+	{
+		maps/mp/gametypes/_spectating::updatespectatesettings();
+	}
+}
+
+sd_endgame( winningteam, endreasontext )
+{
+	if ( isDefined( winningteam ) )
+	{
+		maps/mp/gametypes/_globallogic_score::giveteamscoreforobjective_delaypostprocessing( winningteam, 1 );
+	}
+	thread maps/mp/gametypes/_globallogic::endgame( winningteam, endreasontext );
+}
+
+sd_endgamewithkillcam( winningteam, endreasontext )
+{
+	sd_endgame( winningteam, endreasontext );
+}
+
+ondeadevent( team )
+{
+	if ( level.bombexploded || level.bombdefused )
+	{
+		return;
+	}
+	if ( team == "all" )
+	{
+		if ( level.bombplanted )
+		{
+			sd_endgamewithkillcam( game[ "attackers" ], game[ "strings" ][ game[ "defenders" ] + "_eliminated" ] );
+		}
+		else
+		{
+			sd_endgamewithkillcam( game[ "defenders" ], game[ "strings" ][ game[ "attackers" ] + "_eliminated" ] );
+		}
+	}
+	else if ( team == game[ "attackers" ] )
+	{
+		if ( level.bombplanted )
+		{
+			return;
+		}
+		sd_endgamewithkillcam( game[ "defenders" ], game[ "strings" ][ game[ "attackers" ] + "_eliminated" ] );
+	}
+	else
+	{
+		if ( team == game[ "defenders" ] )
+		{
+			sd_endgamewithkillcam( game[ "attackers" ], game[ "strings" ][ game[ "defenders" ] + "_eliminated" ] );
+		}
+	}
+}
+
+ononeleftevent( team )
+{
+	if ( level.bombexploded || level.bombdefused )
+	{
+		return;
+	}
+	warnlastplayer( team );
+}
+
+ontimelimit()
+{
+	if ( level.teambased )
+	{
+		sd_endgame( game[ "defenders" ], game[ "strings" ][ "time_limit_reached" ] );
+	}
+	else
+	{
+		sd_endgame( undefined, game[ "strings" ][ "time_limit_reached" ] );
+	}
+}
+
+warnlastplayer( team )
+{
+	if ( !isDefined( level.warnedlastplayer ) )
+	{
+		level.warnedlastplayer = [];
+	}
+	if ( isDefined( level.warnedlastplayer[ team ] ) )
+	{
+		return;
+	}
+	level.warnedlastplayer[ team ] = 1;
+	players = level.players;
+	i = 0;
+	while ( i < players.size )
+	{
+		player = players[ i ];
+		if ( isDefined( player.pers[ "team" ] ) && player.pers[ "team" ] == team && isDefined( player.pers[ "class" ] ) )
+		{
+			if ( player.sessionstate == "playing" && !player.afk )
+			{
+				break;
+			}
+		}
+		else
+		{
+			i++;
+		}
+	}
+	if ( i == players.size )
+	{
+		return;
+	}
+	players[ i ] thread givelastattackerwarning( team );
+}
+
+givelastattackerwarning( team )
+{
+	self endon( "death" );
+	self endon( "disconnect" );
+	fullhealthtime = 0;
+	interval = 0,05;
+	self.lastmansd = 1;
+	enemyteam = game[ "defenders" ];
+	if ( team == enemyteam )
+	{
+		enemyteam = game[ "attackers" ];
+	}
+	if ( level.alivecount[ enemyteam ] > 2 )
+	{
+		self.lastmansddefeat3enemies = 1;
+	}
+	while ( 1 )
+	{
+		if ( self.health != self.maxhealth )
+		{
+			fullhealthtime = 0;
+		}
+		else
+		{
+			fullhealthtime += interval;
+		}
+		wait interval;
+		if ( self.health == self.maxhealth && fullhealthtime >= 3 )
+		{
+			break;
+		}
+		else
+		{
+		}
+	}
+	self maps/mp/gametypes/_globallogic_audio::leaderdialogonplayer( "last_one" );
+	self playlocalsound( "mus_last_stand" );
+}
+
+updategametypedvars()
+{
+	level.planttime = getgametypesetting( "plantTime" );
+	level.defusetime = getgametypesetting( "defuseTime" );
+	level.bombtimer = getgametypesetting( "bombTimer" );
+	level.multibomb = getgametypesetting( "multiBomb" );
+	level.teamkillpenaltymultiplier = getgametypesetting( "teamKillPenalty" );
+	level.teamkillscoremultiplier = getgametypesetting( "teamKillScore" );
+	level.playerkillsmax = getgametypesetting( "playerKillsMax" );
+	level.totalkillsmax = getgametypesetting( "totalKillsMax" );
+}
+
+bombs()
+{
+	level.bombplanted = 0;
+	level.bombdefused = 0;
+	level.bombexploded = 0;
+	trigger = getent( "sd_bomb_pickup_trig", "targetname" );
+	if ( !isDefined( trigger ) )
+	{
+/#
+		maps/mp/_utility::error( "No sd_bomb_pickup_trig trigger found in map." );
+#/
+		return;
+	}
+	visuals[ 0 ] = getent( "sd_bomb", "targetname" );
+	if ( !isDefined( visuals[ 0 ] ) )
+	{
+/#
+		maps/mp/_utility::error( "No sd_bomb script_model found in map." );
+#/
+		return;
+	}
+	precachemodel( "prop_suitcase_bomb" );
+	precachestring( &"bomb" );
+	if ( !level.multibomb )
+	{
+		level.sdbomb = maps/mp/gametypes/_gameobjects::createcarryobject( game[ "attackers" ], trigger, visuals, vectorScale( ( 0, 0, 1 ), 32 ), &"bomb" );
+		level.sdbomb maps/mp/gametypes/_gameobjects::allowcarry( "friendly" );
+		level.sdbomb maps/mp/gametypes/_gameobjects::set2dicon( "friendly", "compass_waypoint_bomb" );
+		level.sdbomb maps/mp/gametypes/_gameobjects::set3dicon( "friendly", "waypoint_bomb" );
+		level.sdbomb maps/mp/gametypes/_gameobjects::setvisibleteam( "friendly" );
+		level.sdbomb maps/mp/gametypes/_gameobjects::setcarryicon( "hud_suitcase_bomb" );
+		level.sdbomb.allowweapons = 1;
+		level.sdbomb.onpickup = ::onpickup;
+		level.sdbomb.ondrop = ::ondrop;
+	}
+	else
+	{
+		trigger delete();
+		visuals[ 0 ] delete();
+	}
+	level.bombzones = [];
+	bombzones = getentarray( "bombzone", "targetname" );
+	index = 0;
+	while ( index < bombzones.size )
+	{
+		trigger = bombzones[ index ];
+		visuals = getentarray( bombzones[ index ].target, "targetname" );
+		name = istring( trigger.script_label );
+		precachestring( name );
+		precachestring( istring( "defuse" + trigger.script_label ) );
+		bombzone = maps/mp/gametypes/_gameobjects::createuseobject( game[ "defenders" ], trigger, visuals, ( 0, 0, 1 ), name );
+		bombzone maps/mp/gametypes/_gameobjects::allowuse( "enemy" );
+		bombzone maps/mp/gametypes/_gameobjects::setusetime( level.planttime );
+		bombzone maps/mp/gametypes/_gameobjects::setusetext( &"MP_PLANTING_EXPLOSIVE" );
+		bombzone maps/mp/gametypes/_gameobjects::setusehinttext( &"PLATFORM_HOLD_TO_PLANT_EXPLOSIVES" );
+		if ( !level.multibomb )
+		{
+			bombzone maps/mp/gametypes/_gameobjects::setkeyobject( level.sdbomb );
+		}
+		label = bombzone maps/mp/gametypes/_gameobjects::getlabel();
+		bombzone.label = label;
+		bombzone maps/mp/gametypes/_gameobjects::set2dicon( "friendly", "compass_waypoint_defend" + label );
+		bombzone maps/mp/gametypes/_gameobjects::set3dicon( "friendly", "waypoint_defend" + label );
+		bombzone maps/mp/gametypes/_gameobjects::set2dicon( "enemy", "compass_waypoint_target" + label );
+		bombzone maps/mp/gametypes/_gameobjects::set3dicon( "enemy", "waypoint_target" + label );
+		bombzone maps/mp/gametypes/_gameobjects::setvisibleteam( "any" );
+		bombzone.onbeginuse = ::onbeginuse;
+		bombzone.onenduse = ::onenduse;
+		bombzone.onuse = ::onuseplantobject;
+		bombzone.oncantuse = ::oncantuse;
+		bombzone.useweapon = "briefcase_bomb_mp";
+		bombzone.visuals[ 0 ].killcament = spawn( "script_model", bombzone.visuals[ 0 ].origin + vectorScale( ( 0, 0, 1 ), 128 ) );
+		if ( !level.multibomb )
+		{
+			bombzone.trigger setinvisibletoall();
+		}
+		i = 0;
+		while ( i < visuals.size )
+		{
+			if ( isDefined( visuals[ i ].script_exploder ) )
+			{
+				bombzone.exploderindex = visuals[ i ].script_exploder;
+				break;
+			}
+			else
+			{
+				i++;
+			}
+		}
+		level.bombzones[ level.bombzones.size ] = bombzone;
+		bombzone.bombdefusetrig = getent( visuals[ 0 ].target, "targetname" );
+/#
+		assert( isDefined( bombzone.bombdefusetrig ) );
+#/
+		bombzone.bombdefusetrig.origin += vectorScale( ( 0, 0, 1 ), 10000 );
+		bombzone.bombdefusetrig.label = label;
+		index++;
+	}
+	index = 0;
+	while ( index < level.bombzones.size )
+	{
+		array = [];
+		otherindex = 0;
+		while ( otherindex < level.bombzones.size )
+		{
+			if ( otherindex != index )
+			{
+				array[ array.size ] = level.bombzones[ otherindex ];
+			}
+			otherindex++;
+		}
+		level.bombzones[ index ].otherbombzones = array;
+		index++;
+	}
+}
+
+onbeginuse( player )
+{
+	if ( self maps/mp/gametypes/_gameobjects::isfriendlyteam( player.pers[ "team" ] ) )
+	{
+		player playsound( "mpl_sd_bomb_defuse" );
+		player.isdefusing = 1;
+		player thread maps/mp/gametypes/_battlechatter_mp::gametypespecificbattlechatter( "sd_enemyplant", player.pers[ "team" ] );
+		if ( isDefined( level.sdbombmodel ) )
+		{
+			level.sdbombmodel hide();
+		}
+	}
+	else
+	{
+		player.isplanting = 1;
+		player thread maps/mp/gametypes/_battlechatter_mp::gametypespecificbattlechatter( "sd_friendlyplant", player.pers[ "team" ] );
+		while ( level.multibomb )
+		{
+			i = 0;
+			while ( i < self.otherbombzones.size )
+			{
+				self.otherbombzones[ i ] maps/mp/gametypes/_gameobjects::disableobject();
+				i++;
+			}
+		}
+	}
+	player playsound( "fly_bomb_raise_plr" );
+}
+
+onenduse( team, player, result )
+{
+	if ( !isDefined( player ) )
+	{
+		return;
+	}
+	player.isdefusing = 0;
+	player.isplanting = 0;
+	player notify( "event_ended" );
+	if ( self maps/mp/gametypes/_gameobjects::isfriendlyteam( player.pers[ "team" ] ) )
+	{
+		if ( isDefined( level.sdbombmodel ) && !result )
+		{
+			level.sdbombmodel show();
+		}
+	}
+	else
+	{
+		while ( level.multibomb && !result )
+		{
+			i = 0;
+			while ( i < self.otherbombzones.size )
+			{
+				self.otherbombzones[ i ] maps/mp/gametypes/_gameobjects::enableobject();
+				i++;
+			}
+		}
+	}
+}
+
+oncantuse( player )
+{
+	player iprintlnbold( &"MP_CANT_PLANT_WITHOUT_BOMB" );
+}
+
+onuseplantobject( player )
+{
+	if ( !self maps/mp/gametypes/_gameobjects::isfriendlyteam( player.pers[ "team" ] ) )
+	{
+		self maps/mp/gametypes/_gameobjects::setflags( 1 );
+		level thread bombplanted( self, player );
+		player logstring( "bomb planted: " + self.label );
+		index = 0;
+		while ( index < level.bombzones.size )
+		{
+			if ( level.bombzones[ index ] == self )
+			{
+				index++;
+				continue;
+			}
+			else
+			{
+				level.bombzones[ index ] maps/mp/gametypes/_gameobjects::disableobject();
+			}
+			index++;
+		}
+		thread playsoundonplayers( "mus_sd_planted" + "_" + level.teampostfix[ player.pers[ "team" ] ] );
+		player notify( "bomb_planted" );
+		level thread maps/mp/_popups::displayteammessagetoall( &"MP_EXPLOSIVES_PLANTED_BY", player );
+		if ( isDefined( player.pers[ "plants" ] ) )
+		{
+			player.pers[ "plants" ]++;
+			player.plants = player.pers[ "plants" ];
+		}
+		maps/mp/_demo::bookmark( "event", getTime(), player );
+		player addplayerstatwithgametype( "PLANTS", 1 );
+		maps/mp/gametypes/_globallogic_audio::leaderdialog( "bomb_planted" );
+		maps/mp/_scoreevents::processscoreevent( "planted_bomb", player );
+		player recordgameevent( "plant" );
+	}
+}
+
+onusedefuseobject( player )
+{
+	self maps/mp/gametypes/_gameobjects::setflags( 0 );
+	player notify( "bomb_defused" );
+	player logstring( "bomb defused: " + self.label );
+	bbprint( "mpobjective", "gametime %d objtype %s label %s team %s", getTime(), "sd_bombdefuse", self.label, player.pers[ "team" ] );
+	level thread bombdefused();
+	self maps/mp/gametypes/_gameobjects::disableobject();
+	level thread maps/mp/_popups::displayteammessagetoall( &"MP_EXPLOSIVES_DEFUSED_BY", player );
+	if ( isDefined( player.pers[ "defuses" ] ) )
+	{
+		player.pers[ "defuses" ]++;
+		player.defuses = player.pers[ "defuses" ];
+	}
+	player addplayerstatwithgametype( "DEFUSES", 1 );
+	maps/mp/_demo::bookmark( "event", getTime(), player );
+	maps/mp/gametypes/_globallogic_audio::leaderdialog( "bomb_defused" );
+	if ( isDefined( player.lastmansd ) && player.lastmansd == 1 )
+	{
+		maps/mp/_scoreevents::processscoreevent( "defused_bomb_last_man_alive", player );
+	}
+	else
+	{
+		maps/mp/_scoreevents::processscoreevent( "defused_bomb", player );
+	}
+	player recordgameevent( "defuse" );
+}
+
+ondrop( player )
+{
+	if ( !level.bombplanted )
+	{
+		maps/mp/gametypes/_globallogic_audio::leaderdialog( "bomb_lost", game[ "attackers" ] );
+		if ( isDefined( player ) )
+		{
+			player logstring( "bomb dropped" );
+		}
+		else
+		{
+			logstring( "bomb dropped" );
+		}
+	}
+	player notify( "event_ended" );
+	self maps/mp/gametypes/_gameobjects::set3dicon( "friendly", "waypoint_bomb" );
+	maps/mp/_utility::playsoundonplayers( game[ "bomb_dropped_sound" ], game[ "attackers" ] );
+}
+
+onpickup( player )
+{
+	player.isbombcarrier = 1;
+	player recordgameevent( "pickup" );
+	self maps/mp/gametypes/_gameobjects::set3dicon( "friendly", "waypoint_defend" );
+	if ( !level.bombdefused )
+	{
+		if ( isDefined( player ) && isDefined( player.name ) )
+		{
+			player addplayerstatwithgametype( "PICKUPS", 1 );
+		}
+		team = self maps/mp/gametypes/_gameobjects::getownerteam();
+		otherteam = getotherteam( team );
+		maps/mp/gametypes/_globallogic_audio::leaderdialog( "bomb_acquired", game[ "attackers" ] );
+		player logstring( "bomb taken" );
+	}
+	maps/mp/_utility::playsoundonplayers( game[ "bomb_recovered_sound" ], game[ "attackers" ] );
+	i = 0;
+	while ( i < level.bombzones.size )
+	{
+		level.bombzones[ i ].trigger setinvisibletoall();
+		level.bombzones[ i ].trigger setvisibletoplayer( player );
+		i++;
+	}
+}
+
+onreset()
+{
+}
+
+bombplantedmusicdelay()
+{
+	level endon( "bomb_defused" );
+	time = level.bombtimer - 30;
+/#
+	if ( getDvarInt( #"0BC4784C" ) > 0 )
+	{
+		println( "Music System - waiting to set TIME_OUT: " + time );
+#/
+	}
+	if ( time > 1 )
+	{
+		wait time;
+		thread maps/mp/gametypes/_globallogic_audio::set_music_on_team( "TIME_OUT", "both" );
+	}
+}
+
+bombplanted( destroyedobj, player )
+{
+	maps/mp/gametypes/_globallogic_utils::pausetimer();
+	level.bombplanted = 1;
+	team = player.pers[ "team" ];
+	destroyedobj.visuals[ 0 ] thread maps/mp/gametypes/_globallogic_utils::playtickingsound( "mpl_sab_ui_suitcasebomb_timer" );
+	level thread bombplantedmusicdelay();
+	level.tickingobject = destroyedobj.visuals[ 0 ];
+	level.timelimitoverride = 1;
+	setgameendtime( int( getTime() + ( level.bombtimer * 1000 ) ) );
+	label = destroyedobj maps/mp/gametypes/_gameobjects::getlabel();
+	setmatchflag( "bomb_timer" + label, 1 );
+	if ( label == "_a" )
+	{
+		setbombtimer( "A", int( getTime() + ( level.bombtimer * 1000 ) ) );
+	}
+	else
+	{
+		setbombtimer( "B", int( getTime() + ( level.bombtimer * 1000 ) ) );
+	}
+	bbprint( "mpobjective", "gametime %d objtype %s label %s team %s", getTime(), "sd_bombplant", label, team );
+	if ( !level.multibomb )
+	{
+		level.sdbomb maps/mp/gametypes/_gameobjects::allowcarry( "none" );
+		level.sdbomb maps/mp/gametypes/_gameobjects::setvisibleteam( "none" );
+		level.sdbomb maps/mp/gametypes/_gameobjects::setdropped();
+		level.sdbombmodel = level.sdbomb.visuals[ 0 ];
+	}
+	else
+	{
+		index = 0;
+		while ( index < level.players.size )
+		{
+			if ( isDefined( level.players[ index ].carryicon ) )
+			{
+				level.players[ index ].carryicon destroyelem();
+			}
+			index++;
+		}
+		trace = bullettrace( player.origin + vectorScale( ( 0, 0, 1 ), 20 ), player.origin - vectorScale( ( 0, 0, 1 ), 2000 ), 0, player );
+		tempangle = randomfloat( 360 );
+		forward = ( cos( tempangle ), sin( tempangle ), 0 );
+		forward = vectornormalize( forward - vectorScale( trace[ "normal" ], vectordot( forward, trace[ "normal" ] ) ) );
+		dropangles = vectorToAngle( forward );
+		level.sdbombmodel = spawn( "script_model", trace[ "position" ] );
+		level.sdbombmodel.angles = dropangles;
+		level.sdbombmodel setmodel( "prop_suitcase_bomb" );
+	}
+	destroyedobj maps/mp/gametypes/_gameobjects::allowuse( "none" );
+	destroyedobj maps/mp/gametypes/_gameobjects::setvisibleteam( "none" );
+	label = destroyedobj maps/mp/gametypes/_gameobjects::getlabel();
+	trigger = destroyedobj.bombdefusetrig;
+	trigger.origin = level.sdbombmodel.origin;
+	visuals = [];
+	defuseobject = maps/mp/gametypes/_gameobjects::createuseobject( game[ "defenders" ], trigger, visuals, vectorScale( ( 0, 0, 1 ), 32 ), istring( "defuse" + label ) );
+	defuseobject maps/mp/gametypes/_gameobjects::allowuse( "friendly" );
+	defuseobject maps/mp/gametypes/_gameobjects::setusetime( level.defusetime );
+	defuseobject maps/mp/gametypes/_gameobjects::setusetext( &"MP_DEFUSING_EXPLOSIVE" );
+	defuseobject maps/mp/gametypes/_gameobjects::setusehinttext( &"PLATFORM_HOLD_TO_DEFUSE_EXPLOSIVES" );
+	defuseobject maps/mp/gametypes/_gameobjects::setvisibleteam( "any" );
+	defuseobject maps/mp/gametypes/_gameobjects::set2dicon( "friendly", "compass_waypoint_defuse" + label );
+	defuseobject maps/mp/gametypes/_gameobjects::set2dicon( "enemy", "compass_waypoint_defend" + label );
+	defuseobject maps/mp/gametypes/_gameobjects::set3dicon( "friendly", "waypoint_defuse" + label );
+	defuseobject maps/mp/gametypes/_gameobjects::set3dicon( "enemy", "waypoint_defend" + label );
+	defuseobject maps/mp/gametypes/_gameobjects::setflags( 1 );
+	defuseobject.label = label;
+	defuseobject.onbeginuse = ::onbeginuse;
+	defuseobject.onenduse = ::onenduse;
+	defuseobject.onuse = ::onusedefuseobject;
+	defuseobject.useweapon = "briefcase_bomb_defuse_mp";
+	player.isbombcarrier = 0;
+	bombtimerwait();
+	setbombtimer( "A", 0 );
+	setbombtimer( "B", 0 );
+	setmatchflag( "bomb_timer_a", 0 );
+	setmatchflag( "bomb_timer_b", 0 );
+	destroyedobj.visuals[ 0 ] maps/mp/gametypes/_globallogic_utils::stoptickingsound();
+	if ( level.gameended || level.bombdefused )
+	{
+		return;
+	}
+	level.bombexploded = 1;
+	bbprint( "mpobjective", "gametime %d objtype %s label %s team %s", getTime(), "sd_bombexplode", label, team );
+	explosionorigin = level.sdbombmodel.origin + vectorScale( ( 0, 0, 1 ), 12 );
+	level.sdbombmodel hide();
+	if ( isDefined( player ) )
+	{
+		destroyedobj.visuals[ 0 ] radiusdamage( explosionorigin, 512, 200, 20, player, "MOD_EXPLOSIVE", "briefcase_bomb_mp" );
+		level thread maps/mp/_popups::displayteammessagetoall( &"MP_EXPLOSIVES_BLOWUP_BY", player );
+		maps/mp/_scoreevents::processscoreevent( "bomb_detonated", player );
+		player addplayerstatwithgametype( "DESTRUCTIONS", 1 );
+		player recordgameevent( "destroy" );
+	}
+	else
+	{
+		destroyedobj.visuals[ 0 ] radiusdamage( explosionorigin, 512, 200, 20, undefined, "MOD_EXPLOSIVE", "briefcase_bomb_mp" );
+	}
+	rot = randomfloat( 360 );
+	explosioneffect = spawnfx( level._effect[ "bombexplosion" ], explosionorigin + vectorScale( ( 0, 0, 1 ), 50 ), ( 0, 0, 1 ), ( cos( rot ), sin( rot ), 0 ) );
+	triggerfx( explosioneffect );
+	thread playsoundinspace( "mpl_sd_exp_suitcase_bomb_main", explosionorigin );
+	if ( isDefined( destroyedobj.exploderindex ) )
+	{
+		exploder( destroyedobj.exploderindex );
+	}
+	index = 0;
+	while ( index < level.bombzones.size )
+	{
+		level.bombzones[ index ] maps/mp/gametypes/_gameobjects::disableobject();
+		index++;
+	}
+	defuseobject maps/mp/gametypes/_gameobjects::disableobject();
+	setgameendtime( 0 );
+	wait 3;
+	sd_endgame( game[ "attackers" ], game[ "strings" ][ "target_destroyed" ] );
+}
+
+bombtimerwait()
+{
+	level endon( "game_ended" );
+	level endon( "bomb_defused" );
+	maps/mp/gametypes/_hostmigration::waitlongdurationwithgameendtimeupdate( level.bombtimer );
+}
+
+bombdefused()
+{
+	level.tickingobject maps/mp/gametypes/_globallogic_utils::stoptickingsound();
+	level.bombdefused = 1;
+	setbombtimer( "A", 0 );
+	setbombtimer( "B", 0 );
+	setmatchflag( "bomb_timer_a", 0 );
+	setmatchflag( "bomb_timer_b", 0 );
+	level notify( "bomb_defused" );
+	thread maps/mp/gametypes/_globallogic_audio::set_music_on_team( "SILENT", "both" );
+	wait 1,5;
+	setgameendtime( 0 );
+	sd_endgame( game[ "defenders" ], game[ "strings" ][ "bomb_defused" ] );
+}
+
+sd_iskillboosting()
+{
+	roundsplayed = maps/mp/_utility::getroundsplayed();
+	if ( level.playerkillsmax == 0 )
+	{
+		return 0;
+	}
+	if ( game[ "totalKills" ] > ( level.totalkillsmax * ( roundsplayed + 1 ) ) )
+	{
+		return 1;
+	}
+	if ( self.kills > ( level.playerkillsmax * ( roundsplayed + 1 ) ) )
+	{
+		return 1;
+	}
+	if ( level.teambased || self.team == "allies" && self.team == "axis" )
+	{
+		if ( game[ "totalKillsTeam" ][ self.team ] > ( level.playerkillsmax * ( roundsplayed + 1 ) ) )
+		{
+			return 1;
+		}
+	}
+	return 0;
+}

patch_mp/maps/mp/gametypes/shrp.gsc

@@ -0,0 +1,716 @@
+#include maps/mp/gametypes/_persistence;
+#include maps/mp/gametypes/_globallogic_score;
+#include maps/mp/_scoreevents;
+#include maps/mp/gametypes/_hostmigration;
+#include maps/mp/gametypes/_wager;
+#include maps/mp/gametypes/_spawnlogic;
+#include maps/mp/gametypes/_spawning;
+#include maps/mp/gametypes/_hud_util;
+#include maps/mp/_utility;
+#include common_scripts/utility;
+
+main()
+{
+	maps/mp/gametypes/_globallogic::init();
+	maps/mp/gametypes/_callbacksetup::setupcallbacks();
+	maps/mp/gametypes/_globallogic::setupcallbacks();
+	level.pointsperweaponkill = getgametypesetting( "pointsPerWeaponKill" );
+	level.pointspermeleekill = getgametypesetting( "pointsPerMeleeKill" );
+	level.shrpweapontimer = getgametypesetting( "weaponTimer" );
+	level.shrpweaponnumber = getgametypesetting( "weaponCount" );
+	registertimelimit( ( level.shrpweaponnumber * level.shrpweapontimer ) / 60, ( level.shrpweaponnumber * level.shrpweapontimer ) / 60 );
+	registerscorelimit( 0, 50000 );
+	registerroundlimit( 0, 10 );
+	registerroundwinlimit( 0, 10 );
+	registernumlives( 0, 100 );
+	level.onstartgametype = ::onstartgametype;
+	level.onspawnplayer = ::onspawnplayer;
+	level.onspawnplayerunified = ::onspawnplayerunified;
+	level.onplayerkilled = ::onplayerkilled;
+	level.onwagerawards = ::onwagerawards;
+	game[ "dialog" ][ "gametype" ] = "ss_start";
+	level.givecustomloadout = ::givecustomloadout;
+	precachestring( &"MP_SHRP_WEAPONS_CYCLED" );
+	precachestring( &"MP_SHRP_PENULTIMATE_RND" );
+	precachestring( &"MP_SHRP_PENULTIMATE_MULTIPLIER" );
+	precachestring( &"MP_SHRP_RND" );
+	precachestring( &"MP_SHRP_FINAL_MULTIPLIER" );
+	precachestring( &"MP_SHRP_COUNTDOWN" );
+	precacheshader( "perk_times_two" );
+	precacheitem( "minigun_wager_mp" );
+	precacheitem( "m32_wager_mp" );
+	game[ "dialog" ][ "wm_weapons_cycled" ] = "ssharp_cycle_01";
+	game[ "dialog" ][ "wm_final_weapon" ] = "ssharp_fweapon";
+	game[ "dialog" ][ "wm_bonus_rnd" ] = "ssharp_2multi_00";
+	game[ "dialog" ][ "wm_shrp_rnd" ] = "ssharp_sround";
+	game[ "dialog" ][ "wm_bonus0" ] = "boost_gen_05";
+	game[ "dialog" ][ "wm_bonus1" ] = "boost_gen_05";
+	game[ "dialog" ][ "wm_bonus2" ] = "boost_gen_05";
+	game[ "dialog" ][ "wm_bonus3" ] = "boost_gen_05";
+	game[ "dialog" ][ "wm_bonus4" ] = "boost_gen_05";
+	game[ "dialog" ][ "wm_bonus5" ] = "boost_gen_05";
+	setscoreboardcolumns( "pointstowin", "kills", "deaths", "stabs", "x2score" );
+}
+
+onstartgametype()
+{
+	setdvar( "scr_disable_weapondrop", 1 );
+	setdvar( "scr_xpscale", 0 );
+	setdvar( "ui_guncycle", 0 );
+	makedvarserverinfo( "ui_guncycle", 0 );
+	setclientnamemode( "auto_change" );
+	setobjectivetext( "allies", &"OBJECTIVES_SHRP" );
+	setobjectivetext( "axis", &"OBJECTIVES_SHRP" );
+	attach_compatibility_init();
+	if ( level.splitscreen )
+	{
+		setobjectivescoretext( "allies", &"OBJECTIVES_SHRP" );
+		setobjectivescoretext( "axis", &"OBJECTIVES_SHRP" );
+	}
+	else
+	{
+		setobjectivescoretext( "allies", &"OBJECTIVES_SHRP_SCORE" );
+		setobjectivescoretext( "axis", &"OBJECTIVES_SHRP_SCORE" );
+	}
+	setobjectivehinttext( "allies", &"OBJECTIVES_SHRP_HINT" );
+	setobjectivehinttext( "axis", &"OBJECTIVES_SHRP_HINT" );
+	allowed[ 0 ] = "shrp";
+	maps/mp/gametypes/_gameobjects::main( allowed );
+	maps/mp/gametypes/_spawning::create_map_placed_influencers();
+	level.spawnmins = ( 0, 0, 0 );
+	level.spawnmaxs = ( 0, 0, 0 );
+	newspawns = getentarray( "mp_wager_spawn", "classname" );
+	if ( newspawns.size > 0 )
+	{
+		maps/mp/gametypes/_spawnlogic::addspawnpoints( "allies", "mp_wager_spawn" );
+		maps/mp/gametypes/_spawnlogic::addspawnpoints( "axis", "mp_wager_spawn" );
+	}
+	else
+	{
+		maps/mp/gametypes/_spawnlogic::addspawnpoints( "allies", "mp_dm_spawn" );
+		maps/mp/gametypes/_spawnlogic::addspawnpoints( "axis", "mp_dm_spawn" );
+	}
+	maps/mp/gametypes/_spawning::updateallspawnpoints();
+	level.mapcenter = maps/mp/gametypes/_spawnlogic::findboxcenter( level.spawnmins, level.spawnmaxs );
+	setmapcenter( level.mapcenter );
+	spawnpoint = maps/mp/gametypes/_spawnlogic::getrandomintermissionpoint();
+	setdemointermissionpoint( spawnpoint.origin, spawnpoint.angles );
+	level.usestartspawns = 0;
+	maps/mp/gametypes/_wager::addpowerup( "specialty_bulletflinch", "perk", &"PERKS_TOUGHNESS", "perk_warrior" );
+	maps/mp/gametypes/_wager::addpowerup( "specialty_movefaster", "perk", &"PERKS_LIGHTWEIGHT", "perk_lightweight" );
+	maps/mp/gametypes/_wager::addpowerup( "specialty_fallheight", "perk", &"PERKS_LIGHTWEIGHT", "perk_lightweight" );
+	maps/mp/gametypes/_wager::addpowerup( "specialty_longersprint", "perk", &"PERKS_EXTREME_CONDITIONING", "perk_marathon" );
+	maps/mp/gametypes/_wager::addpowerup( 2, "score_multiplier", &"PERKS_SCORE_MULTIPLIER", "perk_times_two" );
+	level.guncycletimer = createservertimer( "extrasmall", 1,2 );
+	level.guncycletimer.horzalign = "user_left";
+	level.guncycletimer.vertalign = "user_top";
+	level.guncycletimer.x = 10;
+	level.guncycletimer.y = 123;
+	level.guncycletimer.alignx = "left";
+	level.guncycletimer.aligny = "top";
+	level.guncycletimer.label = &"MP_SHRP_COUNTDOWN";
+	level.guncycletimer.alpha = 0;
+	level.guncycletimer.hidewheninkillcam = 1;
+	level.displayroundendtext = 0;
+	level.quickmessagetoall = 1;
+	level thread chooserandomguns();
+	level thread clearpowerupsongameend();
+}
+
+attach_compatibility_init()
+{
+	level.attach_compatible = [];
+	set_attachtable_id();
+	i = 0;
+	while ( i < 33 )
+	{
+		itemrow = tablelookuprownum( level.attachtableid, 9, i );
+		if ( itemrow > -1 )
+		{
+			name = tablelookupcolumnforrow( level.attachtableid, itemrow, 4 );
+			level.attach_compatible[ name ] = [];
+			compatible = tablelookupcolumnforrow( level.attachtableid, itemrow, 11 );
+			level.attach_compatible[ name ] = strtok( compatible, " " );
+		}
+		i++;
+	}
+}
+
+set_attachtable_id()
+{
+	if ( !isDefined( level.attachtableid ) )
+	{
+		level.attachtableid = "mp/attachmentTable.csv";
+	}
+}
+
+addguntoprogression( gunname, altname )
+{
+	if ( !isDefined( level.gunprogression ) )
+	{
+		level.gunprogression = [];
+	}
+	newweapon = spawnstruct();
+	newweapon.names = [];
+	newweapon.names[ newweapon.names.size ] = gunname;
+	if ( isDefined( altname ) )
+	{
+		newweapon.names[ newweapon.names.size ] = altname;
+	}
+	level.gunprogression[ level.gunprogression.size ] = newweapon;
+}
+
+getrandomgunfromprogression()
+{
+	weaponidkeys = getarraykeys( level.tbl_weaponids );
+	numweaponidkeys = weaponidkeys.size;
+	gunprogressionsize = 0;
+	if ( isDefined( level.gunprogression ) )
+	{
+		size = level.gunprogression.size;
+	}
+/#
+	debug_weapon = getDvar( #"1C6DE858" );
+#/
+	allowproneblock = 1;
+	players = get_players();
+	_a256 = players;
+	_k256 = getFirstArrayKey( _a256 );
+	while ( isDefined( _k256 ) )
+	{
+		player = _a256[ _k256 ];
+		if ( player getstance() == "prone" )
+		{
+			allowproneblock = 0;
+			break;
+		}
+		else
+		{
+			_k256 = getNextArrayKey( _a256, _k256 );
+		}
+	}
+	while ( 1 )
+	{
+		randomindex = randomint( numweaponidkeys + gunprogressionsize );
+		baseweaponname = "";
+		weaponname = "";
+		if ( randomindex < numweaponidkeys )
+		{
+			id = random( level.tbl_weaponids );
+			while ( id[ "group" ] != "weapon_launcher" && id[ "group" ] != "weapon_sniper" && id[ "group" ] != "weapon_lmg" && id[ "group" ] != "weapon_assault" && id[ "group" ] != "weapon_smg" && id[ "group" ] != "weapon_pistol" && id[ "group" ] != "weapon_cqb" && id[ "group" ] != "weapon_special" )
+			{
+				continue;
+			}
+			while ( id[ "reference" ] == "weapon_null" )
+			{
+				continue;
+			}
+			baseweaponname = id[ "reference" ];
+			attachmentlist = id[ "attachment" ];
+			if ( baseweaponname == "m32" )
+			{
+				baseweaponname = "m32_wager";
+			}
+			if ( baseweaponname == "minigun" )
+			{
+				baseweaponname = "minigun_wager";
+			}
+			while ( baseweaponname == "riotshield" )
+			{
+				continue;
+			}
+			if ( getDvarInt( #"97A055DA" ) == 0 && baseweaponname == "peacekeeper" )
+			{
+				continue;
+			}
+			weaponname = addrandomattachmenttoweaponname( baseweaponname, attachmentlist );
+			if ( !allowproneblock && weaponblocksprone( weaponname ) )
+			{
+				continue;
+			}
+		}
+		else baseweaponname = level.gunprogression[ randomindex - numweaponidkeys ].names[ 0 ];
+		weaponname = level.gunprogression[ randomindex - numweaponidkeys ].names[ 0 ];
+		if ( !isDefined( level.usedbaseweapons ) )
+		{
+			level.usedbaseweapons = [];
+			level.usedbaseweapons[ 0 ] = "fhj18";
+		}
+		skipweapon = 0;
+		i = 0;
+		while ( i < level.usedbaseweapons.size )
+		{
+			if ( level.usedbaseweapons[ i ] == baseweaponname )
+			{
+				skipweapon = 1;
+				break;
+			}
+			else
+			{
+				i++;
+			}
+		}
+		while ( skipweapon )
+		{
+			continue;
+		}
+		level.usedbaseweapons[ level.usedbaseweapons.size ] = baseweaponname;
+/#
+		if ( debug_weapon != "" )
+		{
+			weaponname = debug_weapon;
+#/
+		}
+		return weaponname;
+	}
+}
+
+addrandomattachmenttoweaponname( baseweaponname, attachmentlist )
+{
+	if ( !isDefined( attachmentlist ) )
+	{
+		return baseweaponname;
+	}
+	attachments = strtok( attachmentlist, " " );
+	arrayremovevalue( attachments, "dw" );
+	if ( attachments.size <= 0 )
+	{
+		return baseweaponname + "_mp";
+	}
+	attachments[ attachments.size ] = "";
+	attachment = random( attachments );
+	if ( attachment == "" )
+	{
+		return baseweaponname + "_mp";
+	}
+	if ( issubstr( attachment, "_" ) )
+	{
+		attachment = strtok( attachment, "_" )[ 0 ];
+	}
+	if ( isDefined( level.attach_compatible[ attachment ] ) && level.attach_compatible[ attachment ].size > 0 )
+	{
+		attachment2 = level.attach_compatible[ attachment ][ randomint( level.attach_compatible[ attachment ].size ) ];
+		contains = 0;
+		i = 0;
+		while ( i < attachments.size )
+		{
+			if ( isDefined( attachment2 ) && attachments[ i ] == attachment2 )
+			{
+				contains = 1;
+				break;
+			}
+			else
+			{
+				i++;
+			}
+		}
+		if ( contains )
+		{
+			if ( attachment < attachment2 )
+			{
+				return ( baseweaponname + "_mp+" ) + attachment + "+" + attachment2;
+			}
+			return ( baseweaponname + "_mp+" ) + attachment2 + "+" + attachment;
+		}
+	}
+	return ( baseweaponname + "_mp+" ) + attachment;
+}
+
+waitlongdurationwithhostmigrationpause( nextguncycletime, duration )
+{
+	endtime = getTime() + ( duration * 1000 );
+	totaltimepassed = 0;
+	while ( getTime() < endtime )
+	{
+		maps/mp/gametypes/_hostmigration::waittillhostmigrationstarts( ( endtime - getTime() ) / 1000 );
+		if ( isDefined( level.hostmigrationtimer ) )
+		{
+			setdvar( "ui_guncycle", 0 );
+			timepassed = maps/mp/gametypes/_hostmigration::waittillhostmigrationdone();
+			totaltimepassed += timepassed;
+			endtime += timepassed;
+/#
+			println( "[SHRP] timePassed = " + timepassed );
+			println( "[SHRP] totatTimePassed = " + totaltimepassed );
+			println( "[SHRP] level.discardTime = " + level.discardtime );
+#/
+			setdvar( "ui_guncycle", nextguncycletime + totaltimepassed );
+		}
+	}
+	maps/mp/gametypes/_hostmigration::waittillhostmigrationdone();
+	return totaltimepassed;
+}
+
+guncyclewaiter( nextguncycletime, waittime )
+{
+	continuecycling = 1;
+	setdvar( "ui_guncycle", nextguncycletime );
+	level.guncycletimer settimer( waittime );
+	level.guncycletimer.alpha = 1;
+	timepassed = waitlongdurationwithhostmigrationpause( nextguncycletime, ( ( nextguncycletime - getTime() ) / 1000 ) - 6 );
+	nextguncycletime += timepassed;
+	i = 6;
+	while ( i > 1 )
+	{
+		j = 0;
+		while ( j < level.players.size )
+		{
+			level.players[ j ] playlocalsound( "uin_timer_wager_beep" );
+			j++;
+		}
+		timepassed = waitlongdurationwithhostmigrationpause( nextguncycletime, ( nextguncycletime - getTime() ) / 1000 / i );
+		nextguncycletime += timepassed;
+		i--;
+
+	}
+	i = 0;
+	while ( i < level.players.size )
+	{
+		level.players[ i ] playlocalsound( "uin_timer_wager_last_beep" );
+		i++;
+	}
+	if ( ( nextguncycletime - getTime() ) > 0 )
+	{
+		wait ( ( nextguncycletime - getTime() ) / 1000 );
+	}
+	level.shrprandomweapon = getrandomgunfromprogression();
+	i = 0;
+	while ( i < level.players.size )
+	{
+		level.players[ i ] notify( "remove_planted_weapons" );
+		level.players[ i ] givecustomloadout( 0, 1 );
+		i++;
+	}
+	return continuecycling;
+}
+
+chooserandomguns()
+{
+	level endon( "game_ended" );
+	level thread awardmostpointsmedalgameend();
+	waittime = level.shrpweapontimer;
+	lightningwaittime = 15;
+	level.shrprandomweapon = getrandomgunfromprogression();
+	if ( level.inprematchperiod )
+	{
+		level waittill( "prematch_over" );
+	}
+	guncycle = 1;
+	numguncycles = int( ( ( level.timelimit * 60 ) / waittime ) + 0,5 );
+	while ( 1 )
+	{
+		nextguncycletime = getTime() + ( waittime * 1000 );
+		ispenultimateround = 0;
+		issharpshooterround = guncycle == ( numguncycles - 1 );
+		i = 0;
+		while ( i < level.players.size )
+		{
+			level.players[ i ].currentguncyclepoints = 0;
+			i++;
+		}
+		level.currentguncyclemaxpoints = 0;
+		guncyclewaiter( nextguncycletime, waittime );
+		i = 0;
+		while ( i < level.players.size )
+		{
+			player = level.players[ i ];
+			if ( ( guncycle + 1 ) == numguncycles )
+			{
+				player maps/mp/gametypes/_wager::wagerannouncer( "wm_final_weapon" );
+			}
+			else
+			{
+				player maps/mp/gametypes/_wager::wagerannouncer( "wm_weapons_cycled" );
+			}
+			player checkawardmostpointsthiscycle();
+			i++;
+		}
+		if ( ispenultimateround )
+		{
+			level.sharpshootermultiplier = 2;
+			i = 0;
+			while ( i < level.players.size )
+			{
+				level.players[ i ] thread maps/mp/gametypes/_wager::queuewagerpopup( &"MP_SHRP_PENULTIMATE_RND", 0, &"MP_SHRP_PENULTIMATE_MULTIPLIER", "wm_bonus_rnd" );
+				i++;
+			}
+		}
+		else if ( issharpshooterround )
+		{
+			lastmultiplier = level.sharpshootermultiplier;
+			if ( !isDefined( lastmultiplier ) )
+			{
+				lastmultiplier = 1;
+			}
+			level.sharpshootermultiplier = 2;
+			setdvar( "ui_guncycle", 0 );
+			level.guncycletimer.alpha = 0;
+			i = 0;
+			while ( i < level.players.size )
+			{
+				level.players[ i ] thread maps/mp/gametypes/_wager::queuewagerpopup( &"MP_SHRP_RND", 0, &"MP_SHRP_FINAL_MULTIPLIER", "wm_shrp_rnd" );
+				i++;
+			}
+		}
+		else level.sharpshootermultiplier = 1;
+		guncycle++;
+	}
+}
+
+checkawardmostpointsthiscycle()
+{
+	if ( isDefined( self.currentguncyclepoints ) && self.currentguncyclepoints > 0 )
+	{
+		if ( self.currentguncyclepoints == level.currentguncyclemaxpoints )
+		{
+			maps/mp/_scoreevents::processscoreevent( "most_points_shrp", self );
+		}
+	}
+}
+
+awardmostpointsmedalgameend()
+{
+	level waittill( "game_end" );
+	i = 0;
+	while ( i < level.players.size )
+	{
+		level.players[ i ] checkawardmostpointsthiscycle();
+		i++;
+	}
+}
+
+givecustomloadout( takeallweapons, alreadyspawned )
+{
+	chooserandombody = 0;
+	if ( !isDefined( alreadyspawned ) || !alreadyspawned )
+	{
+		chooserandombody = 1;
+	}
+	self maps/mp/gametypes/_wager::setupblankrandomplayer( takeallweapons, chooserandombody, level.shrprandomweapon );
+	self disableweaponcycling();
+	self giveweapon( level.shrprandomweapon );
+	self switchtoweapon( level.shrprandomweapon );
+	self giveweapon( "knife_mp" );
+	if ( !isDefined( alreadyspawned ) || !alreadyspawned )
+	{
+		self setspawnweapon( level.shrprandomweapon );
+	}
+	if ( isDefined( takeallweapons ) && !takeallweapons )
+	{
+		self thread takeoldweapons();
+	}
+	else
+	{
+		self enableweaponcycling();
+	}
+	return level.shrprandomweapon;
+}
+
+takeoldweapons()
+{
+	self endon( "disconnect" );
+	self endon( "death" );
+	for ( ;; )
+	{
+		self waittill( "weapon_change", newweapon );
+		if ( newweapon != "none" )
+		{
+			break;
+		}
+		else
+		{
+		}
+	}
+	weaponslist = self getweaponslist();
+	i = 0;
+	while ( i < weaponslist.size )
+	{
+		if ( weaponslist[ i ] != level.shrprandomweapon && weaponslist[ i ] != "knife_mp" )
+		{
+			self takeweapon( weaponslist[ i ] );
+		}
+		i++;
+	}
+	self enableweaponcycling();
+}
+
+onplayerkilled( einflictor, attacker, idamage, smeansofdeath, sweapon, vdir, shitloc, psoffsettime, deathanimduration )
+{
+	if ( isDefined( attacker ) && isplayer( attacker ) && attacker != self )
+	{
+		if ( isDefined( level.sharpshootermultiplier ) && level.sharpshootermultiplier == 2 )
+		{
+			if ( !isDefined( attacker.pers[ "x2kills" ] ) )
+			{
+				attacker.pers[ "x2kills" ] = 1;
+			}
+			else
+			{
+				attacker.pers[ "x2kills" ]++;
+			}
+			attacker.x2kills = attacker.pers[ "x2kills" ];
+		}
+		else
+		{
+			if ( isDefined( level.sharpshootermultiplier ) && level.sharpshootermultiplier == 3 )
+			{
+				if ( !isDefined( attacker.pers[ "x3kills" ] ) )
+				{
+					attacker.pers[ "x3kills" ] = 1;
+				}
+				else
+				{
+					attacker.pers[ "x3kills" ]++;
+				}
+				attacker.x2kills = attacker.pers[ "x3kills" ];
+			}
+		}
+		if ( isDefined( self.scoremultiplier ) && self.scoremultiplier >= 2 )
+		{
+			maps/mp/_scoreevents::processscoreevent( "kill_x2_score_shrp", attacker, self, sweapon );
+		}
+		currentbonus = attacker.currentbonus;
+		if ( !isDefined( currentbonus ) )
+		{
+			currentbonus = 0;
+		}
+		if ( currentbonus < level.poweruplist.size )
+		{
+			attacker maps/mp/gametypes/_wager::givepowerup( level.poweruplist[ currentbonus ] );
+			attacker thread maps/mp/gametypes/_wager::wagerannouncer( "wm_bonus" + currentbonus );
+			if ( level.poweruplist[ currentbonus ].type == "score_multiplier" && attacker.scoremultiplier == 2 )
+			{
+				maps/mp/_scoreevents::processscoreevent( "x2_score_shrp", attacker, self, sweapon );
+			}
+			currentbonus++;
+			attacker.currentbonus = currentbonus;
+		}
+		if ( currentbonus >= level.poweruplist.size )
+		{
+			if ( isDefined( attacker.powerups ) && isDefined( attacker.powerups.size ) && attacker.powerups.size > 0 )
+			{
+				attacker thread maps/mp/gametypes/_wager::pulsepowerupicon( attacker.powerups.size - 1 );
+			}
+		}
+		scoremultiplier = 1;
+		if ( isDefined( attacker.scoremultiplier ) )
+		{
+			scoremultiplier = attacker.scoremultiplier;
+		}
+		if ( isDefined( level.sharpshootermultiplier ) )
+		{
+			scoremultiplier *= level.sharpshootermultiplier;
+		}
+		scoreincrease = attacker.pointstowin;
+		i = 1;
+		while ( i <= scoremultiplier )
+		{
+			if ( smeansofdeath == "MOD_MELEE" && level.shrprandomweapon != "knife_mp" && level.shrprandomweapon != "riotshield_mp" )
+			{
+				attacker maps/mp/gametypes/_globallogic_score::givepointstowin( level.pointspermeleekill );
+				if ( i != 1 )
+				{
+					maps/mp/_scoreevents::processscoreevent( "kill", attacker, self, sweapon );
+					maps/mp/_scoreevents::processscoreevent( "wager_melee_kill", attacker, self, sweapon );
+				}
+				i++;
+				continue;
+			}
+			else
+			{
+				attacker maps/mp/gametypes/_globallogic_score::givepointstowin( level.pointsperweaponkill );
+				if ( !isDefined( attacker.currentguncyclepoints ) )
+				{
+					attacker.currentguncyclepoints = 0;
+				}
+				attacker.currentguncyclepoints += level.pointsperweaponkill;
+				if ( level.currentguncyclemaxpoints < attacker.currentguncyclepoints )
+				{
+					level.currentguncyclemaxpoints = attacker.currentguncyclepoints;
+				}
+				if ( i != 1 )
+				{
+					maps/mp/_scoreevents::processscoreevent( "kill", attacker, self, sweapon );
+				}
+			}
+			i++;
+		}
+		scoreincrease = attacker.pointstowin - scoreincrease;
+		if ( scoremultiplier > 1 || isDefined( level.sharpshootermultiplier ) && level.sharpshootermultiplier > 1 )
+		{
+			attacker playlocalsound( "uin_alert_cash_register" );
+			attacker.pers[ "x2score" ] += scoreincrease;
+			attacker.x2score = attacker.pers[ "x2score" ];
+		}
+	}
+	self.currentbonus = 0;
+	self.scoremultiplier = 1;
+	self maps/mp/gametypes/_wager::clearpowerups();
+}
+
+onspawnplayerunified()
+{
+	maps/mp/gametypes/_spawning::onspawnplayer_unified();
+	self thread infiniteammo();
+}
+
+onspawnplayer( predictedspawn )
+{
+	spawnpoints = maps/mp/gametypes/_spawnlogic::getteamspawnpoints( self.pers[ "team" ] );
+	spawnpoint = maps/mp/gametypes/_spawnlogic::getspawnpoint_dm( spawnpoints );
+	if ( predictedspawn )
+	{
+		self predictspawnpoint( spawnpoint.origin, spawnpoint.angles );
+	}
+	else
+	{
+		self spawn( spawnpoint.origin, spawnpoint.angles, "shrp" );
+		self thread infiniteammo();
+	}
+}
+
+infiniteammo()
+{
+	self endon( "death" );
+	self endon( "disconnect" );
+	for ( ;; )
+	{
+		wait 0,1;
+		weapon = self getcurrentweapon();
+		self givemaxammo( weapon );
+	}
+}
+
+onwagerawards()
+{
+	x2kills = self maps/mp/gametypes/_globallogic_score::getpersstat( "x2kills" );
+	if ( !isDefined( x2kills ) )
+	{
+		x2kills = 0;
+	}
+	self maps/mp/gametypes/_persistence::setafteractionreportstat( "wagerAwards", x2kills, 0 );
+	headshots = self maps/mp/gametypes/_globallogic_score::getpersstat( "headshots" );
+	if ( !isDefined( headshots ) )
+	{
+		headshots = 0;
+	}
+	self maps/mp/gametypes/_persistence::setafteractionreportstat( "wagerAwards", headshots, 1 );
+	bestkillstreak = self maps/mp/gametypes/_globallogic_score::getpersstat( "best_kill_streak" );
+	if ( !isDefined( bestkillstreak ) )
+	{
+		bestkillstreak = 0;
+	}
+	self maps/mp/gametypes/_persistence::setafteractionreportstat( "wagerAwards", bestkillstreak, 2 );
+}
+
+clearpowerupsongameend()
+{
+	level waittill( "game_ended" );
+	i = 0;
+	while ( i < level.players.size )
+	{
+		player = level.players[ i ];
+		player maps/mp/gametypes/_wager::clearpowerups();
+		i++;
+	}
+}

patch_mp/maps/mp/gametypes/tdm.gsc

@@ -0,0 +1,300 @@
+#include maps/mp/gametypes/_globallogic_audio;
+#include maps/mp/gametypes/_globallogic_score;
+#include maps/mp/gametypes/_spawnlogic;
+#include maps/mp/gametypes/_spawning;
+#include maps/mp/gametypes/_hud_util;
+#include maps/mp/_utility;
+
+main()
+{
+	if ( getDvar( "mapname" ) == "mp_background" )
+	{
+		return;
+	}
+	maps/mp/gametypes/_globallogic::init();
+	maps/mp/gametypes/_callbacksetup::setupcallbacks();
+	maps/mp/gametypes/_globallogic::setupcallbacks();
+	registerroundswitch( 0, 9 );
+	registertimelimit( 0, 1440 );
+	registerscorelimit( 0, 50000 );
+	registerroundlimit( 0, 10 );
+	registerroundwinlimit( 0, 10 );
+	registernumlives( 0, 100 );
+	maps/mp/gametypes/_globallogic::registerfriendlyfiredelay( level.gametype, 15, 0, 1440 );
+	level.scoreroundbased = getgametypesetting( "roundscorecarry" ) == 0;
+	level.teamscoreperkill = getgametypesetting( "teamScorePerKill" );
+	level.teamscoreperdeath = getgametypesetting( "teamScorePerDeath" );
+	level.teamscoreperheadshot = getgametypesetting( "teamScorePerHeadshot" );
+	level.teambased = 1;
+	level.overrideteamscore = 1;
+	level.onstartgametype = ::onstartgametype;
+	level.onspawnplayer = ::onspawnplayer;
+	level.onspawnplayerunified = ::onspawnplayerunified;
+	level.onroundendgame = ::onroundendgame;
+	level.onroundswitch = ::onroundswitch;
+	level.onplayerkilled = ::onplayerkilled;
+	game[ "dialog" ][ "gametype" ] = "tdm_start";
+	game[ "dialog" ][ "gametype_hardcore" ] = "hctdm_start";
+	game[ "dialog" ][ "offense_obj" ] = "generic_boost";
+	game[ "dialog" ][ "defense_obj" ] = "generic_boost";
+	setscoreboardcolumns( "score", "kills", "deaths", "kdratio", "assists" );
+}
+
+onstartgametype()
+{
+	setclientnamemode( "auto_change" );
+	if ( !isDefined( game[ "switchedsides" ] ) )
+	{
+		game[ "switchedsides" ] = 0;
+	}
+	if ( game[ "switchedsides" ] )
+	{
+		oldattackers = game[ "attackers" ];
+		olddefenders = game[ "defenders" ];
+		game[ "attackers" ] = olddefenders;
+		game[ "defenders" ] = oldattackers;
+	}
+	allowed[ 0 ] = "tdm";
+	level.displayroundendtext = 0;
+	maps/mp/gametypes/_gameobjects::main( allowed );
+	maps/mp/gametypes/_spawning::create_map_placed_influencers();
+	level.spawnmins = ( 0, 0, 0 );
+	level.spawnmaxs = ( 0, 0, 0 );
+	_a135 = level.teams;
+	_k135 = getFirstArrayKey( _a135 );
+	while ( isDefined( _k135 ) )
+	{
+		team = _a135[ _k135 ];
+		setobjectivetext( team, &"OBJECTIVES_TDM" );
+		setobjectivehinttext( team, &"OBJECTIVES_TDM_HINT" );
+		if ( level.splitscreen )
+		{
+			setobjectivescoretext( team, &"OBJECTIVES_TDM" );
+		}
+		else
+		{
+			setobjectivescoretext( team, &"OBJECTIVES_TDM_SCORE" );
+		}
+		maps/mp/gametypes/_spawnlogic::addspawnpoints( team, "mp_tdm_spawn" );
+		maps/mp/gametypes/_spawnlogic::placespawnpoints( maps/mp/gametypes/_spawning::gettdmstartspawnname( team ) );
+		_k135 = getNextArrayKey( _a135, _k135 );
+	}
+	maps/mp/gametypes/_spawning::updateallspawnpoints();
+/#
+	level.spawn_start = [];
+	_a161 = level.teams;
+	_k161 = getFirstArrayKey( _a161 );
+	while ( isDefined( _k161 ) )
+	{
+		team = _a161[ _k161 ];
+		level.spawn_start[ team ] = maps/mp/gametypes/_spawnlogic::getspawnpointarray( maps/mp/gametypes/_spawning::gettdmstartspawnname( team ) );
+		_k161 = getNextArrayKey( _a161, _k161 );
+#/
+	}
+	level.mapcenter = maps/mp/gametypes/_spawnlogic::findboxcenter( level.spawnmins, level.spawnmaxs );
+	setmapcenter( level.mapcenter );
+	spawnpoint = maps/mp/gametypes/_spawnlogic::getrandomintermissionpoint();
+	setdemointermissionpoint( spawnpoint.origin, spawnpoint.angles );
+	if ( !isoneround() )
+	{
+		level.displayroundendtext = 1;
+		if ( isscoreroundbased() )
+		{
+			maps/mp/gametypes/_globallogic_score::resetteamscores();
+		}
+	}
+}
+
+onspawnplayerunified( question )
+{
+	self.usingobj = undefined;
+	if ( level.usestartspawns && !level.ingraceperiod && !level.playerqueuedrespawn )
+	{
+		level.usestartspawns = 0;
+	}
+	spawnteam = self.pers[ "team" ];
+	if ( game[ "switchedsides" ] )
+	{
+		spawnteam = getotherteam( spawnteam );
+	}
+	if ( isDefined( question ) )
+	{
+		question = 1;
+	}
+	if ( isDefined( question ) )
+	{
+		question = -1;
+	}
+	if ( isDefined( spawnteam ) )
+	{
+		spawnteam = spawnteam;
+	}
+	if ( !isDefined( spawnteam ) )
+	{
+		spawnteam = -1;
+	}
+	maps/mp/gametypes/_spawning::onspawnplayer_unified();
+}
+
+onspawnplayer( predictedspawn, question )
+{
+	pixbeginevent( "TDM:onSpawnPlayer" );
+	self.usingobj = undefined;
+	if ( isDefined( question ) )
+	{
+		question = 1;
+	}
+	if ( isDefined( question ) )
+	{
+		question = -1;
+	}
+	spawnteam = self.pers[ "team" ];
+	if ( isDefined( spawnteam ) )
+	{
+		spawnteam = spawnteam;
+	}
+	if ( !isDefined( spawnteam ) )
+	{
+		spawnteam = -1;
+	}
+	if ( level.ingraceperiod )
+	{
+		spawnpoints = maps/mp/gametypes/_spawnlogic::getspawnpointarray( maps/mp/gametypes/_spawning::gettdmstartspawnname( spawnteam ) );
+		if ( !spawnpoints.size )
+		{
+			spawnpoints = maps/mp/gametypes/_spawnlogic::getspawnpointarray( maps/mp/gametypes/_spawning::getteamstartspawnname( spawnteam, "mp_sab_spawn" ) );
+		}
+		if ( !spawnpoints.size )
+		{
+			if ( game[ "switchedsides" ] )
+			{
+				spawnteam = getotherteam( spawnteam );
+			}
+			spawnpoints = maps/mp/gametypes/_spawnlogic::getteamspawnpoints( spawnteam );
+			spawnpoint = maps/mp/gametypes/_spawnlogic::getspawnpoint_nearteam( spawnpoints );
+		}
+		else
+		{
+			spawnpoint = maps/mp/gametypes/_spawnlogic::getspawnpoint_random( spawnpoints );
+		}
+	}
+	else
+	{
+		if ( game[ "switchedsides" ] )
+		{
+			spawnteam = getotherteam( spawnteam );
+		}
+		spawnpoints = maps/mp/gametypes/_spawnlogic::getteamspawnpoints( spawnteam );
+		spawnpoint = maps/mp/gametypes/_spawnlogic::getspawnpoint_nearteam( spawnpoints );
+	}
+	if ( predictedspawn )
+	{
+		self predictspawnpoint( spawnpoint.origin, spawnpoint.angles );
+	}
+	else
+	{
+		self spawn( spawnpoint.origin, spawnpoint.angles, "tdm" );
+	}
+	pixendevent();
+}
+
+onendgame( winningteam )
+{
+	if ( isDefined( winningteam ) && isDefined( level.teams[ winningteam ] ) )
+	{
+		maps/mp/gametypes/_globallogic_score::giveteamscoreforobjective( winningteam, 1 );
+	}
+}
+
+onroundswitch()
+{
+	game[ "switchedsides" ] = !game[ "switchedsides" ];
+	while ( level.roundscorecarry == 0 )
+	{
+		_a288 = level.teams;
+		_k288 = getFirstArrayKey( _a288 );
+		while ( isDefined( _k288 ) )
+		{
+			team = _a288[ _k288 ];
+			[[ level._setteamscore ]]( team, game[ "roundswon" ][ team ] );
+			_k288 = getNextArrayKey( _a288, _k288 );
+		}
+	}
+}
+
+onroundendgame( roundwinner )
+{
+	if ( level.roundscorecarry == 0 )
+	{
+		_a299 = level.teams;
+		_k299 = getFirstArrayKey( _a299 );
+		while ( isDefined( _k299 ) )
+		{
+			team = _a299[ _k299 ];
+			[[ level._setteamscore ]]( team, game[ "roundswon" ][ team ] );
+			_k299 = getNextArrayKey( _a299, _k299 );
+		}
+		winner = maps/mp/gametypes/_globallogic::determineteamwinnerbygamestat( "roundswon" );
+	}
+	else
+	{
+		winner = maps/mp/gametypes/_globallogic::determineteamwinnerbyteamscore();
+	}
+	return winner;
+}
+
+onscoreclosemusic()
+{
+	teamscores = [];
+	while ( !level.gameended )
+	{
+		scorelimit = level.scorelimit;
+		scorethreshold = scorelimit * 0,1;
+		scorethresholdstart = abs( scorelimit - scorethreshold );
+		scorelimitcheck = scorelimit - 10;
+		topscore = 0;
+		runnerupscore = 0;
+		_a327 = level.teams;
+		_k327 = getFirstArrayKey( _a327 );
+		while ( isDefined( _k327 ) )
+		{
+			team = _a327[ _k327 ];
+			score = [[ level._getteamscore ]]( team );
+			if ( score > topscore )
+			{
+				runnerupscore = topscore;
+				topscore = score;
+			}
+			else
+			{
+				if ( score > runnerupscore )
+				{
+					runnerupscore = score;
+				}
+			}
+			_k327 = getNextArrayKey( _a327, _k327 );
+		}
+		scoredif = topscore - runnerupscore;
+		if ( scoredif <= scorethreshold && scorethresholdstart <= topscore )
+		{
+			thread maps/mp/gametypes/_globallogic_audio::set_music_on_team( "TIME_OUT", "both" );
+			thread maps/mp/gametypes/_globallogic_audio::actionmusicset();
+			return;
+		}
+		wait 1;
+	}
+}
+
+onplayerkilled( einflictor, attacker, idamage, smeansofdeath, sweapon, vdir, shitloc, psoffsettime, deathanimduration )
+{
+	if ( isplayer( attacker ) == 0 || attacker.team == self.team )
+	{
+		return;
+	}
+	attacker maps/mp/gametypes/_globallogic_score::giveteamscoreforobjective( attacker.team, level.teamscoreperkill );
+	self maps/mp/gametypes/_globallogic_score::giveteamscoreforobjective( self.team, level.teamscoreperdeath * -1 );
+	if ( smeansofdeath == "MOD_HEAD_SHOT" )
+	{
+		attacker maps/mp/gametypes/_globallogic_score::giveteamscoreforobjective( attacker.team, level.teamscoreperheadshot );
+	}
+}

patch_mp/readme.md

@@ -0,0 +1,86 @@
+### The following gscs compile and run successfully with no known errors:
+```
+patch_mp/maps/mp/gametypes/_clientids.gsc
+patch_mp/maps/mp/gametypes/_globalentities.gsc
+patch_mp/maps/mp/gametypes/_scoreboard.gsc
+patch_mp/maps/mp/gametypes/_shellshock.gsc
+```
+### The following scripts compile and run successfully with minor errors:
+```
+```
+### The following scripts compile and run successfully with major errors:
+```
+```
+### The following scripts compile and run serverside but clients cannot join due to exe_client_field_mismatch
+```
+```
+### The following scripts compile but cause a minidump or other severe error:
+```
+```
+### The following scripts have been checked, but they have not been tested yet
+```
+```
+### The following scripts are not checked yet, uploaded to setup a baseline:
+```
+patch_mp/maps/mp/gametypes/_battlechatter.gsc
+patch_mp/maps/mp/gametypes/_callbacksetup.gsc
+patch_mp/maps/mp/gametypes/_class.gsc
+patch_mp/maps/mp/gametypes/_copter.gsc
+patch_mp/maps/mp/gametypes/_damagefeedback.gsc
+patch_mp/maps/mp/gametypes/_deathicons.gsc
+patch_mp/maps/mp/gametypes/_dev.gsc
+patch_mp/maps/mp/gametypes/_dev_class.gsc
+patch_mp/maps/mp/gametypes/_friendicons.gsc
+patch_mp/maps/mp/gametypes/_gameobjects.gsc
+patch_mp/maps/mp/gametypes/_globallogic.gsc
+patch_mp/maps/mp/gametypes/_globallogic_actor.gsc
+patch_mp/maps/mp/gametypes/_globallogic_audio.gsc
+patch_mp/maps/mp/gametypes/_globallogic_defaults.gsc
+patch_mp/maps/mp/gametypes/_globallogic_player.gsc
+patch_mp/maps/mp/gametypes/_globallogic_score.gsc
+patch_mp/maps/mp/gametypes/_globallogic_spawn.gsc
+patch_mp/maps/mp/gametypes/_globallogic_ui.gsc
+patch_mp/maps/mp/gametypes/_globallogic_utils.gsc
+patch_mp/maps/mp/gametypes/_globallogic_vehicle.gsc
+patch_mp/maps/mp/gametypes/_gv_actions.gsc
+patch_mp/maps/mp/gametypes/_healthoverlay.gsc
+patch_mp/maps/mp/gametypes/_hostmigration.gsc
+patch_mp/maps/mp/gametypes/_hud.gsc
+patch_mp/maps/mp/gametypes/_hud_message.gsc
+patch_mp/maps/mp/gametypes/_hud_util.gsc
+patch_mp/maps/mp/gametypes/_killcam.gsc
+patch_mp/maps/mp/gametypes/_menus.gsc
+patch_mp/maps/mp/gametypes/_objpoints.gsc
+patch_mp/maps/mp/gametypes/_perplayer.gsc
+patch_mp/maps/mp/gametypes/_persistence.gsc
+patch_mp/maps/mp/gametypes/_pregame.gsc
+patch_mp/maps/mp/gametypes/_rank.gsc
+patch_mp/maps/mp/gametypes/_serversettings.gsc
+patch_mp/maps/mp/gametypes/_spawning.gsc
+patch_mp/maps/mp/gametypes/_spawnlogic.gsc
+patch_mp/maps/mp/gametypes/_spectating.gsc
+patch_mp/maps/mp/gametypes/_tweakables.gsc
+patch_mp/maps/mp/gametypes/_wager.gsc
+patch_mp/maps/mp/gametypes/_weapon_utils.gsc
+patch_mp/maps/mp/gametypes/_weaponobjects.gsc
+patch_mp/maps/mp/gametypes/_weapons.gsc
+patch_mp/maps/mp/gametypes/conf.gsc
+patch_mp/maps/mp/gametypes/ctf.gsc
+patch_mp/maps/mp/gametypes/dem.gsc
+patch_mp/maps/mp/gametypes/dm.gsc
+patch_mp/maps/mp/gametypes/dom.gsc
+patch_mp/maps/mp/gametypes/gun.gsc
+patch_mp/maps/mp/gametypes/hq.gsc
+patch_mp/maps/mp/gametypes/koth.gsc
+patch_mp/maps/mp/gametypes/oic.gsc
+patch_mp/maps/mp/gametypes/oneflag.gsc
+patch_mp/maps/mp/gametypes/sas.gsc
+patch_mp/maps/mp/gametypes/sd.gsc
+patch_mp/maps/mp/gametypes/shrp.gsc
+patch_mp/maps/mp/gametypes/tdm.gsc
+```
+### notes:
+```
+```
+
+