uploading 119 patch_mp scripts and 23 patch_zm scripts as a baseline

patch_mp/codescripts/character_mp.gsc

@@ -0,0 +1,21 @@
+#include codescripts/character;
+
+setmodelfromarray( a )
+{
+	self setmodel( a[ randomint( a.size ) ] );
+}
+
+precachemodelarray( a )
+{
+	i = 0;
+	while ( i < a.size )
+	{
+		precachemodel( a[ i ] );
+		i++;
+	}
+}
+
+attachfromarray( a )
+{
+	self attach( codescripts/character::randomelement( a ), "", 1 );
+}

patch_mp/codescripts/delete.gsc

@@ -0,0 +1,23 @@
+
+main()
+{
+/#
+	assert( isDefined( self ) );
+#/
+	wait 0;
+	if ( isDefined( self ) )
+	{
+/#
+		if ( isDefined( self.classname ) )
+		{
+			if ( self.classname != "trigger_once" || self.classname == "trigger_radius" && self.classname == "trigger_multiple" )
+			{
+				println( "" );
+				println( "*** trigger debug: delete.gsc is deleting trigger with ent#: " + self getentitynumber() + " at origin: " + self.origin );
+				println( "" );
+#/
+			}
+		}
+		self delete();
+	}
+}

patch_mp/codescripts/struct.gsc

@@ -0,0 +1,41 @@
+
+initstructs()
+{
+	level.struct = [];
+}
+
+createstruct()
+{
+	struct = spawnstruct();
+	level.struct[ level.struct.size ] = struct;
+	return struct;
+}
+
+findstruct( position )
+{
+	_a20 = level.struct_class_names;
+	key = getFirstArrayKey( _a20 );
+	while ( isDefined( key ) )
+	{
+		_ = _a20[ key ];
+		_a22 = level.struct_class_names[ key ];
+		val = getFirstArrayKey( _a22 );
+		while ( isDefined( val ) )
+		{
+			s_array = _a22[ val ];
+			_a24 = s_array;
+			_k24 = getFirstArrayKey( _a24 );
+			while ( isDefined( _k24 ) )
+			{
+				struct = _a24[ _k24 ];
+				if ( distancesquared( struct.origin, position ) < 1 )
+				{
+					return struct;
+				}
+				_k24 = getNextArrayKey( _a24, _k24 );
+			}
+			val = getNextArrayKey( _a22, val );
+		}
+		key = getNextArrayKey( _a20, key );
+	}
+}

patch_mp/maps/mp/_acousticsensor.gsc

@@ -0,0 +1,165 @@
+#include maps/mp/gametypes/_damagefeedback;
+#include maps/mp/gametypes/_globallogic_player;
+#include maps/mp/_scoreevents;
+#include maps/mp/_challenges;
+#include maps/mp/killstreaks/_emp;
+#include maps/mp/_utility;
+#include maps/mp/gametypes/_weaponobjects;
+#include common_scripts/utility;
+
+init()
+{
+	level._effect[ "acousticsensor_enemy_light" ] = loadfx( "misc/fx_equip_light_red" );
+	level._effect[ "acousticsensor_friendly_light" ] = loadfx( "misc/fx_equip_light_green" );
+}
+
+createacousticsensorwatcher()
+{
+	watcher = self maps/mp/gametypes/_weaponobjects::createuseweaponobjectwatcher( "acoustic_sensor", "acoustic_sensor_mp", self.team );
+	watcher.onspawn = ::onspawnacousticsensor;
+	watcher.detonate = ::acousticsensordetonate;
+	watcher.stun = ::maps/mp/gametypes/_weaponobjects::weaponstun;
+	watcher.stuntime = 5;
+	watcher.reconmodel = "t5_weapon_acoustic_sensor_world_detect";
+	watcher.hackable = 1;
+	watcher.ondamage = ::watchacousticsensordamage;
+}
+
+onspawnacousticsensor( watcher, player )
+{
+	self endon( "death" );
+	self thread maps/mp/gametypes/_weaponobjects::onspawnuseweaponobject( watcher, player );
+	player.acousticsensor = self;
+	self setowner( player );
+	self setteam( player.team );
+	self.owner = player;
+	self playloopsound( "fly_acoustic_sensor_lp" );
+	if ( !self maps/mp/_utility::ishacked() )
+	{
+		player addweaponstat( "acoustic_sensor_mp", "used", 1 );
+	}
+	self thread watchshutdown( player, self.origin );
+}
+
+acousticsensordetonate( attacker, weaponname )
+{
+	from_emp = maps/mp/killstreaks/_emp::isempweapon( weaponname );
+	if ( !from_emp )
+	{
+		playfx( level._equipment_explode_fx, self.origin );
+	}
+	if ( isDefined( attacker ) )
+	{
+		if ( self.owner isenemyplayer( attacker ) )
+		{
+			attacker maps/mp/_challenges::destroyedequipment( weaponname );
+			maps/mp/_scoreevents::processscoreevent( "destroyed_motion_sensor", attacker, self.owner, weaponname );
+		}
+	}
+	playsoundatposition( "dst_equipment_destroy", self.origin );
+	self destroyent();
+}
+
+destroyent()
+{
+	self delete();
+}
+
+watchshutdown( player, origin )
+{
+	self waittill_any( "death", "hacked" );
+	if ( isDefined( player ) )
+	{
+		player.acousticsensor = undefined;
+	}
+}
+
+watchacousticsensordamage( watcher )
+{
+	self endon( "death" );
+	self endon( "hacked" );
+	self setcandamage( 1 );
+	damagemax = 100;
+	if ( !self maps/mp/_utility::ishacked() )
+	{
+		self.damagetaken = 0;
+	}
+	for ( ;; )
+	{
+		while ( 1 )
+		{
+			self.maxhealth = 100000;
+			self.health = self.maxhealth;
+			self waittill( "damage", damage, attacker, direction, point, type, tagname, modelname, partname, weaponname, idflags );
+			if ( !isDefined( attacker ) || !isplayer( attacker ) )
+			{
+				continue;
+			}
+			while ( level.teambased && attacker.team == self.owner.team && attacker != self.owner )
+			{
+				continue;
+			}
+			if ( isDefined( weaponname ) )
+			{
+				switch( weaponname )
+				{
+					case "concussion_grenade_mp":
+					case "flash_grenade_mp":
+						if ( watcher.stuntime > 0 )
+						{
+							self thread maps/mp/gametypes/_weaponobjects::stunstart( watcher, watcher.stuntime );
+						}
+						if ( level.teambased && self.owner.team != attacker.team )
+						{
+							if ( maps/mp/gametypes/_globallogic_player::dodamagefeedback( weaponname, attacker ) )
+							{
+								attacker maps/mp/gametypes/_damagefeedback::updatedamagefeedback();
+							}
+							continue;
+						}
+						else
+						{
+							if ( !level.teambased && self.owner != attacker )
+							{
+								if ( maps/mp/gametypes/_globallogic_player::dodamagefeedback( weaponname, attacker ) )
+								{
+									attacker maps/mp/gametypes/_damagefeedback::updatedamagefeedback();
+								}
+							}
+						}
+					}
+					case "emp_grenade_mp":
+						damage = damagemax;
+						default:
+							if ( maps/mp/gametypes/_globallogic_player::dodamagefeedback( weaponname, attacker ) )
+							{
+								attacker maps/mp/gametypes/_damagefeedback::updatedamagefeedback();
+							}
+							break;
+					}
+				}
+				else
+				{
+					weaponname = "";
+				}
+				while ( isplayer( attacker ) && level.teambased && isDefined( attacker.team ) && self.owner.team == attacker.team && attacker != self.owner )
+				{
+					continue;
+				}
+				if ( type == "MOD_MELEE" )
+				{
+					self.damagetaken = damagemax;
+				}
+				else
+				{
+					self.damagetaken += damage;
+				}
+				if ( self.damagetaken >= damagemax )
+				{
+					watcher thread maps/mp/gametypes/_weaponobjects::waitanddetonate( self, 0, attacker, weaponname );
+					return;
+				}
+			}
+		}
+	}
+}

patch_mp/maps/mp/_art.gsc

@@ -0,0 +1,497 @@
+#include maps/mp/_utility;
+#include common_scripts/utility;
+
+main()
+{
+/#
+	if ( getDvar( "scr_art_tweak" ) == "" || getDvar( "scr_art_tweak" ) == "0" )
+	{
+		setdvar( "scr_art_tweak", 0 );
+	}
+	if ( getDvar( "scr_dof_enable" ) == "" )
+	{
+		setdvar( "scr_dof_enable", "1" );
+	}
+	if ( getDvar( "scr_cinematic_autofocus" ) == "" )
+	{
+		setdvar( "scr_cinematic_autofocus", "1" );
+	}
+	if ( getDvar( "scr_art_visionfile" ) == "" && isDefined( level.script ) )
+	{
+		setdvar( "scr_art_visionfile", level.script );
+	}
+	if ( getDvar( "debug_reflection" ) == "" )
+	{
+		setdvar( "debug_reflection", "0" );
+	}
+	if ( getDvar( "debug_reflection_matte" ) == "" )
+	{
+		setdvar( "debug_reflection_matte", "0" );
+	}
+	if ( getDvar( "debug_color_pallete" ) == "" )
+	{
+		setdvar( "debug_color_pallete", "0" );
+	}
+	precachemodel( "test_sphere_lambert" );
+	precachemodel( "test_macbeth_chart" );
+	precachemodel( "test_macbeth_chart_unlit" );
+	precachemodel( "test_sphere_silver" );
+	level thread debug_reflection();
+	level thread debug_reflection_matte();
+	level thread debug_color_pallete();
+#/
+	if ( !isDefined( level.dofdefault ) )
+	{
+		level.dofdefault[ "nearStart" ] = 0;
+		level.dofdefault[ "nearEnd" ] = 1;
+		level.dofdefault[ "farStart" ] = 8000;
+		level.dofdefault[ "farEnd" ] = 10000;
+		level.dofdefault[ "nearBlur" ] = 6;
+		level.dofdefault[ "farBlur" ] = 0;
+	}
+	level.curdof = ( level.dofdefault[ "farStart" ] - level.dofdefault[ "nearEnd" ] ) / 2;
+/#
+	thread tweakart();
+#/
+	if ( !isDefined( level.script ) )
+	{
+		level.script = tolower( getDvar( "mapname" ) );
+	}
+}
+
+artfxprintln( file, string )
+{
+/#
+	if ( file == -1 )
+	{
+		return;
+	}
+	fprintln( file, string );
+#/
+}
+
+strtok_loc( string, par1 )
+{
+	stringlist = [];
+	indexstring = "";
+	i = 0;
+	while ( i < string.size )
+	{
+		if ( string[ i ] == " " )
+		{
+			stringlist[ stringlist.size ] = indexstring;
+			indexstring = "";
+			i++;
+			continue;
+		}
+		else
+		{
+			indexstring += string[ i ];
+		}
+		i++;
+	}
+	if ( indexstring.size )
+	{
+		stringlist[ stringlist.size ] = indexstring;
+	}
+	return stringlist;
+}
+
+setfogsliders()
+{
+	fogall = strtok_loc( getDvar( "g_fogColorReadOnly" ), " " );
+	red = fogall[ 0 ];
+	green = fogall[ 1 ];
+	blue = fogall[ 2 ];
+	halfplane = getDvar( "g_fogHalfDistReadOnly" );
+	nearplane = getDvar( "g_fogStartDistReadOnly" );
+	if ( isDefined( red ) && isDefined( green ) || !isDefined( blue ) && !isDefined( halfplane ) )
+	{
+		red = 1;
+		green = 1;
+		blue = 1;
+		halfplane = 10000001;
+		nearplane = 10000000;
+	}
+	setdvar( "scr_fog_exp_halfplane", halfplane );
+	setdvar( "scr_fog_nearplane", nearplane );
+	setdvar( "scr_fog_color", ( red + " " ) + green + " " + blue );
+}
+
+tweakart()
+{
+/#
+	if ( !isDefined( level.tweakfile ) )
+	{
+		level.tweakfile = 0;
+	}
+	if ( getDvar( "scr_fog_baseheight" ) == "" )
+	{
+		setdvar( "scr_fog_exp_halfplane", "500" );
+		setdvar( "scr_fog_exp_halfheight", "500" );
+		setdvar( "scr_fog_nearplane", "0" );
+		setdvar( "scr_fog_baseheight", "0" );
+	}
+	setdvar( "scr_fog_fraction", "1.0" );
+	setdvar( "scr_art_dump", "0" );
+	setdvar( "scr_art_sun_fog_dir_set", "0" );
+	setdvar( "scr_dof_nearStart", level.dofdefault[ "nearStart" ] );
+	setdvar( "scr_dof_nearEnd", level.dofdefault[ "nearEnd" ] );
+	setdvar( "scr_dof_farStart", level.dofdefault[ "farStart" ] );
+	setdvar( "scr_dof_farEnd", level.dofdefault[ "farEnd" ] );
+	setdvar( "scr_dof_nearBlur", level.dofdefault[ "nearBlur" ] );
+	setdvar( "scr_dof_farBlur", level.dofdefault[ "farBlur" ] );
+	file = undefined;
+	filename = undefined;
+	tweak_toggle = 1;
+	for ( ;; )
+	{
+		while ( getDvarInt( "scr_art_tweak" ) == 0 )
+		{
+			tweak_toggle = 1;
+			wait 0,05;
+		}
+		if ( tweak_toggle )
+		{
+			tweak_toggle = 0;
+			fogsettings = getfogsettings();
+			setdvar( "scr_fog_nearplane", fogsettings[ 0 ] );
+			setdvar( "scr_fog_exp_halfplane", fogsettings[ 1 ] );
+			setdvar( "scr_fog_exp_halfheight", fogsettings[ 3 ] );
+			setdvar( "scr_fog_baseheight", fogsettings[ 2 ] );
+			setdvar( "scr_fog_color", fogsettings[ 4 ] + " " + fogsettings[ 5 ] + " " + fogsettings[ 6 ] );
+			setdvar( "scr_fog_color_scale", fogsettings[ 7 ] );
+			setdvar( "scr_sun_fog_color", fogsettings[ 8 ] + " " + fogsettings[ 9 ] + " " + fogsettings[ 10 ] );
+			level.fogsundir = [];
+			level.fogsundir[ 0 ] = fogsettings[ 11 ];
+			level.fogsundir[ 1 ] = fogsettings[ 12 ];
+			level.fogsundir[ 2 ] = fogsettings[ 13 ];
+			setdvar( "scr_sun_fog_start_angle", fogsettings[ 14 ] );
+			setdvar( "scr_sun_fog_end_angle", fogsettings[ 15 ] );
+			setdvar( "scr_fog_max_opacity", fogsettings[ 16 ] );
+		}
+		level.fogexphalfplane = getDvarFloat( "scr_fog_exp_halfplane" );
+		level.fogexphalfheight = getDvarFloat( "scr_fog_exp_halfheight" );
+		level.fognearplane = getDvarFloat( "scr_fog_nearplane" );
+		level.fogbaseheight = getDvarFloat( "scr_fog_baseheight" );
+		level.fogcolorred = getDvarColorRed( "scr_fog_color" );
+		level.fogcolorgreen = getDvarColorGreen( "scr_fog_color" );
+		level.fogcolorblue = getDvarColorBlue( "scr_fog_color" );
+		level.fogcolorscale = getDvarFloat( "scr_fog_color_scale" );
+		level.sunfogcolorred = getDvarColorRed( "scr_sun_fog_color" );
+		level.sunfogcolorgreen = getDvarColorGreen( "scr_sun_fog_color" );
+		level.sunfogcolorblue = getDvarColorBlue( "scr_sun_fog_color" );
+		level.sunstartangle = getDvarFloat( "scr_sun_fog_start_angle" );
+		level.sunendangle = getDvarFloat( "scr_sun_fog_end_angle" );
+		level.fogmaxopacity = getDvarFloat( "scr_fog_max_opacity" );
+		if ( getDvarInt( "scr_art_sun_fog_dir_set" ) )
+		{
+			setdvar( "scr_art_sun_fog_dir_set", "0" );
+			println( "Setting sun fog direction to facing of player" );
+			players = get_players();
+			dir = vectornormalize( anglesToForward( players[ 0 ] getplayerangles() ) );
+			level.fogsundir = [];
+			level.fogsundir[ 0 ] = dir[ 0 ];
+			level.fogsundir[ 1 ] = dir[ 1 ];
+			level.fogsundir[ 2 ] = dir[ 2 ];
+		}
+		fovslidercheck();
+		dumpsettings();
+		if ( !getDvarInt( "scr_fog_disable" ) )
+		{
+			if ( !isDefined( level.fogsundir ) )
+			{
+				level.fogsundir = [];
+				level.fogsundir[ 0 ] = 1;
+				level.fogsundir[ 1 ] = 0;
+				level.fogsundir[ 2 ] = 0;
+			}
+			setvolfog( level.fognearplane, level.fogexphalfplane, level.fogexphalfheight, level.fogbaseheight, level.fogcolorred, level.fogcolorgreen, level.fogcolorblue, level.fogcolorscale, level.sunfogcolorred, level.sunfogcolorgreen, level.sunfogcolorblue, level.fogsundir[ 0 ], level.fogsundir[ 1 ], level.fogsundir[ 2 ], level.sunstartangle, level.sunendangle, 0, level.fogmaxopacity );
+		}
+		else
+		{
+			setexpfog( 100000000, 100000001, 0, 0, 0, 0 );
+		}
+		wait 0,1;
+#/
+	}
+}
+
+fovslidercheck()
+{
+	if ( level.dofdefault[ "nearStart" ] >= level.dofdefault[ "nearEnd" ] )
+	{
+		level.dofdefault[ "nearStart" ] = level.dofdefault[ "nearEnd" ] - 1;
+		setdvar( "scr_dof_nearStart", level.dofdefault[ "nearStart" ] );
+	}
+	if ( level.dofdefault[ "nearEnd" ] <= level.dofdefault[ "nearStart" ] )
+	{
+		level.dofdefault[ "nearEnd" ] = level.dofdefault[ "nearStart" ] + 1;
+		setdvar( "scr_dof_nearEnd", level.dofdefault[ "nearEnd" ] );
+	}
+	if ( level.dofdefault[ "farStart" ] >= level.dofdefault[ "farEnd" ] )
+	{
+		level.dofdefault[ "farStart" ] = level.dofdefault[ "farEnd" ] - 1;
+		setdvar( "scr_dof_farStart", level.dofdefault[ "farStart" ] );
+	}
+	if ( level.dofdefault[ "farEnd" ] <= level.dofdefault[ "farStart" ] )
+	{
+		level.dofdefault[ "farEnd" ] = level.dofdefault[ "farStart" ] + 1;
+		setdvar( "scr_dof_farEnd", level.dofdefault[ "farEnd" ] );
+	}
+	if ( level.dofdefault[ "farBlur" ] >= level.dofdefault[ "nearBlur" ] )
+	{
+		level.dofdefault[ "farBlur" ] = level.dofdefault[ "nearBlur" ] - 0,1;
+		setdvar( "scr_dof_farBlur", level.dofdefault[ "farBlur" ] );
+	}
+	if ( level.dofdefault[ "farStart" ] <= level.dofdefault[ "nearEnd" ] )
+	{
+		level.dofdefault[ "farStart" ] = level.dofdefault[ "nearEnd" ] + 1;
+		setdvar( "scr_dof_farStart", level.dofdefault[ "farStart" ] );
+	}
+}
+
+dumpsettings()
+{
+/#
+	if ( getDvar( "scr_art_dump" ) != "0" )
+	{
+		println( "\tstart_dist = " + level.fognearplane + ";" );
+		println( "\thalf_dist = " + level.fogexphalfplane + ";" );
+		println( "\thalf_height = " + level.fogexphalfheight + ";" );
+		println( "\tbase_height = " + level.fogbaseheight + ";" );
+		println( "\tfog_r = " + level.fogcolorred + ";" );
+		println( "\tfog_g = " + level.fogcolorgreen + ";" );
+		println( "\tfog_b = " + level.fogcolorblue + ";" );
+		println( "\tfog_scale = " + level.fogcolorscale + ";" );
+		println( "\tsun_col_r = " + level.sunfogcolorred + ";" );
+		println( "\tsun_col_g = " + level.sunfogcolorgreen + ";" );
+		println( "\tsun_col_b = " + level.sunfogcolorblue + ";" );
+		println( "\tsun_dir_x = " + level.fogsundir[ 0 ] + ";" );
+		println( "\tsun_dir_y = " + level.fogsundir[ 1 ] + ";" );
+		println( "\tsun_dir_z = " + level.fogsundir[ 2 ] + ";" );
+		println( "\tsun_start_ang = " + level.sunstartangle + ";" );
+		println( "\tsun_stop_ang = " + level.sunendangle + ";" );
+		println( "\ttime = 0;" );
+		println( "\tmax_fog_opacity = " + level.fogmaxopacity + ";" );
+		println( "" );
+		println( "\tsetVolFog(start_dist, half_dist, half_height, base_height, fog_r, fog_g, fog_b, fog_scale," );
+		println( "\t\tsun_col_r, sun_col_g, sun_col_b, sun_dir_x, sun_dir_y, sun_dir_z, sun_start_ang, " );
+		println( "\t\tsun_stop_ang, time, max_fog_opacity);" );
+		setdvar( "scr_art_dump", "0" );
+#/
+	}
+}
+
+debug_reflection()
+{
+/#
+	level.debug_reflection = 0;
+	while ( 1 )
+	{
+		wait 0,1;
+		if ( getDvar( "debug_reflection" ) == "2" || level.debug_reflection != 2 && getDvar( "debug_reflection" ) == "3" && level.debug_reflection != 3 )
+		{
+			remove_reflection_objects();
+			if ( getDvar( "debug_reflection" ) == "2" )
+			{
+				create_reflection_objects();
+				level.debug_reflection = 2;
+			}
+			else
+			{
+				create_reflection_objects();
+				create_reflection_object();
+				level.debug_reflection = 3;
+			}
+			continue;
+		}
+		else
+		{
+			if ( getDvar( "debug_reflection" ) == "1" && level.debug_reflection != 1 )
+			{
+				setdvar( "debug_reflection_matte", "0" );
+				setdvar( "debug_color_pallete", "0" );
+				remove_reflection_objects();
+				create_reflection_object();
+				level.debug_reflection = 1;
+				break;
+			}
+			else
+			{
+				if ( getDvar( "debug_reflection" ) == "0" && level.debug_reflection != 0 )
+				{
+					remove_reflection_objects();
+					level.debug_reflection = 0;
+				}
+			}
+		}
+#/
+	}
+}
+
+remove_reflection_objects()
+{
+/#
+	if ( level.debug_reflection != 2 && level.debug_reflection == 3 && isDefined( level.debug_reflection_objects ) )
+	{
+		i = 0;
+		while ( i < level.debug_reflection_objects.size )
+		{
+			level.debug_reflection_objects[ i ] delete();
+			i++;
+		}
+		level.debug_reflection_objects = undefined;
+	}
+	if ( level.debug_reflection != 1 && level.debug_reflection != 3 && level.debug_reflection_matte != 1 || level.debug_color_pallete == 1 && level.debug_color_pallete == 2 )
+	{
+		if ( isDefined( level.debug_reflectionobject ) )
+		{
+			level.debug_reflectionobject delete();
+#/
+		}
+	}
+}
+
+create_reflection_objects()
+{
+/#
+	reflection_locs = getreflectionlocs();
+	i = 0;
+	while ( i < reflection_locs.size )
+	{
+		level.debug_reflection_objects[ i ] = spawn( "script_model", reflection_locs[ i ] );
+		level.debug_reflection_objects[ i ] setmodel( "test_sphere_silver" );
+		i++;
+#/
+	}
+}
+
+create_reflection_object( model )
+{
+	if ( !isDefined( model ) )
+	{
+		model = "test_sphere_silver";
+	}
+/#
+	if ( isDefined( level.debug_reflectionobject ) )
+	{
+		level.debug_reflectionobject delete();
+	}
+	players = get_players();
+	player = players[ 0 ];
+	level.debug_reflectionobject = spawn( "script_model", player geteye() + vectorScale( anglesToForward( player.angles ), 100 ) );
+	level.debug_reflectionobject setmodel( model );
+	level.debug_reflectionobject.origin = player geteye() + vectorScale( anglesToForward( player getplayerangles() ), 100 );
+	level.debug_reflectionobject linkto( player );
+	thread debug_reflection_buttons();
+#/
+}
+
+debug_reflection_buttons()
+{
+/#
+	level notify( "new_reflection_button_running" );
+	level endon( "new_reflection_button_running" );
+	level.debug_reflectionobject endon( "death" );
+	offset = 100;
+	lastoffset = offset;
+	while ( getDvar( "debug_reflection" ) != "1" && getDvar( "debug_reflection" ) != "3" && getDvar( "debug_reflection_matte" ) != "1" || getDvar( "debug_color_pallete" ) == "1" && getDvar( "debug_color_pallete" ) == "2" )
+	{
+		players = get_players();
+		if ( players[ 0 ] buttonpressed( "BUTTON_X" ) )
+		{
+			offset += 50;
+		}
+		if ( players[ 0 ] buttonpressed( "BUTTON_Y" ) )
+		{
+			offset -= 50;
+		}
+		if ( offset > 1000 )
+		{
+			offset = 1000;
+		}
+		if ( offset < 64 )
+		{
+			offset = 64;
+		}
+		level.debug_reflectionobject unlink();
+		level.debug_reflectionobject.origin = players[ 0 ] geteye() + vectorScale( anglesToForward( players[ 0 ] getplayerangles() ), offset );
+		temp_angles = vectorToAngle( players[ 0 ].origin - level.debug_reflectionobject.origin );
+		level.debug_reflectionobject.angles = ( 0, temp_angles[ 1 ], 0 );
+		lastoffset = offset;
+		line( level.debug_reflectionobject.origin, getreflectionorigin( level.debug_reflectionobject.origin ), ( 1, 0, 0 ), 1, 1 );
+		wait 0,05;
+		if ( isDefined( level.debug_reflectionobject ) )
+		{
+			level.debug_reflectionobject linkto( players[ 0 ] );
+		}
+#/
+	}
+}
+
+debug_reflection_matte()
+{
+/#
+	level.debug_reflection_matte = 0;
+	while ( 1 )
+	{
+		wait 0,1;
+		if ( getDvar( "debug_reflection_matte" ) == "1" && level.debug_reflection_matte != 1 )
+		{
+			setdvar( "debug_reflection", "0" );
+			setdvar( "debug_color_pallete", "0" );
+			remove_reflection_objects();
+			create_reflection_object( "test_sphere_lambert" );
+			level.debug_reflection_matte = 1;
+			continue;
+		}
+		else
+		{
+			if ( getDvar( "debug_reflection_matte" ) == "0" && level.debug_reflection_matte != 0 )
+			{
+				remove_reflection_objects();
+				level.debug_reflection_matte = 0;
+			}
+		}
+#/
+	}
+}
+
+debug_color_pallete()
+{
+/#
+	level.debug_color_pallete = 0;
+	while ( 1 )
+	{
+		wait 0,1;
+		if ( getDvar( "debug_color_pallete" ) == "1" && level.debug_color_pallete != 1 )
+		{
+			setdvar( "debug_reflection", "0" );
+			setdvar( "debug_reflection_matte", "0" );
+			remove_reflection_objects();
+			create_reflection_object( "test_macbeth_chart" );
+			level.debug_color_pallete = 1;
+			continue;
+		}
+		else
+		{
+			if ( getDvar( "debug_color_pallete" ) == "2" && level.debug_color_pallete != 2 )
+			{
+				remove_reflection_objects();
+				create_reflection_object( "test_macbeth_chart_unlit" );
+				level.debug_color_pallete = 2;
+				break;
+			}
+			else
+			{
+				if ( getDvar( "debug_color_pallete" ) == "0" && level.debug_color_pallete != 0 )
+				{
+					remove_reflection_objects();
+					level.debug_color_pallete = 0;
+				}
+			}
+		}
+#/
+	}
+}

patch_mp/maps/mp/_audio.gsc

@@ -0,0 +1,150 @@
+#include common_scripts/utility;
+#include maps/mp/_utility;
+
+init()
+{
+}
+
+wait_until_first_player()
+{
+	players = get_players();
+	if ( !isDefined( players[ 0 ] ) )
+	{
+		level waittill( "first_player_ready" );
+	}
+	players = get_players();
+	i = 0;
+	while ( i < players.size )
+	{
+		players[ i ] thread monitor_player_sprint();
+		i++;
+	}
+}
+
+stand_think( trig )
+{
+	killtext = "kill_stand_think" + trig getentitynumber();
+	self endon( "disconnect" );
+	self endon( "death" );
+	self endon( killtext );
+	while ( 1 )
+	{
+		if ( self.player_is_moving )
+		{
+			trig playsound( trig.script_label );
+		}
+		wait 1;
+	}
+}
+
+monitor_player_sprint()
+{
+	self endon( "disconnect" );
+	self thread monitor_player_movement();
+	self._is_sprinting = 0;
+	while ( 1 )
+	{
+		self waittill( "sprint_begin" );
+		self._is_sprinting = 1;
+		self waittill( "sprint_end" );
+		self._is_sprinting = 0;
+	}
+}
+
+monitor_player_movement()
+{
+	self endon( "disconnect" );
+	while ( 1 )
+	{
+		org_1 = self.origin;
+		wait 1;
+		org_2 = self.origin;
+		distancemoved = distancesquared( org_1, org_2 );
+		if ( distancemoved > 4096 )
+		{
+			self.player_is_moving = 1;
+			continue;
+		}
+		else
+		{
+			self.player_is_moving = 0;
+		}
+	}
+}
+
+thread_enter_exit_sound( trig )
+{
+	self endon( "death" );
+	self endon( "disconnect" );
+	trig.touchingplayers[ self getentitynumber() ] = 1;
+	if ( isDefined( trig.script_sound ) && trig.script_activated && self._is_sprinting )
+	{
+		self playsound( trig.script_sound );
+	}
+	self thread stand_think( trig );
+	while ( self istouching( trig ) )
+	{
+		wait 0,1;
+	}
+	self notify( "kill_stand_think" + trig getentitynumber() );
+	self playsound( trig.script_noteworthy );
+	trig.touchingplayers[ self getentitynumber() ] = 0;
+}
+
+thread_step_trigger()
+{
+	if ( !isDefined( self.script_activated ) )
+	{
+		self.script_activated = 1;
+	}
+	while ( !isDefined( self.touchingplayers ) )
+	{
+		self.touchingplayers = [];
+		i = 0;
+		while ( i < 4 )
+		{
+			self.touchingplayers[ i ] = 0;
+			i++;
+		}
+	}
+	while ( 1 )
+	{
+		self waittill( "trigger", who );
+		if ( self.touchingplayers[ who getentitynumber() ] == 0 )
+		{
+			who thread thread_enter_exit_sound( self );
+		}
+	}
+}
+
+disable_bump_trigger( triggername )
+{
+	triggers = getentarray( "audio_bump_trigger", "targetname" );
+	while ( isDefined( triggers ) )
+	{
+		i = 0;
+		while ( i < triggers.size )
+		{
+			if ( isDefined( triggers[ i ].script_label ) && triggers[ i ].script_label == triggername )
+			{
+				triggers[ i ].script_activated = 0;
+			}
+			i++;
+		}
+	}
+}
+
+get_player_index_number( player )
+{
+	players = get_players();
+	i = 0;
+	while ( i < players.size )
+	{
+		if ( players[ i ] == player )
+		{
+			return i;
+		}
+		i++;
+	}
+	return 1;
+}

patch_mp/maps/mp/_ballistic_knife.gsc

@@ -0,0 +1,273 @@
+#include maps/mp/_challenges;
+#include common_scripts/utility;
+#include maps/mp/_utility;
+
+init()
+{
+	precachemodel( "t6_wpn_ballistic_knife_projectile" );
+	precachemodel( "t6_wpn_ballistic_knife_blade_retrieve" );
+}
+
+onspawn( watcher, player )
+{
+	player endon( "death" );
+	player endon( "disconnect" );
+	level endon( "game_ended" );
+	self waittill( "stationary", endpos, normal, angles, attacker, prey, bone );
+	isfriendly = 0;
+	if ( isDefined( endpos ) )
+	{
+		retrievable_model = spawn( "script_model", endpos );
+		retrievable_model setmodel( "t6_wpn_ballistic_knife_projectile" );
+		retrievable_model setteam( player.team );
+		retrievable_model setowner( player );
+		retrievable_model.owner = player;
+		retrievable_model.angles = angles;
+		retrievable_model.name = watcher.weapon;
+		retrievable_model.targetname = "sticky_weapon";
+		if ( isDefined( prey ) )
+		{
+			if ( level.teambased && isplayer( prey ) && player.team == prey.team )
+			{
+				isfriendly = 1;
+			}
+			else
+			{
+				if ( level.teambased && isai( prey ) && player.team == prey.aiteam )
+				{
+					isfriendly = 1;
+				}
+			}
+			if ( !isfriendly )
+			{
+				if ( isalive( prey ) )
+				{
+					retrievable_model droptoground( retrievable_model.origin, 80 );
+				}
+				else
+				{
+					retrievable_model linkto( prey, bone );
+				}
+			}
+			else
+			{
+				if ( isfriendly )
+				{
+					retrievable_model physicslaunch( normal, ( randomint( 10 ), randomint( 10 ), randomint( 10 ) ) );
+					normal = ( 0, 0, 1 );
+				}
+			}
+		}
+		watcher.objectarray[ watcher.objectarray.size ] = retrievable_model;
+		if ( isfriendly )
+		{
+			retrievable_model waittill( "stationary" );
+		}
+		retrievable_model thread dropknivestoground();
+		if ( isfriendly )
+		{
+			player notify( "ballistic_knife_stationary" );
+		}
+		else
+		{
+			player notify( "ballistic_knife_stationary" );
+		}
+		retrievable_model thread wait_to_show_glowing_model( prey );
+	}
+}
+
+wait_to_show_glowing_model( prey )
+{
+	level endon( "game_ended" );
+	self endon( "death" );
+	glowing_retrievable_model = spawn( "script_model", self.origin );
+	self.glowing_model = glowing_retrievable_model;
+	glowing_retrievable_model.angles = self.angles;
+	glowing_retrievable_model linkto( self );
+	if ( isDefined( prey ) && !isalive( prey ) )
+	{
+		wait 2;
+	}
+	glowing_retrievable_model setmodel( "t6_wpn_ballistic_knife_blade_retrieve" );
+}
+
+watch_shutdown()
+{
+	pickuptrigger = self.pickuptrigger;
+	glowing_model = self.glowing_model;
+	self waittill( "death" );
+	if ( isDefined( pickuptrigger ) )
+	{
+		pickuptrigger delete();
+	}
+	if ( isDefined( glowing_model ) )
+	{
+		glowing_model delete();
+	}
+}
+
+onspawnretrievetrigger( watcher, player )
+{
+	player endon( "death" );
+	player endon( "disconnect" );
+	level endon( "game_ended" );
+	player waittill( "ballistic_knife_stationary", retrievable_model, normal, prey );
+	if ( !isDefined( retrievable_model ) )
+	{
+		return;
+	}
+	vec_scale = 10;
+	trigger_pos = [];
+	if ( isDefined( prey ) || isplayer( prey ) && isai( prey ) )
+	{
+		trigger_pos[ 0 ] = prey.origin[ 0 ];
+		trigger_pos[ 1 ] = prey.origin[ 1 ];
+		trigger_pos[ 2 ] = prey.origin[ 2 ] + vec_scale;
+	}
+	else
+	{
+		trigger_pos[ 0 ] = retrievable_model.origin[ 0 ] + ( vec_scale * normal[ 0 ] );
+		trigger_pos[ 1 ] = retrievable_model.origin[ 1 ] + ( vec_scale * normal[ 1 ] );
+		trigger_pos[ 2 ] = retrievable_model.origin[ 2 ] + ( vec_scale * normal[ 2 ] );
+	}
+	trigger_pos[ 2 ] -= 50;
+	pickup_trigger = spawn( "trigger_radius", ( trigger_pos[ 0 ], trigger_pos[ 1 ], trigger_pos[ 2 ] ), 0, 50, 100 );
+	pickup_trigger.owner = player;
+	retrievable_model.pickuptrigger = pickup_trigger;
+	pickup_trigger enablelinkto();
+	if ( isDefined( prey ) )
+	{
+		pickup_trigger linkto( prey );
+	}
+	else
+	{
+		pickup_trigger linkto( retrievable_model );
+	}
+	retrievable_model thread watch_use_trigger( pickup_trigger, retrievable_model, ::pick_up, watcher.pickupsoundplayer, watcher.pickupsound );
+	retrievable_model thread watch_shutdown();
+}
+
+watch_use_trigger( trigger, model, callback, playersoundonuse, npcsoundonuse )
+{
+	self endon( "death" );
+	self endon( "delete" );
+	level endon( "game_ended" );
+	max_ammo = weaponmaxammo( "knife_ballistic_mp" ) + 1;
+	while ( 1 )
+	{
+		trigger waittill( "trigger", player );
+		while ( !isalive( player ) )
+		{
+			continue;
+		}
+		while ( !player isonground() )
+		{
+			continue;
+		}
+		if ( isDefined( trigger.triggerteam ) && player.team != trigger.triggerteam )
+		{
+			continue;
+		}
+		if ( isDefined( trigger.claimedby ) && player != trigger.claimedby )
+		{
+			continue;
+		}
+		while ( !player hasweapon( "knife_ballistic_mp" ) )
+		{
+			continue;
+		}
+		ammo_stock = player getweaponammostock( "knife_ballistic_mp" );
+		ammo_clip = player getweaponammoclip( "knife_ballistic_mp" );
+		current_weapon = player getcurrentweapon();
+		total_ammo = ammo_stock + ammo_clip;
+		hasreloaded = 1;
+		if ( total_ammo > 0 && ammo_stock == total_ammo && current_weapon == "knife_ballistic_mp" )
+		{
+			hasreloaded = 0;
+		}
+		if ( total_ammo >= max_ammo || !hasreloaded )
+		{
+			continue;
+		}
+		if ( isDefined( playersoundonuse ) )
+		{
+			player playlocalsound( playersoundonuse );
+		}
+		if ( isDefined( npcsoundonuse ) )
+		{
+			player playsound( npcsoundonuse );
+		}
+		self thread [[ callback ]]( player );
+		return;
+	}
+}
+
+pick_up( player )
+{
+	self destroy_ent();
+	current_weapon = player getcurrentweapon();
+	player maps/mp/_challenges::pickedupballisticknife();
+	if ( current_weapon != "knife_ballistic_mp" )
+	{
+		clip_ammo = player getweaponammoclip( "knife_ballistic_mp" );
+		if ( !clip_ammo )
+		{
+			player setweaponammoclip( "knife_ballistic_mp", 1 );
+		}
+		else
+		{
+			new_ammo_stock = player getweaponammostock( "knife_ballistic_mp" ) + 1;
+			player setweaponammostock( "knife_ballistic_mp", new_ammo_stock );
+		}
+	}
+	else
+	{
+		new_ammo_stock = player getweaponammostock( "knife_ballistic_mp" ) + 1;
+		player setweaponammostock( "knife_ballistic_mp", new_ammo_stock );
+	}
+}
+
+destroy_ent()
+{
+	if ( isDefined( self ) )
+	{
+		pickuptrigger = self.pickuptrigger;
+		if ( isDefined( pickuptrigger ) )
+		{
+			pickuptrigger delete();
+		}
+		if ( isDefined( self.glowing_model ) )
+		{
+			self.glowing_model delete();
+		}
+		self delete();
+	}
+}
+
+dropknivestoground()
+{
+	self endon( "death" );
+	for ( ;; )
+	{
+		level waittill( "drop_objects_to_ground", origin, radius );
+		self droptoground( origin, radius );
+	}
+}
+
+droptoground( origin, radius )
+{
+	if ( distancesquared( origin, self.origin ) < ( radius * radius ) )
+	{
+		self physicslaunch( ( 0, 0, 1 ), vectorScale( ( 0, 0, 1 ), 5 ) );
+		self thread updateretrievetrigger();
+	}
+}
+
+updateretrievetrigger()
+{
+	self endon( "death" );
+	self waittill( "stationary" );
+	trigger = self.pickuptrigger;
+	trigger.origin = ( self.origin[ 0 ], self.origin[ 1 ], self.origin[ 2 ] + 10 );
+	trigger linkto( self );
+}

patch_mp/maps/mp/_bb.gsc

@@ -0,0 +1,87 @@
+#include common_scripts/utility;
+#include maps/mp/_utility;
+
+init()
+{
+	level thread onplayerconnect();
+}
+
+onplayerconnect()
+{
+	for ( ;; )
+	{
+		level waittill( "connected", player );
+		player thread onplayerspawned();
+		player thread onplayerdeath();
+	}
+}
+
+onplayerspawned()
+{
+	self endon( "disconnect" );
+	self._bbdata = [];
+	for ( ;; )
+	{
+		self waittill( "spawned_player" );
+		self._bbdata[ "score" ] = 0;
+		self._bbdata[ "momentum" ] = 0;
+		self._bbdata[ "spawntime" ] = getTime();
+		self._bbdata[ "shots" ] = 0;
+		self._bbdata[ "hits" ] = 0;
+	}
+}
+
+onplayerdisconnect()
+{
+	for ( ;; )
+	{
+		self waittill( "disconnect" );
+		self commitspawndata();
+		return;
+	}
+}
+
+onplayerdeath()
+{
+	self endon( "disconnect" );
+	for ( ;; )
+	{
+		self waittill( "death" );
+		self commitspawndata();
+	}
+}
+
+commitspawndata()
+{
+/#
+	assert( isDefined( self._bbdata ) );
+#/
+	if ( !isDefined( self._bbdata ) )
+	{
+		return;
+	}
+	bbprint( "mpplayerlives", "gametime %d spawnid %d lifescore %d lifemomentum %d lifetime %d name %s", getTime(), getplayerspawnid( self ), self._bbdata[ "score" ], self._bbdata[ "momentum" ], getTime() - self._bbdata[ "spawntime" ], self.name );
+}
+
+commitweapondata( spawnid, currentweapon, time0 )
+{
+/#
+	assert( isDefined( self._bbdata ) );
+#/
+	if ( !isDefined( self._bbdata ) )
+	{
+		return;
+	}
+	time1 = getTime();
+	bbprint( "mpweapons", "spawnid %d name %s duration %d shots %d hits %d", spawnid, currentweapon, time1 - time0, self._bbdata[ "shots" ], self._bbdata[ "hits" ] );
+	self._bbdata[ "shots" ] = 0;
+	self._bbdata[ "hits" ] = 0;
+}
+
+bbaddtostat( statname, delta )
+{
+	if ( isDefined( self._bbdata ) && isDefined( self._bbdata[ statname ] ) )
+	{
+		self._bbdata[ statname ] += delta;
+	}
+}

patch_mp/maps/mp/_bouncingbetty.gsc

@@ -0,0 +1,175 @@
+#include maps/mp/_scoreevents;
+#include maps/mp/_challenges;
+#include maps/mp/gametypes/_weaponobjects;
+#include common_scripts/utility;
+#include maps/mp/_utility;
+
+init()
+{
+	precachemodel( "t6_wpn_bouncing_betty_world" );
+	level.bettyexplosionfx = loadfx( "weapon/bouncing_betty/fx_betty_explosion" );
+	level.bettydestroyedfx = loadfx( "weapon/bouncing_betty/fx_betty_destroyed" );
+	level.bettylaunchfx = loadfx( "weapon/bouncing_betty/fx_betty_launch_dust" );
+	level._effect[ "fx_betty_friendly_light" ] = loadfx( "weapon/bouncing_betty/fx_betty_light_green" );
+	level._effect[ "fx_betty_enemy_light" ] = loadfx( "weapon/bouncing_betty/fx_betty_light_red" );
+	level.bettymindist = 20;
+	level.bettygraceperiod = 0,6;
+	level.bettyradius = 192;
+	level.bettystuntime = 1;
+	level.bettydamageradius = 256;
+	level.bettydamagemax = 210;
+	level.bettydamagemin = 70;
+	level.bettyjumpheight = 65;
+	level.bettyjumptime = 0,65;
+	level.bettyrotatevelocity = ( 0, 750, 32 );
+	level.bettyactivationdelay = 0,1;
+}
+
+createbouncingbettywatcher()
+{
+	watcher = self createproximityweaponobjectwatcher( "bouncingbetty", "bouncingbetty_mp", self.team );
+	watcher.onspawn = ::onspawnbouncingbetty;
+	watcher.watchforfire = 1;
+	watcher.detonate = ::bouncingbettydetonate;
+	watcher.activatesound = "wpn_claymore_alert";
+	watcher.hackable = 1;
+	watcher.hackertoolradius = level.equipmenthackertoolradius;
+	watcher.hackertooltimems = level.equipmenthackertooltimems;
+	watcher.reconmodel = "t6_wpn_bouncing_betty_world_detect";
+	watcher.ownergetsassist = 1;
+	watcher.ignoredirection = 1;
+	watcher.detectionmindist = level.bettymindist;
+	watcher.detectiongraceperiod = level.bettygraceperiod;
+	watcher.detonateradius = level.bettyradius;
+	watcher.stun = ::weaponstun;
+	watcher.stuntime = level.bettystuntime;
+	watcher.activationdelay = level.bettyactivationdelay;
+}
+
+onspawnbouncingbetty( watcher, owner )
+{
+	onspawnproximityweaponobject( watcher, owner );
+	self thread spawnminemover();
+}
+
+spawnminemover()
+{
+	self waittillnotmoving();
+	minemover = spawn( "script_model", self.origin );
+	minemover.angles = self.angles;
+	minemover setmodel( "tag_origin" );
+	minemover.owner = self.owner;
+	minemover.killcamoffset = ( 0, 0, getdvarfloatdefault( "scr_bouncing_betty_killcam_offset", 8 ) );
+	killcament = spawn( "script_model", minemover.origin + minemover.killcamoffset );
+	killcament.angles = ( 0, 0, 0 );
+	killcament setmodel( "tag_origin" );
+	killcament setweapon( "bouncingbetty_mp" );
+	minemover.killcament = killcament;
+	self.minemover = minemover;
+	self thread killminemoveronpickup();
+}
+
+killminemoveronpickup()
+{
+	self.minemover endon( "death" );
+	self waittill_any( "picked_up", "hacked" );
+	self killminemover();
+}
+
+killminemover()
+{
+	if ( isDefined( self.minemover ) )
+	{
+		if ( isDefined( self.minemover.killcament ) )
+		{
+			self.minemover.killcament delete();
+		}
+		self.minemover delete();
+	}
+}
+
+bouncingbettydetonate( attacker, weaponname )
+{
+	if ( isDefined( weaponname ) )
+	{
+		if ( isDefined( attacker ) )
+		{
+			if ( self.owner isenemyplayer( attacker ) )
+			{
+				attacker maps/mp/_challenges::destroyedexplosive( weaponname );
+				maps/mp/_scoreevents::processscoreevent( "destroyed_bouncingbetty", attacker, self.owner, weaponname );
+			}
+		}
+		self bouncingbettydestroyed();
+	}
+	else if ( isDefined( self.minemover ) )
+	{
+		self.minemover setmodel( self.model );
+		self.minemover thread bouncingbettyjumpandexplode();
+		self delete();
+	}
+	else
+	{
+		self bouncingbettydestroyed();
+	}
+}
+
+bouncingbettydestroyed()
+{
+	playfx( level.bettydestroyedfx, self.origin );
+	playsoundatposition( "dst_equipment_destroy", self.origin );
+	if ( isDefined( self.trigger ) )
+	{
+		self.trigger delete();
+	}
+	if ( isDefined( self.minemover ) )
+	{
+		if ( isDefined( self.minemover.killcament ) )
+		{
+			self.minemover.killcament delete();
+		}
+		self.minemover delete();
+	}
+	self radiusdamage( self.origin, 128, 110, 10, self.owner, "MOD_EXPLOSIVE", "bouncingbetty_mp" );
+	self delete();
+}
+
+bouncingbettyjumpandexplode()
+{
+	explodepos = self.origin + ( 0, 0, level.bettyjumpheight );
+	self moveto( explodepos, level.bettyjumptime, level.bettyjumptime, 0 );
+	self.killcament moveto( explodepos + self.killcamoffset, level.bettyjumptime, 0, level.bettyjumptime );
+	playfx( level.bettylaunchfx, self.origin );
+	self rotatevelocity( level.bettyrotatevelocity, level.bettyjumptime, 0, level.bettyjumptime );
+	self playsound( "fly_betty_jump" );
+	wait level.bettyjumptime;
+	self thread mineexplode();
+}
+
+mineexplode()
+{
+	if ( !isDefined( self ) || !isDefined( self.owner ) )
+	{
+		return;
+	}
+	self playsound( "fly_betty_explo" );
+	wait 0,05;
+	if ( !isDefined( self ) || !isDefined( self.owner ) )
+	{
+		return;
+	}
+	self hide();
+	self radiusdamage( self.origin, level.bettydamageradius, level.bettydamagemax, level.bettydamagemin, self.owner, "MOD_EXPLOSIVE", "bouncingbetty_mp" );
+	playfx( level.bettyexplosionfx, self.origin );
+	wait 0,2;
+	if ( !isDefined( self ) || !isDefined( self.owner ) )
+	{
+		return;
+	}
+	if ( isDefined( self.trigger ) )
+	{
+		self.trigger delete();
+	}
+	self.killcament delete();
+	self delete();
+}

patch_mp/maps/mp/_burnplayer.gsc

@@ -0,0 +1,588 @@
+#include maps/mp/gametypes/_damagefeedback;
+#include maps/mp/gametypes/_globallogic_player;
+#include maps/mp/_utility;
+#include common_scripts/utility;
+
+initburnplayer()
+{
+	level.flamedamage = 15;
+	level.flameburntime = 1,5;
+}
+
+hitwithincendiary( attacker, inflictor, mod )
+{
+	if ( isDefined( self.burning ) )
+	{
+		return;
+	}
+	self starttanning();
+	self thread waitthenstoptanning( level.flameburntime );
+	self endon( "disconnect" );
+	attacker endon( "disconnect" );
+	waittillframeend;
+	self.burning = 1;
+	self thread burn_blocker();
+	tagarray = [];
+	if ( isai( self ) )
+	{
+		tagarray[ tagarray.size ] = "J_Wrist_RI";
+		tagarray[ tagarray.size ] = "J_Wrist_LE";
+		tagarray[ tagarray.size ] = "J_Elbow_LE";
+		tagarray[ tagarray.size ] = "J_Elbow_RI";
+		tagarray[ tagarray.size ] = "J_Knee_RI";
+		tagarray[ tagarray.size ] = "J_Knee_LE";
+		tagarray[ tagarray.size ] = "J_Ankle_RI";
+		tagarray[ tagarray.size ] = "J_Ankle_LE";
+	}
+	else
+	{
+		tagarray[ tagarray.size ] = "J_Wrist_RI";
+		tagarray[ tagarray.size ] = "J_Wrist_LE";
+		tagarray[ tagarray.size ] = "J_Elbow_LE";
+		tagarray[ tagarray.size ] = "J_Elbow_RI";
+		tagarray[ tagarray.size ] = "J_Knee_RI";
+		tagarray[ tagarray.size ] = "J_Knee_LE";
+		tagarray[ tagarray.size ] = "J_Ankle_RI";
+		tagarray[ tagarray.size ] = "J_Ankle_LE";
+		if ( isplayer( self ) && self.health > 0 )
+		{
+			self setburn( 3 );
+		}
+	}
+	while ( isDefined( level._effect[ "character_fire_death_torso" ] ) )
+	{
+		arrayindex = 0;
+		while ( arrayindex < tagarray.size )
+		{
+			playfxontag( level._effect[ "character_fire_death_sm" ], self, tagarray[ arrayindex ] );
+			arrayindex++;
+		}
+	}
+	if ( isai( self ) )
+	{
+		playfxontag( level._effect[ "character_fire_death_torso" ], self, "J_Spine1" );
+	}
+	else
+	{
+		playfxontag( level._effect[ "character_fire_death_torso" ], self, "J_SpineLower" );
+	}
+	if ( !isalive( self ) )
+	{
+		return;
+	}
+	if ( isplayer( self ) )
+	{
+		self thread watchforwater( 7 );
+		self thread watchfordeath();
+	}
+}
+
+hitwithnapalmstrike( attacker, inflictor, mod )
+{
+	if ( isDefined( self.burning ) || self hasperk( "specialty_fireproof" ) )
+	{
+		return;
+	}
+	self starttanning();
+	self thread waitthenstoptanning( level.flameburntime );
+	self endon( "disconnect" );
+	attacker endon( "disconnect" );
+	self endon( "death" );
+	if ( isDefined( self.burning ) )
+	{
+		return;
+	}
+	self thread burn_blocker();
+	waittillframeend;
+	self.burning = 1;
+	self thread burn_blocker();
+	tagarray = [];
+	if ( isai( self ) )
+	{
+		tagarray[ tagarray.size ] = "J_Wrist_RI";
+		tagarray[ tagarray.size ] = "J_Wrist_LE";
+		tagarray[ tagarray.size ] = "J_Elbow_LE";
+		tagarray[ tagarray.size ] = "J_Elbow_RI";
+		tagarray[ tagarray.size ] = "J_Knee_RI";
+		tagarray[ tagarray.size ] = "J_Knee_LE";
+		tagarray[ tagarray.size ] = "J_Ankle_RI";
+		tagarray[ tagarray.size ] = "J_Ankle_LE";
+	}
+	else
+	{
+		tagarray[ tagarray.size ] = "J_Wrist_RI";
+		tagarray[ tagarray.size ] = "J_Wrist_LE";
+		tagarray[ tagarray.size ] = "J_Elbow_LE";
+		tagarray[ tagarray.size ] = "J_Elbow_RI";
+		tagarray[ tagarray.size ] = "J_Knee_RI";
+		tagarray[ tagarray.size ] = "J_Knee_LE";
+		tagarray[ tagarray.size ] = "J_Ankle_RI";
+		tagarray[ tagarray.size ] = "J_Ankle_LE";
+		if ( isplayer( self ) )
+		{
+			self setburn( 3 );
+		}
+	}
+	while ( isDefined( level._effect[ "character_fire_death_sm" ] ) )
+	{
+		arrayindex = 0;
+		while ( arrayindex < tagarray.size )
+		{
+			playfxontag( level._effect[ "character_fire_death_sm" ], self, tagarray[ arrayindex ] );
+			arrayindex++;
+		}
+	}
+	if ( isDefined( level._effect[ "character_fire_death_torso" ] ) )
+	{
+		playfxontag( level._effect[ "character_fire_death_torso" ], self, "J_SpineLower" );
+	}
+	if ( !isalive( self ) )
+	{
+		return;
+	}
+	self thread donapalmstrikedamage( attacker, inflictor, mod );
+	if ( isplayer( self ) )
+	{
+		self thread watchforwater( 7 );
+		self thread watchfordeath();
+	}
+}
+
+walkedthroughflames( attacker, inflictor, weapon )
+{
+	if ( isDefined( self.burning ) || self hasperk( "specialty_fireproof" ) )
+	{
+		return;
+	}
+	self starttanning();
+	self thread waitthenstoptanning( level.flameburntime );
+	self endon( "disconnect" );
+	waittillframeend;
+	self.burning = 1;
+	self thread burn_blocker();
+	tagarray = [];
+	if ( isai( self ) )
+	{
+		tagarray[ tagarray.size ] = "J_Wrist_RI";
+		tagarray[ tagarray.size ] = "J_Wrist_LE";
+		tagarray[ tagarray.size ] = "J_Elbow_LE";
+		tagarray[ tagarray.size ] = "J_Elbow_RI";
+		tagarray[ tagarray.size ] = "J_Knee_RI";
+		tagarray[ tagarray.size ] = "J_Knee_LE";
+		tagarray[ tagarray.size ] = "J_Ankle_RI";
+		tagarray[ tagarray.size ] = "J_Ankle_LE";
+	}
+	else
+	{
+		tagarray[ tagarray.size ] = "J_Knee_RI";
+		tagarray[ tagarray.size ] = "J_Knee_LE";
+		tagarray[ tagarray.size ] = "J_Ankle_RI";
+		tagarray[ tagarray.size ] = "J_Ankle_LE";
+	}
+	while ( isDefined( level._effect[ "character_fire_player_sm" ] ) )
+	{
+		arrayindex = 0;
+		while ( arrayindex < tagarray.size )
+		{
+			playfxontag( level._effect[ "character_fire_player_sm" ], self, tagarray[ arrayindex ] );
+			arrayindex++;
+		}
+	}
+	if ( !isalive( self ) )
+	{
+		return;
+	}
+	self thread doflamedamage( attacker, inflictor, weapon, 1 );
+	if ( isplayer( self ) )
+	{
+		self thread watchforwater( 7 );
+		self thread watchfordeath();
+	}
+}
+
+burnedwithflamethrower( attacker, inflictor, weapon )
+{
+	if ( isDefined( self.burning ) )
+	{
+		return;
+	}
+	self starttanning();
+	self thread waitthenstoptanning( level.flameburntime );
+	self endon( "disconnect" );
+	waittillframeend;
+	self.burning = 1;
+	self thread burn_blocker();
+	tagarray = [];
+	if ( isai( self ) )
+	{
+		tagarray[ 0 ] = "J_Spine1";
+		tagarray[ 1 ] = "J_Elbow_LE";
+		tagarray[ 2 ] = "J_Elbow_RI";
+		tagarray[ 3 ] = "J_Head";
+		tagarray[ 4 ] = "j_knee_ri";
+		tagarray[ 5 ] = "j_knee_le";
+	}
+	else
+	{
+		tagarray[ 0 ] = "J_Elbow_RI";
+		tagarray[ 1 ] = "j_knee_ri";
+		tagarray[ 2 ] = "j_knee_le";
+		if ( isplayer( self ) && self.health > 0 )
+		{
+			self setburn( 3 );
+		}
+	}
+	if ( isplayer( self ) && isalive( self ) )
+	{
+		self thread watchforwater( 7 );
+		self thread watchfordeath();
+	}
+	while ( isDefined( level._effect[ "character_fire_player_sm" ] ) )
+	{
+		arrayindex = 0;
+		while ( arrayindex < tagarray.size )
+		{
+			playfxontag( level._effect[ "character_fire_player_sm" ], self, tagarray[ arrayindex ] );
+			arrayindex++;
+		}
+	}
+}
+
+burnedwithdragonsbreath( attacker, inflictor, weapon )
+{
+	if ( isDefined( self.burning ) )
+	{
+		return;
+	}
+	self starttanning();
+	self thread waitthenstoptanning( level.flameburntime );
+	self endon( "disconnect" );
+	waittillframeend;
+	self.burning = 1;
+	self thread burn_blocker();
+	tagarray = [];
+	if ( isai( self ) )
+	{
+		tagarray[ 0 ] = "J_Spine1";
+		tagarray[ 1 ] = "J_Elbow_LE";
+		tagarray[ 2 ] = "J_Elbow_RI";
+		tagarray[ 3 ] = "J_Head";
+		tagarray[ 4 ] = "j_knee_ri";
+		tagarray[ 5 ] = "j_knee_le";
+	}
+	else
+	{
+		tagarray[ 0 ] = "j_spinelower";
+		tagarray[ 1 ] = "J_Elbow_RI";
+		tagarray[ 2 ] = "j_knee_ri";
+		tagarray[ 3 ] = "j_knee_le";
+		if ( isplayer( self ) && self.health > 0 )
+		{
+			self setburn( 3 );
+		}
+	}
+	if ( isplayer( self ) && isalive( self ) )
+	{
+		self thread watchforwater( 7 );
+		self thread watchfordeath();
+		return;
+	}
+	while ( isDefined( level._effect[ "character_fire_player_sm" ] ) )
+	{
+		arrayindex = 0;
+		while ( arrayindex < tagarray.size )
+		{
+			playfxontag( level._effect[ "character_fire_player_sm" ], self, tagarray[ arrayindex ] );
+			arrayindex++;
+		}
+	}
+}
+
+burnedtodeath()
+{
+	self.burning = 1;
+	self thread burn_blocker();
+	self starttanning();
+	self thread doburningsound();
+	self thread waitthenstoptanning( level.flameburntime );
+}
+
+watchfordeath()
+{
+	self endon( "disconnect" );
+	self notify( "watching for death while on fire" );
+	self endon( "watching for death while on fire" );
+	self waittill( "death" );
+	if ( isplayer( self ) )
+	{
+		self _stopburning();
+	}
+	self.burning = undefined;
+}
+
+watchforwater( time )
+{
+	self endon( "disconnect" );
+	self notify( "watching for water" );
+	self endon( "watching for water" );
+	wait 0,1;
+	looptime = 0,1;
+	while ( time > 0 )
+	{
+		wait looptime;
+		if ( self depthofplayerinwater() > 0 )
+		{
+			finish_burn();
+			time = 0;
+		}
+		time -= looptime;
+	}
+}
+
+finish_burn()
+{
+	self notify( "stop burn damage" );
+	tagarray = [];
+	tagarray[ 0 ] = "j_spinelower";
+	tagarray[ 1 ] = "J_Elbow_RI";
+	tagarray[ 2 ] = "J_Head";
+	tagarray[ 3 ] = "j_knee_ri";
+	tagarray[ 4 ] = "j_knee_le";
+	while ( isDefined( level._effect[ "fx_fire_player_sm_smk_2sec" ] ) )
+	{
+		arrayindex = 0;
+		while ( arrayindex < tagarray.size )
+		{
+			playfxontag( level._effect[ "fx_fire_player_sm_smk_2sec" ], self, tagarray[ arrayindex ] );
+			arrayindex++;
+		}
+	}
+	self.burning = undefined;
+	self _stopburning();
+	self.ingroundnapalm = 0;
+}
+
+donapalmstrikedamage( attacker, inflictor, mod )
+{
+	if ( isai( self ) )
+	{
+		dodognapalmstrikedamage( attacker, inflictor, mod );
+		return;
+	}
+	self endon( "death" );
+	self endon( "disconnect" );
+	attacker endon( "disconnect" );
+	self endon( "stop burn damage" );
+	while ( isDefined( level.napalmstrikedamage ) && isDefined( self ) && self depthofplayerinwater() < 1 )
+	{
+		self dodamage( level.napalmstrikedamage, self.origin, attacker, attacker, "none", mod, 0, "napalm_mp" );
+		wait 1;
+	}
+}
+
+donapalmgrounddamage( attacker, inflictor, mod )
+{
+	if ( self hasperk( "specialty_fireproof" ) )
+	{
+		return;
+	}
+	if ( level.teambased )
+	{
+		if ( attacker != self && attacker.team == self.team )
+		{
+			return;
+		}
+	}
+	if ( isai( self ) )
+	{
+		dodognapalmgrounddamage( attacker, inflictor, mod );
+		return;
+	}
+	if ( isDefined( self.burning ) )
+	{
+		return;
+	}
+	self thread burn_blocker();
+	self endon( "death" );
+	self endon( "disconnect" );
+	attacker endon( "disconnect" );
+	self endon( "stop burn damage" );
+	if ( isDefined( level.groundburntime ) )
+	{
+		if ( getDvar( #"6EC13261" ) == "" )
+		{
+			waittime = level.groundburntime;
+		}
+		else
+		{
+			waittime = getDvarFloat( #"6EC13261" );
+		}
+	}
+	else
+	{
+		waittime = 100;
+	}
+	self walkedthroughflames( attacker, inflictor, "napalm_mp" );
+	self.ingroundnapalm = 1;
+	while ( isDefined( level.napalmgrounddamage ) )
+	{
+		if ( getDvar( #"3FFA6673" ) == "" )
+		{
+			napalmgrounddamage = level.napalmgrounddamage;
+		}
+		else
+		{
+			napalmgrounddamage = getDvarFloat( #"3FFA6673" );
+		}
+		while ( isDefined( self ) && isDefined( inflictor ) && self depthofplayerinwater() < 1 && waittime > 0 )
+		{
+			self dodamage( level.napalmgrounddamage, self.origin, attacker, inflictor, "none", mod, 0, "napalm_mp" );
+			if ( isplayer( self ) )
+			{
+				self setburn( 1,1 );
+			}
+			wait 1;
+			waittime -= 1;
+		}
+	}
+	self.ingroundnapalm = 0;
+}
+
+dodognapalmstrikedamage( attacker, inflictor, mod )
+{
+	attacker endon( "disconnect" );
+	self endon( "death" );
+	self endon( "stop burn damage" );
+	while ( isDefined( level.napalmstrikedamage ) && isDefined( self ) )
+	{
+		self dodamage( level.napalmstrikedamage, self.origin, attacker, attacker, "none", mod );
+		wait 1;
+	}
+}
+
+dodognapalmgrounddamage( attacker, inflictor, mod )
+{
+	attacker endon( "disconnect" );
+	self endon( "death" );
+	self endon( "stop burn damage" );
+	while ( isDefined( level.napalmgrounddamage ) && isDefined( self ) )
+	{
+		self dodamage( level.napalmgrounddamage, self.origin, attacker, attacker, "none", mod, 0, "napalm_mp" );
+		wait 1;
+	}
+}
+
+burn_blocker()
+{
+	self endon( "disconnect" );
+	self endon( "death" );
+	wait 3;
+	self.burning = undefined;
+}
+
+doflamedamage( attacker, inflictor, weapon, time )
+{
+	if ( isai( self ) )
+	{
+		dodogflamedamage( attacker, inflictor, weapon, time );
+		return;
+	}
+	if ( isDefined( attacker ) )
+	{
+		attacker endon( "disconnect" );
+	}
+	self endon( "death" );
+	self endon( "disconnect" );
+	self endon( "stop burn damage" );
+	self thread doburningsound();
+	self notify( "snd_burn_scream" );
+	wait_time = 1;
+	while ( isDefined( level.flamedamage ) && isDefined( self ) && self depthofplayerinwater() < 1 && time > 0 )
+	{
+		if ( isDefined( attacker ) && isDefined( inflictor ) && isDefined( weapon ) )
+		{
+			if ( maps/mp/gametypes/_globallogic_player::dodamagefeedback( weapon, attacker ) )
+			{
+				attacker maps/mp/gametypes/_damagefeedback::updatedamagefeedback();
+			}
+			self dodamage( level.flamedamage, self.origin, attacker, inflictor, "none", "MOD_BURNED", 0, weapon );
+		}
+		else
+		{
+			self dodamage( level.flamedamage, self.origin );
+		}
+		wait wait_time;
+		time -= wait_time;
+	}
+	self thread finish_burn();
+}
+
+dodogflamedamage( attacker, inflictor, weapon, time )
+{
+	if ( isDefined( attacker ) || !isDefined( inflictor ) && !isDefined( weapon ) )
+	{
+		return;
+	}
+	attacker endon( "disconnect" );
+	self endon( "death" );
+	self endon( "stop burn damage" );
+	self thread doburningsound();
+	wait_time = 1;
+	while ( isDefined( level.flamedamage ) && isDefined( self ) && time > 0 )
+	{
+		self dodamage( level.flamedamage, self.origin, attacker, inflictor, "none", "MOD_BURNED", 0, weapon );
+		wait wait_time;
+		time -= wait_time;
+	}
+}
+
+waitthenstoptanning( time )
+{
+	self endon( "disconnect" );
+	self endon( "death" );
+	wait time;
+	self _stopburning();
+}
+
+doburningsound()
+{
+	self endon( "disconnect" );
+	self endon( "death" );
+	fire_sound_ent = spawn( "script_origin", self.origin );
+	fire_sound_ent linkto( self, "tag_origin", ( 0, 0, 0 ), ( 0, 0, 0 ) );
+	fire_sound_ent playloopsound( "mpl_player_burn_loop" );
+	self thread firesounddeath( fire_sound_ent );
+	self waittill( "StopBurnSound" );
+	if ( isDefined( fire_sound_ent ) )
+	{
+		fire_sound_ent stoploopsound( 0,5 );
+	}
+	wait 0,5;
+	if ( isDefined( fire_sound_ent ) )
+	{
+		fire_sound_ent delete();
+	}
+/#
+	println( "sound stop burning" );
+#/
+}
+
+_stopburning()
+{
+	self endon( "disconnect" );
+	self notify( "StopBurnSound" );
+	if ( isDefined( self ) )
+	{
+		self stopburning();
+	}
+}
+
+firesounddeath( ent )
+{
+	ent endon( "death" );
+	self waittill_any( "death", "disconnect" );
+	ent delete();
+/#
+	println( "sound delete burning" );
+#/
+}

patch_mp/maps/mp/_busing.gsc

@@ -0,0 +1,19 @@
+#include maps/mp/_utility;
+
+businit()
+{
+/#
+	assert( level.clientscripts );
+#/
+	level.busstate = "";
+	registerclientsys( "busCmd" );
+}
+
+setbusstate( state )
+{
+	if ( level.busstate != state )
+	{
+		setclientsysstate( "busCmd", state );
+	}
+	level.busstate = state;
+}

patch_mp/maps/mp/_compass.gsc

@@ -0,0 +1,67 @@
+
+setupminimap( material )
+{
+	requiredmapaspectratio = getDvarFloat( "scr_RequiredMapAspectratio" );
+	corners = getentarray( "minimap_corner", "targetname" );
+	if ( corners.size != 2 )
+	{
+/#
+		println( "^1Error: There are not exactly two "minimap_corner" entities in the map. Could not set up minimap." );
+#/
+		return;
+	}
+	corner0 = ( corners[ 0 ].origin[ 0 ], corners[ 0 ].origin[ 1 ], 0 );
+	corner1 = ( corners[ 1 ].origin[ 0 ], corners[ 1 ].origin[ 1 ], 0 );
+	cornerdiff = corner1 - corner0;
+	north = ( cos( getnorthyaw() ), sin( getnorthyaw() ), 0 );
+	west = ( 0 - north[ 1 ], north[ 0 ], 0 );
+	if ( vectordot( cornerdiff, west ) > 0 )
+	{
+		if ( vectordot( cornerdiff, north ) > 0 )
+		{
+			northwest = corner1;
+			southeast = corner0;
+		}
+		else
+		{
+			side = vecscale( north, vectordot( cornerdiff, north ) );
+			northwest = corner1 - side;
+			southeast = corner0 + side;
+		}
+	}
+	else if ( vectordot( cornerdiff, north ) > 0 )
+	{
+		side = vecscale( north, vectordot( cornerdiff, north ) );
+		northwest = corner0 + side;
+		southeast = corner1 - side;
+	}
+	else
+	{
+		northwest = corner0;
+		southeast = corner1;
+	}
+	if ( requiredmapaspectratio > 0 )
+	{
+		northportion = vectordot( northwest - southeast, north );
+		westportion = vectordot( northwest - southeast, west );
+		mapaspectratio = westportion / northportion;
+		if ( mapaspectratio < requiredmapaspectratio )
+		{
+			incr = requiredmapaspectratio / mapaspectratio;
+			addvec = vecscale( west, westportion * ( incr - 1 ) * 0,5 );
+		}
+		else
+		{
+			incr = mapaspectratio / requiredmapaspectratio;
+			addvec = vecscale( north, northportion * ( incr - 1 ) * 0,5 );
+		}
+		northwest += addvec;
+		southeast -= addvec;
+	}
+	setminimap( material, northwest[ 0 ], northwest[ 1 ], southeast[ 0 ], southeast[ 1 ] );
+}
+
+vecscale( vec, scalar )
+{
+	return ( vec[ 0 ] * scalar, vec[ 1 ] * scalar, vec[ 2 ] * scalar );
+}

patch_mp/maps/mp/_createfxundo.gsc

@@ -0,0 +1,545 @@
+#include maps/mp/_createfxmenu;
+#include maps/mp/_createfx;
+#include maps/mp/_utility;
+#include common_scripts/utility;
+
+store_undo_state( change_type, ents )
+{
+	if ( !isDefined( level.cfx_undo_states ) )
+	{
+		level.cfx_undo_states = [];
+		level.cfx_redo_states = [];
+		level.cfx_limbo_state = spawnstruct();
+		level.cfx_max_states = 10;
+	}
+	if ( !isarray( ents ) )
+	{
+		ents = array( ents );
+	}
+	temp_array = [];
+	i = 0;
+	while ( i < ents.size )
+	{
+		temp_array[ i ] = copy_fx_ent( ents[ i ] );
+		i++;
+	}
+	state = spawnstruct();
+	state.operation = change_type;
+	state.last_action = level.cfx_last_action;
+	state.ent_array = temp_array;
+	if ( level.cfx_undo_states.size >= level.cfx_max_states )
+	{
+		level.cfx_undo_states = array_drop( level.cfx_undo_states );
+	}
+	level.cfx_undo_states[ level.cfx_undo_states.size ] = state;
+	level.cfx_redo_states = [];
+	level.cfx_limbo_state = undefined;
+	debug_print_latest_state( "undo" );
+}
+
+undo()
+{
+	if ( isDefined( level.createfxent ) || !isDefined( level.cfx_undo_states ) && level.cfx_undo_states.size < 1 )
+	{
+		return;
+	}
+	revert_state = level.cfx_undo_states[ level.cfx_undo_states.size - 1 ];
+	if ( level.cfx_last_action != "none" )
+	{
+		store_undo_state( "edit", level.selected_fx_ents );
+		move_undo_state_to_redo();
+		clear_entity_selection( "skip_undo" );
+		apply_state_change( "undo", revert_state );
+		move_undo_state_to_limbo();
+		level.cfx_last_action = "none";
+	}
+	else clear_entity_selection( "skip_undo" );
+	if ( revert_state.operation != "edit" )
+	{
+		apply_state_change( "undo", revert_state );
+		move_undo_state_to_redo();
+		level.cfx_last_action = "none";
+	}
+	else if ( isDefined( level.cfx_limbo_state ) )
+	{
+		move_limbo_state_to_redo();
+		apply_state_change( "undo", revert_state );
+		move_undo_state_to_limbo();
+		level.cfx_last_action = "none";
+	}
+	else
+	{
+		if ( level.cfx_undo_states.size > 1 )
+		{
+			move_undo_state_to_redo();
+			revert_state = level.cfx_undo_states[ level.cfx_undo_states.size - 1 ];
+		}
+		apply_state_change( "undo", revert_state );
+		move_undo_state_to_limbo();
+	}
+}
+
+apply_state_change( type, revert_state )
+{
+	if ( type == "undo" )
+	{
+/#
+		println( "^2CreateFX: Undo operation" );
+#/
+		if ( revert_state.operation == "edit" )
+		{
+			undo_edit( revert_state.ent_array );
+		}
+		else if ( revert_state.operation == "add" )
+		{
+			undo_add( revert_state.ent_array );
+		}
+		else
+		{
+			if ( revert_state.operation == "delete" )
+			{
+				undo_delete( revert_state.ent_array );
+			}
+		}
+	}
+	else /#
+	println( "^2CreateFX: Redo operation" );
+#/
+	if ( revert_state.operation == "edit" )
+	{
+		undo_edit( revert_state.ent_array );
+	}
+	else if ( revert_state.operation == "add" )
+	{
+		undo_delete( revert_state.ent_array );
+	}
+	else
+	{
+		if ( revert_state.operation == "delete" )
+		{
+			undo_add( revert_state.ent_array );
+		}
+	}
+}
+
+move_undo_state_to_redo()
+{
+	if ( level.cfx_redo_states.size >= level.cfx_max_states )
+	{
+		level.cfx_redo_states = array_drop( level.cfx_redo_states );
+	}
+	level.cfx_redo_states[ level.cfx_redo_states.size ] = level.cfx_undo_states[ level.cfx_undo_states.size - 1 ];
+	level.cfx_undo_states = array_pop( level.cfx_undo_states );
+	debug_print_latest_state( "undo" );
+	debug_print_latest_state( "redo" );
+}
+
+move_redo_state_to_undo()
+{
+	if ( level.cfx_undo_states.size >= level.cfx_max_states )
+	{
+		level.cfx_undo_states = array_drop( level.cfx_undo_states );
+	}
+	level.cfx_undo_states[ level.cfx_undo_states.size ] = level.cfx_redo_states[ level.cfx_redo_states.size - 1 ];
+	level.cfx_redo_states = array_pop( level.cfx_redo_states );
+	debug_print_latest_state( "undo" );
+	debug_print_latest_state( "redo" );
+}
+
+move_undo_state_to_limbo()
+{
+	level.cfx_limbo_state = level.cfx_undo_states[ level.cfx_undo_states.size - 1 ];
+	level.cfx_undo_states = array_pop( level.cfx_undo_states );
+	debug_print_latest_state( "undo" );
+	debug_print_latest_state( "limbo" );
+}
+
+move_redo_state_to_limbo()
+{
+	level.cfx_limbo_state = level.cfx_redo_states[ level.cfx_redo_states.size - 1 ];
+	level.cfx_redo_states = array_pop( level.cfx_redo_states );
+	debug_print_latest_state( "redo" );
+	debug_print_latest_state( "limbo" );
+}
+
+move_limbo_state_to_undo()
+{
+	if ( level.cfx_undo_states.size >= level.cfx_max_states )
+	{
+		level.cfx_undo_states = array_drop( level.cfx_undo_states );
+	}
+	level.cfx_undo_states[ level.cfx_undo_states.size ] = level.cfx_limbo_state;
+	level.cfx_limbo_state = undefined;
+	debug_print_latest_state( "undo" );
+	debug_print_latest_state( "limbo" );
+}
+
+move_limbo_state_to_redo()
+{
+	if ( level.cfx_redo_states.size >= level.cfx_max_states )
+	{
+		level.cfx_redo_states = array_drop( level.cfx_redo_states );
+	}
+	level.cfx_redo_states[ level.cfx_redo_states.size ] = level.cfx_limbo_state;
+	level.cfx_limbo_state = undefined;
+	debug_print_latest_state( "redo" );
+}
+
+undo_edit( ent_array )
+{
+	ent_array = reorder_ent_array_by_uniqueid( ent_array );
+/#
+	println( "^3CreateFX: Undoing edit" );
+	debug_print_ent_array( ent_array, "ent_array[]" );
+	debug_print_ent_array( level.createfxent, "level.createFXent[]" );
+#/
+	last_id = ent_array[ ent_array.size - 1 ].uniqueid;
+	if ( last_id > ( level.createfxent.size - 1 ) )
+	{
+		last_id = level.createfxent.size - 1;
+	}
+	j = ent_array.size - 1;
+	source_ent = ent_array[ j ];
+	i = last_id;
+	while ( i >= 0 )
+	{
+		target_ent = level.createfxent[ i ];
+		if ( source_ent.uniqueid == target_ent.uniqueid )
+		{
+			copy_values_between_fx_ents( source_ent, target_ent );
+			select_entity( i, target_ent, "skip_undo" );
+			j--;
+
+			if ( j < 0 )
+			{
+				break;
+			}
+			else
+			{
+				source_ent = ent_array[ j ];
+			}
+			i--;
+
+		}
+	}
+	update_selected_entities();
+/#
+	println( "^1CreateFX: Finished edit" );
+	debug_print_ent_array( level.createfxent, "level.createFXent[]" );
+#/
+}
+
+undo_add( ent_array )
+{
+	ent_array = reorder_ent_array_by_uniqueid( ent_array );
+/#
+	println( "^3createfx: Undoing add." );
+	debug_print_ent_array( ent_array, "ent_array[]" );
+	debug_print_ent_array( level.createfxent, "level.createFXent[]" );
+#/
+	last_id = ent_array[ ent_array.size - 1 ].uniqueid;
+	if ( last_id > ( level.createfxent.size - 1 ) )
+	{
+		last_id = level.createfxent.size - 1;
+	}
+	j = ent_array.size - 1;
+	source_ent = ent_array[ j ];
+	i = last_id;
+	while ( i >= 0 )
+	{
+		target_ent = level.createfxent[ i ];
+		if ( source_ent.uniqueid == target_ent.uniqueid )
+		{
+			if ( isDefined( target_ent.looper ) )
+			{
+				target_ent.looper delete();
+			}
+			target_ent notify( "stop_loop" );
+			j--;
+
+			if ( j < 0 )
+			{
+				break;
+			}
+			else
+			{
+				source_ent = ent_array[ j ];
+			}
+			i--;
+
+		}
+	}
+/#
+	debug_print_ent_array( level.createfxent, "level.createFXent[]" );
+	println( "createfx: Starting array_remove_undefined()" );
+#/
+	arrayremovevalue( level.createfxent, undefined );
+/#
+	println( "^1CreateFX: Finished undo add." );
+	debug_print_ent_array( level.createfxent, "level.createFXent[]" );
+#/
+	clear_fx_hudelements();
+}
+
+undo_delete( ent_array )
+{
+/#
+	println( "^3CreateFX: Undoing delete" );
+	debug_print_ent_array( ent_array, "ent_array in undo_delete()" );
+	debug_print_ent_array( level.createfxent, "level.createFXent[]" );
+#/
+	ent_array = reorder_ent_array_by_uniqueid( ent_array );
+	if ( level.createfxent.size == 0 )
+	{
+		i = 0;
+		while ( i < ent_array.size )
+		{
+			level.createfxent[ i ] = copy_fx_ent( ent_array[ i ] );
+			i++;
+		}
+	}
+	else temp_array = [];
+	i = 0;
+	j = 0;
+	while ( j < level.createfxent.size )
+	{
+		target_ent = level.createfxent[ j ];
+		if ( i >= ent_array.size )
+		{
+			temp_array[ temp_array.size ] = target_ent;
+			j++;
+			continue;
+		}
+		else source_ent = ent_array[ i ];
+		if ( target_ent.uniqueid < source_ent.uniqueid )
+		{
+			temp_array[ temp_array.size ] = target_ent;
+			j++;
+			continue;
+		}
+		else
+		{
+			temp_array[ temp_array.size ] = copy_fx_ent( source_ent );
+			j--;
+
+			i++;
+		}
+		j++;
+	}
+	while ( i < ent_array.size )
+	{
+		temp_array[ temp_array.size ] = ent_array[ i ];
+		i++;
+	}
+	level.createfxent = temp_array;
+/#
+	println( "^1Createfx: Finished undoing delete, pre-selection" );
+	debug_print_ent_array( level.createfxent, "level.createFXent[]" );
+#/
+	last_id = ent_array[ ent_array.size - 1 ].uniqueid;
+	if ( last_id > ( level.createfxent.size - 1 ) )
+	{
+		last_id = level.createfxent.size - 1;
+	}
+	j = ent_array.size - 1;
+	source_ent = ent_array[ j ];
+	i = last_id;
+	while ( i >= 0 )
+	{
+		target_ent = level.createfxent[ i ];
+		if ( source_ent.uniqueid == target_ent.uniqueid )
+		{
+			target_ent post_entity_creation_function();
+			select_entity( i, target_ent, "skip_undo" );
+			j--;
+
+			if ( j < 0 )
+			{
+				break;
+			}
+			else
+			{
+				source_ent = ent_array[ j ];
+			}
+			i--;
+
+		}
+	}
+	update_selected_entities();
+}
+
+redo()
+{
+	if ( isDefined( level.createfxent ) || !isDefined( level.cfx_redo_states ) && level.cfx_redo_states.size < 1 )
+	{
+		return;
+	}
+	clear_entity_selection( "skip_undo" );
+	if ( isDefined( level.cfx_limbo_state ) )
+	{
+		move_limbo_state_to_undo();
+		move_redo_state_to_limbo();
+		apply_state_change( "redo", level.cfx_limbo_state );
+	}
+	else revert_state = level.cfx_redo_states[ level.cfx_redo_states.size - 1 ];
+	apply_state_change( "redo", revert_state );
+	if ( revert_state.operation == "edit" )
+	{
+		move_redo_state_to_limbo();
+	}
+	else
+	{
+		move_redo_state_to_undo();
+	}
+	level.cfx_last_action = "none";
+}
+
+reorder_ent_array_by_uniqueid( ent_array )
+{
+	if ( ent_array.size <= 1 )
+	{
+		return ent_array;
+	}
+	array_size = ent_array.size;
+	i = 0;
+	while ( i < ( array_size - 1 ) )
+	{
+		j = i + 1;
+		while ( j < array_size )
+		{
+			if ( ent_array[ i ].uniqueid > ent_array[ j ].uniqueid )
+			{
+				temp_ent = ent_array[ i ];
+				ent_array[ i ] = ent_array[ j ];
+				ent_array[ j ] = temp_ent;
+			}
+			j++;
+		}
+		i++;
+	}
+	return ent_array;
+}
+
+copy_fx_ent( ent )
+{
+	temp_ent = spawnstruct();
+	temp_ent.drawn = ent.drawn;
+	temp_ent.drawn_axis_model = ent.drawn_axis_model;
+	temp_ent.last_fx_index = ent.last_fx_index;
+	temp_ent.textalpha = ent.textalpha;
+	temp_ent.uniqueid = ent.uniqueid;
+	temp_ent.v = ent.v;
+	return temp_ent;
+}
+
+copy_values_between_fx_ents( source, dest )
+{
+	dest.drawn = source.drawn;
+	dest.drawn_axis_model = source.drawn_axis_model;
+	dest.last_fx_index = source.last_fx_index;
+	dest.textalpha = source.textalpha;
+	dest.v = source.v;
+	return dest;
+}
+
+array_pop( array )
+{
+	array_size = array.size - 1;
+	temp_array = [];
+	if ( array_size <= 0 )
+	{
+		return temp_array;
+	}
+	i = 0;
+	while ( i < array_size )
+	{
+		temp_array[ i ] = array[ i ];
+		i++;
+	}
+	array = temp_array;
+	return array;
+}
+
+array_drop( array )
+{
+	if ( array.size > 0 )
+	{
+		temp_array = [];
+		i = 1;
+		while ( i < array.size )
+		{
+			temp_array[ i - 1 ] = array[ i ];
+			i++;
+		}
+		array = temp_array;
+	}
+	return array;
+}
+
+debug_print_ent_array( array, name )
+{
+/#
+	if ( isDefined( name ) )
+	{
+		println( "Printing out " + name );
+	}
+	else
+	{
+		println( "Printing out some array" );
+	}
+	i = 0;
+	while ( i < array.size )
+	{
+		if ( !isDefined( array[ i ] ) )
+		{
+			println( "" + i + ": deleted effect" );
+			i++;
+			continue;
+		}
+		else
+		{
+			println( "" + i + ": uniqueid: " + array[ i ].uniqueid + "  fxid: " + array[ i ].v[ "fxid" ] );
+		}
+		i++;
+#/
+	}
+}
+
+debug_print_latest_state( type )
+{
+/#
+	println( "^3Saving " + type + " state" );
+	if ( type == "undo" )
+	{
+		if ( !isDefined( level.cfx_undo_states[ level.cfx_undo_states.size - 1 ] ) )
+		{
+			println( "There are no undo states." );
+			return;
+		}
+		state = level.cfx_undo_states[ level.cfx_undo_states.size - 1 ];
+		size = level.cfx_undo_states.size - 1;
+	}
+	else if ( type == "redo" )
+	{
+		if ( !isDefined( level.cfx_redo_states[ level.cfx_redo_states.size - 1 ] ) )
+		{
+			println( "There are no redo states." );
+			return;
+		}
+		state = level.cfx_redo_states[ level.cfx_redo_states.size - 1 ];
+		size = level.cfx_redo_states.size - 1;
+	}
+	else
+	{
+		if ( !isDefined( level.cfx_limbo_state ) )
+		{
+			println( "There is no limbo state." );
+			return;
+		}
+		state = level.cfx_limbo_state;
+		size = 0;
+	}
+	println( "State " + size + " - " + state.operation + ": " + state.last_action );
+	debug_print_ent_array( state.ent_array, "save state ent_array" );
+#/
+}

patch_mp/maps/mp/_decoy.gsc

@@ -0,0 +1,355 @@
+#include maps/mp/_entityheadicons;
+#include maps/mp/gametypes/_weaponobjects;
+#include maps/mp/_utility;
+#include common_scripts/utility;
+
+init()
+{
+	level.decoyweapons = [];
+	level.decoyweapons[ "fullauto" ] = [];
+	level.decoyweapons[ "semiauto" ] = [];
+	level.decoyweapons[ "fullauto" ][ level.decoyweapons[ "fullauto" ].size ] = "uzi_mp";
+	level.decoyweapons[ "semiauto" ][ level.decoyweapons[ "semiauto" ].size ] = "m1911_mp";
+	level.decoyweapons[ "semiauto" ][ level.decoyweapons[ "semiauto" ].size ] = "python_mp";
+	level.decoyweapons[ "semiauto" ][ level.decoyweapons[ "semiauto" ].size ] = "cz75_mp";
+	level.decoyweapons[ "semiauto" ][ level.decoyweapons[ "semiauto" ].size ] = "fnfal_mp";
+}
+
+createdecoywatcher()
+{
+	watcher = self maps/mp/gametypes/_weaponobjects::createuseweaponobjectwatcher( "nightingale", "nightingale_mp", self.team );
+	watcher.onspawn = ::onspawndecoy;
+	watcher.detonate = ::decoydetonate;
+	watcher.deleteondifferentobjectspawn = 0;
+	watcher.headicon = 0;
+}
+
+onspawndecoy( watcher, owner )
+{
+	owner endon( "disconnect" );
+	self endon( "death" );
+	maps/mp/gametypes/_weaponobjects::onspawnuseweaponobject( watcher, owner );
+	self.initial_velocity = self getvelocity();
+	delay = 1;
+	wait delay;
+	decoy_time = 30;
+	spawn_time = getTime();
+	owner addweaponstat( "nightingale_mp", "used", 1 );
+	self thread simulateweaponfire( owner );
+	while ( 1 )
+	{
+		if ( getTime() > ( spawn_time + ( decoy_time * 1000 ) ) )
+		{
+			self destroydecoy( watcher, owner );
+			return;
+		}
+		wait 0,05;
+	}
+}
+
+movedecoy( owner, count, fire_time, main_dir, max_offset_angle )
+{
+	self endon( "death" );
+	self endon( "done" );
+	if ( !self isonground() )
+	{
+		return;
+	}
+	min_speed = 100;
+	max_speed = 200;
+	min_up_speed = 100;
+	max_up_speed = 200;
+	current_main_dir = randomintrange( main_dir - max_offset_angle, main_dir + max_offset_angle );
+	avel = ( randomfloatrange( 800, 1800 ) * ( ( randomintrange( 0, 2 ) * 2 ) - 1 ), 0, randomfloatrange( 580, 940 ) * ( ( randomintrange( 0, 2 ) * 2 ) - 1 ) );
+	intial_up = randomfloatrange( min_up_speed, max_up_speed );
+	start_time = getTime();
+	gravity = getDvarInt( "bg_gravity" );
+	i = 0;
+	while ( i < 1 )
+	{
+		angles = ( 0, randomintrange( current_main_dir - max_offset_angle, current_main_dir + max_offset_angle ), 0 );
+		dir = anglesToForward( angles );
+		dir = vectorScale( dir, randomfloatrange( min_speed, max_speed ) );
+		deltatime = ( getTime() - start_time ) * 0,001;
+		up = ( 0, 0, intial_up - ( 800 * deltatime ) );
+		self launch( dir + up, avel );
+		wait fire_time;
+		i++;
+	}
+}
+
+destroydecoy( watcher, owner )
+{
+	self notify( "done" );
+	self maps/mp/_entityheadicons::setentityheadicon( "none" );
+}
+
+decoydetonate( attacker )
+{
+	self notify( "done" );
+	self maps/mp/_entityheadicons::setentityheadicon( "none" );
+}
+
+getweaponfordecoy( owner )
+{
+	weapon = pickrandomweapon();
+	return weapon;
+}
+
+simulateweaponfire( owner )
+{
+	owner endon( "disconnect" );
+	self endon( "death" );
+	self endon( "done" );
+	weapon = getweaponfordecoy( owner );
+	if ( weapon == "none" )
+	{
+		return;
+	}
+	self thread watchforexplosion( owner, weapon );
+	self thread trackmaindirection();
+	self.max_offset_angle = 30;
+	weapon_class = getweaponclass( weapon );
+	switch( weapon_class )
+	{
+		case "weapon_assault":
+		case "weapon_cqb":
+		case "weapon_hmg":
+		case "weapon_lmg":
+		case "weapon_smg":
+			simulateweaponfiremachinegun( owner, weapon );
+			break;
+		case "weapon_sniper":
+			simulateweaponfiresniper( owner, weapon );
+			break;
+		case "weapon_pistol":
+			simulateweaponfirepistol( owner, weapon );
+			break;
+		case "weapon_shotgun":
+			simulateweaponfireshotgun( owner, weapon );
+			break;
+		default:
+			simulateweaponfiremachinegun( owner, weapon );
+			break;
+	}
+}
+
+simulateweaponfiremachinegun( owner, weapon )
+{
+	if ( weaponissemiauto( weapon ) )
+	{
+		simulateweaponfiremachinegunsemiauto( owner, weapon );
+	}
+	else
+	{
+		simulateweaponfiremachinegunfullauto( owner, weapon );
+	}
+}
+
+simulateweaponfiremachinegunsemiauto( owner, weapon )
+{
+	firetime = weaponfiretime( weapon );
+	clipsize = weaponclipsize( weapon );
+	reloadtime = weaponreloadtime( weapon );
+	burst_spacing_min = 4;
+	burst_spacing_max = 10;
+	while ( 1 )
+	{
+		if ( clipsize <= 1 )
+		{
+			burst_count = 1;
+		}
+		else
+		{
+			burst_count = randomintrange( 1, clipsize );
+		}
+		self thread movedecoy( owner, burst_count, firetime, self.main_dir, self.max_offset_angle );
+		self fireburst( owner, weapon, firetime, burst_count, 1 );
+		finishwhileloop( weapon, reloadtime, burst_spacing_min, burst_spacing_max );
+	}
+}
+
+simulateweaponfirepistol( owner, weapon )
+{
+	firetime = weaponfiretime( weapon );
+	clipsize = weaponclipsize( weapon );
+	reloadtime = weaponreloadtime( weapon );
+	burst_spacing_min = 0,5;
+	burst_spacing_max = 4;
+	while ( 1 )
+	{
+		burst_count = randomintrange( 1, clipsize );
+		self thread movedecoy( owner, burst_count, firetime, self.main_dir, self.max_offset_angle );
+		self fireburst( owner, weapon, firetime, burst_count, 0 );
+		finishwhileloop( weapon, reloadtime, burst_spacing_min, burst_spacing_max );
+	}
+}
+
+simulateweaponfireshotgun( owner, weapon )
+{
+	firetime = weaponfiretime( weapon );
+	clipsize = weaponclipsize( weapon );
+	reloadtime = weaponreloadtime( weapon );
+	if ( clipsize > 2 )
+	{
+		clipsize = 2;
+	}
+	burst_spacing_min = 0,5;
+	burst_spacing_max = 4;
+	while ( 1 )
+	{
+		burst_count = randomintrange( 1, clipsize );
+		self thread movedecoy( owner, burst_count, firetime, self.main_dir, self.max_offset_angle );
+		self fireburst( owner, weapon, firetime, burst_count, 0 );
+		finishwhileloop( weapon, reloadtime, burst_spacing_min, burst_spacing_max );
+	}
+}
+
+simulateweaponfiremachinegunfullauto( owner, weapon )
+{
+	firetime = weaponfiretime( weapon );
+	clipsize = weaponclipsize( weapon );
+	reloadtime = weaponreloadtime( weapon );
+	if ( clipsize > 30 )
+	{
+		clipsize = 30;
+	}
+	burst_spacing_min = 2;
+	burst_spacing_max = 6;
+	while ( 1 )
+	{
+		burst_count = randomintrange( int( clipsize * 0,6 ), clipsize );
+		interrupt = 0;
+		self thread movedecoy( owner, burst_count, firetime, self.main_dir, self.max_offset_angle );
+		self fireburst( owner, weapon, firetime, burst_count, interrupt );
+		finishwhileloop( weapon, reloadtime, burst_spacing_min, burst_spacing_max );
+	}
+}
+
+simulateweaponfiresniper( owner, weapon )
+{
+	firetime = weaponfiretime( weapon );
+	clipsize = weaponclipsize( weapon );
+	reloadtime = weaponreloadtime( weapon );
+	if ( clipsize > 2 )
+	{
+		clipsize = 2;
+	}
+	burst_spacing_min = 3;
+	burst_spacing_max = 5;
+	while ( 1 )
+	{
+		burst_count = randomintrange( 1, clipsize );
+		self thread movedecoy( owner, burst_count, firetime, self.main_dir, self.max_offset_angle );
+		self fireburst( owner, weapon, firetime, burst_count, 0 );
+		finishwhileloop( weapon, reloadtime, burst_spacing_min, burst_spacing_max );
+	}
+}
+
+fireburst( owner, weapon, firetime, count, interrupt )
+{
+	interrupt_shot = count;
+	if ( interrupt )
+	{
+		interrupt_shot = int( count * randomfloatrange( 0,6, 0,8 ) );
+	}
+	self fakefire( owner, self.origin, weapon, interrupt_shot );
+	wait ( firetime * interrupt_shot );
+	if ( interrupt )
+	{
+		self fakefire( owner, self.origin, weapon, count - interrupt_shot );
+		wait ( firetime * ( count - interrupt_shot ) );
+	}
+}
+
+finishwhileloop( weapon, reloadtime, burst_spacing_min, burst_spacing_max )
+{
+	if ( shouldplayreloadsound() )
+	{
+		playreloadsounds( weapon, reloadtime );
+	}
+	else
+	{
+		wait randomfloatrange( burst_spacing_min, burst_spacing_max );
+	}
+}
+
+playreloadsounds( weapon, reloadtime )
+{
+	divy_it_up = ( reloadtime - 0,1 ) / 2;
+	wait 0,1;
+	self playsound( "fly_assault_reload_npc_mag_out" );
+	wait divy_it_up;
+	self playsound( "fly_assault_reload_npc_mag_in" );
+	wait divy_it_up;
+}
+
+watchforexplosion( owner, weapon )
+{
+	self thread watchfordeathbeforeexplosion();
+	owner endon( "disconnect" );
+	self endon( "death_before_explode" );
+	self waittill( "explode", pos );
+	level thread doexplosion( owner, pos, weapon, randomintrange( 5, 10 ) );
+}
+
+watchfordeathbeforeexplosion()
+{
+	self waittill( "death" );
+	wait 0,1;
+	self notify( "death_before_explode" );
+}
+
+doexplosion( owner, pos, weapon, count )
+{
+	min_offset = 100;
+	max_offset = 500;
+	i = 0;
+	while ( i < count )
+	{
+		wait randomfloatrange( 0,1, 0,5 );
+		offset = ( randomfloatrange( min_offset, max_offset ) * ( ( randomintrange( 0, 2 ) * 2 ) - 1 ), randomfloatrange( min_offset, max_offset ) * ( ( randomintrange( 0, 2 ) * 2 ) - 1 ), 0 );
+		owner fakefire( owner, pos + offset, weapon, 1 );
+		i++;
+	}
+}
+
+pickrandomweapon()
+{
+	type = "fullauto";
+	if ( randomintrange( 0, 10 ) < 3 )
+	{
+		type = "semiauto";
+	}
+	randomval = randomintrange( 0, level.decoyweapons[ type ].size );
+/#
+	println( "Decoy type: " + type + " weapon: " + level.decoyweapons[ type ][ randomval ] );
+#/
+	return level.decoyweapons[ type ][ randomval ];
+}
+
+shouldplayreloadsound()
+{
+	if ( randomintrange( 0, 5 ) == 1 )
+	{
+		return 1;
+	}
+	return 0;
+}
+
+trackmaindirection()
+{
+	self endon( "death" );
+	self endon( "done" );
+	self.main_dir = int( vectorToAngle( ( self.initial_velocity[ 0 ], self.initial_velocity[ 1 ], 0 ) )[ 1 ] );
+	up = ( 0, 0, 1 );
+	while ( 1 )
+	{
+		self waittill( "grenade_bounce", pos, normal );
+		dot = vectordot( normal, up );
+		if ( dot < 0,5 && dot > -0,5 )
+		{
+			self.main_dir = int( vectorToAngle( ( normal[ 0 ], normal[ 1 ], 0 ) )[ 1 ] );
+		}
+	}
+}

patch_mp/maps/mp/_demo.gsc

@@ -0,0 +1,97 @@
+
+init()
+{
+	level.bookmark[ "kill" ] = 0;
+	level.bookmark[ "event" ] = 1;
+	level.bookmark[ "zm_round_end" ] = 2;
+	level.bookmark[ "zm_player_downed" ] = 3;
+	level.bookmark[ "zm_player_revived" ] = 4;
+	level.bookmark[ "zm_player_bledout" ] = 5;
+	level.bookmark[ "zm_player_use_magicbox" ] = 6;
+	level.bookmark[ "score_event" ] = 7;
+	level.bookmark[ "medal" ] = 8;
+	level.bookmark[ "round_result" ] = 9;
+	level.bookmark[ "game_result" ] = 10;
+	level.bookmark[ "zm_powerup_dropped" ] = 11;
+	level.bookmark[ "zm_player_powerup_grabbed" ] = 12;
+	level.bookmark[ "zm_player_perk" ] = 13;
+	level.bookmark[ "zm_power" ] = 14;
+	level.bookmark[ "zm_player_door" ] = 15;
+	level.bookmark[ "zm_player_buildable_placed" ] = 16;
+	level.bookmark[ "zm_player_use_packapunch" ] = 17;
+	level.bookmark[ "zm_player_rampage" ] = 18;
+	level.bookmark[ "zm_player_grenade_special" ] = 19;
+	level.bookmark[ "zm_player_grenade_multiattack" ] = 20;
+	level.bookmark[ "zm_player_meat_stink" ] = 21;
+	level.bookmark[ "zm_player_grabbed_magicbox" ] = 22;
+	level.bookmark[ "zm_player_grabbed_packapunch" ] = 23;
+	level.bookmark[ "zm_player_grenade_special_long" ] = 24;
+}
+
+bookmark( type, time, clientent1, clientent2, eventpriority, inflictorent, overrideentitycamera, actorent )
+{
+/#
+	assert( isDefined( level.bookmark[ type ] ), "Unable to find a bookmark type for type - " + type );
+#/
+	client1 = 255;
+	client2 = 255;
+	inflictorentnum = -1;
+	inflictorenttype = 0;
+	inflictorbirthtime = 0;
+	actorentnum = undefined;
+	scoreeventpriority = 0;
+	if ( isDefined( clientent1 ) )
+	{
+		client1 = clientent1 getentitynumber();
+	}
+	if ( isDefined( clientent2 ) )
+	{
+		client2 = clientent2 getentitynumber();
+	}
+	if ( isDefined( eventpriority ) )
+	{
+		scoreeventpriority = eventpriority;
+	}
+	if ( isDefined( inflictorent ) )
+	{
+		inflictorentnum = inflictorent getentitynumber();
+		inflictorenttype = inflictorent getentitytype();
+		if ( isDefined( inflictorent.birthtime ) )
+		{
+			inflictorbirthtime = inflictorent.birthtime;
+		}
+	}
+	if ( !isDefined( overrideentitycamera ) )
+	{
+		overrideentitycamera = 0;
+	}
+	if ( isDefined( actorent ) )
+	{
+		actorentnum = actorent getentitynumber();
+	}
+	adddemobookmark( level.bookmark[ type ], time, client1, client2, scoreeventpriority, inflictorentnum, inflictorenttype, inflictorbirthtime, overrideentitycamera, actorentnum );
+}
+
+gameresultbookmark( type, winningteamindex, losingteamindex )
+{
+/#
+	assert( isDefined( level.bookmark[ type ] ), "Unable to find a bookmark type for type - " + type );
+#/
+	client1 = 255;
+	client2 = 255;
+	scoreeventpriority = 0;
+	inflictorentnum = -1;
+	inflictorenttype = 0;
+	inflictorbirthtime = 0;
+	overrideentitycamera = 0;
+	actorentnum = undefined;
+	if ( isDefined( winningteamindex ) )
+	{
+		client1 = winningteamindex;
+	}
+	if ( isDefined( losingteamindex ) )
+	{
+		client2 = losingteamindex;
+	}
+	adddemobookmark( level.bookmark[ type ], getTime(), client1, client2, scoreeventpriority, inflictorentnum, inflictorenttype, inflictorbirthtime, overrideentitycamera, actorentnum );
+}

patch_mp/maps/mp/_destructible.gsc

@@ -0,0 +1,480 @@
+#include maps/mp/_challenges;
+#include maps/mp/gametypes/_globallogic_player;
+#include common_scripts/utility;
+#include maps/mp/_utility;
+
+#using_animtree( "mp_vehicles" );
+
+init()
+{
+	level.destructible_callbacks = [];
+	destructibles = getentarray( "destructible", "targetname" );
+	if ( destructibles.size <= 0 )
+	{
+		return;
+	}
+	precacheitem( "destructible_car_mp" );
+	precacheitem( "explodable_barrel_mp" );
+	i = 0;
+	while ( i < destructibles.size )
+	{
+		if ( getsubstr( destructibles[ i ].destructibledef, 0, 4 ) == "veh_" )
+		{
+			destructibles[ i ] thread destructible_car_death_think();
+			destructibles[ i ] thread destructible_car_grenade_stuck_think();
+			i++;
+			continue;
+		}
+		else if ( issubstr( destructibles[ i ].destructibledef, "barrel" ) )
+		{
+			destructibles[ i ] thread destructible_barrel_death_think();
+			i++;
+			continue;
+		}
+		else if ( issubstr( destructibles[ i ].destructibledef, "gaspump" ) )
+		{
+			destructibles[ i ] thread destructible_barrel_death_think();
+			i++;
+			continue;
+		}
+		else
+		{
+			if ( destructibles[ i ].destructibledef == "fxdest_upl_metal_tank_01" )
+			{
+				destructibles[ i ] thread destructible_tank_grenade_stuck_think();
+			}
+		}
+		i++;
+	}
+	destructible_anims = [];
+	destructible_anims[ "car" ] = %veh_car_destroy;
+}
+
+destructible_event_callback( destructible_event, attacker, weapon )
+{
+	explosion_radius = 0;
+	if ( issubstr( destructible_event, "explode" ) && destructible_event != "explode" )
+	{
+		tokens = strtok( destructible_event, "_" );
+		explosion_radius = tokens[ 1 ];
+		if ( explosion_radius == "sm" )
+		{
+			explosion_radius = 150;
+		}
+		else if ( explosion_radius == "lg" )
+		{
+			explosion_radius = 450;
+		}
+		else
+		{
+			explosion_radius = int( explosion_radius );
+		}
+		destructible_event = "explode_complex";
+	}
+	if ( issubstr( destructible_event, "simple_timed_explosion" ) )
+	{
+		self thread simple_timed_explosion( destructible_event, attacker );
+		return;
+	}
+	switch( destructible_event )
+	{
+		case "destructible_car_explosion":
+			self destructible_car_explosion( attacker );
+			if ( isDefined( weapon ) )
+			{
+				self.destroyingweapon = weapon;
+			}
+			break;
+		case "destructible_car_fire":
+			self thread destructible_car_fire_think( attacker );
+			if ( isDefined( weapon ) )
+			{
+				self.destroyingweapon = weapon;
+			}
+			break;
+		case "destructible_barrel_fire":
+			self thread destructible_barrel_fire_think( attacker );
+			break;
+		case "destructible_barrel_explosion":
+			self destructible_barrel_explosion( attacker );
+			break;
+		case "explode":
+			self thread simple_explosion( attacker );
+			break;
+		case "explode_complex":
+			self thread complex_explosion( attacker, explosion_radius );
+			break;
+		default:
+		}
+		if ( isDefined( level.destructible_callbacks[ destructible_event ] ) )
+		{
+			self thread [[ level.destructible_callbacks[ destructible_event ] ]]( destructible_event, attacker );
+		}
+	}
+}
+
+simple_explosion( attacker )
+{
+	if ( is_true( self.exploded ) )
+	{
+		return;
+	}
+	self.exploded = 1;
+	offset = vectorScale( ( 0, 0, 1 ), 5 );
+	self radiusdamage( self.origin + offset, 256, 300, 75, attacker, "MOD_EXPLOSIVE", "explodable_barrel_mp" );
+	physicsexplosionsphere( self.origin, 255, 254, 0,3, 400, 25 );
+	if ( isDefined( attacker ) )
+	{
+		self dodamage( self.health + 10000, self.origin + offset, attacker );
+	}
+	else
+	{
+		self dodamage( self.health + 10000, self.origin + offset );
+	}
+}
+
+simple_timed_explosion( destructible_event, attacker )
+{
+	self endon( "death" );
+	wait_times = [];
+	str = getsubstr( destructible_event, 23 );
+	tokens = strtok( str, "_" );
+	i = 0;
+	while ( i < tokens.size )
+	{
+		wait_times[ wait_times.size ] = int( tokens[ i ] );
+		i++;
+	}
+	if ( wait_times.size <= 0 )
+	{
+		wait_times[ 0 ] = 5;
+		wait_times[ 1 ] = 10;
+	}
+	wait randomintrange( wait_times[ 0 ], wait_times[ 1 ] );
+	simple_explosion( attacker );
+}
+
+complex_explosion( attacker, max_radius )
+{
+	offset = vectorScale( ( 0, 0, 1 ), 5 );
+	if ( isDefined( attacker ) )
+	{
+		self radiusdamage( self.origin + offset, max_radius, 300, 100, attacker );
+	}
+	else
+	{
+		self radiusdamage( self.origin + offset, max_radius, 300, 100 );
+	}
+	playrumbleonposition( "grenade_rumble", self.origin );
+	earthquake( 0,5, 0,5, self.origin, max_radius );
+	physicsexplosionsphere( self.origin + offset, max_radius, max_radius - 1, 0,3 );
+	if ( isDefined( attacker ) )
+	{
+		self dodamage( 20000, self.origin + offset, attacker );
+	}
+	else
+	{
+		self dodamage( 20000, self.origin + offset );
+	}
+}
+
+destructible_car_explosion( attacker, physics_explosion )
+{
+	if ( self.car_dead )
+	{
+		return;
+	}
+	if ( !isDefined( physics_explosion ) )
+	{
+		physics_explosion = 1;
+	}
+	players = get_players();
+	i = 0;
+	while ( i < players.size )
+	{
+		body = players[ i ].body;
+		if ( !isDefined( body ) )
+		{
+			i++;
+			continue;
+		}
+		else if ( distancesquared( body.origin, self.origin ) > 9216 )
+		{
+			i++;
+			continue;
+		}
+		else
+		{
+			if ( ( body.origin[ 2 ] - ( self.origin[ 2 ] + 32 ) ) > 0 )
+			{
+				body.origin = ( body.origin[ 0 ], body.origin[ 1 ], body.origin[ 2 ] + 16 );
+			}
+			body maps/mp/gametypes/_globallogic_player::start_explosive_ragdoll();
+		}
+		i++;
+	}
+	self notify( "car_dead" );
+	self.car_dead = 1;
+	self thread destructible_car_explosion_animate();
+	if ( isDefined( attacker ) )
+	{
+		self radiusdamage( self.origin, 256, 300, 75, attacker, "MOD_EXPLOSIVE", "destructible_car_mp" );
+	}
+	else
+	{
+		self radiusdamage( self.origin, 256, 300, 75 );
+	}
+	playrumbleonposition( "grenade_rumble", self.origin );
+	earthquake( 0,5, 0,5, self.origin, 800 );
+	if ( physics_explosion )
+	{
+		physicsexplosionsphere( self.origin, 255, 254, 0,3, 400, 25 );
+	}
+	if ( isDefined( attacker ) )
+	{
+		attacker thread maps/mp/_challenges::destroyed_car();
+	}
+	level.globalcarsdestroyed++;
+	if ( isDefined( attacker ) )
+	{
+		self dodamage( self.health + 10000, self.origin + ( 0, 0, 1 ), attacker );
+	}
+	else
+	{
+		self dodamage( self.health + 10000, self.origin + ( 0, 0, 1 ) );
+	}
+	self setclientflag( 3 );
+}
+
+destructible_tank_grenade_stuck_think()
+{
+	self endon( "destructible_base_piece_death" );
+	self endon( "death" );
+	for ( ;; )
+	{
+		self waittill( "grenade_stuck", missile );
+		if ( !isDefined( missile ) || !isDefined( missile.model ) )
+		{
+			continue;
+		}
+		else
+		{
+			if ( missile.model != "t5_weapon_crossbow_bolt" || missile.model == "t6_wpn_grenade_semtex_projectile" && missile.model == "t6_wpn_c4_world" )
+			{
+				self thread destructible_tank_grenade_stuck_explode( missile );
+			}
+		}
+	}
+}
+
+destructible_tank_grenade_stuck_explode( missile )
+{
+	self endon( "destructible_base_piece_death" );
+	self endon( "death" );
+	owner = getmissileowner( missile );
+	if ( isDefined( owner ) && missile.model == "t6_wpn_c4_world" )
+	{
+		owner endon( "disconnect" );
+		owner endon( "weapon_object_destroyed" );
+		missile endon( "picked_up" );
+		missile thread destructible_tank_hacked_c4( self );
+	}
+	missile waittill( "explode" );
+	if ( isDefined( owner ) )
+	{
+		self dodamage( self.health + 10000, self.origin + ( 0, 0, 1 ), owner );
+	}
+	else
+	{
+		self dodamage( self.health + 10000, self.origin + ( 0, 0, 1 ) );
+	}
+}
+
+destructible_tank_hacked_c4( tank )
+{
+	tank endon( "destructible_base_piece_death" );
+	tank endon( "death" );
+	self endon( "death" );
+	self waittill( "hacked" );
+	self notify( "picked_up" );
+	tank thread destructible_tank_grenade_stuck_explode( self );
+}
+
+destructible_car_death_think()
+{
+	self endon( "car_dead" );
+	self.car_dead = 0;
+	self thread destructible_car_death_notify();
+	self waittill( "destructible_base_piece_death", attacker );
+	if ( isDefined( self ) )
+	{
+		self thread destructible_car_explosion( attacker, 0 );
+	}
+}
+
+destructible_car_grenade_stuck_think()
+{
+	self endon( "destructible_base_piece_death" );
+	self endon( "car_dead" );
+	self endon( "death" );
+	for ( ;; )
+	{
+		self waittill( "grenade_stuck", missile );
+		if ( !isDefined( missile ) || !isDefined( missile.model ) )
+		{
+			continue;
+		}
+		else
+		{
+			if ( missile.model != "t5_weapon_crossbow_bolt" || missile.model == "t6_wpn_grenade_semtex_projectile" && missile.model == "t6_wpn_c4_world" )
+			{
+				self thread destructible_car_grenade_stuck_explode( missile );
+			}
+		}
+	}
+}
+
+destructible_car_grenade_stuck_explode( missile )
+{
+	self endon( "destructible_base_piece_death" );
+	self endon( "car_dead" );
+	self endon( "death" );
+	owner = getmissileowner( missile );
+	if ( isDefined( owner ) && missile.model == "t6_wpn_c4_world" )
+	{
+		owner endon( "disconnect" );
+		owner endon( "weapon_object_destroyed" );
+		missile endon( "picked_up" );
+		missile thread destructible_car_hacked_c4( self );
+	}
+	missile waittill( "explode" );
+	if ( isDefined( owner ) )
+	{
+		self dodamage( self.health + 10000, self.origin + ( 0, 0, 1 ), owner );
+	}
+	else
+	{
+		self dodamage( self.health + 10000, self.origin + ( 0, 0, 1 ) );
+	}
+}
+
+destructible_car_hacked_c4( car )
+{
+	car endon( "destructible_base_piece_death" );
+	car endon( "car_dead" );
+	car endon( "death" );
+	self endon( "death" );
+	self waittill( "hacked" );
+	self notify( "picked_up" );
+	car thread destructible_car_grenade_stuck_explode( self );
+}
+
+destructible_car_death_notify()
+{
+	self endon( "car_dead" );
+	self waittill( "death", attacker );
+	self notify( "destructible_base_piece_death" );
+}
+
+destructible_car_explosion_animate()
+{
+	self setclientflag( 12 );
+	end_origin = self.origin;
+	self.origin = ( self.origin[ 0 ], self.origin[ 1 ], self.origin[ 2 ] + 16 );
+	wait 0,3;
+	items = getdroppedweapons();
+	i = 0;
+	while ( i < items.size )
+	{
+		if ( distancesquared( end_origin, items[ i ].origin ) < 16384 )
+		{
+			if ( ( items[ i ].origin[ 2 ] - ( end_origin[ 2 ] + 32 ) ) > 0 )
+			{
+				items[ i ] delete();
+			}
+		}
+		i++;
+	}
+	self moveto( end_origin, 0,3, 0,15 );
+	self clearclientflag( 12 );
+}
+
+destructible_car_fire_think( attacker )
+{
+	self endon( "death" );
+	wait randomintrange( 7, 10 );
+	self thread destructible_car_explosion( attacker );
+}
+
+codecallback_destructibleevent( event, param1, param2, param3 )
+{
+	if ( event == "broken" )
+	{
+		notify_type = param1;
+		attacker = param2;
+		weapon = param3;
+		destructible_event_callback( notify_type, attacker, weapon );
+		self notify( event );
+	}
+	else
+	{
+		if ( event == "breakafter" )
+		{
+			piece = param1;
+			time = param2;
+			damage = param3;
+			self thread breakafter( time, damage, piece );
+		}
+	}
+}
+
+breakafter( time, damage, piece )
+{
+	self notify( "breakafter" );
+	self endon( "breakafter" );
+	wait time;
+	self dodamage( damage, self.origin, undefined, undefined );
+}
+
+destructible_barrel_death_think()
+{
+	self endon( "barrel_dead" );
+	self waittill( "death", attacker );
+	if ( isDefined( self ) )
+	{
+		self thread destructible_barrel_explosion( attacker, 0 );
+	}
+}
+
+destructible_barrel_fire_think( attacker )
+{
+	self endon( "barrel_dead" );
+	self endon( "explode" );
+	self endon( "death" );
+	wait randomintrange( 7, 10 );
+	self thread destructible_barrel_explosion( attacker );
+}
+
+destructible_barrel_explosion( attacker, physics_explosion )
+{
+	if ( !isDefined( physics_explosion ) )
+	{
+		physics_explosion = 1;
+	}
+	self notify( "barrel_dead" );
+	if ( isDefined( self.target ) )
+	{
+		dest_clip = getent( self.target, "targetname" );
+		dest_clip delete();
+	}
+	self radiusdamage( self.origin, 256, 300, 75, attacker, "MOD_EXPLOSIVE", "explodable_barrel_mp" );
+	playrumbleonposition( "grenade_rumble", self.origin );
+	earthquake( 0,5, 0,5, self.origin, 800 );
+	if ( physics_explosion )
+	{
+		physicsexplosionsphere( self.origin, 255, 254, 0,3, 400, 25 );
+	}
+	level.globalbarrelsdestroyed++;
+	self dodamage( self.health + 10000, self.origin + ( 0, 0, 1 ), attacker );
+	self setclientflag( 3 );
+}

patch_mp/maps/mp/_development_dvars.gsc

@@ -0,0 +1,6 @@
+#include maps/mp/_utility;
+#include common_scripts/utility;
+
+init()
+{
+}

patch_mp/maps/mp/_empgrenade.gsc

@@ -0,0 +1,184 @@
+#include maps/mp/killstreaks/_emp;
+#include common_scripts/utility;
+#include maps/mp/_utility;
+
+init()
+{
+	precacheshellshock( "flashbang" );
+	thread onplayerconnect();
+}
+
+onplayerconnect()
+{
+	for ( ;; )
+	{
+		level waittill( "connected", player );
+		player thread onplayerspawned();
+	}
+}
+
+onplayerspawned()
+{
+	self endon( "disconnect" );
+	for ( ;; )
+	{
+		self waittill( "spawned_player" );
+		self thread monitorempgrenade();
+	}
+}
+
+monitorempgrenade()
+{
+	self endon( "disconnect" );
+	self endon( "death" );
+	self.empendtime = 0;
+	for ( ;; )
+	{
+		while ( 1 )
+		{
+			self waittill( "emp_grenaded", attacker );
+			if ( !isalive( self ) || self hasperk( "specialty_immuneemp" ) )
+			{
+				continue;
+			}
+			hurtvictim = 1;
+			hurtattacker = 0;
+/#
+			assert( isDefined( self.team ) );
+#/
+			if ( level.teambased && isDefined( attacker ) && isDefined( attacker.team ) && attacker.team == self.team && attacker != self )
+			{
+				if ( level.friendlyfire == 0 )
+				{
+				}
+			}
+			else if ( level.friendlyfire == 1 )
+			{
+				hurtattacker = 0;
+				hurtvictim = 1;
+				break;
+			}
+			else if ( level.friendlyfire == 2 )
+			{
+				hurtvictim = 0;
+				hurtattacker = 1;
+				break;
+			}
+			else
+			{
+				if ( level.friendlyfire == 3 )
+				{
+					hurtattacker = 1;
+					hurtvictim = 1;
+				}
+			}
+		}
+		if ( hurtvictim && isDefined( self ) )
+		{
+			self thread applyemp( attacker );
+		}
+		if ( hurtattacker && isDefined( attacker ) )
+		{
+			attacker thread applyemp( attacker );
+		}
+	}
+}
+
+applyemp( attacker )
+{
+	self notify( "applyEmp" );
+	self endon( "applyEmp" );
+	self endon( "disconnect" );
+	self endon( "death" );
+	wait 0,05;
+	if ( self == attacker )
+	{
+		if ( isDefined( self.empendtime ) )
+		{
+			emp_time_left_ms = self.empendtime - getTime();
+			if ( emp_time_left_ms > 1000 )
+			{
+				self.empduration = emp_time_left_ms / 1000;
+			}
+			else
+			{
+				self.empduration = 1;
+			}
+		}
+		else
+		{
+			self.empduration = 1;
+		}
+	}
+	else
+	{
+		self.empduration = 12;
+	}
+	self.empgrenaded = 1;
+	self shellshock( "flashbang", 1 );
+	self.empendtime = getTime() + ( self.empduration * 1000 );
+	self thread emprumbleloop( 0,75 );
+	self setempjammed( 1 );
+	self thread empgrenadedeathwaiter();
+	wait self.empduration;
+	self notify( "empGrenadeTimedOut" );
+	self checktoturnoffemp();
+}
+
+empgrenadedeathwaiter()
+{
+	self notify( "empGrenadeDeathWaiter" );
+	self endon( "empGrenadeDeathWaiter" );
+	self endon( "empGrenadeTimedOut" );
+	self waittill( "death" );
+	self checktoturnoffemp();
+}
+
+checktoturnoffemp()
+{
+	self.empgrenaded = 0;
+	if ( level.teambased || maps/mp/killstreaks/_emp::emp_isteamemped( self.team ) && !level.teambased && isDefined( level.empplayer ) && level.empplayer != self )
+	{
+		return;
+	}
+	self setempjammed( 0 );
+}
+
+emprumbleloop( duration )
+{
+	self endon( "emp_rumble_loop" );
+	self notify( "emp_rumble_loop" );
+	goaltime = getTime() + ( duration * 1000 );
+	while ( getTime() < goaltime )
+	{
+		self playrumbleonentity( "damage_heavy" );
+		wait 0,05;
+	}
+}
+
+watchempexplosion( owner, weaponname )
+{
+	owner endon( "disconnect" );
+	owner endon( "team_changed" );
+	self endon( "shutdown_empgrenade" );
+	self thread watchempgrenadeshutdown();
+	owner addweaponstat( weaponname, "used", 1 );
+	self waittill( "explode", origin, surface );
+	ents = getdamageableentarray( origin, 512 );
+	_a223 = ents;
+	_k223 = getFirstArrayKey( _a223 );
+	while ( isDefined( _k223 ) )
+	{
+		ent = _a223[ _k223 ];
+		ent dodamage( 1, origin, owner, owner, "none", "MOD_GRENADE_SPLASH", 0, weaponname );
+		_k223 = getNextArrayKey( _a223, _k223 );
+	}
+}
+
+watchempgrenadeshutdown()
+{
+	self endon( "explode" );
+	self waittill( "death" );
+	wait 0,05;
+	self notify( "shutdown_empgrenade" );
+}

patch_mp/maps/mp/_entityheadicons.gsc

@@ -0,0 +1,162 @@
+#include common_scripts/utility;
+
+init()
+{
+	if ( isDefined( level.initedentityheadicons ) )
+	{
+		return;
+	}
+	if ( level.createfx_enabled )
+	{
+		return;
+	}
+	level.initedentityheadicons = 1;
+/#
+	assert( isDefined( game[ "entity_headicon_allies" ] ), "Allied head icons are not defined.  Check the team set for the level." );
+#/
+/#
+	assert( isDefined( game[ "entity_headicon_axis" ] ), "Axis head icons are not defined.  Check the team set for the level." );
+#/
+	precacheshader( game[ "entity_headicon_allies" ] );
+	precacheshader( game[ "entity_headicon_axis" ] );
+	if ( !level.teambased )
+	{
+		return;
+	}
+	level.entitieswithheadicons = [];
+}
+
+setentityheadicon( team, owner, offset, icon, constant_size )
+{
+	if ( !level.teambased && !isDefined( owner ) )
+	{
+		return;
+	}
+	if ( !isDefined( constant_size ) )
+	{
+		constant_size = 0;
+	}
+	if ( !isDefined( self.entityheadiconteam ) )
+	{
+		self.entityheadiconteam = "none";
+		self.entityheadicons = [];
+	}
+	if ( level.teambased && !isDefined( owner ) )
+	{
+		if ( team == self.entityheadiconteam )
+		{
+			return;
+		}
+		self.entityheadiconteam = team;
+	}
+	if ( isDefined( offset ) )
+	{
+		self.entityheadiconoffset = offset;
+	}
+	else
+	{
+		self.entityheadiconoffset = ( 0, 0, 0 );
+	}
+	while ( isDefined( self.entityheadicons ) )
+	{
+		i = 0;
+		while ( i < self.entityheadicons.size )
+		{
+			if ( isDefined( self.entityheadicons[ i ] ) )
+			{
+				self.entityheadicons[ i ] destroy();
+			}
+			i++;
+		}
+	}
+	self.entityheadicons = [];
+	self notify( "kill_entity_headicon_thread" );
+	if ( !isDefined( icon ) )
+	{
+		icon = game[ "entity_headicon_" + team ];
+	}
+	if ( isDefined( owner ) && !level.teambased )
+	{
+		if ( !isplayer( owner ) )
+		{
+/#
+			assert( isDefined( owner.owner ), "entity has to have an owner if it's not a player" );
+#/
+			owner = owner.owner;
+		}
+		owner updateentityheadclienticon( self, icon, constant_size );
+	}
+	else
+	{
+		if ( isDefined( owner ) && team != "none" )
+		{
+			owner updateentityheadteamicon( self, team, icon, constant_size );
+		}
+	}
+	self thread destroyheadiconsondeath();
+}
+
+updateentityheadteamicon( entity, team, icon, constant_size )
+{
+	headicon = newteamhudelem( team );
+	headicon.archived = 1;
+	headicon.x = entity.entityheadiconoffset[ 0 ];
+	headicon.y = entity.entityheadiconoffset[ 1 ];
+	headicon.z = entity.entityheadiconoffset[ 2 ];
+	headicon.alpha = 0,8;
+	headicon setshader( icon, 6, 6 );
+	headicon setwaypoint( constant_size );
+	headicon settargetent( entity );
+	entity.entityheadicons[ entity.entityheadicons.size ] = headicon;
+}
+
+updateentityheadclienticon( entity, icon, constant_size )
+{
+	headicon = newclienthudelem( self );
+	headicon.archived = 1;
+	headicon.x = entity.entityheadiconoffset[ 0 ];
+	headicon.y = entity.entityheadiconoffset[ 1 ];
+	headicon.z = entity.entityheadiconoffset[ 2 ];
+	headicon.alpha = 0,8;
+	headicon setshader( icon, 6, 6 );
+	headicon setwaypoint( constant_size );
+	headicon settargetent( entity );
+	entity.entityheadicons[ entity.entityheadicons.size ] = headicon;
+}
+
+destroyheadiconsondeath()
+{
+	self waittill_any( "death", "hacked" );
+	i = 0;
+	while ( i < self.entityheadicons.size )
+	{
+		if ( isDefined( self.entityheadicons[ i ] ) )
+		{
+			self.entityheadicons[ i ] destroy();
+		}
+		i++;
+	}
+}
+
+destroyentityheadicons()
+{
+	while ( isDefined( self.entityheadicons ) )
+	{
+		i = 0;
+		while ( i < self.entityheadicons.size )
+		{
+			if ( isDefined( self.entityheadicons[ i ] ) )
+			{
+				self.entityheadicons[ i ] destroy();
+			}
+			i++;
+		}
+	}
+}
+
+updateentityheadiconpos( headicon )
+{
+	headicon.x = self.origin[ 0 ] + self.entityheadiconoffset[ 0 ];
+	headicon.y = self.origin[ 1 ] + self.entityheadiconoffset[ 1 ];
+	headicon.z = self.origin[ 2 ] + self.entityheadiconoffset[ 2 ];
+}

patch_mp/maps/mp/_explosive_bolt.gsc

@@ -0,0 +1,12 @@
+#include common_scripts/utility;
+#include maps/mp/_utility;
+
+init()
+{
+	loadfx( "weapon/crossbow/fx_trail_crossbow_blink_grn_os" );
+	loadfx( "weapon/crossbow/fx_trail_crossbow_blink_red_os" );
+}
+
+watch_bolt_detonation( owner )
+{
+}

patch_mp/maps/mp/_flashgrenades.gsc

@@ -0,0 +1,205 @@
+#include maps/mp/_utility;
+
+main()
+{
+	precacheshellshock( "flashbang" );
+	level.sound_flash_start = "";
+	level.sound_flash_loop = "";
+	level.sound_flash_stop = "";
+}
+
+startmonitoringflash()
+{
+	self thread monitorflash();
+}
+
+stopmonitoringflash( disconnected )
+{
+	self notify( "stop_monitoring_flash" );
+}
+
+flashrumbleloop( duration )
+{
+	self endon( "stop_monitoring_flash" );
+	self endon( "flash_rumble_loop" );
+	self notify( "flash_rumble_loop" );
+	goaltime = getTime() + ( duration * 1000 );
+	while ( getTime() < goaltime )
+	{
+		self playrumbleonentity( "damage_heavy" );
+		wait 0,05;
+	}
+}
+
+monitorflash_internal( amount_distance, amount_angle, attacker, direct_on_player )
+{
+	hurtattacker = 0;
+	hurtvictim = 1;
+	if ( amount_angle < 0,5 )
+	{
+		amount_angle = 0,5;
+	}
+	else
+	{
+		if ( amount_angle > 0,8 )
+		{
+			amount_angle = 1;
+		}
+	}
+	if ( isDefined( attacker ) && attacker == self )
+	{
+		amount_distance *= 0,5;
+	}
+	duration = amount_distance * amount_angle * 6;
+	if ( duration < 0,25 )
+	{
+		return;
+	}
+	rumbleduration = undefined;
+	if ( duration > 2 )
+	{
+		rumbleduration = 0,75;
+	}
+	else
+	{
+		rumbleduration = 0,25;
+	}
+/#
+	assert( isDefined( self.team ) );
+#/
+	if ( level.teambased && isDefined( attacker ) && isDefined( attacker.team ) && attacker.team == self.team && attacker != self )
+	{
+		if ( level.friendlyfire == 0 )
+		{
+			return;
+		}
+		else if ( level.friendlyfire == 1 )
+		{
+		}
+		else if ( level.friendlyfire == 2 )
+		{
+			duration *= 0,5;
+			rumbleduration *= 0,5;
+			hurtvictim = 0;
+			hurtattacker = 1;
+		}
+		else
+		{
+			if ( level.friendlyfire == 3 )
+			{
+				duration *= 0,5;
+				rumbleduration *= 0,5;
+				hurtattacker = 1;
+			}
+		}
+	}
+	if ( self hasperk( "specialty_flashprotection" ) )
+	{
+		duration *= 0,1;
+		rumbleduration *= 0,1;
+	}
+	if ( hurtvictim )
+	{
+		if ( self mayapplyscreeneffect() || !direct_on_player && self isremotecontrolling() )
+		{
+			if ( self != attacker )
+			{
+				attacker addweaponstat( "flash_grenade_mp", "hits", 1 );
+				attacker addweaponstat( "flash_grenade_mp", "used", 1 );
+			}
+			self thread applyflash( duration, rumbleduration, attacker );
+		}
+	}
+	if ( hurtattacker )
+	{
+		if ( attacker mayapplyscreeneffect() )
+		{
+			attacker thread applyflash( duration, rumbleduration, attacker );
+		}
+	}
+}
+
+monitorflash()
+{
+	self endon( "disconnect" );
+	self.flashendtime = 0;
+	while ( 1 )
+	{
+		self waittill( "flashbang", amount_distance, amount_angle, attacker );
+		while ( !isalive( self ) )
+		{
+			continue;
+		}
+		self monitorflash_internal( amount_distance, amount_angle, attacker, 1 );
+	}
+}
+
+monitorrcbombflash()
+{
+	self endon( "death" );
+	self.flashendtime = 0;
+	while ( 1 )
+	{
+		self waittill( "flashbang", amount_distance, amount_angle, attacker );
+		driver = self getseatoccupant( 0 );
+		if ( !isDefined( driver ) || !isalive( driver ) )
+		{
+			continue;
+		}
+		driver monitorflash_internal( amount_distance, amount_angle, attacker, 0 );
+	}
+}
+
+applyflash( duration, rumbleduration, attacker )
+{
+	if ( !isDefined( self.flashduration ) || duration > self.flashduration )
+	{
+		self.flashduration = duration;
+	}
+	if ( !isDefined( self.flashrumbleduration ) || rumbleduration > self.flashrumbleduration )
+	{
+		self.flashrumbleduration = rumbleduration;
+	}
+	self thread playflashsound( duration );
+	wait 0,05;
+	if ( isDefined( self.flashduration ) )
+	{
+		self shellshock( "flashbang", self.flashduration, 0 );
+		self.flashendtime = getTime() + ( self.flashduration * 1000 );
+		self.lastflashedby = attacker;
+	}
+	if ( isDefined( self.flashrumbleduration ) )
+	{
+		self thread flashrumbleloop( self.flashrumbleduration );
+	}
+	self.flashduration = undefined;
+	self.flashrumbleduration = undefined;
+}
+
+playflashsound( duration )
+{
+	self endon( "death" );
+	self endon( "disconnect" );
+	flashsound = spawn( "script_origin", ( 0, 0, 1 ) );
+	flashsound.origin = self.origin;
+	flashsound linkto( self );
+	flashsound thread deleteentonownerdeath( self );
+	flashsound playsound( level.sound_flash_start );
+	flashsound playloopsound( level.sound_flash_loop );
+	if ( duration > 0,5 )
+	{
+		wait ( duration - 0,5 );
+	}
+	flashsound playsound( level.sound_flash_start );
+	flashsound stoploopsound( 0,5 );
+	wait 0,5;
+	flashsound notify( "delete" );
+	flashsound delete();
+}
+
+deleteentonownerdeath( owner )
+{
+	self endon( "delete" );
+	owner waittill( "death" );
+	self delete();
+}

patch_mp/maps/mp/_fx.gsc

@@ -0,0 +1,458 @@
+#include maps/mp/_createfx;
+#include maps/mp/_utility;
+#include common_scripts/utility;
+
+print_org( fxcommand, fxid, fxpos, waittime )
+{
+/#
+	if ( getDvar( "debug" ) == "1" )
+	{
+		println( "{" );
+		println( ""origin" "" + fxpos[ 0 ] + " " + fxpos[ 1 ] + " " + fxpos[ 2 ] + """ );
+		println( ""classname" "script_model"" );
+		println( ""model" "fx"" );
+		println( ""script_fxcommand" "" + fxcommand + """ );
+		println( ""script_fxid" "" + fxid + """ );
+		println( ""script_delay" "" + waittime + """ );
+		println( "}" );
+#/
+	}
+}
+
+oneshotfx( fxid, fxpos, waittime, fxpos2 )
+{
+}
+
+oneshotfxthread()
+{
+	wait 0,05;
+	if ( self.v[ "delay" ] > 0 )
+	{
+		wait self.v[ "delay" ];
+	}
+	create_triggerfx();
+}
+
+create_triggerfx()
+{
+	self.looper = spawnfx_wrapper( self.v[ "fxid" ], self.v[ "origin" ], self.v[ "forward" ], self.v[ "up" ] );
+	triggerfx( self.looper, self.v[ "delay" ] );
+	create_loopsound();
+}
+
+exploderfx( num, fxid, fxpos, waittime, fxpos2, firefx, firefxdelay, firefxsound, fxsound, fxquake, fxdamage, soundalias, repeat, delay_min, delay_max, damage_radius, firefxtimeout, exploder_group )
+{
+	if ( 1 )
+	{
+		ent = createexploder( fxid );
+		ent.v[ "origin" ] = fxpos;
+		ent.v[ "angles" ] = ( 0, 0, 0 );
+		if ( isDefined( fxpos2 ) )
+		{
+			ent.v[ "angles" ] = vectorToAngle( fxpos2 - fxpos );
+		}
+		ent.v[ "delay" ] = waittime;
+		ent.v[ "exploder" ] = num;
+		return;
+	}
+	fx = spawn( "script_origin", ( 0, 0, 0 ) );
+	fx.origin = fxpos;
+	fx.angles = vectorToAngle( fxpos2 - fxpos );
+	fx.script_exploder = num;
+	fx.script_fxid = fxid;
+	fx.script_delay = waittime;
+	fx.script_firefx = firefx;
+	fx.script_firefxdelay = firefxdelay;
+	fx.script_firefxsound = firefxsound;
+	fx.script_sound = fxsound;
+	fx.script_earthquake = fxquake;
+	fx.script_damage = fxdamage;
+	fx.script_radius = damage_radius;
+	fx.script_soundalias = soundalias;
+	fx.script_firefxtimeout = firefxtimeout;
+	fx.script_repeat = repeat;
+	fx.script_delay_min = delay_min;
+	fx.script_delay_max = delay_max;
+	fx.script_exploder_group = exploder_group;
+	forward = anglesToForward( fx.angles );
+	forward = vectorScale( forward, 150 );
+	fx.targetpos = fxpos + forward;
+	if ( !isDefined( level._script_exploders ) )
+	{
+		level._script_exploders = [];
+	}
+	level._script_exploders[ level._script_exploders.size ] = fx;
+	maps/mp/_createfx::createfx_showorigin( fxid, fxpos, waittime, fxpos2, "exploderfx", fx, undefined, firefx, firefxdelay, firefxsound, fxsound, fxquake, fxdamage, soundalias, repeat, delay_min, delay_max, damage_radius, firefxtimeout );
+}
+
+loopfx( fxid, fxpos, waittime, fxpos2, fxstart, fxstop, timeout )
+{
+/#
+	println( "Loopfx is deprecated!" );
+#/
+	ent = createloopeffect( fxid );
+	ent.v[ "origin" ] = fxpos;
+	ent.v[ "angles" ] = ( 0, 0, 0 );
+	if ( isDefined( fxpos2 ) )
+	{
+		ent.v[ "angles" ] = vectorToAngle( fxpos2 - fxpos );
+	}
+	ent.v[ "delay" ] = waittime;
+}
+
+create_looper()
+{
+	self.looper = playloopedfx( level._effect[ self.v[ "fxid" ] ], self.v[ "delay" ], self.v[ "origin" ], 0, self.v[ "forward" ], self.v[ "up" ] );
+	create_loopsound();
+}
+
+create_loopsound()
+{
+	self notify( "stop_loop" );
+	if ( isDefined( self.v[ "soundalias" ] ) && self.v[ "soundalias" ] != "nil" )
+	{
+		if ( isDefined( self.looper ) )
+		{
+			self.looper thread maps/mp/_utility::loop_fx_sound( self.v[ "soundalias" ], self.v[ "origin" ], "death" );
+			return;
+		}
+		else
+		{
+			thread maps/mp/_utility::loop_fx_sound( self.v[ "soundalias" ], self.v[ "origin" ], "stop_loop" );
+		}
+	}
+}
+
+stop_loopsound()
+{
+	self notify( "stop_loop" );
+}
+
+loopfxthread()
+{
+	wait 0,05;
+	if ( isDefined( self.fxstart ) )
+	{
+		level waittill( "start fx" + self.fxstart );
+	}
+	while ( 1 )
+	{
+		create_looper();
+		if ( isDefined( self.timeout ) )
+		{
+			thread loopfxstop( self.timeout );
+		}
+		if ( isDefined( self.fxstop ) )
+		{
+			level waittill( "stop fx" + self.fxstop );
+		}
+		else
+		{
+			return;
+		}
+		if ( isDefined( self.looper ) )
+		{
+			self.looper delete();
+		}
+		if ( isDefined( self.fxstart ) )
+		{
+			level waittill( "start fx" + self.fxstart );
+			continue;
+		}
+		else
+		{
+			return;
+		}
+	}
+}
+
+loopfxchangeid( ent )
+{
+	self endon( "death" );
+	ent waittill( "effect id changed", change );
+}
+
+loopfxchangeorg( ent )
+{
+	self endon( "death" );
+	for ( ;; )
+	{
+		ent waittill( "effect org changed", change );
+		self.origin = change;
+	}
+}
+
+loopfxchangedelay( ent )
+{
+	self endon( "death" );
+	ent waittill( "effect delay changed", change );
+}
+
+loopfxdeletion( ent )
+{
+	self endon( "death" );
+	ent waittill( "effect deleted" );
+	self delete();
+}
+
+loopfxstop( timeout )
+{
+	self endon( "death" );
+	wait timeout;
+	self.looper delete();
+}
+
+loopsound( sound, pos, waittime )
+{
+	level thread loopsoundthread( sound, pos, waittime );
+}
+
+loopsoundthread( sound, pos, waittime )
+{
+	org = spawn( "script_origin", pos );
+	org.origin = pos;
+	org playloopsound( sound );
+}
+
+gunfireloopfx( fxid, fxpos, shotsmin, shotsmax, shotdelaymin, shotdelaymax, betweensetsmin, betweensetsmax )
+{
+	thread gunfireloopfxthread( fxid, fxpos, shotsmin, shotsmax, shotdelaymin, shotdelaymax, betweensetsmin, betweensetsmax );
+}
+
+gunfireloopfxthread( fxid, fxpos, shotsmin, shotsmax, shotdelaymin, shotdelaymax, betweensetsmin, betweensetsmax )
+{
+	level endon( "stop all gunfireloopfx" );
+	wait 0,05;
+	if ( betweensetsmax < betweensetsmin )
+	{
+		temp = betweensetsmax;
+		betweensetsmax = betweensetsmin;
+		betweensetsmin = temp;
+	}
+	betweensetsbase = betweensetsmin;
+	betweensetsrange = betweensetsmax - betweensetsmin;
+	if ( shotdelaymax < shotdelaymin )
+	{
+		temp = shotdelaymax;
+		shotdelaymax = shotdelaymin;
+		shotdelaymin = temp;
+	}
+	shotdelaybase = shotdelaymin;
+	shotdelayrange = shotdelaymax - shotdelaymin;
+	if ( shotsmax < shotsmin )
+	{
+		temp = shotsmax;
+		shotsmax = shotsmin;
+		shotsmin = temp;
+	}
+	shotsbase = shotsmin;
+	shotsrange = shotsmax - shotsmin;
+	fxent = spawnfx( level._effect[ fxid ], fxpos );
+	for ( ;; )
+	{
+		shotnum = shotsbase + randomint( shotsrange );
+		i = 0;
+		while ( i < shotnum )
+		{
+			triggerfx( fxent );
+			wait ( shotdelaybase + randomfloat( shotdelayrange ) );
+			i++;
+		}
+		wait ( betweensetsbase + randomfloat( betweensetsrange ) );
+	}
+}
+
+gunfireloopfxvec( fxid, fxpos, fxpos2, shotsmin, shotsmax, shotdelaymin, shotdelaymax, betweensetsmin, betweensetsmax )
+{
+	thread gunfireloopfxvecthread( fxid, fxpos, fxpos2, shotsmin, shotsmax, shotdelaymin, shotdelaymax, betweensetsmin, betweensetsmax );
+}
+
+gunfireloopfxvecthread( fxid, fxpos, fxpos2, shotsmin, shotsmax, shotdelaymin, shotdelaymax, betweensetsmin, betweensetsmax )
+{
+	level endon( "stop all gunfireloopfx" );
+	wait 0,05;
+	if ( betweensetsmax < betweensetsmin )
+	{
+		temp = betweensetsmax;
+		betweensetsmax = betweensetsmin;
+		betweensetsmin = temp;
+	}
+	betweensetsbase = betweensetsmin;
+	betweensetsrange = betweensetsmax - betweensetsmin;
+	if ( shotdelaymax < shotdelaymin )
+	{
+		temp = shotdelaymax;
+		shotdelaymax = shotdelaymin;
+		shotdelaymin = temp;
+	}
+	shotdelaybase = shotdelaymin;
+	shotdelayrange = shotdelaymax - shotdelaymin;
+	if ( shotsmax < shotsmin )
+	{
+		temp = shotsmax;
+		shotsmax = shotsmin;
+		shotsmin = temp;
+	}
+	shotsbase = shotsmin;
+	shotsrange = shotsmax - shotsmin;
+	fxpos2 = vectornormalize( fxpos2 - fxpos );
+	fxent = spawnfx( level._effect[ fxid ], fxpos, fxpos2 );
+	for ( ;; )
+	{
+		shotnum = shotsbase + randomint( shotsrange );
+		i = 0;
+		while ( i < int( shotnum / level.fxfireloopmod ) )
+		{
+			triggerfx( fxent );
+			delay = ( shotdelaybase + randomfloat( shotdelayrange ) ) * level.fxfireloopmod;
+			if ( delay < 0,05 )
+			{
+				delay = 0,05;
+			}
+			wait delay;
+			i++;
+		}
+		wait ( shotdelaybase + randomfloat( shotdelayrange ) );
+		wait ( betweensetsbase + randomfloat( betweensetsrange ) );
+	}
+}
+
+setfireloopmod( value )
+{
+	level.fxfireloopmod = 1 / value;
+}
+
+setup_fx()
+{
+	if ( isDefined( self.script_fxid ) || !isDefined( self.script_fxcommand ) && !isDefined( self.script_delay ) )
+	{
+		return;
+	}
+	org = undefined;
+	if ( isDefined( self.target ) )
+	{
+		ent = getent( self.target, "targetname" );
+		if ( isDefined( ent ) )
+		{
+			org = ent.origin;
+		}
+	}
+	fxstart = undefined;
+	if ( isDefined( self.script_fxstart ) )
+	{
+		fxstart = self.script_fxstart;
+	}
+	fxstop = undefined;
+	if ( isDefined( self.script_fxstop ) )
+	{
+		fxstop = self.script_fxstop;
+	}
+	if ( self.script_fxcommand == "OneShotfx" )
+	{
+		oneshotfx( self.script_fxid, self.origin, self.script_delay, org );
+	}
+	if ( self.script_fxcommand == "loopfx" )
+	{
+		loopfx( self.script_fxid, self.origin, self.script_delay, org, fxstart, fxstop );
+	}
+	if ( self.script_fxcommand == "loopsound" )
+	{
+		loopsound( self.script_fxid, self.origin, self.script_delay );
+	}
+	self delete();
+}
+
+script_print_fx()
+{
+/#
+	if ( isDefined( self.script_fxid ) || !isDefined( self.script_fxcommand ) && !isDefined( self.script_delay ) )
+	{
+		println( "Effect at origin ", self.origin, " doesn't have script_fxid/script_fxcommand/script_delay" );
+		self delete();
+		return;
+	}
+	if ( isDefined( self.target ) )
+	{
+		org = getent( self.target, "targetname" ).origin;
+	}
+	else
+	{
+		org = "undefined";
+	}
+	if ( self.script_fxcommand == "OneShotfx" )
+	{
+		println( "mapsmp_fx::OneShotfx("" + self.script_fxid + "", " + self.origin + ", " + self.script_delay + ", " + org + ");" );
+	}
+	if ( self.script_fxcommand == "loopfx" )
+	{
+		println( "mapsmp_fx::LoopFx("" + self.script_fxid + "", " + self.origin + ", " + self.script_delay + ", " + org + ");" );
+	}
+	if ( self.script_fxcommand == "loopsound" )
+	{
+		println( "mapsmp_fx::LoopSound("" + self.script_fxid + "", " + self.origin + ", " + self.script_delay + ", " + org + ");" );
+#/
+	}
+}
+
+script_playfx( id, pos, pos2 )
+{
+	if ( !id )
+	{
+		return;
+	}
+	if ( isDefined( pos2 ) )
+	{
+		playfx( id, pos, pos2 );
+	}
+	else
+	{
+		playfx( id, pos );
+	}
+}
+
+script_playfxontag( id, ent, tag )
+{
+	if ( !id )
+	{
+		return;
+	}
+	playfxontag( id, ent, tag );
+}
+
+grenadeexplosionfx( pos )
+{
+	playfx( level._effect[ "mechanical explosion" ], pos );
+	earthquake( 0,15, 0,5, pos, 250 );
+}
+
+soundfx( fxid, fxpos, endonnotify )
+{
+	org = spawn( "script_origin", ( 0, 0, 0 ) );
+	org.origin = fxpos;
+	org playloopsound( fxid );
+	if ( isDefined( endonnotify ) )
+	{
+		org thread soundfxdelete( endonnotify );
+	}
+}
+
+soundfxdelete( endonnotify )
+{
+	level waittill( endonnotify );
+	self delete();
+}
+
+blenddelete( blend )
+{
+	self waittill( "death" );
+	blend delete();
+}
+
+spawnfx_wrapper( fx_id, origin, forward, up )
+{
+/#
+	assert( isDefined( level._effect[ fx_id ] ), "Missing level._effect["" + fx_id + ""]. You did not setup the fx before calling it in createFx." );
+#/
+	fx_object = spawnfx( level._effect[ fx_id ], origin, forward, up );
+	return fx_object;
+}

patch_mp/maps/mp/_fxanim.gsc

@@ -0,0 +1,6 @@
+
+init()
+{
+	level.scr_anim = [];
+	level.scr_anim[ "fxanim_props" ] = [];
+}

patch_mp/maps/mp/_gameadvertisement.gsc

@@ -0,0 +1,530 @@
+#include maps/mp/gametypes/_dev;
+#include maps/mp/gametypes/_globallogic_utils;
+#include maps/mp/_utility;
+
+init()
+{
+/#
+	level.sessionadvertstatus = 1;
+	thread sessionadvertismentupdatedebughud();
+#/
+	thread sessionadvertisementcheck();
+}
+
+setadvertisedstatus( onoff )
+{
+/#
+	level.sessionadvertstatus = onoff;
+#/
+	changeadvertisedstatus( onoff );
+}
+
+sessionadvertisementcheck()
+{
+	if ( sessionmodeisprivate() )
+	{
+		return;
+	}
+	if ( sessionmodeiszombiesgame() )
+	{
+		setadvertisedstatus( 0 );
+		return;
+	}
+	runrules = getgametyperules();
+	if ( !isDefined( runrules ) )
+	{
+		return;
+	}
+	level endon( "game_end" );
+	level waittill( "prematch_over" );
+	while ( 1 )
+	{
+		sessionadvertcheckwait = getdvarintdefault( "sessionAdvertCheckwait", 1 );
+		wait sessionadvertcheckwait;
+		advertise = [[ runrules ]]();
+		setadvertisedstatus( advertise );
+	}
+}
+
+getgametyperules()
+{
+	gametype = level.gametype;
+	switch( gametype )
+	{
+		case "dm":
+			return ::dm_rules;
+		case "tdm":
+			return ::tdm_rules;
+		case "dom":
+			return ::dom_rules;
+		case "hq":
+			return ::hq_rules;
+		case "sd":
+			return ::sd_rules;
+		case "dem":
+			return ::dem_rules;
+		case "ctf":
+			return ::ctf_rules;
+		case "koth":
+			return ::koth_rules;
+		case "conf":
+			return ::conf_rules;
+		case "oic":
+			return ::oic_rules;
+		case "sas":
+			return ::sas_rules;
+		case "gun":
+			return ::gun_rules;
+		case "shrp":
+			return ::shrp_rules;
+	}
+	return;
+}
+
+teamscorelimitcheck( rulescorepercent )
+{
+	if ( level.scorelimit )
+	{
+		minscorepercentageleft = 100;
+		_a100 = level.teams;
+		_k100 = getFirstArrayKey( _a100 );
+		while ( isDefined( _k100 ) )
+		{
+			team = _a100[ _k100 ];
+			scorepercentageleft = 100 - ( ( game[ "teamScores" ][ team ] / level.scorelimit ) * 100 );
+			if ( minscorepercentageleft > scorepercentageleft )
+			{
+				minscorepercentageleft = scorepercentageleft;
+			}
+			if ( rulescorepercent >= scorepercentageleft )
+			{
+/#
+				updatedebughud( 3, "Score Percentage Left: ", int( scorepercentageleft ) );
+#/
+				return 0;
+			}
+			_k100 = getNextArrayKey( _a100, _k100 );
+		}
+/#
+		updatedebughud( 3, "Score Percentage Left: ", int( minscorepercentageleft ) );
+#/
+	}
+	return 1;
+}
+
+timelimitcheck( ruletimeleft )
+{
+	maxtime = level.timelimit;
+	if ( maxtime != 0 )
+	{
+		timeleft = maps/mp/gametypes/_globallogic_utils::gettimeremaining();
+		if ( ruletimeleft >= timeleft )
+		{
+			return 0;
+		}
+	}
+	return 1;
+}
+
+dm_rules()
+{
+	rulescorepercent = 35;
+	ruletimeleft = 60000 * 1,5;
+/#
+	updatedebughud( 1, "Any player is within percent of score cap: ", rulescorepercent );
+	updatedebughud( 2, "Time limit has less than minutes remaining: ", ruletimeleft / 60000 );
+#/
+	if ( level.scorelimit )
+	{
+		highestscore = 0;
+		players = get_players();
+		i = 0;
+		while ( i < players.size )
+		{
+			if ( players[ i ].pointstowin > highestscore )
+			{
+				highestscore = players[ i ].pointstowin;
+			}
+			i++;
+		}
+		scorepercentageleft = 100 - ( ( highestscore / level.scorelimit ) * 100 );
+/#
+		updatedebughud( 3, "Score Percentage Left: ", int( scorepercentageleft ) );
+#/
+		if ( rulescorepercent >= scorepercentageleft )
+		{
+			return 0;
+		}
+	}
+	if ( timelimitcheck( ruletimeleft ) == 0 )
+	{
+		return 0;
+	}
+	return 1;
+}
+
+tdm_rules()
+{
+	rulescorepercent = 15;
+	ruletimeleft = 60000 * 1,5;
+/#
+	updatedebughud( 1, "Any player is within percent of score cap: ", rulescorepercent );
+	updatedebughud( 2, "Time limit has less than minutes remaining: ", ruletimeleft / 60000 );
+#/
+	if ( teamscorelimitcheck( rulescorepercent ) == 0 )
+	{
+		return 0;
+	}
+	if ( timelimitcheck( ruletimeleft ) == 0 )
+	{
+		return 0;
+	}
+	return 1;
+}
+
+dom_rules()
+{
+	rulescorepercent = 15;
+	ruletimeleft = 60000 * 1,5;
+	ruleround = 3;
+	currentround = game[ "roundsplayed" ] + 1;
+/#
+	updatedebughud( 1, "Time limit 1.5 minutes remaining in final round. Any player is within percent of score cap: ", rulescorepercent );
+	updatedebughud( 2, "Is round: ", ruleround );
+	updatedebughud( 4, "Current Round: ", currentround );
+#/
+	if ( currentround >= 2 )
+	{
+		if ( teamscorelimitcheck( rulescorepercent ) == 0 )
+		{
+			return 0;
+		}
+	}
+	if ( timelimitcheck( ruletimeleft ) == 0 )
+	{
+		return 0;
+	}
+	if ( ruleround <= currentround )
+	{
+		return 0;
+	}
+	return 1;
+}
+
+hq_rules()
+{
+	return koth_rules();
+}
+
+sd_rules()
+{
+	ruleround = 3;
+/#
+	updatedebughud( 1, "Any team has won rounds: ", ruleround );
+#/
+	maxroundswon = 0;
+	_a299 = level.teams;
+	_k299 = getFirstArrayKey( _a299 );
+	while ( isDefined( _k299 ) )
+	{
+		team = _a299[ _k299 ];
+		roundswon = game[ "teamScores" ][ team ];
+		if ( maxroundswon < roundswon )
+		{
+			maxroundswon = roundswon;
+		}
+		if ( ruleround <= roundswon )
+		{
+/#
+			updatedebughud( 3, "Max Rounds Won: ", maxroundswon );
+#/
+			return 0;
+		}
+		_k299 = getNextArrayKey( _a299, _k299 );
+	}
+/#
+	updatedebughud( 3, "Max Rounds Won: ", maxroundswon );
+#/
+	return 1;
+}
+
+dem_rules()
+{
+	return ctf_rules();
+}
+
+ctf_rules()
+{
+	ruleround = 3;
+	roundsplayed = game[ "roundsplayed" ];
+/#
+	updatedebughud( 1, "Is round or later: ", ruleround );
+	updatedebughud( 3, "Rounds Played: ", roundsplayed );
+#/
+	if ( ruleround <= roundsplayed )
+	{
+		return 0;
+	}
+	return 1;
+}
+
+koth_rules()
+{
+	rulescorepercent = 20;
+	ruletimeleft = 60000 * 1,5;
+/#
+	updatedebughud( 1, "Any player is within percent of score cap: ", rulescorepercent );
+	updatedebughud( 2, "Time limit has less than minutes remaining: ", ruletimeleft / 60000 );
+#/
+	if ( teamscorelimitcheck( rulescorepercent ) == 0 )
+	{
+		return 0;
+	}
+	if ( timelimitcheck( ruletimeleft ) == 0 )
+	{
+		return 0;
+	}
+	return 1;
+}
+
+conf_rules()
+{
+	return tdm_rules();
+}
+
+oic_rules()
+{
+/#
+	updatedebughud( 1, "No join in progress, so shouldn’t advertise to matchmaking once the countdown timer ends.", 0 );
+#/
+	return 0;
+}
+
+sas_rules()
+{
+	rulescorepercent = 35;
+	ruletimeleft = 60000 * 1,5;
+/#
+	updatedebughud( 1, "Any player is within percent of score cap: ", rulescorepercent );
+	updatedebughud( 2, "Time limit has less than minutes remaining: ", ruletimeleft / 60000 );
+#/
+	if ( teamscorelimitcheck( rulescorepercent ) == 0 )
+	{
+		return 0;
+	}
+	if ( timelimitcheck( ruletimeleft ) == 0 )
+	{
+		return 0;
+	}
+	return 1;
+}
+
+gun_rules()
+{
+	ruleweaponsleft = 3;
+/#
+	updatedebughud( 1, "Any player is within X weapons from winning: ", ruleweaponsleft );
+#/
+	minweaponsleft = level.gunprogression.size;
+	_a455 = level.players;
+	_k455 = getFirstArrayKey( _a455 );
+	while ( isDefined( _k455 ) )
+	{
+		player = _a455[ _k455 ];
+		weaponsleft = level.gunprogression.size - player.gunprogress;
+		if ( minweaponsleft > weaponsleft )
+		{
+			minweaponsleft = weaponsleft;
+		}
+		if ( ruleweaponsleft >= minweaponsleft )
+		{
+/#
+			updatedebughud( 3, "Weapons Left: ", minweaponsleft );
+#/
+			return 0;
+		}
+		_k455 = getNextArrayKey( _a455, _k455 );
+	}
+/#
+	updatedebughud( 3, "Weapons Left: ", minweaponsleft );
+#/
+	return 1;
+}
+
+shrp_rules()
+{
+	rulescorepercent = 35;
+	ruletimeleft = 60000 * 1,5;
+/#
+	updatedebughud( 1, "Any player is within percent of score cap: ", rulescorepercent );
+	updatedebughud( 2, "Time limit has less than minutes remaining: ", ruletimeleft / 60000 );
+#/
+	if ( teamscorelimitcheck( rulescorepercent ) == 0 )
+	{
+		return 0;
+	}
+	if ( timelimitcheck( ruletimeleft ) == 0 )
+	{
+		return 0;
+	}
+	return 1;
+}
+
+sessionadvertismentcreatedebughud( linenum, alignx )
+{
+/#
+	debug_hud = maps/mp/gametypes/_dev::new_hud( "session_advert", "debug_hud", 0, 0, 1 );
+	debug_hud.hidewheninmenu = 1;
+	debug_hud.horzalign = "right";
+	debug_hud.vertalign = "middle";
+	debug_hud.alignx = "right";
+	debug_hud.aligny = "middle";
+	debug_hud.x = alignx;
+	debug_hud.y = -50 + ( linenum * 15 );
+	debug_hud.foreground = 1;
+	debug_hud.font = "default";
+	debug_hud.fontscale = 1,5;
+	debug_hud.color = ( 1, 0, 0 );
+	debug_hud.alpha = 1;
+	debug_hud settext( "" );
+	return debug_hud;
+#/
+}
+
+updatedebughud( hudindex, text, value )
+{
+/#
+	switch( hudindex )
+	{
+		case 1:
+			level.sessionadverthud_1a_text = text;
+			level.sessionadverthud_1b_text = value;
+			break;
+		case 2:
+			level.sessionadverthud_2a_text = text;
+			level.sessionadverthud_2b_text = value;
+			break;
+		case 3:
+			level.sessionadverthud_3a_text = text;
+			level.sessionadverthud_3b_text = value;
+			break;
+		case 4:
+			level.sessionadverthud_4a_text = text;
+			level.sessionadverthud_4b_text = value;
+			break;
+	}
+#/
+}
+
+sessionadvertismentupdatedebughud()
+{
+/#
+	level endon( "game_end" );
+	sessionadverthud_0 = undefined;
+	sessionadverthud_1a = undefined;
+	sessionadverthud_1b = undefined;
+	sessionadverthud_2a = undefined;
+	sessionadverthud_2b = undefined;
+	sessionadverthud_3a = undefined;
+	sessionadverthud_3b = undefined;
+	sessionadverthud_4a = undefined;
+	sessionadverthud_4b = undefined;
+	level.sessionadverthud_0_text = "";
+	level.sessionadverthud_1a_text = "";
+	level.sessionadverthud_1b_text = "";
+	level.sessionadverthud_2a_text = "";
+	level.sessionadverthud_2b_text = "";
+	level.sessionadverthud_3a_text = "";
+	level.sessionadverthud_3b_text = "";
+	level.sessionadverthud_4a_text = "";
+	level.sessionadverthud_4b_text = "";
+	while ( 1 )
+	{
+		wait 1;
+		showdebughud = getdvarintdefault( "sessionAdvertShowDebugHud", 0 );
+		level.sessionadverthud_0_text = "Session is advertised";
+		if ( level.sessionadvertstatus == 0 )
+		{
+			level.sessionadverthud_0_text = "Session is not advertised";
+		}
+		if ( !isDefined( sessionadverthud_0 ) && showdebughud != 0 )
+		{
+			host = gethostplayer();
+			while ( !isDefined( host ) )
+			{
+				continue;
+			}
+			sessionadverthud_0 = host sessionadvertismentcreatedebughud( 0, 0 );
+			sessionadverthud_1a = host sessionadvertismentcreatedebughud( 1, -20 );
+			sessionadverthud_1b = host sessionadvertismentcreatedebughud( 1, 0 );
+			sessionadverthud_2a = host sessionadvertismentcreatedebughud( 2, -20 );
+			sessionadverthud_2b = host sessionadvertismentcreatedebughud( 2, 0 );
+			sessionadverthud_3a = host sessionadvertismentcreatedebughud( 3, -20 );
+			sessionadverthud_3b = host sessionadvertismentcreatedebughud( 3, 0 );
+			sessionadverthud_4a = host sessionadvertismentcreatedebughud( 4, -20 );
+			sessionadverthud_4b = host sessionadvertismentcreatedebughud( 4, 0 );
+			sessionadverthud_1a.color = vectorScale( ( 1, 0, 0 ), 0,5 );
+			sessionadverthud_1b.color = vectorScale( ( 1, 0, 0 ), 0,5 );
+			sessionadverthud_2a.color = vectorScale( ( 1, 0, 0 ), 0,5 );
+			sessionadverthud_2b.color = vectorScale( ( 1, 0, 0 ), 0,5 );
+		}
+		if ( isDefined( sessionadverthud_0 ) )
+		{
+			if ( showdebughud == 0 )
+			{
+				sessionadverthud_0 destroy();
+				sessionadverthud_1a destroy();
+				sessionadverthud_1b destroy();
+				sessionadverthud_2a destroy();
+				sessionadverthud_2b destroy();
+				sessionadverthud_3a destroy();
+				sessionadverthud_3b destroy();
+				sessionadverthud_4a destroy();
+				sessionadverthud_4b destroy();
+				sessionadverthud_0 = undefined;
+				sessionadverthud_1a = undefined;
+				sessionadverthud_1b = undefined;
+				sessionadverthud_2a = undefined;
+				sessionadverthud_2b = undefined;
+				sessionadverthud_3a = undefined;
+				sessionadverthud_3b = undefined;
+				sessionadverthud_4a = undefined;
+				sessionadverthud_4b = undefined;
+				break;
+			}
+			else
+			{
+				if ( level.sessionadvertstatus == 1 )
+				{
+					sessionadverthud_0.color = ( 1, 0, 0 );
+				}
+				else
+				{
+					sessionadverthud_0.color = vectorScale( ( 1, 0, 0 ), 0,9 );
+				}
+				sessionadverthud_0 settext( level.sessionadverthud_0_text );
+				if ( level.sessionadverthud_1a_text != "" )
+				{
+					sessionadverthud_1a settext( level.sessionadverthud_1a_text );
+					sessionadverthud_1b setvalue( level.sessionadverthud_1b_text );
+				}
+				if ( level.sessionadverthud_2a_text != "" )
+				{
+					sessionadverthud_2a settext( level.sessionadverthud_2a_text );
+					sessionadverthud_2b setvalue( level.sessionadverthud_2b_text );
+				}
+				if ( level.sessionadverthud_3a_text != "" )
+				{
+					sessionadverthud_3a settext( level.sessionadverthud_3a_text );
+					sessionadverthud_3b setvalue( level.sessionadverthud_3b_text );
+				}
+				if ( level.sessionadverthud_4a_text != "" )
+				{
+					sessionadverthud_4a settext( level.sessionadverthud_4a_text );
+					sessionadverthud_4b setvalue( level.sessionadverthud_4b_text );
+				}
+			}
+		}
+#/
+	}
+}

patch_mp/maps/mp/_gamerep.gsc

@@ -0,0 +1,401 @@
+#include maps/mp/bots/_bot;
+#include maps/mp/gametypes/_rank;
+#include maps/mp/_utility;
+
+init()
+{
+	if ( !isgamerepenabled() )
+	{
+		return;
+	}
+	if ( isgamerepinitialized() )
+	{
+		return;
+	}
+	game[ "gameRepInitialized" ] = 1;
+	game[ "gameRep" ][ "players" ] = [];
+	game[ "gameRep" ][ "playerNames" ] = [];
+	game[ "gameRep" ][ "max" ] = [];
+	game[ "gameRep" ][ "playerCount" ] = 0;
+	gamerepinitializeparams();
+}
+
+isgamerepinitialized()
+{
+	if ( !isDefined( game[ "gameRepInitialized" ] ) || !game[ "gameRepInitialized" ] )
+	{
+		return 0;
+	}
+	return 1;
+}
+
+isgamerepenabled()
+{
+	if ( maps/mp/bots/_bot::is_bot_ranked_match() )
+	{
+		return 0;
+	}
+	if ( sessionmodeiszombiesgame() )
+	{
+		return 0;
+	}
+	if ( !level.rankedmatch )
+	{
+		return 0;
+	}
+	return 1;
+}
+
+gamerepinitializeparams()
+{
+	threshold_exceeded_score = 0;
+	threshold_exceeded_score_per_min = 1;
+	threshold_exceeded_kills = 2;
+	threshold_exceeded_deaths = 3;
+	threshold_exceeded_kd_ratio = 4;
+	threshold_exceeded_kills_per_min = 5;
+	threshold_exceeded_plants = 6;
+	threshold_exceeded_defuses = 7;
+	threshold_exceeded_captures = 8;
+	threshold_exceeded_defends = 9;
+	threshold_exceeded_total_time_played = 10;
+	threshold_exceeded_tactical_insertion_use = 11;
+	threshold_exceeded_join_attempts = 12;
+	threshold_exceeded_xp = 13;
+	threshold_exceeded_splitscreen = 14;
+	game[ "gameRep" ][ "params" ] = [];
+	game[ "gameRep" ][ "params" ][ 0 ] = "score";
+	game[ "gameRep" ][ "params" ][ 1 ] = "scorePerMin";
+	game[ "gameRep" ][ "params" ][ 2 ] = "kills";
+	game[ "gameRep" ][ "params" ][ 3 ] = "deaths";
+	game[ "gameRep" ][ "params" ][ 4 ] = "killDeathRatio";
+	game[ "gameRep" ][ "params" ][ 5 ] = "killsPerMin";
+	game[ "gameRep" ][ "params" ][ 6 ] = "plants";
+	game[ "gameRep" ][ "params" ][ 7 ] = "defuses";
+	game[ "gameRep" ][ "params" ][ 8 ] = "captures";
+	game[ "gameRep" ][ "params" ][ 9 ] = "defends";
+	game[ "gameRep" ][ "params" ][ 10 ] = "totalTimePlayed";
+	game[ "gameRep" ][ "params" ][ 11 ] = "tacticalInsertions";
+	game[ "gameRep" ][ "params" ][ 12 ] = "joinAttempts";
+	game[ "gameRep" ][ "params" ][ 13 ] = "xp";
+	game[ "gameRep" ][ "ignoreParams" ] = [];
+	game[ "gameRep" ][ "ignoreParams" ][ 0 ] = "totalTimePlayed";
+	game[ "gameRep" ][ "gameLimit" ] = [];
+	game[ "gameRep" ][ "gameLimit" ][ "default" ] = [];
+	game[ "gameRep" ][ "gameLimit" ][ "tdm" ] = [];
+	game[ "gameRep" ][ "gameLimit" ][ "dm" ] = [];
+	game[ "gameRep" ][ "gameLimit" ][ "dom" ] = [];
+	game[ "gameRep" ][ "gameLimit" ][ "hq" ] = [];
+	game[ "gameRep" ][ "gameLimit" ][ "sd" ] = [];
+	game[ "gameRep" ][ "gameLimit" ][ "dem" ] = [];
+	game[ "gameRep" ][ "gameLimit" ][ "ctf" ] = [];
+	game[ "gameRep" ][ "gameLimit" ][ "koth" ] = [];
+	game[ "gameRep" ][ "gameLimit" ][ "conf" ] = [];
+	game[ "gameRep" ][ "gameLimit" ][ "id" ][ "score" ] = threshold_exceeded_score;
+	game[ "gameRep" ][ "gameLimit" ][ "default" ][ "score" ] = 20000;
+	game[ "gameRep" ][ "gameLimit" ][ "id" ][ "scorePerMin" ] = threshold_exceeded_score_per_min;
+	game[ "gameRep" ][ "gameLimit" ][ "default" ][ "scorePerMin" ] = 250;
+	game[ "gameRep" ][ "gameLimit" ][ "dem" ][ "scorePerMin" ] = 1000;
+	game[ "gameRep" ][ "gameLimit" ][ "tdm" ][ "scorePerMin" ] = 700;
+	game[ "gameRep" ][ "gameLimit" ][ "dm" ][ "scorePerMin" ] = 950;
+	game[ "gameRep" ][ "gameLimit" ][ "dom" ][ "scorePerMin" ] = 1000;
+	game[ "gameRep" ][ "gameLimit" ][ "sd" ][ "scorePerMin" ] = 200;
+	game[ "gameRep" ][ "gameLimit" ][ "ctf" ][ "scorePerMin" ] = 600;
+	game[ "gameRep" ][ "gameLimit" ][ "hq" ][ "scorePerMin" ] = 1000;
+	game[ "gameRep" ][ "gameLimit" ][ "koth" ][ "scorePerMin" ] = 1000;
+	game[ "gameRep" ][ "gameLimit" ][ "conf" ][ "scorePerMin" ] = 1000;
+	game[ "gameRep" ][ "gameLimit" ][ "id" ][ "kills" ] = threshold_exceeded_kills;
+	game[ "gameRep" ][ "gameLimit" ][ "default" ][ "kills" ] = 75;
+	game[ "gameRep" ][ "gameLimit" ][ "tdm" ][ "kills" ] = 40;
+	game[ "gameRep" ][ "gameLimit" ][ "sd" ][ "kills" ] = 15;
+	game[ "gameRep" ][ "gameLimit" ][ "dm" ][ "kills" ] = 31;
+	game[ "gameRep" ][ "gameLimit" ][ "id" ][ "deaths" ] = threshold_exceeded_deaths;
+	game[ "gameRep" ][ "gameLimit" ][ "default" ][ "deaths" ] = 50;
+	game[ "gameRep" ][ "gameLimit" ][ "dm" ][ "deaths" ] = 15;
+	game[ "gameRep" ][ "gameLimit" ][ "tdm" ][ "deaths" ] = 40;
+	game[ "gameRep" ][ "gameLimit" ][ "id" ][ "killDeathRatio" ] = threshold_exceeded_kd_ratio;
+	game[ "gameRep" ][ "gameLimit" ][ "default" ][ "killDeathRatio" ] = 30;
+	game[ "gameRep" ][ "gameLimit" ][ "tdm" ][ "killDeathRatio" ] = 50;
+	game[ "gameRep" ][ "gameLimit" ][ "sd" ][ "killDeathRatio" ] = 20;
+	game[ "gameRep" ][ "gameLimit" ][ "id" ][ "killsPerMin" ] = threshold_exceeded_kills_per_min;
+	game[ "gameRep" ][ "gameLimit" ][ "default" ][ "killsPerMin" ] = 15;
+	game[ "gameRep" ][ "gameLimit" ][ "id" ][ "plants" ] = threshold_exceeded_plants;
+	game[ "gameRep" ][ "gameLimit" ][ "default" ][ "plants" ] = 10;
+	game[ "gameRep" ][ "gameLimit" ][ "id" ][ "defuses" ] = threshold_exceeded_defuses;
+	game[ "gameRep" ][ "gameLimit" ][ "default" ][ "defuses" ] = 10;
+	game[ "gameRep" ][ "gameLimit" ][ "id" ][ "captures" ] = threshold_exceeded_captures;
+	game[ "gameRep" ][ "gameLimit" ][ "default" ][ "captures" ] = 30;
+	game[ "gameRep" ][ "gameLimit" ][ "id" ][ "defends" ] = threshold_exceeded_defends;
+	game[ "gameRep" ][ "gameLimit" ][ "default" ][ "defends" ] = 50;
+	game[ "gameRep" ][ "gameLimit" ][ "id" ][ "totalTimePlayed" ] = threshold_exceeded_total_time_played;
+	game[ "gameRep" ][ "gameLimit" ][ "default" ][ "totalTimePlayed" ] = 600;
+	game[ "gameRep" ][ "gameLimit" ][ "dom" ][ "totalTimePlayed" ] = 600;
+	game[ "gameRep" ][ "gameLimit" ][ "dem" ][ "totalTimePlayed" ] = 1140;
+	game[ "gameRep" ][ "gameLimit" ][ "id" ][ "tacticalInsertions" ] = threshold_exceeded_tactical_insertion_use;
+	game[ "gameRep" ][ "gameLimit" ][ "default" ][ "tacticalInsertions" ] = 20;
+	game[ "gameRep" ][ "gameLimit" ][ "id" ][ "joinAttempts" ] = threshold_exceeded_join_attempts;
+	game[ "gameRep" ][ "gameLimit" ][ "default" ][ "joinAttempts" ] = 3;
+	game[ "gameRep" ][ "gameLimit" ][ "id" ][ "xp" ] = threshold_exceeded_xp;
+	game[ "gameRep" ][ "gameLimit" ][ "default" ][ "xp" ] = 25000;
+	game[ "gameRep" ][ "gameLimit" ][ "id" ][ "splitscreen" ] = threshold_exceeded_splitscreen;
+	game[ "gameRep" ][ "gameLimit" ][ "default" ][ "splitscreen" ] = 8;
+}
+
+gamerepplayerconnected()
+{
+	if ( !isgamerepenabled() )
+	{
+		return;
+	}
+	name = self.name;
+/#
+#/
+	if ( !isDefined( game[ "gameRep" ][ "players" ][ name ] ) )
+	{
+		game[ "gameRep" ][ "players" ][ name ] = [];
+		j = 0;
+		while ( j < game[ "gameRep" ][ "params" ].size )
+		{
+			paramname = game[ "gameRep" ][ "params" ][ j ];
+			game[ "gameRep" ][ "players" ][ name ][ paramname ] = 0;
+			j++;
+		}
+		game[ "gameRep" ][ "players" ][ name ][ "splitscreen" ] = self issplitscreen();
+		game[ "gameRep" ][ "players" ][ name ][ "joinAttempts" ] = 1;
+		game[ "gameRep" ][ "players" ][ name ][ "connected" ] = 1;
+		game[ "gameRep" ][ "players" ][ name ][ "xpStart" ] = self getrankxpstat();
+		game[ "gameRep" ][ "playerNames" ][ game[ "gameRep" ][ "playerCount" ] ] = name;
+		game[ "gameRep" ][ "playerCount" ]++;
+	}
+	else
+	{
+		if ( !game[ "gameRep" ][ "players" ][ name ][ "connected" ] )
+		{
+			game[ "gameRep" ][ "players" ][ name ][ "joinAttempts" ]++;
+			game[ "gameRep" ][ "players" ][ name ][ "connected" ] = 1;
+			game[ "gameRep" ][ "players" ][ name ][ "xpStart" ] = self getrankxpstat();
+		}
+	}
+}
+
+gamerepplayerdisconnected()
+{
+	if ( !isgamerepenabled() )
+	{
+		return;
+	}
+	name = self.name;
+	if ( !isDefined( game[ "gameRep" ][ "players" ][ name ] ) || !isDefined( self.pers[ "summary" ] ) )
+	{
+		return;
+	}
+/#
+#/
+	self gamerepupdatenonpersistentplayerinformation();
+	self gamerepupdatepersistentplayerinformation();
+	game[ "gameRep" ][ "players" ][ name ][ "connected" ] = 0;
+}
+
+gamerepupdatenonpersistentplayerinformation()
+{
+	name = self.name;
+	if ( !isDefined( game[ "gameRep" ][ "players" ][ name ] ) )
+	{
+		return;
+	}
+	game[ "gameRep" ][ "players" ][ name ][ "totalTimePlayed" ] += self.timeplayed[ "total" ];
+	if ( isDefined( self.tacticalinsertioncount ) )
+	{
+		game[ "gameRep" ][ "players" ][ name ][ "tacticalInsertions" ] += self.tacticalinsertioncount;
+	}
+}
+
+gamerepupdatepersistentplayerinformation()
+{
+	name = self.name;
+	if ( !isDefined( game[ "gameRep" ][ "players" ][ name ] ) )
+	{
+		return;
+	}
+	if ( game[ "gameRep" ][ "players" ][ name ][ "totalTimePlayed" ] != 0 )
+	{
+		timeplayed = game[ "gameRep" ][ "players" ][ name ][ "totalTimePlayed" ];
+	}
+	else
+	{
+		timeplayed = 1;
+	}
+	game[ "gameRep" ][ "players" ][ name ][ "score" ] = self.score;
+	game[ "gameRep" ][ "players" ][ name ][ "scorePerMin" ] = int( game[ "gameRep" ][ "players" ][ name ][ "score" ] / ( timeplayed / 60 ) );
+	game[ "gameRep" ][ "players" ][ name ][ "kills" ] = self.kills;
+	game[ "gameRep" ][ "players" ][ name ][ "deaths" ] = self.deaths;
+	if ( game[ "gameRep" ][ "players" ][ name ][ "deaths" ] != 0 )
+	{
+		game[ "gameRep" ][ "players" ][ name ][ "killDeathRatio" ] = int( ( game[ "gameRep" ][ "players" ][ name ][ "kills" ] / game[ "gameRep" ][ "players" ][ name ][ "deaths" ] ) * 100 );
+	}
+	else
+	{
+		game[ "gameRep" ][ "players" ][ name ][ "killDeathRatio" ] = game[ "gameRep" ][ "players" ][ name ][ "kills" ] * 100;
+	}
+	game[ "gameRep" ][ "players" ][ name ][ "killsPerMin" ] = int( game[ "gameRep" ][ "players" ][ name ][ "kills" ] / ( timeplayed / 60 ) );
+	game[ "gameRep" ][ "players" ][ name ][ "plants" ] = self.plants;
+	game[ "gameRep" ][ "players" ][ name ][ "defuses" ] = self.defuses;
+	game[ "gameRep" ][ "players" ][ name ][ "captures" ] = self.captures;
+	game[ "gameRep" ][ "players" ][ name ][ "defends" ] = self.defends;
+	game[ "gameRep" ][ "players" ][ name ][ "xp" ] = self getrankxpstat() - game[ "gameRep" ][ "players" ][ name ][ "xpStart" ];
+	game[ "gameRep" ][ "players" ][ name ][ "xpStart" ] = self getrankxpstat();
+}
+
+getparamvalueforplayer( playername, paramname )
+{
+	if ( isDefined( game[ "gameRep" ][ "players" ][ playername ][ paramname ] ) )
+	{
+		return game[ "gameRep" ][ "players" ][ playername ][ paramname ];
+	}
+/#
+	assertmsg( "Unknown parameter " + paramname + "for individual player" );
+#/
+}
+
+isgamerepparamvalid( paramname )
+{
+	gametype = level.gametype;
+	if ( !isDefined( game[ "gameRep" ] ) )
+	{
+		return 0;
+	}
+	if ( !isDefined( game[ "gameRep" ][ "gameLimit" ] ) )
+	{
+		return 0;
+	}
+	if ( !isDefined( game[ "gameRep" ][ "gameLimit" ][ gametype ] ) )
+	{
+		return 0;
+	}
+	if ( !isDefined( game[ "gameRep" ][ "gameLimit" ][ gametype ][ paramname ] ) && !isDefined( game[ "gameRep" ][ "gameLimit" ][ "default" ][ paramname ] ) )
+	{
+		return 0;
+	}
+	return 1;
+}
+
+isgamerepparamignoredforreporting( paramname )
+{
+	if ( isDefined( game[ "gameRep" ][ "ignoreParams" ][ paramname ] ) )
+	{
+		return 1;
+	}
+	return 0;
+}
+
+getgamerepparamlimit( paramname )
+{
+	gametype = level.gametype;
+	if ( isDefined( game[ "gameRep" ][ "gameLimit" ][ gametype ] ) )
+	{
+		if ( isDefined( game[ "gameRep" ][ "gameLimit" ][ gametype ][ paramname ] ) )
+		{
+			return game[ "gameRep" ][ "gameLimit" ][ gametype ][ paramname ];
+		}
+	}
+	if ( isDefined( game[ "gameRep" ][ "gameLimit" ][ "default" ][ paramname ] ) )
+	{
+		return game[ "gameRep" ][ "gameLimit" ][ "default" ][ paramname ];
+	}
+/#
+	assertmsg( "Default values for parameter " + paramname + " is not defined." );
+#/
+}
+
+setmaximumparamvalueforcurrentgame( paramname, value )
+{
+	if ( !isDefined( game[ "gameRep" ][ "max" ][ paramname ] ) )
+	{
+		game[ "gameRep" ][ "max" ][ paramname ] = value;
+		return;
+	}
+	if ( game[ "gameRep" ][ "max" ][ paramname ] < value )
+	{
+		game[ "gameRep" ][ "max" ][ paramname ] = value;
+	}
+}
+
+gamerepupdateinformationforround()
+{
+	if ( !isgamerepenabled() )
+	{
+		return;
+	}
+	players = get_players();
+	i = 0;
+	while ( i < players.size )
+	{
+		player = players[ i ];
+		player gamerepupdatenonpersistentplayerinformation();
+		i++;
+	}
+}
+
+gamerepanalyzeandreport()
+{
+	if ( !isgamerepenabled() )
+	{
+		return;
+	}
+	players = get_players();
+	i = 0;
+	while ( i < players.size )
+	{
+		player = players[ i ];
+		player gamerepupdatepersistentplayerinformation();
+		i++;
+	}
+	splitscreenplayercount = 0;
+	i = 0;
+	while ( i < game[ "gameRep" ][ "playerNames" ].size )
+	{
+		playername = game[ "gameRep" ][ "playerNames" ][ i ];
+		j = 0;
+		while ( j < game[ "gameRep" ][ "params" ].size )
+		{
+			paramname = game[ "gameRep" ][ "params" ][ j ];
+			if ( isgamerepparamvalid( paramname ) )
+			{
+				setmaximumparamvalueforcurrentgame( paramname, getparamvalueforplayer( playername, paramname ) );
+			}
+			j++;
+		}
+		paramname = "splitscreen";
+		splitscreenplayercount += getparamvalueforplayer( playername, paramname );
+		i++;
+	}
+	setmaximumparamvalueforcurrentgame( paramname, splitscreenplayercount );
+	j = 0;
+	while ( j < game[ "gameRep" ][ "params" ].size )
+	{
+		paramname = game[ "gameRep" ][ "params" ][ j ];
+		if ( isgamerepparamvalid( paramname ) && game[ "gameRep" ][ "max" ][ paramname ] >= getgamerepparamlimit( paramname ) )
+		{
+			gamerepprepareandreport( paramname );
+		}
+		j++;
+	}
+	paramname = "splitscreen";
+	if ( game[ "gameRep" ][ "max" ][ paramname ] >= getgamerepparamlimit( paramname ) )
+	{
+		gamerepprepareandreport( paramname );
+	}
+}
+
+gamerepprepareandreport( paramname )
+{
+	if ( !isDefined( game[ "gameRep" ][ "gameLimit" ][ "id" ][ paramname ] ) )
+	{
+		return;
+	}
+	if ( isgamerepparamignoredforreporting( paramname ) )
+	{
+		return;
+	}
+	gamerepthresholdexceeded( game[ "gameRep" ][ "gameLimit" ][ "id" ][ paramname ] );
+}

patch_mp/maps/mp/_global_fx.gsc

@@ -0,0 +1,60 @@
+#include maps/mp/_utility;
+#include common_scripts/utility;
+
+main()
+{
+	randomstartdelay = randomfloatrange( -20, -15 );
+	global_fx( "barrel_fireFX_origin", "global_barrel_fire", "fire/firelp_barrel_pm", randomstartdelay, "fire_barrel_small" );
+	global_fx( "ch_streetlight_02_FX_origin", "ch_streetlight_02_FX", "misc/lighthaze", randomstartdelay );
+	global_fx( "me_streetlight_01_FX_origin", "me_streetlight_01_FX", "misc/lighthaze_bog_a", randomstartdelay );
+	global_fx( "ch_street_light_01_on", "lamp_glow_FX", "misc/light_glow_white", randomstartdelay );
+	global_fx( "highway_lamp_post", "ch_streetlight_02_FX", "misc/lighthaze_villassault", randomstartdelay );
+	global_fx( "cs_cargoship_spotlight_on_FX_origin", "cs_cargoship_spotlight_on_FX", "misc/lighthaze", randomstartdelay );
+	global_fx( "me_dumpster_fire_FX_origin", "me_dumpster_fire_FX", "fire/firelp_med_pm_nodistort", randomstartdelay, "fire_dumpster_medium" );
+	global_fx( "com_tires_burning01_FX_origin", "com_tires_burning01_FX", "fire/tire_fire_med", randomstartdelay );
+	global_fx( "icbm_powerlinetower_FX_origin", "icbm_powerlinetower_FX", "misc/power_tower_light_red_blink", randomstartdelay );
+}
+
+global_fx( targetname, fxname, fxfile, delay, soundalias )
+{
+	ents = getstructarray( targetname, "targetname" );
+	if ( !isDefined( ents ) )
+	{
+		return;
+	}
+	if ( ents.size <= 0 )
+	{
+		return;
+	}
+	i = 0;
+	while ( i < ents.size )
+	{
+		ents[ i ] global_fx_create( fxname, fxfile, delay, soundalias );
+		i++;
+	}
+}
+
+global_fx_create( fxname, fxfile, delay, soundalias )
+{
+	if ( !isDefined( level._effect ) )
+	{
+		level._effect = [];
+	}
+	if ( !isDefined( level._effect[ fxname ] ) )
+	{
+		level._effect[ fxname ] = loadfx( fxfile );
+	}
+	if ( !isDefined( self.angles ) )
+	{
+		self.angles = ( 0, 0, 0 );
+	}
+	ent = createoneshoteffect( fxname );
+	ent.v[ "origin" ] = self.origin;
+	ent.v[ "angles" ] = self.angles;
+	ent.v[ "fxid" ] = fxname;
+	ent.v[ "delay" ] = delay;
+	if ( isDefined( soundalias ) )
+	{
+		ent.v[ "soundalias" ] = soundalias;
+	}
+}

patch_mp/maps/mp/_hacker_tool.gsc

@@ -0,0 +1,746 @@
+#include maps/mp/gametypes/_weaponobjects;
+#include maps/mp/killstreaks/_supplydrop;
+#include maps/mp/_heatseekingmissile;
+#include maps/mp/gametypes/_hud_util;
+#include common_scripts/utility;
+#include maps/mp/_utility;
+
+init()
+{
+	level.hackertoolmaxequipmentdistance = 2000;
+	level.hackertoolmaxequipmentdistancesq = level.hackertoolmaxequipmentdistance * level.hackertoolmaxequipmentdistance;
+	level.hackertoolnosighthackdistance = 750;
+	level.hackertoollostsightlimitms = 450;
+	level.hackertoollockonradius = 20;
+	level.hackertoollockonfov = 65;
+	level.hackertoolhacktimems = 0,5;
+	level.equipmenthackertoolradius = 60;
+	level.equipmenthackertooltimems = 50;
+	level.carepackagehackertoolradius = 60;
+	level.carepackagehackertooltimems = getgametypesetting( "crateCaptureTime" ) * 500;
+	level.carepackagefriendlyhackertooltimems = getgametypesetting( "crateCaptureTime" ) * 2000;
+	level.carepackageownerhackertooltimems = 250;
+	level.sentryhackertoolradius = 80;
+	level.sentryhackertooltimems = 4000;
+	level.microwavehackertoolradius = 80;
+	level.microwavehackertooltimems = 4000;
+	level.vehiclehackertoolradius = 80;
+	level.vehiclehackertooltimems = 4000;
+	level.rcxdhackertooltimems = 1500;
+	level.rcxdhackertoolradius = 20;
+	level.uavhackertooltimems = 4000;
+	level.uavhackertoolradius = 40;
+	level.cuavhackertooltimems = 4000;
+	level.cuavhackertoolradius = 40;
+	level.carepackagechopperhackertooltimems = 3000;
+	level.carepackagechopperhackertoolradius = 60;
+	level.littlebirdhackertooltimems = 4000;
+	level.littlebirdhackertoolradius = 80;
+	level.qrdronehackertooltimems = 3000;
+	level.qrdronehackertoolradius = 60;
+	level.aitankhackertooltimems = 4000;
+	level.aitankhackertoolradius = 60;
+	level.stealthchopperhackertooltimems = 4000;
+	level.stealthchopperhackertoolradius = 80;
+	level.warthoghackertooltimems = 4000;
+	level.warthoghackertoolradius = 80;
+	level.lodestarhackertooltimems = 4000;
+	level.lodestarhackertoolradius = 60;
+	level.choppergunnerhackertooltimems = 4000;
+	level.choppergunnerhackertoolradius = 260;
+	thread onplayerconnect();
+}
+
+onplayerconnect()
+{
+	for ( ;; )
+	{
+		level waittill( "connecting", player );
+		player thread onplayerspawned();
+	}
+}
+
+onplayerspawned()
+{
+	self endon( "disconnect" );
+	for ( ;; )
+	{
+		self waittill( "spawned_player" );
+		self clearhackertarget();
+		self thread watchhackertooluse();
+		self thread watchhackertoolfired();
+	}
+}
+
+clearhackertarget()
+{
+	self notify( "stop_lockon_sound" );
+	self notify( "stop_locked_sound" );
+	self.stingerlocksound = undefined;
+	self stoprumble( "stinger_lock_rumble" );
+	self.hackertoollockstarttime = 0;
+	self.hackertoollockstarted = 0;
+	self.hackertoollockfinalized = 0;
+	self.hackertoollocktimeelapsed = 0;
+	self setweaponheatpercent( "pda_hack_mp", 0 );
+	if ( isDefined( self.hackertooltarget ) )
+	{
+		lockingon( self.hackertooltarget, 0 );
+		lockedon( self.hackertooltarget, 0 );
+	}
+	self.hackertooltarget = undefined;
+	self weaponlockfree();
+	self weaponlocktargettooclose( 0 );
+	self weaponlocknoclearance( 0 );
+	self stoplocalsound( game[ "locking_on_sound" ] );
+	self stoplocalsound( game[ "locked_on_sound" ] );
+	self destroylockoncanceledmessage();
+}
+
+watchhackertoolfired()
+{
+	self endon( "disconnect" );
+	self endon( "death" );
+	while ( 1 )
+	{
+		self waittill( "hacker_tool_fired", hackertooltarget );
+		if ( isDefined( hackertooltarget ) )
+		{
+			if ( isentityhackablecarepackage( hackertooltarget ) )
+			{
+				maps/mp/killstreaks/_supplydrop::givecratecapturemedal( hackertooltarget, self );
+				hackertooltarget notify( "captured" );
+			}
+			if ( isentityhackableweaponobject( hackertooltarget ) || isDefined( hackertooltarget.hackertrigger ) )
+			{
+				hackertooltarget.hackertrigger notify( "trigger" );
+			}
+			else
+			{
+				if ( isDefined( hackertooltarget.classname ) && hackertooltarget.classname == "grenade" )
+				{
+					damage = 1;
+				}
+				else
+				{
+					if ( isDefined( hackertooltarget.maxhealth ) )
+					{
+						damage = hackertooltarget.maxhealth + 1;
+						break;
+					}
+					else
+					{
+						damage = 999999;
+					}
+				}
+				if ( isDefined( hackertooltarget.numflares ) && hackertooltarget.numflares > 0 )
+				{
+					damage = 1;
+					hackertooltarget.numflares--;
+
+					hackertooltarget maps/mp/_heatseekingmissile::missiletarget_playflarefx();
+				}
+				hackertooltarget dodamage( damage, self.origin, self, self, 0, "MOD_UNKNOWN", 0, "pda_hack_mp" );
+			}
+			self addplayerstat( "hack_enemy_target", 1 );
+			self addweaponstat( "pda_hack_mp", "used", 1 );
+		}
+		clearhackertarget();
+		self forceoffhandend();
+		clip_ammo = self getweaponammoclip( "pda_hack_mp" );
+		clip_ammo--;
+
+/#
+		assert( clip_ammo >= 0 );
+#/
+		self setweaponammoclip( "pda_hack_mp", clip_ammo );
+		self switchtoweapon( self getlastweapon() );
+	}
+}
+
+watchhackertooluse()
+{
+	self endon( "disconnect" );
+	self endon( "death" );
+	for ( ;; )
+	{
+		self waittill( "grenade_pullback", weapon );
+		if ( weapon == "pda_hack_mp" )
+		{
+			wait 0,05;
+			if ( self isusingoffhand() && self getcurrentoffhand() == "pda_hack_mp" )
+			{
+				self thread hackertooltargetloop();
+				self thread watchhackertoolend();
+				self thread watchforgrenadefire();
+				self thread watchhackertoolinterrupt();
+			}
+		}
+	}
+}
+
+watchhackertoolinterrupt()
+{
+	self endon( "disconnect" );
+	self endon( "hacker_tool_fired" );
+	self endon( "death" );
+	self endon( "weapon_change" );
+	self endon( "grenade_fire" );
+	while ( 1 )
+	{
+		level waittill( "use_interrupt", interrupttarget );
+		if ( self.hackertooltarget == interrupttarget )
+		{
+			clearhackertarget();
+		}
+		wait 0,05;
+	}
+}
+
+watchhackertoolend()
+{
+	self endon( "disconnect" );
+	self endon( "hacker_tool_fired" );
+	msg = self waittill_any_return( "weapon_change", "death" );
+	clearhackertarget();
+}
+
+watchforgrenadefire()
+{
+	self endon( "disconnect" );
+	self endon( "hacker_tool_fired" );
+	self endon( "weapon_change" );
+	self endon( "death" );
+	while ( 1 )
+	{
+		self waittill( "grenade_fire", grenade, grenadename, respawnfromhack );
+		if ( isDefined( respawnfromhack ) && respawnfromhack )
+		{
+			continue;
+		}
+		clearhackertarget();
+		clip_ammo = self getweaponammoclip( "pda_hack_mp" );
+		clip_max_ammo = weaponclipsize( "pda_hack_mp" );
+		if ( clip_ammo < clip_max_ammo )
+		{
+			clip_ammo++;
+		}
+		self setweaponammoclip( "pda_hack_mp", clip_ammo );
+		return;
+	}
+}
+
+hackertooltargetloop()
+{
+	self endon( "disconnect" );
+	self endon( "death" );
+	self endon( "weapon_change" );
+	self endon( "grenade_fire" );
+	while ( 1 )
+	{
+		wait 0,05;
+		if ( self.hackertoollockfinalized )
+		{
+			while ( !self isvalidhackertooltarget( self.hackertooltarget ) )
+			{
+				self clearhackertarget();
+			}
+			passed = self hackersoftsighttest();
+			while ( !passed )
+			{
+				continue;
+			}
+			lockingon( self.hackertooltarget, 0 );
+			lockedon( self.hackertooltarget, 1 );
+			thread looplocallocksound( game[ "locked_on_sound" ], 0,75 );
+			self notify( "hacker_tool_fired" );
+			return;
+		}
+		while ( self.hackertoollockstarted )
+		{
+			while ( !self isvalidhackertooltarget( self.hackertooltarget ) )
+			{
+				self clearhackertarget();
+			}
+			locklengthms = self gethacktime( self.hackertooltarget );
+			while ( locklengthms == 0 )
+			{
+				self clearhackertarget();
+			}
+			if ( self.hackertoollocktimeelapsed == 0 )
+			{
+				self playlocalsound( "evt_hacker_hacking" );
+			}
+			lockingon( self.hackertooltarget, 1 );
+			lockedon( self.hackertooltarget, 0 );
+			passed = self hackersoftsighttest();
+			while ( !passed )
+			{
+				continue;
+			}
+			if ( self.hackertoollostsightlinetime == 0 )
+			{
+				self.hackertoollocktimeelapsed += 0,05;
+				hackpercentage = self.hackertoollocktimeelapsed / ( locklengthms / 1000 );
+				self setweaponheatpercent( "pda_hack_mp", hackpercentage );
+			}
+			while ( self.hackertoollocktimeelapsed < ( locklengthms / 1000 ) )
+			{
+				continue;
+			}
+/#
+			assert( isDefined( self.hackertooltarget ) );
+#/
+			self notify( "stop_lockon_sound" );
+			self.hackertoollockfinalized = 1;
+			self weaponlockfinalize( self.hackertooltarget );
+		}
+		besttarget = self getbesthackertooltarget();
+		while ( !isDefined( besttarget ) )
+		{
+			self destroylockoncanceledmessage();
+		}
+		while ( !self locksighttest( besttarget ) && distance2d( self.origin, besttarget.origin ) > level.hackertoolnosighthackdistance )
+		{
+			self destroylockoncanceledmessage();
+		}
+		while ( self locksighttest( besttarget ) && isDefined( besttarget.lockondelay ) && besttarget.lockondelay )
+		{
+			self displaylockoncanceledmessage();
+		}
+		self destroylockoncanceledmessage();
+		initlockfield( besttarget );
+		self.hackertooltarget = besttarget;
+		self.hackertoollockstarttime = getTime();
+		self.hackertoollockstarted = 1;
+		self.hackertoollostsightlinetime = 0;
+		self.hackertoollocktimeelapsed = 0;
+		self setweaponheatpercent( "pda_hack_mp", 0 );
+		self thread looplocalseeksound( game[ "locking_on_sound" ], 0,6 );
+	}
+}
+
+getbesthackertooltarget()
+{
+	targetsvalid = [];
+	targetsall = arraycombine( target_getarray(), level.missileentities, 0, 0 );
+	targetsall = arraycombine( targetsall, level.hackertooltargets, 0, 0 );
+	idx = 0;
+	while ( idx < targetsall.size )
+	{
+		target_ent = targetsall[ idx ];
+		if ( !isDefined( target_ent ) || !isDefined( target_ent.owner ) )
+		{
+			idx++;
+			continue;
+		}
+		else
+		{
+/#
+			if ( getDvar( "scr_freelock" ) == "1" )
+			{
+				if ( self iswithinhackertoolreticle( targetsall[ idx ] ) )
+				{
+					targetsvalid[ targetsvalid.size ] = targetsall[ idx ];
+				}
+				idx++;
+				continue;
+#/
+			}
+			else if ( level.teambased )
+			{
+				if ( isentityhackablecarepackage( target_ent ) )
+				{
+					if ( self iswithinhackertoolreticle( target_ent ) )
+					{
+						targetsvalid[ targetsvalid.size ] = target_ent;
+					}
+				}
+				else if ( isDefined( target_ent.team ) )
+				{
+					if ( target_ent.team != self.team )
+					{
+						if ( self iswithinhackertoolreticle( target_ent ) )
+						{
+							targetsvalid[ targetsvalid.size ] = target_ent;
+						}
+					}
+				}
+				else
+				{
+					if ( isDefined( target_ent.owner.team ) )
+					{
+						if ( target_ent.owner.team != self.team )
+						{
+							if ( self iswithinhackertoolreticle( target_ent ) )
+							{
+								targetsvalid[ targetsvalid.size ] = target_ent;
+							}
+						}
+					}
+				}
+				idx++;
+				continue;
+			}
+			else if ( self iswithinhackertoolreticle( target_ent ) )
+			{
+				if ( isentityhackablecarepackage( target_ent ) )
+				{
+					targetsvalid[ targetsvalid.size ] = target_ent;
+					idx++;
+					continue;
+				}
+				else
+				{
+					if ( isDefined( target_ent.owner ) && self != target_ent.owner )
+					{
+						targetsvalid[ targetsvalid.size ] = target_ent;
+					}
+				}
+			}
+		}
+		idx++;
+	}
+	chosenent = undefined;
+	if ( targetsvalid.size != 0 )
+	{
+		chosenent = targetsvalid[ 0 ];
+	}
+	return chosenent;
+}
+
+iswithinhackertoolreticle( target )
+{
+	radius = gethackertoolradius( target );
+	return target_isincircle( target, self, level.hackertoollockonfov, radius, 0 );
+}
+
+isentityhackableweaponobject( entity )
+{
+	if ( isDefined( entity.classname ) && entity.classname == "grenade" )
+	{
+		if ( isDefined( entity.name ) )
+		{
+			watcher = maps/mp/gametypes/_weaponobjects::getweaponobjectwatcherbyweapon( entity.name );
+			if ( isDefined( watcher ) )
+			{
+				if ( watcher.hackable )
+				{
+/#
+					assert( isDefined( watcher.hackertoolradius ) );
+					assert( isDefined( watcher.hackertooltimems ) );
+#/
+					return 1;
+				}
+			}
+		}
+	}
+	return 0;
+}
+
+getweaponobjecthackerradius( entity )
+{
+/#
+	assert( isDefined( entity.classname ) );
+	assert( isDefined( entity.name ) );
+#/
+	watcher = maps/mp/gametypes/_weaponobjects::getweaponobjectwatcherbyweapon( entity.name );
+/#
+	assert( watcher.hackable );
+	assert( isDefined( watcher.hackertoolradius ) );
+#/
+	return watcher.hackertoolradius;
+}
+
+getweaponobjecthacktimems( entity )
+{
+/#
+	assert( isDefined( entity.classname ) );
+	assert( isDefined( entity.name ) );
+#/
+	watcher = maps/mp/gametypes/_weaponobjects::getweaponobjectwatcherbyweapon( entity.name );
+/#
+	assert( watcher.hackable );
+	assert( isDefined( watcher.hackertooltimems ) );
+#/
+	return watcher.hackertooltimems;
+}
+
+isentityhackablecarepackage( entity )
+{
+	if ( isDefined( entity.model ) )
+	{
+		return entity.model == "t6_wpn_supply_drop_ally";
+	}
+	else
+	{
+		return 0;
+	}
+}
+
+isvalidhackertooltarget( ent )
+{
+	if ( !isDefined( ent ) )
+	{
+		return 0;
+	}
+	if ( self isusingremote() )
+	{
+		return 0;
+	}
+	if ( self isempjammed() )
+	{
+		return 0;
+	}
+	if ( !target_istarget( ent ) && !isentityhackableweaponobject( ent ) && !isinarray( level.hackertooltargets, ent ) )
+	{
+		return 0;
+	}
+	if ( isentityhackableweaponobject( ent ) )
+	{
+		if ( distancesquared( self.origin, ent.origin ) > level.hackertoolmaxequipmentdistancesq )
+		{
+			return 0;
+		}
+	}
+	return 1;
+}
+
+hackersoftsighttest()
+{
+	passed = 1;
+	locklengthms = 0;
+	if ( isDefined( self.hackertooltarget ) )
+	{
+		locklengthms = self gethacktime( self.hackertooltarget );
+	}
+	if ( self isempjammed() || locklengthms == 0 )
+	{
+		self clearhackertarget();
+		passed = 0;
+	}
+	else
+	{
+		if ( iswithinhackertoolreticle( self.hackertooltarget ) )
+		{
+			self.hackertoollostsightlinetime = 0;
+		}
+		else
+		{
+			if ( self.hackertoollostsightlinetime == 0 )
+			{
+				self.hackertoollostsightlinetime = getTime();
+			}
+			timepassed = getTime() - self.hackertoollostsightlinetime;
+			if ( timepassed >= level.hackertoollostsightlimitms )
+			{
+				self clearhackertarget();
+				passed = 0;
+			}
+		}
+	}
+	return passed;
+}
+
+registerwithhackertool( radius, hacktimems )
+{
+	self endon( "death" );
+	if ( isDefined( radius ) )
+	{
+		self.hackertoolradius = radius;
+	}
+	else
+	{
+		self.hackertoolradius = level.hackertoollockonradius;
+	}
+	if ( isDefined( hacktimems ) )
+	{
+		self.hackertooltimems = hacktimems;
+	}
+	else
+	{
+		self.hackertooltimems = level.hackertoolhacktimems;
+	}
+	self thread watchhackableentitydeath();
+	level.hackertooltargets[ level.hackertooltargets.size ] = self;
+}
+
+watchhackableentitydeath()
+{
+	self waittill( "death" );
+	arrayremovevalue( level.hackertooltargets, self );
+}
+
+gethackertoolradius( target )
+{
+	radius = 20;
+	if ( isentityhackablecarepackage( target ) )
+	{
+/#
+		assert( isDefined( target.hackertoolradius ) );
+#/
+		radius = target.hackertoolradius;
+		break;
+}
+else if ( isentityhackableweaponobject( target ) )
+{
+	radius = getweaponobjecthackerradius( target );
+	break;
+}
+else if ( isDefined( target.hackertoolradius ) )
+{
+radius = target.hackertoolradius;
+break;
+}
+else radius = level.vehiclehackertoolradius;
+switch( target.model )
+{
+case "veh_t6_drone_uav":
+radius = level.uavhackertoolradius;
+break;
+case "veh_t6_drone_cuav":
+radius = level.cuavhackertoolradius;
+break;
+case "t5_veh_rcbomb_axis":
+radius = level.rcxdhackertoolradius;
+break;
+case "veh_iw_mh6_littlebird_mp":
+radius = level.carepackagechopperhackertoolradius;
+break;
+case "veh_t6_drone_quad_rotor_mp":
+case "veh_t6_drone_quad_rotor_mp_alt":
+radius = level.qrdronehackertoolradius;
+break;
+case "veh_t6_drone_tank":
+case "veh_t6_drone_tank_alt":
+radius = level.aitankhackertoolradius;
+break;
+case "veh_t6_air_attack_heli_mp_dark":
+case "veh_t6_air_attack_heli_mp_light":
+radius = level.stealthchopperhackertoolradius;
+break;
+case "veh_t6_drone_overwatch_dark":
+case "veh_t6_drone_overwatch_light":
+radius = level.littlebirdhackertoolradius;
+break;
+case "veh_t6_drone_pegasus":
+radius = level.lodestarhackertoolradius;
+break;
+case "veh_iw_air_apache_killstreak":
+radius = level.choppergunnerhackertoolradius;
+break;
+case "veh_t6_air_a10f":
+case "veh_t6_air_a10f_alt":
+radius = level.warthoghackertoolradius;
+break;
+}
+return radius;
+}
+
+gethacktime( target )
+{
+	time = 500;
+	if ( isentityhackablecarepackage( target ) )
+	{
+/#
+		assert( isDefined( target.hackertooltimems ) );
+#/
+		if ( isDefined( target.owner ) && target.owner == self )
+		{
+			time = level.carepackageownerhackertooltimems;
+		}
+		else
+		{
+			if ( isDefined( target.owner ) && target.owner.team == self.team )
+			{
+				time = level.carepackagefriendlyhackertooltimems;
+			}
+			else
+			{
+				time = level.carepackagehackertooltimems;
+			}
+		}
+		break;
+}
+else if ( isentityhackableweaponobject( target ) )
+{
+	time = getweaponobjecthacktimems( target );
+	break;
+}
+else if ( isDefined( target.hackertooltimems ) )
+{
+time = target.hackertooltimems;
+break;
+}
+else time = level.vehiclehackertooltimems;
+switch( target.model )
+{
+case "veh_t6_drone_uav":
+time = level.uavhackertooltimems;
+break;
+case "veh_t6_drone_cuav":
+time = level.cuavhackertooltimems;
+break;
+case "t5_veh_rcbomb_axis":
+time = level.rcxdhackertooltimems;
+break;
+case "veh_t6_drone_supply_alt":
+case "veh_t6_drone_supply_alt":
+time = level.carepackagechopperhackertooltimems;
+break;
+case "veh_t6_drone_quad_rotor_mp":
+case "veh_t6_drone_quad_rotor_mp_alt":
+time = level.qrdronehackertooltimems;
+break;
+case "veh_t6_drone_tank":
+case "veh_t6_drone_tank_alt":
+time = level.aitankhackertooltimems;
+break;
+case "veh_t6_air_attack_heli_mp_dark":
+case "veh_t6_air_attack_heli_mp_light":
+time = level.stealthchopperhackertooltimems;
+break;
+case "veh_t6_drone_overwatch_dark":
+case "veh_t6_drone_overwatch_light":
+time = level.littlebirdhackertooltimems;
+break;
+case "veh_t6_drone_pegasus":
+time = level.lodestarhackertooltimems;
+break;
+case "veh_t6_air_v78_vtol_killstreak":
+case "veh_t6_air_v78_vtol_killstreak_alt":
+time = level.choppergunnerhackertooltimems;
+break;
+case "veh_t6_air_a10f":
+case "veh_t6_air_a10f_alt":
+time = level.warthoghackertooltimems;
+break;
+}
+return time;
+}
+
+tunables()
+{
+/#
+	while ( 1 )
+	{
+		level.hackertoollostsightlimitms = weapons_get_dvar_int( "scr_hackerToolLostSightLimitMs", 1000 );
+		level.hackertoollockonradius = weapons_get_dvar( "scr_hackerToolLockOnRadius", 20 );
+		level.hackertoollockonfov = weapons_get_dvar_int( "scr_hackerToolLockOnFOV", 65 );
+		level.rcxd_time = weapons_get_dvar( "scr_rcxd_time", 1,5 );
+		level.uav_time = weapons_get_dvar_int( "scr_uav_time", 4 );
+		level.cuav_time = weapons_get_dvar_int( "scr_cuav_time", 4 );
+		level.care_package_chopper_time = weapons_get_dvar_int( "scr_care_package_chopper_time", 3 );
+		level.guardian_time = weapons_get_dvar_int( "scr_guardian_time", 5 );
+		level.sentry_time = weapons_get_dvar_int( "scr_sentry_time", 5 );
+		level.wasp_time = weapons_get_dvar_int( "scr_wasp_time", 5 );
+		level.agr_time = weapons_get_dvar_int( "scr_agr_time", 5 );
+		level.stealth_helicopter_time = weapons_get_dvar_int( "scr_stealth_helicopter_time", 7 );
+		level.escort_drone_time = weapons_get_dvar_int( "scr_escort_drone_time", 7 );
+		level.warthog_time = weapons_get_dvar_int( "scr_warthog_time", 7 );
+		level.lodestar_time = weapons_get_dvar_int( "scr_lodestar_time", 7 );
+		level.chopper_gunner_time = weapons_get_dvar_int( "scr_chopper_gunner_time", 7 );
+		wait 1;
+#/
+	}
+}

patch_mp/maps/mp/_heatseekingmissile.gsc

@@ -0,0 +1,688 @@
+#include maps/mp/killstreaks/_airsupport;
+#include maps/mp/killstreaks/_helicopter;
+#include maps/mp/gametypes/_weapon_utils;
+#include common_scripts/utility;
+#include maps/mp/_utility;
+
+init()
+{
+	precacherumble( "stinger_lock_rumble" );
+	game[ "locking_on_sound" ] = "uin_alert_lockon_start";
+	game[ "locked_on_sound" ] = "uin_alert_lockon";
+	precachestring( &"MP_CANNOT_LOCKON_TO_TARGET" );
+	thread onplayerconnect();
+	level.fx_flare = loadfx( "vehicle/vexplosion/fx_heli_chaff" );
+/#
+	setdvar( "scr_freelock", "0" );
+#/
+}
+
+onplayerconnect()
+{
+	for ( ;; )
+	{
+		level waittill( "connecting", player );
+		player thread onplayerspawned();
+	}
+}
+
+onplayerspawned()
+{
+	self endon( "disconnect" );
+	for ( ;; )
+	{
+		self waittill( "spawned_player" );
+		self clearirtarget();
+		thread stingertoggleloop();
+		self thread stingerfirednotify();
+	}
+}
+
+clearirtarget()
+{
+	self notify( "stinger_irt_cleartarget" );
+	self notify( "stop_lockon_sound" );
+	self notify( "stop_locked_sound" );
+	self.stingerlocksound = undefined;
+	self stoprumble( "stinger_lock_rumble" );
+	self.stingerlockstarttime = 0;
+	self.stingerlockstarted = 0;
+	self.stingerlockfinalized = 0;
+	if ( isDefined( self.stingertarget ) )
+	{
+		lockingon( self.stingertarget, 0 );
+		lockedon( self.stingertarget, 0 );
+	}
+	self.stingertarget = undefined;
+	self weaponlockfree();
+	self weaponlocktargettooclose( 0 );
+	self weaponlocknoclearance( 0 );
+	self stoplocalsound( game[ "locking_on_sound" ] );
+	self stoplocalsound( game[ "locked_on_sound" ] );
+	self destroylockoncanceledmessage();
+}
+
+stingerfirednotify()
+{
+	self endon( "disconnect" );
+	self endon( "death" );
+	while ( 1 )
+	{
+		self waittill( "missile_fire", missile, weap );
+		if ( maps/mp/gametypes/_weapon_utils::isguidedrocketlauncherweapon( weap ) )
+		{
+			if ( isDefined( self.stingertarget ) && self.stingerlockfinalized )
+			{
+				self.stingertarget notify( "stinger_fired_at_me" );
+			}
+			level notify( "missile_fired" );
+			self notify( "stinger_fired" );
+		}
+	}
+}
+
+stingertoggleloop()
+{
+	self endon( "disconnect" );
+	self endon( "death" );
+	for ( ;; )
+	{
+		self waittill( "weapon_change", weapon );
+		while ( maps/mp/gametypes/_weapon_utils::isguidedrocketlauncherweapon( weapon ) )
+		{
+			abort = 0;
+			while ( !self playerstingerads() )
+			{
+				wait 0,05;
+				if ( !maps/mp/gametypes/_weapon_utils::isguidedrocketlauncherweapon( self getcurrentweapon() ) )
+				{
+					abort = 1;
+					break;
+				}
+				else
+				{
+				}
+			}
+			if ( abort )
+			{
+				break;
+			}
+			else self thread stingerirtloop();
+			while ( self playerstingerads() )
+			{
+				wait 0,05;
+			}
+			self notify( "stinger_IRT_off" );
+			self clearirtarget();
+			weapon = self getcurrentweapon();
+		}
+	}
+}
+
+stingerirtloop()
+{
+	self endon( "disconnect" );
+	self endon( "death" );
+	self endon( "stinger_IRT_off" );
+	locklength = self getlockonspeed();
+	for ( ;; )
+	{
+		wait 0,05;
+		if ( self.stingerlockfinalized )
+		{
+			passed = softsighttest();
+			if ( !passed )
+			{
+				continue;
+			}
+			else if ( !isstillvalidtarget( self.stingertarget ) )
+			{
+				self clearirtarget();
+				continue;
+			}
+			else if ( !self.stingertarget.locked_on )
+			{
+				self.stingertarget notify( "missile_lock" );
+			}
+			lockingon( self.stingertarget, 0 );
+			lockedon( self.stingertarget, 1 );
+			thread looplocallocksound( game[ "locked_on_sound" ], 0,75 );
+			continue;
+		}
+		else if ( self.stingerlockstarted )
+		{
+			if ( !isstillvalidtarget( self.stingertarget ) )
+			{
+				self clearirtarget();
+				continue;
+			}
+			else lockingon( self.stingertarget, 1 );
+			lockedon( self.stingertarget, 0 );
+			passed = softsighttest();
+			if ( !passed )
+			{
+				continue;
+			}
+			else timepassed = getTime() - self.stingerlockstarttime;
+			if ( timepassed < locklength )
+			{
+				continue;
+			}
+			else /#
+			assert( isDefined( self.stingertarget ) );
+#/
+			self notify( "stop_lockon_sound" );
+			self.stingerlockfinalized = 1;
+			self weaponlockfinalize( self.stingertarget );
+			continue;
+		}
+		else besttarget = self getbeststingertarget();
+		if ( !isDefined( besttarget ) )
+		{
+			self destroylockoncanceledmessage();
+			continue;
+		}
+		else if ( !self locksighttest( besttarget ) )
+		{
+			self destroylockoncanceledmessage();
+			continue;
+		}
+		else if ( self locksighttest( besttarget ) && isDefined( besttarget.lockondelay ) && besttarget.lockondelay )
+		{
+			self displaylockoncanceledmessage();
+			continue;
+		}
+		else
+		{
+			self destroylockoncanceledmessage();
+			initlockfield( besttarget );
+			self.stingertarget = besttarget;
+			self.stingerlockstarttime = getTime();
+			self.stingerlockstarted = 1;
+			self.stingerlostsightlinetime = 0;
+			self thread looplocalseeksound( game[ "locking_on_sound" ], 0,6 );
+		}
+	}
+}
+
+destroylockoncanceledmessage()
+{
+	if ( isDefined( self.lockoncanceledmessage ) )
+	{
+		self.lockoncanceledmessage destroy();
+	}
+}
+
+displaylockoncanceledmessage()
+{
+	if ( isDefined( self.lockoncanceledmessage ) )
+	{
+		return;
+	}
+	self.lockoncanceledmessage = newclienthudelem( self );
+	self.lockoncanceledmessage.fontscale = 1,25;
+	self.lockoncanceledmessage.x = 0;
+	self.lockoncanceledmessage.y = 50;
+	self.lockoncanceledmessage.alignx = "center";
+	self.lockoncanceledmessage.aligny = "top";
+	self.lockoncanceledmessage.horzalign = "center";
+	self.lockoncanceledmessage.vertalign = "top";
+	self.lockoncanceledmessage.foreground = 1;
+	self.lockoncanceledmessage.hidewhendead = 0;
+	self.lockoncanceledmessage.hidewheninmenu = 1;
+	self.lockoncanceledmessage.archived = 0;
+	self.lockoncanceledmessage.alpha = 1;
+	self.lockoncanceledmessage settext( &"MP_CANNOT_LOCKON_TO_TARGET" );
+}
+
+getbeststingertarget()
+{
+	targetsall = target_getarray();
+	targetsvalid = [];
+	idx = 0;
+	while ( idx < targetsall.size )
+	{
+/#
+		if ( getDvar( "scr_freelock" ) == "1" )
+		{
+			if ( self insidestingerreticlenolock( targetsall[ idx ] ) )
+			{
+				targetsvalid[ targetsvalid.size ] = targetsall[ idx ];
+			}
+			idx++;
+			continue;
+#/
+		}
+		else if ( level.teambased )
+		{
+			if ( isDefined( targetsall[ idx ].team ) && targetsall[ idx ].team != self.team )
+			{
+				if ( self insidestingerreticlenolock( targetsall[ idx ] ) )
+				{
+					targetsvalid[ targetsvalid.size ] = targetsall[ idx ];
+				}
+			}
+			idx++;
+			continue;
+		}
+		else
+		{
+			if ( self insidestingerreticlenolock( targetsall[ idx ] ) )
+			{
+				if ( isDefined( targetsall[ idx ].owner ) && self != targetsall[ idx ].owner )
+				{
+					targetsvalid[ targetsvalid.size ] = targetsall[ idx ];
+				}
+			}
+		}
+		idx++;
+	}
+	if ( targetsvalid.size == 0 )
+	{
+		return undefined;
+	}
+	chosenent = targetsvalid[ 0 ];
+	if ( targetsvalid.size > 1 )
+	{
+	}
+	return chosenent;
+}
+
+insidestingerreticlenolock( target )
+{
+	radius = self getlockonradius();
+	return target_isincircle( target, self, 65, radius );
+}
+
+insidestingerreticlelocked( target )
+{
+	radius = self getlockonradius();
+	return target_isincircle( target, self, 65, radius );
+}
+
+isstillvalidtarget( ent )
+{
+	if ( !isDefined( ent ) )
+	{
+		return 0;
+	}
+	if ( !target_istarget( ent ) )
+	{
+		return 0;
+	}
+	if ( !insidestingerreticlelocked( ent ) )
+	{
+		return 0;
+	}
+	return 1;
+}
+
+playerstingerads()
+{
+	return self playerads() == 1;
+}
+
+looplocalseeksound( alias, interval )
+{
+	self endon( "stop_lockon_sound" );
+	self endon( "disconnect" );
+	self endon( "death" );
+	for ( ;; )
+	{
+		self playlocalsound( alias );
+		self playrumbleonentity( "stinger_lock_rumble" );
+		wait ( interval / 2 );
+	}
+}
+
+looplocallocksound( alias, interval )
+{
+	self endon( "stop_locked_sound" );
+	self endon( "disconnect" );
+	self endon( "death" );
+	if ( isDefined( self.stingerlocksound ) )
+	{
+		return;
+	}
+	self.stingerlocksound = 1;
+	for ( ;; )
+	{
+		self playlocalsound( alias );
+		self playrumbleonentity( "stinger_lock_rumble" );
+		wait ( interval / 6 );
+		self playlocalsound( alias );
+		self playrumbleonentity( "stinger_lock_rumble" );
+		wait ( interval / 6 );
+		self playlocalsound( alias );
+		self playrumbleonentity( "stinger_lock_rumble" );
+		wait ( interval / 6 );
+		self stoprumble( "stinger_lock_rumble" );
+	}
+	self.stingerlocksound = undefined;
+}
+
+locksighttest( target )
+{
+	eyepos = self geteye();
+	if ( !isDefined( target ) )
+	{
+		return 0;
+	}
+	passed = bullettracepassed( eyepos, target.origin, 0, target );
+	if ( passed )
+	{
+		return 1;
+	}
+	front = target getpointinbounds( 1, 0, 0 );
+	passed = bullettracepassed( eyepos, front, 0, target );
+	if ( passed )
+	{
+		return 1;
+	}
+	back = target getpointinbounds( -1, 0, 0 );
+	passed = bullettracepassed( eyepos, back, 0, target );
+	if ( passed )
+	{
+		return 1;
+	}
+	return 0;
+}
+
+softsighttest()
+{
+	lost_sight_limit = 500;
+	if ( self locksighttest( self.stingertarget ) )
+	{
+		self.stingerlostsightlinetime = 0;
+		return 1;
+	}
+	if ( self.stingerlostsightlinetime == 0 )
+	{
+		self.stingerlostsightlinetime = getTime();
+	}
+	timepassed = getTime() - self.stingerlostsightlinetime;
+	if ( timepassed >= lost_sight_limit )
+	{
+		self clearirtarget();
+		return 0;
+	}
+	return 1;
+}
+
+initlockfield( target )
+{
+	if ( isDefined( target.locking_on ) )
+	{
+		return;
+	}
+	target.locking_on = 0;
+	target.locked_on = 0;
+}
+
+lockingon( target, lock )
+{
+/#
+	assert( isDefined( target.locking_on ) );
+#/
+	clientnum = self getentitynumber();
+	if ( lock )
+	{
+		target notify( "locking on" );
+		target.locking_on |= 1 << clientnum;
+		self thread watchclearlockingon( target, clientnum );
+	}
+	else
+	{
+		self notify( "locking_on_cleared" );
+		target.locking_on &= 1 << clientnum;
+	}
+}
+
+watchclearlockingon( target, clientnum )
+{
+	target endon( "death" );
+	self endon( "locking_on_cleared" );
+	self waittill_any( "death", "disconnect" );
+	target.locking_on &= 1 << clientnum;
+}
+
+lockedon( target, lock )
+{
+/#
+	assert( isDefined( target.locked_on ) );
+#/
+	clientnum = self getentitynumber();
+	if ( lock )
+	{
+		target.locked_on |= 1 << clientnum;
+		self thread watchclearlockedon( target, clientnum );
+	}
+	else
+	{
+		self notify( "locked_on_cleared" );
+		target.locked_on &= 1 << clientnum;
+	}
+}
+
+watchclearlockedon( target, clientnum )
+{
+	self endon( "locked_on_cleared" );
+	self waittill_any( "death", "disconnect" );
+	if ( isDefined( target ) )
+	{
+		target.locked_on &= 1 << clientnum;
+	}
+}
+
+missiletarget_lockonmonitor( player, endon1, endon2 )
+{
+	self endon( "death" );
+	if ( isDefined( endon1 ) )
+	{
+		self endon( endon1 );
+	}
+	if ( isDefined( endon2 ) )
+	{
+		self endon( endon2 );
+	}
+	for ( ;; )
+	{
+		if ( target_istarget( self ) )
+		{
+		}
+		wait 0,1;
+	}
+}
+
+_incomingmissile( missile )
+{
+	if ( !isDefined( self.incoming_missile ) )
+	{
+		self.incoming_missile = 0;
+	}
+	self.incoming_missile++;
+	self thread _incomingmissiletracker( missile );
+}
+
+_incomingmissiletracker( missile )
+{
+	self endon( "death" );
+	missile waittill( "death" );
+	self.incoming_missile--;
+
+/#
+	assert( self.incoming_missile >= 0 );
+#/
+}
+
+missiletarget_ismissileincoming()
+{
+	if ( !isDefined( self.incoming_missile ) )
+	{
+		return 0;
+	}
+	if ( self.incoming_missile )
+	{
+		return 1;
+	}
+	return 0;
+}
+
+missiletarget_handleincomingmissile( responsefunc, endon1, endon2 )
+{
+	level endon( "game_ended" );
+	self endon( "death" );
+	if ( isDefined( endon1 ) )
+	{
+		self endon( endon1 );
+	}
+	if ( isDefined( endon2 ) )
+	{
+		self endon( endon2 );
+	}
+	for ( ;; )
+	{
+		self waittill( "stinger_fired_at_me", missile, weap, attacker );
+		_incomingmissile( missile );
+		if ( isDefined( responsefunc ) )
+		{
+			[[ responsefunc ]]( missile, attacker, weap, endon1, endon2 );
+		}
+	}
+}
+
+missiletarget_proximitydetonateincomingmissile( endon1, endon2 )
+{
+	missiletarget_handleincomingmissile( ::missiletarget_proximitydetonate, endon1, endon2 );
+}
+
+_missiledetonate( attacker, weapon )
+{
+	self endon( "death" );
+	radiusdamage( self.origin, 500, 600, 600, attacker, undefined, weapon );
+	wait 0,05;
+	self detonate();
+	wait 0,05;
+	self delete();
+}
+
+missiletarget_proximitydetonate( missile, attacker, weapon, endon1, endon2 )
+{
+	level endon( "game_ended" );
+	missile endon( "death" );
+	if ( isDefined( endon1 ) )
+	{
+		self endon( endon1 );
+	}
+	if ( isDefined( endon2 ) )
+	{
+		self endon( endon2 );
+	}
+	mindist = distance( missile.origin, self.origin );
+	lastcenter = self.origin;
+	missile missile_settarget( self );
+	for ( ;; )
+	{
+		if ( !isDefined( self ) )
+		{
+			center = lastcenter;
+		}
+		else
+		{
+			center = self.origin;
+		}
+		lastcenter = center;
+		curdist = distance( missile.origin, center );
+		if ( curdist < 3500 && isDefined( self.numflares ) && self.numflares > 0 )
+		{
+			self.numflares--;
+
+			self thread missiletarget_playflarefx();
+			self maps/mp/killstreaks/_helicopter::trackassists( attacker, 0, 1 );
+			newtarget = self missiletarget_deployflares( missile.origin, missile.angles );
+			missile missile_settarget( newtarget );
+			missiletarget = newtarget;
+			return;
+		}
+		if ( curdist < mindist )
+		{
+			mindist = curdist;
+		}
+		if ( curdist > mindist )
+		{
+			if ( curdist > 500 )
+			{
+				return;
+			}
+			missile thread _missiledetonate( attacker, weapon );
+		}
+		wait 0,05;
+	}
+}
+
+missiletarget_playflarefx()
+{
+	if ( !isDefined( self ) )
+	{
+		return;
+	}
+	flare_fx = level.fx_flare;
+	if ( isDefined( self.fx_flare ) )
+	{
+		flare_fx = self.fx_flare;
+	}
+	if ( isDefined( self.flare_ent ) )
+	{
+		playfxontag( flare_fx, self.flare_ent, "tag_origin" );
+	}
+	else
+	{
+		playfxontag( flare_fx, self, "tag_origin" );
+	}
+	if ( isDefined( self.owner ) )
+	{
+		self playsoundtoplayer( "veh_huey_chaff_drop_plr", self.owner );
+	}
+	self playsound( "veh_huey_chaff_explo_npc" );
+}
+
+missiletarget_deployflares( origin, angles )
+{
+	vec_toforward = anglesToForward( self.angles );
+	vec_toright = anglesToRight( self.angles );
+	vec_tomissileforward = anglesToForward( angles );
+	delta = self.origin - origin;
+	dot = vectordot( vec_tomissileforward, vec_toright );
+	sign = 1;
+	if ( dot > 0 )
+	{
+		sign = -1;
+	}
+	flare_dir = vectornormalize( vectorScale( vec_toforward, -0,5 ) + vectorScale( vec_toright, sign ) );
+	velocity = vectorScale( flare_dir, randomintrange( 200, 400 ) );
+	velocity = ( velocity[ 0 ], velocity[ 1 ], velocity[ 2 ] - randomintrange( 10, 100 ) );
+	flareorigin = self.origin;
+	flareorigin += vectorScale( flare_dir, randomintrange( 500, 700 ) );
+	flareorigin += vectorScale( ( 1, 0, 0 ), 500 );
+	if ( isDefined( self.flareoffset ) )
+	{
+		flareorigin += self.flareoffset;
+	}
+	flareobject = spawn( "script_origin", flareorigin );
+	flareobject.angles = self.angles;
+	flareobject setmodel( "tag_origin" );
+	flareobject movegravity( velocity, 5 );
+	flareobject thread deleteaftertime( 5 );
+	self thread debug_tracker( flareobject );
+	return flareobject;
+}
+
+debug_tracker( target )
+{
+	target endon( "death" );
+	while ( 1 )
+	{
+		maps/mp/killstreaks/_airsupport::debug_sphere( target.origin, 10, ( 1, 0, 0 ), 1, 1 );
+		wait 0,05;
+	}
+}

patch_mp/maps/mp/_interactive_objects.gsc

@@ -0,0 +1,407 @@
+#include common_scripts/utility;
+#include maps/mp/_utility;
+
+init()
+{
+	level.barrelexplodingthisframe = 0;
+	qbarrels = 0;
+	all_barrels = [];
+	barrels = getentarray( "explodable_barrel", "targetname" );
+	while ( isDefined( barrels ) && barrels.size > 0 )
+	{
+		qbarrels = 1;
+		i = 0;
+		while ( i < barrels.size )
+		{
+			all_barrels[ all_barrels.size ] = barrels[ i ];
+			i++;
+		}
+	}
+	barrels = getentarray( "explodable_barrel", "script_noteworthy" );
+	while ( isDefined( barrels ) && barrels.size > 0 )
+	{
+		qbarrels = 1;
+		i = 0;
+		while ( i < barrels.size )
+		{
+			all_barrels[ all_barrels.size ] = barrels[ i ];
+			i++;
+		}
+	}
+	if ( qbarrels )
+	{
+		precachemodel( "global_explosive_barrel" );
+		level.barrelburn = 100;
+		level.barrelhealth = 250;
+		level.barrelingsound = "exp_redbarrel_ignition";
+		level.barrelexpsound = "exp_redbarrel";
+		level.breakables_fx[ "barrel" ][ "burn_start" ] = loadfx( "destructibles/fx_barrel_ignite" );
+		level.breakables_fx[ "barrel" ][ "burn" ] = loadfx( "destructibles/fx_barrel_fire_top" );
+		level.breakables_fx[ "barrel" ][ "explode" ] = loadfx( "destructibles/fx_dest_barrelexp" );
+		array_thread( all_barrels, ::explodable_barrel_think );
+	}
+	qcrates = 0;
+	all_crates = [];
+	crates = getentarray( "flammable_crate", "targetname" );
+	while ( isDefined( crates ) && crates.size > 0 )
+	{
+		qcrates = 1;
+		i = 0;
+		while ( i < crates.size )
+		{
+			all_crates[ all_crates.size ] = crates[ i ];
+			i++;
+		}
+	}
+	crates = getentarray( "flammable_crate", "script_noteworthy" );
+	while ( isDefined( crates ) && crates.size > 0 )
+	{
+		qcrates = 1;
+		i = 0;
+		while ( i < crates.size )
+		{
+			all_crates[ all_crates.size ] = crates[ i ];
+			i++;
+		}
+	}
+	if ( qcrates )
+	{
+		precachemodel( "global_flammable_crate_jap_piece01_d" );
+		level.crateburn = 100;
+		level.cratehealth = 200;
+		level.breakables_fx[ "ammo_crate" ][ "burn_start" ] = loadfx( "destructibles/fx_ammobox_ignite" );
+		level.breakables_fx[ "ammo_crate" ][ "burn" ] = loadfx( "destructibles/fx_ammobox_fire_top" );
+		level.breakables_fx[ "ammo_crate" ][ "explode" ] = loadfx( "destructibles/fx_ammoboxExp" );
+		level.crateignsound = "Ignition_ammocrate";
+		level.crateexpsound = "Explo_ammocrate";
+		array_thread( all_crates, ::flammable_crate_think );
+	}
+	if ( !qbarrels && !qcrates )
+	{
+		return;
+	}
+}
+
+explodable_barrel_think()
+{
+	if ( self.classname != "script_model" )
+	{
+		return;
+	}
+	self endon( "exploding" );
+	self breakable_clip();
+	self.health = level.barrelhealth;
+	self setcandamage( 1 );
+	self.targetname = "explodable_barrel";
+	if ( sessionmodeiszombiesgame() )
+	{
+		self.removeexplodable = 1;
+	}
+	for ( ;; )
+	{
+		self waittill( "damage", amount, attacker, direction_vec, p, type );
+/#
+		println( "BARRELDAMAGE: " + type );
+#/
+		if ( type == "MOD_MELEE" || type == "MOD_IMPACT" )
+		{
+			continue;
+		}
+		else
+		{
+			if ( isDefined( self.script_requires_player ) && self.script_requires_player && !isplayer( attacker ) )
+			{
+				break;
+			}
+			else
+			{
+				if ( isDefined( self.script_selfisattacker ) && self.script_selfisattacker )
+				{
+					self.damageowner = self;
+				}
+				else
+				{
+					self.damageowner = attacker;
+				}
+				self.health -= amount;
+				if ( self.health <= level.barrelburn )
+				{
+					self thread explodable_barrel_burn();
+				}
+			}
+		}
+	}
+}
+
+explodable_barrel_burn()
+{
+	count = 0;
+	startedfx = 0;
+	up = anglesToUp( vectorScale( ( 0, 0, 1 ), 90 ) );
+	worldup = anglesToUp( vectorScale( ( 0, 0, 1 ), 90 ) );
+	dot = vectordot( up, worldup );
+	offset1 = ( 0, 0, 1 );
+	offset2 = up * vectorScale( ( 0, 0, 1 ), 44 );
+	if ( dot < 0,5 )
+	{
+		offset1 = ( up * vectorScale( ( 0, 0, 1 ), 22 ) ) - vectorScale( ( 0, 0, 1 ), 30 );
+		offset2 = ( up * vectorScale( ( 0, 0, 1 ), 22 ) ) + vectorScale( ( 0, 0, 1 ), 14 );
+	}
+	while ( self.health > 0 )
+	{
+		if ( !startedfx )
+		{
+			playfx( level.breakables_fx[ "barrel" ][ "burn_start" ], self.origin + offset1 );
+			level thread play_sound_in_space( level.barrelingsound, self.origin );
+			startedfx = 1;
+		}
+		if ( count > 20 )
+		{
+			count = 0;
+		}
+		playfx( level.breakables_fx[ "barrel" ][ "burn" ], self.origin + offset2 );
+		self playloopsound( "barrel_fuse" );
+		if ( count == 0 )
+		{
+			self.health -= 10 + randomint( 10 );
+		}
+		count++;
+		wait 0,05;
+	}
+	level notify( "explosion_started" );
+	self thread explodable_barrel_explode();
+}
+
+explodable_barrel_explode()
+{
+	self notify( "exploding" );
+	self death_notify_wrapper();
+	up = anglesToUp( vectorScale( ( 0, 0, 1 ), 90 ) );
+	worldup = anglesToUp( vectorScale( ( 0, 0, 1 ), 90 ) );
+	dot = vectordot( up, worldup );
+	offset = ( 0, 0, 1 );
+	if ( dot < 0,5 )
+	{
+		start = self.origin + vectorScale( up, 22 );
+		trace = physicstrace( start, start + vectorScale( ( 0, 0, 1 ), 64 ) );
+		end = trace[ "position" ];
+		offset = end - self.origin;
+	}
+	offset += vectorScale( ( 0, 0, 1 ), 4 );
+	mindamage = 1;
+	maxdamage = 250;
+	blastradius = 250;
+	level thread play_sound_in_space( level.barrelexpsound, self.origin );
+	playfx( level.breakables_fx[ "barrel" ][ "explode" ], self.origin + offset );
+	physicsexplosionsphere( self.origin + offset, 100, 80, 1, maxdamage, mindamage );
+	level.barrelexplodingthisframe = 1;
+	if ( isDefined( self.remove ) )
+	{
+		self.remove delete();
+	}
+	if ( isDefined( self.radius ) )
+	{
+		blastradius = self.radius;
+	}
+	self radiusdamage( self.origin + vectorScale( ( 0, 0, 1 ), 56 ), blastradius, maxdamage, mindamage, self.damageowner );
+	attacker = undefined;
+	if ( isDefined( self.damageowner ) )
+	{
+		attacker = self.damageowner;
+	}
+	level.lastexplodingbarrel[ "time" ] = getTime();
+	level.lastexplodingbarrel[ "origin" ] = self.origin + vectorScale( ( 0, 0, 1 ), 30 );
+	if ( isDefined( self.removeexplodable ) )
+	{
+		self hide();
+	}
+	else
+	{
+		self setmodel( "global_explosive_barrel" );
+	}
+	if ( dot < 0,5 )
+	{
+		start = self.origin + vectorScale( up, 22 );
+		trace = physicstrace( start, start + vectorScale( ( 0, 0, 1 ), 64 ) );
+		pos = trace[ "position" ];
+		self.origin = pos;
+		self.angles += vectorScale( ( 0, 0, 1 ), 90 );
+	}
+	wait 0,05;
+	level.barrelexplodingthisframe = 0;
+}
+
+flammable_crate_think()
+{
+	if ( self.classname != "script_model" )
+	{
+		return;
+	}
+	self endon( "exploding" );
+	self breakable_clip();
+	self.health = level.cratehealth;
+	self setcandamage( 1 );
+	for ( ;; )
+	{
+		self waittill( "damage", amount, attacker, direction_vec, p, type );
+		if ( isDefined( self.script_requires_player ) && self.script_requires_player && !isplayer( attacker ) )
+		{
+			continue;
+		}
+		else
+		{
+			if ( isDefined( self.script_selfisattacker ) && self.script_selfisattacker )
+			{
+				self.damageowner = self;
+			}
+			else
+			{
+				self.damageowner = attacker;
+			}
+			if ( level.barrelexplodingthisframe )
+			{
+				wait randomfloat( 1 );
+			}
+			self.health -= amount;
+			if ( self.health <= level.crateburn )
+			{
+				self thread flammable_crate_burn();
+			}
+		}
+	}
+}
+
+flammable_crate_burn()
+{
+	count = 0;
+	startedfx = 0;
+	up = anglesToUp( vectorScale( ( 0, 0, 1 ), 90 ) );
+	worldup = anglesToUp( vectorScale( ( 0, 0, 1 ), 90 ) );
+	dot = vectordot( up, worldup );
+	offset1 = ( 0, 0, 1 );
+	offset2 = up * vectorScale( ( 0, 0, 1 ), 44 );
+	if ( dot < 0,5 )
+	{
+		offset1 = ( up * vectorScale( ( 0, 0, 1 ), 22 ) ) - vectorScale( ( 0, 0, 1 ), 30 );
+		offset2 = ( up * vectorScale( ( 0, 0, 1 ), 22 ) ) + vectorScale( ( 0, 0, 1 ), 14 );
+	}
+	while ( self.health > 0 )
+	{
+		if ( !startedfx )
+		{
+			playfx( level.breakables_fx[ "ammo_crate" ][ "burn_start" ], self.origin );
+			level thread play_sound_in_space( level.crateignsound, self.origin );
+			startedfx = 1;
+		}
+		if ( count > 20 )
+		{
+			count = 0;
+		}
+		playfx( level.breakables_fx[ "ammo_crate" ][ "burn" ], self.origin );
+		if ( count == 0 )
+		{
+			self.health -= 10 + randomint( 10 );
+		}
+		count++;
+		wait 0,05;
+	}
+	self thread flammable_crate_explode();
+}
+
+flammable_crate_explode()
+{
+	self notify( "exploding" );
+	self death_notify_wrapper();
+	up = anglesToUp( vectorScale( ( 0, 0, 1 ), 90 ) );
+	worldup = anglesToUp( vectorScale( ( 0, 0, 1 ), 90 ) );
+	dot = vectordot( up, worldup );
+	offset = ( 0, 0, 1 );
+	if ( dot < 0,5 )
+	{
+		start = self.origin + vectorScale( up, 22 );
+		trace = physicstrace( start, start + vectorScale( ( 0, 0, 1 ), 64 ) );
+		end = trace[ "position" ];
+		offset = end - self.origin;
+	}
+	offset += vectorScale( ( 0, 0, 1 ), 4 );
+	mindamage = 1;
+	maxdamage = 250;
+	blastradius = 250;
+	level thread play_sound_in_space( level.crateexpsound, self.origin );
+	playfx( level.breakables_fx[ "ammo_crate" ][ "explode" ], self.origin );
+	physicsexplosionsphere( self.origin + offset, 100, 80, 1, maxdamage, mindamage );
+	level.barrelexplodingthisframe = 1;
+	if ( isDefined( self.remove ) )
+	{
+		self.remove delete();
+	}
+	if ( isDefined( self.radius ) )
+	{
+		blastradius = self.radius;
+	}
+	attacker = undefined;
+	if ( isDefined( self.damageowner ) )
+	{
+		attacker = self.damageowner;
+	}
+	self radiusdamage( self.origin + vectorScale( ( 0, 0, 1 ), 30 ), blastradius, maxdamage, mindamage, attacker );
+	self setmodel( "global_flammable_crate_jap_piece01_d" );
+	if ( dot < 0,5 )
+	{
+		start = self.origin + vectorScale( up, 22 );
+		trace = physicstrace( start, start + vectorScale( ( 0, 0, 1 ), 64 ) );
+		pos = trace[ "position" ];
+		self.origin = pos;
+		self.angles += vectorScale( ( 0, 0, 1 ), 90 );
+	}
+	wait 0,05;
+	level.barrelexplodingthisframe = 0;
+}
+
+breakable_clip()
+{
+	if ( isDefined( self.target ) )
+	{
+		targ = getent( self.target, "targetname" );
+		if ( targ.classname == "script_brushmodel" )
+		{
+			self.remove = targ;
+			return;
+		}
+	}
+	if ( isDefined( level.breakables_clip ) && level.breakables_clip.size > 0 )
+	{
+		self.remove = getclosestent( self.origin, level.breakables_clip );
+	}
+	if ( isDefined( self.remove ) )
+	{
+		arrayremovevalue( level.breakables_clip, self.remove );
+	}
+}
+
+getclosestent( org, array )
+{
+	if ( array.size < 1 )
+	{
+		return;
+	}
+	dist = 256;
+	ent = undefined;
+	i = 0;
+	while ( i < array.size )
+	{
+		newdist = distance( array[ i ] getorigin(), org );
+		if ( newdist >= dist )
+		{
+			i++;
+			continue;
+		}
+		else
+		{
+			dist = newdist;
+			ent = array[ i ];
+		}
+		i++;
+	}
+	return ent;
+}

patch_mp/maps/mp/_load.gsc

@@ -0,0 +1,537 @@
+#include maps/mp/gametypes/_spawnlogic;
+#include maps/mp/animscripts/traverse/shared;
+#include maps/mp/animscripts/utility;
+#include maps/mp/_load;
+#include maps/mp/_createfx;
+#include maps/mp/_music;
+#include maps/mp/_busing;
+#include maps/mp/_script_gen;
+#include maps/mp/_utility;
+#include common_scripts/utility;
+
+main( bscriptgened, bcsvgened, bsgenabled )
+{
+	if ( !isDefined( level.script_gen_dump_reasons ) )
+	{
+		level.script_gen_dump_reasons = [];
+	}
+	if ( !isDefined( bsgenabled ) )
+	{
+		level.script_gen_dump_reasons[ level.script_gen_dump_reasons.size ] = "First run";
+	}
+	if ( !isDefined( bcsvgened ) )
+	{
+		bcsvgened = 0;
+	}
+	level.bcsvgened = bcsvgened;
+	if ( !isDefined( bscriptgened ) )
+	{
+		bscriptgened = 0;
+	}
+	else
+	{
+		bscriptgened = 1;
+	}
+	level.bscriptgened = bscriptgened;
+	level._loadstarted = 1;
+	struct_class_init();
+	level.clientscripts = getDvar( "cg_usingClientScripts" ) != "";
+	level._client_exploders = [];
+	level._client_exploder_ids = [];
+	if ( !isDefined( level.flag ) )
+	{
+		level.flag = [];
+		level.flags_lock = [];
+	}
+	if ( !isDefined( level.timeofday ) )
+	{
+		level.timeofday = "day";
+	}
+	flag_init( "scriptgen_done" );
+	level.script_gen_dump_reasons = [];
+	if ( !isDefined( level.script_gen_dump ) )
+	{
+		level.script_gen_dump = [];
+		level.script_gen_dump_reasons[ 0 ] = "First run";
+	}
+	if ( !isDefined( level.script_gen_dump2 ) )
+	{
+		level.script_gen_dump2 = [];
+	}
+	if ( isDefined( level.createfxent ) )
+	{
+		script_gen_dump_addline( "maps\\mp\\createfx\\" + level.script + "_fx::main();", level.script + "_fx" );
+	}
+	while ( isDefined( level.script_gen_dump_preload ) )
+	{
+		i = 0;
+		while ( i < level.script_gen_dump_preload.size )
+		{
+			script_gen_dump_addline( level.script_gen_dump_preload[ i ].string, level.script_gen_dump_preload[ i ].signature );
+			i++;
+		}
+	}
+	if ( getDvar( "scr_RequiredMapAspectratio" ) == "" )
+	{
+		setdvar( "scr_RequiredMapAspectratio", "1" );
+	}
+	setdvar( "r_waterFogTest", 0 );
+	setdvar( "tu6_player_shallowWaterHeight", "0.0" );
+	precacherumble( "reload_small" );
+	precacherumble( "reload_medium" );
+	precacherumble( "reload_large" );
+	precacherumble( "reload_clipin" );
+	precacherumble( "reload_clipout" );
+	precacherumble( "reload_rechamber" );
+	precacherumble( "pullout_small" );
+	precacherumble( "buzz_high" );
+	precacherumble( "riotshield_impact" );
+	registerclientsys( "levelNotify" );
+	level.aitriggerspawnflags = getaitriggerflags();
+	level.vehicletriggerspawnflags = getvehicletriggerflags();
+	level.physicstracemaskphysics = 1;
+	level.physicstracemaskvehicle = 2;
+	level.physicstracemaskwater = 4;
+	level.physicstracemaskclip = 8;
+	level.physicstracecontentsvehicleclip = 16;
+	level.createfx_enabled = getDvar( "createfx" ) != "";
+	if ( !sessionmodeiszombiesgame() )
+	{
+		thread maps/mp/gametypes/_spawning::init();
+		thread maps/mp/gametypes/_tweakables::init();
+		thread maps/mp/_destructible::init();
+		thread maps/mp/_riotshield::register();
+		thread maps/mp/_vehicles::init();
+		thread maps/mp/killstreaks/_dogs::init();
+		thread maps/mp/killstreaks/_ai_tank::register();
+		thread maps/mp/killstreaks/_rcbomb::register();
+		thread maps/mp/killstreaks/_helicopter_guard::register();
+		thread maps/mp/_trophy_system::register();
+		thread maps/mp/_proximity_grenade::register();
+		maps/mp/_audio::init();
+		thread maps/mp/_busing::businit();
+		thread maps/mp/_music::music_init();
+		thread maps/mp/_fxanim::init();
+	}
+	else
+	{
+		level thread start_intro_screen_zm();
+		thread maps/mp/_interactive_objects::init();
+		maps/mp/_audio::init();
+		thread maps/mp/_busing::businit();
+		thread maps/mp/_music::music_init();
+		thread maps/mp/_fxanim::init();
+		thread maps/mp/_serverfaceanim_mp::init();
+		if ( level.createfx_enabled )
+		{
+			setinitialplayersconnected();
+		}
+	}
+	visionsetnight( "default_night" );
+	setup_traversals();
+	maps/mp/_art::main();
+	setupexploders();
+	parse_structs();
+	if ( sessionmodeiszombiesgame() )
+	{
+		thread footsteps();
+	}
+/#
+	level thread level_notify_listener();
+	level thread client_notify_listener();
+#/
+	thread maps/mp/_createfx::fx_init();
+	if ( level.createfx_enabled )
+	{
+		calculate_map_center();
+		maps/mp/_createfx::createfx();
+	}
+	if ( getDvar( #"F7B30924" ) == "1" )
+	{
+		maps/mp/_global_fx::main();
+		level waittill( "eternity" );
+	}
+	thread maps/mp/_global_fx::main();
+	maps/mp/_demo::init();
+	if ( !sessionmodeiszombiesgame() )
+	{
+		thread maps/mp/_development_dvars::init();
+	}
+	p = 0;
+	while ( p < 6 )
+	{
+		switch( p )
+		{
+			case 0:
+				triggertype = "trigger_multiple";
+				break;
+			case 1:
+				triggertype = "trigger_once";
+				break;
+			case 2:
+				triggertype = "trigger_use";
+				break;
+			case 3:
+				triggertype = "trigger_radius";
+				break;
+			case 4:
+				triggertype = "trigger_lookat";
+				break;
+			default:
+/#
+				assert( p == 5 );
+#/
+				triggertype = "trigger_damage";
+				break;
+		}
+		triggers = getentarray( triggertype, "classname" );
+		i = 0;
+		while ( i < triggers.size )
+		{
+			if ( isDefined( triggers[ i ].script_prefab_exploder ) )
+			{
+				triggers[ i ].script_exploder = triggers[ i ].script_prefab_exploder;
+			}
+			if ( isDefined( triggers[ i ].script_exploder ) )
+			{
+				level thread maps/mp/_load::exploder_load( triggers[ i ] );
+			}
+			i++;
+		}
+		p++;
+	}
+}
+
+level_notify_listener()
+{
+	while ( 1 )
+	{
+		val = getDvar( "level_notify" );
+		if ( val != "" )
+		{
+			level notify( val );
+			setdvar( "level_notify", "" );
+		}
+		wait 0,2;
+	}
+}
+
+client_notify_listener()
+{
+	while ( 1 )
+	{
+		val = getDvar( "client_notify" );
+		if ( val != "" )
+		{
+			clientnotify( val );
+			setdvar( "client_notify", "" );
+		}
+		wait 0,2;
+	}
+}
+
+footsteps()
+{
+	maps/mp/animscripts/utility::setfootstepeffect( "asphalt", loadfx( "bio/player/fx_footstep_dust" ) );
+	maps/mp/animscripts/utility::setfootstepeffect( "brick", loadfx( "bio/player/fx_footstep_dust" ) );
+	maps/mp/animscripts/utility::setfootstepeffect( "carpet", loadfx( "bio/player/fx_footstep_dust" ) );
+	maps/mp/animscripts/utility::setfootstepeffect( "cloth", loadfx( "bio/player/fx_footstep_dust" ) );
+	maps/mp/animscripts/utility::setfootstepeffect( "concrete", loadfx( "bio/player/fx_footstep_dust" ) );
+	maps/mp/animscripts/utility::setfootstepeffect( "dirt", loadfx( "bio/player/fx_footstep_sand" ) );
+	maps/mp/animscripts/utility::setfootstepeffect( "foliage", loadfx( "bio/player/fx_footstep_sand" ) );
+	maps/mp/animscripts/utility::setfootstepeffect( "gravel", loadfx( "bio/player/fx_footstep_dust" ) );
+	maps/mp/animscripts/utility::setfootstepeffect( "grass", loadfx( "bio/player/fx_footstep_dust" ) );
+	maps/mp/animscripts/utility::setfootstepeffect( "metal", loadfx( "bio/player/fx_footstep_dust" ) );
+	maps/mp/animscripts/utility::setfootstepeffect( "mud", loadfx( "bio/player/fx_footstep_mud" ) );
+	maps/mp/animscripts/utility::setfootstepeffect( "paper", loadfx( "bio/player/fx_footstep_dust" ) );
+	maps/mp/animscripts/utility::setfootstepeffect( "plaster", loadfx( "bio/player/fx_footstep_dust" ) );
+	maps/mp/animscripts/utility::setfootstepeffect( "rock", loadfx( "bio/player/fx_footstep_dust" ) );
+	maps/mp/animscripts/utility::setfootstepeffect( "sand", loadfx( "bio/player/fx_footstep_sand" ) );
+	maps/mp/animscripts/utility::setfootstepeffect( "water", loadfx( "bio/player/fx_footstep_water" ) );
+	maps/mp/animscripts/utility::setfootstepeffect( "wood", loadfx( "bio/player/fx_footstep_dust" ) );
+}
+
+parse_structs()
+{
+	i = 0;
+	while ( i < level.struct.size )
+	{
+		if ( isDefined( level.struct[ i ].targetname ) )
+		{
+			if ( level.struct[ i ].targetname == "flak_fire_fx" )
+			{
+				level._effect[ "flak20_fire_fx" ] = loadfx( "weapon/tracer/fx_tracer_flak_single_noExp" );
+				level._effect[ "flak38_fire_fx" ] = loadfx( "weapon/tracer/fx_tracer_quad_20mm_Flak38_noExp" );
+				level._effect[ "flak_cloudflash_night" ] = loadfx( "weapon/flak/fx_flak_cloudflash_night" );
+				level._effect[ "flak_burst_single" ] = loadfx( "weapon/flak/fx_flak_single_day_dist" );
+			}
+			if ( level.struct[ i ].targetname == "fake_fire_fx" )
+			{
+				level._effect[ "distant_muzzleflash" ] = loadfx( "weapon/muzzleflashes/heavy" );
+			}
+			if ( level.struct[ i ].targetname == "spotlight_fx" )
+			{
+				level._effect[ "spotlight_beam" ] = loadfx( "env/light/fx_ray_spotlight_md" );
+			}
+		}
+		i++;
+	}
+}
+
+exploder_load( trigger )
+{
+	level endon( "killexplodertridgers" + trigger.script_exploder );
+	trigger waittill( "trigger" );
+	if ( isDefined( trigger.script_chance ) && randomfloat( 1 ) > trigger.script_chance )
+	{
+		if ( isDefined( trigger.script_delay ) )
+		{
+			wait trigger.script_delay;
+		}
+		else
+		{
+			wait 4;
+		}
+		level thread exploder_load( trigger );
+		return;
+	}
+	maps/mp/_utility::exploder( trigger.script_exploder );
+	level notify( "killexplodertridgers" + trigger.script_exploder );
+}
+
+setupexploders()
+{
+	ents = getentarray( "script_brushmodel", "classname" );
+	smodels = getentarray( "script_model", "classname" );
+	i = 0;
+	while ( i < smodels.size )
+	{
+		ents[ ents.size ] = smodels[ i ];
+		i++;
+	}
+	i = 0;
+	while ( i < ents.size )
+	{
+		if ( isDefined( ents[ i ].script_prefab_exploder ) )
+		{
+			ents[ i ].script_exploder = ents[ i ].script_prefab_exploder;
+		}
+		if ( isDefined( ents[ i ].script_exploder ) )
+		{
+			if ( ents[ i ].model == "fx" || !isDefined( ents[ i ].targetname ) && ents[ i ].targetname != "exploderchunk" )
+			{
+				ents[ i ] hide();
+				i++;
+				continue;
+			}
+			else
+			{
+				if ( isDefined( ents[ i ].targetname ) && ents[ i ].targetname == "exploder" )
+				{
+					ents[ i ] hide();
+					ents[ i ] notsolid();
+					i++;
+					continue;
+				}
+				else
+				{
+					if ( isDefined( ents[ i ].targetname ) && ents[ i ].targetname == "exploderchunk" )
+					{
+						ents[ i ] hide();
+						ents[ i ] notsolid();
+					}
+				}
+			}
+		}
+		i++;
+	}
+	script_exploders = [];
+	potentialexploders = getentarray( "script_brushmodel", "classname" );
+	i = 0;
+	while ( i < potentialexploders.size )
+	{
+		if ( isDefined( potentialexploders[ i ].script_prefab_exploder ) )
+		{
+			potentialexploders[ i ].script_exploder = potentialexploders[ i ].script_prefab_exploder;
+		}
+		if ( isDefined( potentialexploders[ i ].script_exploder ) )
+		{
+			script_exploders[ script_exploders.size ] = potentialexploders[ i ];
+		}
+		i++;
+	}
+	potentialexploders = getentarray( "script_model", "classname" );
+	i = 0;
+	while ( i < potentialexploders.size )
+	{
+		if ( isDefined( potentialexploders[ i ].script_prefab_exploder ) )
+		{
+			potentialexploders[ i ].script_exploder = potentialexploders[ i ].script_prefab_exploder;
+		}
+		if ( isDefined( potentialexploders[ i ].script_exploder ) )
+		{
+			script_exploders[ script_exploders.size ] = potentialexploders[ i ];
+		}
+		i++;
+	}
+	potentialexploders = getentarray( "item_health", "classname" );
+	i = 0;
+	while ( i < potentialexploders.size )
+	{
+		if ( isDefined( potentialexploders[ i ].script_prefab_exploder ) )
+		{
+			potentialexploders[ i ].script_exploder = potentialexploders[ i ].script_prefab_exploder;
+		}
+		if ( isDefined( potentialexploders[ i ].script_exploder ) )
+		{
+			script_exploders[ script_exploders.size ] = potentialexploders[ i ];
+		}
+		i++;
+	}
+	if ( !isDefined( level.createfxent ) )
+	{
+		level.createfxent = [];
+	}
+	acceptabletargetnames = [];
+	acceptabletargetnames[ "exploderchunk visible" ] = 1;
+	acceptabletargetnames[ "exploderchunk" ] = 1;
+	acceptabletargetnames[ "exploder" ] = 1;
+	i = 0;
+	while ( i < script_exploders.size )
+	{
+		exploder = script_exploders[ i ];
+		ent = createexploder( exploder.script_fxid );
+		ent.v = [];
+		ent.v[ "origin" ] = exploder.origin;
+		ent.v[ "angles" ] = exploder.angles;
+		ent.v[ "delay" ] = exploder.script_delay;
+		ent.v[ "firefx" ] = exploder.script_firefx;
+		ent.v[ "firefxdelay" ] = exploder.script_firefxdelay;
+		ent.v[ "firefxsound" ] = exploder.script_firefxsound;
+		ent.v[ "firefxtimeout" ] = exploder.script_firefxtimeout;
+		ent.v[ "earthquake" ] = exploder.script_earthquake;
+		ent.v[ "damage" ] = exploder.script_damage;
+		ent.v[ "damage_radius" ] = exploder.script_radius;
+		ent.v[ "soundalias" ] = exploder.script_soundalias;
+		ent.v[ "repeat" ] = exploder.script_repeat;
+		ent.v[ "delay_min" ] = exploder.script_delay_min;
+		ent.v[ "delay_max" ] = exploder.script_delay_max;
+		ent.v[ "target" ] = exploder.target;
+		ent.v[ "ender" ] = exploder.script_ender;
+		ent.v[ "type" ] = "exploder";
+		if ( !isDefined( exploder.script_fxid ) )
+		{
+			ent.v[ "fxid" ] = "No FX";
+		}
+		else
+		{
+			ent.v[ "fxid" ] = exploder.script_fxid;
+		}
+		ent.v[ "exploder" ] = exploder.script_exploder;
+/#
+		assert( isDefined( exploder.script_exploder ), "Exploder at origin " + exploder.origin + " has no script_exploder" );
+#/
+		if ( !isDefined( ent.v[ "delay" ] ) )
+		{
+			ent.v[ "delay" ] = 0;
+		}
+		if ( isDefined( exploder.target ) )
+		{
+			org = getent( ent.v[ "target" ], "targetname" ).origin;
+			ent.v[ "angles" ] = vectorToAngle( org - ent.v[ "origin" ] );
+		}
+		if ( exploder.classname == "script_brushmodel" || isDefined( exploder.model ) )
+		{
+			ent.model = exploder;
+			ent.model.disconnect_paths = exploder.script_disconnectpaths;
+		}
+		if ( isDefined( exploder.targetname ) && isDefined( acceptabletargetnames[ exploder.targetname ] ) )
+		{
+			ent.v[ "exploder_type" ] = exploder.targetname;
+		}
+		else
+		{
+			ent.v[ "exploder_type" ] = "normal";
+		}
+		ent maps/mp/_createfx::post_entity_creation_function();
+		i++;
+	}
+	level.createfxexploders = [];
+	i = 0;
+	while ( i < level.createfxent.size )
+	{
+		ent = level.createfxent[ i ];
+		if ( ent.v[ "type" ] != "exploder" )
+		{
+			i++;
+			continue;
+		}
+		else
+		{
+			ent.v[ "exploder_id" ] = getexploderid( ent );
+			if ( !isDefined( level.createfxexploders[ ent.v[ "exploder" ] ] ) )
+			{
+				level.createfxexploders[ ent.v[ "exploder" ] ] = [];
+			}
+			level.createfxexploders[ ent.v[ "exploder" ] ][ level.createfxexploders[ ent.v[ "exploder" ] ].size ] = ent;
+		}
+		i++;
+	}
+}
+
+setup_traversals()
+{
+	potential_traverse_nodes = getallnodes();
+	i = 0;
+	while ( i < potential_traverse_nodes.size )
+	{
+		node = potential_traverse_nodes[ i ];
+		if ( node.type == "Begin" )
+		{
+			node maps/mp/animscripts/traverse/shared::init_traverse();
+		}
+		i++;
+	}
+}
+
+calculate_map_center()
+{
+	if ( !isDefined( level.mapcenter ) )
+	{
+		level.nodesmins = ( 0, 0, 0 );
+		level.nodesmaxs = ( 0, 0, 0 );
+		level.mapcenter = maps/mp/gametypes/_spawnlogic::findboxcenter( level.nodesmins, level.nodesmaxs );
+/#
+		println( "map center: ", level.mapcenter );
+#/
+		setmapcenter( level.mapcenter );
+	}
+}
+
+start_intro_screen_zm()
+{
+	if ( level.createfx_enabled )
+	{
+		return;
+	}
+	if ( !isDefined( level.introscreen ) )
+	{
+		level.introscreen = newhudelem();
+		level.introscreen.x = 0;
+		level.introscreen.y = 0;
+		level.introscreen.horzalign = "fullscreen";
+		level.introscreen.vertalign = "fullscreen";
+		level.introscreen.foreground = 0;
+		level.introscreen setshader( "black", 640, 480 );
+		wait 0,05;
+	}
+	level.introscreen.alpha = 1;
+	players = get_players();
+	i = 0;
+	while ( i < players.size )
+	{
+		players[ i ] freezecontrols( 1 );
+		i++;
+	}
+	wait 1;
+}

patch_mp/maps/mp/_medals.gsc

@@ -0,0 +1,41 @@
+#include common_scripts/utility;
+#include maps/mp/_scoreevents;
+#include maps/mp/_utility;
+
+init()
+{
+	level.medalinfo = [];
+	level.medalcallbacks = [];
+	level.numkills = 0;
+	level thread onplayerconnect();
+}
+
+onplayerconnect()
+{
+	for ( ;; )
+	{
+		level waittill( "connected", player );
+		player.lastkilledby = undefined;
+	}
+}
+
+setlastkilledby( attacker )
+{
+	self.lastkilledby = attacker;
+}
+
+offenseglobalcount()
+{
+	level.globalteammedals++;
+}
+
+defenseglobalcount()
+{
+	level.globalteammedals++;
+}
+
+codecallback_medal( medalindex )
+{
+	self luinotifyevent( &"medal_received", 1, medalindex );
+	self luinotifyeventtospectators( &"medal_received", 1, medalindex );
+}

patch_mp/maps/mp/_menus.gsc

@@ -0,0 +1,4 @@
+
+init()
+{
+}

patch_mp/maps/mp/_mgturret.gsc

@@ -0,0 +1,322 @@
+#include common_scripts/utility;
+#include maps/mp/_utility;
+
+main()
+{
+	if ( getDvar( #"7C9A91DF" ) == "" )
+	{
+		setdvar( "mgTurret", "off" );
+	}
+	level.magic_distance = 24;
+	turretinfos = getentarray( "turretInfo", "targetname" );
+	index = 0;
+	while ( index < turretinfos.size )
+	{
+		turretinfos[ index ] delete();
+		index++;
+	}
+}
+
+set_difficulty( difficulty )
+{
+	init_turret_difficulty_settings();
+	turrets = getentarray( "misc_turret", "classname" );
+	index = 0;
+	while ( index < turrets.size )
+	{
+		if ( isDefined( turrets[ index ].script_skilloverride ) )
+		{
+			switch( turrets[ index ].script_skilloverride )
+			{
+				case "easy":
+					difficulty = "easy";
+					break;
+				break;
+				case "medium":
+					difficulty = "medium";
+					break;
+				break;
+				case "hard":
+					difficulty = "hard";
+					break;
+				break;
+				case "fu":
+					difficulty = "fu";
+					break;
+				break;
+				default:
+				}
+			}
+			turret_set_difficulty( turrets[ index ], difficulty );
+			index++;
+		}
+	}
+}
+
+init_turret_difficulty_settings()
+{
+	level.mgturretsettings[ "easy" ][ "convergenceTime" ] = 2,5;
+	level.mgturretsettings[ "easy" ][ "suppressionTime" ] = 3;
+	level.mgturretsettings[ "easy" ][ "accuracy" ] = 0,38;
+	level.mgturretsettings[ "easy" ][ "aiSpread" ] = 2;
+	level.mgturretsettings[ "easy" ][ "playerSpread" ] = 0,5;
+	level.mgturretsettings[ "medium" ][ "convergenceTime" ] = 1,5;
+	level.mgturretsettings[ "medium" ][ "suppressionTime" ] = 3;
+	level.mgturretsettings[ "medium" ][ "accuracy" ] = 0,38;
+	level.mgturretsettings[ "medium" ][ "aiSpread" ] = 2;
+	level.mgturretsettings[ "medium" ][ "playerSpread" ] = 0,5;
+	level.mgturretsettings[ "hard" ][ "convergenceTime" ] = 0,8;
+	level.mgturretsettings[ "hard" ][ "suppressionTime" ] = 3;
+	level.mgturretsettings[ "hard" ][ "accuracy" ] = 0,38;
+	level.mgturretsettings[ "hard" ][ "aiSpread" ] = 2;
+	level.mgturretsettings[ "hard" ][ "playerSpread" ] = 0,5;
+	level.mgturretsettings[ "fu" ][ "convergenceTime" ] = 0,4;
+	level.mgturretsettings[ "fu" ][ "suppressionTime" ] = 3;
+	level.mgturretsettings[ "fu" ][ "accuracy" ] = 0,38;
+	level.mgturretsettings[ "fu" ][ "aiSpread" ] = 2;
+	level.mgturretsettings[ "fu" ][ "playerSpread" ] = 0,5;
+}
+
+turret_set_difficulty( turret, difficulty )
+{
+	turret.convergencetime = level.mgturretsettings[ difficulty ][ "convergenceTime" ];
+	turret.suppressiontime = level.mgturretsettings[ difficulty ][ "suppressionTime" ];
+	turret.accuracy = level.mgturretsettings[ difficulty ][ "accuracy" ];
+	turret.aispread = level.mgturretsettings[ difficulty ][ "aiSpread" ];
+	turret.playerspread = level.mgturretsettings[ difficulty ][ "playerSpread" ];
+}
+
+turret_suppression_fire( targets )
+{
+	self endon( "death" );
+	self endon( "stop_suppression_fire" );
+	if ( !isDefined( self.suppresionfire ) )
+	{
+		self.suppresionfire = 1;
+	}
+	for ( ;; )
+	{
+		while ( self.suppresionfire )
+		{
+			self settargetentity( targets[ randomint( targets.size ) ] );
+			wait ( 2 + randomfloat( 2 ) );
+		}
+		self cleartargetentity();
+		while ( !self.suppresionfire )
+		{
+			wait 1;
+		}
+	}
+}
+
+burst_fire_settings( setting )
+{
+	if ( setting == "delay" )
+	{
+		return 0,2;
+	}
+	else
+	{
+		if ( setting == "delay_range" )
+		{
+			return 0,5;
+		}
+		else
+		{
+			if ( setting == "burst" )
+			{
+				return 0,5;
+			}
+			else
+			{
+				if ( setting == "burst_range" )
+				{
+					return 4;
+				}
+			}
+		}
+	}
+}
+
+burst_fire( turret, manual_target )
+{
+	turret endon( "death" );
+	turret endon( "stopfiring" );
+	self endon( "stop_using_built_in_burst_fire" );
+	if ( isDefined( turret.script_delay_min ) )
+	{
+		turret_delay = turret.script_delay_min;
+	}
+	else
+	{
+		turret_delay = burst_fire_settings( "delay" );
+	}
+	if ( isDefined( turret.script_delay_max ) )
+	{
+		turret_delay_range = turret.script_delay_max - turret_delay;
+	}
+	else
+	{
+		turret_delay_range = burst_fire_settings( "delay_range" );
+	}
+	if ( isDefined( turret.script_burst_min ) )
+	{
+		turret_burst = turret.script_burst_min;
+	}
+	else
+	{
+		turret_burst = burst_fire_settings( "burst" );
+	}
+	if ( isDefined( turret.script_burst_max ) )
+	{
+		turret_burst_range = turret.script_burst_max - turret_burst;
+	}
+	else
+	{
+		turret_burst_range = burst_fire_settings( "burst_range" );
+	}
+	while ( 1 )
+	{
+		turret startfiring();
+		if ( isDefined( manual_target ) )
+		{
+			turret thread random_spread( manual_target );
+		}
+		turret do_shoot();
+		wait ( turret_burst + randomfloat( turret_burst_range ) );
+		turret stopshootturret();
+		turret stopfiring();
+		wait ( turret_delay + randomfloat( turret_delay_range ) );
+	}
+}
+
+burst_fire_unmanned()
+{
+	self notify( "stop_burst_fire_unmanned" );
+	self endon( "stop_burst_fire_unmanned" );
+	self endon( "death" );
+	self endon( "remote_start" );
+	level endon( "game_ended" );
+	if ( isDefined( self.controlled ) && self.controlled )
+	{
+		return;
+	}
+	if ( isDefined( self.script_delay_min ) )
+	{
+		turret_delay = self.script_delay_min;
+	}
+	else
+	{
+		turret_delay = burst_fire_settings( "delay" );
+	}
+	if ( isDefined( self.script_delay_max ) )
+	{
+		turret_delay_range = self.script_delay_max - turret_delay;
+	}
+	else
+	{
+		turret_delay_range = burst_fire_settings( "delay_range" );
+	}
+	if ( isDefined( self.script_burst_min ) )
+	{
+		turret_burst = self.script_burst_min;
+	}
+	else
+	{
+		turret_burst = burst_fire_settings( "burst" );
+	}
+	if ( isDefined( self.script_burst_max ) )
+	{
+		turret_burst_range = self.script_burst_max - turret_burst;
+	}
+	else
+	{
+		turret_burst_range = burst_fire_settings( "burst_range" );
+	}
+	pauseuntiltime = getTime();
+	turretstate = "start";
+	self.script_shooting = 0;
+	for ( ;; )
+	{
+		if ( isDefined( self.manual_targets ) )
+		{
+			self cleartargetentity();
+			self settargetentity( self.manual_targets[ randomint( self.manual_targets.size ) ] );
+		}
+		duration = ( pauseuntiltime - getTime() ) * 0,001;
+		if ( self isfiringturret() && duration <= 0 )
+		{
+			if ( turretstate != "fire" )
+			{
+				turretstate = "fire";
+				self playsound( "mpl_turret_alert" );
+				self thread do_shoot();
+				self.script_shooting = 1;
+			}
+			duration = turret_burst + randomfloat( turret_burst_range );
+			self thread turret_timer( duration );
+			self waittill( "turretstatechange" );
+			self.script_shooting = 0;
+			duration = turret_delay + randomfloat( turret_delay_range );
+			pauseuntiltime = getTime() + int( duration * 1000 );
+			continue;
+		}
+		else
+		{
+			if ( turretstate != "aim" )
+			{
+				turretstate = "aim";
+			}
+			self thread turret_timer( duration );
+			self waittill( "turretstatechange" );
+		}
+	}
+}
+
+do_shoot()
+{
+	self endon( "death" );
+	self endon( "turretstatechange" );
+	for ( ;; )
+	{
+		self shootturret();
+		wait 0,112;
+	}
+}
+
+turret_timer( duration )
+{
+	if ( duration <= 0 )
+	{
+		return;
+	}
+	self endon( "turretstatechange" );
+	wait duration;
+	if ( isDefined( self ) )
+	{
+		self notify( "turretstatechange" );
+	}
+}
+
+random_spread( ent )
+{
+	self endon( "death" );
+	self notify( "stop random_spread" );
+	self endon( "stop random_spread" );
+	self endon( "stopfiring" );
+	self settargetentity( ent );
+	self.manual_target = ent;
+	while ( 1 )
+	{
+		if ( isplayer( ent ) )
+		{
+			ent.origin = self.manual_target getorigin();
+		}
+		else
+		{
+			ent.origin = self.manual_target.origin;
+		}
+		ent.origin += ( 20 - randomfloat( 40 ), 20 - randomfloat( 40 ), 20 - randomfloat( 60 ) );
+		wait 0,2;
+	}
+}

patch_mp/maps/mp/_multi_extracam.gsc

@@ -0,0 +1,4 @@
+
+init()
+{
+}

patch_mp/maps/mp/_music.gsc

@@ -0,0 +1,30 @@
+#include maps/mp/_utility;
+
+music_init()
+{
+/#
+	assert( level.clientscripts );
+#/
+	level.musicstate = "";
+	registerclientsys( "musicCmd" );
+}
+
+setmusicstate( state, player )
+{
+	if ( isDefined( level.musicstate ) )
+	{
+		if ( isDefined( player ) )
+		{
+			setclientsysstate( "musicCmd", state, player );
+			return;
+		}
+		else
+		{
+			if ( level.musicstate != state )
+			{
+				setclientsysstate( "musicCmd", state );
+			}
+		}
+	}
+	level.musicstate = state;
+}

patch_mp/maps/mp/_pc.gsc

@@ -0,0 +1,5 @@
+
+pcserver()
+{
+	pcserverupdateplaylist();
+}

patch_mp/maps/mp/_popups.gsc

@@ -0,0 +1,393 @@
+#include maps/mp/gametypes/_hud_message;
+#include maps/mp/gametypes/_rank;
+#include maps/mp/gametypes/_persistence;
+#include maps/mp/_medals;
+#include common_scripts/utility;
+#include maps/mp/_utility;
+
+init()
+{
+	level.contractsettings = spawnstruct();
+	level.contractsettings.waittime = 4,2;
+	level.killstreaksettings = spawnstruct();
+	level.killstreaksettings.waittime = 3;
+	level.ranksettings = spawnstruct();
+	level.ranksettings.waittime = 3;
+	level.startmessage = spawnstruct();
+	level.startmessagedefaultduration = 2;
+	level.endmessagedefaultduration = 2;
+	level.challengesettings = spawnstruct();
+	level.challengesettings.waittime = 3;
+	level.teammessage = spawnstruct();
+	level.teammessage.waittime = 3;
+	level.regulargamemessages = spawnstruct();
+	level.regulargamemessages.waittime = 6;
+	level.wagersettings = spawnstruct();
+	level.wagersettings.waittime = 3;
+	level.momentumnotifywaittime = 0;
+	level.momentumnotifywaitlasttime = 0;
+	level.teammessagequeuemax = 8;
+	precachestring( &"KILLSTREAK_DESTROYED_UAV" );
+	precachestring( &"KILLSTREAK_DESTROYED_COUNTERUAV" );
+	precachestring( &"KILLSTREAK_DESTROYED_REMOTE_MORTAR" );
+	precachestring( &"KILLSTREAK_MP40_INBOUND" );
+	precachestring( &"KILLSTREAK_M220_TOW_INBOUND" );
+	precachestring( &"KILLSTREAK_MINIGUN_INBOUND" );
+	precachestring( &"KILLSTREAK_M202_FLASH_INBOUND" );
+	precachestring( &"KILLSTREAK_M32_INBOUND" );
+	precachestring( &"MP_CAPTURED_THE_FLAG" );
+	precachestring( &"MP_KILLED_FLAG_CARRIER" );
+	precachestring( &"MP_FRIENDLY_FLAG_DROPPED" );
+	precachestring( &"MP_ENEMY_FLAG_DROPPED" );
+	precachestring( &"MP_FRIENDLY_FLAG_RETURNED" );
+	precachestring( &"MP_ENEMY_FLAG_RETURNED" );
+	precachestring( &"MP_FRIENDLY_FLAG_TAKEN" );
+	precachestring( &"MP_ENEMY_FLAG_TAKEN" );
+	precachestring( &"MP_ENEMY_FLAG_CAPTURED" );
+	precachestring( &"MP_FRIENDLY_FLAG_CAPTURED" );
+	precachestring( &"MP_EXPLOSIVES_BLOWUP_BY" );
+	precachestring( &"MP_EXPLOSIVES_DEFUSED_BY" );
+	precachestring( &"MP_EXPLOSIVES_PLANTED_BY" );
+	precachestring( &"MP_HQ_DESTROYED_BY" );
+	precachestring( &"KILLSTREAK_DESTROYED_HELICOPTER" );
+/#
+	level thread popupsfromconsole();
+#/
+	level thread onplayerconnect();
+}
+
+popupsfromconsole()
+{
+/#
+	while ( 1 )
+	{
+		timeout = getdvarintdefault( "scr_popuptime", 1 );
+		if ( timeout == 0 )
+		{
+			timeout = 1;
+		}
+		wait timeout;
+		medal = getdvarintdefault( "scr_popupmedal", 0 );
+		challenge = getdvarintdefault( "scr_popupchallenge", 0 );
+		rank = getdvarintdefault( "scr_popuprank", 0 );
+		gun = getdvarintdefault( "scr_popupgun", 0 );
+		contractpass = getdvarintdefault( "scr_popupcontractpass", 0 );
+		contractfail = getdvarintdefault( "scr_popupcontractfail", 0 );
+		gamemodemsg = getdvarintdefault( "scr_gamemodeslideout", 0 );
+		teammsg = getdvarintdefault( "scr_teamslideout", 0 );
+		challengeindex = getdvarintdefault( "scr_challengeIndex", 1 );
+		i = 0;
+		while ( i < medal )
+		{
+			level.players[ 0 ] maps/mp/_medals::codecallback_medal( 4 );
+			i++;
+		}
+		i = 0;
+		while ( i < challenge )
+		{
+			level.players[ 0 ] maps/mp/gametypes/_persistence::codecallback_challengecomplete( 2500, 1, 84, 3, 0, 0, 851 );
+			level.players[ 0 ] maps/mp/gametypes/_persistence::codecallback_challengecomplete( 500, 1, 22, 2, 0, 0, 533 );
+			i++;
+		}
+		i = 0;
+		while ( i < rank )
+		{
+			level.players[ 0 ] maps/mp/gametypes/_rank::codecallback_rankup( 4, 0, 0 );
+			i++;
+		}
+		i = 0;
+		while ( i < gun )
+		{
+			level.players[ 0 ] maps/mp/gametypes/_persistence::codecallback_gunchallengecomplete( 0, 20, 25, 0 );
+			i++;
+		}
+		i = 0;
+		while ( i < contractpass )
+		{
+			level.players[ 0 ] maps/mp/gametypes/_persistence::addcontracttoqueue( 12, 1 );
+			i++;
+		}
+		i = 0;
+		while ( i < contractfail )
+		{
+			level.players[ 0 ] maps/mp/gametypes/_persistence::addcontracttoqueue( 12, 0 );
+			i++;
+		}
+		i = 0;
+		while ( i < teammsg )
+		{
+			player = level.players[ 0 ];
+			if ( isDefined( level.players[ 1 ] ) )
+			{
+				player = level.players[ 1 ];
+			}
+			level.players[ 0 ] displayteammessagetoall( &"KILLSTREAK_DESTROYED_HELICOPTER", player );
+			i++;
+		}
+		reset = getdvarintdefault( "scr_popupreset", 1 );
+		if ( reset )
+		{
+			if ( medal )
+			{
+				setdvar( "scr_popupmedal", 0 );
+			}
+			if ( challenge )
+			{
+				setdvar( "scr_popupchallenge", 0 );
+			}
+			if ( gun )
+			{
+				setdvar( "scr_popupgun", 0 );
+			}
+			if ( rank )
+			{
+				setdvar( "scr_popuprank", 0 );
+			}
+			if ( contractpass )
+			{
+				setdvar( "scr_popupcontractpass", 0 );
+			}
+			if ( contractfail )
+			{
+				setdvar( "scr_popupcontractfail", 0 );
+			}
+			if ( gamemodemsg )
+			{
+				setdvar( "scr_gamemodeslideout", 0 );
+			}
+			if ( teammsg )
+			{
+				setdvar( "scr_teamslideout", 0 );
+			}
+		}
+#/
+	}
+}
+
+displaykillstreakteammessagetoall( killstreak, player )
+{
+	if ( !isDefined( level.killstreaks[ killstreak ] ) )
+	{
+		return;
+	}
+	if ( !isDefined( level.killstreaks[ killstreak ].inboundtext ) )
+	{
+		return;
+	}
+	message = level.killstreaks[ killstreak ].inboundtext;
+	self displayteammessagetoall( message, player );
+}
+
+shoulddisplayteammessages()
+{
+	if ( level.hardcoremode == 1 || level.splitscreen == 1 )
+	{
+		return 0;
+	}
+	return 1;
+}
+
+displayteammessagetoall( message, player )
+{
+	if ( !shoulddisplayteammessages() )
+	{
+		return;
+	}
+	i = 0;
+	while ( i < level.players.size )
+	{
+		cur_player = level.players[ i ];
+		if ( cur_player isempjammed() )
+		{
+			i++;
+			continue;
+		}
+		else size = cur_player.teammessagequeue.size;
+		if ( size >= level.teammessagequeuemax )
+		{
+			i++;
+			continue;
+		}
+		else
+		{
+			cur_player.teammessagequeue[ size ] = spawnstruct();
+			cur_player.teammessagequeue[ size ].message = message;
+			cur_player.teammessagequeue[ size ].player = player;
+			cur_player notify( "received teammessage" );
+		}
+		i++;
+	}
+}
+
+displayteammessagetoteam( message, player, team )
+{
+	if ( !shoulddisplayteammessages() )
+	{
+		return;
+	}
+	i = 0;
+	while ( i < level.players.size )
+	{
+		cur_player = level.players[ i ];
+		if ( cur_player.team != team )
+		{
+			i++;
+			continue;
+		}
+		else if ( cur_player isempjammed() )
+		{
+			i++;
+			continue;
+		}
+		else size = cur_player.teammessagequeue.size;
+		if ( size >= level.teammessagequeuemax )
+		{
+			i++;
+			continue;
+		}
+		else
+		{
+			cur_player.teammessagequeue[ size ] = spawnstruct();
+			cur_player.teammessagequeue[ size ].message = message;
+			cur_player.teammessagequeue[ size ].player = player;
+			cur_player notify( "received teammessage" );
+		}
+		i++;
+	}
+}
+
+displayteammessagewaiter()
+{
+	if ( !shoulddisplayteammessages() )
+	{
+		return;
+	}
+	self endon( "disconnect" );
+	level endon( "game_ended" );
+	self.teammessagequeue = [];
+	for ( ;; )
+	{
+		if ( self.teammessagequeue.size == 0 )
+		{
+			self waittill( "received teammessage" );
+		}
+		if ( self.teammessagequeue.size > 0 )
+		{
+			nextnotifydata = self.teammessagequeue[ 0 ];
+			arrayremoveindex( self.teammessagequeue, 0, 0 );
+			if ( !isDefined( nextnotifydata.player ) || !isplayer( nextnotifydata.player ) )
+			{
+				continue;
+			}
+			else
+			{
+				if ( self isempjammed() )
+				{
+					break;
+				}
+				else
+				{
+					self luinotifyevent( &"player_callout", 2, nextnotifydata.message, nextnotifydata.player.entnum );
+				}
+				wait level.teammessage.waittime;
+			}
+		}
+	}
+}
+
+displaypopupswaiter()
+{
+	self endon( "disconnect" );
+	self.ranknotifyqueue = [];
+	if ( !isDefined( self.pers[ "challengeNotifyQueue" ] ) )
+	{
+		self.pers[ "challengeNotifyQueue" ] = [];
+	}
+	if ( !isDefined( self.pers[ "contractNotifyQueue" ] ) )
+	{
+		self.pers[ "contractNotifyQueue" ] = [];
+	}
+	self.messagenotifyqueue = [];
+	self.startmessagenotifyqueue = [];
+	self.wagernotifyqueue = [];
+	while ( !level.gameended )
+	{
+		if ( self.startmessagenotifyqueue.size == 0 && self.messagenotifyqueue.size == 0 )
+		{
+			self waittill( "received award" );
+		}
+		waittillframeend;
+		if ( level.gameended )
+		{
+			return;
+		}
+		else
+		{
+			if ( self.startmessagenotifyqueue.size > 0 )
+			{
+				nextnotifydata = self.startmessagenotifyqueue[ 0 ];
+				arrayremoveindex( self.startmessagenotifyqueue, 0, 0 );
+				if ( isDefined( nextnotifydata.duration ) )
+				{
+					duration = nextnotifydata.duration;
+				}
+				else
+				{
+					duration = level.startmessagedefaultduration;
+				}
+				self maps/mp/gametypes/_hud_message::shownotifymessage( nextnotifydata, duration );
+				wait duration;
+				continue;
+			}
+			else if ( self.messagenotifyqueue.size > 0 )
+			{
+				nextnotifydata = self.messagenotifyqueue[ 0 ];
+				arrayremoveindex( self.messagenotifyqueue, 0, 0 );
+				if ( isDefined( nextnotifydata.duration ) )
+				{
+					duration = nextnotifydata.duration;
+				}
+				else
+				{
+					duration = level.regulargamemessages.waittime;
+				}
+				self maps/mp/gametypes/_hud_message::shownotifymessage( nextnotifydata, duration );
+				continue;
+			}
+			else
+			{
+				wait 1;
+			}
+		}
+	}
+}
+
+onplayerconnect()
+{
+	for ( ;; )
+	{
+		level waittill( "connecting", player );
+		player.resetgameoverhudrequired = 0;
+		player thread displaypopupswaiter();
+		if ( !level.hardcoremode )
+		{
+			player thread displayteammessagewaiter();
+		}
+	}
+}
+
+milestonenotify( index, itemindex, type, tier )
+{
+	level.globalchallenges++;
+	if ( !isDefined( type ) )
+	{
+		type = "global";
+	}
+	size = self.pers[ "challengeNotifyQueue" ].size;
+	self.pers[ "challengeNotifyQueue" ][ size ] = [];
+	self.pers[ "challengeNotifyQueue" ][ size ][ "tier" ] = tier;
+	self.pers[ "challengeNotifyQueue" ][ size ][ "index" ] = index;
+	self.pers[ "challengeNotifyQueue" ][ size ][ "itemIndex" ] = itemindex;
+	self.pers[ "challengeNotifyQueue" ][ size ][ "type" ] = type;
+	self notify( "received award" );
+}

patch_mp/maps/mp/_proximity_grenade.gsc

@@ -0,0 +1,240 @@
+#include maps/mp/_scoreevents;
+#include maps/mp/_challenges;
+#include maps/mp/gametypes/_weaponobjects;
+#include common_scripts/utility;
+#include maps/mp/_utility;
+
+init()
+{
+	precacheshader( "gfx_fxt_fx_screen_droplets_02" );
+	precacherumble( "proximity_grenade" );
+	precacheitem( "proximity_grenade_aoe_mp" );
+	level._effect[ "prox_grenade_friendly_default" ] = loadfx( "weapon/grenade/fx_prox_grenade_scan_grn" );
+	level._effect[ "prox_grenade_friendly_warning" ] = loadfx( "weapon/grenade/fx_prox_grenade_wrn_grn" );
+	level._effect[ "prox_grenade_enemy_default" ] = loadfx( "weapon/grenade/fx_prox_grenade_scan_red" );
+	level._effect[ "prox_grenade_enemy_warning" ] = loadfx( "weapon/grenade/fx_prox_grenade_wrn_red" );
+	level._effect[ "prox_grenade_player_shock" ] = loadfx( "weapon/grenade/fx_prox_grenade_impact_player_spwner" );
+	level.proximitygrenadedetectionradius = weapons_get_dvar_int( "scr_proximityGrenadeDetectionRadius", "150" );
+	level.proximitygrenadegraceperiod = weapons_get_dvar( "scr_proximityGrenadeGracePeriod", 0,1 );
+	level.proximitygrenadedamageradius = weapons_get_dvar_int( "scr_proximityGrenadeDamageRadius", "200" );
+	level.proximitygrenadedotdamageamount = weapons_get_dvar_int( "scr_proximityGrenadeDOTDamageAmount", "1" );
+	level.proximitygrenadedotdamageamounthardcore = weapons_get_dvar_int( "scr_proximityGrenadeDOTDamageAmountHardcore", "1" );
+	level.proximitygrenadedotdamagetime = weapons_get_dvar( "scr_proximityGrenadeDOTDamageTime", 0,15 );
+	level.proximitygrenadedotdamageinstances = weapons_get_dvar_int( "scr_proximityGrenadeDOTDamageInstances", "4" );
+	level.proximitygrenademaxinstances = weapons_get_dvar_int( "scr_proximityGrenadeMaxInstances", "3" );
+	level.proximitygrenadeeffectdebug = weapons_get_dvar_int( "scr_proximityGrenadeEffectDebug", "0" );
+	level.proximitygrenadeactivationtime = weapons_get_dvar( "scr_proximityGrenadeActivationTime", 0,1 );
+	level.poisonfxduration = 6;
+/#
+	level thread updatedvars();
+#/
+}
+
+register()
+{
+	registerclientfield( "toplayer", "tazered", 1000, 1, "int" );
+}
+
+updatedvars()
+{
+	while ( 1 )
+	{
+		level.proximitygrenadedetectionradius = weapons_get_dvar_int( "scr_proximityGrenadeDetectionRadius", level.proximitygrenadedetectionradius );
+		level.proximitygrenadegraceperiod = weapons_get_dvar( "scr_proximityGrenadeGracePeriod", level.proximitygrenadegraceperiod );
+		level.proximitygrenadedamageradius = weapons_get_dvar_int( "scr_proximityGrenadeDamageRadius", level.proximitygrenadedamageradius );
+		level.proximitygrenadedotdamageamount = weapons_get_dvar_int( "scr_proximityGrenadeDOTDamageAmount", level.proximitygrenadedotdamageamount );
+		level.proximitygrenadedotdamageamounthardcore = weapons_get_dvar_int( "scr_proximityGrenadeDOTDamageAmountHardcore", level.proximitygrenadedotdamageamounthardcore );
+		level.proximitygrenadedotdamagetime = weapons_get_dvar( "scr_proximityGrenadeDOTDamageTime", level.proximitygrenadedotdamagetime );
+		level.proximitygrenadedotdamageinstances = weapons_get_dvar_int( "scr_proximityGrenadeDOTDamageInstances", level.proximitygrenadedotdamageinstances );
+		level.proximitygrenademaxinstances = weapons_get_dvar_int( "scr_proximityGrenadeMaxInstances", level.proximitygrenademaxinstances );
+		level.proximitygrenadeeffectdebug = weapons_get_dvar_int( "scr_proximityGrenadeEffectDebug", level.proximitygrenadeeffectdebug );
+		level.proximitygrenadeactivationtime = weapons_get_dvar( "scr_proximityGrenadeActivationTime", level.proximitygrenadeactivationtime );
+		wait 1;
+	}
+}
+
+createproximitygrenadewatcher()
+{
+	watcher = self maps/mp/gametypes/_weaponobjects::createproximityweaponobjectwatcher( "proximity_grenade", "proximity_grenade_mp", self.team );
+	watcher.watchforfire = 1;
+	watcher.hackable = 1;
+	watcher.hackertoolradius = level.equipmenthackertoolradius;
+	watcher.hackertooltimems = level.equipmenthackertooltimems;
+	watcher.headicon = 0;
+	watcher.reconmodel = "t6_wpn_taser_mine_world_detect";
+	watcher.activatefx = 1;
+	watcher.ownergetsassist = 1;
+	watcher.ignoredirection = 1;
+	watcher.immediatedetonation = 1;
+	watcher.detectiongraceperiod = level.proximitygrenadegraceperiod;
+	watcher.detonateradius = level.proximitygrenadedetectionradius;
+	watcher.stun = ::maps/mp/gametypes/_weaponobjects::weaponstun;
+	watcher.stuntime = 1;
+	watcher.detonate = ::proximitydetonate;
+	watcher.activationdelay = level.proximitygrenadeactivationtime;
+	watcher.onspawn = ::onspawnproximitygrenadeweaponobject;
+}
+
+onspawnproximitygrenadeweaponobject( watcher, owner )
+{
+	self thread setupkillcament();
+	owner addweaponstat( "proximity_grenade_mp", "used", 1 );
+	onspawnproximityweaponobject( watcher, owner );
+}
+
+setupkillcament()
+{
+	self endon( "death" );
+	self waittillnotmoving();
+	self.killcament = spawn( "script_model", self.origin + vectorScale( ( 0, 0, 1 ), 8 ) );
+	self thread cleanupkillcamentondeath();
+}
+
+cleanupkillcamentondeath()
+{
+	self waittill( "death" );
+	self.killcament deleteaftertime( 3 + ( level.proximitygrenadedotdamagetime * level.proximitygrenadedotdamageinstances ) );
+}
+
+proximitydetonate( attacker, weaponname )
+{
+	if ( isDefined( weaponname ) )
+	{
+		if ( isDefined( attacker ) )
+		{
+			if ( self.owner isenemyplayer( attacker ) )
+			{
+				attacker maps/mp/_challenges::destroyedexplosive( weaponname );
+				maps/mp/_scoreevents::processscoreevent( "destroyed_proxy", attacker, self.owner, weaponname );
+			}
+		}
+	}
+	maps/mp/gametypes/_weaponobjects::weapondetonate( attacker, weaponname );
+}
+
+proximitygrenadedamageplayer( eattacker, einflictor )
+{
+	if ( !self hasperk( "specialty_proximityprotection" ) )
+	{
+		if ( !level.proximitygrenadeeffectdebug )
+		{
+			self thread damageplayerinradius( einflictor.origin, eattacker, einflictor );
+		}
+	}
+}
+
+watchproximitygrenadehitplayer( owner )
+{
+	self endon( "death" );
+	self setowner( owner );
+	self setteam( owner.team );
+	while ( 1 )
+	{
+		self waittill( "grenade_bounce", pos, normal, ent, surface );
+		if ( isDefined( ent ) && isplayer( ent ) && surface != "riotshield" )
+		{
+			if ( level.teambased && ent.team == self.owner.team )
+			{
+				continue;
+			}
+			self proximitydetonate( self.owner, undefined );
+			return;
+		}
+	}
+}
+
+performhudeffects( position, distancetogrenade )
+{
+	forwardvec = vectornormalize( anglesToForward( self.angles ) );
+	rightvec = vectornormalize( anglesToRight( self.angles ) );
+	explosionvec = vectornormalize( position - self.origin );
+	fdot = vectordot( explosionvec, forwardvec );
+	rdot = vectordot( explosionvec, rightvec );
+	fangle = acos( fdot );
+	rangle = acos( rdot );
+}
+
+damageplayerinradius( position, owner, einflictor )
+{
+	self notify( "proximityGrenadeDamageStart" );
+	self endon( "proximityGrenadeDamageStart" );
+	self endon( "disconnect" );
+	self endon( "death" );
+	owner endon( "disconnect" );
+	self thread watch_death();
+	if ( !isDefined( einflictor.killcament ) )
+	{
+		killcament = spawn( "script_model", self.origin + vectorScale( ( 0, 0, 1 ), 8 ) );
+		killcament deleteaftertime( 3 + ( level.proximitygrenadedotdamagetime * level.proximitygrenadedotdamageinstances ) );
+		killcament.soundmod = "taser_spike";
+	}
+	else
+	{
+		killcament = einflictor.killcament;
+		killcament.soundmod = "taser_spike";
+	}
+	damage = level.proximitygrenadedotdamageamount;
+	playfxontag( level._effect[ "prox_grenade_player_shock" ], self, "J_SpineUpper" );
+	if ( level.hardcoremode )
+	{
+		damage = level.proximitygrenadedotdamageamounthardcore;
+	}
+	if ( self mayapplyscreeneffect() )
+	{
+		shellshock_duration = 1,5;
+		self shellshock( "proximity_grenade", shellshock_duration, 0 );
+		self setclientfieldtoplayer( "tazered", 1 );
+	}
+	self playrumbleonentity( "proximity_grenade" );
+	self playsound( "wpn_taser_mine_zap" );
+	self setclientuivisibilityflag( "hud_visible", 0 );
+	i = 0;
+	while ( i < level.proximitygrenadedotdamageinstances )
+	{
+		wait level.proximitygrenadedotdamagetime;
+/#
+		assert( isDefined( owner ) );
+#/
+/#
+		assert( isDefined( killcament ) );
+#/
+		self dodamage( damage, position, owner, killcament, "none", "MOD_GAS", 0, "proximity_grenade_aoe_mp" );
+		i++;
+	}
+	wait 0,85;
+	self shellshock( "proximity_grenade_exit", 0,6, 0 );
+	self setclientuivisibilityflag( "hud_visible", 1 );
+	self setclientfieldtoplayer( "tazered", 0 );
+}
+
+deleteentonownerdeath( owner )
+{
+	self thread deleteentontimeout();
+	self thread deleteentaftertime();
+	self endon( "delete" );
+	owner waittill( "death" );
+	self notify( "deleteSound" );
+}
+
+deleteentaftertime()
+{
+	self endon( "delete" );
+	wait 10;
+	self notify( "deleteSound" );
+}
+
+deleteentontimeout()
+{
+	self endon( "delete" );
+	self waittill( "deleteSound" );
+	self delete();
+}
+
+watch_death()
+{
+	self waittill( "death" );
+	self stoprumble( "proximity_grenade" );
+	self setblur( 0, 0 );
+	self setclientuivisibilityflag( "hud_visible", 1 );
+	self setclientfieldtoplayer( "tazered", 0 );
+}

patch_mp/maps/mp/_riotshield.gsc

@@ -0,0 +1,491 @@
+#include maps/mp/_scoreevents;
+#include maps/mp/killstreaks/_killstreak_weapons;
+#include maps/mp/killstreaks/_killstreaks;
+#include common_scripts/utility;
+#include maps/mp/_utility;
+
+#using_animtree( "mp_riotshield" );
+
+init()
+{
+	if ( !isDefined( level.riotshield_name ) )
+	{
+		level.riotshield_name = "riotshield_mp";
+		if ( isDefined( level.is_zombie_level ) && level.is_zombie_level )
+		{
+			level.riotshield_name = "riotshield_zm";
+		}
+	}
+	level.deployedshieldmodel = "t6_wpn_shield_carry_world";
+	level.stowedshieldmodel = "t6_wpn_shield_stow_world";
+	level.carriedshieldmodel = "t6_wpn_shield_carry_world";
+	level.detectshieldmodel = "t6_wpn_shield_carry_world_detect";
+	if ( isDefined( level.is_zombie_level ) && level.is_zombie_level )
+	{
+		level.deployedshieldmodel = "t6_wpn_zmb_shield_world";
+		level.stowedshieldmodel = "t6_wpn_zmb_shield_stow";
+		level.carriedshieldmodel = "t6_wpn_zmb_shield_world";
+	}
+	precachemodel( level.stowedshieldmodel );
+	precachemodel( level.carriedshieldmodel );
+	precachemodel( level.detectshieldmodel );
+	level.riotshielddestroyanim = %o_riot_stand_destroyed;
+	level.riotshielddeployanim = %o_riot_stand_deploy;
+	level.riotshieldshotanimfront = %o_riot_stand_shot;
+	level.riotshieldshotanimback = %o_riot_stand_shot_back;
+	level.riotshieldmeleeanimfront = %o_riot_stand_melee_front;
+	level.riotshieldmeleeanimback = %o_riot_stand_melee_back;
+	loadfx( "weapon/riotshield/fx_riotshield_depoly_lights" );
+	loadfx( "weapon/riotshield/fx_riotshield_depoly_dust" );
+	level.riotshield_placement_zoffset = 26;
+}
+
+register()
+{
+	registerclientfield( "scriptmover", "riotshield_state", 1, 2, "int" );
+}
+
+watchpregameclasschange()
+{
+	self endon( "death" );
+	self endon( "disconnect" );
+	self endon( "track_riot_shield" );
+	self waittill( "changed_class" );
+	if ( level.ingraceperiod && !self.hasdonecombat )
+	{
+		self clearstowedweapon();
+		self refreshshieldattachment();
+		self thread trackriotshield();
+	}
+}
+
+watchriotshieldpickup()
+{
+	self endon( "death" );
+	self endon( "disconnect" );
+	self endon( "track_riot_shield" );
+	self notify( "watch_riotshield_pickup" );
+	self endon( "watch_riotshield_pickup" );
+	self waittill( "pickup_riotshield" );
+	self endon( "weapon_change" );
+/#
+	println( "Picked up riotshield, expecting weapon_change notify..." );
+#/
+	wait 0,5;
+/#
+	println( "picked up shield but didn't change weapons, attach it!" );
+#/
+	self.hasriotshield = self hasweapon( level.riotshield_name );
+	self.hasriotshieldequipped = self getcurrentweapon() == level.riotshield_name;
+	self refreshshieldattachment();
+}
+
+trackriotshield()
+{
+	self endon( "death" );
+	self endon( "disconnect" );
+	self notify( "track_riot_shield" );
+	self endon( "track_riot_shield" );
+	self thread watchpregameclasschange();
+	self waittill( "weapon_change", newweapon );
+	self refreshshieldattachment();
+	self.hasriotshield = self hasweapon( level.riotshield_name );
+	self.hasriotshieldequipped = self getcurrentweapon() == level.riotshield_name;
+	self.lastnonshieldweapon = "none";
+	while ( 1 )
+	{
+		self thread watchriotshieldpickup();
+		currentweapon = self getcurrentweapon();
+		self.hasriotshield = self hasweapon( level.riotshield_name );
+		self.hasriotshieldequipped = self getcurrentweapon() == level.riotshield_name;
+		refresh_attach = 0;
+		self waittill( "weapon_change", newweapon );
+		if ( newweapon == level.riotshield_name )
+		{
+			refresh_attach = 1;
+			if ( isDefined( self.riotshieldentity ) )
+			{
+				self notify( "destroy_riotshield" );
+			}
+			if ( self.hasriotshield )
+			{
+				if ( isDefined( self.riotshieldtakeweapon ) )
+				{
+					self takeweapon( self.riotshieldtakeweapon );
+					self.riotshieldtakeweapon = undefined;
+				}
+			}
+			if ( isvalidnonshieldweapon( currentweapon ) )
+			{
+				self.lastnonshieldweapon = currentweapon;
+			}
+		}
+		if ( self.hasriotshield || refresh_attach == 1 )
+		{
+			self refreshshieldattachment();
+		}
+	}
+}
+
+isvalidnonshieldweapon( weapon )
+{
+	if ( maps/mp/killstreaks/_killstreaks::iskillstreakweapon( weapon ) )
+	{
+		return 0;
+	}
+	if ( maps/mp/killstreaks/_killstreak_weapons::isheldkillstreakweapon( weapon ) )
+	{
+		return 0;
+	}
+	if ( maps/mp/killstreaks/_killstreak_weapons::isgameplayweapon( weapon ) )
+	{
+		return 0;
+	}
+	if ( weapon == "none" )
+	{
+		return 0;
+	}
+	if ( isweaponequipment( weapon ) )
+	{
+		return 0;
+	}
+	return 1;
+}
+
+startriotshielddeploy()
+{
+	self notify( "start_riotshield_deploy" );
+	self thread watchriotshielddeploy();
+}
+
+resetreconmodelvisibility( owner )
+{
+	if ( !isDefined( self ) )
+	{
+		return;
+	}
+	self setinvisibletoall();
+	self setforcenocull();
+	if ( !isDefined( owner ) )
+	{
+		return;
+	}
+	i = 0;
+	while ( i < level.players.size )
+	{
+		if ( level.players[ i ] hasperk( "specialty_showenemyequipment" ) )
+		{
+			if ( level.players[ i ].team == "spectator" )
+			{
+				i++;
+				continue;
+			}
+			else
+			{
+				isenemy = 1;
+				if ( level.teambased )
+				{
+					if ( level.players[ i ].team == owner.team )
+					{
+						isenemy = 0;
+					}
+				}
+				else
+				{
+					if ( level.players[ i ] == owner )
+					{
+						isenemy = 0;
+					}
+				}
+				if ( isenemy )
+				{
+					self setvisibletoplayer( level.players[ i ] );
+				}
+			}
+		}
+		i++;
+	}
+}
+
+resetreconmodelonevent( eventname, owner )
+{
+	self endon( "death" );
+	for ( ;; )
+	{
+		level waittill( eventname, newowner );
+		if ( isDefined( newowner ) )
+		{
+			owner = newowner;
+		}
+		self resetreconmodelvisibility( owner );
+	}
+}
+
+attachreconmodel( modelname, owner )
+{
+	if ( !isDefined( self ) )
+	{
+		return;
+	}
+	reconmodel = spawn( "script_model", self.origin );
+	reconmodel.angles = self.angles;
+	reconmodel setmodel( modelname );
+	reconmodel.model_name = modelname;
+	reconmodel linkto( self );
+	reconmodel setcontents( 0 );
+	reconmodel resetreconmodelvisibility( owner );
+	reconmodel thread resetreconmodelonevent( "joined_team", owner );
+	reconmodel thread resetreconmodelonevent( "player_spawned", owner );
+	self.reconmodel = reconmodel;
+}
+
+spawnriotshieldcover( origin, angles )
+{
+	shield_ent = spawn( "script_model", origin, 1 );
+	shield_ent.targetname = "riotshield_mp";
+	shield_ent.angles = angles;
+	shield_ent setmodel( level.deployedshieldmodel );
+	shield_ent setowner( self );
+	shield_ent.owner = self;
+	shield_ent.team = self.team;
+	shield_ent setteam( self.team );
+	shield_ent attachreconmodel( level.detectshieldmodel, self );
+	shield_ent useanimtree( -1 );
+	shield_ent setscriptmoverflag( 0 );
+	shield_ent disconnectpaths();
+	return shield_ent;
+}
+
+watchriotshielddeploy()
+{
+	self endon( "death" );
+	self endon( "disconnect" );
+	self endon( "start_riotshield_deploy" );
+	self waittill( "deploy_riotshield", deploy_attempt );
+	self setheldweaponmodel( 0 );
+	self setplacementhint( 1 );
+	placement_hint = 0;
+	if ( deploy_attempt )
+	{
+		placement = self canplaceriotshield( "deploy_riotshield" );
+		if ( placement[ "result" ] )
+		{
+			self.hasdonecombat = 1;
+			zoffset = level.riotshield_placement_zoffset;
+			shield_ent = self spawnriotshieldcover( placement[ "origin" ] + ( 0, 0, zoffset ), placement[ "angles" ] );
+			item_ent = deployriotshield( self, shield_ent );
+			primaries = self getweaponslistprimaries();
+/#
+			assert( isDefined( item_ent ) );
+			assert( !isDefined( self.riotshieldretrievetrigger ) );
+			assert( !isDefined( self.riotshieldentity ) );
+			if ( level.gametype != "shrp" )
+			{
+				assert( primaries.size > 0 );
+#/
+			}
+			shield_ent setclientfield( "riotshield_state", 1 );
+			shield_ent.reconmodel setclientfield( "riotshield_state", 1 );
+			if ( level.gametype != "shrp" )
+			{
+				if ( self.lastnonshieldweapon != "none" && self hasweapon( self.lastnonshieldweapon ) )
+				{
+					self switchtoweapon( self.lastnonshieldweapon );
+				}
+				else
+				{
+					self switchtoweapon( primaries[ 0 ] );
+				}
+			}
+			if ( !self hasweapon( "knife_held_mp" ) )
+			{
+				self giveweapon( "knife_held_mp" );
+				self.riotshieldtakeweapon = "knife_held_mp";
+			}
+			self.riotshieldretrievetrigger = item_ent;
+			self.riotshieldentity = shield_ent;
+			self thread watchdeployedriotshieldents();
+			self thread deleteshieldontriggerdeath( self.riotshieldretrievetrigger );
+			self thread deleteshieldonplayerdeathordisconnect( shield_ent );
+			self.riotshieldentity thread watchdeployedriotshielddamage();
+			level notify( "riotshield_planted" );
+		}
+		else
+		{
+			placement_hint = 1;
+			clip_max_ammo = weaponclipsize( level.riotshield_name );
+			self setweaponammoclip( level.riotshield_name, clip_max_ammo );
+		}
+	}
+	else
+	{
+		placement_hint = 1;
+	}
+	if ( placement_hint )
+	{
+		self setriotshieldfailhint();
+	}
+}
+
+riotshielddistancetest( origin )
+{
+/#
+	assert( isDefined( origin ) );
+#/
+	min_dist_squared = getDvarFloat( "riotshield_deploy_limit_radius" );
+	min_dist_squared *= min_dist_squared;
+	i = 0;
+	while ( i < level.players.size )
+	{
+		if ( isDefined( level.players[ i ].riotshieldentity ) )
+		{
+			dist_squared = distancesquared( level.players[ i ].riotshieldentity.origin, origin );
+			if ( min_dist_squared > dist_squared )
+			{
+/#
+				println( "Shield placement denied!  Failed distance check to other riotshields." );
+#/
+				return 0;
+			}
+		}
+		i++;
+	}
+	return 1;
+}
+
+watchdeployedriotshieldents()
+{
+/#
+	assert( isDefined( self.riotshieldretrievetrigger ) );
+	assert( isDefined( self.riotshieldentity ) );
+#/
+	self waittill( "destroy_riotshield" );
+	if ( isDefined( self.riotshieldretrievetrigger ) )
+	{
+		self.riotshieldretrievetrigger delete();
+	}
+	if ( isDefined( self.riotshieldentity ) )
+	{
+		if ( isDefined( self.riotshieldentity.reconmodel ) )
+		{
+			self.riotshieldentity.reconmodel delete();
+		}
+		self.riotshieldentity connectpaths();
+		self.riotshieldentity delete();
+	}
+}
+
+watchdeployedriotshielddamage()
+{
+	self endon( "death" );
+	damagemax = getDvarInt( "riotshield_deployed_health" );
+	self.damagetaken = 0;
+	while ( 1 )
+	{
+		self.maxhealth = 100000;
+		self.health = self.maxhealth;
+		self waittill( "damage", damage, attacker, direction, point, type, tagname, modelname, partname, weaponname, idflags );
+		while ( !isDefined( attacker ) )
+		{
+			continue;
+		}
+/#
+		if ( isDefined( self.owner ) )
+		{
+			assert( isDefined( self.owner.team ) );
+		}
+#/
+		while ( isplayer( attacker ) )
+		{
+			while ( level.teambased && attacker.team == self.owner.team && attacker != self.owner )
+			{
+				continue;
+			}
+		}
+		if ( type == "MOD_MELEE" )
+		{
+			damage *= getDvarFloat( "riotshield_melee_damage_scale" );
+		}
+		else if ( type == "MOD_PISTOL_BULLET" || type == "MOD_RIFLE_BULLET" )
+		{
+			damage *= getDvarFloat( "riotshield_bullet_damage_scale" );
+		}
+		else
+		{
+			if ( type != "MOD_GRENADE" && type != "MOD_GRENADE_SPLASH" && type != "MOD_EXPLOSIVE" && type != "MOD_EXPLOSIVE_SPLASH" || type == "MOD_PROJECTILE" && type == "MOD_PROJECTILE_SPLASH" )
+			{
+				damage *= getDvarFloat( "riotshield_explosive_damage_scale" );
+				break;
+			}
+			else
+			{
+				if ( type == "MOD_IMPACT" )
+				{
+					damage *= getDvarFloat( "riotshield_projectile_damage_scale" );
+					break;
+				}
+				else
+				{
+					if ( type == "MOD_CRUSH" )
+					{
+						damage = damagemax;
+					}
+				}
+			}
+		}
+		self.damagetaken += damage;
+		if ( self.damagetaken >= damagemax )
+		{
+			self thread damagethendestroyriotshield( attacker, weaponname );
+			return;
+		}
+		else
+		{
+		}
+	}
+}
+
+damagethendestroyriotshield( attacker, weaponname )
+{
+	self notify( "damageThenDestroyRiotshield" );
+	self endon( "death" );
+	if ( isDefined( self.owner.riotshieldretrievetrigger ) )
+	{
+		self.owner.riotshieldretrievetrigger delete();
+	}
+	if ( isDefined( self.reconmodel ) )
+	{
+		self.reconmodel delete();
+	}
+	self connectpaths();
+	self.owner.riotshieldentity = undefined;
+	self notsolid();
+	self setclientfield( "riotshield_state", 2 );
+	if ( isDefined( attacker ) && isDefined( weaponname ) && attacker != self.owner && isplayer( attacker ) )
+	{
+		maps/mp/_scoreevents::processscoreevent( "destroyed_shield", attacker, self.owner, weaponname );
+	}
+	wait getDvarFloat( "riotshield_destroyed_cleanup_time" );
+	self delete();
+}
+
+deleteshieldontriggerdeath( shield_trigger )
+{
+	shield_trigger waittill_any( "trigger", "death" );
+	self notify( "destroy_riotshield" );
+}
+
+deleteshieldonplayerdeathordisconnect( shield_ent )
+{
+	shield_ent endon( "death" );
+	shield_ent endon( "damageThenDestroyRiotshield" );
+	self waittill_any( "death", "disconnect", "remove_planted_weapons" );
+	shield_ent thread damagethendestroyriotshield();
+}
+
+watchriotshieldstuckentitydeath( grenade, owner )
+{
+	grenade endon( "death" );
+	self waittill_any( "damageThenDestroyRiotshield", "death", "disconnect", "weapon_change", "deploy_riotshield" );
+	grenade detonate( owner );
+}

patch_mp/maps/mp/_satchel_charge.gsc

@@ -0,0 +1,45 @@
+#include maps/mp/_scoreevents;
+#include maps/mp/_challenges;
+#include maps/mp/killstreaks/_emp;
+#include maps/mp/gametypes/_weaponobjects;
+#include maps/mp/_utility;
+
+init()
+{
+	level._effect[ "satchel_charge_enemy_light" ] = loadfx( "weapon/c4/fx_c4_light_red" );
+	level._effect[ "satchel_charge_friendly_light" ] = loadfx( "weapon/c4/fx_c4_light_green" );
+}
+
+createsatchelwatcher()
+{
+	watcher = self maps/mp/gametypes/_weaponobjects::createuseweaponobjectwatcher( "satchel_charge", "satchel_charge_mp", self.team );
+	watcher.altdetonate = 1;
+	watcher.watchforfire = 1;
+	watcher.hackable = 1;
+	watcher.hackertoolradius = level.equipmenthackertoolradius;
+	watcher.hackertooltimems = level.equipmenthackertooltimems;
+	watcher.headicon = 1;
+	watcher.detonate = ::satcheldetonate;
+	watcher.stun = ::maps/mp/gametypes/_weaponobjects::weaponstun;
+	watcher.stuntime = 1;
+	watcher.altweapon = "satchel_charge_detonator_mp";
+	watcher.reconmodel = "t6_wpn_c4_world_detect";
+	watcher.ownergetsassist = 1;
+}
+
+satcheldetonate( attacker, weaponname )
+{
+	from_emp = maps/mp/killstreaks/_emp::isempkillstreakweapon( weaponname );
+	if ( !isDefined( from_emp ) || !from_emp )
+	{
+		if ( isDefined( attacker ) )
+		{
+			if ( self.owner isenemyplayer( attacker ) )
+			{
+				attacker maps/mp/_challenges::destroyedexplosive( weaponname );
+				maps/mp/_scoreevents::processscoreevent( "destroyed_c4", attacker, self.owner, weaponname );
+			}
+		}
+	}
+	maps/mp/gametypes/_weaponobjects::weapondetonate( attacker, weaponname );
+}

patch_mp/maps/mp/_scoreevents.gsc

@@ -0,0 +1,838 @@
+#include maps/mp/gametypes/_globallogic_score;
+#include maps/mp/gametypes/_rank;
+#include maps/mp/killstreaks/_killstreaks;
+#include maps/mp/_scoreevents;
+#include common_scripts/utility;
+#include maps/mp/_utility;
+
+init()
+{
+	level.scoreeventcallbacks = [];
+	level.scoreeventgameendcallback = ::ongameend;
+	registerscoreeventcallback( "playerKilled", ::scoreeventplayerkill );
+}
+
+scoreeventtablelookupint( index, scoreeventcolumn )
+{
+	return int( tablelookup( "mp/scoreInfo.csv", 0, index, scoreeventcolumn ) );
+}
+
+scoreeventtablelookup( index, scoreeventcolumn )
+{
+	return tablelookup( "mp/scoreInfo.csv", 0, index, scoreeventcolumn );
+}
+
+getscoreeventcolumn( gametype )
+{
+	columnoffset = getcolumnoffsetforgametype( gametype );
+/#
+	assert( columnoffset >= 0 );
+#/
+	if ( columnoffset >= 0 )
+	{
+		columnoffset += 0;
+	}
+	return columnoffset;
+}
+
+getxpeventcolumn( gametype )
+{
+	columnoffset = getcolumnoffsetforgametype( gametype );
+/#
+	assert( columnoffset >= 0 );
+#/
+	if ( columnoffset >= 0 )
+	{
+		columnoffset += 1;
+	}
+	return columnoffset;
+}
+
+getcolumnoffsetforgametype( gametype )
+{
+	foundgamemode = 0;
+	if ( !isDefined( level.scoreeventtableid ) )
+	{
+		level.scoreeventtableid = getscoreeventtableid();
+	}
+/#
+	assert( isDefined( level.scoreeventtableid ) );
+#/
+	if ( !isDefined( level.scoreeventtableid ) )
+	{
+		return -1;
+	}
+	gamemodecolumn = 11;
+	for ( ;; )
+	{
+		column_header = tablelookupcolumnforrow( level.scoreeventtableid, 0, gamemodecolumn );
+		if ( column_header == "" )
+		{
+			gamemodecolumn = 11;
+			break;
+		}
+		else if ( column_header == ( level.gametype + " score" ) )
+		{
+			foundgamemode = 1;
+			break;
+		}
+		else
+		{
+			gamemodecolumn += 2;
+		}
+	}
+/#
+	assert( foundgamemode, "Could not find gamemode in scoreInfo.csv:" + gametype );
+#/
+	return gamemodecolumn;
+}
+
+getscoreeventtableid()
+{
+	scoreinfotableloaded = 0;
+	scoreinfotableid = tablelookupfindcoreasset( "mp/scoreInfo.csv" );
+	if ( isDefined( scoreinfotableid ) )
+	{
+		scoreinfotableloaded = 1;
+	}
+/#
+	assert( scoreinfotableloaded, "Score Event Table is not loaded: " + "mp/scoreInfo.csv" );
+#/
+	return scoreinfotableid;
+}
+
+isregisteredevent( type )
+{
+	if ( isDefined( level.scoreinfo[ type ] ) )
+	{
+		return 1;
+	}
+	else
+	{
+		return 0;
+	}
+}
+
+shouldaddrankxp( player )
+{
+	if ( !isDefined( level.rankcap ) || level.rankcap == 0 )
+	{
+		return 1;
+	}
+	if ( player.pers[ "plevel" ] > 0 || player.pers[ "rank" ] > level.rankcap )
+	{
+		return 0;
+	}
+	return 1;
+}
+
+processscoreevent( event, player, victim, weapon )
+{
+	pixbeginevent( "processScoreEvent" );
+	scoregiven = 0;
+	if ( !isplayer( player ) )
+	{
+/#
+		assertmsg( "processScoreEvent called on non player entity: " + event );
+#/
+		return scoregiven;
+	}
+	player thread maps/mp/_challenges::eventreceived( event );
+	if ( isregisteredevent( event ) )
+	{
+		allowplayerscore = 0;
+		if ( !isDefined( weapon ) || maps/mp/killstreaks/_killstreaks::iskillstreakweapon( weapon ) == 0 )
+		{
+			allowplayerscore = 1;
+		}
+		else
+		{
+			allowplayerscore = maps/mp/gametypes/_rank::killstreakweaponsallowedscore( event );
+		}
+		if ( allowplayerscore )
+		{
+			scoregiven = maps/mp/gametypes/_globallogic_score::giveplayerscore( event, player, victim, weapon, undefined );
+			isscoreevent = scoregiven > 0;
+		}
+	}
+	if ( shouldaddrankxp( player ) )
+	{
+		player addrankxp( event, weapon, isscoreevent );
+	}
+	pixendevent();
+	return scoregiven;
+}
+
+registerscoreeventcallback( callback, func )
+{
+	if ( !isDefined( level.scoreeventcallbacks[ callback ] ) )
+	{
+		level.scoreeventcallbacks[ callback ] = [];
+	}
+	level.scoreeventcallbacks[ callback ][ level.scoreeventcallbacks[ callback ].size ] = func;
+}
+
+scoreeventplayerkill( data, time )
+{
+	victim = data.victim;
+	attacker = data.attacker;
+	time = data.time;
+	level.numkills++;
+	victim = data.victim;
+	attacker.lastkilledplayer = victim;
+	wasdefusing = data.wasdefusing;
+	wasplanting = data.wasplanting;
+	wasonground = data.victimonground;
+	meansofdeath = data.smeansofdeath;
+	if ( isDefined( data.sweapon ) )
+	{
+		weapon = data.sweapon;
+		weaponclass = getweaponclass( data.sweapon );
+		killstreak = getkillstreakfromweapon( data.sweapon );
+	}
+	victim.anglesondeath = victim getplayerangles();
+	if ( meansofdeath != "MOD_GRENADE" && meansofdeath != "MOD_GRENADE_SPLASH" && meansofdeath != "MOD_EXPLOSIVE" && meansofdeath != "MOD_EXPLOSIVE_SPLASH" || meansofdeath == "MOD_PROJECTILE" && meansofdeath == "MOD_PROJECTILE_SPLASH" )
+	{
+		if ( weapon == "none" && isDefined( data.victim.explosiveinfo[ "weapon" ] ) )
+		{
+			weapon = data.victim.explosiveinfo[ "weapon" ];
+		}
+	}
+	while ( level.teambased )
+	{
+		attacker.lastkilltime = time;
+		if ( isDefined( victim.lastkilltime ) && victim.lastkilltime > ( time - 3000 ) )
+		{
+			if ( isDefined( victim.lastkilledplayer ) && victim.lastkilledplayer isenemyplayer( attacker ) == 0 && attacker != victim.lastkilledplayer )
+			{
+				processscoreevent( "kill_enemy_who_killed_teammate", attacker, victim, weapon );
+				victim recordkillmodifier( "avenger" );
+			}
+		}
+		while ( isDefined( victim.damagedplayers ) )
+		{
+			keys = getarraykeys( victim.damagedplayers );
+			i = 0;
+			while ( i < keys.size )
+			{
+				key = keys[ i ];
+				if ( key == attacker.clientid )
+				{
+					i++;
+					continue;
+				}
+				else if ( !isDefined( victim.damagedplayers[ key ].entity ) )
+				{
+					i++;
+					continue;
+				}
+				else if ( attacker isenemyplayer( victim.damagedplayers[ key ].entity ) )
+				{
+					i++;
+					continue;
+				}
+				else
+				{
+					if ( ( time - victim.damagedplayers[ key ].time ) < 1000 )
+					{
+						processscoreevent( "kill_enemy_injuring_teammate", attacker, victim, weapon );
+						if ( isDefined( victim.damagedplayers[ key ].entity ) )
+						{
+							victim.damagedplayers[ key ].entity.lastrescuedby = attacker;
+							victim.damagedplayers[ key ].entity.lastrescuedtime = time;
+						}
+						victim recordkillmodifier( "defender" );
+					}
+				}
+				i++;
+			}
+		}
+	}
+	switch( weapon )
+	{
+		case "hatchet_mp":
+			attacker.pers[ "tomahawks" ]++;
+			attacker.tomahawks = attacker.pers[ "tomahawks" ];
+			processscoreevent( "hatchet_kill", attacker, victim, weapon );
+			if ( isDefined( data.victim.explosiveinfo[ "projectile_bounced" ] ) && data.victim.explosiveinfo[ "projectile_bounced" ] == 1 )
+			{
+				level.globalbankshots++;
+				processscoreevent( "bounce_hatchet_kill", attacker, victim, weapon );
+			}
+			break;
+		case "knife_ballistic_mp":
+			if ( meansofdeath == "MOD_PISTOL_BULLET" || meansofdeath == "MOD_HEAD_SHOT" )
+			{
+				processscoreevent( "ballistic_knife_kill", attacker, victim, data.sweapon );
+			}
+			attacker addweaponstat( weapon, "ballistic_knife_kill", 1 );
+			break;
+		case "inventory_supplydrop_mp":
+		case "supplydrop_mp":
+			if ( meansofdeath == "MOD_HIT_BY_OBJECT" || meansofdeath == "MOD_CRUSH" )
+			{
+				processscoreevent( "kill_enemy_with_care_package_crush", attacker, victim, weapon );
+			}
+			else
+			{
+				processscoreevent( "kill_enemy_with_hacked_care_package", attacker, victim, weapon );
+			}
+			break;
+	}
+	if ( isDefined( data.victimweapon ) )
+	{
+		if ( data.victimweapon == "minigun_mp" )
+		{
+			processscoreevent( "killed_death_machine_enemy", attacker, victim, weapon );
+		}
+		else
+		{
+			if ( data.victimweapon == "m32_mp" )
+			{
+				processscoreevent( "killed_multiple_grenade_launcher_enemy", attacker, victim, weapon );
+			}
+		}
+	}
+	attacker thread updatemultikills( weapon, weaponclass, killstreak );
+	if ( level.numkills == 1 )
+	{
+		victim recordkillmodifier( "firstblood" );
+		processscoreevent( "first_kill", attacker, victim, weapon );
+	}
+	else
+	{
+		if ( isDefined( attacker.lastkilledby ) )
+		{
+			if ( attacker.lastkilledby == victim )
+			{
+				level.globalpaybacks++;
+				processscoreevent( "revenge_kill", attacker, victim, weapon );
+				attacker addweaponstat( weapon, "revenge_kill", 1 );
+				victim recordkillmodifier( "revenge" );
+				attacker.lastkilledby = undefined;
+			}
+		}
+		if ( victim maps/mp/killstreaks/_killstreaks::isonakillstreak() )
+		{
+			level.globalbuzzkills++;
+			processscoreevent( "stop_enemy_killstreak", attacker, victim, weapon );
+			victim recordkillmodifier( "buzzkill" );
+		}
+		if ( isDefined( victim.lastmansd ) && victim.lastmansd == 1 )
+		{
+			processscoreevent( "final_kill_elimination", attacker, victim, weapon );
+			if ( isDefined( attacker.lastmansd ) && attacker.lastmansd == 1 )
+			{
+				processscoreevent( "elimination_and_last_player_alive", attacker, victim, weapon );
+			}
+		}
+	}
+	if ( is_weapon_valid( meansofdeath, weapon, weaponclass ) )
+	{
+		if ( isDefined( victim.vattackerorigin ) )
+		{
+			attackerorigin = victim.vattackerorigin;
+		}
+		else
+		{
+			attackerorigin = attacker.origin;
+		}
+		disttovictim = distancesquared( victim.origin, attackerorigin );
+		weap_min_dmg_range = get_distance_for_weapon( weapon, weaponclass );
+		if ( disttovictim > weap_min_dmg_range )
+		{
+			attacker maps/mp/_challenges::longdistancekill();
+			if ( weapon == "hatchet_mp" )
+			{
+				attacker maps/mp/_challenges::longdistancehatchetkill();
+			}
+			processscoreevent( "longshot_kill", attacker, victim, weapon );
+			attacker addweaponstat( weapon, "longshot_kill", 1 );
+			attacker.pers[ "longshots" ]++;
+			attacker.longshots = attacker.pers[ "longshots" ];
+			victim recordkillmodifier( "longshot" );
+		}
+	}
+	if ( isalive( attacker ) )
+	{
+		if ( attacker.health < ( attacker.maxhealth * 0,35 ) )
+		{
+			attacker.lastkillwheninjured = time;
+			processscoreevent( "kill_enemy_when_injured", attacker, victim, weapon );
+			attacker addweaponstat( weapon, "kill_enemy_when_injured", 1 );
+			if ( attacker hasperk( "specialty_bulletflinch" ) )
+			{
+				attacker addplayerstat( "perk_bulletflinch_kills", 1 );
+			}
+		}
+	}
+	else
+	{
+		if ( isDefined( attacker.deathtime ) && ( attacker.deathtime + 800 ) < time && !attacker isinvehicle() )
+		{
+			level.globalafterlifes++;
+			processscoreevent( "kill_enemy_after_death", attacker, victim, weapon );
+			victim recordkillmodifier( "posthumous" );
+		}
+	}
+	if ( attacker.cur_death_streak >= 3 )
+	{
+		level.globalcomebacks++;
+		processscoreevent( "comeback_from_deathstreak", attacker, victim, weapon );
+		victim recordkillmodifier( "comeback" );
+	}
+	if ( isDefined( victim.beingmicrowavedby ) && weapon != "microwave_turret_mp" )
+	{
+		if ( victim.beingmicrowavedby != attacker && attacker isenemyplayer( victim.beingmicrowavedby ) == 0 )
+		{
+			scoregiven = processscoreevent( "microwave_turret_assist", victim.beingmicrowavedby, victim, weapon );
+			if ( isDefined( scoregiven ) && isDefined( victim.beingmicrowavedby ) )
+			{
+				victim.beingmicrowavedby maps/mp/_challenges::earnedmicrowaveassistscore( scoregiven );
+			}
+		}
+		else
+		{
+			attacker maps/mp/_challenges::killwhiledamagingwithhpm();
+		}
+	}
+	if ( meansofdeath == "MOD_MELEE" && weapon != "riotshield_mp" )
+	{
+		attacker.pers[ "stabs" ]++;
+		attacker.stabs = attacker.pers[ "stabs" ];
+		vangles = victim.anglesondeath[ 1 ];
+		pangles = attacker.anglesonkill[ 1 ];
+		anglediff = angleClamp180( vangles - pangles );
+		if ( anglediff > -30 && anglediff < 70 )
+		{
+			level.globalbackstabs++;
+			processscoreevent( "backstabber_kill", attacker, victim, weapon );
+			attacker addweaponstat( weapon, "backstabber_kill", 1 );
+			attacker.pers[ "backstabs" ]++;
+			attacker.backstabs = attacker.pers[ "backstabs" ];
+		}
+	}
+	else
+	{
+		if ( isDefined( victim.firsttimedamaged ) && victim.firsttimedamaged == time )
+		{
+			if ( weaponclass == "weapon_sniper" )
+			{
+				attacker thread updateoneshotmultikills( victim, weapon, victim.firsttimedamaged );
+				attacker addweaponstat( weapon, "kill_enemy_one_bullet", 1 );
+			}
+		}
+		if ( isDefined( attacker.tookweaponfrom[ weapon ] ) && isDefined( attacker.tookweaponfrom[ weapon ].previousowner ) )
+		{
+			pickedupweapon = attacker.tookweaponfrom[ weapon ];
+			if ( pickedupweapon.previousowner == victim )
+			{
+				processscoreevent( "kill_enemy_with_their_weapon", attacker, victim, weapon );
+				attacker addweaponstat( weapon, "kill_enemy_with_their_weapon", 1 );
+				if ( isDefined( pickedupweapon.sweapon ) && isDefined( pickedupweapon.smeansofdeath ) )
+				{
+					if ( pickedupweapon.sweapon == "knife_held_mp" && pickedupweapon.smeansofdeath == "MOD_MELEE" )
+					{
+						attacker addweaponstat( "knife_held_mp", "kill_enemy_with_their_weapon", 1 );
+					}
+				}
+			}
+		}
+	}
+	if ( wasdefusing )
+	{
+		processscoreevent( "killed_bomb_defuser", attacker, victim, weapon );
+	}
+	else
+	{
+		if ( wasplanting )
+		{
+			processscoreevent( "killed_bomb_planter", attacker, victim, weapon );
+		}
+	}
+	specificweaponkill( attacker, victim, weapon, killstreak );
+	if ( !isDefined( killstreak ) && isDefined( attacker.dtptime ) && ( attacker.dtptime + 5000 ) > time )
+	{
+		attacker.dtptime = 0;
+		if ( attacker getstance() == "prone" )
+		{
+			processscoreevent( "kill_enemy_recent_dive_prone", attacker, self, weapon );
+		}
+	}
+	if ( isDefined( killstreak ) )
+	{
+		victim recordkillmodifier( "killstreak" );
+	}
+	attacker.cur_death_streak = 0;
+	attacker disabledeathstreak();
+}
+
+specificweaponkill( attacker, victim, weapon, killstreak )
+{
+	switchweapon = weapon;
+	if ( isDefined( killstreak ) )
+	{
+		switchweapon = killstreak;
+	}
+	switch( switchweapon )
+	{
+		case "crossbow_mp":
+		case "explosive_bolt_mp":
+			if ( isDefined( victim.explosiveinfo[ "stuckToPlayer" ] ) && victim.explosiveinfo[ "stuckToPlayer" ] == victim )
+			{
+				event = "crossbow_kill";
+			}
+			else
+			{
+				return;
+			}
+			break;
+		case "rcbomb_mp":
+			event = "rcxd_kill";
+			break;
+		case "remote_missile_mp":
+			event = "remote_missile_kill";
+			break;
+		case "missile_drone_mp":
+			event = "missile_drone_kill";
+			break;
+		case "autoturret_mp":
+			event = "sentry_gun_kill";
+			break;
+		case "planemortar_mp":
+			event = "plane_mortar_kill";
+			break;
+		case "inventory_minigun_mp":
+		case "minigun_mp":
+			event = "death_machine_kill";
+			break;
+		case "inventory_m32_mp":
+		case "m32_mp":
+			event = "multiple_grenade_launcher_kill";
+			break;
+		case "qrdrone_mp":
+			event = "qrdrone_kill";
+			break;
+		case "ai_tank_drop_mp":
+			event = "aitank_kill";
+			break;
+		case "helicopter_guard_mp":
+			event = "helicopter_guard_kill";
+			break;
+		case "straferun_mp":
+			event = "strafe_run_kill";
+			break;
+		case "remote_mortar_mp":
+			event = "remote_mortar_kill";
+			break;
+		case "helicopter_player_gunner_mp":
+			event = "helicopter_gunner_kill";
+			break;
+		case "dogs_mp":
+			event = "dogs_kill";
+			break;
+		case "missile_swarm_mp":
+			event = "missile_swarm_kill";
+			break;
+		case "helicopter_comlink_mp":
+			event = "helicopter_comlink_kill";
+			break;
+		case "microwaveturret_mp":
+			event = "microwave_turret_kill";
+			break;
+		default:
+			return;
+	}
+	processscoreevent( event, attacker, victim, weapon );
+}
+
+multikill( killcount, weapon )
+{
+/#
+	assert( killcount > 1 );
+#/
+	self maps/mp/_challenges::multikill( killcount, weapon );
+	if ( killcount > 8 )
+	{
+		processscoreevent( "multikill_more_than_8", self, undefined, weapon );
+	}
+	else
+	{
+		processscoreevent( "multikill_" + killcount, self, undefined, weapon );
+	}
+	self recordmultikill( killcount );
+}
+
+uninterruptedobitfeedkills( attacker, sweapon )
+{
+	self endon( "disconnect" );
+	wait 0,1;
+	waittillslowprocessallowed();
+	wait 0,1;
+	maps/mp/_scoreevents::processscoreevent( "uninterrupted_obit_feed_kills", attacker, self, sweapon );
+}
+
+is_weapon_valid( meansofdeath, weapon, weaponclass )
+{
+	valid_weapon = 0;
+	if ( get_distance_for_weapon( weapon, weaponclass ) == 0 )
+	{
+		valid_weapon = 0;
+	}
+	else if ( meansofdeath == "MOD_PISTOL_BULLET" || meansofdeath == "MOD_RIFLE_BULLET" )
+	{
+		valid_weapon = 1;
+	}
+	else
+	{
+		if ( meansofdeath == "MOD_HEAD_SHOT" )
+		{
+			valid_weapon = 1;
+		}
+		else
+		{
+			if ( weapon == "hatchet_mp" && meansofdeath == "MOD_IMPACT" )
+			{
+				valid_weapon = 1;
+			}
+		}
+	}
+	return valid_weapon;
+}
+
+updatemultikills( weapon, weaponclass, killstreak )
+{
+	self endon( "disconnect" );
+	level endon( "game_ended" );
+	self notify( "updateRecentKills" );
+	self endon( "updateRecentKills" );
+	baseweaponname = getreffromitemindex( getbaseweaponitemindex( weapon ) ) + "_mp";
+	if ( !isDefined( self.recentkillcount ) )
+	{
+		self.recentkillcount = 0;
+	}
+	if ( !isDefined( self.recentkillcountweapon ) || self.recentkillcountweapon != baseweaponname )
+	{
+		self.recentkillcountsameweapon = 0;
+		self.recentkillcountweapon = baseweaponname;
+	}
+	if ( !isDefined( killstreak ) )
+	{
+		self.recentkillcountsameweapon++;
+		self.recentkillcount++;
+	}
+	if ( !isDefined( self.recent_lmg_smg_killcount ) )
+	{
+		self.recent_lmg_smg_killcount = 0;
+	}
+	if ( !isDefined( self.recentremotemissilekillcount ) )
+	{
+		self.recentremotemissilekillcount = 0;
+	}
+	if ( !isDefined( self.recentremotemissileattackerkillcount ) )
+	{
+		self.recentremotemissileattackerkillcount = 0;
+	}
+	if ( !isDefined( self.recentrcbombkillcount ) )
+	{
+		self.recentrcbombkillcount = 0;
+	}
+	if ( !isDefined( self.recentrcbombattackerkillcount ) )
+	{
+		self.recentrcbombattackerkillcount = 0;
+	}
+	if ( !isDefined( self.recentmglkillcount ) )
+	{
+		self.recentmglkillcount = 0;
+	}
+	if ( isDefined( weaponclass ) )
+	{
+		if ( weaponclass == "weapon_lmg" || weaponclass == "weapon_smg" )
+		{
+			if ( self playerads() < 1 )
+			{
+				self.recent_lmg_smg_killcount++;
+			}
+		}
+	}
+	if ( isDefined( killstreak ) )
+	{
+		switch( killstreak )
+		{
+			case "remote_missile_mp":
+				self.recentremotemissilekillcount++;
+				break;
+			case "rcbomb_mp":
+				self.recentrcbombkillcount++;
+				break;
+			case "inventory_m32_mp":
+			case "m32_mp":
+				self.recentmglkillcount++;
+				break;
+		}
+	}
+	if ( self.recentkillcountsameweapon == 2 )
+	{
+		self addweaponstat( weapon, "multikill_2", 1 );
+	}
+	else if ( self.recentkillcountsameweapon == 3 )
+	{
+		self addweaponstat( weapon, "multikill_3", 1 );
+	}
+	self waittilltimeoutordeath( 4 );
+	if ( self.recent_lmg_smg_killcount >= 3 )
+	{
+		self maps/mp/_challenges::multi_lmg_smg_kill();
+	}
+	if ( self.recentrcbombkillcount >= 2 )
+	{
+		self maps/mp/_challenges::multi_rcbomb_kill();
+	}
+	if ( self.recentmglkillcount >= 3 )
+	{
+		self maps/mp/_challenges::multi_mgl_kill();
+	}
+	if ( self.recentremotemissilekillcount >= 3 )
+	{
+		self maps/mp/_challenges::multi_remotemissile_kill();
+	}
+	if ( self.recentkillcount > 1 )
+	{
+		self multikill( self.recentkillcount, weapon );
+	}
+	self.recentkillcount = 0;
+	self.recentkillcountsameweapon = 0;
+	self.recentkillcountweapon = undefined;
+	self.recent_lmg_smg_killcount = 0;
+	self.recentremotemissilekillcount = 0;
+	self.recentremotemissileattackerkillcount = 0;
+	self.recentrcbombkillcount = 0;
+	self.recentmglkillcount = 0;
+}
+
+waittilltimeoutordeath( timeout )
+{
+	self endon( "death" );
+	wait timeout;
+}
+
+updateoneshotmultikills( victim, weapon, firsttimedamaged )
+{
+	self endon( "death" );
+	self endon( "disconnect" );
+	self notify( "updateoneshotmultikills" + firsttimedamaged );
+	self endon( "updateoneshotmultikills" + firsttimedamaged );
+	if ( !isDefined( self.oneshotmultikills ) )
+	{
+		self.oneshotmultikills = 0;
+	}
+	self.oneshotmultikills++;
+	wait 1;
+	if ( self.oneshotmultikills > 1 )
+	{
+		processscoreevent( "kill_enemies_one_bullet", self, victim, weapon );
+	}
+	else
+	{
+		processscoreevent( "kill_enemy_one_bullet", self, victim, weapon );
+	}
+	self.oneshotmultikills = 0;
+}
+
+get_distance_for_weapon( weapon, weaponclass )
+{
+	distance = 0;
+	switch( weaponclass )
+	{
+		case "weapon_smg":
+			distance = 1562500;
+			break;
+		case "weapon_assault":
+			distance = 2250000;
+			break;
+		case "weapon_lmg":
+			distance = 2250000;
+			break;
+		case "weapon_sniper":
+			distance = 3062500;
+			break;
+		case "weapon_pistol":
+			distance = 490000;
+			break;
+		case "weapon_cqb":
+			distance = 422500;
+			break;
+		case "weapon_special":
+			if ( weapon == "knife_ballistic_mp" )
+			{
+				distance = 2250000;
+			}
+			else if ( weapon == "crossbow_mp" )
+			{
+				distance = 2250000;
+			}
+			else
+			{
+				if ( weapon == "metalstorm_mp" )
+				{
+					distance = 3062500;
+				}
+			}
+			break;
+		case "weapon_grenade":
+			if ( weapon == "hatchet_mp" )
+			{
+				distance = 6250000;
+			}
+			break;
+		default:
+			distance = 0;
+			break;
+	}
+	return distance;
+}
+
+decrementlastobituaryplayercountafterfade()
+{
+	level endon( "reset_obituary_count" );
+	wait 5;
+	level.lastobituaryplayercount--;
+
+/#
+	assert( level.lastobituaryplayercount >= 0 );
+#/
+}
+
+ongameend( data )
+{
+	player = data.player;
+	winner = data.winner;
+	while ( isDefined( winner ) )
+	{
+		if ( level.teambased )
+		{
+			if ( winner != "tie" && player.team == winner )
+			{
+				processscoreevent( "won_match", player );
+				return;
+			}
+			break;
+		}
+		else
+		{
+			placement = level.placement[ "all" ];
+			topthreeplayers = min( 3, placement.size );
+			index = 0;
+			while ( index < topthreeplayers )
+			{
+				if ( level.placement[ "all" ][ index ] == player )
+				{
+					processscoreevent( "won_match", player );
+					return;
+				}
+				index++;
+			}
+		}
+	}
+	processscoreevent( "completed_match", player );
+}

patch_mp/maps/mp/_scrambler.gsc

@@ -0,0 +1,228 @@
+#include maps/mp/gametypes/_damagefeedback;
+#include maps/mp/gametypes/_globallogic_player;
+#include maps/mp/_challenges;
+#include maps/mp/killstreaks/_emp;
+#include maps/mp/gametypes/_weaponobjects;
+#include common_scripts/utility;
+#include maps/mp/_utility;
+
+init()
+{
+	level._effect[ "scrambler_enemy_light" ] = loadfx( "misc/fx_equip_light_red" );
+	level._effect[ "scrambler_friendly_light" ] = loadfx( "misc/fx_equip_light_green" );
+	level.scramblerweapon = "scrambler_mp";
+	level.scramblerlength = 30;
+	level.scramblerouterradiussq = 1000000;
+	level.scramblerinnerradiussq = 360000;
+}
+
+createscramblerwatcher()
+{
+	watcher = self maps/mp/gametypes/_weaponobjects::createuseweaponobjectwatcher( "scrambler", "scrambler_mp", self.team );
+	watcher.onspawn = ::onspawnscrambler;
+	watcher.detonate = ::scramblerdetonate;
+	watcher.stun = ::maps/mp/gametypes/_weaponobjects::weaponstun;
+	watcher.stuntime = 5;
+	watcher.reconmodel = "t5_weapon_scrambler_world_detect";
+	watcher.hackable = 1;
+	watcher.ondamage = ::watchscramblerdamage;
+}
+
+onspawnscrambler( watcher, player )
+{
+	player endon( "disconnect" );
+	self endon( "death" );
+	self thread maps/mp/gametypes/_weaponobjects::onspawnuseweaponobject( watcher, player );
+	player.scrambler = self;
+	self setowner( player );
+	self setteam( player.team );
+	self.owner = player;
+	self setclientflag( 3 );
+	if ( !self maps/mp/_utility::ishacked() )
+	{
+		player addweaponstat( "scrambler_mp", "used", 1 );
+	}
+	self thread watchshutdown( player );
+	level notify( "scrambler_spawn" );
+}
+
+scramblerdetonate( attacker, weaponname )
+{
+	from_emp = maps/mp/killstreaks/_emp::isempweapon( weaponname );
+	if ( !from_emp )
+	{
+		playfx( level._equipment_explode_fx, self.origin );
+	}
+	if ( self.owner isenemyplayer( attacker ) )
+	{
+		attacker maps/mp/_challenges::destroyedequipment( weaponname );
+	}
+	playsoundatposition( "dst_equipment_destroy", self.origin );
+	self delete();
+}
+
+watchshutdown( player )
+{
+	self waittill_any( "death", "hacked" );
+	level notify( "scrambler_death" );
+	if ( isDefined( player ) )
+	{
+		player.scrambler = undefined;
+	}
+}
+
+destroyent()
+{
+	self delete();
+}
+
+watchscramblerdamage( watcher )
+{
+	self endon( "death" );
+	self endon( "hacked" );
+	self setcandamage( 1 );
+	damagemax = 100;
+	if ( !self maps/mp/_utility::ishacked() )
+	{
+		self.damagetaken = 0;
+	}
+	for ( ;; )
+	{
+		while ( 1 )
+		{
+			self.maxhealth = 100000;
+			self.health = self.maxhealth;
+			self waittill( "damage", damage, attacker, direction, point, type, tagname, modelname, partname, weaponname, idflags );
+			if ( !isDefined( attacker ) || !isplayer( attacker ) )
+			{
+				continue;
+			}
+			while ( level.teambased && attacker.team == self.owner.team && attacker != self.owner )
+			{
+				continue;
+			}
+			if ( isDefined( weaponname ) )
+			{
+				switch( weaponname )
+				{
+					case "concussion_grenade_mp":
+					case "flash_grenade_mp":
+						if ( watcher.stuntime > 0 )
+						{
+							self thread maps/mp/gametypes/_weaponobjects::stunstart( watcher, watcher.stuntime );
+						}
+						if ( level.teambased && self.owner.team != attacker.team )
+						{
+							if ( maps/mp/gametypes/_globallogic_player::dodamagefeedback( weaponname, attacker ) )
+							{
+								attacker maps/mp/gametypes/_damagefeedback::updatedamagefeedback();
+							}
+							continue;
+						}
+						else
+						{
+							if ( !level.teambased && self.owner != attacker )
+							{
+								if ( maps/mp/gametypes/_globallogic_player::dodamagefeedback( weaponname, attacker ) )
+								{
+									attacker maps/mp/gametypes/_damagefeedback::updatedamagefeedback();
+								}
+							}
+						}
+					}
+					case "emp_grenade_mp":
+						damage = damagemax;
+						default:
+							if ( maps/mp/gametypes/_globallogic_player::dodamagefeedback( weaponname, attacker ) )
+							{
+								attacker maps/mp/gametypes/_damagefeedback::updatedamagefeedback();
+							}
+							break;
+					}
+				}
+				else
+				{
+					weaponname = "";
+				}
+				while ( isplayer( attacker ) && level.teambased && isDefined( attacker.team ) && self.owner.team == attacker.team && attacker != self.owner )
+				{
+					continue;
+				}
+				if ( type == "MOD_MELEE" )
+				{
+					self.damagetaken = damagemax;
+				}
+				else
+				{
+					self.damagetaken += damage;
+				}
+				if ( self.damagetaken >= damagemax )
+				{
+					watcher thread maps/mp/gametypes/_weaponobjects::waitanddetonate( self, 0, attacker, weaponname );
+				}
+			}
+		}
+	}
+}
+
+ownersameteam( owner1, owner2 )
+{
+	if ( !level.teambased )
+	{
+		return 0;
+	}
+	if ( !isDefined( owner1 ) || !isDefined( owner2 ) )
+	{
+		return 0;
+	}
+	if ( !isDefined( owner1.team ) || !isDefined( owner2.team ) )
+	{
+		return 0;
+	}
+	return owner1.team == owner2.team;
+}
+
+checkscramblerstun()
+{
+	scramblers = getentarray( "grenade", "classname" );
+	if ( isDefined( self.name ) && self.name == "scrambler_mp" )
+	{
+		return 0;
+	}
+	i = 0;
+	while ( i < scramblers.size )
+	{
+		scrambler = scramblers[ i ];
+		if ( !isalive( scrambler ) )
+		{
+			i++;
+			continue;
+		}
+		else if ( !isDefined( scrambler.name ) )
+		{
+			i++;
+			continue;
+		}
+		else if ( scrambler.name != "scrambler_mp" )
+		{
+			i++;
+			continue;
+		}
+		else if ( ownersameteam( self.owner, scrambler.owner ) )
+		{
+			i++;
+			continue;
+		}
+		else
+		{
+			flattenedselforigin = ( self.origin[ 0 ], self.origin[ 1 ], 0 );
+			flattenedscramblerorigin = ( scrambler.origin[ 0 ], scrambler.origin[ 1 ], 0 );
+			if ( distancesquared( flattenedselforigin, flattenedscramblerorigin ) < level.scramblerouterradiussq )
+			{
+				return 1;
+			}
+		}
+		i++;
+	}
+	return 0;
+}

patch_mp/maps/mp/_script_gen.gsc

@@ -0,0 +1,342 @@
+#include maps/mp/_script_gen;
+#include maps/mp/_utility;
+#include common_scripts/utility;
+
+script_gen_dump_checksaved()
+{
+	signatures = getarraykeys( level.script_gen_dump );
+	i = 0;
+	while ( i < signatures.size )
+	{
+		if ( !isDefined( level.script_gen_dump2[ signatures[ i ] ] ) )
+		{
+			level.script_gen_dump_reasons[ level.script_gen_dump_reasons.size ] = "Signature unmatched( removed feature ): " + signatures[ i ];
+		}
+		i++;
+	}
+}
+
+script_gen_dump()
+{
+/#
+	script_gen_dump_checksaved();
+	if ( !level.script_gen_dump_reasons.size )
+	{
+		flag_set( "scriptgen_done" );
+		return;
+	}
+	firstrun = 0;
+	if ( level.bscriptgened )
+	{
+		println( " " );
+		println( " " );
+		println( " " );
+		println( "^2 -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- " );
+		println( "^3Dumping scriptgen dump for these reasons" );
+		println( "^2 -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- " );
+		i = 0;
+		while ( i < level.script_gen_dump_reasons.size )
+		{
+			if ( issubstr( level.script_gen_dump_reasons[ i ], "nowrite" ) )
+			{
+				substr = getsubstr( level.script_gen_dump_reasons[ i ], 15 );
+				println( ( i + ". ) " ) + substr );
+			}
+			else
+			{
+				println( ( i + ". ) " ) + level.script_gen_dump_reasons[ i ] );
+			}
+			if ( level.script_gen_dump_reasons[ i ] == "First run" )
+			{
+				firstrun = 1;
+			}
+			i++;
+		}
+		println( "^2 -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- " );
+		println( " " );
+		if ( firstrun )
+		{
+			println( "for First Run make sure you delete all of the vehicle precache script calls, createart calls, createfx calls( most commonly placed in maps\\" + level.script + "_fx.gsc ) " );
+			println( " " );
+			println( "replace:" );
+			println( "maps\\_load::main( 1 );" );
+			println( " " );
+			println( "with( don't forget to add this file to P4 ):" );
+			println( "maps\\scriptgen\\" + level.script + "_scriptgen::main();" );
+			println( " " );
+		}
+		println( "^2 -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- " );
+		println( " " );
+		println( "^2 / \\ / \\ / \\" );
+		println( "^2scroll up" );
+		println( "^2 / \\ / \\ / \\" );
+		println( " " );
+	}
+	else
+	{
+		return;
+	}
+	filename = "scriptgen/" + level.script + "_scriptgen.gsc";
+	csvfilename = "zone_source/" + level.script + ".csv";
+	if ( level.bscriptgened )
+	{
+		file = openfile( filename, "write" );
+	}
+	else
+	{
+		file = 0;
+	}
+	assert( file != -1, "File not writeable( check it and and restart the map ): " + filename );
+	script_gen_dumpprintln( file, "// script generated script do not write your own script here it will go away if you do." );
+	script_gen_dumpprintln( file, "main()" );
+	script_gen_dumpprintln( file, "{" );
+	script_gen_dumpprintln( file, "" );
+	script_gen_dumpprintln( file, "\tlevel.script_gen_dump = [];" );
+	script_gen_dumpprintln( file, "" );
+	signatures = getarraykeys( level.script_gen_dump );
+	i = 0;
+	while ( i < signatures.size )
+	{
+		if ( !issubstr( level.script_gen_dump[ signatures[ i ] ], "nowrite" ) )
+		{
+			script_gen_dumpprintln( file, "\t" + level.script_gen_dump[ signatures[ i ] ] );
+		}
+		i++;
+	}
+	i = 0;
+	while ( i < signatures.size )
+	{
+		if ( !issubstr( level.script_gen_dump[ signatures[ i ] ], "nowrite" ) )
+		{
+			script_gen_dumpprintln( file, "\tlevel.script_gen_dump[ " + """ + signatures[ i ] + """ + " ] = " + """ + signatures[ i ] + """ + ";" );
+			i++;
+			continue;
+		}
+		else
+		{
+			script_gen_dumpprintln( file, "\tlevel.script_gen_dump[ " + """ + signatures[ i ] + """ + " ] = " + ""nowrite"" + ";" );
+		}
+		i++;
+	}
+	script_gen_dumpprintln( file, "" );
+	keys1 = undefined;
+	keys2 = undefined;
+	if ( isDefined( level.sg_precacheanims ) )
+	{
+		keys1 = getarraykeys( level.sg_precacheanims );
+	}
+	while ( isDefined( keys1 ) )
+	{
+		i = 0;
+		while ( i < keys1.size )
+		{
+			script_gen_dumpprintln( file, "\tanim_precach_" + keys1[ i ] + "();" );
+			i++;
+		}
+	}
+	script_gen_dumpprintln( file, "\tmaps\\_load::main( 1, " + level.bcsvgened + ", 1 );" );
+	script_gen_dumpprintln( file, "}" );
+	script_gen_dumpprintln( file, "" );
+	if ( isDefined( level.sg_precacheanims ) )
+	{
+		keys1 = getarraykeys( level.sg_precacheanims );
+	}
+	while ( isDefined( keys1 ) )
+	{
+		i = 0;
+		while ( i < keys1.size )
+		{
+			script_gen_dumpprintln( file, "#using_animtree( "" + keys1[ i ] + "" );" );
+			script_gen_dumpprintln( file, "anim_precach_" + keys1[ i ] + "()" );
+			script_gen_dumpprintln( file, "{" );
+			script_gen_dumpprintln( file, "\tlevel.sg_animtree[ "" + keys1[ i ] + "" ] = #animtree;" );
+			keys2 = getarraykeys( level.sg_precacheanims[ keys1[ i ] ] );
+			while ( isDefined( keys2 ) )
+			{
+				j = 0;
+				while ( j < keys2.size )
+				{
+					script_gen_dumpprintln( file, "\tlevel.sg_anim[ "" + keys2[ j ] + "" ] = %" + keys2[ j ] + ";" );
+					j++;
+				}
+			}
+			script_gen_dumpprintln( file, "}" );
+			script_gen_dumpprintln( file, "" );
+			i++;
+		}
+	}
+	if ( level.bscriptgened )
+	{
+		saved = closefile( file );
+	}
+	else
+	{
+		saved = 1;
+	}
+	if ( level.bcsvgened )
+	{
+		csvfile = openfile( csvfilename, "write" );
+	}
+	else
+	{
+		csvfile = 0;
+	}
+	assert( csvfile != -1, "File not writeable( check it and and restart the map ): " + csvfilename );
+	signatures = getarraykeys( level.script_gen_dump );
+	i = 0;
+	while ( i < signatures.size )
+	{
+		script_gen_csvdumpprintln( csvfile, signatures[ i ] );
+		i++;
+	}
+	if ( level.bcsvgened )
+	{
+		csvfilesaved = closefile( csvfile );
+	}
+	else
+	{
+		csvfilesaved = 1;
+	}
+	assert( csvfilesaved == 1, "csv not saved( see above message? ): " + csvfilename );
+	assert( saved == 1, "map not saved( see above message? ): " + filename );
+#/
+/#
+	assert( !level.bscriptgened, "SCRIPTGEN generated: follow instructions listed above this error in the console" );
+#/
+	if ( level.bscriptgened )
+	{
+/#
+		assertmsg( "SCRIPTGEN updated: Rebuild fast file and run map again" );
+#/
+	}
+	flag_set( "scriptgen_done" );
+}
+
+script_gen_csvdumpprintln( file, signature )
+{
+	prefix = undefined;
+	writtenprefix = undefined;
+	path = "";
+	extension = "";
+	if ( issubstr( signature, "ignore" ) )
+	{
+		prefix = "ignore";
+	}
+	else if ( issubstr( signature, "col_map_sp" ) )
+	{
+		prefix = "col_map_sp";
+	}
+	else if ( issubstr( signature, "gfx_map" ) )
+	{
+		prefix = "gfx_map";
+	}
+	else if ( issubstr( signature, "rawfile" ) )
+	{
+		prefix = "rawfile";
+	}
+	else if ( issubstr( signature, "sound" ) )
+	{
+		prefix = "sound";
+	}
+	else if ( issubstr( signature, "xmodel" ) )
+	{
+		prefix = "xmodel";
+	}
+	else if ( issubstr( signature, "xanim" ) )
+	{
+		prefix = "xanim";
+	}
+	else if ( issubstr( signature, "item" ) )
+	{
+		prefix = "item";
+		writtenprefix = "weapon";
+		path = "sp/";
+	}
+	else if ( issubstr( signature, "fx" ) )
+	{
+		prefix = "fx";
+	}
+	else if ( issubstr( signature, "menu" ) )
+	{
+		prefix = "menu";
+		writtenprefix = "menufile";
+		path = "ui / scriptmenus/";
+		extension = ".menu";
+	}
+	else if ( issubstr( signature, "rumble" ) )
+	{
+		prefix = "rumble";
+		writtenprefix = "rawfile";
+		path = "rumble/";
+	}
+	else if ( issubstr( signature, "shader" ) )
+	{
+		prefix = "shader";
+		writtenprefix = "material";
+	}
+	else if ( issubstr( signature, "shock" ) )
+	{
+		prefix = "shock";
+		writtenprefix = "rawfile";
+		extension = ".shock";
+		path = "shock/";
+	}
+	else if ( issubstr( signature, "string" ) )
+	{
+		prefix = "string";
+/#
+		assertmsg( "string not yet supported by scriptgen" );
+#/
+	}
+	else if ( issubstr( signature, "turret" ) )
+	{
+		prefix = "turret";
+		writtenprefix = "weapon";
+		path = "sp/";
+	}
+	else
+	{
+		if ( issubstr( signature, "vehicle" ) )
+		{
+			prefix = "vehicle";
+			writtenprefix = "rawfile";
+			path = "vehicles/";
+		}
+	}
+	if ( !isDefined( prefix ) )
+	{
+		return;
+	}
+	if ( !isDefined( writtenprefix ) )
+	{
+		string = ( prefix + ", " ) + getsubstr( signature, prefix.size + 1, signature.size );
+	}
+	else
+	{
+		string = ( writtenprefix + ", " ) + path + getsubstr( signature, prefix.size + 1, signature.size ) + extension;
+	}
+/#
+	if ( file == -1 || !level.bcsvgened )
+	{
+		println( string );
+	}
+	else
+	{
+		fprintln( file, string );
+#/
+	}
+}
+
+script_gen_dumpprintln( file, string )
+{
+/#
+	if ( file == -1 || !level.bscriptgened )
+	{
+		println( string );
+	}
+	else
+	{
+		fprintln( file, string );
+#/
+	}
+}

patch_mp/maps/mp/_sensor_grenade.gsc

@@ -0,0 +1,225 @@
+#include maps/mp/gametypes/_damagefeedback;
+#include maps/mp/gametypes/_globallogic_player;
+#include maps/mp/_utility;
+#include maps/mp/_scoreevents;
+#include maps/mp/_challenges;
+#include maps/mp/killstreaks/_emp;
+#include maps/mp/_hacker_tool;
+#include maps/mp/gametypes/_weaponobjects;
+#include common_scripts/utility;
+
+init()
+{
+	level.isplayertrackedfunc = ::isplayertracked;
+}
+
+createsensorgrenadewatcher()
+{
+	watcher = self maps/mp/gametypes/_weaponobjects::createuseweaponobjectwatcher( "sensor_grenade", "sensor_grenade_mp", self.team );
+	watcher.headicon = 0;
+	watcher.onspawn = ::onspawnsensorgrenade;
+	watcher.detonate = ::sensorgrenadedestroyed;
+	watcher.stun = ::maps/mp/gametypes/_weaponobjects::weaponstun;
+	watcher.stuntime = 0;
+	watcher.reconmodel = "t6_wpn_motion_sensor_world_detect";
+	watcher.ondamage = ::watchsensorgrenadedamage;
+	watcher.enemydestroy = 1;
+}
+
+onspawnsensorgrenade( watcher, player )
+{
+	self endon( "death" );
+	self thread maps/mp/gametypes/_weaponobjects::onspawnuseweaponobject( watcher, player );
+	self setowner( player );
+	self setteam( player.team );
+	self.owner = player;
+	self playloopsound( "fly_sensor_nade_lp" );
+	self maps/mp/_hacker_tool::registerwithhackertool( level.equipmenthackertoolradius, level.equipmenthackertooltimems );
+	player addweaponstat( "sensor_grenade_mp", "used", 1 );
+	self thread watchforstationary( player );
+	self thread watchforexplode( player );
+}
+
+watchforstationary( owner )
+{
+	self endon( "death" );
+	self endon( "hacked" );
+	self endon( "explode" );
+	owner endon( "death" );
+	owner endon( "disconnect" );
+	self waittill( "stationary" );
+	checkfortracking( self.origin );
+}
+
+watchforexplode( owner )
+{
+	self endon( "hacked" );
+	self endon( "delete" );
+	owner endon( "death" );
+	owner endon( "disconnect" );
+	self waittill( "explode", origin );
+	checkfortracking( origin + ( 0, 0, 1 ) );
+}
+
+checkfortracking( origin )
+{
+	if ( isDefined( self.owner ) == 0 )
+	{
+		return;
+	}
+	players = level.players;
+	_a85 = level.players;
+	_k85 = getFirstArrayKey( _a85 );
+	while ( isDefined( _k85 ) )
+	{
+		player = _a85[ _k85 ];
+		if ( player isenemyplayer( self.owner ) )
+		{
+			if ( !player hasperk( "specialty_nomotionsensor" ) )
+			{
+				if ( distancesquared( player.origin, origin ) < 562500 )
+				{
+					trace = bullettrace( origin, player.origin + vectorScale( ( 0, 0, 1 ), 12 ), 0, player );
+					if ( trace[ "fraction" ] == 1 )
+					{
+						self.owner tracksensorgrenadevictim( player );
+					}
+				}
+			}
+		}
+		_k85 = getNextArrayKey( _a85, _k85 );
+	}
+}
+
+tracksensorgrenadevictim( victim )
+{
+	if ( !isDefined( self.sensorgrenadedata ) )
+	{
+		self.sensorgrenadedata = [];
+	}
+	if ( !isDefined( self.sensorgrenadedata[ victim.clientid ] ) )
+	{
+		self.sensorgrenadedata[ victim.clientid ] = getTime();
+	}
+}
+
+isplayertracked( player, time )
+{
+	playertracked = 0;
+	if ( isDefined( self.sensorgrenadedata ) && isDefined( self.sensorgrenadedata[ player.clientid ] ) )
+	{
+		if ( ( self.sensorgrenadedata[ player.clientid ] + 10000 ) > time )
+		{
+			playertracked = 1;
+		}
+	}
+	return playertracked;
+}
+
+sensorgrenadedestroyed( attacker, weaponname )
+{
+	from_emp = maps/mp/killstreaks/_emp::isempweapon( weaponname );
+	if ( !from_emp )
+	{
+		playfx( level._equipment_explode_fx, self.origin );
+	}
+	if ( isDefined( attacker ) )
+	{
+		if ( self.owner isenemyplayer( attacker ) )
+		{
+			attacker maps/mp/_challenges::destroyedequipment( weaponname );
+			maps/mp/_scoreevents::processscoreevent( "destroyed_motion_sensor", attacker, self.owner, weaponname );
+		}
+	}
+	playsoundatposition( "dst_equipment_destroy", self.origin );
+	self delete();
+}
+
+watchsensorgrenadedamage( watcher )
+{
+	self endon( "death" );
+	self endon( "hacked" );
+	self setcandamage( 1 );
+	damagemax = 1;
+	if ( !self maps/mp/_utility::ishacked() )
+	{
+		self.damagetaken = 0;
+	}
+	for ( ;; )
+	{
+		while ( 1 )
+		{
+			self.maxhealth = 100000;
+			self.health = self.maxhealth;
+			self waittill( "damage", damage, attacker, direction, point, type, tagname, modelname, partname, weaponname, idflags );
+			if ( !isDefined( attacker ) || !isplayer( attacker ) )
+			{
+				continue;
+			}
+			while ( level.teambased && isplayer( attacker ) )
+			{
+				while ( !level.hardcoremode && self.owner.team == attacker.pers[ "team" ] && self.owner != attacker )
+				{
+					continue;
+				}
+			}
+			if ( isDefined( weaponname ) )
+			{
+				switch( weaponname )
+				{
+					case "concussion_grenade_mp":
+					case "flash_grenade_mp":
+						if ( watcher.stuntime > 0 )
+						{
+							self thread maps/mp/gametypes/_weaponobjects::stunstart( watcher, watcher.stuntime );
+						}
+						if ( level.teambased && self.owner.team != attacker.team )
+						{
+							if ( maps/mp/gametypes/_globallogic_player::dodamagefeedback( weaponname, attacker ) )
+							{
+								attacker maps/mp/gametypes/_damagefeedback::updatedamagefeedback();
+							}
+							continue;
+						}
+						else
+						{
+							if ( !level.teambased && self.owner != attacker )
+							{
+								if ( maps/mp/gametypes/_globallogic_player::dodamagefeedback( weaponname, attacker ) )
+								{
+									attacker maps/mp/gametypes/_damagefeedback::updatedamagefeedback();
+								}
+							}
+						}
+					}
+					case "emp_grenade_mp":
+						damage = damagemax;
+						default:
+							if ( maps/mp/gametypes/_globallogic_player::dodamagefeedback( weaponname, attacker ) )
+							{
+								attacker maps/mp/gametypes/_damagefeedback::updatedamagefeedback();
+							}
+							break;
+					}
+				}
+				else
+				{
+					weaponname = "";
+				}
+				if ( type == "MOD_MELEE" )
+				{
+					self.damagetaken = damagemax;
+				}
+				else
+				{
+					self.damagetaken += damage;
+				}
+				if ( self.damagetaken >= damagemax )
+				{
+					watcher thread maps/mp/gametypes/_weaponobjects::waitanddetonate( self, 0, attacker, weaponname );
+					return;
+				}
+			}
+		}
+	}
+}

patch_mp/maps/mp/_smokegrenade.gsc

@@ -0,0 +1,60 @@
+#include maps/mp/killstreaks/_dogs;
+#include maps/mp/killstreaks/_airsupport;
+#include common_scripts/utility;
+#include maps/mp/_utility;
+
+init()
+{
+	level.willypetedamageradius = 300;
+	level.willypetedamageheight = 128;
+	level.sound_smoke_start = "wpn_smoke_hiss_start";
+	level.sound_smoke_loop = "wpn_smoke_hiss_lp";
+	level.sound_smoke_stop = "wpn_smoke_hiss_end";
+	level.smokesoundduration = 8;
+	level.fx_smokegrenade_single = "smoke_center_mp";
+	precacheitem( level.fx_smokegrenade_single );
+}
+
+watchsmokegrenadedetonation( owner )
+{
+	owner addweaponstat( "willy_pete_mp", "used", 1 );
+	self waittill( "explode", position, surface );
+	if ( !isDefined( level.water_duds ) || level.water_duds == 1 )
+	{
+		if ( isDefined( surface ) && surface == "water" )
+		{
+			return;
+		}
+	}
+	onefoot = vectorScale( ( 0, 0, 1 ), 12 );
+	startpos = position + onefoot;
+	ent = spawntimedfx( level.fx_smokegrenade_single, position, ( 0, 0, 1 ), 12 );
+	ent thread blocksight();
+	if ( isDefined( owner ) )
+	{
+		owner.smokegrenadetime = getTime();
+		owner.smokegrenadeposition = position;
+	}
+	thread playsmokesound( position, level.smokesoundduration, level.sound_smoke_start, level.sound_smoke_stop, level.sound_smoke_loop );
+	damageeffectarea( owner, startpos, level.willypetedamageradius, level.willypetedamageheight, undefined );
+}
+
+damageeffectarea( owner, position, radius, height, killcament )
+{
+	effectarea = spawn( "trigger_radius", position, 0, radius, height );
+	owner thread maps/mp/killstreaks/_dogs::flash_dogs( effectarea );
+	effectarea delete();
+}
+
+blocksight()
+{
+	self endon( "death" );
+	radius = 64;
+	fxblocksight( self, radius );
+	for ( ;; )
+	{
+		wait 0,75;
+		radius = clamp( radius * 1,5, 10, 150 );
+		fxblocksight( self, radius );
+	}
+}

patch_mp/maps/mp/_sticky_grenade.gsc

@@ -0,0 +1,12 @@
+#include common_scripts/utility;
+#include maps/mp/_utility;
+
+init()
+{
+	loadfx( "weapon/crossbow/fx_trail_crossbow_blink_grn_os" );
+	loadfx( "weapon/crossbow/fx_trail_crossbow_blink_red_os" );
+}
+
+watch_bolt_detonation( owner )
+{
+}

patch_mp/maps/mp/_tabun.gsc

@@ -0,0 +1,566 @@
+#include maps/mp/gametypes/_battlechatter_mp;
+#include maps/mp/killstreaks/_dogs;
+#include maps/mp/killstreaks/_airsupport;
+#include common_scripts/utility;
+#include maps/mp/_utility;
+
+init()
+{
+	level.tabuninitialgasshockduration = weapons_get_dvar_int( "scr_tabunInitialGasShockDuration", "7" );
+	level.tabunwalkingasshockduration = weapons_get_dvar_int( "scr_tabunWalkInGasShockDuration", "4" );
+	level.tabungasshockradius = weapons_get_dvar_int( "scr_tabun_shock_radius", "185" );
+	level.tabungasshockheight = weapons_get_dvar_int( "scr_tabun_shock_height", "20" );
+	level.tabungaspoisonradius = weapons_get_dvar_int( "scr_tabun_effect_radius", "185" );
+	level.tabungaspoisonheight = weapons_get_dvar_int( "scr_tabun_shock_height", "20" );
+	level.tabungasduration = weapons_get_dvar_int( "scr_tabunGasDuration", "8" );
+	level.poisonduration = weapons_get_dvar_int( "scr_poisonDuration", "8" );
+	level.poisondamage = weapons_get_dvar_int( "scr_poisonDamage", "13" );
+	level.poisondamagehardcore = weapons_get_dvar_int( "scr_poisonDamageHardcore", "5" );
+	level.fx_tabun_0 = "tabun_tiny_mp";
+	level.fx_tabun_1 = "tabun_small_mp";
+	level.fx_tabun_2 = "tabun_medium_mp";
+	level.fx_tabun_3 = "tabun_large_mp";
+	level.fx_tabun_single = "tabun_center_mp";
+	precacheitem( level.fx_tabun_0 );
+	precacheitem( level.fx_tabun_1 );
+	precacheitem( level.fx_tabun_2 );
+	precacheitem( level.fx_tabun_3 );
+	precacheitem( level.fx_tabun_single );
+	level.fx_tabun_radius0 = weapons_get_dvar_int( "scr_fx_tabun_radius0", 55 );
+	level.fx_tabun_radius1 = weapons_get_dvar_int( "scr_fx_tabun_radius1", 55 );
+	level.fx_tabun_radius2 = weapons_get_dvar_int( "scr_fx_tabun_radius2", 50 );
+	level.fx_tabun_radius3 = weapons_get_dvar_int( "scr_fx_tabun_radius3", 25 );
+	level.sound_tabun_start = "wpn_gas_hiss_start";
+	level.sound_tabun_loop = "wpn_gas_hiss_lp";
+	level.sound_tabun_stop = "wpn_gas_hiss_end";
+	level.sound_shock_tabun_start = "";
+	level.sound_shock_tabun_loop = "";
+	level.sound_shock_tabun_stop = "";
+/#
+	level thread checkdvarupdates();
+#/
+}
+
+checkdvarupdates()
+{
+	while ( 1 )
+	{
+		level.tabungaspoisonradius = weapons_get_dvar_int( "scr_tabun_effect_radius", level.tabungaspoisonradius );
+		level.tabungaspoisonheight = weapons_get_dvar_int( "scr_tabun_shock_height", level.tabungaspoisonheight );
+		level.tabungasshockradius = weapons_get_dvar_int( "scr_tabun_shock_radius", level.tabungasshockradius );
+		level.tabungasshockheight = weapons_get_dvar_int( "scr_tabun_shock_height", level.tabungasshockheight );
+		level.tabuninitialgasshockduration = weapons_get_dvar_int( "scr_tabunInitialGasShockDuration", level.tabuninitialgasshockduration );
+		level.tabunwalkingasshockduration = weapons_get_dvar_int( "scr_tabunWalkInGasShockDuration", level.tabunwalkingasshockduration );
+		level.tabungasduration = weapons_get_dvar_int( "scr_tabunGasDuration", level.tabungasduration );
+		level.poisonduration = weapons_get_dvar_int( "scr_poisonDuration", level.poisonduration );
+		level.poisondamage = weapons_get_dvar_int( "scr_poisonDamage", level.poisondamage );
+		level.poisondamagehardcore = weapons_get_dvar_int( "scr_poisonDamageHardcore", level.poisondamagehardcore );
+		level.fx_tabun_radius0 = weapons_get_dvar_int( "scr_fx_tabun_radius0", level.fx_tabun_radius0 );
+		level.fx_tabun_radius1 = weapons_get_dvar_int( "scr_fx_tabun_radius1", level.fx_tabun_radius1 );
+		level.fx_tabun_radius2 = weapons_get_dvar_int( "scr_fx_tabun_radius2", level.fx_tabun_radius2 );
+		level.fx_tabun_radius3 = weapons_get_dvar_int( "scr_fx_tabun_radius3", level.fx_tabun_radius3 );
+		wait 1;
+	}
+}
+
+watchtabungrenadedetonation( owner )
+{
+	self waittill( "explode", position, surface );
+	if ( !isDefined( level.water_duds ) || level.water_duds == 1 )
+	{
+		if ( isDefined( surface ) && surface == "water" )
+		{
+			return;
+		}
+	}
+	if ( weapons_get_dvar_int( "scr_enable_new_tabun", 1 ) )
+	{
+		generatelocations( position, owner );
+	}
+	else
+	{
+		singlelocation( position, owner );
+	}
+}
+
+damageeffectarea( owner, position, radius, height, killcament )
+{
+	shockeffectarea = spawn( "trigger_radius", position, 0, radius, height );
+	gaseffectarea = spawn( "trigger_radius", position, 0, radius, height );
+/#
+	if ( getDvarInt( "scr_draw_triggers" ) )
+	{
+		level thread drawcylinder( position, radius, height, undefined, "tabun_draw_cylinder_stop" );
+#/
+	}
+	owner thread maps/mp/killstreaks/_dogs::flash_dogs( shockeffectarea );
+	owner thread maps/mp/killstreaks/_dogs::flash_dogs( gaseffectarea );
+	loopwaittime = 0,5;
+	durationoftabun = level.tabungasduration;
+	while ( durationoftabun > 0 )
+	{
+		players = get_players();
+		i = 0;
+		while ( i < players.size )
+		{
+			if ( level.friendlyfire == 0 )
+			{
+				if ( players[ i ] != owner )
+				{
+					if ( !isDefined( owner ) || !isDefined( owner.team ) )
+					{
+						i++;
+						continue;
+					}
+					else
+					{
+						if ( level.teambased && players[ i ].team == owner.team )
+						{
+							i++;
+							continue;
+						}
+					}
+				}
+				else
+				{
+					if ( !isDefined( players[ i ].inpoisonarea ) || players[ i ].inpoisonarea == 0 )
+					{
+						if ( players[ i ] istouching( gaseffectarea ) && players[ i ].sessionstate == "playing" )
+						{
+							if ( !players[ i ] hasperk( "specialty_proximityprotection" ) )
+							{
+								trace = bullettrace( position, players[ i ].origin + vectorScale( ( 0, 0, 0 ), 12 ), 0, players[ i ] );
+								if ( trace[ "fraction" ] == 1 )
+								{
+									players[ i ].lastpoisonedby = owner;
+									players[ i ] thread damageinpoisonarea( shockeffectarea, killcament, trace, position );
+								}
+							}
+							players[ i ] thread maps/mp/gametypes/_battlechatter_mp::incomingspecialgrenadetracking( "gas" );
+						}
+					}
+				}
+			}
+			i++;
+		}
+		wait loopwaittime;
+		durationoftabun -= loopwaittime;
+	}
+	if ( level.tabungasduration < level.poisonduration )
+	{
+		wait ( level.poisonduration - level.tabungasduration );
+	}
+	shockeffectarea delete();
+	gaseffectarea delete();
+/#
+	if ( getDvarInt( "scr_draw_triggers" ) )
+	{
+		level notify( "tabun_draw_cylinder_stop" );
+#/
+	}
+}
+
+damageinpoisonarea( gaseffectarea, killcament, trace, position )
+{
+	self endon( "disconnect" );
+	self endon( "death" );
+	self thread watch_death();
+	self.inpoisonarea = 1;
+	self startpoisoning();
+	tabunshocksound = spawn( "script_origin", ( 0, 0, 0 ) );
+	tabunshocksound thread deleteentonownerdeath( self );
+	tabunshocksound.origin = position;
+	tabunshocksound playsound( level.sound_shock_tabun_start );
+	tabunshocksound playloopsound( level.sound_shock_tabun_loop );
+	timer = 0;
+	while ( trace[ "fraction" ] == 1 && isDefined( gaseffectarea ) && self istouching( gaseffectarea ) && self.sessionstate == "playing" && isDefined( self.lastpoisonedby ) )
+	{
+		damage = level.poisondamage;
+		if ( level.hardcoremode )
+		{
+			damage = level.poisondamagehardcore;
+		}
+		self dodamage( damage, gaseffectarea.origin, self.lastpoisonedby, killcament, "none", "MOD_GAS", 0, "tabun_gas_mp" );
+		if ( self mayapplyscreeneffect() )
+		{
+			switch( timer )
+			{
+				case 0:
+					self shellshock( "tabun_gas_mp", 1 );
+					break;
+				timer++;
+				continue;
+				case 1:
+					self shellshock( "tabun_gas_nokick_mp", 1 );
+					break;
+				timer++;
+				continue;
+				default:
+				}
+				timer++;
+				if ( timer >= 2 )
+				{
+					timer = 0;
+				}
+				self hide_hud();
+			}
+			wait 1;
+			trace = bullettrace( position, self.origin + vectorScale( ( 0, 0, 0 ), 12 ), 0, self );
+		}
+		tabunshocksound stoploopsound( 0,5 );
+		wait 0,5;
+		thread playsoundinspace( level.sound_shock_tabun_stop, position );
+		wait 0,5;
+		tabunshocksound notify( "delete" );
+		tabunshocksound delete();
+		self show_hud();
+		self stoppoisoning();
+		self.inpoisonarea = 0;
+	}
+}
+
+deleteentonownerdeath( owner )
+{
+	self endon( "delete" );
+	owner waittill( "death" );
+	self delete();
+}
+
+watch_death()
+{
+	self waittill( "death" );
+	self show_hud();
+}
+
+hide_hud()
+{
+	self setclientuivisibilityflag( "hud_visible", 0 );
+}
+
+show_hud()
+{
+	self setclientuivisibilityflag( "hud_visible", 1 );
+}
+
+weapons_get_dvar_int( dvar, def )
+{
+	return int( weapons_get_dvar( dvar, def ) );
+}
+
+weapons_get_dvar( dvar, def )
+{
+	if ( getDvar( dvar ) != "" )
+	{
+		return getDvarFloat( dvar );
+	}
+	else
+	{
+		setdvar( dvar, def );
+		return def;
+	}
+}
+
+generatelocations( position, owner )
+{
+	onefoot = vectorScale( ( 0, 0, 0 ), 12 );
+	startpos = position + onefoot;
+/#
+	level.tabun_debug = getdvarintdefault( "scr_tabun_debug", 0 );
+	if ( level.tabun_debug )
+	{
+		black = vectorScale( ( 0, 0, 0 ), 0,2 );
+		debugstar( startpos, 2000, black );
+#/
+	}
+	spawnalllocs( owner, startpos );
+}
+
+singlelocation( position, owner )
+{
+	spawntimedfx( level.fx_tabun_single, position );
+	killcament = spawn( "script_model", position + vectorScale( ( 0, 0, 0 ), 60 ) );
+	killcament deleteaftertime( 15 );
+	killcament.starttime = getTime();
+	damageeffectarea( owner, position, level.tabungaspoisonradius, level.tabungaspoisonheight, killcament );
+}
+
+hitpos( start, end, color )
+{
+	trace = bullettrace( start, end, 0, undefined );
+/#
+	level.tabun_debug = getdvarintdefault( "scr_tabun_debug", 0 );
+	if ( level.tabun_debug )
+	{
+		debugstar( trace[ "position" ], 2000, color );
+	}
+	thread debug_line( start, trace[ "position" ], color, 80 );
+#/
+	return trace[ "position" ];
+}
+
+spawnalllocs( owner, startpos )
+{
+	defaultdistance = weapons_get_dvar_int( "scr_defaultDistanceTabun", 220 );
+	cos45 = 0,707;
+	negcos45 = -0,707;
+	red = ( 0,9, 0,2, 0,2 );
+	blue = ( 0,2, 0,2, 0,9 );
+	green = ( 0,2, 0,9, 0,2 );
+	white = vectorScale( ( 0, 0, 0 ), 0,9 );
+	north = startpos + ( defaultdistance, 0, 0 );
+	south = startpos - ( defaultdistance, 0, 0 );
+	east = startpos + ( 0, defaultdistance, 0 );
+	west = startpos - ( 0, defaultdistance, 0 );
+	nw = startpos + ( cos45 * defaultdistance, negcos45 * defaultdistance, 0 );
+	ne = startpos + ( cos45 * defaultdistance, cos45 * defaultdistance, 0 );
+	sw = startpos + ( negcos45 * defaultdistance, negcos45 * defaultdistance, 0 );
+	se = startpos + ( negcos45 * defaultdistance, cos45 * defaultdistance, 0 );
+	locations = [];
+	locations[ "color" ] = [];
+	locations[ "loc" ] = [];
+	locations[ "tracePos" ] = [];
+	locations[ "distSqrd" ] = [];
+	locations[ "fxtoplay" ] = [];
+	locations[ "radius" ] = [];
+	locations[ "color" ][ 0 ] = red;
+	locations[ "color" ][ 1 ] = red;
+	locations[ "color" ][ 2 ] = blue;
+	locations[ "color" ][ 3 ] = blue;
+	locations[ "color" ][ 4 ] = green;
+	locations[ "color" ][ 5 ] = green;
+	locations[ "color" ][ 6 ] = white;
+	locations[ "color" ][ 7 ] = white;
+	locations[ "point" ][ 0 ] = north;
+	locations[ "point" ][ 1 ] = ne;
+	locations[ "point" ][ 2 ] = east;
+	locations[ "point" ][ 3 ] = se;
+	locations[ "point" ][ 4 ] = south;
+	locations[ "point" ][ 5 ] = sw;
+	locations[ "point" ][ 6 ] = west;
+	locations[ "point" ][ 7 ] = nw;
+	count = 0;
+	while ( count < 8 )
+	{
+		trace = hitpos( startpos, locations[ "point" ][ count ], locations[ "color" ][ count ] );
+		locations[ "tracePos" ][ count ] = trace;
+		locations[ "loc" ][ count ] = ( startpos / 2 ) + ( trace / 2 );
+		locations[ "loc" ][ count ] -= vectorScale( ( 0, 0, 0 ), 12 );
+		locations[ "distSqrd" ][ count ] = distancesquared( startpos, trace );
+		count++;
+	}
+	centroid = getcentroid( locations );
+	killcament = spawn( "script_model", centroid + vectorScale( ( 0, 0, 0 ), 60 ) );
+	killcament deleteaftertime( 15 );
+	killcament.starttime = getTime();
+	center = getcenter( locations );
+	i = 0;
+	while ( i < 8 )
+	{
+		fxtoplay = setuptabunfx( owner, locations, i );
+		switch( fxtoplay )
+		{
+			case 0:
+				locations[ "fxtoplay" ][ i ] = level.fx_tabun_0;
+				locations[ "radius" ][ i ] = level.fx_tabun_radius0;
+				break;
+			i++;
+			continue;
+			case 1:
+				locations[ "fxtoplay" ][ i ] = level.fx_tabun_1;
+				locations[ "radius" ][ i ] = level.fx_tabun_radius1;
+				break;
+			i++;
+			continue;
+			case 2:
+				locations[ "fxtoplay" ][ i ] = level.fx_tabun_2;
+				locations[ "radius" ][ i ] = level.fx_tabun_radius2;
+				break;
+			i++;
+			continue;
+			case 3:
+				locations[ "fxtoplay" ][ i ] = level.fx_tabun_3;
+				locations[ "radius" ][ i ] = level.fx_tabun_radius3;
+				break;
+			i++;
+			continue;
+			default:
+				locations[ "radius" ][ i ] = 0;
+		}
+		i++;
+	}
+	singleeffect = 1;
+	freepassused = 0;
+	i = 0;
+	while ( i < 8 )
+	{
+		if ( locations[ "radius" ][ i ] != level.fx_tabun_radius0 )
+		{
+			if ( freepassused == 0 && locations[ "radius" ][ i ] == level.fx_tabun_radius1 )
+			{
+				freepassused = 1;
+				i++;
+				continue;
+			}
+			else
+			{
+				singleeffect = 0;
+			}
+		}
+		i++;
+	}
+	onefoot = vectorScale( ( 0, 0, 0 ), 12 );
+	startpos -= onefoot;
+	thread playtabunsound( startpos );
+	if ( singleeffect == 1 )
+	{
+		singlelocation( startpos, owner );
+	}
+	else
+	{
+		spawntimedfx( level.fx_tabun_3, startpos );
+		count = 0;
+		while ( count < 8 )
+		{
+			if ( isDefined( locations[ "fxtoplay" ][ count ] ) )
+			{
+				spawntimedfx( locations[ "fxtoplay" ][ count ], locations[ "loc" ][ count ] );
+				thread damageeffectarea( owner, locations[ "loc" ][ count ], locations[ "radius" ][ count ], locations[ "radius" ][ count ], killcament );
+			}
+			count++;
+		}
+	}
+}
+
+playtabunsound( position )
+{
+	tabunsound = spawn( "script_origin", ( 0, 0, 0 ) );
+	tabunsound.origin = position;
+	tabunsound playsound( level.sound_tabun_start );
+	tabunsound playloopsound( level.sound_tabun_loop );
+	wait level.tabungasduration;
+	thread playsoundinspace( level.sound_tabun_stop, position );
+	tabunsound stoploopsound( 0,5 );
+	wait 0,5;
+	tabunsound delete();
+}
+
+setuptabunfx( owner, locations, count )
+{
+	fxtoplay = undefined;
+	previous = count - 1;
+	if ( previous < 0 )
+	{
+		previous += locations[ "loc" ].size;
+	}
+	next = count + 1;
+	if ( next >= locations[ "loc" ].size )
+	{
+		next -= locations[ "loc" ].size;
+	}
+	effect0dist = level.fx_tabun_radius0 * level.fx_tabun_radius0;
+	effect1dist = level.fx_tabun_radius1 * level.fx_tabun_radius1;
+	effect2dist = level.fx_tabun_radius2 * level.fx_tabun_radius2;
+	effect3dist = level.fx_tabun_radius3 * level.fx_tabun_radius3;
+	effect4dist = level.fx_tabun_radius3;
+	fxtoplay = -1;
+	if ( locations[ "distSqrd" ][ count ] > effect0dist && locations[ "distSqrd" ][ previous ] > effect1dist && locations[ "distSqrd" ][ next ] > effect1dist )
+	{
+		fxtoplay = 0;
+	}
+	else
+	{
+		if ( locations[ "distSqrd" ][ count ] > effect1dist && locations[ "distSqrd" ][ previous ] > effect2dist && locations[ "distSqrd" ][ next ] > effect2dist )
+		{
+			fxtoplay = 1;
+		}
+		else
+		{
+			if ( locations[ "distSqrd" ][ count ] > effect2dist && locations[ "distSqrd" ][ previous ] > effect3dist && locations[ "distSqrd" ][ next ] > effect3dist )
+			{
+				fxtoplay = 2;
+			}
+			else
+			{
+				if ( locations[ "distSqrd" ][ count ] > effect3dist && locations[ "distSqrd" ][ previous ] > effect4dist && locations[ "distSqrd" ][ next ] > effect4dist )
+				{
+					fxtoplay = 3;
+				}
+			}
+		}
+	}
+	return fxtoplay;
+}
+
+getcentroid( locations )
+{
+	centroid = ( 0, 0, 0 );
+	i = 0;
+	while ( i < locations[ "loc" ].size )
+	{
+		centroid += locations[ "loc" ][ i ] / locations[ "loc" ].size;
+		i++;
+	}
+/#
+	level.tabun_debug = getdvarintdefault( "scr_tabun_debug", 0 );
+	if ( level.tabun_debug )
+	{
+		purple = ( 0,9, 0,2, 0,9 );
+		debugstar( centroid, 2000, purple );
+#/
+	}
+	return centroid;
+}
+
+getcenter( locations )
+{
+	center = ( 0, 0, 0 );
+	curx = locations[ "tracePos" ][ 0 ][ 0 ];
+	cury = locations[ "tracePos" ][ 0 ][ 1 ];
+	minx = curx;
+	maxx = curx;
+	miny = cury;
+	maxy = cury;
+	i = 1;
+	while ( i < locations[ "tracePos" ].size )
+	{
+		curx = locations[ "tracePos" ][ i ][ 0 ];
+		cury = locations[ "tracePos" ][ i ][ 1 ];
+		if ( curx > maxx )
+		{
+			maxx = curx;
+		}
+		else
+		{
+			if ( curx < minx )
+			{
+				minx = curx;
+			}
+		}
+		if ( cury > maxy )
+		{
+			maxy = cury;
+			i++;
+			continue;
+		}
+		else
+		{
+			if ( cury < miny )
+			{
+				miny = cury;
+			}
+		}
+		i++;
+	}
+	avgx = ( maxx + minx ) / 2;
+	avgy = ( maxy + miny ) / 2;
+	center = ( avgx, avgy, locations[ "tracePos" ][ 0 ][ 2 ] );
+/#
+	level.tabun_debug = getdvarintdefault( "scr_tabun_debug", 0 );
+	if ( level.tabun_debug )
+	{
+		cyan = ( 0,2, 0,9, 0,9 );
+		debugstar( center, 2000, cyan );
+#/
+	}
+	return center;
+}

patch_mp/maps/mp/_tacticalinsertion.gsc

@@ -0,0 +1,408 @@
+#include maps/mp/gametypes/_damagefeedback;
+#include maps/mp/gametypes/_globallogic_player;
+#include maps/mp/_hacker_tool;
+#include maps/mp/gametypes/_weaponobjects;
+#include maps/mp/_scoreevents;
+#include maps/mp/_challenges;
+#include maps/mp/gametypes/_globallogic_audio;
+#include maps/mp/gametypes/_hud_util;
+#include maps/mp/_utility;
+#include common_scripts/utility;
+
+init()
+{
+	level.tacticalinsertionweapon = "tactical_insertion_mp";
+	precachemodel( "t6_wpn_tac_insert_world" );
+	loadfx( "misc/fx_equip_tac_insert_light_grn" );
+	loadfx( "misc/fx_equip_tac_insert_light_red" );
+	level._effect[ "tacticalInsertionFizzle" ] = loadfx( "misc/fx_equip_tac_insert_exp" );
+	maps/mp/gametypes/_globallogic_audio::registerdialoggroup( "item_destroyed", 1 );
+}
+
+istacspawntouchingcrates( origin, angles )
+{
+	crate_ents = getentarray( "care_package", "script_noteworthy" );
+	mins = ( -17, -17, -40 );
+	maxs = ( 17, 17, 40 );
+	i = 0;
+	while ( i < crate_ents.size )
+	{
+		if ( crate_ents[ i ] istouchingvolume( origin + vectorScale( ( 0, 0, 1 ), 40 ), mins, maxs ) )
+		{
+			return 1;
+		}
+		i++;
+	}
+	return 0;
+}
+
+overridespawn( ispredictedspawn )
+{
+	if ( !isDefined( self.tacticalinsertion ) )
+	{
+		return 0;
+	}
+	origin = self.tacticalinsertion.origin;
+	angles = self.tacticalinsertion.angles;
+	team = self.tacticalinsertion.team;
+	if ( !ispredictedspawn )
+	{
+		self.tacticalinsertion destroy_tactical_insertion();
+	}
+	if ( team != self.team )
+	{
+		return 0;
+	}
+	if ( istacspawntouchingcrates( origin ) )
+	{
+		return 0;
+	}
+	if ( !ispredictedspawn )
+	{
+		self.tacticalinsertiontime = getTime();
+		self spawn( origin, angles, "tactical insertion" );
+		self setspawnclientflag( "SCDFL_DISABLE_LOGGING" );
+		self addweaponstat( "tactical_insertion_mp", "used", 1 );
+	}
+	return 1;
+}
+
+waitanddelete( time )
+{
+	self endon( "death" );
+	wait 0,05;
+	self delete();
+}
+
+watch( player )
+{
+	if ( isDefined( player.tacticalinsertion ) )
+	{
+		player.tacticalinsertion destroy_tactical_insertion();
+	}
+	player thread spawntacticalinsertion();
+	self waitanddelete( 0,05 );
+}
+
+watchusetrigger( trigger, callback, playersoundonuse, npcsoundonuse )
+{
+	self endon( "delete" );
+	while ( 1 )
+	{
+		trigger waittill( "trigger", player );
+		while ( !isalive( player ) )
+		{
+			continue;
+		}
+		while ( !player isonground() )
+		{
+			continue;
+		}
+		if ( isDefined( trigger.triggerteam ) && player.team != trigger.triggerteam )
+		{
+			continue;
+		}
+		if ( isDefined( trigger.triggerteamignore ) && player.team == trigger.triggerteamignore )
+		{
+			continue;
+		}
+		if ( isDefined( trigger.claimedby ) && player != trigger.claimedby )
+		{
+			continue;
+		}
+		if ( player usebuttonpressed() && !player.throwinggrenade && !player meleebuttonpressed() )
+		{
+			if ( isDefined( playersoundonuse ) )
+			{
+				player playlocalsound( playersoundonuse );
+			}
+			if ( isDefined( npcsoundonuse ) )
+			{
+				player playsound( npcsoundonuse );
+			}
+			self thread [[ callback ]]( player );
+		}
+	}
+}
+
+watchdisconnect()
+{
+	self.tacticalinsertion endon( "delete" );
+	self waittill( "disconnect" );
+	self.tacticalinsertion thread destroy_tactical_insertion();
+}
+
+destroy_tactical_insertion( attacker )
+{
+	self.owner.tacticalinsertion = undefined;
+	self notify( "delete" );
+	self.owner notify( "tactical_insertion_destroyed" );
+	self.friendlytrigger delete();
+	self.enemytrigger delete();
+	if ( isDefined( attacker ) && isDefined( attacker.pers[ "team" ] ) && isDefined( self.owner ) && isDefined( self.owner.pers[ "team" ] ) )
+	{
+		if ( level.teambased )
+		{
+			if ( attacker.pers[ "team" ] != self.owner.pers[ "team" ] )
+			{
+				attacker notify( "destroyed_explosive" );
+				attacker maps/mp/_challenges::destroyedequipment();
+				attacker maps/mp/_challenges::destroyedtacticalinsert();
+				maps/mp/_scoreevents::processscoreevent( "destroyed_tac_insert", attacker );
+			}
+		}
+		else
+		{
+			if ( attacker != self.owner )
+			{
+				attacker notify( "destroyed_explosive" );
+				attacker maps/mp/_challenges::destroyedequipment();
+				attacker maps/mp/_challenges::destroyedtacticalinsert();
+				maps/mp/_scoreevents::processscoreevent( "destroyed_tac_insert", attacker );
+			}
+		}
+	}
+	self delete();
+}
+
+fizzle( attacker )
+{
+	if ( isDefined( self.fizzle ) && self.fizzle )
+	{
+		return;
+	}
+	self.fizzle = 1;
+	playfx( level._effect[ "tacticalInsertionFizzle" ], self.origin );
+	self playsound( "dst_tac_insert_break" );
+	if ( isDefined( attacker ) && attacker != self.owner )
+	{
+		self.owner maps/mp/gametypes/_globallogic_audio::leaderdialogonplayer( "tact_destroyed", "item_destroyed" );
+	}
+	self destroy_tactical_insertion( attacker );
+}
+
+pickup( attacker )
+{
+	player = self.owner;
+	self destroy_tactical_insertion();
+	player giveweapon( level.tacticalinsertionweapon );
+	player setweaponammoclip( level.tacticalinsertionweapon, 1 );
+}
+
+spawntacticalinsertion()
+{
+	self endon( "disconnect" );
+	self.tacticalinsertion = spawn( "script_model", self.origin + ( 0, 0, 1 ) );
+	self.tacticalinsertion setmodel( "t6_wpn_tac_insert_world" );
+	self.tacticalinsertion.origin = self.origin + ( 0, 0, 1 );
+	self.tacticalinsertion.angles = self.angles;
+	self.tacticalinsertion.team = self.team;
+	self.tacticalinsertion setteam( self.team );
+	self.tacticalinsertion.owner = self;
+	self.tacticalinsertion setowner( self );
+	self.tacticalinsertion setweapon( level.tacticalinsertionweapon );
+	self.tacticalinsertion thread maps/mp/gametypes/_weaponobjects::attachreconmodel( "t6_wpn_tac_insert_detect", self );
+	self.tacticalinsertion endon( "delete" );
+	self.tacticalinsertion maps/mp/_hacker_tool::registerwithhackertool( level.equipmenthackertoolradius, level.equipmenthackertooltimems );
+	triggerheight = 64;
+	triggerradius = 128;
+	self.tacticalinsertion.friendlytrigger = spawn( "trigger_radius_use", self.tacticalinsertion.origin + vectorScale( ( 0, 0, 1 ), 3 ) );
+	self.tacticalinsertion.friendlytrigger setcursorhint( "HINT_NOICON", self.tacticalinsertion );
+	self.tacticalinsertion.friendlytrigger sethintstring( &"MP_TACTICAL_INSERTION_PICKUP" );
+	if ( level.teambased )
+	{
+		self.tacticalinsertion.friendlytrigger setteamfortrigger( self.team );
+		self.tacticalinsertion.friendlytrigger.triggerteam = self.team;
+	}
+	self clientclaimtrigger( self.tacticalinsertion.friendlytrigger );
+	self.tacticalinsertion.friendlytrigger.claimedby = self;
+	self.tacticalinsertion.enemytrigger = spawn( "trigger_radius_use", self.tacticalinsertion.origin + vectorScale( ( 0, 0, 1 ), 3 ) );
+	self.tacticalinsertion.enemytrigger setcursorhint( "HINT_NOICON", self.tacticalinsertion );
+	self.tacticalinsertion.enemytrigger sethintstring( &"MP_TACTICAL_INSERTION_DESTROY" );
+	self.tacticalinsertion.enemytrigger setinvisibletoplayer( self );
+	if ( level.teambased )
+	{
+		self.tacticalinsertion.enemytrigger setexcludeteamfortrigger( self.team );
+		self.tacticalinsertion.enemytrigger.triggerteamignore = self.team;
+	}
+	self.tacticalinsertion setclientflag( 2 );
+	self thread watchdisconnect();
+	watcher = maps/mp/gametypes/_weaponobjects::getweaponobjectwatcherbyweapon( level.tacticalinsertionweapon );
+	self.tacticalinsertion thread watchusetrigger( self.tacticalinsertion.friendlytrigger, ::pickup, watcher.pickupsoundplayer, watcher.pickupsound );
+	self.tacticalinsertion thread watchusetrigger( self.tacticalinsertion.enemytrigger, ::fizzle );
+	if ( isDefined( self.tacticalinsertioncount ) )
+	{
+		self.tacticalinsertioncount++;
+	}
+	else
+	{
+		self.tacticalinsertioncount = 1;
+	}
+	self.tacticalinsertion setcandamage( 1 );
+	self.tacticalinsertion.health = 1;
+	while ( 1 )
+	{
+		self.tacticalinsertion waittill( "damage", damage, attacker, direction, point, type, tagname, modelname, partname, weaponname, idflags );
+		while ( level.teambased && isDefined( attacker ) && isplayer( attacker ) && attacker.team == self.team && attacker != self )
+		{
+			continue;
+		}
+		if ( attacker != self )
+		{
+			attacker maps/mp/_challenges::destroyedequipment( weaponname );
+			attacker maps/mp/_challenges::destroyedtacticalinsert();
+			maps/mp/_scoreevents::processscoreevent( "destroyed_tac_insert", attacker );
+		}
+		if ( isDefined( weaponname ) )
+		{
+			switch( weaponname )
+			{
+				case "concussion_grenade_mp":
+				case "flash_grenade_mp":
+					if ( level.teambased && self.tacticalinsertion.owner.team != attacker.team )
+					{
+						if ( maps/mp/gametypes/_globallogic_player::dodamagefeedback( weaponname, attacker ) )
+						{
+							attacker maps/mp/gametypes/_damagefeedback::updatedamagefeedback();
+						}
+					}
+					else
+					{
+						if ( !level.teambased && self.tacticalinsertion.owner != attacker )
+						{
+							if ( maps/mp/gametypes/_globallogic_player::dodamagefeedback( weaponname, attacker ) )
+							{
+								attacker maps/mp/gametypes/_damagefeedback::updatedamagefeedback();
+							}
+						}
+					}
+					break;
+				break;
+				default:
+					if ( maps/mp/gametypes/_globallogic_player::dodamagefeedback( weaponname, attacker ) )
+					{
+						attacker maps/mp/gametypes/_damagefeedback::updatedamagefeedback();
+					}
+					break;
+				break;
+			}
+		}
+		if ( isDefined( attacker ) && attacker != self )
+		{
+			self maps/mp/gametypes/_globallogic_audio::leaderdialogonplayer( "tact_destroyed", "item_destroyed" );
+		}
+		self.tacticalinsertion thread fizzle();
+	}
+}
+
+cancel_button_think()
+{
+	if ( !isDefined( self.tacticalinsertion ) )
+	{
+		return;
+	}
+	text = cancel_text_create();
+	self thread cancel_button_press();
+	event = self waittill_any_return( "tactical_insertion_destroyed", "disconnect", "end_killcam", "abort_killcam", "tactical_insertion_canceled", "spawned" );
+	if ( event == "tactical_insertion_canceled" )
+	{
+		self.tacticalinsertion destroy_tactical_insertion();
+	}
+	if ( isDefined( text ) )
+	{
+		text destroy();
+	}
+}
+
+canceltackinsertionbutton()
+{
+	if ( level.console )
+	{
+		return self changeseatbuttonpressed();
+	}
+	else
+	{
+		return self jumpbuttonpressed();
+	}
+}
+
+cancel_button_press()
+{
+	self endon( "disconnect" );
+	self endon( "end_killcam" );
+	self endon( "abort_killcam" );
+	while ( 1 )
+	{
+		wait 0,05;
+		if ( self canceltackinsertionbutton() )
+		{
+			break;
+		}
+		else
+		{
+		}
+	}
+	self notify( "tactical_insertion_canceled" );
+}
+
+cancel_text_create()
+{
+	text = newclienthudelem( self );
+	text.archived = 0;
+	text.y = -100;
+	text.alignx = "center";
+	text.aligny = "middle";
+	text.horzalign = "center";
+	text.vertalign = "bottom";
+	text.sort = 10;
+	text.font = "small";
+	text.foreground = 1;
+	text.hidewheninmenu = 1;
+	if ( self issplitscreen() )
+	{
+		text.y = -80;
+		text.fontscale = 1,2;
+	}
+	else
+	{
+		text.fontscale = 1,6;
+	}
+	text settext( &"PLATFORM_PRESS_TO_CANCEL_TACTICAL_INSERTION" );
+	text.alpha = 1;
+	return text;
+}
+
+gettacticalinsertions()
+{
+	tac_inserts = [];
+	_a393 = level.players;
+	_k393 = getFirstArrayKey( _a393 );
+	while ( isDefined( _k393 ) )
+	{
+		player = _a393[ _k393 ];
+		if ( isDefined( player.tacticalinsertion ) )
+		{
+			tac_inserts[ tac_inserts.size ] = player.tacticalinsertion;
+		}
+		_k393 = getNextArrayKey( _a393, _k393 );
+	}
+	return tac_inserts;
+}
+
+tacticalinsertiondestroyedbytrophysystem( attacker, trophysystem )
+{
+	owner = self.owner;
+	if ( isDefined( attacker ) )
+	{
+		attacker maps/mp/_challenges::destroyedequipment( trophysystem.name );
+		attacker maps/mp/_challenges::destroyedtacticalinsert();
+	}
+	self thread fizzle();
+	if ( isDefined( owner ) )
+	{
+		owner endon( "death" );
+		owner endon( "disconnect" );
+		wait 0,05;
+		owner maps/mp/gametypes/_globallogic_audio::leaderdialogonplayer( "tact_destroyed", "item_destroyed" );
+	}
+}

patch_mp/maps/mp/_teargrenades.gsc

@@ -0,0 +1,187 @@
+#include maps/mp/gametypes/_perplayer;
+
+main()
+{
+	level.tearradius = 170;
+	level.tearheight = 128;
+	level.teargasfillduration = 7;
+	level.teargasduration = 23;
+	level.tearsufferingduration = 3;
+	level.teargrenadetimer = 4;
+	precacheshellshock( "teargas" );
+	fgmonitor = maps/mp/gametypes/_perplayer::init( "tear_grenade_monitor", ::startmonitoringtearusage, ::stopmonitoringtearusage );
+	maps/mp/gametypes/_perplayer::enable( fgmonitor );
+}
+
+startmonitoringtearusage()
+{
+	self thread monitortearusage();
+}
+
+stopmonitoringtearusage( disconnected )
+{
+	self notify( "stop_monitoring_tear_usage" );
+}
+
+monitortearusage()
+{
+	self endon( "stop_monitoring_tear_usage" );
+	wait 0,05;
+	if ( !self hasweapon( "tear_grenade_mp" ) )
+	{
+		return;
+	}
+	prevammo = self getammocount( "tear_grenade_mp" );
+	while ( 1 )
+	{
+		ammo = self getammocount( "tear_grenade_mp" );
+		while ( ammo < prevammo )
+		{
+			num = prevammo - ammo;
+/#
+#/
+			i = 0;
+			while ( i < num )
+			{
+				grenades = getentarray( "grenade", "classname" );
+				bestdist = undefined;
+				bestg = undefined;
+				g = 0;
+				while ( g < grenades.size )
+				{
+					if ( !isDefined( grenades[ g ].teargrenade ) )
+					{
+						dist = distance( grenades[ g ].origin, self.origin + vectorScale( ( 0, 0, 1 ), 48 ) );
+						if ( !isDefined( bestdist ) || dist < bestdist )
+						{
+							bestdist = dist;
+							bestg = g;
+						}
+					}
+					g++;
+				}
+				if ( isDefined( bestdist ) )
+				{
+					grenades[ bestg ].teargrenade = 1;
+					grenades[ bestg ] thread teargrenade_think( self.team );
+				}
+				i++;
+			}
+		}
+		prevammo = ammo;
+		wait 0,05;
+	}
+}
+
+teargrenade_think( team )
+{
+	wait level.teargrenadetimer;
+	ent = spawnstruct();
+	ent thread tear( self.origin );
+}
+
+tear( pos )
+{
+	trig = spawn( "trigger_radius", pos, 0, level.tearradius, level.tearheight );
+	starttime = getTime();
+	self thread teartimer();
+	self endon( "tear_timeout" );
+	while ( 1 )
+	{
+		trig waittill( "trigger", player );
+		while ( player.sessionstate != "playing" )
+		{
+			continue;
+		}
+		time = ( getTime() - starttime ) / 1000;
+		currad = level.tearradius;
+		curheight = level.tearheight;
+		if ( time < level.teargasfillduration )
+		{
+			currad *= time / level.teargasfillduration;
+			curheight *= time / level.teargasfillduration;
+		}
+		offset = ( player.origin + vectorScale( ( 0, 0, 1 ), 32 ) ) - pos;
+		offset2d = ( offset[ 0 ], offset[ 1 ], 0 );
+		while ( lengthsquared( offset2d ) > ( currad * currad ) )
+		{
+			continue;
+		}
+		while ( ( player.origin[ 2 ] - pos[ 2 ] ) > curheight )
+		{
+			continue;
+		}
+		player.teargasstarttime = getTime();
+		if ( !isDefined( player.teargassuffering ) )
+		{
+			player thread teargassuffering();
+		}
+	}
+}
+
+teartimer()
+{
+	wait level.teargasduration;
+	self notify( "tear_timeout" );
+}
+
+teargassuffering()
+{
+	self endon( "death" );
+	self endon( "disconnect" );
+	self.teargassuffering = 1;
+	if ( self mayapplyscreeneffect() )
+	{
+		self shellshock( "teargas", 60 );
+	}
+	while ( 1 )
+	{
+		if ( ( getTime() - self.teargasstarttime ) > ( level.tearsufferingduration * 1000 ) )
+		{
+			break;
+		}
+		else
+		{
+			wait 1;
+		}
+	}
+	self shellshock( "teargas", 1 );
+	if ( self mayapplyscreeneffect() )
+	{
+		self.teargassuffering = undefined;
+	}
+}
+
+drawcylinder( pos, rad, height )
+{
+	time = 0;
+	while ( 1 )
+	{
+		currad = rad;
+		curheight = height;
+		if ( time < level.teargasfillduration )
+		{
+			currad *= time / level.teargasfillduration;
+			curheight *= time / level.teargasfillduration;
+		}
+		r = 0;
+		while ( r < 20 )
+		{
+			theta = ( r / 20 ) * 360;
+			theta2 = ( ( r + 1 ) / 20 ) * 360;
+			line( pos + ( cos( theta ) * currad, sin( theta ) * currad, 0 ), pos + ( cos( theta2 ) * currad, sin( theta2 ) * currad, 0 ) );
+			line( pos + ( cos( theta ) * currad, sin( theta ) * currad, curheight ), pos + ( cos( theta2 ) * currad, sin( theta2 ) * currad, curheight ) );
+			line( pos + ( cos( theta ) * currad, sin( theta ) * currad, 0 ), pos + ( cos( theta ) * currad, sin( theta ) * currad, curheight ) );
+			r++;
+		}
+		time += 0,05;
+		if ( time > level.teargasduration )
+		{
+			return;
+		}
+		else
+		{
+			wait 0,05;
+		}
+	}
+}

patch_mp/maps/mp/_treadfx.gsc

@@ -0,0 +1,128 @@
+
+loadtreadfx( vehicle )
+{
+	treadfx = vehicle.treadfxnamearray;
+	if ( isDefined( treadfx ) )
+	{
+		vehicle.treadfx = [];
+		if ( isDefined( treadfx[ "asphalt" ] ) && treadfx[ "asphalt" ] != "" )
+		{
+			vehicle.treadfx[ "asphalt" ] = loadfx( treadfx[ "asphalt" ] );
+		}
+		if ( isDefined( treadfx[ "bark" ] ) && treadfx[ "bark" ] != "" )
+		{
+			vehicle.treadfx[ "bark" ] = loadfx( treadfx[ "bark" ] );
+		}
+		if ( isDefined( treadfx[ "brick" ] ) && treadfx[ "brick" ] != "" )
+		{
+			vehicle.treadfx[ "brick" ] = loadfx( treadfx[ "brick" ] );
+		}
+		if ( isDefined( treadfx[ "carpet" ] ) && treadfx[ "carpet" ] != "" )
+		{
+			vehicle.treadfx[ "carpet" ] = loadfx( treadfx[ "carpet" ] );
+		}
+		if ( isDefined( treadfx[ "ceramic" ] ) && treadfx[ "ceramic" ] != "" )
+		{
+			vehicle.treadfx[ "ceramic" ] = loadfx( treadfx[ "ceramic" ] );
+		}
+		if ( isDefined( treadfx[ "cloth" ] ) && treadfx[ "cloth" ] != "" )
+		{
+			vehicle.treadfx[ "cloth" ] = loadfx( treadfx[ "cloth" ] );
+		}
+		if ( isDefined( treadfx[ "concrete" ] ) && treadfx[ "concrete" ] != "" )
+		{
+			vehicle.treadfx[ "concrete" ] = loadfx( treadfx[ "concrete" ] );
+		}
+		if ( isDefined( treadfx[ "cushion" ] ) && treadfx[ "cushion" ] != "" )
+		{
+			vehicle.treadfx[ "cushion" ] = loadfx( treadfx[ "cushion" ] );
+		}
+		if ( isDefined( treadfx[ "none" ] ) && treadfx[ "none" ] != "" )
+		{
+			vehicle.treadfx[ "none" ] = loadfx( treadfx[ "none" ] );
+		}
+		if ( isDefined( treadfx[ "dirt" ] ) && treadfx[ "dirt" ] != "" )
+		{
+			vehicle.treadfx[ "dirt" ] = loadfx( treadfx[ "dirt" ] );
+		}
+		if ( isDefined( treadfx[ "flesh" ] ) && treadfx[ "flesh" ] != "" )
+		{
+			vehicle.treadfx[ "flesh" ] = loadfx( treadfx[ "flesh" ] );
+		}
+		if ( isDefined( treadfx[ "foliage" ] ) && treadfx[ "foliage" ] != "" )
+		{
+			vehicle.treadfx[ "foliage" ] = loadfx( treadfx[ "foliage" ] );
+		}
+		if ( isDefined( treadfx[ "fruit" ] ) && treadfx[ "fruit" ] != "" )
+		{
+			vehicle.treadfx[ "fruit" ] = loadfx( treadfx[ "fruit" ] );
+		}
+		if ( isDefined( treadfx[ "glass" ] ) && treadfx[ "glass" ] != "" )
+		{
+			vehicle.treadfx[ "glass" ] = loadfx( treadfx[ "glass" ] );
+		}
+		if ( isDefined( treadfx[ "grass" ] ) && treadfx[ "grass" ] != "" )
+		{
+			vehicle.treadfx[ "grass" ] = loadfx( treadfx[ "grass" ] );
+		}
+		if ( isDefined( treadfx[ "gravel" ] ) && treadfx[ "gravel" ] != "" )
+		{
+			vehicle.treadfx[ "gravel" ] = loadfx( treadfx[ "gravel" ] );
+		}
+		if ( isDefined( treadfx[ "metal" ] ) && treadfx[ "metal" ] != "" )
+		{
+			vehicle.treadfx[ "metal" ] = loadfx( treadfx[ "metal" ] );
+		}
+		if ( isDefined( treadfx[ "mud" ] ) && treadfx[ "mud" ] != "" )
+		{
+			vehicle.treadfx[ "mud" ] = loadfx( treadfx[ "mud" ] );
+		}
+		if ( isDefined( treadfx[ "paintedmetal" ] ) && treadfx[ "paintedmetal" ] != "" )
+		{
+			vehicle.treadfx[ "paintedmetal" ] = loadfx( treadfx[ "paintedmetal" ] );
+		}
+		if ( isDefined( treadfx[ "paper" ] ) && treadfx[ "paper" ] != "" )
+		{
+			vehicle.treadfx[ "paper" ] = loadfx( treadfx[ "paper" ] );
+		}
+		if ( isDefined( treadfx[ "plaster" ] ) && treadfx[ "plaster" ] != "" )
+		{
+			vehicle.treadfx[ "plaster" ] = loadfx( treadfx[ "plaster" ] );
+		}
+		if ( isDefined( treadfx[ "plastic" ] ) && treadfx[ "plastic" ] != "" )
+		{
+			vehicle.treadfx[ "plastic" ] = loadfx( treadfx[ "plastic" ] );
+		}
+		if ( isDefined( treadfx[ "rock" ] ) && treadfx[ "rock" ] != "" )
+		{
+			vehicle.treadfx[ "rock" ] = loadfx( treadfx[ "rock" ] );
+		}
+		if ( isDefined( treadfx[ "rubber" ] ) && treadfx[ "rubber" ] != "" )
+		{
+			vehicle.treadfx[ "rubber" ] = loadfx( treadfx[ "rubber" ] );
+		}
+		if ( isDefined( treadfx[ "sand" ] ) && treadfx[ "sand" ] != "" )
+		{
+			vehicle.treadfx[ "sand" ] = loadfx( treadfx[ "sand" ] );
+		}
+		if ( isDefined( treadfx[ "water" ] ) && treadfx[ "water" ] != "" )
+		{
+			vehicle.treadfx[ "water" ] = loadfx( treadfx[ "water" ] );
+		}
+		if ( isDefined( treadfx[ "wood" ] ) && treadfx[ "wood" ] != "" )
+		{
+			vehicle.treadfx[ "wood" ] = loadfx( treadfx[ "wood" ] );
+		}
+	}
+}
+
+preloadtreadfx( vehicle )
+{
+	treadfx = getvehicletreadfxarray( vehicle );
+	i = 0;
+	while ( i < treadfx.size )
+	{
+		loadfx( treadfx[ i ] );
+		i++;
+	}
+}

patch_mp/maps/mp/_trophy_system.gsc

@@ -0,0 +1,379 @@
+#include maps/mp/gametypes/_damagefeedback;
+#include maps/mp/gametypes/_globallogic_player;
+#include maps/mp/killstreaks/_emp;
+#include maps/mp/_tacticalinsertion;
+#include maps/mp/_scoreevents;
+#include maps/mp/_challenges;
+#include maps/mp/gametypes/_globallogic_audio;
+#include maps/mp/gametypes/_weaponobjects;
+#include common_scripts/utility;
+#include maps/mp/_utility;
+
+#using_animtree( "mp_trophy_system" );
+
+init()
+{
+	precachemodel( "t6_wpn_trophy_system_world" );
+	level.trophylongflashfx = loadfx( "weapon/trophy_system/fx_trophy_flash_lng" );
+	level.trophydetonationfx = loadfx( "weapon/trophy_system/fx_trophy_radius_detonation" );
+	level._effect[ "fx_trophy_friendly_light" ] = loadfx( "weapon/trophy_system/fx_trophy_light_friendly" );
+	level._effect[ "fx_trophy_enemy_light" ] = loadfx( "weapon/trophy_system/fx_trophy_light_enemy" );
+	level._effect[ "fx_trophy_deploy_impact" ] = loadfx( "weapon/trophy_system/fx_trophy_deploy_impact" );
+	trophydeployanim = %o_trophy_deploy;
+	trophyspinanim = %o_trophy_spin;
+}
+
+register()
+{
+	registerclientfield( "missile", "trophy_system_state", 1, 2, "int" );
+	registerclientfield( "scriptmover", "trophy_system_state", 1, 2, "int" );
+}
+
+createtrophysystemwatcher()
+{
+	watcher = self maps/mp/gametypes/_weaponobjects::createuseweaponobjectwatcher( "trophy_system", "trophy_system_mp", self.team );
+	watcher.detonate = ::trophysystemdetonate;
+	watcher.activatesound = "wpn_claymore_alert";
+	watcher.hackable = 1;
+	watcher.hackertoolradius = level.equipmenthackertoolradius;
+	watcher.hackertooltimems = level.equipmenthackertooltimems;
+	watcher.reconmodel = "t6_wpn_trophy_system_world_detect";
+	watcher.ownergetsassist = 1;
+	watcher.ignoredirection = 1;
+	watcher.activationdelay = 0,1;
+	watcher.headicon = 1;
+	watcher.enemydestroy = 1;
+	watcher.onspawn = ::ontrophysystemspawn;
+	watcher.ondamage = ::watchtrophysystemdamage;
+	watcher.ondestroyed = ::ontrophysystemsmashed;
+	watcher.stun = ::weaponstun;
+	watcher.stuntime = 1;
+}
+
+ontrophysystemspawn( watcher, player )
+{
+	player endon( "death" );
+	player endon( "disconnect" );
+	level endon( "game_ended" );
+	self maps/mp/gametypes/_weaponobjects::onspawnuseweaponobject( watcher, player );
+	player addweaponstat( "trophy_system_mp", "used", 1 );
+	self.ammo = 2;
+	self thread trophyactive( player );
+	self thread trophywatchhack();
+	self setclientfield( "trophy_system_state", 1 );
+	self playloopsound( "wpn_trophy_spin", 0,25 );
+	if ( isDefined( watcher.reconmodel ) )
+	{
+		self thread setreconmodeldeployed();
+	}
+}
+
+setreconmodeldeployed()
+{
+	self endon( "death" );
+	for ( ;; )
+	{
+		if ( isDefined( self.reconmodelentity ) )
+		{
+			self.reconmodelentity setclientfield( "trophy_system_state", 1 );
+			return;
+		}
+		wait 0,05;
+	}
+}
+
+trophywatchhack()
+{
+	self endon( "death" );
+	self waittill( "hacked", player );
+	wait 0,05;
+	self thread trophyactive( player );
+}
+
+ontrophysystemsmashed( attacker )
+{
+	playfx( level._effect[ "tacticalInsertionFizzle" ], self.origin );
+	self playsound( "dst_tac_insert_break" );
+	self.owner maps/mp/gametypes/_globallogic_audio::leaderdialogonplayer( "equipment_destroyed", "item_destroyed" );
+	if ( isDefined( attacker ) && self.owner isenemyplayer( attacker ) )
+	{
+		attacker maps/mp/_challenges::destroyedequipment();
+		maps/mp/_scoreevents::processscoreevent( "destroyed_trophy_system", attacker, self.owner );
+	}
+	self delete();
+}
+
+trophyactive( owner )
+{
+	owner endon( "disconnect" );
+	self endon( "death" );
+	self endon( "hacked" );
+	while ( 1 )
+	{
+		tac_inserts = maps/mp/_tacticalinsertion::gettacticalinsertions();
+		while ( level.missileentities.size < 1 || tac_inserts.size < 1 && isDefined( self.disabled ) )
+		{
+			wait 0,05;
+		}
+		index = 0;
+		while ( index < level.missileentities.size )
+		{
+			wait 0,05;
+			grenade = level.missileentities[ index ];
+			if ( !isDefined( grenade ) )
+			{
+				index++;
+				continue;
+			}
+			else if ( grenade == self )
+			{
+				index++;
+				continue;
+			}
+			else if ( isDefined( grenade.weaponname ) )
+			{
+				switch( grenade.weaponname )
+				{
+					case "claymore_mp":
+						index++;
+						continue;
+					}
+				}
+				if ( isDefined( grenade.name ) && grenade.name == "tactical_insertion_mp" )
+				{
+					index++;
+					continue;
+				}
+				else switch( grenade.model )
+				{
+					case "t6_wpn_grenade_supply_projectile":
+						index++;
+						continue;
+					}
+					if ( !isDefined( grenade.owner ) )
+					{
+						grenade.owner = getmissileowner( grenade );
+					}
+					if ( isDefined( grenade.owner ) )
+					{
+						if ( level.teambased )
+						{
+							if ( grenade.owner.team == owner.team )
+							{
+								index++;
+								continue;
+							}
+							else }
+						else if ( grenade.owner == owner )
+						{
+							index++;
+							continue;
+						}
+						else
+						{
+							grenadedistancesquared = distancesquared( grenade.origin, self.origin );
+							if ( grenadedistancesquared < 262144 )
+							{
+								if ( bullettracepassed( grenade.origin, self.origin + vectorScale( ( 0, 0, 1 ), 29 ), 0, self ) )
+								{
+									playfx( level.trophylongflashfx, self.origin + vectorScale( ( 0, 0, 1 ), 15 ), grenade.origin - self.origin, anglesToUp( self.angles ) );
+									owner thread projectileexplode( grenade, self );
+									index--;
+
+									self playsound( "wpn_trophy_alert" );
+									self.ammo--;
+
+									if ( self.ammo <= 0 )
+									{
+										self thread trophysystemdetonate();
+									}
+								}
+							}
+						}
+					}
+					index++;
+				}
+				index = 0;
+				while ( index < tac_inserts.size )
+				{
+					wait 0,05;
+					tac_insert = tac_inserts[ index ];
+					if ( !isDefined( tac_insert ) )
+					{
+						index++;
+						continue;
+					}
+					else if ( isDefined( tac_insert.owner ) )
+					{
+						if ( level.teambased )
+						{
+							if ( tac_insert.owner.team == owner.team )
+							{
+								index++;
+								continue;
+							}
+							else }
+						else if ( tac_insert.owner == owner )
+						{
+							index++;
+							continue;
+						}
+						else
+						{
+							grenadedistancesquared = distancesquared( tac_insert.origin, self.origin );
+							if ( grenadedistancesquared < 262144 )
+							{
+								if ( bullettracepassed( tac_insert.origin, self.origin + vectorScale( ( 0, 0, 1 ), 29 ), 0, tac_insert ) )
+								{
+									playfx( level.trophylongflashfx, self.origin + vectorScale( ( 0, 0, 1 ), 15 ), tac_insert.origin - self.origin, anglesToUp( self.angles ) );
+									owner thread trophydestroytacinsert( tac_insert, self );
+									index--;
+
+									self playsound( "wpn_trophy_alert" );
+									self.ammo--;
+
+									if ( self.ammo <= 0 )
+									{
+										self thread trophysystemdetonate();
+									}
+								}
+							}
+						}
+					}
+					index++;
+				}
+			}
+		}
+	}
+}
+
+projectileexplode( projectile, trophy )
+{
+	self endon( "death" );
+	projposition = projectile.origin;
+	playfx( level.trophydetonationfx, projposition );
+	projectile delete();
+	trophy radiusdamage( projposition, 128, 105, 10, self );
+	maps/mp/_scoreevents::processscoreevent( "trophy_defense", self );
+	self addplayerstat( "destroy_explosive_with_trophy", 1 );
+	self addweaponstat( "trophy_system_mp", "CombatRecordStat", 1 );
+}
+
+trophydestroytacinsert( tacinsert, trophy )
+{
+	self endon( "death" );
+	tacpos = tacinsert.origin;
+	playfx( level.trophydetonationfx, tacinsert.origin );
+	tacinsert thread maps/mp/_tacticalinsertion::tacticalinsertiondestroyedbytrophysystem( self, trophy );
+	trophy radiusdamage( tacpos, 128, 105, 10, self );
+	maps/mp/_scoreevents::processscoreevent( "trophy_defense", self );
+	self addplayerstat( "destroy_explosive_with_trophy", 1 );
+	self addweaponstat( "trophy_system_mp", "CombatRecordStat", 1 );
+}
+
+trophysystemdetonate( attacker, weaponname )
+{
+	from_emp = maps/mp/killstreaks/_emp::isempweapon( weaponname );
+	if ( !from_emp )
+	{
+		playfx( level._equipment_explode_fx_lg, self.origin );
+	}
+	if ( isDefined( attacker ) && self.owner isenemyplayer( attacker ) )
+	{
+		attacker maps/mp/_challenges::destroyedequipment( weaponname );
+		maps/mp/_scoreevents::processscoreevent( "destroyed_trophy_system", attacker, self.owner, weaponname );
+	}
+	playsoundatposition( "dst_equipment_destroy", self.origin );
+	self delete();
+}
+
+watchtrophysystemdamage( watcher )
+{
+	self endon( "death" );
+	self endon( "hacked" );
+	self setcandamage( 1 );
+	damagemax = 20;
+	if ( !self maps/mp/_utility::ishacked() )
+	{
+		self.damagetaken = 0;
+	}
+	self.maxhealth = 10000;
+	self.health = self.maxhealth;
+	self setmaxhealth( self.maxhealth );
+	attacker = undefined;
+	for ( ;; )
+	{
+		while ( 1 )
+		{
+			self waittill( "damage", damage, attacker, direction_vec, point, type, modelname, tagname, partname, weaponname, idflags );
+			while ( !isplayer( attacker ) )
+			{
+				continue;
+			}
+			while ( level.teambased )
+			{
+				while ( !level.hardcoremode && self.owner.team == attacker.pers[ "team" ] && self.owner != attacker )
+				{
+					continue;
+				}
+			}
+			if ( isDefined( weaponname ) )
+			{
+				switch( weaponname )
+				{
+					case "concussion_grenade_mp":
+					case "flash_grenade_mp":
+						if ( watcher.stuntime > 0 )
+						{
+							self thread maps/mp/gametypes/_weaponobjects::stunstart( watcher, watcher.stuntime );
+						}
+						if ( level.teambased && self.owner.team != attacker.team )
+						{
+							if ( maps/mp/gametypes/_globallogic_player::dodamagefeedback( weaponname, attacker ) )
+							{
+								attacker maps/mp/gametypes/_damagefeedback::updatedamagefeedback();
+							}
+							continue;
+						}
+						else
+						{
+							if ( !level.teambased && self.owner != attacker )
+							{
+								if ( maps/mp/gametypes/_globallogic_player::dodamagefeedback( weaponname, attacker ) )
+								{
+									attacker maps/mp/gametypes/_damagefeedback::updatedamagefeedback();
+								}
+							}
+						}
+					}
+					case "emp_grenade_mp":
+						damage = damagemax;
+						default:
+							if ( maps/mp/gametypes/_globallogic_player::dodamagefeedback( weaponname, attacker ) )
+							{
+								attacker maps/mp/gametypes/_damagefeedback::updatedamagefeedback();
+							}
+							break;
+					}
+				}
+				else
+				{
+					weaponname = "";
+				}
+				if ( type == "MOD_MELEE" )
+				{
+					self.damagetaken = damagemax;
+				}
+				else
+				{
+					self.damagetaken += damage;
+				}
+				if ( self.damagetaken >= damagemax )
+				{
+					watcher thread maps/mp/gametypes/_weaponobjects::waitanddetonate( self, 0,05, attacker, weaponname );
+					return;
+				}
+			}
+		}
+	}
+}

patch_mp/maps/mp/killstreaks/_airsupport.gsc

@@ -0,0 +1,948 @@
+#include maps/mp/gametypes/_weapons;
+#include common_scripts/utility;
+#include maps/mp/_utility;
+
+initairsupport()
+{
+	if ( !isDefined( level.airsupportheightscale ) )
+	{
+		level.airsupportheightscale = 1;
+	}
+	level.airsupportheightscale = getdvarintdefault( "scr_airsupportHeightScale", level.airsupportheightscale );
+	level.noflyzones = [];
+	level.noflyzones = getentarray( "no_fly_zone", "targetname" );
+	airsupport_heights = getstructarray( "air_support_height", "targetname" );
+/#
+	if ( airsupport_heights.size > 1 )
+	{
+		error( "Found more then one 'air_support_height' structs in the map" );
+#/
+	}
+	airsupport_heights = getentarray( "air_support_height", "targetname" );
+/#
+	if ( airsupport_heights.size > 0 )
+	{
+		error( "Found an entity in the map with an 'air_support_height' targetname.  There should be only structs." );
+#/
+	}
+	heli_height_meshes = getentarray( "heli_height_lock", "classname" );
+/#
+	if ( heli_height_meshes.size > 1 )
+	{
+		error( "Found more then one 'heli_height_lock' classname in the map" );
+#/
+	}
+}
+
+finishhardpointlocationusage( location, usedcallback )
+{
+	self notify( "used" );
+	wait 0,05;
+	return self [[ usedcallback ]]( location );
+}
+
+finishdualhardpointlocationusage( locationstart, locationend, usedcallback )
+{
+	self notify( "used" );
+	wait 0,05;
+	return self [[ usedcallback ]]( locationstart, locationend );
+}
+
+endselectionongameend()
+{
+	self endon( "death" );
+	self endon( "disconnect" );
+	self endon( "cancel_location" );
+	self endon( "used" );
+	self endon( "host_migration_begin" );
+	level waittill( "game_ended" );
+	self notify( "game_ended" );
+}
+
+endselectiononhostmigration()
+{
+	self endon( "death" );
+	self endon( "disconnect" );
+	self endon( "cancel_location" );
+	self endon( "used" );
+	self endon( "game_ended" );
+	level waittill( "host_migration_begin" );
+	self notify( "cancel_location" );
+}
+
+endselectionthink()
+{
+/#
+	assert( isplayer( self ) );
+#/
+/#
+	assert( isalive( self ) );
+#/
+/#
+	assert( isDefined( self.selectinglocation ) );
+#/
+/#
+	assert( self.selectinglocation == 1 );
+#/
+	self thread endselectionongameend();
+	self thread endselectiononhostmigration();
+	event = self waittill_any_return( "death", "disconnect", "cancel_location", "game_ended", "used", "weapon_change", "emp_jammed" );
+	if ( event != "disconnect" )
+	{
+		self endlocationselection();
+		self.selectinglocation = undefined;
+	}
+	if ( event != "used" )
+	{
+		self notify( "confirm_location" );
+	}
+}
+
+stoploopsoundaftertime( time )
+{
+	self endon( "death" );
+	wait time;
+	self stoploopsound( 2 );
+}
+
+calculatefalltime( flyheight )
+{
+	gravity = getDvarInt( "bg_gravity" );
+	time = sqrt( ( 2 * flyheight ) / gravity );
+	return time;
+}
+
+calculatereleasetime( flytime, flyheight, flyspeed, bombspeedscale )
+{
+	falltime = calculatefalltime( flyheight );
+	bomb_x = flyspeed * bombspeedscale * falltime;
+	release_time = bomb_x / flyspeed;
+	return ( flytime * 0,5 ) - release_time;
+}
+
+getminimumflyheight()
+{
+	airsupport_height = getstruct( "air_support_height", "targetname" );
+	if ( isDefined( airsupport_height ) )
+	{
+		planeflyheight = airsupport_height.origin[ 2 ];
+	}
+	else
+	{
+/#
+		println( "WARNING:  Missing air_support_height entity in the map.  Using default height." );
+#/
+		planeflyheight = 850;
+		if ( isDefined( level.airsupportheightscale ) )
+		{
+			level.airsupportheightscale = getdvarintdefault( "scr_airsupportHeightScale", level.airsupportheightscale );
+			planeflyheight *= getdvarintdefault( "scr_airsupportHeightScale", level.airsupportheightscale );
+		}
+		if ( isDefined( level.forceairsupportmapheight ) )
+		{
+			planeflyheight += level.forceairsupportmapheight;
+		}
+	}
+	return planeflyheight;
+}
+
+callstrike( flightplan )
+{
+	level.bomberdamagedents = [];
+	level.bomberdamagedentscount = 0;
+	level.bomberdamagedentsindex = 0;
+/#
+	assert( flightplan.distance != 0, "callStrike can not be passed a zero fly distance" );
+#/
+	planehalfdistance = flightplan.distance / 2;
+	path = getstrikepath( flightplan.target, flightplan.height, planehalfdistance );
+	startpoint = path[ "start" ];
+	endpoint = path[ "end" ];
+	flightplan.height = path[ "height" ];
+	direction = path[ "direction" ];
+	d = length( startpoint - endpoint );
+	flytime = d / flightplan.speed;
+	bombtime = calculatereleasetime( flytime, flightplan.height, flightplan.speed, flightplan.bombspeedscale );
+	if ( bombtime < 0 )
+	{
+		bombtime = 0;
+	}
+/#
+	assert( flytime > bombtime );
+#/
+	flightplan.owner endon( "disconnect" );
+	requireddeathcount = flightplan.owner.deathcount;
+	side = vectorcross( anglesToForward( direction ), ( 1, 1, 1 ) );
+	plane_seperation = 25;
+	side_offset = vectorScale( side, plane_seperation );
+	level thread planestrike( flightplan.owner, requireddeathcount, startpoint, endpoint, bombtime, flytime, flightplan.speed, flightplan.bombspeedscale, direction, flightplan.planespawncallback );
+	wait flightplan.planespacing;
+	level thread planestrike( flightplan.owner, requireddeathcount, startpoint + side_offset, endpoint + side_offset, bombtime, flytime, flightplan.speed, flightplan.bombspeedscale, direction, flightplan.planespawncallback );
+	wait flightplan.planespacing;
+	side_offset = vectorScale( side, -1 * plane_seperation );
+	level thread planestrike( flightplan.owner, requireddeathcount, startpoint + side_offset, endpoint + side_offset, bombtime, flytime, flightplan.speed, flightplan.bombspeedscale, direction, flightplan.planespawncallback );
+}
+
+planestrike( owner, requireddeathcount, pathstart, pathend, bombtime, flytime, flyspeed, bombspeedscale, direction, planespawnedfunction )
+{
+	if ( !isDefined( owner ) )
+	{
+		return;
+	}
+	plane = spawnplane( owner, "script_model", pathstart );
+	plane.angles = direction;
+	plane moveto( pathend, flytime, 0, 0 );
+	thread debug_plane_line( flytime, flyspeed, pathstart, pathend );
+	if ( isDefined( planespawnedfunction ) )
+	{
+		plane [[ planespawnedfunction ]]( owner, requireddeathcount, pathstart, pathend, bombtime, bombspeedscale, flytime, flyspeed );
+	}
+	wait flytime;
+	plane notify( "delete" );
+	plane delete();
+}
+
+determinegroundpoint( player, position )
+{
+	ground = ( position[ 0 ], position[ 1 ], player.origin[ 2 ] );
+	trace = bullettrace( ground + vectorScale( ( 1, 1, 1 ), 10000 ), ground, 0, undefined );
+	return trace[ "position" ];
+}
+
+determinetargetpoint( player, position )
+{
+	point = determinegroundpoint( player, position );
+	return clamptarget( point );
+}
+
+getmintargetheight()
+{
+	return level.spawnmins[ 2 ] - 500;
+}
+
+getmaxtargetheight()
+{
+	return level.spawnmaxs[ 2 ] + 500;
+}
+
+clamptarget( target )
+{
+	min = getmintargetheight();
+	max = getmaxtargetheight();
+	if ( target[ 2 ] < min )
+	{
+		target[ 2 ] = min;
+	}
+	if ( target[ 2 ] > max )
+	{
+		target[ 2 ] = max;
+	}
+	return target;
+}
+
+_insidecylinder( point, base, radius, height )
+{
+	if ( isDefined( height ) )
+	{
+		if ( point[ 2 ] > ( base[ 2 ] + height ) )
+		{
+			return 0;
+		}
+	}
+	dist = distance2d( point, base );
+	if ( dist < radius )
+	{
+		return 1;
+	}
+	return 0;
+}
+
+_insidenoflyzonebyindex( point, index, disregardheight )
+{
+	height = level.noflyzones[ index ].height;
+	if ( isDefined( disregardheight ) )
+	{
+		height = undefined;
+	}
+	return _insidecylinder( point, level.noflyzones[ index ].origin, level.noflyzones[ index ].radius, height );
+}
+
+getnoflyzoneheight( point )
+{
+	height = point[ 2 ];
+	origin = undefined;
+	i = 0;
+	while ( i < level.noflyzones.size )
+	{
+		if ( _insidenoflyzonebyindex( point, i ) )
+		{
+			if ( height < level.noflyzones[ i ].height )
+			{
+				height = level.noflyzones[ i ].height;
+				origin = level.noflyzones[ i ].origin;
+			}
+		}
+		i++;
+	}
+	if ( !isDefined( origin ) )
+	{
+		return point[ 2 ];
+	}
+	return origin[ 2 ] + height;
+}
+
+insidenoflyzones( point, disregardheight )
+{
+	noflyzones = [];
+	i = 0;
+	while ( i < level.noflyzones.size )
+	{
+		if ( _insidenoflyzonebyindex( point, i, disregardheight ) )
+		{
+			noflyzones[ noflyzones.size ] = i;
+		}
+		i++;
+	}
+	return noflyzones;
+}
+
+crossesnoflyzone( start, end )
+{
+	i = 0;
+	while ( i < level.noflyzones.size )
+	{
+		point = closestpointonline( level.noflyzones[ i ].origin + ( 0, 0, 0,5 * level.noflyzones[ i ].height ), start, end );
+		dist = distance2d( point, level.noflyzones[ i ].origin );
+		if ( point[ 2 ] > ( level.noflyzones[ i ].origin[ 2 ] + level.noflyzones[ i ].height ) )
+		{
+			i++;
+			continue;
+		}
+		else
+		{
+			if ( dist < level.noflyzones[ i ].radius )
+			{
+				return i;
+			}
+		}
+		i++;
+	}
+	return undefined;
+}
+
+crossesnoflyzones( start, end )
+{
+	zones = [];
+	i = 0;
+	while ( i < level.noflyzones.size )
+	{
+		point = closestpointonline( level.noflyzones[ i ].origin, start, end );
+		dist = distance2d( point, level.noflyzones[ i ].origin );
+		if ( point[ 2 ] > ( level.noflyzones[ i ].origin[ 2 ] + level.noflyzones[ i ].height ) )
+		{
+			i++;
+			continue;
+		}
+		else
+		{
+			if ( dist < level.noflyzones[ i ].radius )
+			{
+				zones[ zones.size ] = i;
+			}
+		}
+		i++;
+	}
+	return zones;
+}
+
+getnoflyzoneheightcrossed( start, end, minheight )
+{
+	height = minheight;
+	i = 0;
+	while ( i < level.noflyzones.size )
+	{
+		point = closestpointonline( level.noflyzones[ i ].origin, start, end );
+		dist = distance2d( point, level.noflyzones[ i ].origin );
+		if ( dist < level.noflyzones[ i ].radius )
+		{
+			if ( height < level.noflyzones[ i ].height )
+			{
+				height = level.noflyzones[ i ].height;
+			}
+		}
+		i++;
+	}
+	return height;
+}
+
+_shouldignorenoflyzone( noflyzone, noflyzones )
+{
+	if ( !isDefined( noflyzone ) )
+	{
+		return 1;
+	}
+	i = 0;
+	while ( i < noflyzones.size )
+	{
+		if ( isDefined( noflyzones[ i ] ) && noflyzones[ i ] == noflyzone )
+		{
+			return 1;
+		}
+		i++;
+	}
+	return 0;
+}
+
+_shouldignorestartgoalnoflyzone( noflyzone, startnoflyzones, goalnoflyzones )
+{
+	if ( !isDefined( noflyzone ) )
+	{
+		return 1;
+	}
+	if ( _shouldignorenoflyzone( noflyzone, startnoflyzones ) )
+	{
+		return 1;
+	}
+	if ( _shouldignorenoflyzone( noflyzone, goalnoflyzones ) )
+	{
+		return 1;
+	}
+	return 0;
+}
+
+gethelipath( start, goal )
+{
+	startnoflyzones = insidenoflyzones( start, 1 );
+	thread debug_line( start, goal, ( 1, 1, 1 ) );
+	goalnoflyzones = insidenoflyzones( goal );
+	if ( goalnoflyzones.size )
+	{
+		goal = ( goal[ 0 ], goal[ 1 ], getnoflyzoneheight( goal ) );
+	}
+	goal_points = calculatepath( start, goal, startnoflyzones, goalnoflyzones );
+	if ( !isDefined( goal_points ) )
+	{
+		return undefined;
+	}
+/#
+	assert( goal_points.size >= 1 );
+#/
+	return goal_points;
+}
+
+followpath( path, donenotify, stopatgoal )
+{
+	i = 0;
+	while ( i < ( path.size - 1 ) )
+	{
+		self setvehgoalpos( path[ i ], 0 );
+		thread debug_line( self.origin, path[ i ], ( 1, 1, 1 ) );
+		self waittill( "goal" );
+		i++;
+	}
+	self setvehgoalpos( path[ path.size - 1 ], stopatgoal );
+	thread debug_line( self.origin, path[ i ], ( 1, 1, 1 ) );
+	self waittill( "goal" );
+	if ( isDefined( donenotify ) )
+	{
+		self notify( donenotify );
+	}
+}
+
+setgoalposition( goal, donenotify, stopatgoal )
+{
+	if ( !isDefined( stopatgoal ) )
+	{
+		stopatgoal = 1;
+	}
+	start = self.origin;
+	goal_points = gethelipath( start, goal );
+	if ( !isDefined( goal_points ) )
+	{
+		goal_points = [];
+		goal_points[ 0 ] = goal;
+	}
+	followpath( goal_points, donenotify, stopatgoal );
+}
+
+clearpath( start, end, startnoflyzone, goalnoflyzone )
+{
+	noflyzones = crossesnoflyzones( start, end );
+	i = 0;
+	while ( i < noflyzones.size )
+	{
+		if ( !_shouldignorestartgoalnoflyzone( noflyzones[ i ], startnoflyzone, goalnoflyzone ) )
+		{
+			return 0;
+		}
+		i++;
+	}
+	return 1;
+}
+
+append_array( dst, src )
+{
+	i = 0;
+	while ( i < src.size )
+	{
+		dst[ dst.size ] = src[ i ];
+		i++;
+	}
+}
+
+calculatepath_r( start, end, points, startnoflyzones, goalnoflyzones, depth )
+{
+	depth--;
+
+	if ( depth <= 0 )
+	{
+		points[ points.size ] = end;
+		return points;
+	}
+	noflyzones = crossesnoflyzones( start, end );
+	i = 0;
+	while ( i < noflyzones.size )
+	{
+		noflyzone = noflyzones[ i ];
+		if ( !_shouldignorestartgoalnoflyzone( noflyzone, startnoflyzones, goalnoflyzones ) )
+		{
+			return undefined;
+		}
+		i++;
+	}
+	points[ points.size ] = end;
+	return points;
+}
+
+calculatepath( start, end, startnoflyzones, goalnoflyzones )
+{
+	points = [];
+	points = calculatepath_r( start, end, points, startnoflyzones, goalnoflyzones, 3 );
+	if ( !isDefined( points ) )
+	{
+		return undefined;
+	}
+/#
+	assert( points.size >= 1 );
+#/
+	debug_sphere( points[ points.size - 1 ], 10, ( 1, 1, 1 ), 1, 1000 );
+	point = start;
+	i = 0;
+	while ( i < points.size )
+	{
+		thread debug_line( point, points[ i ], ( 1, 1, 1 ) );
+		debug_sphere( points[ i ], 10, ( 1, 1, 1 ), 1, 1000 );
+		point = points[ i ];
+		i++;
+	}
+	return points;
+}
+
+_getstrikepathstartandend( goal, yaw, halfdistance )
+{
+	direction = ( 0, yaw, 0 );
+	startpoint = goal + vectorScale( anglesToForward( direction ), -1 * halfdistance );
+	endpoint = goal + vectorScale( anglesToForward( direction ), halfdistance );
+	noflyzone = crossesnoflyzone( startpoint, endpoint );
+	path = [];
+	if ( isDefined( noflyzone ) )
+	{
+		path[ "noFlyZone" ] = noflyzone;
+		startpoint = ( startpoint[ 0 ], startpoint[ 1 ], level.noflyzones[ noflyzone ].origin[ 2 ] + level.noflyzones[ noflyzone ].height );
+		endpoint = ( endpoint[ 0 ], endpoint[ 1 ], startpoint[ 2 ] );
+	}
+	else
+	{
+	}
+	path[ "start" ] = startpoint;
+	path[ "end" ] = endpoint;
+	path[ "direction" ] = direction;
+	return path;
+}
+
+getstrikepath( target, height, halfdistance, yaw )
+{
+	noflyzoneheight = getnoflyzoneheight( target );
+	worldheight = target[ 2 ] + height;
+	if ( noflyzoneheight > worldheight )
+	{
+		worldheight = noflyzoneheight;
+	}
+	goal = ( target[ 0 ], target[ 1 ], worldheight );
+	path = [];
+	if ( !isDefined( yaw ) || yaw != "random" )
+	{
+		i = 0;
+		while ( i < 3 )
+		{
+			path = _getstrikepathstartandend( goal, randomint( 360 ), halfdistance );
+			if ( !isDefined( path[ "noFlyZone" ] ) )
+			{
+				break;
+			}
+			else
+			{
+				i++;
+			}
+		}
+	}
+	else path = _getstrikepathstartandend( goal, yaw, halfdistance );
+	path[ "height" ] = worldheight - target[ 2 ];
+	return path;
+}
+
+doglassdamage( pos, radius, max, min, mod )
+{
+	wait randomfloatrange( 0,05, 0,15 );
+	glassradiusdamage( pos, radius, max, min, mod );
+}
+
+entlosradiusdamage( ent, pos, radius, max, min, owner, einflictor )
+{
+	dist = distance( pos, ent.damagecenter );
+	if ( ent.isplayer || ent.isactor )
+	{
+		assumed_ceiling_height = 800;
+		eye_position = ent.entity geteye();
+		head_height = eye_position[ 2 ];
+		debug_display_time = 4000;
+		trace = maps/mp/gametypes/_weapons::weapondamagetrace( ent.entity.origin, ent.entity.origin + ( 0, 0, assumed_ceiling_height ), 0, undefined );
+		indoors = trace[ "fraction" ] != 1;
+		if ( indoors )
+		{
+			test_point = trace[ "position" ];
+			debug_star( test_point, ( 1, 1, 1 ), debug_display_time );
+			trace = maps/mp/gametypes/_weapons::weapondamagetrace( ( test_point[ 0 ], test_point[ 1 ], head_height ), ( pos[ 0 ], pos[ 1 ], head_height ), 0, undefined );
+			indoors = trace[ "fraction" ] != 1;
+			if ( indoors )
+			{
+				debug_star( ( pos[ 0 ], pos[ 1 ], head_height ), ( 1, 1, 1 ), debug_display_time );
+				dist *= 4;
+				if ( dist > radius )
+				{
+					return 0;
+				}
+			}
+			else
+			{
+				debug_star( ( pos[ 0 ], pos[ 1 ], head_height ), ( 1, 1, 1 ), debug_display_time );
+				trace = maps/mp/gametypes/_weapons::weapondamagetrace( ( pos[ 0 ], pos[ 1 ], head_height ), pos, 0, undefined );
+				indoors = trace[ "fraction" ] != 1;
+				if ( indoors )
+				{
+					debug_star( pos, ( 1, 1, 1 ), debug_display_time );
+					dist *= 4;
+					if ( dist > radius )
+					{
+						return 0;
+					}
+				}
+				else
+				{
+					debug_star( pos, ( 1, 1, 1 ), debug_display_time );
+				}
+			}
+		}
+		else
+		{
+			debug_star( ent.entity.origin + ( 0, 0, assumed_ceiling_height ), ( 1, 1, 1 ), debug_display_time );
+		}
+	}
+	ent.damage = int( max + ( ( ( min - max ) * dist ) / radius ) );
+	ent.pos = pos;
+	ent.damageowner = owner;
+	ent.einflictor = einflictor;
+	return 1;
+}
+
+debug_no_fly_zones()
+{
+/#
+	i = 0;
+	while ( i < level.noflyzones.size )
+	{
+		debug_cylinder( level.noflyzones[ i ].origin, level.noflyzones[ i ].radius, level.noflyzones[ i ].height, ( 1, 1, 1 ), undefined, 5000 );
+		i++;
+#/
+	}
+}
+
+debug_plane_line( flytime, flyspeed, pathstart, pathend )
+{
+	thread debug_line( pathstart, pathend, ( 1, 1, 1 ) );
+	delta = vectornormalize( pathend - pathstart );
+	i = 0;
+	while ( i < flytime )
+	{
+		thread debug_star( pathstart + vectorScale( delta, i * flyspeed ), ( 1, 1, 1 ) );
+		i++;
+	}
+}
+
+debug_draw_bomb_explosion( prevpos )
+{
+	self notify( "draw_explosion" );
+	wait 0,05;
+	self endon( "draw_explosion" );
+	self waittill( "projectile_impact", weapon, position );
+	thread debug_line( prevpos, position, ( 0,5, 1, 0 ) );
+	thread debug_star( position, ( 1, 1, 1 ) );
+}
+
+debug_draw_bomb_path( projectile, color, time )
+{
+/#
+	self endon( "death" );
+	level.airsupport_debug = getdvarintdefault( "scr_airsupport_debug", 0 );
+	if ( !isDefined( color ) )
+	{
+		color = ( 0,5, 1, 0 );
+	}
+	while ( isDefined( level.airsupport_debug ) && level.airsupport_debug == 1 )
+	{
+		prevpos = self.origin;
+		while ( isDefined( self.origin ) )
+		{
+			thread debug_line( prevpos, self.origin, color, time );
+			prevpos = self.origin;
+			if ( isDefined( projectile ) && projectile )
+			{
+				thread debug_draw_bomb_explosion( prevpos );
+			}
+			wait 0,2;
+#/
+		}
+	}
+}
+
+debug_print3d_simple( message, ent, offset, frames )
+{
+/#
+	level.airsupport_debug = getdvarintdefault( "scr_airsupport_debug", 0 );
+	if ( isDefined( level.airsupport_debug ) && level.airsupport_debug == 1 )
+	{
+		if ( isDefined( frames ) )
+		{
+			thread draw_text( message, vectorScale( ( 1, 1, 1 ), 0,8 ), ent, offset, frames );
+			return;
+		}
+		else
+		{
+			thread draw_text( message, vectorScale( ( 1, 1, 1 ), 0,8 ), ent, offset, 0 );
+#/
+		}
+	}
+}
+
+draw_text( msg, color, ent, offset, frames )
+{
+/#
+	if ( frames == 0 )
+	{
+		while ( isDefined( ent ) && isDefined( ent.origin ) )
+		{
+			print3d( ent.origin + offset, msg, color, 0,5, 4 );
+			wait 0,05;
+		}
+	}
+	else i = 0;
+	while ( i < frames )
+	{
+		if ( !isDefined( ent ) )
+		{
+			return;
+		}
+		else
+		{
+			print3d( ent.origin + offset, msg, color, 0,5, 4 );
+			wait 0,05;
+			i++;
+#/
+		}
+	}
+}
+
+debug_print3d( message, color, ent, origin_offset, frames )
+{
+/#
+	level.airsupport_debug = getdvarintdefault( "scr_airsupport_debug", 0 );
+	if ( isDefined( level.airsupport_debug ) && level.airsupport_debug == 1 )
+	{
+		self thread draw_text( message, color, ent, origin_offset, frames );
+#/
+	}
+}
+
+debug_line( from, to, color, time, depthtest )
+{
+/#
+	level.airsupport_debug = getdvarintdefault( "scr_airsupport_debug", 0 );
+	if ( isDefined( level.airsupport_debug ) && level.airsupport_debug == 1 )
+	{
+		if ( !isDefined( time ) )
+		{
+			time = 1000;
+		}
+		if ( !isDefined( depthtest ) )
+		{
+			depthtest = 1;
+		}
+		line( from, to, color, 1, depthtest, time );
+#/
+	}
+}
+
+debug_star( origin, color, time )
+{
+/#
+	level.airsupport_debug = getdvarintdefault( "scr_airsupport_debug", 0 );
+	if ( isDefined( level.airsupport_debug ) && level.airsupport_debug == 1 )
+	{
+		if ( !isDefined( time ) )
+		{
+			time = 1000;
+		}
+		if ( !isDefined( color ) )
+		{
+			color = ( 1, 1, 1 );
+		}
+		debugstar( origin, time, color );
+#/
+	}
+}
+
+debug_circle( origin, radius, color, time )
+{
+/#
+	level.airsupport_debug = getdvarintdefault( "scr_airsupport_debug", 0 );
+	if ( isDefined( level.airsupport_debug ) && level.airsupport_debug == 1 )
+	{
+		if ( !isDefined( time ) )
+		{
+			time = 1000;
+		}
+		if ( !isDefined( color ) )
+		{
+			color = ( 1, 1, 1 );
+		}
+		circle( origin, radius, color, 1, 1, time );
+#/
+	}
+}
+
+debug_sphere( origin, radius, color, alpha, time )
+{
+/#
+	level.airsupport_debug = getdvarintdefault( "scr_airsupport_debug", 0 );
+	if ( isDefined( level.airsupport_debug ) && level.airsupport_debug == 1 )
+	{
+		if ( !isDefined( time ) )
+		{
+			time = 1000;
+		}
+		if ( !isDefined( color ) )
+		{
+			color = ( 1, 1, 1 );
+		}
+		sides = int( 10 * ( 1 + int( radius / 100 ) ) );
+		sphere( origin, radius, color, alpha, 1, sides, time );
+#/
+	}
+}
+
+debug_cylinder( origin, radius, height, color, mustrenderheight, time )
+{
+/#
+	level.airsupport_debug = getdvarintdefault( "scr_airsupport_debug", 0 );
+	subdivision = 600;
+	if ( isDefined( level.airsupport_debug ) && level.airsupport_debug == 1 )
+	{
+		if ( !isDefined( time ) )
+		{
+			time = 1000;
+		}
+		if ( !isDefined( color ) )
+		{
+			color = ( 1, 1, 1 );
+		}
+		count = height / subdivision;
+		i = 0;
+		while ( i < count )
+		{
+			point = origin + ( 0, 0, i * subdivision );
+			circle( point, radius, color, 1, 1, time );
+			i++;
+		}
+		if ( isDefined( mustrenderheight ) )
+		{
+			point = origin + ( 0, 0, mustrenderheight );
+			circle( point, radius, color, 1, 1, time );
+#/
+		}
+	}
+}
+
+getpointonline( startpoint, endpoint, ratio )
+{
+	nextpoint = ( startpoint[ 0 ] + ( ( endpoint[ 0 ] - startpoint[ 0 ] ) * ratio ), startpoint[ 1 ] + ( ( endpoint[ 1 ] - startpoint[ 1 ] ) * ratio ), startpoint[ 2 ] + ( ( endpoint[ 2 ] - startpoint[ 2 ] ) * ratio ) );
+	return nextpoint;
+}
+
+cantargetplayerwithspecialty()
+{
+	if ( self hasperk( "specialty_nottargetedbyairsupport" ) || isDefined( self.specialty_nottargetedbyairsupport ) && self.specialty_nottargetedbyairsupport )
+	{
+		if ( !isDefined( self.nottargettedai_underminspeedtimer ) || self.nottargettedai_underminspeedtimer < getDvarInt( "perk_nottargetedbyai_graceperiod" ) )
+		{
+			return 0;
+		}
+	}
+	return 1;
+}
+
+monitorspeed( spawnprotectiontime )
+{
+	self endon( "death" );
+	self endon( "disconnect" );
+	if ( self hasperk( "specialty_nottargetedbyairsupport" ) == 0 )
+	{
+		return;
+	}
+	getDvar( #"B46C7AAF" );
+	graceperiod = getDvarInt( "perk_nottargetedbyai_graceperiod" );
+	minspeed = getDvarInt( "perk_nottargetedbyai_min_speed" );
+	minspeedsq = minspeed * minspeed;
+	waitperiod = 0,25;
+	waitperiodmilliseconds = waitperiod * 1000;
+	if ( minspeedsq == 0 )
+	{
+		return;
+	}
+	self.nottargettedai_underminspeedtimer = 0;
+	if ( isDefined( spawnprotectiontime ) )
+	{
+		wait spawnprotectiontime;
+	}
+	while ( 1 )
+	{
+		velocity = self getvelocity();
+		speedsq = lengthsquared( velocity );
+		if ( speedsq < minspeedsq )
+		{
+			self.nottargettedai_underminspeedtimer += waitperiodmilliseconds;
+		}
+		else
+		{
+			self.nottargettedai_underminspeedtimer = 0;
+		}
+		wait waitperiod;
+	}
+}
+
+clearmonitoredspeed()
+{
+	if ( isDefined( self.nottargettedai_underminspeedtimer ) )
+	{
+		self.nottargettedai_underminspeedtimer = 0;
+	}
+}

patch_mp/maps/mp/killstreaks/_emp.gsc

@@ -0,0 +1,590 @@
+#include maps/mp/killstreaks/_emp;
+#include maps/mp/_tacticalinsertion;
+#include maps/mp/gametypes/_weaponobjects;
+#include maps/mp/gametypes/_hostmigration;
+#include maps/mp/killstreaks/_killstreakrules;
+#include maps/mp/killstreaks/_killstreaks;
+#include common_scripts/utility;
+#include maps/mp/_utility;
+
+init()
+{
+	level._effect[ "emp_flash" ] = loadfx( "weapon/emp/fx_emp_explosion" );
+	_a9 = level.teams;
+	_k9 = getFirstArrayKey( _a9 );
+	while ( isDefined( _k9 ) )
+	{
+		team = _a9[ _k9 ];
+		level.teamemping[ team ] = 0;
+		_k9 = getNextArrayKey( _a9, _k9 );
+	}
+	level.empplayer = undefined;
+	level.emptimeout = 40;
+	level.empowners = [];
+	if ( level.teambased )
+	{
+		level thread emp_teamtracker();
+	}
+	else
+	{
+		level thread emp_playertracker();
+	}
+	level thread onplayerconnect();
+	registerkillstreak( "emp_mp", "emp_mp", "killstreak_emp", "emp_used", ::emp_use );
+	registerkillstreakstrings( "emp_mp", &"KILLSTREAK_EARNED_EMP", &"KILLSTREAK_EMP_NOT_AVAILABLE", &"KILLSTREAK_EMP_INBOUND" );
+	registerkillstreakdialog( "emp_mp", "mpl_killstreak_emp_activate", "kls_emp_used", "", "kls_emp_enemy", "", "kls_emp_ready" );
+	registerkillstreakdevdvar( "emp_mp", "scr_giveemp" );
+	maps/mp/killstreaks/_killstreaks::createkillstreaktimer( "emp_mp" );
+/#
+	set_dvar_float_if_unset( "scr_emp_timeout", 40 );
+	set_dvar_int_if_unset( "scr_emp_damage_debug", 0 );
+#/
+}
+
+onplayerconnect()
+{
+	for ( ;; )
+	{
+		level waittill( "connected", player );
+		player thread onplayerspawned();
+	}
+}
+
+onplayerspawned()
+{
+	self endon( "disconnect" );
+	for ( ;; )
+	{
+		self waittill( "spawned_player" );
+		if ( level.teambased || emp_isteamemped( self.team ) && !level.teambased && isDefined( level.empplayer ) && level.empplayer != self )
+		{
+			self setempjammed( 1 );
+		}
+	}
+}
+
+emp_isteamemped( check_team )
+{
+	_a64 = level.teams;
+	_k64 = getFirstArrayKey( _a64 );
+	while ( isDefined( _k64 ) )
+	{
+		team = _a64[ _k64 ];
+		if ( team == check_team )
+		{
+		}
+		else
+		{
+			if ( level.teamemping[ team ] )
+			{
+				return 1;
+			}
+		}
+		_k64 = getNextArrayKey( _a64, _k64 );
+	}
+	return 0;
+}
+
+emp_use( lifeid )
+{
+/#
+	assert( isDefined( self ) );
+#/
+	killstreak_id = self maps/mp/killstreaks/_killstreakrules::killstreakstart( "emp_mp", self.team, 0, 1 );
+	if ( killstreak_id == -1 )
+	{
+		return 0;
+	}
+	myteam = self.pers[ "team" ];
+	if ( level.teambased )
+	{
+		self thread emp_jamotherteams( myteam, killstreak_id );
+	}
+	else
+	{
+		self thread emp_jamplayers( self, killstreak_id );
+	}
+	self.emptime = getTime();
+	self notify( "used_emp" );
+	self playlocalsound( "mpl_killstreak_emp_activate" );
+	self maps/mp/killstreaks/_killstreaks::playkillstreakstartdialog( "emp_mp", self.pers[ "team" ] );
+	level.globalkillstreakscalled++;
+	self addweaponstat( "emp_mp", "used", 1 );
+	return 1;
+}
+
+emp_jamotherteams( teamname, killstreak_id )
+{
+	level endon( "game_ended" );
+	overlays = [];
+/#
+	assert( isDefined( level.teams[ teamname ] ) );
+#/
+	level notify( "EMP_JamOtherTeams" + teamname );
+	level endon( "EMP_JamOtherTeams" + teamname );
+	level.empowners[ teamname ] = self;
+	_a121 = level.players;
+	_k121 = getFirstArrayKey( _a121 );
+	while ( isDefined( _k121 ) )
+	{
+		player = _a121[ _k121 ];
+		if ( player.team == teamname )
+		{
+		}
+		else
+		{
+			player playlocalsound( "mpl_killstreak_emp_blast_front" );
+		}
+		_k121 = getNextArrayKey( _a121, _k121 );
+	}
+	visionsetnaked( "flash_grenade", 1,5 );
+	thread empeffects();
+	wait 0,1;
+	visionsetnaked( "flash_grenade", 0 );
+	if ( isDefined( level.nukedetonated ) )
+	{
+		visionsetnaked( level.nukevisionset, 5 );
+	}
+	else
+	{
+		visionsetnaked( getDvar( "mapname" ), 5 );
+	}
+	level.teamemping[ teamname ] = 1;
+	level notify( "emp_update" );
+	level destroyotherteamsactivevehicles( self, teamname );
+	level destroyotherteamsequipment( self, teamname );
+/#
+	level.emptimeout = getDvarFloat( #"35E553D4" );
+#/
+	maps/mp/gametypes/_hostmigration::waitlongdurationwithhostmigrationpauseemp( level.emptimeout );
+	level.teamemping[ teamname ] = 0;
+	maps/mp/killstreaks/_killstreakrules::killstreakstop( "emp_mp", teamname, killstreak_id );
+	level notify( "emp_update" );
+	level notify( "emp_end" + teamname );
+}
+
+emp_jamplayers( owner, killstreak_id )
+{
+	level notify( "EMP_JamPlayers" );
+	level endon( "EMP_JamPlayers" );
+	overlays = [];
+/#
+	assert( isDefined( owner ) );
+#/
+	_a180 = level.players;
+	_k180 = getFirstArrayKey( _a180 );
+	while ( isDefined( _k180 ) )
+	{
+		player = _a180[ _k180 ];
+		if ( player == owner )
+		{
+		}
+		else
+		{
+			player playlocalsound( "mpl_killstreak_emp_blast_front" );
+		}
+		_k180 = getNextArrayKey( _a180, _k180 );
+	}
+	visionsetnaked( "flash_grenade", 1,5 );
+	thread empeffects();
+	wait 0,1;
+	visionsetnaked( "flash_grenade", 0 );
+	if ( isDefined( level.nukedetonated ) )
+	{
+		visionsetnaked( level.nukevisionset, 5 );
+	}
+	else
+	{
+		visionsetnaked( getDvar( "mapname" ), 5 );
+	}
+	level notify( "emp_update" );
+	level.empplayer = owner;
+	level.empplayer thread empplayerffadisconnect();
+	level destroyactivevehicles( owner );
+	level destroyequipment( owner );
+	level notify( "emp_update" );
+/#
+	level.emptimeout = getDvarFloat( #"35E553D4" );
+#/
+	maps/mp/gametypes/_hostmigration::waitlongdurationwithhostmigrationpause( level.emptimeout );
+	maps/mp/killstreaks/_killstreakrules::killstreakstop( "emp_mp", level.empplayer.team, killstreak_id );
+	level.empplayer = undefined;
+	level notify( "emp_update" );
+	level notify( "emp_ended" );
+}
+
+empplayerffadisconnect()
+{
+	level endon( "EMP_JamPlayers" );
+	level endon( "emp_ended" );
+	self waittill( "disconnect" );
+	level notify( "emp_update" );
+}
+
+empeffects()
+{
+	_a241 = level.players;
+	_k241 = getFirstArrayKey( _a241 );
+	while ( isDefined( _k241 ) )
+	{
+		player = _a241[ _k241 ];
+		playerforward = anglesToForward( player.angles );
+		playerforward = ( playerforward[ 0 ], playerforward[ 1 ], 0 );
+		playerforward = vectornormalize( playerforward );
+		empdistance = 20000;
+		empent = spawn( "script_model", ( player.origin + vectorScale( ( 0, 0, 1 ), 8000 ) ) + ( playerforward * empdistance ) );
+		empent setmodel( "tag_origin" );
+		empent.angles += vectorScale( ( 0, 0, 1 ), 270 );
+		empent thread empeffect( player );
+		_k241 = getNextArrayKey( _a241, _k241 );
+	}
+}
+
+empeffect( player )
+{
+	player endon( "disconnect" );
+	self setinvisibletoall();
+	self setvisibletoplayer( player );
+	wait 0,5;
+	playfxontag( level._effect[ "emp_flash" ], self, "tag_origin" );
+	self playsound( "wpn_emp_bomb" );
+	self deleteaftertime( 11 );
+}
+
+emp_teamtracker()
+{
+	level endon( "game_ended" );
+	for ( ;; )
+	{
+		level waittill_either( "joined_team", "emp_update" );
+		_a279 = level.players;
+		_k279 = getFirstArrayKey( _a279 );
+		while ( isDefined( _k279 ) )
+		{
+			player = _a279[ _k279 ];
+			if ( player.team == "spectator" )
+			{
+			}
+			else
+			{
+				emped = emp_isteamemped( player.team );
+				player setempjammed( emped );
+				if ( emped )
+				{
+					player notify( "emp_jammed" );
+				}
+			}
+			_k279 = getNextArrayKey( _a279, _k279 );
+		}
+	}
+}
+
+emp_playertracker()
+{
+	level endon( "game_ended" );
+	for ( ;; )
+	{
+		level waittill_either( "joined_team", "emp_update" );
+		_a306 = level.players;
+		_k306 = getFirstArrayKey( _a306 );
+		while ( isDefined( _k306 ) )
+		{
+			player = _a306[ _k306 ];
+			if ( player.team == "spectator" )
+			{
+			}
+			else if ( isDefined( level.empplayer ) && level.empplayer != player )
+			{
+				player setempjammed( 1 );
+				player notify( "emp_jammed" );
+			}
+			else
+			{
+				player setempjammed( 0 );
+			}
+			_k306 = getNextArrayKey( _a306, _k306 );
+		}
+	}
+}
+
+destroyotherteamsequipment( attacker, teamemping )
+{
+	_a328 = level.teams;
+	_k328 = getFirstArrayKey( _a328 );
+	while ( isDefined( _k328 ) )
+	{
+		team = _a328[ _k328 ];
+		if ( team == teamemping )
+		{
+		}
+		else
+		{
+			destroyequipment( attacker, team );
+			destroytacticalinsertions( attacker, team );
+		}
+		_k328 = getNextArrayKey( _a328, _k328 );
+	}
+}
+
+destroyequipment( attacker, teamemped )
+{
+	i = 0;
+	while ( i < level.missileentities.size )
+	{
+		item = level.missileentities[ i ];
+		if ( !isDefined( item.name ) )
+		{
+			i++;
+			continue;
+		}
+		else if ( !isDefined( item.owner ) )
+		{
+			i++;
+			continue;
+		}
+		else if ( isDefined( teamemped ) && item.owner.team != teamemped )
+		{
+			i++;
+			continue;
+		}
+		else if ( item.owner == attacker )
+		{
+			i++;
+			continue;
+		}
+		else if ( !isweaponequipment( item.name ) && item.name != "proximity_grenade_mp" )
+		{
+			i++;
+			continue;
+		}
+		else
+		{
+			watcher = item.owner getwatcherforweapon( item.name );
+			if ( !isDefined( watcher ) )
+			{
+				i++;
+				continue;
+			}
+			else
+			{
+				watcher thread maps/mp/gametypes/_weaponobjects::waitanddetonate( item, 0, attacker, "emp_mp" );
+			}
+		}
+		i++;
+	}
+}
+
+destroytacticalinsertions( attacker, victimteam )
+{
+	i = 0;
+	while ( i < level.players.size )
+	{
+		player = level.players[ i ];
+		if ( !isDefined( player.tacticalinsertion ) )
+		{
+			i++;
+			continue;
+		}
+		else if ( level.teambased && player.team != victimteam )
+		{
+			i++;
+			continue;
+		}
+		else
+		{
+			if ( attacker == player )
+			{
+				i++;
+				continue;
+			}
+			else
+			{
+				player.tacticalinsertion thread maps/mp/_tacticalinsertion::fizzle();
+			}
+		}
+		i++;
+	}
+}
+
+getwatcherforweapon( weapname )
+{
+	if ( !isDefined( self ) )
+	{
+		return undefined;
+	}
+	if ( !isplayer( self ) )
+	{
+		return undefined;
+	}
+	i = 0;
+	while ( i < self.weaponobjectwatcherarray.size )
+	{
+		if ( self.weaponobjectwatcherarray[ i ].weapon != weapname )
+		{
+			i++;
+			continue;
+		}
+		else
+		{
+			return self.weaponobjectwatcherarray[ i ];
+		}
+		i++;
+	}
+	return undefined;
+}
+
+destroyotherteamsactivevehicles( attacker, teamemping )
+{
+	_a431 = level.teams;
+	_k431 = getFirstArrayKey( _a431 );
+	while ( isDefined( _k431 ) )
+	{
+		team = _a431[ _k431 ];
+		if ( team == teamemping )
+		{
+		}
+		else
+		{
+			destroyactivevehicles( attacker, team );
+		}
+		_k431 = getNextArrayKey( _a431, _k431 );
+	}
+}
+
+destroyactivevehicles( attacker, teamemped )
+{
+	turrets = getentarray( "auto_turret", "classname" );
+	destroyentities( turrets, attacker, teamemped );
+	targets = target_getarray();
+	destroyentities( targets, attacker, teamemped );
+	rcbombs = getentarray( "rcbomb", "targetname" );
+	destroyentities( rcbombs, attacker, teamemped );
+	remotemissiles = getentarray( "remote_missile", "targetname" );
+	destroyentities( remotemissiles, attacker, teamemped );
+	remotedrone = getentarray( "remote_drone", "targetname" );
+	destroyentities( remotedrone, attacker, teamemped );
+	planemortars = getentarray( "plane_mortar", "targetname" );
+	_a458 = planemortars;
+	_k458 = getFirstArrayKey( _a458 );
+	while ( isDefined( _k458 ) )
+	{
+		planemortar = _a458[ _k458 ];
+		if ( isDefined( teamemped ) && isDefined( planemortar.team ) )
+		{
+			if ( planemortar.team != teamemped )
+			{
+			}
+			else }
+		else if ( planemortar.owner == attacker )
+		{
+		}
+		else
+		{
+			planemortar notify( "emp_deployed" );
+		}
+		_k458 = getNextArrayKey( _a458, _k458 );
+	}
+	satellites = getentarray( "satellite", "targetname" );
+	_a477 = satellites;
+	_k477 = getFirstArrayKey( _a477 );
+	while ( isDefined( _k477 ) )
+	{
+		satellite = _a477[ _k477 ];
+		if ( isDefined( teamemped ) && isDefined( satellite.team ) )
+		{
+			if ( satellite.team != teamemped )
+			{
+			}
+			else }
+		else if ( satellite.owner == attacker )
+		{
+		}
+		else
+		{
+			satellite notify( "emp_deployed" );
+		}
+		_k477 = getNextArrayKey( _a477, _k477 );
+	}
+	if ( isDefined( level.missile_swarm_owner ) )
+	{
+		if ( level.missile_swarm_owner isenemyplayer( attacker ) )
+		{
+			level.missile_swarm_owner notify( "emp_destroyed_missile_swarm" );
+		}
+	}
+}
+
+destroyentities( entities, attacker, team )
+{
+	meansofdeath = "MOD_EXPLOSIVE";
+	weapon = "killstreak_emp_mp";
+	damage = 5000;
+	direction_vec = ( 0, 0, 1 );
+	point = ( 0, 0, 1 );
+	modelname = "";
+	tagname = "";
+	partname = "";
+	_a515 = entities;
+	_k515 = getFirstArrayKey( _a515 );
+	while ( isDefined( _k515 ) )
+	{
+		entity = _a515[ _k515 ];
+		if ( isDefined( team ) && isDefined( entity.team ) )
+		{
+			if ( entity.team != team )
+			{
+			}
+			else }
+		else if ( entity.owner == attacker )
+		{
+		}
+		else
+		{
+			entity notify( "damage" );
+		}
+		_k515 = getNextArrayKey( _a515, _k515 );
+	}
+}
+
+drawempdamageorigin( pos, ang, radius )
+{
+/#
+	while ( getDvarInt( #"D04570F2" ) )
+	{
+		line( pos, pos + ( anglesToForward( ang ) * radius ), ( 0, 0, 1 ) );
+		line( pos, pos + ( anglesToRight( ang ) * radius ), ( 0, 0, 1 ) );
+		line( pos, pos + ( anglesToUp( ang ) * radius ), ( 0, 0, 1 ) );
+		line( pos, pos - ( anglesToForward( ang ) * radius ), ( 0, 0, 1 ) );
+		line( pos, pos - ( anglesToRight( ang ) * radius ), ( 0, 0, 1 ) );
+		line( pos, pos - ( anglesToUp( ang ) * radius ), ( 0, 0, 1 ) );
+		wait 0,05;
+#/
+	}
+}
+
+isenemyempkillstreakactive()
+{
+	if ( level.teambased || maps/mp/killstreaks/_emp::emp_isteamemped( self.team ) && !level.teambased && isDefined( level.empplayer ) && level.empplayer != self )
+	{
+		return 1;
+	}
+	return 0;
+}
+
+isempweapon( weaponname )
+{
+	if ( isDefined( weaponname ) && weaponname != "emp_mp" || weaponname == "emp_grenade_mp" && weaponname == "emp_grenade_zm" )
+	{
+		return 1;
+	}
+	return 0;
+}
+
+isempkillstreakweapon( weaponname )
+{
+	if ( isDefined( weaponname ) && weaponname == "emp_mp" )
+	{
+		return 1;
+	}
+	return 0;
+}

patch_mp/maps/mp/killstreaks/_helicopter_guard.gsc

@@ -0,0 +1,796 @@
+#include maps/mp/gametypes/_hostmigration;
+#include maps/mp/_heatseekingmissile;
+#include maps/mp/gametypes/_spawning;
+#include maps/mp/killstreaks/_helicopter;
+#include maps/mp/killstreaks/_killstreakrules;
+#include maps/mp/killstreaks/_airsupport;
+#include maps/mp/killstreaks/_killstreaks;
+#include common_scripts/utility;
+#include maps/mp/_utility;
+
+init()
+{
+	precachestring( &"MP_CIVILIAN_AIR_TRAFFIC" );
+	precachestring( &"MP_AIR_SPACE_TOO_CROWDED" );
+	precachevehicle( "heli_guard_mp" );
+	precachemodel( "veh_t6_drone_overwatch_light" );
+	precachemodel( "veh_t6_drone_overwatch_dark" );
+	precacheturret( "littlebird_guard_minigun_mp" );
+	precachemodel( "veh_iw_littlebird_minigun_left" );
+	precachemodel( "veh_iw_littlebird_minigun_right" );
+	registerkillstreak( "helicopter_guard_mp", "helicopter_guard_mp", "killstreak_helicopter_guard", "helicopter_used", ::tryuseheliguardsupport, 1 );
+	registerkillstreakaltweapon( "helicopter_guard_mp", "littlebird_guard_minigun_mp" );
+	registerkillstreakstrings( "helicopter_guard_mp", &"KILLSTREAK_EARNED_HELICOPTER_GUARD", &"KILLSTREAK_HELICOPTER_GUARD_NOT_AVAILABLE", &"KILLSTREAK_HELICOPTER_GUARD_INBOUND" );
+	registerkillstreakdialog( "helicopter_guard_mp", "mpl_killstreak_lbguard_strt", "kls_littlebird_used", "", "kls_littlebird_enemy", "", "kls_littlebird_ready" );
+	registerkillstreakdevdvar( "helicopter_guard_mp", "scr_givehelicopterguard" );
+	setkillstreakteamkillpenaltyscale( "helicopter_guard_mp", 0 );
+	shouldtimeout = setdvar( "scr_heli_guard_no_timeout", 0 );
+	debuglittlebird = setdvar( "scr_heli_guard_debug", 0 );
+	level._effect[ "heli_guard_light" ][ "friendly" ] = loadfx( "light/fx_vlight_mp_escort_eye_grn" );
+	level._effect[ "heli_guard_light" ][ "enemy" ] = loadfx( "light/fx_vlight_mp_escort_eye_red" );
+/#
+	set_dvar_float_if_unset( "scr_lbguard_timeout", 60 );
+#/
+	level.heliguardflyovernfz = 0;
+	if ( level.script == "mp_hydro" )
+	{
+		level.heliguardflyovernfz = 1;
+	}
+}
+
+register()
+{
+	registerclientfield( "helicopter", "vehicle_is_firing", 1, 1, "int" );
+}
+
+tryuseheliguardsupport( lifeid )
+{
+	if ( isDefined( level.civilianjetflyby ) )
+	{
+		self iprintlnbold( &"MP_CIVILIAN_AIR_TRAFFIC" );
+		return 0;
+	}
+	if ( self isremotecontrolling() )
+	{
+		return 0;
+	}
+	if ( !isDefined( level.heli_paths ) || level.heli_paths.size <= 0 )
+	{
+		self iprintlnbold( &"MP_UNAVAILABLE_IN_LEVEL" );
+		return 0;
+	}
+	killstreak_id = self maps/mp/killstreaks/_killstreakrules::killstreakstart( "helicopter_guard_mp", self.team, 0, 1 );
+	if ( killstreak_id == -1 )
+	{
+		return 0;
+	}
+	heliguard = createheliguardsupport( lifeid, killstreak_id );
+	if ( !isDefined( heliguard ) )
+	{
+		return 0;
+	}
+	self thread startheliguardsupport( heliguard, lifeid );
+	return 1;
+}
+
+createheliguardsupport( lifeid, killstreak_id )
+{
+	hardpointtype = "helicopter_guard_mp";
+	closeststartnode = heliguardsupport_getcloseststartnode( self.origin );
+	if ( isDefined( closeststartnode.angles ) )
+	{
+		startang = closeststartnode.angles;
+	}
+	else
+	{
+		startang = ( 0, 0, 1 );
+	}
+	closestnode = heliguardsupport_getclosestnode( self.origin );
+	flyheight = max( self.origin[ 2 ] + 1600, getnoflyzoneheight( self.origin ) );
+	forward = anglesToForward( self.angles );
+	targetpos = ( ( self.origin * ( 0, 0, 1 ) ) + ( ( 0, 0, 1 ) * flyheight ) ) + ( forward * -100 );
+	startpos = closeststartnode.origin;
+	heliguard = spawnhelicopter( self, startpos, startang, "heli_guard_mp", "veh_t6_drone_overwatch_light" );
+	if ( !isDefined( heliguard ) )
+	{
+		return;
+	}
+	target_set( heliguard, vectorScale( ( 0, 0, 1 ), 50 ) );
+	heliguard setenemymodel( "veh_t6_drone_overwatch_dark" );
+	heliguard.speed = 150;
+	heliguard.followspeed = 40;
+	heliguard setcandamage( 1 );
+	heliguard.owner = self;
+	heliguard.team = self.team;
+	heliguard setmaxpitchroll( 45, 45 );
+	heliguard setspeed( heliguard.speed, 100, 40 );
+	heliguard setyawspeed( 120, 60 );
+	heliguard setneargoalnotifydist( 512 );
+	heliguard thread heliguardsupport_attacktargets();
+	heliguard.killcount = 0;
+	heliguard.streakname = "littlebird_support";
+	heliguard.helitype = "littlebird";
+	heliguard.targettingradius = 2000;
+	heliguard.targetpos = targetpos;
+	heliguard.currentnode = closestnode;
+	heliguard.attract_strength = 10000;
+	heliguard.attract_range = 150;
+	heliguard.attractor = missile_createattractorent( heliguard, heliguard.attract_strength, heliguard.attract_range );
+	heliguard.health = 999999;
+	heliguard.maxhealth = level.heli_maxhealth;
+	heliguard.rocketdamageoneshot = heliguard.maxhealth + 1;
+	heliguard.crashtype = "explode";
+	heliguard.destroyfunc = ::lbexplode;
+	heliguard.targeting_delay = level.heli_targeting_delay;
+	heliguard.hasdodged = 0;
+	heliguard setdrawinfrared( 1 );
+	self thread maps/mp/killstreaks/_helicopter::announcehelicopterinbound( hardpointtype );
+	heliguard thread maps/mp/killstreaks/_helicopter::heli_targeting( 0, hardpointtype );
+	heliguard thread maps/mp/killstreaks/_helicopter::heli_damage_monitor( hardpointtype );
+	heliguard thread maps/mp/killstreaks/_helicopter::heli_kill_monitor( hardpointtype );
+	heliguard thread maps/mp/killstreaks/_helicopter::heli_health( hardpointtype, self, undefined );
+	heliguard maps/mp/gametypes/_spawning::create_helicopter_influencers( heliguard.team );
+	heliguard thread heliguardsupport_watchtimeout();
+	heliguard thread heliguardsupport_watchownerloss();
+	heliguard thread heliguardsupport_watchownerdamage();
+	heliguard thread heliguardsupport_watchroundend();
+	heliguard.numflares = 1;
+	heliguard.flareoffset = ( 0, 0, 1 );
+	heliguard thread maps/mp/_heatseekingmissile::missiletarget_proximitydetonateincomingmissile( "explode", "death" );
+	heliguard thread create_flare_ent( vectorScale( ( 0, 0, 1 ), 50 ) );
+	heliguard.killstreak_id = killstreak_id;
+	level.littlebirdguard = heliguard;
+	return heliguard;
+}
+
+getmeshheight( littlebird, owner )
+{
+	if ( !owner isinsideheightlock() )
+	{
+		return maps/mp/killstreaks/_airsupport::getminimumflyheight();
+	}
+	maxmeshheight = littlebird getheliheightlockheight( owner.origin );
+	return max( maxmeshheight, owner.origin[ 2 ] );
+}
+
+startheliguardsupport( littlebird, lifeid )
+{
+	level endon( "game_ended" );
+	littlebird endon( "death" );
+	littlebird setlookatent( self );
+	maxmeshheight = getmeshheight( littlebird, self );
+	height = getnoflyzoneheight( ( self.origin[ 0 ], self.origin[ 1 ], maxmeshheight ) );
+	playermeshorigin = ( self.origin[ 0 ], self.origin[ 1 ], height );
+	vectostart = vectornormalize( littlebird.origin - littlebird.targetpos );
+	dist = 1500;
+	target = littlebird.targetpos + ( vectostart * dist );
+	collide = crossesnoflyzone( target, playermeshorigin );
+	while ( isDefined( collide ) && dist > 0 )
+	{
+		dist -= 500;
+		target = littlebird.targetpos + ( vectostart * dist );
+		collide = crossesnoflyzone( target, playermeshorigin );
+	}
+	littlebird setvehgoalpos( target, 1 );
+	target_setturretaquire( littlebird, 0 );
+	littlebird waittill( "near_goal" );
+	target_setturretaquire( littlebird, 1 );
+	littlebird setvehgoalpos( playermeshorigin, 1 );
+	littlebird waittill( "near_goal" );
+	littlebird setspeed( littlebird.speed, 80, 30 );
+	littlebird waittill( "goal" );
+/#
+	if ( getDvar( "scr_heli_guard_debug" ) == "1" )
+	{
+		debug_no_fly_zones();
+#/
+	}
+	littlebird thread heliguardsupport_followplayer();
+}
+
+heliguardsupport_followplayer()
+{
+	level endon( "game_ended" );
+	self endon( "death" );
+	self endon( "leaving" );
+	if ( !isDefined( self.owner ) )
+	{
+		self thread heliguardsupport_leave();
+		return;
+	}
+	self.owner endon( "disconnect" );
+	self.owner endon( "joined_team" );
+	self.owner endon( "joined_spectators" );
+	self setspeed( self.followspeed, 20, 20 );
+	while ( 1 )
+	{
+		if ( isDefined( self.owner ) && isalive( self.owner ) )
+		{
+			heliguardsupport_movetoplayer();
+		}
+		wait 3;
+	}
+}
+
+heliguardsupport_movetoplayer()
+{
+	level endon( "game_ended" );
+	self endon( "death" );
+	self endon( "leaving" );
+	self.owner endon( "death" );
+	self.owner endon( "disconnect" );
+	self.owner endon( "joined_team" );
+	self.owner endon( "joined_spectators" );
+	self notify( "heliGuardSupport_moveToPlayer" );
+	self endon( "heliGuardSupport_moveToPlayer" );
+	maxmeshheight = getmeshheight( self, self.owner );
+	hovergoal = ( self.owner.origin[ 0 ], self.owner.origin[ 1 ], maxmeshheight );
+/#
+	littlebird_debug_line( self.origin, hovergoal, ( 0, 0, 1 ) );
+#/
+	zoneindex = crossesnoflyzone( self.origin, hovergoal );
+	if ( isDefined( zoneindex ) && level.heliguardflyovernfz )
+	{
+		self.intransit = 1;
+		noflyzoneheight = getnoflyzoneheightcrossed( hovergoal, self.origin, maxmeshheight );
+		self setvehgoalpos( ( hovergoal[ 0 ], hovergoal[ 1 ], noflyzoneheight ), 1 );
+		self waittill( "goal" );
+		return;
+	}
+	if ( isDefined( zoneindex ) )
+	{
+/#
+		littlebird_debug_text( "NO FLY ZONE between heli and hoverGoal" );
+#/
+		dist = distance2d( self.owner.origin, level.noflyzones[ zoneindex ].origin );
+		zoneorgtoplayer2d = self.owner.origin - level.noflyzones[ zoneindex ].origin;
+		zoneorgtoplayer2d *= ( 0, 0, 1 );
+		zoneorgtochopper2d = self.origin - level.noflyzones[ zoneindex ].origin;
+		zoneorgtochopper2d *= ( 0, 0, 1 );
+		zoneorgatmeshheight = ( level.noflyzones[ zoneindex ].origin[ 0 ], level.noflyzones[ zoneindex ].origin[ 1 ], maxmeshheight );
+		zoneorgtoadjpos = vectorScale( vectornormalize( zoneorgtoplayer2d ), level.noflyzones[ zoneindex ].radius + 150 );
+		adjacentgoalpos = zoneorgtoadjpos + level.noflyzones[ zoneindex ].origin;
+		adjacentgoalpos = ( adjacentgoalpos[ 0 ], adjacentgoalpos[ 1 ], maxmeshheight );
+		zoneorgtoperpendicular = ( zoneorgtoadjpos[ 1 ], zoneorgtoadjpos[ 0 ] * -1, 0 );
+		zoneorgtooppositeperpendicular = ( zoneorgtoadjpos[ 1 ] * -1, zoneorgtoadjpos[ 0 ], 0 );
+		perpendiculargoalpos = zoneorgtoperpendicular + zoneorgatmeshheight;
+		oppositeperpendiculargoalpos = zoneorgtooppositeperpendicular + zoneorgatmeshheight;
+/#
+		littlebird_debug_line( self.origin, perpendiculargoalpos, ( 0, 0, 1 ) );
+		littlebird_debug_line( self.origin, oppositeperpendiculargoalpos, ( 0,2, 0,6, 1 ) );
+#/
+		if ( dist < level.noflyzones[ zoneindex ].radius )
+		{
+/#
+			littlebird_debug_text( "Owner is in a no fly zone, find perimeter hover goal" );
+			littlebird_debug_line( self.origin, adjacentgoalpos, ( 0, 0, 1 ) );
+#/
+			zoneindex = undefined;
+			zoneindex = crossesnoflyzone( self.origin, adjacentgoalpos );
+			if ( isDefined( zoneindex ) )
+			{
+/#
+				littlebird_debug_text( "adjacentGoalPos is through no fly zone, move to perpendicular edge of cyl" );
+#/
+				hovergoal = perpendiculargoalpos;
+			}
+			else
+			{
+/#
+				littlebird_debug_text( "adjacentGoalPos is NOT through fly zone, move to edge closest to player" );
+#/
+				hovergoal = adjacentgoalpos;
+			}
+		}
+		else
+		{
+/#
+			littlebird_debug_text( "Owner outside no fly zone, navigate around perimeter" );
+			littlebird_debug_line( self.origin, perpendiculargoalpos, ( 0, 0, 1 ) );
+#/
+			hovergoal = perpendiculargoalpos;
+		}
+	}
+	zoneindex = undefined;
+	zoneindex = crossesnoflyzone( self.origin, hovergoal );
+	if ( isDefined( zoneindex ) )
+	{
+/#
+		littlebird_debug_text( "Try opposite perimeter goal" );
+#/
+		hovergoal = oppositeperpendiculargoalpos;
+	}
+	self.intransit = 1;
+	self setvehgoalpos( ( hovergoal[ 0 ], hovergoal[ 1 ], maxmeshheight ), 1 );
+	self waittill( "goal" );
+}
+
+heliguardsupport_movetoplayervertical( maxmeshheight )
+{
+	height = getnoflyzoneheightcrossed( self.origin, self.owner.origin, maxmeshheight );
+	upperheight = max( self.origin[ 2 ], height );
+	acquireupperheight = ( self.origin[ 0 ], self.origin[ 1 ], upperheight );
+	hoveroverplayer = ( self.owner.origin[ 0 ], self.owner.origin[ 1 ], upperheight );
+	hovercorrectheight = ( self.owner.origin[ 0 ], self.owner.origin[ 1 ], height );
+	self.intransit = 1;
+	self setvehgoalpos( acquireupperheight, 1 );
+	self waittill( "goal" );
+	self setvehgoalpos( hoveroverplayer, 1 );
+	self waittill( "goal" );
+	self setvehgoalpos( hovercorrectheight, 1 );
+	self waittill( "goal" );
+	self.intransit = 0;
+}
+
+heliguardsupport_watchtimeout()
+{
+	level endon( "game_ended" );
+	self endon( "death" );
+	self.owner endon( "disconnect" );
+	self.owner endon( "joined_team" );
+	self.owner endon( "joined_spectators" );
+	timeout = 60;
+/#
+	timeout = getDvarFloat( #"E449EBB3" );
+#/
+	maps/mp/gametypes/_hostmigration::waitlongdurationwithhostmigrationpause( timeout );
+	shouldtimeout = getDvar( "scr_heli_guard_no_timeout" );
+	if ( shouldtimeout == "1" )
+	{
+		return;
+	}
+	self thread heliguardsupport_leave();
+}
+
+heliguardsupport_watchownerloss()
+{
+	level endon( "game_ended" );
+	self endon( "death" );
+	self endon( "leaving" );
+	self.owner waittill_any( "disconnect", "joined_team", "joined_spectators" );
+	self thread heliguardsupport_leave();
+}
+
+heliguardsupport_watchownerdamage()
+{
+	level endon( "game_ended" );
+	self endon( "death" );
+	self endon( "leaving" );
+	self.owner endon( "disconnect" );
+	self.owner endon( "joined_team" );
+	self.owner endon( "joined_spectators" );
+	while ( 1 )
+	{
+		self.owner waittill( "damage", damage, attacker, direction_vec, point, meansofdeath, modelname, tagname, partname, weapon, idflags );
+		if ( isplayer( attacker ) )
+		{
+			if ( attacker != self.owner && distance2d( attacker.origin, self.origin ) <= self.targettingradius && attacker cantargetplayerwithspecialty() )
+			{
+				self setlookatent( attacker );
+				self setgunnertargetent( attacker, vectorScale( ( 0, 0, 1 ), 50 ), 0 );
+				self setturrettargetent( attacker, vectorScale( ( 0, 0, 1 ), 50 ) );
+			}
+		}
+	}
+}
+
+heliguardsupport_watchroundend()
+{
+	level endon( "game_ended" );
+	self endon( "death" );
+	self endon( "leaving" );
+	self.owner endon( "disconnect" );
+	self.owner endon( "joined_team" );
+	self.owner endon( "joined_spectators" );
+	level waittill( "round_end_finished" );
+	self thread heliguardsupport_leave();
+}
+
+heliguardsupport_leave()
+{
+	self endon( "death" );
+	self notify( "leaving" );
+	level.littlebirdguard = undefined;
+	self cleargunnertarget( 0 );
+	self clearturrettarget();
+	self clearlookatent();
+	flyheight = getnoflyzoneheight( self.origin );
+	targetpos = self.origin + ( anglesToForward( self.angles ) * 1500 ) + ( 0, 0, flyheight );
+	collide = crossesnoflyzone( self.origin, targetpos );
+	tries = 5;
+	while ( isDefined( collide ) && tries > 0 )
+	{
+		yaw = randomint( 360 );
+		targetpos = self.origin + ( anglesToForward( ( self.angles[ 0 ], yaw, self.angles[ 2 ] ) ) * 1500 ) + ( 0, 0, flyheight );
+		collide = crossesnoflyzone( self.origin, targetpos );
+		tries--;
+
+	}
+	if ( tries == 0 )
+	{
+		targetpos = self.origin + ( 0, 0, flyheight );
+	}
+	self setspeed( self.speed, 80 );
+	self setmaxpitchroll( 45, 180 );
+	self setvehgoalpos( targetpos );
+	self waittill( "goal" );
+	targetpos += anglesToForward( ( 0, self.angles[ 1 ], self.angles[ 2 ] ) ) * 14000;
+	self setvehgoalpos( targetpos );
+	self waittill( "goal" );
+	self notify( "gone" );
+	self removelittlebird();
+}
+
+helidestroyed()
+{
+	level.littlebirdguard = undefined;
+	if ( !isDefined( self ) )
+	{
+		return;
+	}
+	self setspeed( 25, 5 );
+	self thread lbspin( randomintrange( 180, 220 ) );
+	wait randomfloatrange( 0,5, 1,5 );
+	lbexplode();
+}
+
+lbexplode()
+{
+	self notify( "explode" );
+	self removelittlebird();
+}
+
+lbspin( speed )
+{
+	self endon( "explode" );
+	playfxontag( level.chopper_fx[ "explode" ][ "large" ], self, "tail_rotor_jnt" );
+	self thread trail_fx( level.chopper_fx[ "smoke" ][ "trail" ], "tail_rotor_jnt", "stop tail smoke" );
+	self setyawspeed( speed, speed, speed );
+	while ( isDefined( self ) )
+	{
+		self settargetyaw( self.angles[ 1 ] + ( speed * 0,9 ) );
+		wait 1;
+	}
+}
+
+trail_fx( trail_fx, trail_tag, stop_notify )
+{
+	self notify( stop_notify );
+	self endon( stop_notify );
+	self endon( "death" );
+	for ( ;; )
+	{
+		playfxontag( trail_fx, self, trail_tag );
+		wait 0,05;
+	}
+}
+
+removelittlebird()
+{
+	level.lbstrike = 0;
+	maps/mp/killstreaks/_killstreakrules::killstreakstop( "helicopter_guard_mp", self.team, self.killstreak_id );
+	if ( isDefined( self.marker ) )
+	{
+		self.marker delete();
+	}
+	self delete();
+}
+
+heliguardsupport_watchsamproximity( player, missileteam, missiletarget, missilegroup )
+{
+	level endon( "game_ended" );
+	missiletarget endon( "death" );
+	i = 0;
+	while ( i < missilegroup.size )
+	{
+		if ( isDefined( missilegroup[ i ] ) && !missiletarget.hasdodged )
+		{
+			missiletarget.hasdodged = 1;
+			newtarget = spawn( "script_origin", missiletarget.origin );
+			newtarget.angles = missiletarget.angles;
+			newtarget movegravity( anglesToRight( missilegroup[ i ].angles ) * -1000, 0,05 );
+			j = 0;
+			while ( j < missilegroup.size )
+			{
+				if ( isDefined( missilegroup[ j ] ) )
+				{
+					missilegroup[ j ] settargetentity( newtarget );
+				}
+				j++;
+			}
+			dodgepoint = missiletarget.origin + ( anglesToRight( missilegroup[ i ].angles ) * 200 );
+			missiletarget setspeed( missiletarget.speed, 100, 40 );
+			missiletarget setvehgoalpos( dodgepoint, 1 );
+			wait 2;
+			missiletarget setspeed( missiletarget.followspeed, 20, 20 );
+			return;
+		}
+		else
+		{
+			i++;
+		}
+	}
+}
+
+heliguardsupport_getcloseststartnode( pos )
+{
+	closestnode = undefined;
+	closestdistance = 999999;
+	_a645 = level.heli_paths;
+	_k645 = getFirstArrayKey( _a645 );
+	while ( isDefined( _k645 ) )
+	{
+		path = _a645[ _k645 ];
+		_a647 = path;
+		_k647 = getFirstArrayKey( _a647 );
+		while ( isDefined( _k647 ) )
+		{
+			loc = _a647[ _k647 ];
+			nodedistance = distance( loc.origin, pos );
+			if ( nodedistance < closestdistance )
+			{
+				closestnode = loc;
+				closestdistance = nodedistance;
+			}
+			_k647 = getNextArrayKey( _a647, _k647 );
+		}
+		_k645 = getNextArrayKey( _a645, _k645 );
+	}
+	return closestnode;
+}
+
+heliguardsupport_getclosestnode( pos )
+{
+	closestnode = undefined;
+	closestdistance = 999999;
+	_a667 = level.heli_loop_paths;
+	_k667 = getFirstArrayKey( _a667 );
+	while ( isDefined( _k667 ) )
+	{
+		loc = _a667[ _k667 ];
+		nodedistance = distance( loc.origin, pos );
+		if ( nodedistance < closestdistance )
+		{
+			closestnode = loc;
+			closestdistance = nodedistance;
+		}
+		_k667 = getNextArrayKey( _a667, _k667 );
+	}
+	return closestnode;
+}
+
+littlebird_debug_text( string )
+{
+/#
+	if ( getDvar( "scr_heli_guard_debug" ) == "1" )
+	{
+		iprintln( string );
+#/
+	}
+}
+
+littlebird_debug_line( start, end, color )
+{
+/#
+	if ( getDvar( "scr_heli_guard_debug" ) == "1" )
+	{
+		line( start, end, color, 1, 1, 300 );
+#/
+	}
+}
+
+heli_path_debug()
+{
+/#
+	_a703 = level.heli_paths;
+	_k703 = getFirstArrayKey( _a703 );
+	while ( isDefined( _k703 ) )
+	{
+		path = _a703[ _k703 ];
+		_a705 = path;
+		_k705 = getFirstArrayKey( _a705 );
+		while ( isDefined( _k705 ) )
+		{
+			loc = _a705[ _k705 ];
+			prev = loc;
+			target = loc.target;
+			while ( isDefined( target ) )
+			{
+				target = getent( target, "targetname" );
+				line( prev.origin, target.origin, ( 0, 0, 1 ), 1, 0, 50000 );
+				debugstar( prev.origin, 50000, ( 0, 0, 1 ) );
+				prev = target;
+				target = prev.target;
+			}
+			_k705 = getNextArrayKey( _a705, _k705 );
+		}
+		_k703 = getNextArrayKey( _a703, _k703 );
+	}
+	_a722 = level.heli_loop_paths;
+	_k722 = getFirstArrayKey( _a722 );
+	while ( isDefined( _k722 ) )
+	{
+		loc = _a722[ _k722 ];
+		prev = loc;
+		target = loc.target;
+		first = loc;
+		while ( isDefined( target ) )
+		{
+			target = getent( target, "targetname" );
+			line( prev.origin, target.origin, ( 0, 0, 1 ), 1, 0, 50000 );
+			debugstar( prev.origin, 50000, ( 0, 0, 1 ) );
+			prev = target;
+			target = prev.target;
+			if ( prev == first )
+			{
+				break;
+			}
+			else
+			{
+			}
+		}
+		_k722 = getNextArrayKey( _a722, _k722 );
+#/
+	}
+}
+
+heliguardsupport_getclosestlinkednode( pos )
+{
+	closestnode = undefined;
+	totaldistance = distance2d( self.currentnode.origin, pos );
+	closestdistance = totaldistance;
+	target = self.currentnode.target;
+	while ( isDefined( target ) )
+	{
+		nextnode = getent( target, "targetname" );
+		if ( nextnode == self.currentnode )
+		{
+			break;
+		}
+		else
+		{
+			nodedistance = distance2d( nextnode.origin, pos );
+			if ( nodedistance < totaldistance && nodedistance < closestdistance )
+			{
+				closestnode = nextnode;
+				closestdistance = nodedistance;
+			}
+			target = nextnode.target;
+		}
+	}
+	return closestnode;
+}
+
+heliguardsupport_arraycontains( array, compare )
+{
+	if ( array.size <= 0 )
+	{
+		return 0;
+	}
+	_a783 = array;
+	_k783 = getFirstArrayKey( _a783 );
+	while ( isDefined( _k783 ) )
+	{
+		member = _a783[ _k783 ];
+		if ( member == compare )
+		{
+			return 1;
+		}
+		_k783 = getNextArrayKey( _a783, _k783 );
+	}
+	return 0;
+}
+
+heliguardsupport_getlinkedstructs()
+{
+	array = [];
+	return array;
+}
+
+heliguardsupport_setairstartnodes()
+{
+	level.air_start_nodes = getstructarray( "chopper_boss_path_start", "targetname" );
+	_a817 = level.air_start_nodes;
+	_k817 = getFirstArrayKey( _a817 );
+	while ( isDefined( _k817 ) )
+	{
+		loc = _a817[ _k817 ];
+		loc.neighbors = loc heliguardsupport_getlinkedstructs();
+		_k817 = getNextArrayKey( _a817, _k817 );
+	}
+}
+
+heliguardsupport_setairnodemesh()
+{
+	level.air_node_mesh = getstructarray( "so_chopper_boss_path_struct", "script_noteworthy" );
+	_a828 = level.air_node_mesh;
+	_k828 = getFirstArrayKey( _a828 );
+	while ( isDefined( _k828 ) )
+	{
+		loc = _a828[ _k828 ];
+		loc.neighbors = loc heliguardsupport_getlinkedstructs();
+		_a835 = level.air_node_mesh;
+		_k835 = getFirstArrayKey( _a835 );
+		while ( isDefined( _k835 ) )
+		{
+			other_loc = _a835[ _k835 ];
+			if ( loc == other_loc )
+			{
+			}
+			else
+			{
+				if ( !heliguardsupport_arraycontains( loc.neighbors, other_loc ) && heliguardsupport_arraycontains( other_loc heliguardsupport_getlinkedstructs(), loc ) )
+				{
+					loc.neighbors[ loc.neighbors.size ] = other_loc;
+				}
+			}
+			_k835 = getNextArrayKey( _a835, _k835 );
+		}
+		_k828 = getNextArrayKey( _a828, _k828 );
+	}
+}
+
+heliguardsupport_attacktargets()
+{
+	self endon( "death" );
+	level endon( "game_ended" );
+	self endon( "leaving" );
+	for ( ;; )
+	{
+		self heliguardsupport_firestart();
+	}
+}
+
+heliguardsupport_firestart()
+{
+	self endon( "death" );
+	self endon( "leaving" );
+	self endon( "stop_shooting" );
+	level endon( "game_ended" );
+	for ( ;; )
+	{
+		numshots = randomintrange( 10, 21 );
+		if ( !isDefined( self.primarytarget ) )
+		{
+			self waittill( "primary acquired" );
+		}
+		while ( isDefined( self.primarytarget ) )
+		{
+			targetent = self.primarytarget;
+			self thread heliguardsupport_firestop( targetent );
+			self setlookatent( targetent );
+			self setgunnertargetent( targetent, vectorScale( ( 0, 0, 1 ), 50 ), 0 );
+			self setturrettargetent( targetent, vectorScale( ( 0, 0, 1 ), 50 ) );
+			self waittill( "turret_on_target" );
+			wait 0,2;
+			self setclientfield( "vehicle_is_firing", 1 );
+			i = 0;
+			while ( i < numshots )
+			{
+				self firegunnerweapon( 0, self );
+				self fireweapon();
+				wait 0,15;
+				i++;
+			}
+		}
+		self setclientfield( "vehicle_is_firing", 0 );
+		self clearturrettarget();
+		self cleargunnertarget( 0 );
+		wait randomfloatrange( 1, 2 );
+	}
+}
+
+heliguardsupport_firestop( targetent )
+{
+	self endon( "death" );
+	self endon( "leaving" );
+	self notify( "heli_guard_target_death_watcher" );
+	self endon( "heli_guard_target_death_watcher" );
+	targetent waittill_any( "death", "disconnect" );
+	self setclientfield( "vehicle_is_firing", 0 );
+	self notify( "stop_shooting" );
+	self.primarytarget = undefined;
+	self setlookatent( self.owner );
+	self cleargunnertarget( 0 );
+	self clearturrettarget();
+}

patch_mp/maps/mp/killstreaks/_killstreak_weapons.gsc

@@ -0,0 +1,633 @@
+#include maps/mp/gametypes/_class;
+#include maps/mp/_popups;
+#include maps/mp/gametypes/_weapons;
+#include maps/mp/killstreaks/_killstreakrules;
+#include maps/mp/killstreaks/_supplydrop;
+#include maps/mp/gametypes/_globallogic_utils;
+#include maps/mp/killstreaks/_killstreaks;
+#include maps/mp/gametypes/_hud_util;
+#include maps/mp/_utility;
+#include common_scripts/utility;
+
+init()
+{
+	precacheshader( "hud_ks_minigun" );
+	precacheshader( "hud_ks_m32" );
+	maps/mp/killstreaks/_killstreaks::registerkillstreak( "inventory_minigun_mp", "inventory_minigun_mp", "killstreak_minigun", "minigun_used", ::usecarriedkillstreakweapon, 0, 1, "MINIGUN_USED" );
+	maps/mp/killstreaks/_killstreaks::registerkillstreakstrings( "inventory_minigun_mp", &"KILLSTREAK_EARNED_MINIGUN", &"KILLSTREAK_MINIGUN_NOT_AVAILABLE", &"KILLSTREAK_MINIGUN_INBOUND" );
+	maps/mp/killstreaks/_killstreaks::registerkillstreakdialog( "inventory_minigun_mp", "mpl_killstreak_minigun", "kls_death_used", "", "kls_death_enemy", "", "kls_death_ready" );
+	maps/mp/killstreaks/_killstreaks::registerkillstreakdevdvar( "inventory_minigun_mp", "scr_giveminigun_drop" );
+	maps/mp/killstreaks/_killstreaks::registerkillstreak( "minigun_mp", "minigun_mp", "killstreak_minigun", "minigun_used", ::usecarriedkillstreakweapon, 0, 1, "MINIGUN_USED" );
+	maps/mp/killstreaks/_killstreaks::registerkillstreakstrings( "minigun_mp", &"KILLSTREAK_EARNED_MINIGUN", &"KILLSTREAK_MINIGUN_NOT_AVAILABLE", &"KILLSTREAK_MINIGUN_INBOUND" );
+	maps/mp/killstreaks/_killstreaks::registerkillstreakdialog( "minigun_mp", "mpl_killstreak_minigun", "kls_death_used", "", "kls_death_enemy", "", "kls_death_ready" );
+	maps/mp/killstreaks/_killstreaks::registerkillstreak( "inventory_m32_mp", "inventory_m32_mp", "killstreak_m32", "m32_used", ::usecarriedkillstreakweapon, 0, 1, "M32_USED" );
+	maps/mp/killstreaks/_killstreaks::registerkillstreakstrings( "inventory_m32_mp", &"KILLSTREAK_EARNED_M32", &"KILLSTREAK_M32_NOT_AVAILABLE", &"KILLSTREAK_M32_INBOUND" );
+	maps/mp/killstreaks/_killstreaks::registerkillstreakdialog( "inventory_m32_mp", "mpl_killstreak_m32", "kls_mgl_used", "", "kls_mgl_enemy", "", "kls_mgl_ready" );
+	maps/mp/killstreaks/_killstreaks::registerkillstreakdevdvar( "inventory_m32_mp", "scr_givem32_drop" );
+	maps/mp/killstreaks/_killstreaks::overrideentitycameraindemo( "inventory_m32_mp", 1 );
+	maps/mp/killstreaks/_killstreaks::registerkillstreak( "m32_mp", "m32_mp", "killstreak_m32", "m32_used", ::usecarriedkillstreakweapon, 0, 1, "M32_USED" );
+	maps/mp/killstreaks/_killstreaks::registerkillstreakstrings( "m32_mp", &"KILLSTREAK_EARNED_M32", &"KILLSTREAK_M32_NOT_AVAILABLE", &"KILLSTREAK_M32_INBOUND" );
+	maps/mp/killstreaks/_killstreaks::registerkillstreakdialog( "m32_mp", "mpl_killstreak_m32", "kls_mgl_used", "", "kls_mgl_enemy", "", "kls_mgl_ready" );
+	maps/mp/killstreaks/_killstreaks::overrideentitycameraindemo( "m32_mp", 1 );
+	level.killstreakicons[ "killstreak_minigun" ] = "hud_ks_minigun";
+	level.killstreakicons[ "killstreak_m32" ] = "hud_ks_m32";
+	level.killstreakicons[ "killstreak_m202_flash_mp" ] = "hud_ks_m202";
+	level.killstreakicons[ "killstreak_m220_tow_drop_mp" ] = "hud_ks_tv_guided_marker";
+	level.killstreakicons[ "killstreak_m220_tow_mp" ] = "hud_ks_tv_guided_missile";
+	level thread onplayerconnect();
+	setdvar( "scr_HeldKillstreak_Penalty", 0 );
+}
+
+onplayerconnect()
+{
+	for ( ;; )
+	{
+		level waittill( "connecting", player );
+		player thread onplayerspawned();
+	}
+}
+
+onplayerspawned()
+{
+	self endon( "disconnect" );
+	for ( ;; )
+	{
+		self waittill( "spawned_player" );
+		self.firedkillstreakweapon = 0;
+		self.usingkillstreakheldweapon = undefined;
+		if ( !isfirstround() && !isoneround() )
+		{
+			if ( level.roundstartkillstreakdelay > ( maps/mp/gametypes/_globallogic_utils::gettimepassed() / 1000 ) )
+			{
+				self thread watchkillstreakweapondelay();
+			}
+		}
+	}
+}
+
+watchkillstreakweapondelay()
+{
+	self endon( "disconnect" );
+	self endon( "death" );
+	while ( 1 )
+	{
+		currentweapon = self getcurrentweapon();
+		self waittill( "weapon_change", newweapon );
+		if ( level.roundstartkillstreakdelay < ( maps/mp/gametypes/_globallogic_utils::gettimepassed() / 1000 ) )
+		{
+			return;
+		}
+		while ( !maps/mp/killstreaks/_killstreaks::iskillstreakweapon( newweapon ) )
+		{
+			wait 0,5;
+		}
+		if ( maps/mp/killstreaks/_killstreaks::isdelayablekillstreak( newweapon ) && isheldkillstreakweapon( newweapon ) )
+		{
+			timeleft = int( level.roundstartkillstreakdelay - ( maps/mp/gametypes/_globallogic_utils::gettimepassed() / 1000 ) );
+			if ( !timeleft )
+			{
+				timeleft = 1;
+			}
+			self iprintlnbold( &"MP_UNAVAILABLE_FOR_N", " " + timeleft + " ", &"EXE_SECONDS" );
+			self switchtoweapon( currentweapon );
+			wait 0,5;
+		}
+	}
+}
+
+usekillstreakweapondrop( hardpointtype )
+{
+	if ( self maps/mp/killstreaks/_supplydrop::issupplydropgrenadeallowed( hardpointtype ) == 0 )
+	{
+		return 0;
+	}
+	result = self maps/mp/killstreaks/_supplydrop::usesupplydropmarker();
+	self notify( "supply_drop_marker_done" );
+	if ( !isDefined( result ) || !result )
+	{
+		return 0;
+	}
+	return result;
+}
+
+usecarriedkillstreakweapon( hardpointtype )
+{
+	if ( self maps/mp/killstreaks/_killstreakrules::iskillstreakallowed( hardpointtype, self.team ) == 0 )
+	{
+		self switchtoweapon( self.lastdroppableweapon );
+		return 0;
+	}
+	if ( !isDefined( hardpointtype ) )
+	{
+		return 0;
+	}
+	currentweapon = self getcurrentweapon();
+	if ( hardpointtype == "none" )
+	{
+		return 0;
+	}
+	level maps/mp/gametypes/_weapons::addlimitedweapon( hardpointtype, self, 3 );
+	if ( issubstr( hardpointtype, "inventory" ) )
+	{
+		isfrominventory = 1;
+	}
+	else
+	{
+		isfrominventory = 0;
+	}
+	currentammo = self getammocount( hardpointtype );
+	if ( hardpointtype != "minigun_mp" && hardpointtype == "inventory_minigun_mp" && isDefined( self.minigunstart ) || self.minigunstart == 0 && hardpointtype != "m32_mp" && hardpointtype == "inventory_m32_mp" || !isDefined( self.m32start ) && self.m32start == 0 )
+	{
+		if ( hardpointtype == "minigun_mp" || hardpointtype == "inventory_minigun_mp" )
+		{
+			self.minigunstart = 1;
+		}
+		else
+		{
+			self.m32start = 1;
+		}
+		self maps/mp/killstreaks/_killstreaks::playkillstreakstartdialog( hardpointtype, self.team, 1 );
+		level.globalkillstreakscalled++;
+		self addweaponstat( hardpointtype, "used", 1 );
+		level thread maps/mp/_popups::displayteammessagetoall( level.killstreaks[ hardpointtype ].inboundtext, self );
+		if ( weaponclipsize( hardpointtype ) > currentammo )
+		{
+		}
+		else
+		{
+		}
+		self.pers[ "held_killstreak_clip_count" ][ hardpointtype ] = weaponclipsize( hardpointtype );
+		if ( isfrominventory == 0 )
+		{
+			if ( self.pers[ "killstreak_quantity" ][ hardpointtype ] > 0 )
+			{
+				ammopool = weaponmaxammo( hardpointtype );
+			}
+			else
+			{
+				ammopool = self.pers[ "held_killstreak_ammo_count" ][ hardpointtype ];
+			}
+			self setweaponammoclip( hardpointtype, self.pers[ "held_killstreak_clip_count" ][ hardpointtype ] );
+			self setweaponammostock( hardpointtype, ammopool - self.pers[ "held_killstreak_clip_count" ][ hardpointtype ] );
+		}
+	}
+	if ( hardpointtype == "minigun_mp" || hardpointtype == "inventory_minigun_mp" )
+	{
+		if ( !isDefined( self.minigunactive ) || !self.minigunactive )
+		{
+			killstreak_id = self maps/mp/killstreaks/_killstreakrules::killstreakstart( hardpointtype, self.team, 0, 0 );
+			if ( hardpointtype == "inventory_minigun_mp" )
+			{
+				killstreak_id = self.pers[ "killstreak_unique_id" ][ self.pers[ "killstreak_unique_id" ].size - 1 ];
+			}
+			self.minigunid = killstreak_id;
+			self.minigunactive = 1;
+		}
+		else
+		{
+			killstreak_id = self.minigunid;
+		}
+	}
+	else
+	{
+		if ( !isDefined( self.m32active ) || !self.m32active )
+		{
+			killstreak_id = self maps/mp/killstreaks/_killstreakrules::killstreakstart( hardpointtype, self.team, 0, 0 );
+			if ( hardpointtype == "inventory_m32_mp" )
+			{
+				killstreak_id = self.pers[ "killstreak_unique_id" ][ self.pers[ "killstreak_unique_id" ].size - 1 ];
+			}
+			self.m32id = killstreak_id;
+			self.m32active = 1;
+		}
+		else
+		{
+			killstreak_id = self.m32id;
+		}
+	}
+/#
+	assert( killstreak_id != -1 );
+#/
+	self.firedkillstreakweapon = 0;
+	self setblockweaponpickup( hardpointtype, 1 );
+	if ( isfrominventory )
+	{
+		self setweaponammoclip( hardpointtype, self.pers[ "held_killstreak_clip_count" ][ hardpointtype ] );
+		self setweaponammostock( hardpointtype, self.pers[ "killstreak_ammo_count" ][ self.pers[ "killstreak_ammo_count" ].size - 1 ] - self.pers[ "held_killstreak_clip_count" ][ hardpointtype ] );
+	}
+	notifystring = "killstreakWeapon_" + hardpointtype;
+	self notify( notifystring );
+	self thread watchkillstreakweaponswitch( hardpointtype, killstreak_id, isfrominventory );
+	self thread watchkillstreakweapondeath( hardpointtype, killstreak_id, isfrominventory );
+	self thread watchkillstreakroundchange( isfrominventory, killstreak_id );
+	self thread watchplayerdeath( hardpointtype );
+	if ( isfrominventory )
+	{
+		self thread watchkillstreakremoval( hardpointtype, killstreak_id );
+	}
+	self.usingkillstreakheldweapon = 1;
+	return 0;
+}
+
+usekillstreakweaponfromcrate( hardpointtype )
+{
+	if ( !isDefined( hardpointtype ) )
+	{
+		return 0;
+	}
+	if ( hardpointtype == "none" )
+	{
+		return 0;
+	}
+	self.firedkillstreakweapon = 0;
+	self setblockweaponpickup( hardpointtype, 1 );
+	killstreak_id = self maps/mp/killstreaks/_killstreakrules::killstreakstart( hardpointtype, self.team, 0, 0 );
+/#
+	assert( killstreak_id != -1 );
+#/
+	if ( issubstr( hardpointtype, "inventory" ) )
+	{
+		isfrominventory = 1;
+	}
+	else
+	{
+		isfrominventory = 0;
+	}
+	self thread watchkillstreakweaponswitch( hardpointtype, killstreak_id, isfrominventory );
+	self thread watchkillstreakweapondeath( hardpointtype, killstreak_id, isfrominventory );
+	if ( isfrominventory )
+	{
+		self thread watchkillstreakremoval( hardpointtype, killstreak_id );
+	}
+	self.usingkillstreakheldweapon = 1;
+	return 1;
+}
+
+watchkillstreakweaponswitch( killstreakweapon, killstreak_id, isfrominventory )
+{
+	self endon( "disconnect" );
+	self endon( "death" );
+	while ( 1 )
+	{
+		currentweapon = self getcurrentweapon();
+		self waittill( "weapon_change", newweapon );
+		while ( level.infinalkillcam )
+		{
+			continue;
+		}
+		while ( newweapon == "none" )
+		{
+			continue;
+		}
+		currentammo = self getammocount( killstreakweapon );
+		currentammoinclip = self getweaponammoclip( killstreakweapon );
+		if ( isfrominventory && currentammo > 0 )
+		{
+			killstreakindex = self maps/mp/killstreaks/_killstreaks::getkillstreakindexbyid( killstreak_id );
+			if ( isDefined( killstreakindex ) )
+			{
+				self.pers[ "killstreak_ammo_count" ][ killstreakindex ] = currentammo;
+				self.pers[ "held_killstreak_clip_count" ][ killstreakweapon ] = currentammoinclip;
+			}
+		}
+		if ( maps/mp/killstreaks/_killstreaks::iskillstreakweapon( newweapon ) && !isheldkillstreakweapon( newweapon ) )
+		{
+			continue;
+		}
+		while ( isgameplayweapon( newweapon ) )
+		{
+			continue;
+		}
+		if ( isheldkillstreakweapon( newweapon ) && newweapon == self.lastnonkillstreakweapon )
+		{
+			continue;
+		}
+		killstreakid = maps/mp/killstreaks/_killstreaks::gettopkillstreakuniqueid();
+		self.pers[ "held_killstreak_ammo_count" ][ killstreakweapon ] = currentammo;
+		self.pers[ "held_killstreak_clip_count" ][ killstreakweapon ] = currentammoinclip;
+		if ( killstreak_id != -1 )
+		{
+			self notify( "killstreak_weapon_switch" );
+		}
+		self.firedkillstreakweapon = 0;
+		self.usingkillstreakheldweapon = undefined;
+		waittillframeend;
+		if ( currentammo != 0 || self.pers[ "killstreak_quantity" ][ killstreakweapon ] > 0 && isfrominventory && isDefined( killstreakid ) && killstreakid != killstreak_id )
+		{
+			maps/mp/killstreaks/_killstreakrules::killstreakstop( killstreakweapon, self.team, killstreak_id );
+			if ( killstreakweapon == "minigun_mp" || killstreakweapon == "inventory_minigun_mp" )
+			{
+				self.minigunstart = 0;
+				self.minigunactive = 0;
+			}
+			else
+			{
+				self.m32start = 0;
+				self.m32active = 0;
+			}
+			if ( self.pers[ "killstreak_quantity" ][ killstreakweapon ] > 0 )
+			{
+				self.pers[ "held_killstreak_ammo_count" ][ killstreakweapon ] = weaponmaxammo( killstreakweapon );
+				self maps/mp/gametypes/_class::setweaponammooverall( killstreakweapon, self.pers[ "held_killstreak_ammo_count" ][ killstreakweapon ] );
+				self.pers[ "killstreak_quantity" ][ killstreakweapon ]--;
+
+			}
+		}
+		if ( isfrominventory && currentammo == 0 )
+		{
+			self takeweapon( killstreakweapon );
+			self maps/mp/killstreaks/_killstreaks::removeusedkillstreak( killstreakweapon, killstreak_id );
+			self maps/mp/killstreaks/_killstreaks::activatenextkillstreak();
+		}
+		return;
+	}
+}
+
+watchkillstreakweapondeath( hardpointtype, killstreak_id, isfrominventory )
+{
+	self endon( "disconnect" );
+	self endon( "killstreak_weapon_switch" );
+	if ( killstreak_id == -1 )
+	{
+		return;
+	}
+	oldteam = self.team;
+	self waittill( "death" );
+	penalty = getdvarfloatdefault( "scr_HeldKillstreak_Penalty", 0,5 );
+	maxammo = weaponmaxammo( hardpointtype );
+	currentammo = self getammocount( hardpointtype );
+	currentammoinclip = self getweaponammoclip( hardpointtype );
+	if ( self.pers[ "killstreak_quantity" ].size == 0 )
+	{
+		currentammo = 0;
+		currentammoinclip = 0;
+	}
+	maxclipsize = weaponclipsize( hardpointtype );
+	newammo = int( currentammo - ( maxammo * penalty ) );
+	killstreakid = maps/mp/killstreaks/_killstreaks::gettopkillstreakuniqueid();
+	if ( self.lastnonkillstreakweapon == hardpointtype )
+	{
+		if ( newammo < 0 )
+		{
+			self.pers[ "held_killstreak_ammo_count" ][ hardpointtype ] = 0;
+			self.pers[ "held_killstreak_clip_count" ][ hardpointtype ] = 0;
+		}
+		else
+		{
+			self.pers[ "held_killstreak_ammo_count" ][ hardpointtype ] = newammo;
+			if ( maxclipsize <= newammo )
+			{
+			}
+			else
+			{
+			}
+			self.pers[ "held_killstreak_clip_count" ][ hardpointtype ] = newammo;
+		}
+	}
+	self.usingkillstreakheldweapon = 0;
+	if ( newammo <= 0 || self.pers[ "killstreak_quantity" ][ hardpointtype ] > 0 && isfrominventory && isDefined( killstreakid ) && killstreakid != killstreak_id )
+	{
+		maps/mp/killstreaks/_killstreakrules::killstreakstop( hardpointtype, oldteam, killstreak_id );
+		if ( hardpointtype == "minigun_mp" || hardpointtype == "inventory_minigun_mp" )
+		{
+			self.minigunstart = 0;
+			self.minigunactive = 0;
+		}
+		else
+		{
+			self.m32start = 0;
+			self.m32active = 0;
+		}
+		if ( isDefined( self.pers[ "killstreak_quantity" ][ hardpointtype ] ) && self.pers[ "killstreak_quantity" ][ hardpointtype ] > 0 )
+		{
+			self.pers[ "held_killstreak_ammo_count" ][ hardpointtype ] = maxammo;
+			self.pers[ "held_killstreak_clip_count" ][ hardpointtype ] = maxclipsize;
+			self setweaponammoclip( hardpointtype, self.pers[ "held_killstreak_clip_count" ][ hardpointtype ] );
+			self setweaponammostock( hardpointtype, self.pers[ "held_killstreak_ammo_count" ][ hardpointtype ] - self.pers[ "held_killstreak_clip_count" ][ hardpointtype ] );
+			self.pers[ "killstreak_quantity" ][ hardpointtype ]--;
+
+		}
+	}
+	if ( isfrominventory && newammo <= 0 )
+	{
+		self takeweapon( hardpointtype );
+		self maps/mp/killstreaks/_killstreaks::removeusedkillstreak( hardpointtype, killstreak_id );
+		self maps/mp/killstreaks/_killstreaks::activatenextkillstreak();
+	}
+	else
+	{
+		if ( isfrominventory )
+		{
+			killstreakindex = self maps/mp/killstreaks/_killstreaks::getkillstreakindexbyid( killstreak_id );
+			if ( isDefined( killstreakindex ) )
+			{
+				self.pers[ "killstreak_ammo_count" ][ killstreakindex ] = self.pers[ "held_killstreak_ammo_count" ][ hardpointtype ];
+			}
+		}
+	}
+	return;
+}
+
+watchplayerdeath( killstreakweapon )
+{
+	self endon( "disconnect" );
+	endonweaponstring = "killstreakWeapon_" + killstreakweapon;
+	self endon( endonweaponstring );
+	self waittill( "death" );
+	currentammo = self getammocount( killstreakweapon );
+	if ( weaponclipsize( killstreakweapon ) <= currentammo )
+	{
+	}
+	else
+	{
+	}
+	self.pers[ "held_killstreak_clip_count" ][ killstreakweapon ] = currentammo;
+}
+
+watchkillstreakremoval( killstreakweapon, killstreak_id )
+{
+	self endon( "disconnect" );
+	self endon( "death" );
+	self endon( "killstreak_weapon_switch" );
+	self waittill( "oldest_killstreak_removed", removedkillstreakweapon, removed_id );
+	if ( killstreakweapon == removedkillstreakweapon && killstreak_id == removed_id )
+	{
+		if ( removedkillstreakweapon == "inventory_minigun_mp" )
+		{
+			self.minigunstart = 0;
+			self.minigunactive = 0;
+			return;
+		}
+		else
+		{
+			self.m32start = 0;
+			self.m32active = 0;
+		}
+	}
+}
+
+watchkillstreakroundchange( isfrominventory, killstreak_id )
+{
+	self endon( "disconnect" );
+	self endon( "death" );
+	self endon( "killstreak_weapon_switch" );
+	self waittill( "round_ended" );
+	currentweapon = self getcurrentweapon();
+	if ( !isheldkillstreakweapon( currentweapon ) )
+	{
+		return;
+	}
+	currentammo = self getammocount( currentweapon );
+	maxclipsize = weaponclipsize( currentweapon );
+	if ( isfrominventory && currentammo > 0 )
+	{
+		killstreakindex = self maps/mp/killstreaks/_killstreaks::getkillstreakindexbyid( killstreak_id );
+		if ( isDefined( killstreakindex ) )
+		{
+			self.pers[ "killstreak_ammo_count" ][ killstreakindex ] = currentammo;
+			if ( maxclipsize <= currentammo )
+			{
+			}
+			else
+			{
+			}
+			self.pers[ "held_killstreak_clip_count" ][ currentweapon ] = currentammo;
+		}
+	}
+	else
+	{
+		self.pers[ "held_killstreak_ammo_count" ][ currentweapon ] = currentammo;
+		if ( maxclipsize <= currentammo )
+		{
+		}
+		else
+		{
+		}
+		self.pers[ "held_killstreak_clip_count" ][ currentweapon ] = currentammo;
+	}
+}
+
+checkifswitchableweapon( currentweapon, newweapon, killstreakweapon, currentkillstreakid )
+{
+	switchableweapon = 1;
+	topkillstreak = maps/mp/killstreaks/_killstreaks::gettopkillstreak();
+	killstreakid = maps/mp/killstreaks/_killstreaks::gettopkillstreakuniqueid();
+	if ( !isDefined( killstreakid ) )
+	{
+		killstreakid = -1;
+	}
+	if ( self hasweapon( killstreakweapon ) && !self getammocount( killstreakweapon ) )
+	{
+		switchableweapon = 1;
+	}
+	else
+	{
+		if ( self.firedkillstreakweapon && newweapon == killstreakweapon && isheldkillstreakweapon( currentweapon ) )
+		{
+			switchableweapon = 1;
+		}
+		else
+		{
+			if ( isweaponequipment( newweapon ) )
+			{
+				switchableweapon = 1;
+			}
+			else if ( isDefined( level.grenade_array[ newweapon ] ) )
+			{
+				switchableweapon = 0;
+			}
+			else if ( isheldkillstreakweapon( newweapon ) && isheldkillstreakweapon( currentweapon ) || !isDefined( currentkillstreakid ) && currentkillstreakid != killstreakid )
+			{
+				switchableweapon = 1;
+			}
+			else
+			{
+				if ( maps/mp/killstreaks/_killstreaks::iskillstreakweapon( newweapon ) )
+				{
+					switchableweapon = 0;
+				}
+				else if ( isgameplayweapon( newweapon ) )
+				{
+					switchableweapon = 0;
+				}
+				else if ( self.firedkillstreakweapon )
+				{
+					switchableweapon = 1;
+				}
+				else if ( self.lastnonkillstreakweapon == killstreakweapon )
+				{
+					switchableweapon = 0;
+				}
+				else
+				{
+					if ( isDefined( topkillstreak ) && topkillstreak == killstreakweapon && currentkillstreakid == killstreakid )
+					{
+						switchableweapon = 0;
+					}
+				}
+			}
+		}
+	}
+	return switchableweapon;
+}
+
+watchkillstreakweaponusage()
+{
+	self endon( "disconnect" );
+	self endon( "death" );
+	while ( 1 )
+	{
+		self waittill( "weapon_fired", killstreakweapon );
+		while ( !isheldkillstreakweapon( killstreakweapon ) )
+		{
+			wait 0,1;
+		}
+		while ( self.firedkillstreakweapon )
+		{
+			continue;
+		}
+		maps/mp/killstreaks/_killstreaks::removeusedkillstreak( killstreakweapon );
+		self.firedkillstreakweapon = 1;
+		self setactionslot( 4, "" );
+		waittillframeend;
+		maps/mp/killstreaks/_killstreaks::activatenextkillstreak();
+	}
+}
+
+isheldkillstreakweapon( killstreaktype )
+{
+	switch( killstreaktype )
+	{
+		case "inventory_m32_mp":
+		case "inventory_minigun_mp":
+		case "m32_mp":
+		case "minigun_mp":
+			return 1;
+	}
+	return 0;
+}
+
+isheldinventorykillstreakweapon( killstreaktype )
+{
+	switch( killstreaktype )
+	{
+		case "inventory_m32_mp":
+		case "inventory_minigun_mp":
+			return 1;
+	}
+	return 0;
+}
+
+isgameplayweapon( weapon )
+{
+	switch( weapon )
+	{
+		case "briefcase_bomb_defuse_mp":
+		case "briefcase_bomb_mp":
+		case "syrette_mp":
+			return 1;
+		default:
+			return 0;
+	}
+	return 0;
+}

patch_mp/maps/mp/killstreaks/_killstreakrules.gsc

@@ -0,0 +1,415 @@
+#include maps/mp/killstreaks/_emp;
+#include maps/mp/_popups;
+#include common_scripts/utility;
+#include maps/mp/gametypes/_hud_util;
+#include maps/mp/_utility;
+
+init()
+{
+	level.killstreakrules = [];
+	level.killstreaktype = [];
+	level.killstreaks_triggered = [];
+	level.killstreak_counter = 0;
+	createrule( "vehicle", 7, 7 );
+	createrule( "firesupport", 1, 1 );
+	createrule( "airsupport", 1, 1 );
+	createrule( "playercontrolledchopper", 1, 1 );
+	createrule( "chopperInTheAir", 1, 1 );
+	createrule( "chopper", 2, 1 );
+	createrule( "qrdrone", 3, 2 );
+	createrule( "dogs", 1, 1 );
+	createrule( "turret", 8, 4 );
+	createrule( "weapon", 12, 6 );
+	createrule( "satellite", 20, 10 );
+	createrule( "supplydrop", 4, 4 );
+	createrule( "rcxd", 3, 2 );
+	createrule( "targetableent", 32, 32 );
+	createrule( "missileswarm", 1, 1 );
+	createrule( "radar", 20, 10 );
+	createrule( "counteruav", 20, 10 );
+	createrule( "emp", 2, 1 );
+	createrule( "ai_tank", 4, 2 );
+	createrule( "straferun", 1, 1 );
+	createrule( "planemortar", 1, 1 );
+	createrule( "remotemortar", 1, 1 );
+	createrule( "missiledrone", 3, 3 );
+	addkillstreaktorule( "helicopter_mp", "vehicle", 1, 1 );
+	addkillstreaktorule( "helicopter_mp", "chopper", 1, 1 );
+	addkillstreaktorule( "helicopter_mp", "playercontrolledchopper", 0, 1 );
+	addkillstreaktorule( "helicopter_mp", "chopperInTheAir", 1, 0 );
+	addkillstreaktorule( "helicopter_mp", "targetableent", 1, 1 );
+	addkillstreaktorule( "helicopter_x2_mp", "vehicle", 1, 1 );
+	addkillstreaktorule( "helicopter_x2_mp", "chopper", 1, 1 );
+	addkillstreaktorule( "helicopter_x2_mp", "playercontrolledchopper", 0, 1 );
+	addkillstreaktorule( "helicopter_x2_mp", "chopperInTheAir", 1, 0 );
+	addkillstreaktorule( "helicopter_x2_mp", "targetableent", 1, 1 );
+	addkillstreaktorule( "helicopter_comlink_mp", "vehicle", 1, 1 );
+	addkillstreaktorule( "helicopter_comlink_mp", "chopper", 1, 1 );
+	addkillstreaktorule( "helicopter_comlink_mp", "playercontrolledchopper", 0, 1 );
+	addkillstreaktorule( "helicopter_comlink_mp", "chopperInTheAir", 1, 0 );
+	addkillstreaktorule( "helicopter_comlink_mp", "targetableent", 1, 1 );
+	addkillstreaktorule( "helicopter_player_firstperson_mp", "vehicle", 1, 1 );
+	addkillstreaktorule( "helicopter_player_firstperson_mp", "playercontrolledchopper", 1, 1 );
+	addkillstreaktorule( "helicopter_player_firstperson_mp", "chopperInTheAir", 1, 1 );
+	addkillstreaktorule( "helicopter_player_firstperson_mp", "targetableent", 1, 1 );
+	addkillstreaktorule( "helicopter_guard_mp", "airsupport", 1, 1 );
+	addkillstreaktorule( "helicopter_gunner_mp", "vehicle", 1, 1 );
+	addkillstreaktorule( "helicopter_gunner_mp", "playercontrolledchopper", 1, 1 );
+	addkillstreaktorule( "helicopter_gunner_mp", "chopperInTheAir", 1, 1 );
+	addkillstreaktorule( "helicopter_gunner_mp", "targetableent", 1, 1 );
+	addkillstreaktorule( "helicopter_player_gunner_mp", "vehicle", 1, 1 );
+	addkillstreaktorule( "helicopter_player_gunner_mp", "playercontrolledchopper", 1, 1 );
+	addkillstreaktorule( "helicopter_player_gunner_mp", "chopperInTheAir", 1, 1 );
+	addkillstreaktorule( "helicopter_player_gunner_mp", "targetableent", 1, 1 );
+	addkillstreaktorule( "rcbomb_mp", "rcxd", 1, 1 );
+	addkillstreaktorule( "supply_drop_mp", "vehicle", 1, 1 );
+	addkillstreaktorule( "supply_drop_mp", "supplydrop", 1, 1 );
+	addkillstreaktorule( "supply_drop_mp", "targetableent", 1, 1 );
+	addkillstreaktorule( "supply_station_mp", "vehicle", 1, 1 );
+	addkillstreaktorule( "inventory_supply_drop_mp", "vehicle", 1, 1 );
+	addkillstreaktorule( "inventory_supply_drop_mp", "supplydrop", 1, 1 );
+	addkillstreaktorule( "inventory_supply_drop_mp", "targetableent", 1, 1 );
+	addkillstreaktorule( "supply_station_mp", "supplydrop", 1, 1 );
+	addkillstreaktorule( "supply_station_mp", "targetableent", 1, 1 );
+	addkillstreaktorule( "tow_turret_drop_mp", "vehicle", 1, 1 );
+	addkillstreaktorule( "turret_drop_mp", "vehicle", 1, 1 );
+	addkillstreaktorule( "m220_tow_drop_mp", "vehicle", 1, 1 );
+	addkillstreaktorule( "tow_turret_drop_mp", "supplydrop", 1, 1 );
+	addkillstreaktorule( "turret_drop_mp", "supplydrop", 1, 1 );
+	addkillstreaktorule( "m220_tow_drop_mp", "supplydrop", 1, 1 );
+	addkillstreaktorule( "m220_tow_killstreak_mp", "weapon", 1, 1 );
+	addkillstreaktorule( "autoturret_mp", "turret", 1, 1 );
+	addkillstreaktorule( "auto_tow_mp", "turret", 1, 1 );
+	addkillstreaktorule( "microwaveturret_mp", "turret", 1, 1 );
+	addkillstreaktorule( "minigun_mp", "weapon", 1, 1 );
+	addkillstreaktorule( "minigun_drop_mp", "weapon", 1, 1 );
+	addkillstreaktorule( "inventory_minigun_mp", "weapon", 1, 1 );
+	addkillstreaktorule( "m32_mp", "weapon", 1, 1 );
+	addkillstreaktorule( "m32_drop_mp", "weapon", 1, 1 );
+	addkillstreaktorule( "inventory_m32_mp", "weapon", 1, 1 );
+	addkillstreaktorule( "m202_flash_mp", "weapon", 1, 1 );
+	addkillstreaktorule( "m220_tow_mp", "weapon", 1, 1 );
+	addkillstreaktorule( "mp40_drop_mp", "weapon", 1, 1 );
+	addkillstreaktorule( "dogs_mp", "dogs", 1, 1 );
+	addkillstreaktorule( "dogs_lvl2_mp", "dogs", 1, 1 );
+	addkillstreaktorule( "dogs_lvl3_mp", "dogs", 1, 1 );
+	addkillstreaktorule( "artillery_mp", "firesupport", 1, 1 );
+	addkillstreaktorule( "mortar_mp", "firesupport", 1, 1 );
+	addkillstreaktorule( "napalm_mp", "vehicle", 1, 1 );
+	addkillstreaktorule( "napalm_mp", "airsupport", 1, 1 );
+	addkillstreaktorule( "airstrike_mp", "vehicle", 1, 1 );
+	addkillstreaktorule( "airstrike_mp", "airsupport", 1, 1 );
+	addkillstreaktorule( "radardirection_mp", "satellite", 1, 1 );
+	addkillstreaktorule( "radar_mp", "radar", 1, 1 );
+	addkillstreaktorule( "radar_mp", "targetableent", 1, 1 );
+	addkillstreaktorule( "counteruav_mp", "counteruav", 1, 1 );
+	addkillstreaktorule( "counteruav_mp", "targetableent", 1, 1 );
+	addkillstreaktorule( "emp_mp", "emp", 1, 1 );
+	addkillstreaktorule( "remote_mortar_mp", "targetableent", 1, 1 );
+	addkillstreaktorule( "remote_mortar_mp", "remotemortar", 1, 1 );
+	addkillstreaktorule( "remote_missile_mp", "targetableent", 1, 1 );
+	addkillstreaktorule( "qrdrone_mp", "vehicle", 1, 1 );
+	addkillstreaktorule( "qrdrone_mp", "qrdrone", 1, 1 );
+	addkillstreaktorule( "missile_swarm_mp", "missileswarm", 1, 1 );
+	addkillstreaktorule( "missile_drone_mp", "missiledrone", 1, 1 );
+	addkillstreaktorule( "inventory_missile_drone_mp", "missiledrone", 1, 1 );
+	addkillstreaktorule( "straferun_mp", "straferun", 1, 1 );
+	addkillstreaktorule( "ai_tank_drop_mp", "ai_tank", 1, 1 );
+	addkillstreaktorule( "inventory_ai_tank_drop_mp", "ai_tank", 1, 1 );
+	addkillstreaktorule( "planemortar_mp", "planemortar", 1, 1 );
+}
+
+createrule( rule, maxallowable, maxallowableperteam )
+{
+	if ( !level.teambased )
+	{
+		if ( maxallowable > maxallowableperteam )
+		{
+			maxallowable = maxallowableperteam;
+		}
+	}
+	level.killstreakrules[ rule ] = spawnstruct();
+	level.killstreakrules[ rule ].cur = 0;
+	level.killstreakrules[ rule ].curteam = [];
+	level.killstreakrules[ rule ].max = maxallowable;
+	level.killstreakrules[ rule ].maxperteam = maxallowableperteam;
+}
+
+addkillstreaktorule( hardpointtype, rule, counttowards, checkagainst )
+{
+	if ( !isDefined( level.killstreaktype[ hardpointtype ] ) )
+	{
+		level.killstreaktype[ hardpointtype ] = [];
+	}
+	keys = getarraykeys( level.killstreaktype[ hardpointtype ] );
+/#
+	assert( isDefined( level.killstreakrules[ rule ] ) );
+#/
+	if ( !isDefined( level.killstreaktype[ hardpointtype ][ rule ] ) )
+	{
+		level.killstreaktype[ hardpointtype ][ rule ] = spawnstruct();
+	}
+	level.killstreaktype[ hardpointtype ][ rule ].counts = counttowards;
+	level.killstreaktype[ hardpointtype ][ rule ].checks = checkagainst;
+}
+
+killstreakstart( hardpointtype, team, hacked, displayteammessage )
+{
+/#
+	assert( isDefined( team ), "team needs to be defined" );
+#/
+	if ( self iskillstreakallowed( hardpointtype, team ) == 0 )
+	{
+		return -1;
+	}
+/#
+	assert( isDefined( hardpointtype ) );
+#/
+	if ( !isDefined( hacked ) )
+	{
+		hacked = 0;
+	}
+	if ( !isDefined( displayteammessage ) )
+	{
+		displayteammessage = 1;
+	}
+	if ( displayteammessage == 1 )
+	{
+		if ( isDefined( level.killstreaks[ hardpointtype ] ) && isDefined( level.killstreaks[ hardpointtype ].inboundtext ) && !hacked )
+		{
+			level thread maps/mp/_popups::displaykillstreakteammessagetoall( hardpointtype, self );
+		}
+	}
+	keys = getarraykeys( level.killstreaktype[ hardpointtype ] );
+	_a187 = keys;
+	_k187 = getFirstArrayKey( _a187 );
+	while ( isDefined( _k187 ) )
+	{
+		key = _a187[ _k187 ];
+		if ( !level.killstreaktype[ hardpointtype ][ key ].counts )
+		{
+		}
+		else
+		{
+/#
+			assert( isDefined( level.killstreakrules[ key ] ) );
+#/
+			level.killstreakrules[ key ].cur++;
+			if ( level.teambased )
+			{
+				if ( !isDefined( level.killstreakrules[ key ].curteam[ team ] ) )
+				{
+					level.killstreakrules[ key ].curteam[ team ] = 0;
+				}
+				level.killstreakrules[ key ].curteam[ team ]++;
+			}
+		}
+		_k187 = getNextArrayKey( _a187, _k187 );
+	}
+	level notify( "killstreak_started" );
+	killstreak_id = level.killstreak_counter;
+	level.killstreak_counter++;
+	killstreak_data = [];
+	killstreak_data[ "caller" ] = self getxuid();
+	killstreak_data[ "spawnid" ] = getplayerspawnid( self );
+	killstreak_data[ "starttime" ] = getTime();
+	killstreak_data[ "type" ] = hardpointtype;
+	killstreak_data[ "endtime" ] = 0;
+	level.killstreaks_triggered[ killstreak_id ] = killstreak_data;
+/#
+	killstreak_debug_text( "Started killstreak: " + hardpointtype + " for team: " + team + " id: " + killstreak_id );
+#/
+	return killstreak_id;
+}
+
+killstreakstop( hardpointtype, team, id )
+{
+/#
+	assert( isDefined( team ), "team needs to be defined" );
+#/
+/#
+	assert( isDefined( hardpointtype ) );
+#/
+/#
+	killstreak_debug_text( "Stopped killstreak: " + hardpointtype + " for team: " + team + " id: " + id );
+#/
+	keys = getarraykeys( level.killstreaktype[ hardpointtype ] );
+	_a238 = keys;
+	_k238 = getFirstArrayKey( _a238 );
+	while ( isDefined( _k238 ) )
+	{
+		key = _a238[ _k238 ];
+		if ( !level.killstreaktype[ hardpointtype ][ key ].counts )
+		{
+		}
+		else
+		{
+/#
+			assert( isDefined( level.killstreakrules[ key ] ) );
+#/
+			level.killstreakrules[ key ].cur--;
+
+/#
+			assert( level.killstreakrules[ key ].cur >= 0 );
+#/
+			if ( level.teambased )
+			{
+/#
+				assert( isDefined( team ) );
+#/
+/#
+				assert( isDefined( level.killstreakrules[ key ].curteam[ team ] ) );
+#/
+				level.killstreakrules[ key ].curteam[ team ]--;
+
+/#
+				assert( level.killstreakrules[ key ].curteam[ team ] >= 0 );
+#/
+			}
+		}
+		_k238 = getNextArrayKey( _a238, _k238 );
+	}
+	if ( !isDefined( id ) || id == -1 )
+	{
+		killstreak_debug_text( "WARNING! Invalid killstreak id detected for " + hardpointtype );
+		bbprint( "mpkillstreakuses", "starttime %d endtime %d name %s team %s", 0, getTime(), hardpointtype, team );
+		return;
+	}
+	level.killstreaks_triggered[ id ][ "endtime" ] = getTime();
+	bbprint( "mpkillstreakuses", "starttime %d endtime %d spawnid %d name %s team %s", level.killstreaks_triggered[ id ][ "starttime" ], level.killstreaks_triggered[ id ][ "endtime" ], level.killstreaks_triggered[ id ][ "spawnid" ], hardpointtype, team );
+	if ( isDefined( level.killstreaks[ hardpointtype ].menuname ) )
+	{
+		recordstreakindex = level.killstreakindices[ level.killstreaks[ hardpointtype ].menuname ];
+		if ( isDefined( recordstreakindex ) )
+		{
+			if ( isDefined( self.owner ) )
+			{
+				self.owner recordkillstreakendevent( recordstreakindex );
+				return;
+			}
+			else
+			{
+				if ( isplayer( self ) )
+				{
+					self recordkillstreakendevent( recordstreakindex );
+				}
+			}
+		}
+	}
+}
+
+iskillstreakallowed( hardpointtype, team )
+{
+/#
+	assert( isDefined( team ), "team needs to be defined" );
+#/
+/#
+	assert( isDefined( hardpointtype ) );
+#/
+	isallowed = 1;
+	keys = getarraykeys( level.killstreaktype[ hardpointtype ] );
+	_a308 = keys;
+	_k308 = getFirstArrayKey( _a308 );
+	while ( isDefined( _k308 ) )
+	{
+		key = _a308[ _k308 ];
+		if ( !level.killstreaktype[ hardpointtype ][ key ].checks )
+		{
+		}
+		else
+		{
+			if ( level.killstreakrules[ key ].max != 0 )
+			{
+				if ( level.killstreakrules[ key ].cur >= level.killstreakrules[ key ].max )
+				{
+/#
+					killstreak_debug_text( "Exceeded " + key + " overall" );
+#/
+					isallowed = 0;
+					break;
+				}
+			}
+			else if ( level.teambased && level.killstreakrules[ key ].maxperteam != 0 )
+			{
+				if ( !isDefined( level.killstreakrules[ key ].curteam[ team ] ) )
+				{
+					level.killstreakrules[ key ].curteam[ team ] = 0;
+				}
+				if ( level.killstreakrules[ key ].curteam[ team ] >= level.killstreakrules[ key ].maxperteam )
+				{
+					isallowed = 0;
+/#
+					killstreak_debug_text( "Exceeded " + key + " team" );
+#/
+					break;
+				}
+			}
+		}
+		else
+		{
+			_k308 = getNextArrayKey( _a308, _k308 );
+		}
+	}
+	if ( isDefined( self.laststand ) && self.laststand )
+	{
+/#
+		killstreak_debug_text( "In LastStand" );
+#/
+		isallowed = 0;
+	}
+	if ( self isempjammed() )
+	{
+/#
+		killstreak_debug_text( "EMP active" );
+#/
+		isallowed = 0;
+		if ( self maps/mp/killstreaks/_emp::isenemyempkillstreakactive() )
+		{
+			if ( isDefined( level.empendtime ) )
+			{
+				secondsleft = int( ( level.empendtime - getTime() ) / 1000 );
+				if ( secondsleft > 0 )
+				{
+					self iprintlnbold( &"KILLSTREAK_NOT_AVAILABLE_EMP_ACTIVE", secondsleft );
+					return 0;
+				}
+			}
+		}
+	}
+	if ( isallowed == 0 )
+	{
+		if ( isDefined( level.killstreaks[ hardpointtype ] ) && isDefined( level.killstreaks[ hardpointtype ].notavailabletext ) )
+		{
+			self iprintlnbold( level.killstreaks[ hardpointtype ].notavailabletext );
+			if ( hardpointtype != "helicopter_comlink_mp" && hardpointtype != "helicopter_guard_mp" && hardpointtype != "helicopter_player_gunner_mp" && hardpointtype != "remote_mortar_mp" && hardpointtype != "inventory_supply_drop_mp" || hardpointtype == "supply_drop_mp" && hardpointtype == "straferun_mp" )
+			{
+				pilotvoicenumber = randomintrange( 0, 3 );
+				soundalias = level.teamprefix[ self.team ] + pilotvoicenumber + "_" + "kls_full";
+				self playlocalsound( soundalias );
+			}
+		}
+	}
+	return isallowed;
+}
+
+killstreak_debug_text( text )
+{
+/#
+	level.killstreak_rule_debug = getdvarintdefault( "scr_killstreak_rule_debug", 0 );
+	if ( isDefined( level.killstreak_rule_debug ) )
+	{
+		if ( level.killstreak_rule_debug == 1 )
+		{
+			iprintln( "KSR: " + text + "\n" );
+			return;
+		}
+		else
+		{
+			if ( level.killstreak_rule_debug == 2 )
+			{
+				iprintlnbold( "KSR: " + text );
+#/
+			}
+		}
+	}
+}

patch_mp/maps/mp/killstreaks/_missile_drone.gsc

@@ -0,0 +1,694 @@
+#include maps/mp/_challenges;
+#include maps/mp/_scoreevents;
+#include maps/mp/killstreaks/_dogs;
+#include maps/mp/killstreaks/_missile_swarm;
+#include maps/mp/_popups;
+#include maps/mp/killstreaks/_killstreakrules;
+#include maps/mp/killstreaks/_airsupport;
+#include maps/mp/killstreaks/_killstreaks;
+#include common_scripts/utility;
+#include maps/mp/_utility;
+
+#using_animtree( "mp_missile_drone" );
+
+init()
+{
+	registerclientfield( "toplayer", "missile_drone_active", 1, 2, "int" );
+	registerclientfield( "missile", "missile_drone_projectile_active", 1, 1, "int" );
+	registerclientfield( "missile", "missile_drone_projectile_animate", 1, 1, "int" );
+	level.missile_drone_flyheight = 2400;
+	level.missile_drone_anim = %o_drone_hunter_launch;
+	precacheitem( "missile_drone_projectile_mp" );
+	loadfx( "weapon/missile/fx_missile_drone_light_red" );
+	registerkillstreak( "inventory_missile_drone_mp", "inventory_missile_drone_mp", "killstreak_missile_drone", "missile_drone_used", ::missile_drone_killstreak, 1 );
+	registerkillstreakstrings( "inventory_missile_drone_mp", &"KILLSTREAK_EARNED_MISSILE_DRONE", &"KILLSTREAK_MISSILE_DRONE_NOT_AVAILABLE", &"KILLSTREAK_MISSILE_DRONE_INBOUND" );
+	registerkillstreakdialog( "inventory_missile_drone_mp", "mpl_killstreak_missile_drone", "kls_hkdrone_used", "", "kls_hkdrone_enemy", "", "kls_hkdrone_ready" );
+	registerkillstreakdevdvar( "inventory_missile_drone_mp", "scr_givemissiledrone" );
+	registerkillstreak( "missile_drone_mp", "missile_drone_mp", "killstreak_missile_drone", "missile_drone_used", ::missile_drone_killstreak, 1 );
+	registerkillstreakaltweapon( "missile_drone_mp", "missile_drone_projectile_mp" );
+	registerkillstreakaltweapon( "inventory_missile_drone_mp", "missile_drone_projectile_mp" );
+	registerkillstreakstrings( "missile_drone_mp", &"KILLSTREAK_EARNED_MISSILE_DRONE", &"KILLSTREAK_MISSILE_DRONE_NOT_AVAILABLE", &"KILLSTREAK_MISSILE_DRONE_INBOUND" );
+	registerkillstreakdialog( "missile_drone_mp", "mpl_killstreak_missile_drone", "kls_hkdrone_used", "", "kls_hkdrone_enemy", "", "kls_hkdrone_ready" );
+	setkillstreakteamkillpenaltyscale( "missile_drone_mp", 0 );
+}
+
+missile_drone_killstreak( weaponname )
+{
+/#
+	if ( weaponname != "missile_drone_mp" )
+	{
+		assert( weaponname == "inventory_missile_drone_mp" );
+	}
+#/
+	level.missile_drone_origin = level.mapcenter + ( 0, 0, level.missile_drone_flyheight );
+	hardpointtype = "missile_drone_mp";
+	result = usemissiledrone( hardpointtype );
+	if ( !isDefined( result ) || !result )
+	{
+		return 0;
+	}
+	return result;
+}
+
+usemissiledrone( hardpointtype )
+{
+	if ( self maps/mp/killstreaks/_killstreakrules::iskillstreakallowed( hardpointtype, self.team ) == 0 )
+	{
+		return 0;
+	}
+	self thread missiledronewatcher( hardpointtype );
+	missileweapon = self getcurrentweapon();
+	missileweapon = undefined;
+	currentweapon = self getcurrentweapon();
+	if ( ismissiledroneweapon( currentweapon ) )
+	{
+		missileweapon = currentweapon;
+	}
+/#
+	assert( isDefined( missileweapon ) );
+#/
+	notifystring = self waittill_any_return( "weapon_change", "grenade_fire", "death" );
+	if ( notifystring == "weapon_change" || notifystring == "death" )
+	{
+		return 0;
+	}
+	notifystring = self waittill_any_return( "weapon_change", "death" );
+	if ( notifystring == "death" )
+	{
+		return 1;
+	}
+	if ( !isDefined( missileweapon ) )
+	{
+		return 0;
+	}
+	self takeweapon( missileweapon );
+	if ( self hasweapon( missileweapon ) || self getammocount( missileweapon ) )
+	{
+		return 0;
+	}
+	return 1;
+}
+
+ismissiledroneweapon( weapon )
+{
+	if ( weapon == "missile_drone_mp" || weapon == "inventory_missile_drone_mp" )
+	{
+		return 1;
+	}
+	return 0;
+}
+
+missiledronewatcher( hardpointtype )
+{
+	self notify( "missileDroneWatcher" );
+	self endon( "missileDroneWatcher" );
+	self endon( "spawned_player" );
+	self endon( "disconnect" );
+	self endon( "weapon_change" );
+	self endon( "death" );
+	team = self.team;
+	killstreak_id = maps/mp/killstreaks/_killstreakrules::killstreakstart( hardpointtype, team, 0, 0 );
+	if ( killstreak_id == -1 )
+	{
+		self maps/mp/killstreaks/_killstreaks::switchtolastnonkillstreakweapon();
+		return;
+	}
+	self thread checkforemp();
+	self thread checkweaponchange( hardpointtype, team, killstreak_id );
+	self thread watchownerdeath( hardpointtype, team, killstreak_id );
+	self thread updatetargetting();
+	self waittill( "grenade_fire", grenade, weapname );
+	origin = grenade.origin;
+	self notify( "missile_drone_active" );
+	level thread maps/mp/_popups::displaykillstreakteammessagetoall( hardpointtype, self );
+	self maps/mp/killstreaks/_killstreaks::playkillstreakstartdialog( hardpointtype, self.team, 1 );
+	level.globalkillstreakscalled++;
+	self addweaponstat( "missile_drone_mp", "used", 1 );
+	self setclientfieldtoplayer( "missile_drone_active", 0 );
+	grenade thread waitthendelete( 0,05 );
+	grenade.origin += vectorScale( ( 0, 0, 1 ), 1000 );
+	self thread domissiledrone( origin, weapname, killstreak_id, hardpointtype, team );
+	self maps/mp/killstreaks/_killstreaks::switchtolastnonkillstreakweapon();
+}
+
+domissiledrone( origin, weapname, killstreak_id, hardpointtype, team )
+{
+	direction = self getplayerangles();
+	forward = anglesToForward( direction );
+	target = origin + vectorScale( forward, 10000 );
+	debug_line( origin, target, ( 0,9, 0,1, 0,1 ) );
+	projectile = maps/mp/killstreaks/_missile_swarm::projectile_spawn_utility( self, target, origin, "missile_drone_projectile_mp", "drone_missile", 0 );
+	projectile missile_dronesetvisible( 1 );
+	projectile.originaltarget = target;
+	projectile thread maps/mp/killstreaks/_missile_swarm::projectile_abort_think();
+	projectile thread drone_target_search( hardpointtype );
+	projectile thread projectile_death_think();
+	projectile thread watchdamage();
+	projectile.targetname = "remote_drone";
+	projectile playsound( "wpn_hunter_ignite" );
+	projectile thread killstreak_stop_think( killstreak_id, hardpointtype, team );
+	projectile setclientfield( "missile_drone_projectile_animate", 1 );
+}
+
+waitthendelete( waittime )
+{
+	self endon( "delete" );
+	self endon( "death" );
+	wait waittime;
+	self delete();
+}
+
+projectile_death_think()
+{
+	self waittill( "death" );
+	self.goal delete();
+}
+
+drone_target_acquired( hardpointtype, target )
+{
+	self endon( "death" );
+	self notify( "drone_target_acquired" );
+	self setclientfield( "missile_drone_projectile_active", 1 );
+	self set_drone_target( hardpointtype, target );
+}
+
+drone_target_search( hardpointtype )
+{
+	self endon( "death" );
+	if ( isDefined( self.dronetarget ) )
+	{
+		self drone_target_acquired( hardpointtype, self.dronetarget );
+		self missile_settarget( self.goal );
+	}
+	self setclientfield( "missile_drone_projectile_active", 0 );
+	searchdotprodminimums = [];
+	searchdotprodminimums[ 0 ] = 0,9;
+	searchdotprodminimums[ 1 ] = 0,7071;
+	searchdotprodminimums[ 2 ] = 0,5;
+	searchdotprodminimums[ 3 ] = 0;
+	wait 0,1;
+	searchcounter = 0;
+	for ( ;; )
+	{
+		if ( !isDefined( self ) )
+		{
+			self notify( "death" );
+		}
+		target = self projectile_find_target( self.owner, searchdotprodminimums[ searchcounter ] );
+		if ( searchcounter < ( searchdotprodminimums.size - 1 ) )
+		{
+			searchcounter++;
+		}
+		else if ( level.missile_drone_origin[ 2 ] != self.goal.origin[ 2 ] )
+		{
+			currentangles = self.angles;
+			direction = vectornormalize( anglesToForward( self.angles ) );
+			direction = vecscale( direction, 1024 );
+			self.goal.origin = ( self.origin[ 0 ] + direction[ 0 ], self.origin[ 1 ] + direction[ 1 ], level.missile_drone_origin[ 2 ] );
+/#
+			debug_line( self.origin, self.goal.origin, ( 0, 0, 1 ), 5000 );
+#/
+		}
+		else
+		{
+			currentangles = self.angles;
+			direction = vectornormalize( anglesToForward( self.angles ) );
+			direction = vecscale( direction, 1024 );
+			self.goal.origin = ( level.missile_drone_origin[ 0 ] + direction[ 0 ], level.missile_drone_origin[ 1 ] + direction[ 1 ], level.missile_drone_origin[ 2 ] );
+/#
+			debug_line( self.origin, self.goal.origin, ( 0, 1, 1 ), 5000 );
+#/
+		}
+		if ( isDefined( target ) )
+		{
+			self set_drone_target( hardpointtype, target );
+			self missile_settarget( self.goal );
+		}
+		wait 0,25;
+	}
+}
+
+vecscale( vec, scalar )
+{
+	return ( vec[ 0 ] * scalar, vec[ 1 ] * scalar, vec[ 2 ] * scalar );
+}
+
+set_drone_target( hardpointtype, target )
+{
+	self endon( "target_lost" );
+	self thread check_target_lost( target );
+	self.swarm_target = target[ "entity" ];
+	target[ "entity" ].swarm = self;
+	debug_line( self.origin, target[ "entity" ].origin, ( 0, 0, 1 ), 5000 );
+	self missile_settarget( target[ "entity" ], target[ "offset" ] );
+	self playsound( "veh_harpy_drone_swarm_incomming" );
+	if ( !isDefined( target[ "entity" ].swarmsound ) || target[ "entity" ].swarmsound == 0 )
+	{
+		self thread target_sounds( target[ "entity" ] );
+	}
+	target[ "entity" ] notify( "stinger_fired_at_me" );
+	self setclientfield( "missile_drone_projectile_active", 1 );
+	target[ "entity" ] waittill_any( "death", "disconnect", "joined_team" );
+	self setclientfield( "missile_drone_projectile_active", 0 );
+	self missile_settarget( self.goal );
+}
+
+check_target_lost( target )
+{
+	self endon( "death" );
+	target[ "entity" ] endon( "death" );
+	target[ "entity" ] endon( "disconnect" );
+	target[ "entity" ] endon( "joined_team" );
+	failurelimit = 3;
+	failurecount = 0;
+	for ( ;; )
+	{
+/#
+		debug_star( target[ "entity" ].origin, ( 0, 0, 1 ), 1000 );
+		debug_star( self.origin, ( 0, 0, 1 ), 1000 );
+#/
+		if ( bullettracepassed( self.origin, target[ "entity" ].origin + target[ "offset" ], 0, target[ "entity" ] ) )
+		{
+/#
+			debug_line( self.origin, target[ "entity" ].origin, ( 0, 0, 1 ), 1000 );
+#/
+			failurecount = 0;
+		}
+		else
+		{
+			failurecount++;
+			if ( failurecount >= failurelimit )
+			{
+				self notify( "target_lost" );
+				return;
+			}
+		}
+		wait 0,25;
+	}
+}
+
+projectile_find_target( owner, mincos )
+{
+	ks = self projectile_find_target_killstreak( owner, mincos );
+	player = self projectile_find_target_player( owner, mincos );
+	if ( isDefined( ks ) && !isDefined( player ) )
+	{
+		return ks;
+	}
+	else
+	{
+		if ( !isDefined( ks ) && isDefined( player ) )
+		{
+			return player;
+		}
+		else
+		{
+			if ( isDefined( ks ) && isDefined( player ) )
+			{
+				if ( player[ "dotprod" ] < ks[ "dotprod" ] )
+				{
+					return ks;
+				}
+				return player;
+			}
+		}
+	}
+	return undefined;
+}
+
+projectile_find_target_killstreak( owner, mincos )
+{
+	ks = [];
+	ks[ "offset" ] = vectorScale( ( 0, 0, 1 ), 10 );
+	targets = target_getarray();
+	rcbombs = getentarray( "rcbomb", "targetname" );
+	dogs = maps/mp/killstreaks/_dogs::dog_manager_get_dogs();
+	targets = arraycombine( targets, rcbombs, 1, 0 );
+	targets = arraycombine( targets, dogs, 1, 0 );
+	if ( targets.size <= 0 )
+	{
+		return undefined;
+	}
+	targets = get_array_sorted_dot_prod( targets, mincos );
+	_a389 = targets;
+	_k389 = getFirstArrayKey( _a389 );
+	while ( isDefined( _k389 ) )
+	{
+		target = _a389[ _k389 ];
+		if ( isDefined( target.owner ) && target.owner == owner )
+		{
+		}
+		else
+		{
+			if ( isDefined( target.script_owner ) && target.script_owner == owner )
+			{
+				break;
+			}
+			else
+			{
+				if ( level.teambased && isDefined( target.team ) )
+				{
+					if ( target.team == self.team )
+					{
+						break;
+					}
+				}
+				else if ( level.teambased && isDefined( target.aiteam ) )
+				{
+					if ( target.aiteam == self.team )
+					{
+						break;
+					}
+				}
+				else if ( isDefined( target.vehicletype ) && target.vehicletype == "heli_supplydrop_mp" )
+				{
+					break;
+				}
+				else
+				{
+					if ( bullettracepassed( self.origin, target.origin, 0, target ) )
+					{
+						ks[ "entity" ] = target;
+						if ( isDefined( target.sorteddotprod ) )
+						{
+							ks[ "dotprod" ] = target.sorteddotprod;
+						}
+						else
+						{
+							ks[ "dotprod" ] = -1;
+						}
+						return ks;
+					}
+				}
+			}
+		}
+		_k389 = getNextArrayKey( _a389, _k389 );
+	}
+	return undefined;
+}
+
+projectile_find_target_player( owner, mincos )
+{
+	target = [];
+	players = self get_array_sorted_dot_prod( get_players(), mincos );
+	if ( isplayer( self ) )
+	{
+		startoffset = self getplayerviewheight();
+		startorigin = ( self.origin[ 0 ], self.origin[ 1 ], self.origin[ 2 ] + startoffset );
+		startangles = self getplayerangles();
+/#
+		debug_star( startorigin, ( 0, 0, 1 ), 1000 );
+#/
+	}
+	else
+	{
+		startorigin = self.origin;
+		startangles = self.angles;
+	}
+	bestplayerrating = -1;
+	_a470 = players;
+	_k470 = getFirstArrayKey( _a470 );
+	while ( isDefined( _k470 ) )
+	{
+		player = _a470[ _k470 ];
+		if ( !player_valid_target( player, owner.team, owner ) )
+		{
+		}
+		else
+		{
+			currentplayeroffset = undefined;
+			currentplayerdotprod = undefined;
+			currentplayerrating = 0;
+/#
+			debug_star( player.origin, ( 0, 0, 1 ), 1000 );
+#/
+			if ( bullettracepassed( startorigin, player.origin, 0, player ) )
+			{
+/#
+				debug_line( startorigin, player.origin, ( 0, 0, 1 ), 1000 );
+#/
+				if ( !isDefined( currentplayeroffset ) )
+				{
+					currentplayeroffset = ( 0, 0, 1 );
+				}
+				currentplayerrating += 4;
+			}
+			verticaloffset = player getplayerviewheight();
+			playerheadoffset = ( 0, 0, verticaloffset );
+/#
+			debug_star( player.origin + playerheadoffset, ( 0, 0, 1 ), 1000 );
+#/
+			if ( bullettracepassed( startorigin, player.origin + playerheadoffset, 0, player ) )
+			{
+/#
+				debug_line( startorigin, player.origin + playerheadoffset, ( 0, 0, 1 ), 1000 );
+#/
+				if ( !isDefined( currentplayeroffset ) )
+				{
+					currentplayeroffset = playerheadoffset;
+				}
+				currentplayerrating += 3;
+			}
+			end = player.origin + playerheadoffset + vectorScale( ( 0, 0, 1 ), 96 );
+/#
+			debug_star( end, ( 0, 0, 1 ), 1000 );
+#/
+			if ( bullettracepassed( player.origin + playerheadoffset, end, 0, player ) )
+			{
+/#
+				debug_line( player.origin + playerheadoffset, end, ( 0, 0, 1 ), 1000 );
+#/
+				if ( !isDefined( currentplayeroffset ) )
+				{
+					currentplayeroffset = vectorScale( ( 0, 0, 1 ), 30 );
+				}
+				currentplayerrating += 2;
+			}
+			if ( currentplayerrating > bestplayerrating )
+			{
+				bestplayerrating = currentplayerrating;
+				target[ "entity" ] = player;
+				target[ "offset" ] = currentplayeroffset;
+				if ( isDefined( player.sorteddotprod ) )
+				{
+					target[ "dotprod" ] = player.sorteddotprod;
+				}
+				else
+				{
+					target[ "dotprod" ] = -1;
+				}
+				if ( bestplayerrating >= 9 )
+				{
+					return target;
+				}
+			}
+		}
+		_k470 = getNextArrayKey( _a470, _k470 );
+	}
+	if ( bestplayerrating >= 3 )
+	{
+		return target;
+	}
+	return undefined;
+}
+
+killstreak_stop_think( killstreak_id, hardpointtype, team )
+{
+	self waittill( "death" );
+	maps/mp/killstreaks/_killstreakrules::killstreakstop( hardpointtype, team, killstreak_id );
+}
+
+checkweaponchange( hardpointtype, team, killstreak_id )
+{
+	self endon( "spawned_player" );
+	self endon( "death" );
+	self endon( "disconnect" );
+	self endon( "grenade_fire" );
+	self waittill( "weapon_change" );
+	self setclientfieldtoplayer( "missile_drone_active", 0 );
+	maps/mp/killstreaks/_killstreakrules::killstreakstop( hardpointtype, team, killstreak_id );
+}
+
+watchownerdeath( hardpointtype, team, killstreak_id )
+{
+	self endon( "spawned_player" );
+	self endon( "disconnect" );
+	self endon( "weapon_change" );
+	self endon( "missile_drone_active" );
+	self waittill( "death" );
+	maps/mp/killstreaks/_killstreakrules::killstreakstop( hardpointtype, team, killstreak_id );
+}
+
+checkforemp()
+{
+	self endon( "spawned_player" );
+	self endon( "disconnect" );
+	self endon( "weapon_change" );
+	self endon( "death" );
+	self endon( "grenade_fire" );
+	self waittill( "emp_jammed" );
+	self setclientfieldtoplayer( "missile_drone_active", 0 );
+	self maps/mp/killstreaks/_killstreaks::switchtolastnonkillstreakweapon();
+}
+
+watchdamage()
+{
+	self endon( "death" );
+	self setcandamage( 1 );
+	self.maxhealth = 100000;
+	self.health = self.maxhealth;
+	for ( ;; )
+	{
+		self waittill( "damage", damage, attacker, direction, point, type, tagname, modelname, partname, weaponname );
+		if ( !isDefined( attacker ) || !isplayer( attacker ) )
+		{
+			continue;
+		}
+		else
+		{
+			if ( isplayer( attacker ) && level.teambased && isDefined( attacker.team ) && self.team == attacker.team && level.friendlyfire == 0 )
+			{
+				break;
+			}
+			else
+			{
+				if ( self.owner isenemyplayer( attacker ) )
+				{
+					maps/mp/_scoreevents::processscoreevent( "destroyed_missile_drone", attacker, self.owner, weaponname );
+					attacker maps/mp/_challenges::addflyswatterstat( weaponname, self );
+					break;
+				}
+				self detonate();
+			}
+		}
+	}
+}
+
+get_array_sorted_dot_prod( array, mincos )
+{
+	if ( isplayer( self ) )
+	{
+		org = self.origin;
+		angles = self getplayerangles();
+/#
+		assert( isDefined( angles ) );
+#/
+	}
+	else
+	{
+		org = self.origin;
+/#
+		assert( isDefined( self.angles ) );
+#/
+		angles = self.angles;
+	}
+	forwardvec = vectornormalize( anglesToForward( angles ) );
+	dotprod = [];
+	index = [];
+	i = 0;
+	while ( i < array.size )
+	{
+/#
+		assert( isDefined( forwardvec ) );
+#/
+/#
+		assert( isDefined( array[ i ] ) );
+#/
+/#
+		assert( isDefined( array[ i ].origin ) );
+#/
+/#
+		assert( isDefined( org ) );
+#/
+		cosa = vectordot( forwardvec, vectornormalize( array[ i ].origin - org ) );
+/#
+		assert( isDefined( cosa ) );
+#/
+		if ( isDefined( mincos ) && cosa < mincos )
+		{
+			i++;
+			continue;
+		}
+		else
+		{
+			array[ i ].sorteddotprod = cosa;
+			dotprod[ dotprod.size ] = cosa;
+			index[ index.size ] = i;
+		}
+		i++;
+	}
+	for ( ;; )
+	{
+		change = 0;
+		i = 0;
+		while ( i < ( dotprod.size - 1 ) )
+		{
+			if ( dotprod[ i ] >= dotprod[ i + 1 ] )
+			{
+				i++;
+				continue;
+			}
+			else
+			{
+				change = 1;
+				temp = dotprod[ i ];
+				dotprod[ i ] = dotprod[ i + 1 ];
+				dotprod[ i + 1 ] = temp;
+				temp = index[ i ];
+				index[ i ] = index[ i + 1 ];
+				index[ i + 1 ] = temp;
+			}
+			i++;
+		}
+		if ( !change )
+		{
+			break;
+		}
+		else
+		{
+		}
+	}
+	newarray = [];
+	i = 0;
+	while ( i < dotprod.size )
+	{
+		newarray[ i ] = array[ index[ i ] ];
+		i++;
+	}
+	return newarray;
+}
+
+updatetargetting()
+{
+	self endon( "spawned_player" );
+	self endon( "disconnect" );
+	self endon( "weapon_change" );
+	self endon( "death" );
+	self endon( "grenade_fire" );
+	mincos = getdvarfloatdefault( "scr_missile_drone_min_cos", 0,9 );
+	updatewait = getdvarfloatdefault( "scr_missile_drone_update_wait", 0,5 );
+	for ( ;; )
+	{
+		self.dronetarget = self projectile_find_target( self, mincos );
+		if ( isDefined( self.dronetarget ) )
+		{
+			self thread clearinvaliddronetarget();
+			self setclientfieldtoplayer( "missile_drone_active", 2 );
+		}
+		else
+		{
+			self setclientfieldtoplayer( "missile_drone_active", 1 );
+		}
+		wait updatewait;
+	}
+}
+
+clearinvaliddronetarget()
+{
+	self endon( "death" );
+	self notify( "clearInvalidDroneTarget" );
+	self endon( "clearInvalidDroneTarget" );
+	self endon( "drone_target_acquired" );
+	self.dronetarget[ "entity" ] waittill_any( "death", "disconnect", "joined_team" );
+	self.dronetarget = undefined;
+}

patch_mp/maps/mp/killstreaks/_missile_swarm.gsc

@@ -0,0 +1,760 @@
+#include maps/mp/killstreaks/_dogs;
+#include maps/mp/_challenges;
+#include maps/mp/_scoreevents;
+#include maps/mp/killstreaks/_killstreakrules;
+#include maps/mp/killstreaks/_airsupport;
+#include maps/mp/killstreaks/_killstreaks;
+#include common_scripts/utility;
+#include maps/mp/_utility;
+
+init()
+{
+	level.missile_swarm_max = 6;
+	level.missile_swarm_flyheight = 3000;
+	level.missile_swarm_flydist = 5000;
+	set_dvar_float_if_unset( "scr_missile_swarm_lifetime", 40 );
+	precacheitem( "missile_swarm_projectile_mp" );
+	level.swarm_fx[ "swarm" ] = loadfx( "weapon/harpy_swarm/fx_hrpy_swrm_os_circle_neg_x" );
+	level.swarm_fx[ "swarm_tail" ] = loadfx( "weapon/harpy_swarm/fx_hrpy_swrm_exhaust_trail_close" );
+	level.missiledronesoundstart = "mpl_hk_scan";
+	registerkillstreak( "missile_swarm_mp", "missile_swarm_mp", "killstreak_missile_swarm", "missile_swarm_used", ::swarm_killstreak, 1 );
+	registerkillstreakaltweapon( "missile_swarm_mp", "missile_swarm_projectile_mp" );
+	registerkillstreakstrings( "missile_swarm_mp", &"KILLSTREAK_EARNED_MISSILE_SWARM", &"KILLSTREAK_MISSILE_SWARM_NOT_AVAILABLE", &"KILLSTREAK_MISSILE_SWARM_INBOUND" );
+	registerkillstreakdialog( "missile_swarm_mp", "mpl_killstreak_missile_swarm", "kls_swarm_used", "", "kls_swarm_enemy", "", "kls_swarm_ready" );
+	registerkillstreakdevdvar( "missile_swarm_mp", "scr_givemissileswarm" );
+	setkillstreakteamkillpenaltyscale( "missile_swarm_mp", 0 );
+	maps/mp/killstreaks/_killstreaks::createkillstreaktimer( "missile_swarm_mp" );
+	registerclientfield( "world", "missile_swarm", 1, 2, "int" );
+/#
+	set_dvar_int_if_unset( "scr_missile_swarm_cam", 0 );
+#/
+}
+
+swarm_killstreak( hardpointtype )
+{
+/#
+	assert( hardpointtype == "missile_swarm_mp" );
+#/
+	level.missile_swarm_origin = level.mapcenter + ( 0, 0, level.missile_swarm_flyheight );
+	if ( level.script == "mp_drone" )
+	{
+		level.missile_swarm_origin += ( -5000, 0, 2000 );
+	}
+	if ( level.script == "mp_la" )
+	{
+		level.missile_swarm_origin += vectorScale( ( 0, 0, 1 ), 2000 );
+	}
+	if ( level.script == "mp_turbine" )
+	{
+		level.missile_swarm_origin += vectorScale( ( 0, 0, 1 ), 1500 );
+	}
+	if ( level.script == "mp_downhill" )
+	{
+		level.missile_swarm_origin += ( 4000, 0, 1000 );
+	}
+	if ( level.script == "mp_hydro" )
+	{
+		level.missile_swarm_origin += vectorScale( ( 0, 0, 1 ), 5000 );
+	}
+	if ( level.script == "mp_magma" )
+	{
+		level.missile_swarm_origin += ( 0, -6000, 3000 );
+	}
+	if ( level.script == "mp_uplink" )
+	{
+		level.missile_swarm_origin += ( -6000, 0, 2000 );
+	}
+	if ( level.script == "mp_bridge" )
+	{
+		level.missile_swarm_origin += vectorScale( ( 0, 0, 1 ), 2000 );
+	}
+	if ( level.script == "mp_paintball" )
+	{
+		level.missile_swarm_origin += vectorScale( ( 0, 0, 1 ), 1000 );
+	}
+	if ( level.script == "mp_dig" )
+	{
+		level.missile_swarm_origin += ( -2000, -2000, 1000 );
+	}
+	killstreak_id = self maps/mp/killstreaks/_killstreakrules::killstreakstart( "missile_swarm_mp", self.team, 0, 1 );
+	if ( killstreak_id == -1 )
+	{
+		return 0;
+	}
+	level thread swarm_killstreak_start( self, killstreak_id );
+	return 1;
+}
+
+swarm_killstreak_start( owner, killstreak_id )
+{
+	level endon( "swarm_end" );
+	missiles = getentarray( "swarm_missile", "targetname" );
+	_a102 = missiles;
+	_k102 = getFirstArrayKey( _a102 );
+	while ( isDefined( _k102 ) )
+	{
+		missile = _a102[ _k102 ];
+		if ( isDefined( missile ) )
+		{
+			missile detonate();
+			wait 0,1;
+		}
+		_k102 = getNextArrayKey( _a102, _k102 );
+	}
+	while ( isDefined( level.missile_swarm_fx ) )
+	{
+		i = 0;
+		while ( i < level.missile_swarm_fx.size )
+		{
+			if ( isDefined( level.missile_swarm_fx[ i ] ) )
+			{
+				level.missile_swarm_fx[ i ] delete();
+			}
+			i++;
+		}
+	}
+	level.missile_swarm_fx = undefined;
+	level.missile_swarm_team = owner.team;
+	level.missile_swarm_owner = owner;
+	owner maps/mp/killstreaks/_killstreaks::playkillstreakstartdialog( "missile_swarm_mp", owner.pers[ "team" ] );
+	level create_player_targeting_array( owner, owner.team );
+	level.globalkillstreakscalled++;
+	owner addweaponstat( "missile_swarm_mp", "used", 1 );
+	level thread swarm_killstreak_abort( owner, killstreak_id );
+	level thread swarm_killstreak_watch_for_emp( owner, killstreak_id );
+	level thread swarm_killstreak_fx();
+	wait 2;
+	level thread swarm_think( owner, killstreak_id );
+}
+
+swarm_killstreak_end( owner, detonate, killstreak_id )
+{
+	level notify( "swarm_end" );
+	if ( isDefined( detonate ) && detonate )
+	{
+		level setclientfield( "missile_swarm", 2 );
+	}
+	else
+	{
+		level setclientfield( "missile_swarm", 0 );
+	}
+	missiles = getentarray( "swarm_missile", "targetname" );
+	if ( is_true( detonate ) )
+	{
+		i = 0;
+		while ( i < level.missile_swarm_fx.size )
+		{
+			if ( isDefined( level.missile_swarm_fx[ i ] ) )
+			{
+				level.missile_swarm_fx[ i ] delete();
+			}
+			i++;
+		}
+		_a160 = missiles;
+		_k160 = getFirstArrayKey( _a160 );
+		while ( isDefined( _k160 ) )
+		{
+			missile = _a160[ _k160 ];
+			if ( isDefined( missile ) )
+			{
+				missile detonate();
+				wait 0,1;
+			}
+			_k160 = getNextArrayKey( _a160, _k160 );
+		}
+	}
+	else _a171 = missiles;
+	_k171 = getFirstArrayKey( _a171 );
+	while ( isDefined( _k171 ) )
+	{
+		missile = _a171[ _k171 ];
+		if ( isDefined( missile ) )
+		{
+			yaw = randomintrange( 0, 360 );
+			angles = ( 0, yaw, 0 );
+			forward = anglesToForward( angles );
+			if ( isDefined( missile.goal ) )
+			{
+				missile.goal.origin = missile.origin + ( forward * level.missile_swarm_flydist * 1000 );
+			}
+		}
+		_k171 = getNextArrayKey( _a171, _k171 );
+	}
+	wait 1;
+	level.missile_swarm_sound stoploopsound( 2 );
+	wait 2;
+	level.missile_swarm_sound delete();
+	recordstreakindex = level.killstreakindices[ level.killstreaks[ "missile_swarm_mp" ].menuname ];
+	if ( isDefined( recordstreakindex ) )
+	{
+		owner recordkillstreakendevent( recordstreakindex );
+	}
+	maps/mp/killstreaks/_killstreakrules::killstreakstop( "missile_swarm_mp", level.missile_swarm_team, killstreak_id );
+	level.missile_swarm_owner = undefined;
+	wait 4;
+	missiles = getentarray( "swarm_missile", "targetname" );
+	_a205 = missiles;
+	_k205 = getFirstArrayKey( _a205 );
+	while ( isDefined( _k205 ) )
+	{
+		missile = _a205[ _k205 ];
+		if ( isDefined( missile ) )
+		{
+			missile delete();
+			wait 0,1;
+		}
+		_k205 = getNextArrayKey( _a205, _k205 );
+	}
+	wait 6;
+	i = 0;
+	while ( i < level.missile_swarm_fx.size )
+	{
+		if ( isDefined( level.missile_swarm_fx[ i ] ) )
+		{
+			level.missile_swarm_fx[ i ] delete();
+		}
+		i++;
+	}
+}
+
+swarm_killstreak_abort( owner, killstreak_id )
+{
+	level endon( "swarm_end" );
+	owner waittill_any( "disconnect", "joined_team", "joined_spectators", "emp_jammed" );
+	level thread swarm_killstreak_end( owner, 1, killstreak_id );
+}
+
+swarm_killstreak_watch_for_emp( owner, killstreak_id )
+{
+	level endon( "swarm_end" );
+	owner waittill( "emp_destroyed_missile_swarm", attacker );
+	maps/mp/_scoreevents::processscoreevent( "destroyed_missile_swarm", attacker, owner, "emp_mp" );
+	attacker maps/mp/_challenges::addflyswatterstat( "emp_mp" );
+	level thread swarm_killstreak_end( owner, 1, killstreak_id );
+}
+
+swarm_killstreak_fx()
+{
+	level endon( "swarm_end" );
+	level.missile_swarm_fx = [];
+	yaw = randomint( 360 );
+	level.missile_swarm_fx[ 0 ] = spawn( "script_model", level.missile_swarm_origin );
+	level.missile_swarm_fx[ 0 ] setmodel( "tag_origin" );
+	level.missile_swarm_fx[ 0 ].angles = ( -90, yaw, 0 );
+	level.missile_swarm_fx[ 1 ] = spawn( "script_model", level.missile_swarm_origin );
+	level.missile_swarm_fx[ 1 ] setmodel( "tag_origin" );
+	level.missile_swarm_fx[ 1 ].angles = ( -90, yaw, 0 );
+	level.missile_swarm_fx[ 2 ] = spawn( "script_model", level.missile_swarm_origin );
+	level.missile_swarm_fx[ 2 ] setmodel( "tag_origin" );
+	level.missile_swarm_fx[ 2 ].angles = ( -90, yaw, 0 );
+	level.missile_swarm_fx[ 3 ] = spawn( "script_model", level.missile_swarm_origin );
+	level.missile_swarm_fx[ 3 ] setmodel( "tag_origin" );
+	level.missile_swarm_fx[ 3 ].angles = ( -90, yaw, 0 );
+	level.missile_swarm_fx[ 4 ] = spawn( "script_model", level.missile_swarm_origin );
+	level.missile_swarm_fx[ 4 ] setmodel( "tag_origin" );
+	level.missile_swarm_fx[ 4 ].angles = ( -90, yaw, 0 );
+	level.missile_swarm_fx[ 5 ] = spawn( "script_model", level.missile_swarm_origin );
+	level.missile_swarm_fx[ 5 ] setmodel( "tag_origin" );
+	level.missile_swarm_fx[ 5 ].angles = ( -90, yaw, 0 );
+	level.missile_swarm_fx[ 6 ] = spawn( "script_model", level.missile_swarm_origin );
+	level.missile_swarm_fx[ 6 ] setmodel( "tag_origin" );
+	level.missile_swarm_fx[ 6 ].angles = ( -90, yaw, 0 );
+	level.missile_swarm_sound = spawn( "script_model", level.missile_swarm_origin );
+	level.missile_swarm_sound setmodel( "tag_origin" );
+	level.missile_swarm_sound.angles = ( 0, 0, 1 );
+	wait 0,1;
+	playfxontag( level.swarm_fx[ "swarm" ], level.missile_swarm_fx[ 0 ], "tag_origin" );
+	wait 2;
+	level.missile_swarm_sound playloopsound( "veh_harpy_drone_swarm_lp", 3 );
+	level setclientfield( "missile_swarm", 1 );
+	current = 1;
+	while ( 1 )
+	{
+		if ( !isDefined( level.missile_swarm_fx[ current ] ) )
+		{
+			level.missile_swarm_fx[ current ] = spawn( "script_model", level.missile_swarm_origin );
+			level.missile_swarm_fx[ current ] setmodel( "tag_origin" );
+		}
+		yaw = randomint( 360 );
+		if ( isDefined( level.missile_swarm_fx[ current ] ) )
+		{
+			level.missile_swarm_fx[ current ].angles = ( -90, yaw, 0 );
+		}
+		wait 0,1;
+		if ( isDefined( level.missile_swarm_fx[ current ] ) )
+		{
+			playfxontag( level.swarm_fx[ "swarm" ], level.missile_swarm_fx[ current ], "tag_origin" );
+		}
+		current = ( current + 1 ) % 7;
+		wait 1,9;
+	}
+}
+
+swarm_think( owner, killstreak_id )
+{
+	level endon( "swarm_end" );
+	lifetime = getDvarFloat( #"4FEEA279" );
+	end_time = getTime() + ( lifetime * 1000 );
+	level.missile_swarm_count = 0;
+	while ( getTime() < end_time )
+	{
+/#
+		assert( level.missile_swarm_count >= 0 );
+#/
+		while ( level.missile_swarm_count >= level.missile_swarm_max )
+		{
+			wait 0,5;
+		}
+		count = 1;
+		level.missile_swarm_count += count;
+		i = 0;
+		while ( i < count )
+		{
+			self thread projectile_spawn( owner );
+			i++;
+		}
+		wait ( ( level.missile_swarm_count / level.missile_swarm_max ) + 0,4 );
+	}
+	level thread swarm_killstreak_end( owner, undefined, killstreak_id );
+}
+
+projectile_cam( player )
+{
+/#
+	player.swarm_cam = 1;
+	wait 0,05;
+	forward = anglesToForward( self.angles );
+	cam = spawn( "script_model", ( self.origin + vectorScale( ( 0, 0, 1 ), 300 ) ) + ( forward * -200 ) );
+	cam setmodel( "tag_origin" );
+	cam linkto( self );
+	player camerasetposition( cam );
+	player camerasetlookat( self );
+	player cameraactivate( 1 );
+	self waittill( "death" );
+	wait 1;
+	player cameraactivate( 0 );
+	cam delete();
+	player.swarm_cam = 0;
+#/
+}
+
+projectile_goal_move()
+{
+	self endon( "death" );
+	for ( ;; )
+	{
+		wait 0,25;
+		while ( distancesquared( self.origin, self.goal.origin ) < 65536 )
+		{
+			if ( distancesquared( self.origin, level.missile_swarm_origin ) > ( level.missile_swarm_flydist * level.missile_swarm_flydist ) )
+			{
+				self.goal.origin = level.missile_swarm_origin;
+				break;
+			}
+			else
+			{
+				enemy = projectile_find_random_player( self.owner, self.team );
+				if ( isDefined( enemy ) )
+				{
+					self.goal.origin = enemy.origin + ( 0, 0, self.origin[ 2 ] );
+				}
+				else
+				{
+					pitch = randomintrange( -45, 45 );
+					yaw = randomintrange( 0, 360 );
+					angles = ( 0, yaw, 0 );
+					forward = anglesToForward( angles );
+					self.goal.origin = self.origin + ( forward * level.missile_swarm_flydist );
+				}
+				nfz = crossesnoflyzone( self.origin, self.goal.origin );
+				tries = 20;
+				while ( isDefined( nfz ) && tries > 0 )
+				{
+					tries--;
+
+					pitch = randomintrange( -45, 45 );
+					yaw = randomintrange( 0, 360 );
+					angles = ( 0, yaw, 0 );
+					forward = anglesToForward( angles );
+					self.goal.origin = self.origin + ( forward * level.missile_swarm_flydist );
+					nfz = crossesnoflyzone( self.origin, self.goal.origin );
+				}
+			}
+		}
+	}
+}
+
+projectile_target_search( acceptskyexposure, acquiretime, allowplayeroffset )
+{
+	self endon( "death" );
+	wait acquiretime;
+	for ( ;; )
+	{
+		wait randomfloatrange( 0,5, 1 );
+		target = self projectile_find_target( acceptskyexposure );
+		if ( isDefined( target ) )
+		{
+			self.swarm_target = target[ "entity" ];
+			target[ "entity" ].swarm = self;
+			if ( allowplayeroffset )
+			{
+				self missile_settarget( target[ "entity" ], target[ "offset" ] );
+				self missile_dronesetvisible( 1 );
+			}
+			else
+			{
+				self missile_settarget( target[ "entity" ] );
+				self missile_dronesetvisible( 1 );
+			}
+			self playsound( "veh_harpy_drone_swarm_incomming" );
+			if ( !isDefined( target[ "entity" ].swarmsound ) || target[ "entity" ].swarmsound == 0 )
+			{
+				self thread target_sounds( target[ "entity" ] );
+			}
+			target[ "entity" ] waittill_any( "death", "disconnect", "joined_team" );
+			self missile_settarget( self.goal );
+			self missile_dronesetvisible( 0 );
+			break;
+		}
+	}
+}
+
+target_sounds( targetent )
+{
+	targetent endon( "death" );
+	targetent endon( "disconnect" );
+	targetent endon( "joined_team" );
+	self endon( "death" );
+	dist = 3000;
+	if ( isDefined( self.warningsounddist ) )
+	{
+		dist = self.warningsounddist;
+	}
+	while ( distancesquared( self.origin, targetent.origin ) > ( dist * dist ) )
+	{
+		wait 0,05;
+	}
+	if ( isDefined( targetent.swarmsound ) && targetent.swarmsound == 1 )
+	{
+		return;
+	}
+	targetent.swarmsound = 1;
+	self thread reset_sound_blocker( targetent );
+	self thread target_stop_sounds( targetent );
+	if ( isplayer( targetent ) )
+	{
+		targetent playlocalsound( level.missiledronesoundstart );
+	}
+	self playsound( level.missiledronesoundstart );
+}
+
+target_stop_sounds( targetent )
+{
+	targetent waittill_any( "disconnect", "death", "joined_team" );
+	if ( isDefined( targetent ) && isplayer( targetent ) )
+	{
+		targetent stoplocalsound( level.missiledronesoundstart );
+	}
+}
+
+reset_sound_blocker( target )
+{
+	wait 2;
+	if ( isDefined( target ) )
+	{
+		target.swarmsound = 0;
+	}
+}
+
+projectile_spawn( owner )
+{
+	level endon( "swarm_end" );
+	upvector = ( 0, 0, randomintrange( level.missile_swarm_flyheight - 1500, level.missile_swarm_flyheight - 1000 ) );
+	yaw = randomintrange( 0, 360 );
+	angles = ( 0, yaw, 0 );
+	forward = anglesToForward( angles );
+	origin = ( level.mapcenter + upvector ) + ( forward * level.missile_swarm_flydist * -1 );
+	target = ( level.mapcenter + upvector ) + ( forward * level.missile_swarm_flydist );
+	enemy = projectile_find_random_player( owner, owner.team );
+	if ( isDefined( enemy ) )
+	{
+		target = enemy.origin + upvector;
+	}
+	projectile = projectile_spawn_utility( owner, target, origin, "missile_swarm_projectile_mp", "swarm_missile", 1 );
+	projectile thread projectile_abort_think();
+	projectile thread projectile_target_search( cointoss(), 1, 1 );
+	projectile thread projectile_death_think();
+	projectile thread projectile_goal_move();
+	wait 0,1;
+	if ( isDefined( projectile ) )
+	{
+		projectile setclientfield( "missile_drone_projectile_animate", 1 );
+	}
+}
+
+projectile_spawn_utility( owner, target, origin, weapon, targetname, movegoal )
+{
+	goal = spawn( "script_model", target );
+	goal setmodel( "tag_origin" );
+	p = magicbullet( weapon, origin, target, owner, goal );
+	p.owner = owner;
+	p.team = owner.team;
+	p.goal = goal;
+	p.targetname = "swarm_missile";
+/#
+	if ( !is_true( owner.swarm_cam ) && getDvarInt( #"492656A6" ) == 1 )
+	{
+		p thread projectile_cam( owner );
+#/
+	}
+	return p;
+}
+
+projectile_death_think()
+{
+	self waittill( "death" );
+	level.missile_swarm_count--;
+
+	self.goal delete();
+}
+
+projectile_abort_think()
+{
+	self endon( "death" );
+	self.owner waittill_any( "disconnect", "joined_team" );
+	self detonate();
+}
+
+projectile_find_target( acceptskyexposure )
+{
+	ks = projectile_find_target_killstreak( acceptskyexposure );
+	player = projectile_find_target_player( acceptskyexposure );
+	if ( isDefined( ks ) && !isDefined( player ) )
+	{
+		return ks;
+	}
+	else
+	{
+		if ( !isDefined( ks ) && isDefined( player ) )
+		{
+			return player;
+		}
+		else
+		{
+			if ( isDefined( ks ) && isDefined( player ) )
+			{
+				if ( cointoss() )
+				{
+					return ks;
+				}
+				return player;
+			}
+		}
+	}
+	return undefined;
+}
+
+projectile_find_target_killstreak( acceptskyexposure )
+{
+	ks = [];
+	ks[ "offset" ] = vectorScale( ( 0, 0, 1 ), 10 );
+	targets = target_getarray();
+	rcbombs = getentarray( "rcbomb", "targetname" );
+	satellites = getentarray( "satellite", "targetname" );
+	dogs = maps/mp/killstreaks/_dogs::dog_manager_get_dogs();
+	targets = arraycombine( targets, rcbombs, 1, 0 );
+	targets = arraycombine( targets, satellites, 1, 0 );
+	targets = arraycombine( targets, dogs, 1, 0 );
+	if ( targets.size <= 0 )
+	{
+		return undefined;
+	}
+	targets = arraysort( targets, self.origin );
+	_a634 = targets;
+	_k634 = getFirstArrayKey( _a634 );
+	while ( isDefined( _k634 ) )
+	{
+		target = _a634[ _k634 ];
+		if ( isDefined( target.owner ) && target.owner == self.owner )
+		{
+		}
+		else
+		{
+			if ( isDefined( target.script_owner ) && target.script_owner == self.owner )
+			{
+				break;
+			}
+			else
+			{
+				if ( level.teambased && isDefined( target.team ) )
+				{
+					if ( target.team == self.team )
+					{
+						break;
+					}
+				}
+				else if ( level.teambased && isDefined( target.aiteam ) )
+				{
+					if ( target.aiteam == self.team )
+					{
+						break;
+					}
+				}
+				else
+				{
+					if ( bullettracepassed( self.origin, target.origin, 0, target ) )
+					{
+						ks[ "entity" ] = target;
+						return ks;
+					}
+					if ( acceptskyexposure && cointoss() )
+					{
+						end = target.origin + vectorScale( ( 0, 0, 1 ), 2048 );
+						if ( bullettracepassed( target.origin, end, 0, target ) )
+						{
+							ks[ "entity" ] = target;
+							return ks;
+						}
+					}
+				}
+			}
+		}
+		_k634 = getNextArrayKey( _a634, _k634 );
+	}
+	return undefined;
+}
+
+projectile_find_target_player( acceptexposedtosky )
+{
+	target = [];
+	players = get_players();
+	players = arraysort( players, self.origin );
+	_a692 = players;
+	_k692 = getFirstArrayKey( _a692 );
+	while ( isDefined( _k692 ) )
+	{
+		player = _a692[ _k692 ];
+		if ( !player_valid_target( player, self.team, self.owner ) )
+		{
+		}
+		else
+		{
+			if ( bullettracepassed( self.origin, player.origin, 0, player ) )
+			{
+				target[ "entity" ] = player;
+				target[ "offset" ] = ( 0, 0, 1 );
+				return target;
+			}
+			if ( bullettracepassed( self.origin, player geteye(), 0, player ) )
+			{
+				target[ "entity" ] = player;
+				target[ "offset" ] = vectorScale( ( 0, 0, 1 ), 50 );
+				return target;
+			}
+			if ( acceptexposedtosky && cointoss() )
+			{
+				end = player.origin + vectorScale( ( 0, 0, 1 ), 2048 );
+				if ( bullettracepassed( player.origin, end, 0, player ) )
+				{
+					target[ "entity" ] = player;
+					target[ "offset" ] = vectorScale( ( 0, 0, 1 ), 30 );
+					return target;
+				}
+			}
+		}
+		_k692 = getNextArrayKey( _a692, _k692 );
+	}
+	return undefined;
+}
+
+create_player_targeting_array( owner, team )
+{
+	level.playertargetedtimes = [];
+	players = get_players();
+	_a739 = players;
+	_k739 = getFirstArrayKey( _a739 );
+	while ( isDefined( _k739 ) )
+	{
+		player = _a739[ _k739 ];
+		if ( !player_valid_target( player, team, owner ) )
+		{
+		}
+		else
+		{
+			level.playertargetedtimes[ player.clientid ] = 0;
+		}
+		_k739 = getNextArrayKey( _a739, _k739 );
+	}
+}
+
+projectile_find_random_player( owner, team )
+{
+	players = get_players();
+	lowest = 10000;
+	_a757 = players;
+	_k757 = getFirstArrayKey( _a757 );
+	while ( isDefined( _k757 ) )
+	{
+		player = _a757[ _k757 ];
+		if ( !player_valid_target( player, team, owner ) )
+		{
+		}
+		else
+		{
+			if ( !isDefined( level.playertargetedtimes[ player.clientid ] ) )
+			{
+				level.playertargetedtimes[ player.clientid ] = 0;
+			}
+			if ( level.playertargetedtimes[ player.clientid ] < lowest || level.playertargetedtimes[ player.clientid ] == lowest && randomint( 100 ) > 50 )
+			{
+				target = player;
+				lowest = level.playertargetedtimes[ player.clientid ];
+			}
+		}
+		_k757 = getNextArrayKey( _a757, _k757 );
+	}
+	if ( isDefined( target ) )
+	{
+		level.playertargetedtimes[ target.clientid ] += 1;
+		return target;
+	}
+	return undefined;
+}
+
+player_valid_target( player, team, owner )
+{
+	if ( player.sessionstate != "playing" )
+	{
+		return 0;
+	}
+	if ( !isalive( player ) )
+	{
+		return 0;
+	}
+	if ( player == owner )
+	{
+		return 0;
+	}
+	if ( level.teambased )
+	{
+		if ( team == player.team )
+		{
+			return 0;
+		}
+	}
+	if ( player cantargetplayerwithspecialty() == 0 )
+	{
+		return 0;
+	}
+	if ( isDefined( player.lastspawntime ) && ( getTime() - player.lastspawntime ) < 3000 )
+	{
+		return 0;
+	}
+/#
+	if ( player isinmovemode( "ufo", "noclip" ) )
+	{
+		return 0;
+#/
+	}
+	return 1;
+}

patch_mp/maps/mp/killstreaks/_planemortar.gsc

@@ -0,0 +1,367 @@
+#include maps/mp/_challenges;
+#include maps/mp/_scoreevents;
+#include maps/mp/gametypes/_spawning;
+#include maps/mp/killstreaks/_killstreakrules;
+#include maps/mp/killstreaks/_killstreaks;
+#include maps/mp/killstreaks/_airsupport;
+#include common_scripts/utility;
+#include maps/mp/_utility;
+
+init()
+{
+	precachemodel( "veh_t6_air_fa38_killstreak" );
+	precachemodel( "veh_t6_air_fa38_killstreak_alt" );
+	precachelocationselector( "map_mortar_selector" );
+	level.planemortarexhaustfx = loadfx( "vehicle/exhaust/fx_exhaust_f35_afterburner" );
+	registerclientfield( "scriptmover", "planemortar_contrail", 1, 1, "int" );
+	maps/mp/killstreaks/_killstreaks::registerkillstreak( "planemortar_mp", "planemortar_mp", "killstreak_planemortar", "planemortar_used", ::usekillstreakplanemortar, 1 );
+	maps/mp/killstreaks/_killstreaks::registerkillstreakstrings( "planemortar_mp", &"MP_EARNED_PLANEMORTAR", &"KILLSTREAK_PLANEMORTAR_NOT_AVAILABLE", &"MP_WAR_PLANEMORTAR_INBOUND", &"MP_WAR_PLANEMORTAR_INBOUND_NEAR_YOUR_POSITION" );
+	maps/mp/killstreaks/_killstreaks::registerkillstreakdialog( "planemortar_mp", "mpl_killstreak_planemortar", "kls_planemortar_used", "", "kls_planemortar_enemy", "", "kls_planemortar_ready" );
+	maps/mp/killstreaks/_killstreaks::registerkillstreakdevdvar( "planemortar_mp", "scr_giveplanemortar" );
+	maps/mp/killstreaks/_killstreaks::setkillstreakteamkillpenaltyscale( "planemortar_mp", level.teamkillreducedpenalty );
+}
+
+usekillstreakplanemortar( hardpointtype )
+{
+	if ( self maps/mp/killstreaks/_killstreakrules::iskillstreakallowed( hardpointtype, self.team ) == 0 )
+	{
+		return 0;
+	}
+	self thread playpilotdialog( "a10_used", 1,5 );
+	result = self selectplanemortarlocation( hardpointtype );
+	if ( !isDefined( result ) || !result )
+	{
+		return 0;
+	}
+	return 1;
+}
+
+waittill_confirm_location()
+{
+	self endon( "emp_jammed" );
+	self endon( "emp_grenaded" );
+	self waittill( "confirm_location", location );
+	return location;
+}
+
+selectplanemortarlocation( hardpointtype )
+{
+	self beginlocationmortarselection( "map_mortar_selector", 800 );
+	self.selectinglocation = 1;
+	self thread endselectionthink();
+	locations = [];
+	if ( !isDefined( self.pers[ "mortarRadarUsed" ] ) || !self.pers[ "mortarRadarUsed" ] )
+	{
+		self thread singleradarsweep();
+	}
+	i = 0;
+	while ( i < 3 )
+	{
+		location = self waittill_confirm_location();
+		if ( !isDefined( self ) )
+		{
+			return 0;
+		}
+		if ( !isDefined( location ) )
+		{
+			self.pers[ "mortarRadarUsed" ] = 1;
+			self notify( "cancel_selection" );
+			return 0;
+		}
+		locations[ i ] = location;
+		i++;
+	}
+	if ( self maps/mp/killstreaks/_killstreakrules::iskillstreakallowed( hardpointtype, self.team ) == 0 )
+	{
+		self.pers[ "mortarRadarUsed" ] = 1;
+		self notify( "cancel_selection" );
+		return 0;
+	}
+	self.pers[ "mortarRadarUsed" ] = 0;
+	return self finishhardpointlocationusage( locations, ::useplanemortar );
+}
+
+playpilotdialog( dialog, waittime )
+{
+	if ( isDefined( waittime ) )
+	{
+		wait waittime;
+	}
+	self.pilotvoicenumber = self.bcvoicenumber + 1;
+	soundalias = level.teamprefix[ self.team ] + self.pilotvoicenumber + "_" + dialog;
+	while ( isDefined( self ) )
+	{
+		while ( self.pilotisspeaking )
+		{
+			while ( self.pilotisspeaking )
+			{
+				wait 0,2;
+			}
+		}
+	}
+	if ( isDefined( self ) )
+	{
+		self playlocalsound( soundalias );
+		self.pilotisspeaking = 1;
+		self thread waitplaybacktime( soundalias );
+		self waittill_any( soundalias, "death", "disconnect" );
+		if ( isDefined( self ) )
+		{
+			self.pilotisspeaking = 0;
+		}
+	}
+}
+
+waitplaybacktime( soundalias )
+{
+	self endon( "death" );
+	self endon( "disconnect" );
+	playbacktime = soundgetplaybacktime( soundalias );
+	if ( playbacktime >= 0 )
+	{
+		waittime = playbacktime * 0,001;
+		wait waittime;
+	}
+	else
+	{
+		wait 1;
+	}
+	self notify( soundalias );
+}
+
+singleradarsweep()
+{
+	self endon( "disconnect" );
+	self endon( "cancel_selection" );
+	wait 0,5;
+	self playlocalsound( "mpl_killstreak_satellite" );
+	if ( level.teambased )
+	{
+		has_satellite = level.activesatellites[ self.team ] > 0;
+	}
+	else
+	{
+		has_satellite = level.activesatellites[ self.entnum ] > 0;
+	}
+	if ( self.hasspyplane == 0 && !has_satellite && !level.forceradar )
+	{
+		self thread doradarsweep();
+	}
+}
+
+doradarsweep()
+{
+	self setclientuivisibilityflag( "g_compassShowEnemies", 1 );
+	wait 0,2;
+	self setclientuivisibilityflag( "g_compassShowEnemies", 0 );
+}
+
+useplanemortar( positions )
+{
+	team = self.team;
+	killstreak_id = self maps/mp/killstreaks/_killstreakrules::killstreakstart( "planemortar_mp", team, 0, 1 );
+	if ( killstreak_id == -1 )
+	{
+		return 0;
+	}
+	self maps/mp/killstreaks/_killstreaks::playkillstreakstartdialog( "planemortar_mp", team, 1 );
+	level.globalkillstreakscalled++;
+	self addweaponstat( "planemortar_mp", "used", 1 );
+	self thread planemortar_watchforendnotify( team, killstreak_id );
+	self thread doplanemortar( positions, team, killstreak_id );
+	return 1;
+}
+
+doplanemortar( positions, team, killstreak_id )
+{
+	self endon( "emp_jammed" );
+	self endon( "disconnect" );
+	yaw = randomintrange( 0, 360 );
+	odd = 0;
+	wait 1,25;
+	_a221 = positions;
+	_k221 = getFirstArrayKey( _a221 );
+	while ( isDefined( _k221 ) )
+	{
+		position = _a221[ _k221 ];
+		maps/mp/gametypes/_spawning::create_artillery_influencers( position, -1 );
+		self thread dobombrun( position, yaw, team );
+		if ( odd == 0 )
+		{
+			yaw = ( yaw + 35 ) % 360;
+		}
+		else
+		{
+			yaw = ( yaw + 290 ) % 360;
+		}
+		odd = ( odd + 1 ) % 2;
+		wait 0,8;
+		_k221 = getNextArrayKey( _a221, _k221 );
+	}
+	self notify( "planemortarcomplete" );
+	wait 1;
+	self thread plane_mortar_bda_dialog();
+}
+
+plane_mortar_bda_dialog()
+{
+	if ( !isDefined( self.planemortarbda ) )
+	{
+		self.planemortarbda = 0;
+	}
+	if ( self.planemortarbda == 0 )
+	{
+		bdadialog = "kls_killn";
+	}
+	if ( self.planemortarbda == 1 )
+	{
+		bdadialog = "kls_kill1";
+	}
+	if ( self.planemortarbda == 2 )
+	{
+		bdadialog = "kls_kill2";
+	}
+	if ( self.planemortarbda == 3 )
+	{
+		bdadialog = "kls_kill3";
+	}
+	if ( self.planemortarbda > 3 )
+	{
+		bdadialog = "kls_killm";
+	}
+	if ( isDefined( bdadialog ) )
+	{
+		self thread playpilotdialog( bdadialog );
+	}
+	self.planemortarbda = 0;
+}
+
+planemortar_watchforendnotify( team, killstreak_id )
+{
+	self waittill_any( "disconnect", "joined_team", "joined_spectators", "planemortarcomplete", "emp_jammed" );
+	planemortar_killstreakstop( team, killstreak_id );
+}
+
+planemortar_killstreakstop( team, killstreak_id )
+{
+	maps/mp/killstreaks/_killstreakrules::killstreakstop( "planemortar_mp", team, killstreak_id );
+}
+
+dobombrun( position, yaw, team )
+{
+	self endon( "emp_jammed" );
+	player = self;
+	angles = ( 0, yaw, 0 );
+	direction = anglesToForward( angles );
+	height = maps/mp/killstreaks/_airsupport::getminimumflyheight() + 2000;
+	position = ( position[ 0 ], position[ 1 ], height );
+	startpoint = position + vectorScale( direction, -12000 );
+	endpoint = position + vectorScale( direction, 18000 );
+	height = getnoflyzoneheightcrossed( startpoint, endpoint, height );
+	startpoint = ( startpoint[ 0 ], startpoint[ 1 ], height );
+	position = ( position[ 0 ], position[ 1 ], height );
+	endpoint = ( endpoint[ 0 ], endpoint[ 1 ], height );
+	plane = spawnplane( self, "script_model", startpoint );
+	plane.team = team;
+	plane.targetname = "plane_mortar";
+	plane.owner = self;
+	plane endon( "delete" );
+	plane endon( "death" );
+	plane thread planewatchforemp( self );
+	plane.angles = angles;
+	plane setmodel( "veh_t6_air_fa38_killstreak" );
+	plane setenemymodel( "veh_t6_air_fa38_killstreak_alt" );
+	plane setclientfield( "planemortar_contrail", 1 );
+	plane playsound( "mpl_lightning_flyover_boom" );
+	plane setdrawinfrared( 1 );
+	plane.killcament = spawn( "script_model", plane.origin + vectorScale( ( 0, 0, -1 ), 700 ) + vectorScale( direction, -1500 ) );
+	plane.killcament deleteaftertime( 2 * 3 );
+	plane.killcament.angles = ( 15, yaw, 0 );
+	plane.killcament.starttime = getTime();
+	plane.killcament linkto( plane );
+	start = ( position[ 0 ], position[ 1 ], plane.origin[ 2 ] );
+	impact = bullettrace( start, start + vectorScale( ( 0, 0, -1 ), 100000 ), 1, plane );
+	plane moveto( endpoint, ( 2 * 5 ) / 4, 0, 0 );
+	plane.killcament thread followbomb( plane, position, direction, impact, player );
+	wait ( 2 / 2 );
+	if ( isDefined( self ) )
+	{
+		self thread dropbomb( plane, position );
+	}
+	wait ( ( 2 * 3 ) / 4 );
+	plane plane_cleanupondeath();
+}
+
+followbomb( plane, position, direction, impact, player )
+{
+	player endon( "emp_jammed" );
+	wait ( ( 2 * 5 ) / 12 );
+	plane.killcament unlink();
+	plane.killcament moveto( impact[ "position" ] + vectorScale( ( 0, 0, -1 ), 1000 ) + vectorScale( direction, -600 ), 0,8, 0, 0,2 );
+}
+
+lookatexplosion( bomb )
+{
+	while ( isDefined( self ) && isDefined( bomb ) )
+	{
+		angles = vectorToAngle( vectornormalize( bomb.origin - self.origin ) );
+		self.angles = ( max( angles[ 0 ], 15 ), angles[ 1 ], angles[ 2 ] );
+		wait 0,05;
+	}
+}
+
+planewatchforemp( owner )
+{
+	self endon( "delete" );
+	self endon( "death" );
+	self waittill( "emp_deployed", attacker );
+	thread planeawardscoreevent( attacker, self );
+	self plane_cleanupondeath();
+}
+
+planeawardscoreevent( attacker, victim )
+{
+	attacker endon( "disconnect" );
+	attacker notify( "planeAwardScoreEvent_singleton" );
+	attacker endon( "planeAwardScoreEvent_singleton" );
+	waittillframeend;
+	maps/mp/_scoreevents::processscoreevent( "destroyed_plane_mortar", attacker, victim, "emp_mp" );
+	attacker maps/mp/_challenges::addflyswatterstat( "emp_mp" );
+}
+
+plane_cleanupondeath()
+{
+	self delete();
+}
+
+dropbomb( plane, bombposition )
+{
+	if ( !isDefined( plane.owner ) )
+	{
+		return;
+	}
+	targets = getplayers();
+	_a407 = targets;
+	_k407 = getFirstArrayKey( _a407 );
+	while ( isDefined( _k407 ) )
+	{
+		target = _a407[ _k407 ];
+		if ( plane.owner isenemyplayer( target ) && distance2dsquared( target.origin, bombposition ) < 250000 )
+		{
+			if ( bullettracepassed( ( target.origin[ 0 ], target.origin[ 1 ], plane.origin[ 2 ] ), target.origin, 0, plane ) )
+			{
+				bombposition = target.origin;
+				break;
+			}
+		}
+		else
+		{
+			_k407 = getNextArrayKey( _a407, _k407 );
+		}
+	}
+	bombposition = ( bombposition[ 0 ], bombposition[ 1 ], plane.origin[ 2 ] );
+	bomb = self launchbomb( "planemortar_mp", bombposition, vectorScale( ( 0, 0, -1 ), 5000 ) );
+	bomb playsound( "mpl_lightning_bomb_incoming" );
+	bomb.killcament = plane.killcament;
+	plane.killcament thread lookatexplosion( bomb );
+}

patch_mp/maps/mp/killstreaks/_radar.gsc

@@ -0,0 +1,292 @@
+#include maps/mp/_popups;
+#include maps/mp/killstreaks/_spyplane;
+#include maps/mp/killstreaks/_killstreakrules;
+#include maps/mp/killstreaks/_killstreaks;
+#include maps/mp/gametypes/_tweakables;
+#include common_scripts/utility;
+#include maps/mp/_utility;
+
+init()
+{
+	setmatchflag( "radar_allies", 0 );
+	setmatchflag( "radar_axis", 0 );
+	level.spyplane = [];
+	level.counterspyplane = [];
+	level.satellite = [];
+	level.spyplanetype = [];
+	level.satellitetype = [];
+	level.radartimers = [];
+	_a14 = level.teams;
+	_k14 = getFirstArrayKey( _a14 );
+	while ( isDefined( _k14 ) )
+	{
+		team = _a14[ _k14 ];
+		level.radartimers[ team ] = getTime();
+		_k14 = getNextArrayKey( _a14, _k14 );
+	}
+	level.spyplaneviewtime = 25;
+	level.counteruavviewtime = 30;
+	level.radarlongviewtime = 45;
+	if ( maps/mp/gametypes/_tweakables::gettweakablevalue( "killstreak", "allowradar" ) )
+	{
+		maps/mp/killstreaks/_killstreaks::registerkillstreak( "radar_mp", "radar_mp", "killstreak_spyplane", "uav_used", ::usekillstreakradar );
+		maps/mp/killstreaks/_killstreaks::registerkillstreakstrings( "radar_mp", &"KILLSTREAK_EARNED_RADAR", &"KILLSTREAK_RADAR_NOT_AVAILABLE", &"KILLSTREAK_RADAR_INBOUND" );
+		maps/mp/killstreaks/_killstreaks::registerkillstreakdialog( "radar_mp", "mpl_killstreak_radar", "kls_u2_used", "", "kls_u2_enemy", "", "kls_u2_ready" );
+		maps/mp/killstreaks/_killstreaks::registerkillstreakdevdvar( "radar_mp", "scr_giveradar" );
+		maps/mp/killstreaks/_killstreaks::createkillstreaktimer( "radar_mp" );
+	}
+	if ( maps/mp/gametypes/_tweakables::gettweakablevalue( "killstreak", "allowcounteruav" ) )
+	{
+		maps/mp/killstreaks/_killstreaks::registerkillstreak( "counteruav_mp", "counteruav_mp", "killstreak_counteruav", "counteruav_used", ::usekillstreakcounteruav );
+		maps/mp/killstreaks/_killstreaks::registerkillstreakstrings( "counteruav_mp", &"KILLSTREAK_EARNED_COUNTERUAV", &"KILLSTREAK_COUNTERUAV_NOT_AVAILABLE", &"KILLSTREAK_COUNTERUAV_INBOUND" );
+		maps/mp/killstreaks/_killstreaks::registerkillstreakdialog( "counteruav_mp", "mpl_killstreak_radar", "kls_cu2_used", "", "kls_cu2_enemy", "", "kls_cu2_ready" );
+		maps/mp/killstreaks/_killstreaks::registerkillstreakdevdvar( "counteruav_mp", "scr_givecounteruav" );
+		maps/mp/killstreaks/_killstreaks::createkillstreaktimer( "counteruav_mp" );
+	}
+	if ( maps/mp/gametypes/_tweakables::gettweakablevalue( "killstreak", "allowradardirection" ) )
+	{
+		maps/mp/killstreaks/_killstreaks::registerkillstreak( "radardirection_mp", "radardirection_mp", "killstreak_spyplane_direction", "uav_used", ::usekillstreaksatellite );
+		maps/mp/killstreaks/_killstreaks::registerkillstreakstrings( "radardirection_mp", &"KILLSTREAK_EARNED_SATELLITE", &"KILLSTREAK_SATELLITE_NOT_AVAILABLE", &"KILLSTREAK_SATELLITE_INBOUND" );
+		maps/mp/killstreaks/_killstreaks::registerkillstreakdialog( "radardirection_mp", "mpl_killstreak_satellite", "kls_sat_used", "", "kls_sat_enemy", "", "kls_sat_ready" );
+		maps/mp/killstreaks/_killstreaks::registerkillstreakdevdvar( "radardirection_mp", "scr_giveradardirection" );
+		maps/mp/killstreaks/_killstreaks::createkillstreaktimer( "radardirection_mp" );
+	}
+}
+
+usekillstreakradar( hardpointtype )
+{
+	if ( self maps/mp/killstreaks/_killstreakrules::iskillstreakallowed( hardpointtype, self.team ) == 0 )
+	{
+		return 0;
+	}
+	killstreak_id = self maps/mp/killstreaks/_killstreakrules::killstreakstart( hardpointtype, self.team );
+	if ( killstreak_id == -1 )
+	{
+		return 0;
+	}
+	return self maps/mp/killstreaks/_spyplane::callspyplane( hardpointtype, 0, killstreak_id );
+}
+
+usekillstreakcounteruav( hardpointtype )
+{
+	if ( self maps/mp/killstreaks/_killstreakrules::iskillstreakallowed( hardpointtype, self.team ) == 0 )
+	{
+		return 0;
+	}
+	killstreak_id = self maps/mp/killstreaks/_killstreakrules::killstreakstart( hardpointtype, self.team );
+	if ( killstreak_id == -1 )
+	{
+		return 0;
+	}
+	return self maps/mp/killstreaks/_spyplane::callcounteruav( hardpointtype, 0, killstreak_id );
+}
+
+usekillstreaksatellite( hardpointtype )
+{
+	if ( self maps/mp/killstreaks/_killstreakrules::iskillstreakallowed( hardpointtype, self.team ) == 0 )
+	{
+		return 0;
+	}
+	killstreak_id = self maps/mp/killstreaks/_killstreakrules::killstreakstart( hardpointtype, self.team );
+	if ( killstreak_id == -1 )
+	{
+		return 0;
+	}
+	return self maps/mp/killstreaks/_spyplane::callsatellite( hardpointtype, 0, killstreak_id );
+}
+
+teamhasspyplane( team )
+{
+	return getteamspyplane( team ) > 0;
+}
+
+teamhassatellite( team )
+{
+	return getteamsatellite( team ) > 0;
+}
+
+useradaritem( hardpointtype, team, displaymessage )
+{
+	team = self.team;
+/#
+	assert( isDefined( level.players ) );
+#/
+	self maps/mp/killstreaks/_killstreaks::playkillstreakstartdialog( hardpointtype, team );
+	if ( level.teambased )
+	{
+		if ( !isDefined( level.spyplane[ team ] ) )
+		{
+			level.spyplanetype[ team ] = 0;
+		}
+		currenttypespyplane = level.spyplanetype[ team ];
+		if ( !isDefined( level.satellitetype[ team ] ) )
+		{
+			level.satellitetype[ team ] = 0;
+		}
+		currenttypesatellite = level.satellitetype[ team ];
+	}
+	else
+	{
+		if ( !isDefined( self.pers[ "spyplaneType" ] ) )
+		{
+			self.pers[ "spyplaneType" ] = 0;
+		}
+		currenttypespyplane = self.pers[ "spyplaneType" ];
+		if ( !isDefined( self.pers[ "satelliteType" ] ) )
+		{
+			self.pers[ "satelliteType" ] = 0;
+		}
+		currenttypesatellite = self.pers[ "satelliteType" ];
+	}
+	radarviewtype = 0;
+	normal = 1;
+	fastsweep = 2;
+	notifystring = "";
+	issatellite = 0;
+	isradar = 0;
+	iscounteruav = 0;
+	viewtime = level.spyplaneviewtime;
+	switch( hardpointtype )
+	{
+		case "radar_mp":
+			notifystring = "spyplane";
+			isradar = 1;
+			viewtime = level.spyplaneviewtime;
+			level.globalkillstreakscalled++;
+			self addweaponstat( hardpointtype, "used", 1 );
+			break;
+		case "radardirection_mp":
+			notifystring = "satellite";
+			issatellite = 1;
+			viewtime = level.radarlongviewtime;
+			level notify( "satelliteInbound" );
+			level.globalkillstreakscalled++;
+			self addweaponstat( hardpointtype, "used", 1 );
+			break;
+		case "counteruav_mp":
+			notifystring = "counteruav";
+			iscounteruav = 1;
+			viewtime = level.counteruavviewtime;
+			level.globalkillstreakscalled++;
+			self addweaponstat( hardpointtype, "used", 1 );
+			break;
+	}
+	if ( displaymessage )
+	{
+		if ( isDefined( level.killstreaks[ hardpointtype ] ) && isDefined( level.killstreaks[ hardpointtype ].inboundtext ) )
+		{
+			level thread maps/mp/_popups::displaykillstreakteammessagetoall( hardpointtype, self );
+		}
+	}
+	return viewtime;
+}
+
+resetspyplanetypeonend( type )
+{
+	self waittill( type + "_timer_kill" );
+	self.pers[ "spyplane" ] = 0;
+}
+
+resetsatellitetypeonend( type )
+{
+	self waittill( type + "_timer_kill" );
+	self.pers[ "satellite" ] = 0;
+}
+
+setteamspyplanewrapper( team, value )
+{
+	setteamspyplane( team, value );
+	if ( team == "allies" )
+	{
+		setmatchflag( "radar_allies", value );
+	}
+	else
+	{
+		if ( team == "axis" )
+		{
+			setmatchflag( "radar_axis", value );
+		}
+	}
+	while ( level.multiteam == 1 )
+	{
+		_a205 = level.players;
+		_k205 = getFirstArrayKey( _a205 );
+		while ( isDefined( _k205 ) )
+		{
+			player = _a205[ _k205 ];
+			if ( player.team == team )
+			{
+				player setclientuivisibilityflag( "radar_client", value );
+			}
+			_k205 = getNextArrayKey( _a205, _k205 );
+		}
+	}
+	level notify( "radar_status_change" );
+}
+
+setteamsatellitewrapper( team, value )
+{
+	setteamsatellite( team, value );
+	if ( team == "allies" )
+	{
+		setmatchflag( "radar_allies", value );
+	}
+	else
+	{
+		if ( team == "axis" )
+		{
+			setmatchflag( "radar_axis", value );
+		}
+	}
+	while ( level.multiteam == 1 )
+	{
+		_a228 = level.players;
+		_k228 = getFirstArrayKey( _a228 );
+		while ( isDefined( _k228 ) )
+		{
+			player = _a228[ _k228 ];
+			if ( player.team == team )
+			{
+				player setclientuivisibilityflag( "radar_client", value );
+			}
+			_k228 = getNextArrayKey( _a228, _k228 );
+		}
+	}
+	level notify( "radar_status_change" );
+}
+
+enemyobituarytext( type, numseconds )
+{
+	switch( type )
+	{
+		case "radarupdate_mp":
+			self iprintln( &"MP_WAR_RADAR_ACQUIRED_UPDATE_ENEMY", numseconds );
+			break;
+		case "radardirection_mp":
+			self iprintln( &"MP_WAR_RADAR_ACQUIRED_DIRECTION_ENEMY", numseconds );
+			break;
+		case "counteruav_mp":
+			self iprintln( &"MP_WAR_RADAR_COUNTER_UAV_ACQUIRED_ENEMY", numseconds );
+			break;
+		default:
+			self iprintln( &"MP_WAR_RADAR_ACQUIRED_ENEMY", numseconds );
+	}
+}
+
+friendlyobituarytext( type, callingplayer, numseconds )
+{
+	switch( type )
+	{
+		case "radarupdate_mp":
+			self iprintln( &"MP_WAR_RADAR_UPDATE_ACQUIRED", callingplayer, numseconds );
+			break;
+		case "radardirection_mp":
+			self iprintln( &"MP_WAR_RADAR_DIRECTION_ACQUIRED", callingplayer, numseconds );
+			break;
+		case "counteruav_mp":
+			self iprintln( &"MP_WAR_RADAR_COUNTER_UAV_ACQUIRED", numseconds );
+			break;
+		default:
+			self iprintln( &"MP_WAR_RADAR_ACQUIRED", callingplayer, numseconds );
+	}
+}

patch_mp/maps/mp/killstreaks/_rcbomb.gsc

@@ -0,0 +1,792 @@
+#include maps/mp/_challenges;
+#include maps/mp/gametypes/_shellshock;
+#include maps/mp/killstreaks/_emp;
+#include maps/mp/gametypes/_hostmigration;
+#include maps/mp/gametypes/_hud;
+#include maps/mp/_popups;
+#include maps/mp/gametypes/_weaponobjects;
+#include maps/mp/gametypes/_globallogic_utils;
+#include maps/mp/_flashgrenades;
+#include maps/mp/_scoreevents;
+#include maps/mp/gametypes/_spawning;
+#include maps/mp/killstreaks/_killstreakrules;
+#include maps/mp/killstreaks/_killstreaks;
+#include maps/mp/gametypes/_tweakables;
+#include common_scripts/utility;
+#include maps/mp/_utility;
+
+init()
+{
+	precachemodel( "veh_t6_drone_rcxd" );
+	precachemodel( "veh_t6_drone_rcxd_alt" );
+	precachevehicle( "rc_car_medium_mp" );
+	precacherumble( "rcbomb_engine_stutter" );
+	precacherumble( "rcbomb_slide" );
+	loadtreadfx( "dust" );
+	loadtreadfx( "concrete" );
+	loadfx( "weapon/grenade/fx_spark_disabled_rc_car" );
+	loadfx( "vehicle/light/fx_rcbomb_blinky_light" );
+	loadfx( "vehicle/light/fx_rcbomb_solid_light" );
+	loadfx( "vehicle/light/fx_rcbomb_light_green_os" );
+	loadfx( "vehicle/light/fx_rcbomb_light_red_os" );
+	maps/mp/_treadfx::preloadtreadfx( "rc_car_medium_mp" );
+	level._effect[ "rcbombexplosion" ] = loadfx( "maps/mp_maps/fx_mp_exp_rc_bomb" );
+	car_size = getDvar( "scr_rcbomb_car_size" );
+	if ( car_size == "" )
+	{
+		setdvar( "scr_rcbomb_car_size", "1" );
+	}
+	setdvar( "scr_rcbomb_notimeout", 0 );
+	if ( maps/mp/gametypes/_tweakables::gettweakablevalue( "killstreak", "allowrcbomb" ) )
+	{
+		maps/mp/killstreaks/_killstreaks::registerkillstreak( "rcbomb_mp", "rcbomb_mp", "killstreak_rcbomb", "rcbomb_used", ::usekillstreakrcbomb );
+		maps/mp/killstreaks/_killstreaks::registerkillstreakstrings( "rcbomb_mp", &"KILLSTREAK_EARNED_RCBOMB", &"KILLSTREAK_RCBOMB_NOT_AVAILABLE", &"KILLSTREAK_RCBOMB_INBOUND" );
+		maps/mp/killstreaks/_killstreaks::registerkillstreakdialog( "rcbomb_mp", "mpl_killstreak_rcbomb", "kls_rcbomb_used", "", "kls_rcbomb_enemy", "", "kls_rcbomb_ready" );
+		maps/mp/killstreaks/_killstreaks::registerkillstreakdevdvar( "rcbomb_mp", "scr_givercbomb" );
+		maps/mp/killstreaks/_killstreaks::allowkillstreakassists( "rcbomb_mp", 1 );
+	}
+}
+
+register()
+{
+	registerclientfield( "vehicle", "rcbomb_death", 1, 1, "int" );
+	registerclientfield( "vehicle", "rcbomb_countdown", 1, 2, "int" );
+}
+
+loadtreadfx( type )
+{
+	loadfx( "vehicle/treadfx/fx_treadfx_rcbomb_" + type );
+	loadfx( "vehicle/treadfx/fx_treadfx_rcbomb_" + type + "_drift" );
+	loadfx( "vehicle/treadfx/fx_treadfx_rcbomb_" + type + "_peel" );
+	loadfx( "vehicle/treadfx/fx_treadfx_rcbomb_" + type + "_first_person" );
+	loadfx( "vehicle/treadfx/fx_treadfx_rcbomb_" + type + "_reverse" );
+	loadfx( "vehicle/treadfx/fx_treadfx_rcbomb_" + type + "_trail" );
+	loadfx( "vehicle/treadfx/fx_treadfx_rcbomb_" + type + "_slow" );
+}
+
+usekillstreakrcbomb( hardpointtype )
+{
+	if ( self maps/mp/killstreaks/_killstreakrules::iskillstreakallowed( hardpointtype, self.team ) == 0 )
+	{
+		return 0;
+	}
+	if ( !self isonground() || self isusingremote() )
+	{
+		self iprintlnbold( &"KILLSTREAK_RCBOMB_NOT_PLACEABLE" );
+		return 0;
+	}
+	placement = self.rcbombplacement;
+	if ( !isDefined( placement ) )
+	{
+		placement = getrcbombplacement();
+	}
+	if ( !isDefined( placement ) )
+	{
+		self iprintlnbold( &"KILLSTREAK_RCBOMB_NOT_PLACEABLE" );
+		return 0;
+	}
+	if ( maps/mp/killstreaks/_killstreaks::isinteractingwithobject() )
+	{
+		self iprintlnbold( &"KILLSTREAK_RCBOMB_NOT_PLACEABLE" );
+		return 0;
+	}
+	self setusingremote( "rcbomb" );
+	self freezecontrolswrapper( 1 );
+	result = self maps/mp/killstreaks/_killstreaks::initridekillstreak( "rcbomb" );
+	if ( result != "success" )
+	{
+		if ( result != "disconnect" )
+		{
+			self clearusingremote();
+		}
+		return 0;
+	}
+	if ( level.gameended )
+	{
+		return 0;
+	}
+	ret = self usercbomb( placement );
+	if ( !isDefined( ret ) && level.gameended )
+	{
+		ret = 1;
+	}
+	else
+	{
+		if ( !isDefined( ret ) )
+		{
+			ret = 0;
+		}
+	}
+	if ( isDefined( self ) )
+	{
+		self clearusingremote();
+	}
+	return ret;
+}
+
+spawnrcbomb( placement, team )
+{
+	car_size = getDvar( "scr_rcbomb_car_size" );
+	model = "veh_t6_drone_rcxd";
+	enemymodel = "veh_t6_drone_rcxd_alt";
+	death_model = "veh_t6_drone_rcxd";
+	car = "rc_car_medium_mp";
+	vehicle = spawnvehicle( model, "rcbomb", car, placement.origin, placement.angles );
+	vehicle makevehicleunusable();
+	vehicle.death_model = death_model;
+	vehicle.allowfriendlyfiredamageoverride = ::rccarallowfriendlyfiredamage;
+	vehicle setenemymodel( enemymodel );
+	vehicle enableaimassist();
+	vehicle setowner( self );
+	vehicle setvehicleteam( team );
+	vehicle.team = team;
+	vehicle setdrawinfrared( 1 );
+	maps/mp/_treadfx::loadtreadfx( vehicle );
+	vehicle maps/mp/gametypes/_spawning::create_rcbomb_influencers( team );
+	return vehicle;
+}
+
+getrcbombplacement()
+{
+	return calculatespawnorigin( self.origin, self.angles );
+}
+
+giveplayercontrolofrcbomb()
+{
+	self endon( "disconnect" );
+	level endon( "game_ended" );
+	self thread maps/mp/killstreaks/_killstreaks::playkillstreakstartdialog( "rcbomb_mp", self.team );
+	level.globalkillstreakscalled++;
+	self addweaponstat( "rcbomb_mp", "used", 1 );
+	xpamount = maps/mp/killstreaks/_killstreaks::getxpamountforkillstreak( "rcbomb_mp" );
+	if ( maps/mp/_scoreevents::shouldaddrankxp( self ) )
+	{
+		self addrankxpvalue( "killstreakCalledIn", xpamount );
+	}
+	self freeze_player_controls( 0 );
+	self.rcbomb usevehicle( self, 0 );
+	self thread playerdisconnectwaiter( self.rcbomb );
+	self thread cardetonatewaiter( self.rcbomb );
+	self thread exitcarwaiter( self.rcbomb );
+	self thread gameendwatcher( self.rcbomb );
+	self thread changeteamwaiter( self.rcbomb );
+	self.rcbomb thread maps/mp/_flashgrenades::monitorrcbombflash();
+	self thread cartimer( self.rcbomb );
+	self waittill( "rcbomb_done" );
+}
+
+usercbomb( placement )
+{
+	self endon( "disconnect" );
+	level endon( "game_ended" );
+	hardpointtype = "rcbomb_mp";
+	maps/mp/gametypes/_globallogic_utils::waittillslowprocessallowed();
+	if ( isDefined( self ) && isalive( self ) || self isremotecontrolling() && self maps/mp/killstreaks/_killstreaks::isinteractingwithobject() )
+	{
+		self iprintlnbold( &"KILLSTREAK_RCBOMB_NOT_PLACEABLE" );
+		return 0;
+	}
+	if ( !isDefined( self.rcbomb ) )
+	{
+		self.rcbomb = self spawnrcbomb( placement, self.team );
+		self.rcbomb thread carcleanupwaiter( self.rcbomb );
+		self.rcbomb thread trigger_hurt_monitor();
+		self.rcbomb.team = self.team;
+		if ( !isDefined( self.rcbomb ) )
+		{
+			return 0;
+		}
+		self maps/mp/gametypes/_weaponobjects::addweaponobjecttowatcher( "rcbomb", self.rcbomb );
+	}
+	killstreak_id = self maps/mp/killstreaks/_killstreakrules::killstreakstart( hardpointtype, self.team, undefined, 0 );
+	if ( killstreak_id == -1 )
+	{
+		if ( isDefined( self.rcbomb ) )
+		{
+			self.rcbomb delete();
+		}
+		return 0;
+	}
+	self.rcbomb.killstreak_id = killstreak_id;
+	self.enteringvehicle = 1;
+	self thread updatekillstreakondisconnect();
+	self thread updatekillstreakondeletion( self.team );
+	self freeze_player_controls( 1 );
+	if ( isDefined( self ) || !isalive( self ) && !isDefined( self.rcbomb ) )
+	{
+		if ( isDefined( self ) )
+		{
+			self.enteringvehicle = 0;
+			self notify( "weapon_object_destroyed" );
+		}
+		return 0;
+	}
+	self thread giveplayercontrolofrcbomb();
+	self.rcbomb thread watchforscramblers();
+	self.killstreak_waitamount = 30000;
+	self.enteringvehicle = 0;
+	self stopshellshock();
+	if ( isDefined( level.killstreaks[ hardpointtype ] ) && isDefined( level.killstreaks[ hardpointtype ].inboundtext ) )
+	{
+		level thread maps/mp/_popups::displaykillstreakteammessagetoall( hardpointtype, self );
+	}
+	if ( isDefined( level.rcbomb_vision ) )
+	{
+		self thread setvisionsetwaiter();
+	}
+	self updaterulesonend();
+	return 1;
+}
+
+watchforscramblers()
+{
+	self endon( "death" );
+	while ( 1 )
+	{
+		scrambled = self getclientflag( 9 );
+		shouldscramble = 0;
+		players = level.players;
+		i = 0;
+		while ( i < players.size )
+		{
+			if ( !isDefined( players[ i ] ) || !isDefined( players[ i ].scrambler ) )
+			{
+				i++;
+				continue;
+			}
+			else
+			{
+				player = players[ i ];
+				scrambler = player.scrambler;
+				if ( level.teambased && self.team == player.team )
+				{
+					i++;
+					continue;
+				}
+				else
+				{
+					if ( !level.teambased && self.owner == player )
+					{
+						i++;
+						continue;
+					}
+					else
+					{
+						if ( distancesquared( scrambler.origin, self.origin ) < level.scramblerinnerradiussq )
+						{
+							shouldscramble = 1;
+							break;
+						}
+					}
+				}
+			}
+			else
+			{
+				i++;
+			}
+		}
+		if ( shouldscramble == 1 && scrambled == 0 )
+		{
+			self setclientflag( 9 );
+		}
+		else
+		{
+			if ( shouldscramble == 0 && scrambled == 1 )
+			{
+				self clearclientflag( 9 );
+			}
+		}
+		wait_delay = randomfloatrange( 0,25, 0,5 );
+		wait wait_delay;
+	}
+}
+
+updaterulesonend()
+{
+	team = self.rcbomb.team;
+	killstreak_id = self.rcbomb.killstreak_id;
+	self endon( "disconnect" );
+	self waittill( "rcbomb_done" );
+	maps/mp/killstreaks/_killstreakrules::killstreakstop( "rcbomb_mp", team, killstreak_id );
+}
+
+updatekillstreakondisconnect()
+{
+	team = self.rcbomb.team;
+	killstreak_id = self.rcbomb.killstreak_id;
+	self endon( "rcbomb_done" );
+	self waittill( "disconnect" );
+	maps/mp/killstreaks/_killstreakrules::killstreakstop( "rcbomb_mp", team, killstreak_id );
+}
+
+updatekillstreakondeletion( team )
+{
+	killstreak_id = self.rcbomb.killstreak_id;
+	self endon( "disconnect" );
+	self endon( "rcbomb_done" );
+	self waittill( "weapon_object_destroyed" );
+	maps/mp/killstreaks/_killstreakrules::killstreakstop( "rcbomb_mp", team, killstreak_id );
+	if ( isDefined( self.rcbomb ) )
+	{
+		self.rcbomb delete();
+	}
+}
+
+cardetonatewaiter( vehicle )
+{
+	self endon( "disconnect" );
+	vehicle endon( "death" );
+	watcher = maps/mp/gametypes/_weaponobjects::getweaponobjectwatcher( "rcbomb" );
+	while ( !self attackbuttonpressed() )
+	{
+		wait 0,05;
+	}
+	watcher thread maps/mp/gametypes/_weaponobjects::waitanddetonate( vehicle, 0 );
+	self thread maps/mp/gametypes/_hud::fadetoblackforxsec( getDvarFloat( #"CDE26736" ), getDvarFloat( #"AFCAD5CD" ), getDvarFloat( #"88490433" ), getDvarFloat( #"A925AA4E" ) );
+}
+
+jumpwaiter( vehicle )
+{
+	self endon( "disconnect" );
+	vehicle endon( "death" );
+	self.jump_hud = newclienthudelem( self );
+	self.jump_hud.alignx = "left";
+	self.jump_hud.aligny = "bottom";
+	self.jump_hud.horzalign = "user_left";
+	self.jump_hud.vertalign = "user_bottom";
+	self.jump_hud.font = "small";
+	self.jump_hud.hidewheninmenu = 1;
+	self.jump_hud.x = 5;
+	self.jump_hud.y = -60;
+	self.jump_hud.fontscale = 1,25;
+	while ( 1 )
+	{
+		self.jump_hud settext( "[{+gostand}]" + "Jump" );
+		if ( self jumpbuttonpressed() )
+		{
+			vehicle launchvehicle( ( 0, 0, 1 ) * -10, vehicle.origin, 0 );
+			self.jump_hud settext( "" );
+			wait 5;
+		}
+		wait 0,05;
+	}
+}
+
+playerdisconnectwaiter( vehicle )
+{
+	vehicle endon( "death" );
+	self endon( "rcbomb_done" );
+	self waittill( "disconnect" );
+	vehicle delete();
+}
+
+gameendwatcher( vehicle )
+{
+	vehicle endon( "death" );
+	self endon( "rcbomb_done" );
+	level waittill( "game_ended" );
+	watcher = maps/mp/gametypes/_weaponobjects::getweaponobjectwatcher( "rcbomb" );
+	watcher thread maps/mp/gametypes/_weaponobjects::waitanddetonate( vehicle, 0 );
+	self thread maps/mp/gametypes/_hud::fadetoblackforxsec( getDvarFloat( #"CDE26736" ), getDvarFloat( #"AFCAD5CD" ), getDvarFloat( #"88490433" ), getDvarFloat( #"A925AA4E" ) );
+}
+
+exitcarwaiter( vehicle )
+{
+	self endon( "disconnect" );
+	self waittill( "unlink" );
+	self notify( "rcbomb_done" );
+}
+
+changeteamwaiter( vehicle )
+{
+	self endon( "disconnect" );
+	self endon( "rcbomb_done" );
+	vehicle endon( "death" );
+	self waittill_either( "joined_team", "joined_spectators" );
+	vehicle.owner unlink();
+	self.killstreak_waitamount = undefined;
+	vehicle delete();
+}
+
+cardeathwaiter( vehicle )
+{
+	self endon( "disconnect" );
+	self endon( "rcbomb_done" );
+	self waittill( "death" );
+	maps/mp/killstreaks/_killstreaks::removeusedkillstreak( "rcbomb_mp" );
+	self notify( "rcbomb_done" );
+}
+
+carcleanupwaiter( vehicle )
+{
+	self endon( "disconnect" );
+	self waittill( "death" );
+	self.rcbomb = undefined;
+}
+
+setvisionsetwaiter()
+{
+	self endon( "disconnect" );
+	self useservervisionset( 1 );
+	self setvisionsetforplayer( level.rcbomb_vision, 1 );
+	self waittill( "rcbomb_done" );
+	self useservervisionset( 0 );
+}
+
+cartimer( vehicle )
+{
+	self endon( "disconnect" );
+	vehicle endon( "death" );
+	if ( !level.vehiclestimed )
+	{
+		return;
+	}
+/#
+	if ( getDvarInt( "scr_rcbomb_notimeout" ) != 0 )
+	{
+		return;
+#/
+	}
+	maps/mp/gametypes/_hostmigration::waitlongdurationwithhostmigrationpause( 20 );
+	vehicle setclientfield( "rcbomb_countdown", 1 );
+	maps/mp/gametypes/_hostmigration::waitlongdurationwithhostmigrationpause( 6 );
+	vehicle setclientfield( "rcbomb_countdown", 2 );
+	maps/mp/gametypes/_hostmigration::waitlongdurationwithhostmigrationpause( 4 );
+	watcher = maps/mp/gametypes/_weaponobjects::getweaponobjectwatcher( "rcbomb" );
+	watcher thread maps/mp/gametypes/_weaponobjects::waitanddetonate( vehicle, 0 );
+}
+
+detonateiftouchingsphere( origin, radius )
+{
+	if ( distancesquared( self.origin, origin ) < ( radius * radius ) )
+	{
+		self rcbomb_force_explode();
+	}
+}
+
+detonatealliftouchingsphere( origin, radius )
+{
+	rcbombs = getentarray( "rcbomb", "targetname" );
+	index = 0;
+	while ( index < rcbombs.size )
+	{
+		rcbombs[ index ] detonateiftouchingsphere( origin, radius );
+		index++;
+	}
+}
+
+blowup( attacker, weaponname )
+{
+	self.owner endon( "disconnect" );
+	self endon( "death" );
+	explosionorigin = self.origin;
+	explosionangles = self.angles;
+	if ( !isDefined( attacker ) )
+	{
+		attacker = self.owner;
+	}
+	from_emp = maps/mp/killstreaks/_emp::isempweapon( weaponname );
+	origin = self.origin + vectorScale( ( 0, 0, 1 ), 10 );
+	radius = 256;
+	min_damage = 25;
+	max_damage = 350;
+	if ( !from_emp )
+	{
+		self radiusdamage( origin, radius, max_damage, min_damage, attacker, "MOD_EXPLOSIVE", "rcbomb_mp" );
+		physicsexplosionsphere( origin, radius, radius, 1, max_damage, min_damage );
+		maps/mp/gametypes/_shellshock::rcbomb_earthquake( origin );
+		playsoundatposition( "mpl_rc_exp", self.origin );
+		playfx( level._effect[ "rcbombexplosion" ], explosionorigin, ( 0, 0, 1 ) );
+	}
+	self setmodel( self.death_model );
+	self hide();
+	self setclientfield( "rcbomb_death", 1 );
+	if ( attacker != self.owner && isplayer( attacker ) )
+	{
+		attacker maps/mp/_challenges::destroyrcbomb( weaponname );
+		if ( self.owner isenemyplayer( attacker ) )
+		{
+			maps/mp/_scoreevents::processscoreevent( "destroyed_rcbomb", attacker, self.owner, weaponname );
+			if ( isDefined( weaponname ) )
+			{
+				weaponstatname = "destroyed";
+				attacker addweaponstat( weaponname, weaponstatname, 1 );
+				level.globalkillstreaksdestroyed++;
+				attacker addweaponstat( "rcbomb_mp", "destroyed", 1 );
+				attacker addweaponstat( weaponname, "destroyed_controlled_killstreak", 1 );
+			}
+		}
+	}
+	wait 1;
+	if ( isDefined( self.neverdelete ) && self.neverdelete )
+	{
+		return;
+	}
+	if ( isDefined( self.owner.jump_hud ) )
+	{
+		self.owner.jump_hud destroy();
+	}
+	self.owner unlink();
+	if ( isDefined( level.gameended ) && level.gameended )
+	{
+		self.owner freezecontrolswrapper( 1 );
+	}
+	self.owner.killstreak_waitamount = undefined;
+	self delete();
+}
+
+rccarallowfriendlyfiredamage( einflictor, eattacker, smeansofdeath, sweapon )
+{
+	if ( isDefined( eattacker ) && eattacker == self.owner )
+	{
+		return 1;
+	}
+	if ( isDefined( einflictor ) && einflictor islinkedto( self ) )
+	{
+		return 1;
+	}
+	return 0;
+}
+
+getplacementstartheight()
+{
+	startheight = 50;
+	switch( self getstance() )
+	{
+		case "crouch":
+			startheight = 30;
+			break;
+		case "prone":
+			startheight = 15;
+			break;
+	}
+	return startheight;
+}
+
+calculatespawnorigin( origin, angles )
+{
+	distance_from_player = 70;
+	startheight = getplacementstartheight();
+	mins = vectorScale( ( 0, 0, 1 ), 5 );
+	maxs = ( 5, 5, 10 );
+	startpoints = [];
+	startangles = [];
+	wheelcounts = [];
+	testcheck = [];
+	largestcount = 0;
+	largestcountindex = 0;
+	testangles = [];
+	testangles[ 0 ] = ( 0, 0, 1 );
+	testangles[ 1 ] = vectorScale( ( 0, 0, 1 ), 20 );
+	testangles[ 2 ] = vectorScale( ( 0, 0, 1 ), 20 );
+	testangles[ 3 ] = vectorScale( ( 0, 0, 1 ), 45 );
+	testangles[ 4 ] = vectorScale( ( 0, 0, 1 ), 45 );
+	heightoffset = 5;
+	i = 0;
+	while ( i < testangles.size )
+	{
+		testcheck[ i ] = 0;
+		startangles[ i ] = ( 0, angles[ 1 ], 0 );
+		startpoint = origin + vectorScale( anglesToForward( startangles[ i ] + testangles[ i ] ), distance_from_player );
+		endpoint = startpoint - vectorScale( ( 0, 0, 1 ), 100 );
+		startpoint += ( 0, 0, startheight );
+		mask = level.physicstracemaskphysics | level.physicstracemaskvehicle;
+		trace = physicstrace( startpoint, endpoint, mins, maxs, self, mask );
+		if ( isDefined( trace[ "entity" ] ) && isplayer( trace[ "entity" ] ) )
+		{
+			wheelcounts[ i ] = 0;
+			i++;
+			continue;
+		}
+		else
+		{
+			startpoints[ i ] = trace[ "position" ] + ( 0, 0, heightoffset );
+			wheelcounts[ i ] = testwheellocations( startpoints[ i ], startangles[ i ], heightoffset );
+			if ( positionwouldtelefrag( startpoints[ i ] ) )
+			{
+				i++;
+				continue;
+			}
+			else
+			{
+				if ( largestcount < wheelcounts[ i ] )
+				{
+					largestcount = wheelcounts[ i ];
+					largestcountindex = i;
+				}
+				if ( wheelcounts[ i ] >= 3 )
+				{
+					testcheck[ i ] = 1;
+					if ( testspawnorigin( startpoints[ i ], startangles[ i ] ) )
+					{
+						placement = spawnstruct();
+						placement.origin = startpoints[ i ];
+						placement.angles = startangles[ i ];
+						return placement;
+					}
+				}
+			}
+		}
+		i++;
+	}
+	i = 0;
+	while ( i < testangles.size )
+	{
+		if ( !testcheck[ i ] )
+		{
+			if ( wheelcounts[ i ] >= 2 )
+			{
+				if ( testspawnorigin( startpoints[ i ], startangles[ i ] ) )
+				{
+					placement = spawnstruct();
+					placement.origin = startpoints[ i ];
+					placement.angles = startangles[ i ];
+					return placement;
+				}
+			}
+		}
+		i++;
+	}
+	return undefined;
+}
+
+testwheellocations( origin, angles, heightoffset )
+{
+	forward = 13;
+	side = 10;
+	wheels = [];
+	wheels[ 0 ] = ( forward, side, 0 );
+	wheels[ 1 ] = ( forward, -1 * side, 0 );
+	wheels[ 2 ] = ( -1 * forward, -1 * side, 0 );
+	wheels[ 3 ] = ( -1 * forward, side, 0 );
+	height = 5;
+	touchcount = 0;
+	yawangles = ( 0, angles[ 1 ], 0 );
+	i = 0;
+	while ( i < 4 )
+	{
+		wheel = rotatepoint( wheels[ i ], yawangles );
+		startpoint = origin + wheel;
+		endpoint = startpoint + ( 0, 0, ( -1 * height ) - heightoffset );
+		startpoint += ( 0, 0, height - heightoffset );
+		trace = bullettrace( startpoint, endpoint, 0, self );
+		if ( trace[ "fraction" ] < 1 )
+		{
+			touchcount++;
+			rcbomb_debug_line( startpoint, endpoint, ( 0, 0, 1 ) );
+			i++;
+			continue;
+		}
+		else
+		{
+			rcbomb_debug_line( startpoint, endpoint, ( 0, 0, 1 ) );
+		}
+		i++;
+	}
+	return touchcount;
+}
+
+testspawnorigin( origin, angles )
+{
+	liftedorigin = origin + vectorScale( ( 0, 0, 1 ), 5 );
+	size = 12;
+	height = 15;
+	mins = ( -1 * size, -1 * size, 0 );
+	maxs = ( size, size, height );
+	absmins = liftedorigin + mins;
+	absmaxs = liftedorigin + maxs;
+	if ( boundswouldtelefrag( absmins, absmaxs ) )
+	{
+		rcbomb_debug_box( liftedorigin, mins, maxs, ( 0, 0, 1 ) );
+		return 0;
+	}
+	else
+	{
+		rcbomb_debug_box( liftedorigin, mins, maxs, ( 0, 0, 1 ) );
+	}
+	startheight = getplacementstartheight();
+	mask = level.physicstracemaskphysics | level.physicstracemaskvehicle | level.physicstracemaskwater;
+	trace = physicstrace( liftedorigin, origin + ( 0, 0, 1 ), mins, maxs, self, mask );
+	if ( trace[ "fraction" ] < 1 )
+	{
+		rcbomb_debug_box( trace[ "position" ], mins, maxs, ( 0, 0, 1 ) );
+		return 0;
+	}
+	else
+	{
+		rcbomb_debug_box( origin + ( 0, 0, 1 ), mins, maxs, ( 0, 0, 1 ) );
+	}
+	size = 2,5;
+	height = size * 2;
+	mins = ( -1 * size, -1 * size, 0 );
+	maxs = ( size, size, height );
+	sweeptrace = physicstrace( self.origin + ( 0, 0, startheight ), liftedorigin, mins, maxs, self, mask );
+	if ( sweeptrace[ "fraction" ] < 1 )
+	{
+		rcbomb_debug_box( sweeptrace[ "position" ], mins, maxs, ( 0, 0, 1 ) );
+		return 0;
+	}
+	return 1;
+}
+
+trigger_hurt_monitor()
+{
+	self endon( "death" );
+	for ( ;; )
+	{
+		self waittill( "touch", ent );
+		if ( ent.classname == "trigger_hurt" )
+		{
+			if ( level.script == "mp_castaway" )
+			{
+				if ( ent.spawnflags & 16 )
+				{
+					if ( self depthinwater() < 23 )
+					{
+						break;
+					}
+				}
+			}
+			else
+			{
+				self rcbomb_force_explode();
+				return;
+			}
+		}
+	}
+}
+
+rcbomb_force_explode()
+{
+	self endon( "death" );
+/#
+	assert( self.targetname == "rcbomb" );
+#/
+	while ( !isDefined( self getseatoccupant( 0 ) ) )
+	{
+		wait 0,1;
+	}
+	self dodamage( 10, self.origin + vectorScale( ( 0, 0, 1 ), 10 ), self.owner, self.owner, "none", "MOD_EXPLOSIVE" );
+}
+
+rcbomb_debug_box( origin, mins, maxs, color )
+{
+/#
+	debug_rcbomb = getDvar( #"8EAE5CA0" );
+	if ( debug_rcbomb == "1" )
+	{
+		box( origin, mins, maxs, 0, color, 1, 1, 300 );
+#/
+	}
+}
+
+rcbomb_debug_line( start, end, color )
+{
+/#
+	debug_rcbomb = getDvar( #"8EAE5CA0" );
+	if ( debug_rcbomb == "1" )
+	{
+		line( start, end, color, 1, 1, 300 );
+#/
+	}
+}

patch_mp/maps/mp/killstreaks/_remote_weapons.gsc

@@ -0,0 +1,496 @@
+#include maps/mp/gametypes/_hud;
+#include maps/mp/killstreaks/_killstreaks;
+#include maps/mp/killstreaks/_ai_tank;
+#include maps/mp/killstreaks/_turret_killstreak;
+#include maps/mp/gametypes/_hud_util;
+#include common_scripts/utility;
+#include maps/mp/_utility;
+
+init()
+{
+	level.remoteweapons = [];
+	level.remoteweapons[ "killstreak_remote_turret_mp" ] = spawnstruct();
+	level.remoteweapons[ "killstreak_remote_turret_mp" ].hintstring = &"MP_REMOTE_USE_TURRET";
+	level.remoteweapons[ "killstreak_remote_turret_mp" ].usecallback = ::maps/mp/killstreaks/_turret_killstreak::startturretremotecontrol;
+	level.remoteweapons[ "killstreak_remote_turret_mp" ].endusecallback = ::maps/mp/killstreaks/_turret_killstreak::endremoteturret;
+	level.remoteweapons[ "killstreak_ai_tank_mp" ] = spawnstruct();
+	level.remoteweapons[ "killstreak_ai_tank_mp" ].hintstring = &"MP_REMOTE_USE_TANK";
+	level.remoteweapons[ "killstreak_ai_tank_mp" ].usecallback = ::maps/mp/killstreaks/_ai_tank::starttankremotecontrol;
+	level.remoteweapons[ "killstreak_ai_tank_mp" ].endusecallback = ::maps/mp/killstreaks/_ai_tank::endtankremotecontrol;
+	level.remoteexithint = &"MP_REMOTE_EXIT";
+	level thread onplayerconnect();
+}
+
+onplayerconnect()
+{
+	for ( ;; )
+	{
+		level waittill( "connected", player );
+		player thread onplayerspawned();
+	}
+}
+
+onplayerspawned()
+{
+	self endon( "disconnect" );
+	for ( ;; )
+	{
+		self waittill( "spawned_player" );
+		if ( isDefined( self.remotecontroltrigger ) )
+		{
+			self.remotecontroltrigger.origin = self.origin;
+			self.remotecontroltrigger linkto( self );
+		}
+	}
+}
+
+initremoteweapon( weapon, weaponname )
+{
+	weapon.inittime = getTime();
+	weapon.remotename = weaponname;
+	weapon thread watchfindremoteweapon( self );
+	if ( isDefined( self.remoteweapon ) )
+	{
+		if ( !isusingremote() )
+		{
+			self notify( "remove_remote_weapon" );
+		}
+	}
+	else
+	{
+		self thread setactiveremotecontrolledweapon( weapon );
+	}
+}
+
+setactiveremotecontrolledweapon( weapon )
+{
+/#
+	assert( !isDefined( self.remoteweapon ), "Trying to activate remote weapon without cleaning up the current one" );
+#/
+	if ( isDefined( self.remoteweapon ) )
+	{
+		return;
+	}
+	while ( !isalive( self ) )
+	{
+		wait 0,05;
+	}
+	self notify( "set_active_remote_weapon" );
+	self.remoteweapon = weapon;
+	self thread watchremoveremotecontrolledweapon( weapon.remotename );
+	self thread watchremotecontrolledweapondeath();
+	self thread watchremoteweaponpings();
+	self createremoteweapontrigger( weapon.remotename );
+}
+
+watchfindremoteweapon( player )
+{
+	self endon( "removed_on_death" );
+	self endon( "death" );
+	while ( 1 )
+	{
+		player waittill( "find_remote_weapon" );
+		player notify( "remote_weapon_ping" );
+	}
+}
+
+watchremoteweaponpings()
+{
+	self endon( "disconnect" );
+	self endon( "joined_team" );
+	self endon( "joined_spectators" );
+	self endon( "set_active_remote_weapon" );
+	self.remoteweaponqueue = [];
+	self thread collectweaponpings();
+	while ( 1 )
+	{
+		self waittill( "remote_weapon_ping", weapon );
+		if ( isDefined( weapon ) )
+		{
+			self.remoteweaponqueue[ self.remoteweaponqueue.size ] = weapon;
+		}
+	}
+}
+
+collectweaponpings()
+{
+	self endon( "disconnect" );
+	self endon( "joined_team" );
+	self endon( "joined_spectators" );
+	self waittill( "remote_weapon_ping" );
+	wait 0,1;
+	while ( !isalive( self ) )
+	{
+		wait 0,05;
+	}
+	if ( isDefined( self ) )
+	{
+/#
+		assert( isDefined( self.remoteweaponqueue ) );
+#/
+		best_weapon = undefined;
+		_a186 = self.remoteweaponqueue;
+		_k186 = getFirstArrayKey( _a186 );
+		while ( isDefined( _k186 ) )
+		{
+			weapon = _a186[ _k186 ];
+			if ( isDefined( weapon ) && isalive( weapon ) )
+			{
+				if ( !isDefined( best_weapon ) || best_weapon.inittime < weapon.inittime )
+				{
+					best_weapon = weapon;
+				}
+			}
+			_k186 = getNextArrayKey( _a186, _k186 );
+		}
+		if ( isDefined( best_weapon ) )
+		{
+			self thread setactiveremotecontrolledweapon( best_weapon );
+		}
+	}
+}
+
+watchremotecontrolledweapondeath()
+{
+	self endon( "remove_remote_weapon" );
+/#
+	assert( isDefined( self.remoteweapon ) );
+#/
+	self.remoteweapon waittill( "death" );
+	if ( isDefined( self ) )
+	{
+		self notify( "remove_remote_weapon" );
+	}
+}
+
+watchremoveremotecontrolledweapon( weaponname )
+{
+	self endon( "disconnect" );
+	self waittill( "remove_remote_weapon", trytoreplace );
+	self removeremotecontrolledweapon( weaponname );
+	while ( isDefined( self.remoteweapon ) )
+	{
+		wait 0,05;
+	}
+	if ( trytoreplace == 1 )
+	{
+		self notify( "find_remote_weapon" );
+	}
+}
+
+removeremotecontrolledweapon( weaponname )
+{
+	if ( self isusingremote() )
+	{
+		remoteweaponname = self getremotename();
+		if ( remoteweaponname == weaponname )
+		{
+			self baseendremotecontrolweaponuse( weaponname, 1 );
+		}
+	}
+	self destroyremotecontrolactionprompthud();
+	self.remoteweapon = undefined;
+	self.remotecontroltrigger delete();
+}
+
+createremoteweapontrigger( weaponname )
+{
+	trigger = spawn( "trigger_radius_use", self.origin, 32, 32 );
+	trigger enablelinkto();
+	trigger linkto( self );
+	trigger sethintlowpriority( 1 );
+	trigger setcursorhint( "HINT_NOICON" );
+	trigger sethintstring( level.remoteweapons[ weaponname ].hintstring );
+	if ( level.teambased )
+	{
+		trigger setteamfortrigger( self.team );
+		trigger.triggerteam = self.team;
+	}
+	self clientclaimtrigger( trigger );
+	trigger.claimedby = self;
+	self.remotecontroltrigger = trigger;
+	self thread watchremotetriggeruse( weaponname );
+	self thread removeremotetriggerondisconnect( trigger );
+}
+
+removeremotetriggerondisconnect( trigger )
+{
+	self endon( "remove_remote_weapon" );
+	trigger endon( "death" );
+	self waittill( "disconnect" );
+	trigger delete();
+}
+
+watchremotetriggeruse( weaponname )
+{
+	self endon( "remove_remote_weapon" );
+	self endon( "disconnect" );
+	if ( self is_bot() )
+	{
+		return;
+	}
+	while ( 1 )
+	{
+		self.remotecontroltrigger waittill( "trigger", player );
+		while ( self isusingoffhand() )
+		{
+			continue;
+		}
+		while ( isDefined( self.remoteweapon ) && isDefined( self.remoteweapon.hackertrigger ) && isDefined( self.remoteweapon.hackertrigger.progressbar ) )
+		{
+			if ( weaponname == "killstreak_remote_turret_mp" )
+			{
+				self iprintlnbold( &"KILLSTREAK_AUTO_TURRET_NOT_AVAILABLE" );
+			}
+		}
+		if ( self usebuttonpressed() && !self.throwinggrenade && !self meleebuttonpressed() && !self isusingremote() )
+		{
+			self useremotecontrolweapon( weaponname );
+		}
+	}
+}
+
+useremotecontrolweapon( weaponname, allowexit )
+{
+	self disableoffhandweapons();
+	self giveweapon( weaponname );
+	self switchtoweapon( weaponname );
+	if ( !isDefined( allowexit ) )
+	{
+		allowexit = 1;
+	}
+	self thread maps/mp/killstreaks/_killstreaks::watchforemoveremoteweapon();
+	self waittill( "weapon_change", newweapon );
+	self notify( "endWatchFoRemoveRemoteWeapon" );
+	self setusingremote( weaponname );
+	if ( !self isonground() )
+	{
+		self clearusingremote();
+		return;
+	}
+	result = self maps/mp/killstreaks/_killstreaks::initridekillstreak( weaponname );
+	if ( allowexit && result != "success" )
+	{
+		if ( result != "disconnect" )
+		{
+			self clearusingremote();
+		}
+	}
+	else
+	{
+		if ( allowexit && !self isonground() )
+		{
+			self clearusingremote();
+			return;
+			return;
+		}
+		else
+		{
+			self.remoteweapon.controlled = 1;
+			self.remoteweapon.killcament = self;
+			self.remoteweapon notify( "remote_start" );
+			if ( !isDefined( allowexit ) || allowexit )
+			{
+				self thread watchremotecontroldeactivate( weaponname );
+			}
+			self thread [[ level.remoteweapons[ weaponname ].usecallback ]]( self.remoteweapon );
+		}
+	}
+}
+
+createremotecontrolactionprompthud()
+{
+	if ( !isDefined( self.hud_prompt_exit ) )
+	{
+		self.hud_prompt_exit = newclienthudelem( self );
+	}
+	self.hud_prompt_exit.alignx = "left";
+	self.hud_prompt_exit.aligny = "bottom";
+	self.hud_prompt_exit.horzalign = "user_left";
+	self.hud_prompt_exit.vertalign = "user_bottom";
+	self.hud_prompt_exit.font = "small";
+	self.hud_prompt_exit.fontscale = 1,25;
+	self.hud_prompt_exit.hidewheninmenu = 1;
+	self.hud_prompt_exit.archived = 0;
+	self.hud_prompt_exit.x = 25;
+	self.hud_prompt_exit.y = -10;
+	self.hud_prompt_exit settext( level.remoteexithint );
+}
+
+destroyremotecontrolactionprompthud()
+{
+	if ( isDefined( self ) && isDefined( self.hud_prompt_exit ) )
+	{
+		self.hud_prompt_exit destroy();
+	}
+}
+
+watchremotecontroldeactivate( weaponname )
+{
+	self endon( "remove_remote_weapon" );
+	self endon( "disconnect" );
+	self.remoteweapon endon( "remote_start" );
+	wait 1;
+	while ( 1 )
+	{
+		timeused = 0;
+		while ( self usebuttonpressed() )
+		{
+			timeused += 0,05;
+			if ( timeused > 0,25 )
+			{
+				self thread baseendremotecontrolweaponuse( weaponname, 0 );
+				return;
+			}
+			wait 0,05;
+		}
+		wait 0,05;
+	}
+}
+
+endremotecontrolweaponuse( weaponname )
+{
+	if ( isDefined( self.hud_prompt_exit ) )
+	{
+		self.hud_prompt_exit settext( "" );
+	}
+	self [[ level.remoteweapons[ weaponname ].endusecallback ]]( self.remoteweapon );
+}
+
+fadeouttoblack( isdead )
+{
+	self endon( "disconnect" );
+	self endon( "early_death" );
+	if ( isdead )
+	{
+		self sendkillstreakdamageevent( 600 );
+		wait 0,75;
+		self thread maps/mp/gametypes/_hud::fadetoblackforxsec( 0, 0,25, 0,1, 0,25 );
+	}
+	else
+	{
+		self thread maps/mp/gametypes/_hud::fadetoblackforxsec( 0, 0,2, 0, 0,3 );
+	}
+}
+
+baseendremotecontrolweaponuse( weaponname, isdead )
+{
+	if ( isDefined( self ) )
+	{
+		if ( isdead && isDefined( self.remoteweapon ) && !isDefined( self.remoteweapon.skipfutz ) )
+		{
+			self thread fadeouttoblack( 1 );
+			wait 1;
+		}
+		else
+		{
+			self thread fadeouttoblack( 0 );
+		}
+		self clearusingremote();
+		self takeweapon( weaponname );
+	}
+	if ( isDefined( self.remoteweapon ) )
+	{
+		if ( isdead )
+		{
+			self.remoteweapon.wascontrollednowdead = self.remoteweapon.controlled;
+		}
+		self.remoteweapon.controlled = 0;
+		self [[ level.remoteweapons[ weaponname ].endusecallback ]]( self.remoteweapon, isdead );
+		self.remoteweapon.killcament = self.remoteweapon;
+		self unlink();
+		self.killstreak_waitamount = undefined;
+		self destroyremotehud();
+		self clientnotify( "nofutz" );
+		if ( isDefined( level.gameended ) && level.gameended )
+		{
+			self freezecontrolswrapper( 1 );
+		}
+	}
+	if ( isDefined( self.hud_prompt_exit ) )
+	{
+		self.hud_prompt_exit settext( "" );
+	}
+	self notify( "remove_remote_weapon" );
+}
+
+destroyremotehud()
+{
+	self useservervisionset( 0 );
+	self setinfraredvision( 0 );
+	if ( isDefined( self.fullscreen_static ) )
+	{
+		self.fullscreen_static destroy();
+	}
+	if ( isDefined( self.remote_hud_reticle ) )
+	{
+		self.remote_hud_reticle destroy();
+	}
+	if ( isDefined( self.remote_hud_bracket_right ) )
+	{
+		self.remote_hud_bracket_right destroy();
+	}
+	if ( isDefined( self.remote_hud_bracket_left ) )
+	{
+		self.remote_hud_bracket_left destroy();
+	}
+	if ( isDefined( self.remote_hud_arrow_right ) )
+	{
+		self.remote_hud_arrow_right destroy();
+	}
+	if ( isDefined( self.remote_hud_arrow_left ) )
+	{
+		self.remote_hud_arrow_left destroy();
+	}
+	if ( isDefined( self.tank_rocket_1 ) )
+	{
+		self.tank_rocket_1 destroy();
+	}
+	if ( isDefined( self.tank_rocket_2 ) )
+	{
+		self.tank_rocket_2 destroy();
+	}
+	if ( isDefined( self.tank_rocket_3 ) )
+	{
+		self.tank_rocket_3 destroy();
+	}
+	if ( isDefined( self.tank_rocket_hint ) )
+	{
+		self.tank_rocket_hint destroy();
+	}
+	if ( isDefined( self.tank_mg_bar ) )
+	{
+		self.tank_mg_bar destroy();
+	}
+	if ( isDefined( self.tank_mg_arrow ) )
+	{
+		self.tank_mg_arrow destroy();
+	}
+	if ( isDefined( self.tank_mg_hint ) )
+	{
+		self.tank_mg_hint destroy();
+	}
+	if ( isDefined( self.tank_fullscreen_effect ) )
+	{
+		self.tank_fullscreen_effect destroy();
+	}
+	if ( isDefined( self.hud_prompt_exit ) )
+	{
+		self.hud_prompt_exit destroy();
+	}
+}
+
+stunstaticfx( duration )
+{
+	self endon( "remove_remote_weapon" );
+	self.fullscreen_static.alpha = 0,65;
+	wait ( duration - 0,5 );
+	time = duration - 0,5;
+	while ( time < duration )
+	{
+		wait 0,05;
+		time += 0,05;
+		self.fullscreen_static.alpha -= 0,05;
+	}
+	self.fullscreen_static.alpha = 0,15;
+}

patch_mp/maps/mp/killstreaks/_remotemortar.gsc

@@ -0,0 +1,815 @@
+#include maps/mp/killstreaks/_spyplane;
+#include maps/mp/_popups;
+#include maps/mp/_challenges;
+#include maps/mp/_scoreevents;
+#include maps/mp/gametypes/_weapon_utils;
+#include maps/mp/gametypes/_damagefeedback;
+#include maps/mp/gametypes/_weaponobjects;
+#include maps/mp/gametypes/_hostmigration;
+#include maps/mp/gametypes/_spawning;
+#include maps/mp/gametypes/_hud;
+#include maps/mp/gametypes/_gameobjects;
+#include maps/mp/_heatseekingmissile;
+#include maps/mp/killstreaks/_killstreakrules;
+#include maps/mp/gametypes/_spawnlogic;
+#include maps/mp/killstreaks/_helicopter;
+#include maps/mp/killstreaks/_airsupport;
+#include maps/mp/killstreaks/_killstreaks;
+#include common_scripts/utility;
+#include maps/mp/gametypes/_hud_util;
+#include maps/mp/_utility;
+
+init()
+{
+	precachemodel( "veh_t6_drone_pegasus_mp" );
+	precacheshader( "compass_lodestar" );
+	precacheitem( "remote_mortar_missile_mp" );
+	precachestring( &"remotemortar" );
+	level.remote_mortar_fx[ "laserTarget" ] = loadfx( "weapon/remote_mortar/fx_rmt_mortar_laser_loop" );
+	level.remote_mortar_fx[ "missileExplode" ] = loadfx( "weapon/remote_mortar/fx_rmt_mortar_explosion" );
+	registerkillstreak( "remote_mortar_mp", "remote_mortar_mp", "killstreak_remote_mortar", "remote_mortar_used", ::remote_mortar_killstreak, 1 );
+	registerkillstreakaltweapon( "remote_mortar_mp", "remote_mortar_missile_mp" );
+	registerkillstreakstrings( "remote_mortar_mp", &"KILLSTREAK_EARNED_REMOTE_MORTAR", &"KILLSTREAK_REMOTE_MORTAR_NOT_AVAILABLE", &"KILLSTREAK_REMOTE_MORTAR_INBOUND" );
+	registerkillstreakdialog( "remote_mortar_mp", "mpl_killstreak_planemortar", "kls_reaper_used", "", "kls_reaper_enemy", "", "kls_reaper_ready" );
+	registerkillstreakdevdvar( "remote_mortar_mp", "scr_givemortarremote" );
+	setkillstreakteamkillpenaltyscale( "remote_mortar_mp", level.teamkillreducedpenalty );
+	overrideentitycameraindemo( "remote_mortar_mp", 1 );
+	set_dvar_float_if_unset( "scr_remote_mortar_lifetime", 45 );
+	level.remore_mortar_infrared_vision = "remote_mortar_infrared";
+	level.remore_mortar_enhanced_vision = "remote_mortar_enhanced";
+	minimaporigins = getentarray( "minimap_corner", "targetname" );
+	if ( minimaporigins.size )
+	{
+		uavorigin = maps/mp/gametypes/_spawnlogic::findboxcenter( minimaporigins[ 0 ].origin, minimaporigins[ 1 ].origin );
+	}
+	else
+	{
+		uavorigin = ( 0, 0, 1 );
+	}
+	if ( level.script == "mp_la" )
+	{
+		uavorigin += vectorScale( ( 0, 0, 1 ), 1200 );
+	}
+	if ( level.script == "mp_hydro" )
+	{
+		uavorigin += vectorScale( ( 0, 0, 1 ), 2000 );
+	}
+	if ( level.script == "mp_concert" )
+	{
+		uavorigin += vectorScale( ( 0, 0, 1 ), 750 );
+	}
+	if ( level.script == "mp_vertigo" )
+	{
+		uavorigin += vectorScale( ( 0, 0, 1 ), 500 );
+	}
+	level.remotemortarrig = spawn( "script_model", uavorigin );
+	level.remotemortarrig setmodel( "tag_origin" );
+	level.remotemortarrig.angles = vectorScale( ( 0, 0, 1 ), 115 );
+	level.remotemortarrig hide();
+	level.remotemortarrig thread rotaterig( 1 );
+	level.remote_zoffset = 8000;
+	level.remote_radiusoffset = 9000;
+	remote_mortar_height = getstruct( "remote_mortar_height", "targetname" );
+	if ( isDefined( remote_mortar_height ) )
+	{
+		level.remote_radiusoffset = ( remote_mortar_height.origin[ 2 ] / level.remote_zoffset ) * level.remote_radiusoffset;
+		level.remote_zoffset = remote_mortar_height.origin[ 2 ];
+	}
+}
+
+remote_mortar_killstreak( hardpointtype )
+{
+/#
+	assert( hardpointtype == "remote_mortar_mp" );
+#/
+	if ( self maps/mp/killstreaks/_killstreakrules::iskillstreakallowed( hardpointtype, self.team ) == 0 )
+	{
+		return 0;
+	}
+	if ( !self isonground() || self isusingremote() )
+	{
+		self iprintlnbold( &"KILLSTREAK_REMOTE_MORTAR_NOT_USABLE" );
+		return 0;
+	}
+	self setusingremote( hardpointtype );
+	self freezecontrolswrapper( 1 );
+	self disableweaponcycling();
+	result = self maps/mp/killstreaks/_killstreaks::initridekillstreak( "qrdrone" );
+	if ( result != "success" )
+	{
+		if ( result != "disconnect" )
+		{
+			self notify( "remote_mortar_unlock" );
+			self clearusingremote();
+			self enableweaponcycling();
+		}
+		return 0;
+	}
+	killstreak_id = self maps/mp/killstreaks/_killstreakrules::killstreakstart( hardpointtype, self.team, 0, 1 );
+	if ( killstreak_id == -1 )
+	{
+		self clearusingremote();
+		self enableweaponcycling();
+		self notify( "remote_mortar_unlock" );
+		return 0;
+	}
+	self.killstreak_waitamount = getDvarFloat( #"F9AB897A" ) * 1000;
+	remote = self remote_mortar_spawn();
+	remote setdrawinfrared( 1 );
+	remote thread remote_killstreak_abort();
+	remote thread remote_killstreak_game_end();
+	remote thread remote_owner_exit();
+	remote thread remote_owner_teamkillkicked();
+	remote thread remote_damage_think();
+	remote thread play_lockon_sounds( self );
+	remote thread maps/mp/_heatseekingmissile::missiletarget_lockonmonitor( self, "remote_end" );
+	remote thread maps/mp/_heatseekingmissile::missiletarget_proximitydetonateincomingmissile( "crashing" );
+	remote.killstreak_id = killstreak_id;
+	remote thread play_remote_fx();
+	remote playloopsound( "mpl_ks_reaper_exterior_loop", 1 );
+	self.pilottalking = 0;
+	remote.copilotvoicenumber = self.bcvoicenumber;
+	remote.pilotvoicenumber = self.bcvoicenumber + 1;
+	if ( remote.pilotvoicenumber > 3 )
+	{
+		remote.pilotvoicenumber = 0;
+	}
+	self clientnotify( "krms" );
+	self player_linkto_remote( remote );
+	self freezecontrolswrapper( 0 );
+	self thread player_aim_think( remote );
+	self thread player_fire_think( remote );
+	self maps/mp/killstreaks/_killstreaks::playkillstreakstartdialog( "remote_mortar_mp", self.pers[ "team" ] );
+	remote thread remote_killstreak_copilot( remote.copilotvoicenumber );
+	level.globalkillstreakscalled++;
+	self addweaponstat( "remote_mortar_mp", "used", 1 );
+	self thread visionswitch();
+	level waittill( "remote_unlinked" );
+	if ( isDefined( remote ) )
+	{
+		remote stoploopsound( 4 );
+	}
+	if ( !isDefined( self ) )
+	{
+		return 1;
+	}
+	self clientnotify( "krme" );
+	self clearclientflag( 1 );
+	self clientnotify( "nofutz" );
+	self clearusingremote();
+	return 1;
+}
+
+remote_killstreak_copilot( voice )
+{
+	level endon( "remote_end" );
+	wait 2,5;
+	while ( 1 )
+	{
+		self thread playpilotdialog( "reaper_used", 0, voice );
+		wait randomfloatrange( 4,5, 15 );
+	}
+}
+
+remote_killstreak_abort()
+{
+	level endon( "remote_end" );
+/#
+	assert( isDefined( self.owner ) );
+#/
+/#
+	assert( isplayer( self.owner ) );
+#/
+	self.owner waittill_any( "disconnect", "joined_team", "joined_spectators" );
+	self thread remote_killstreak_end( 0, 1 );
+}
+
+remote_owner_teamkillkicked( hardpointtype )
+{
+	level endon( "remote_end" );
+	self.owner waittill( "teamKillKicked" );
+	self thread remote_killstreak_end();
+}
+
+remote_owner_exit()
+{
+	level endon( "remote_end" );
+	wait 1;
+	while ( 1 )
+	{
+		timeused = 0;
+		while ( self.owner usebuttonpressed() )
+		{
+			timeused += 0,05;
+			if ( timeused > 0,25 )
+			{
+				self thread remote_killstreak_end();
+				return;
+			}
+			wait 0,05;
+		}
+		wait 0,05;
+	}
+}
+
+remote_killstreak_game_end()
+{
+	level endon( "remote_end" );
+/#
+	assert( isDefined( self.owner ) );
+#/
+/#
+	assert( isplayer( self.owner ) );
+#/
+	level waittill( "game_ended" );
+	self thread remote_killstreak_end();
+}
+
+remote_mortar_spawn()
+{
+	self setclientflag( 1 );
+	self clientnotify( "reapfutz" );
+	remote = spawnplane( self, "script_model", level.remotemortarrig gettagorigin( "tag_origin" ) );
+/#
+	assert( isDefined( remote ) );
+#/
+	remote setmodel( "veh_t6_drone_pegasus_mp" );
+	remote.targetname = "remote_mortar";
+	remote setowner( self );
+	remote setteam( self.team );
+	remote.team = self.team;
+	remote.owner = self;
+	remote.numflares = 2;
+	remote.flareoffset = vectorScale( ( 0, 0, 1 ), 256 );
+	remote.attackers = [];
+	remote.attackerdata = [];
+	remote.attackerdamage = [];
+	remote.flareattackerdamage = [];
+	remote.pilotvoicenumber = self.bcvoicenumber + 1;
+	if ( remote.pilotvoicenumber > 3 )
+	{
+		remote.pilotvoicenumber = 0;
+	}
+	angle = randomint( 360 );
+	xoffset = cos( angle ) * level.remote_radiusoffset;
+	yoffset = sin( angle ) * level.remote_radiusoffset;
+	anglevector = vectornormalize( ( xoffset, yoffset, level.remote_zoffset ) );
+	anglevector *= 6100;
+	remote linkto( level.remotemortarrig, "tag_origin", anglevector, ( 0, angle - 90, 0 ) );
+	remoteobjidfriendly = maps/mp/gametypes/_gameobjects::getnextobjid();
+	objective_add( remoteobjidfriendly, "invisible", remote.origin, &"remotemortar", self );
+	objective_state( remoteobjidfriendly, "active" );
+	objective_onentity( remoteobjidfriendly, remote );
+	objective_team( remoteobjidfriendly, self.team );
+	self.remoteobjidfriendly = remoteobjidfriendly;
+	remote.fx = spawn( "script_model", ( 0, 0, 1 ) );
+	remote.fx setmodel( "tag_origin" );
+	remote.fx setinvisibletoplayer( remote.owner, 1 );
+	remote remote_mortar_visibility();
+	target_setturretaquire( remote, 1 );
+	return remote;
+}
+
+rotaterig( clockwise )
+{
+	turn = 360;
+	if ( clockwise )
+	{
+		turn = -360;
+	}
+	for ( ;; )
+	{
+		if ( !clockwise )
+		{
+			self rotateyaw( turn, 30 );
+			wait 30;
+			continue;
+		}
+		else
+		{
+			self rotateyaw( turn, 45 );
+			wait 45;
+		}
+	}
+}
+
+remote_mortar_visibility()
+{
+	players = get_players();
+	_a315 = players;
+	_k315 = getFirstArrayKey( _a315 );
+	while ( isDefined( _k315 ) )
+	{
+		player = _a315[ _k315 ];
+		if ( player == self.owner )
+		{
+			self setinvisibletoplayer( player );
+		}
+		else
+		{
+			self setvisibletoplayer( player );
+		}
+		_k315 = getNextArrayKey( _a315, _k315 );
+	}
+}
+
+play_lockon_sounds( player )
+{
+	player endon( "disconnect" );
+	self endon( "death" );
+	self endon( "remote_end" );
+	self.locksounds = spawn( "script_model", self.origin );
+	wait 0,1;
+	self.locksounds linkto( self, "tag_player" );
+	while ( 1 )
+	{
+		self waittill( "locking on" );
+		while ( 1 )
+		{
+			if ( enemy_locking() )
+			{
+				self playsoundtoplayer( "uin_alert_lockon", player );
+				wait 0,125;
+			}
+			if ( enemy_locked() )
+			{
+				self playsoundtoplayer( "uin_alert_lockon", player );
+				wait 0,125;
+			}
+			if ( !enemy_locking() && !enemy_locked() )
+			{
+				break;
+			}
+			else
+			{
+			}
+		}
+	}
+}
+
+enemy_locking()
+{
+	if ( isDefined( self.locking_on ) && self.locking_on )
+	{
+		return 1;
+	}
+	return 0;
+}
+
+enemy_locked()
+{
+	if ( isDefined( self.locked_on ) && self.locked_on )
+	{
+		return 1;
+	}
+	return 0;
+}
+
+create_remote_mortar_hud( remote )
+{
+	self.missile_hud = newclienthudelem( self );
+	self.missile_hud.alignx = "left";
+	self.missile_hud.aligny = "bottom";
+	self.missile_hud.horzalign = "user_left";
+	self.missile_hud.vertalign = "user_bottom";
+	self.missile_hud.font = "small";
+	self.missile_hud settext( "[{+attack}]" + "Fire Missile" );
+	self.missile_hud.hidewheninmenu = 1;
+	self.missile_hud.hidewhenindemo = 1;
+	self.missile_hud.x = 5;
+	self.missile_hud.y = -40;
+	self.missile_hud.fontscale = 1,25;
+	self.zoom_hud = newclienthudelem( self );
+	self.zoom_hud.alignx = "left";
+	self.zoom_hud.aligny = "bottom";
+	self.zoom_hud.horzalign = "user_left";
+	self.zoom_hud.vertalign = "user_bottom";
+	self.zoom_hud.font = "small";
+	self.zoom_hud settext( &"KILLSTREAK_INCREASE_ZOOM" );
+	self.zoom_hud.hidewheninmenu = 1;
+	self.zoom_hud.hidewhenindemo = 1;
+	self.zoom_hud.x = 5;
+	self.zoom_hud.y = -25;
+	self.zoom_hud.fontscale = 1,25;
+	self.hud_prompt_exit = newclienthudelem( self );
+	self.hud_prompt_exit.alignx = "left";
+	self.hud_prompt_exit.aligny = "bottom";
+	self.hud_prompt_exit.horzalign = "user_left";
+	self.hud_prompt_exit.vertalign = "user_bottom";
+	self.hud_prompt_exit.font = "small";
+	self.hud_prompt_exit.fontscale = 1,25;
+	self.hud_prompt_exit.hidewheninmenu = 1;
+	self.hud_prompt_exit.hidewhenindemo = 1;
+	self.hud_prompt_exit.archived = 0;
+	self.hud_prompt_exit.x = 5;
+	self.hud_prompt_exit.y = -10;
+	self.hud_prompt_exit settext( level.remoteexithint );
+	self thread fade_out_hint_hud( remote );
+}
+
+fade_out_hint_hud( remote )
+{
+	self endon( "disconnect" );
+	remote endon( "death" );
+	wait 8;
+	time = 0;
+	while ( time < 2 )
+	{
+		if ( !isDefined( self.missile_hud ) )
+		{
+			return;
+		}
+		self.missile_hud.alpha -= 0,025;
+		self.zoom_hud.alpha -= 0,025;
+		time += 0,05;
+		wait 0,05;
+	}
+	self.missile_hud.alpha = 0;
+	self.zoom_hud.alpha = 0;
+}
+
+remove_hud()
+{
+	if ( isDefined( self.missile_hud ) )
+	{
+		self.missile_hud destroy();
+	}
+	if ( isDefined( self.zoom_hud ) )
+	{
+		self.zoom_hud destroy();
+	}
+	if ( isDefined( self.hud_prompt_exit ) )
+	{
+		self.hud_prompt_exit destroy();
+	}
+}
+
+remote_killstreak_end( explode, disconnected )
+{
+	level notify( "remote_end" );
+	if ( !isDefined( explode ) )
+	{
+		explode = 0;
+	}
+	if ( !isDefined( disconnected ) )
+	{
+		disconnected = 0;
+	}
+	if ( isDefined( self.owner ) )
+	{
+		if ( disconnected == 0 )
+		{
+			if ( explode )
+			{
+				self.owner sendkillstreakdamageevent( 600 );
+				self.owner thread maps/mp/gametypes/_hud::fadetoblackforxsec( 0,5, 0,5, 0,1, 0,25 );
+				wait 1;
+			}
+			else
+			{
+				self.owner sendkillstreakdamageevent( 600 );
+				self.owner thread maps/mp/gametypes/_hud::fadetoblackforxsec( 0, 0,25, 0,1, 0,25 );
+				wait 0,25;
+			}
+		}
+		self.owner unlink();
+		self.owner.killstreak_waitamount = undefined;
+		self.owner enableweaponcycling();
+		self.owner remove_hud();
+		if ( isDefined( level.gameended ) && level.gameended )
+		{
+			self.owner freezecontrolswrapper( 1 );
+		}
+	}
+	self maps/mp/gametypes/_spawning::remove_tvmissile_influencers();
+	objective_delete( self.owner.remoteobjidfriendly );
+	releaseobjid( self.owner.remoteobjidfriendly );
+	target_setturretaquire( self, 0 );
+	level notify( "remote_unlinked" );
+	maps/mp/killstreaks/_killstreakrules::killstreakstop( "remote_mortar_mp", self.team, self.killstreak_id );
+	if ( isDefined( self.owner ) )
+	{
+		self.owner setinfraredvision( 0 );
+		self.owner useservervisionset( 0 );
+	}
+	if ( isDefined( self.fx ) )
+	{
+		self.fx delete();
+	}
+	if ( explode )
+	{
+		self remote_explode();
+	}
+	else
+	{
+		self remote_leave();
+	}
+}
+
+player_linkto_remote( remote )
+{
+	leftarc = 40;
+	rightarc = 40;
+	uparc = 25;
+	downarc = 65;
+	if ( isDefined( level.remotemotarviewleft ) )
+	{
+		leftarc = level.remotemotarviewleft;
+	}
+	if ( isDefined( level.remotemotarviewright ) )
+	{
+		rightarc = level.remotemotarviewright;
+	}
+	if ( isDefined( level.remotemotarviewup ) )
+	{
+		uparc = level.remotemotarviewup;
+	}
+	if ( isDefined( level.remotemotarviewdown ) )
+	{
+		downarc = level.remotemotarviewdown;
+	}
+/#
+	leftarc = getdvarintdefault( "scr_remotemortar_right", leftarc );
+	rightarc = getdvarintdefault( "scr_remotemortar_left", rightarc );
+	uparc = getdvarintdefault( "scr_remotemortar_up", uparc );
+	downarc = getdvarintdefault( "scr_remotemortar_down", downarc );
+#/
+	self playerlinkweaponviewtodelta( remote, "tag_player", 1, leftarc, rightarc, uparc, downarc );
+	self player_center_view();
+}
+
+player_center_view( org )
+{
+	wait 0,05;
+	lookvec = vectorToAngle( level.uavrig.origin - self geteye() );
+	self setplayerangles( lookvec );
+}
+
+player_aim_think( remote )
+{
+	level endon( "remote_end" );
+	wait 0,25;
+	playfxontag( level.remote_mortar_fx[ "laserTarget" ], remote.fx, "tag_origin" );
+	remote.fx playloopsound( "mpl_ks_reaper_laser" );
+	while ( 1 )
+	{
+		origin = self geteye();
+		forward = anglesToForward( self getplayerangles() );
+		endpoint = origin + ( forward * 15000 );
+		trace = bullettrace( origin, endpoint, 0, remote );
+		remote.fx.origin = trace[ "position" ];
+		remote.fx.angles = vectorToAngle( trace[ "normal" ] );
+		if ( isDefined( self.pegasus_influencer ) )
+		{
+			removeinfluencer( self.pegasus_influencer );
+			self.pegasus_influencer = undefined;
+		}
+		if ( isDefined( self.active_pegasus ) )
+		{
+			self.pegasus_influencer = maps/mp/gametypes/_spawning::create_pegasus_influencer( trace[ "position" ], self.team );
+		}
+		wait 0,05;
+	}
+}
+
+player_fire_think( remote )
+{
+	level endon( "remote_end" );
+	end_time = getTime() + self.killstreak_waitamount;
+	shot = 0;
+	while ( getTime() < end_time )
+	{
+		self.active_pegasus = undefined;
+		while ( !self attackbuttonpressed() )
+		{
+			wait 0,05;
+		}
+		self playlocalsound( "mpl_ks_reaper_fire" );
+		self playrumbleonentity( "sniper_fire" );
+		if ( ( shot % 3 ) == 1 )
+		{
+			if ( isDefined( remote.owner ) && isDefined( remote.owner.pilottalking ) && remote.owner.pilottalking )
+			{
+				shot = 0;
+			}
+			remote thread playpilotdialog( "reaper_fire", 0,25, undefined, 0 );
+		}
+		shot = ( shot + 1 ) % 3;
+		origin = self geteye();
+		earthquake( 0,3, 0,5, origin, 256 );
+		angles = self getplayerangles();
+		forward = anglesToForward( angles );
+		right = anglesToRight( angles );
+		up = anglesToUp( angles );
+		offset = ( ( origin + ( forward * 100 ) ) + ( right * -40 ) ) + ( up * -100 );
+		missile = magicbullet( "remote_mortar_missile_mp", offset, ( origin + ( forward * 1000 ) ) + ( up * -100 ), self, remote.fx );
+		self.active_pegasus = missile;
+		missile thread remote_missile_life( remote );
+		missile waittill( "death" );
+		self playlocalsound( "mpl_ks_reaper_explosion" );
+	}
+	if ( isDefined( self.pegasus_influencer ) )
+	{
+		removeinfluencer( self.pegasus_influencer );
+		self.pegasus_influencer = undefined;
+	}
+	remote thread remote_killstreak_end();
+}
+
+remote_missile_life( remote )
+{
+	self endon( "death" );
+	maps/mp/gametypes/_hostmigration::waitlongdurationwithhostmigrationpause( 6 );
+	playfx( level.remote_mortar_fx[ "missileExplode" ], self.origin );
+	self delete();
+}
+
+remote_damage_think()
+{
+	level endon( "remote_end" );
+	self.health = 999999;
+	maxhealth = level.heli_amored_maxhealth;
+	damagetaken = 0;
+	self.lowhealth = 0;
+	self setcandamage( 1 );
+	target_set( self, vectorScale( ( 0, 0, 1 ), 30 ) );
+	while ( 1 )
+	{
+		self waittill( "damage", damage, attacker, direction_vec, point, meansofdeath, tagname, modelname, partname, weapon );
+		self.health = 999999;
+		heli_friendlyfire = maps/mp/gametypes/_weaponobjects::friendlyfirecheck( self.owner, attacker );
+		while ( !heli_friendlyfire )
+		{
+			continue;
+		}
+		if ( isplayer( attacker ) )
+		{
+			attacker maps/mp/gametypes/_damagefeedback::updatedamagefeedback( meansofdeath );
+			if ( attacker hasperk( "specialty_armorpiercing" ) )
+			{
+				if ( meansofdeath == "MOD_RIFLE_BULLET" || meansofdeath == "MOD_PISTOL_BULLET" )
+				{
+					damage += int( damage * level.cac_armorpiercing_data );
+				}
+			}
+		}
+		if ( meansofdeath == "MOD_RIFLE_BULLET" || meansofdeath == "MOD_PISTOL_BULLET" )
+		{
+			damage *= level.heli_armor_bulletdamage;
+		}
+		if ( isDefined( weapon ) )
+		{
+			if ( maps/mp/gametypes/_weapon_utils::islauncherweapon( weapon ) || weapon == "remote_missile_missile_mp" )
+			{
+				damage = maxhealth + 1;
+			}
+		}
+		while ( damage <= 0 )
+		{
+			continue;
+		}
+		self.owner playlocalsound( "reaper_damaged" );
+		self.owner sendkillstreakdamageevent( int( damage ) );
+		damagetaken += damage;
+		if ( damagetaken >= maxhealth )
+		{
+			if ( self.owner isenemyplayer( attacker ) )
+			{
+				maps/mp/_scoreevents::processscoreevent( "destroyed_remote_mortar", attacker, self.owner, weapon );
+				attacker maps/mp/_challenges::addflyswatterstat( weapon, self );
+				attacker addweaponstat( weapon, "destroyed_controlled_killstreak", 1 );
+				attacker destroyedplayercontrolledaircraft();
+				break;
+			}
+			level thread maps/mp/_popups::displayteammessagetoall( &"KILLSTREAK_DESTROYED_REMOTE_MORTAR", attacker );
+			self thread remote_killstreak_end( 1 );
+			return;
+			continue;
+		}
+		else
+		{
+			if ( !self.lowhealth && damagetaken >= ( maxhealth / 2 ) )
+			{
+				playfxontag( level.fx_u2_damage_trail, self, "tag_origin" );
+				self.lowhealth = 1;
+			}
+		}
+	}
+}
+
+remote_leave()
+{
+	level endon( "game_ended" );
+	self endon( "death" );
+	self unlink();
+	tries = 10;
+	yaw = 0;
+	while ( tries > 0 )
+	{
+		exitvector = anglesToForward( self.angles + ( 0, yaw, 0 ) ) * 20000;
+		exitpoint = ( self.origin[ 0 ] + exitvector[ 0 ], self.origin[ 1 ] + exitvector[ 1 ], self.origin[ 2 ] - 2500 );
+		exitpoint = self.origin + exitvector;
+		nfz = crossesnoflyzone( self.origin, exitpoint );
+		if ( isDefined( nfz ) )
+		{
+			if ( ( tries % 2 ) == 1 && tries != 1 )
+			{
+				yaw *= -1;
+				tries--;
+				continue;
+			}
+			else
+			{
+				if ( tries != 1 )
+				{
+					yaw += 10;
+					yaw *= -1;
+				}
+			}
+			tries--;
+
+			continue;
+		}
+		else
+		{
+			tries = 0;
+		}
+	}
+	self thread maps/mp/killstreaks/_spyplane::flattenyaw( self.angles[ 1 ] + yaw );
+	self moveto( exitpoint, 8, 4 );
+	if ( self.lowhealth )
+	{
+		playfxontag( level.chopper_fx[ "damage" ][ "heavy_smoke" ], self, "tag_origin" );
+	}
+	self thread play_afterburner_fx();
+	maps/mp/gametypes/_hostmigration::waitlongdurationwithhostmigrationpause( 8 );
+	self delete();
+}
+
+play_remote_fx()
+{
+	self.exhaustfx = spawn( "script_model", self.origin );
+	self.exhaustfx setmodel( "tag_origin" );
+	self.exhaustfx linkto( self, "tag_turret", vectorScale( ( 0, 0, 1 ), 25 ) );
+	wait 0,1;
+	playfxontag( level.fx_cuav_burner, self.exhaustfx, "tag_origin" );
+}
+
+play_afterburner_fx()
+{
+	if ( !isDefined( self.exhaustfx ) )
+	{
+		self.exhaustfx = spawn( "script_model", self.origin );
+		self.exhaustfx setmodel( "tag_origin" );
+		self.exhaustfx linkto( self, "tag_turret", vectorScale( ( 0, 0, 1 ), 25 ) );
+	}
+	self endon( "death" );
+	wait 0,1;
+	playfxontag( level.fx_cuav_afterburner, self.exhaustfx, "tag_origin" );
+}
+
+remote_explode()
+{
+	self notify( "death" );
+	self hide();
+	forward = anglesToForward( self.angles ) * 200;
+	playfx( level.fx_u2_explode, self.origin, forward );
+	self playsound( "evt_helicopter_midair_exp" );
+	wait 0,2;
+	self notify( "delete" );
+	self delete();
+}
+
+visionswitch()
+{
+	self endon( "disconnect" );
+	level endon( "remote_end" );
+	inverted = 1;
+	self setinfraredvision( 1 );
+	self useservervisionset( 1 );
+	self setvisionsetforplayer( level.remore_mortar_infrared_vision, 1 );
+	for ( ;; )
+	{
+		while ( self changeseatbuttonpressed() )
+		{
+			if ( !inverted )
+			{
+				self setinfraredvision( 1 );
+				self setvisionsetforplayer( level.remore_mortar_infrared_vision, 0,5 );
+				self playlocalsound( "mpl_ks_reaper_view_select" );
+			}
+			else
+			{
+				self setinfraredvision( 0 );
+				self setvisionsetforplayer( level.remore_mortar_enhanced_vision, 0,5 );
+				self playlocalsound( "mpl_ks_reaper_view_select" );
+			}
+			inverted = !inverted;
+			while ( self changeseatbuttonpressed() )
+			{
+				wait 0,05;
+			}
+		}
+		wait 0,05;
+	}
+}

patch_mp/maps/mp/killstreaks/_supplycrate.gsc

@@ -0,0 +1,2 @@
+#include maps/mp/_utility;
+#include common_scripts/utility;

patch_mp/maps/mp/mp_bridge.gsc

@@ -0,0 +1,202 @@
+#include maps/mp/gametypes/_deathicons;
+#include maps/mp/gametypes/_spawning;
+#include maps/mp/_compass;
+#include common_scripts/utility;
+#include maps/mp/_utility;
+
+main()
+{
+	level.levelspawndvars = ::levelspawndvars;
+	maps/mp/mp_bridge_fx::main();
+	precachemodel( "collision_physics_128x128x10" );
+	precachemodel( "collision_missile_128x128x10" );
+	precachemodel( "collision_physics_64x64x10" );
+	precachemodel( "collision_missile_32x32x128" );
+	precachemodel( "collision_clip_32x32x10" );
+	precachemodel( "p6_bri_construction_tarp" );
+	maps/mp/_load::main();
+	maps/mp/mp_bridge_amb::main();
+	maps/mp/_compass::setupminimap( "compass_map_mp_bridge" );
+	setdvar( "compassmaxrange", "2100" );
+	game[ "strings" ][ "war_callsign_a" ] = &"MPUI_CALLSIGN_MAPNAME_A";
+	game[ "strings" ][ "war_callsign_b" ] = &"MPUI_CALLSIGN_MAPNAME_B";
+	game[ "strings" ][ "war_callsign_c" ] = &"MPUI_CALLSIGN_MAPNAME_C";
+	game[ "strings" ][ "war_callsign_d" ] = &"MPUI_CALLSIGN_MAPNAME_D";
+	game[ "strings" ][ "war_callsign_e" ] = &"MPUI_CALLSIGN_MAPNAME_E";
+	game[ "strings_menu" ][ "war_callsign_a" ] = "@MPUI_CALLSIGN_MAPNAME_A";
+	game[ "strings_menu" ][ "war_callsign_b" ] = "@MPUI_CALLSIGN_MAPNAME_B";
+	game[ "strings_menu" ][ "war_callsign_c" ] = "@MPUI_CALLSIGN_MAPNAME_C";
+	game[ "strings_menu" ][ "war_callsign_d" ] = "@MPUI_CALLSIGN_MAPNAME_D";
+	game[ "strings_menu" ][ "war_callsign_e" ] = "@MPUI_CALLSIGN_MAPNAME_E";
+	spawncollision( "collision_physics_128x128x10", "collider", ( -1190, -876, -76 ), ( 342, 2,63, -90 ) );
+	barricade1 = spawn( "script_model", ( 850,5, -812,5, 0 ) );
+	barricade1.angles = vectorScale( ( 0, 0, 1 ), 90 );
+	barricade1 setmodel( "p6_bri_construction_tarp" );
+	spawncollision( "collision_missile_128x128x10", "collider", ( -2182, -185,5, -142 ), vectorScale( ( 0, 0, 1 ), 90 ) );
+	spawncollision( "collision_missile_128x128x10", "collider", ( -2310, -185,5, -142 ), vectorScale( ( 0, 0, 1 ), 90 ) );
+	spawncollision( "collision_missile_128x128x10", "collider", ( -2438, -185,5, -142 ), vectorScale( ( 0, 0, 1 ), 90 ) );
+	spawncollision( "collision_missile_128x128x10", "collider", ( -2182, -57,5, -142 ), vectorScale( ( 0, 0, 1 ), 90 ) );
+	spawncollision( "collision_missile_128x128x10", "collider", ( -2310, -57,5, -142 ), vectorScale( ( 0, 0, 1 ), 90 ) );
+	spawncollision( "collision_missile_128x128x10", "collider", ( -2438, -57,5, -142 ), vectorScale( ( 0, 0, 1 ), 90 ) );
+	spawncollision( "collision_missile_128x128x10", "collider", ( -2366,5, 91, -142 ), vectorScale( ( 0, 0, 1 ), 90 ) );
+	spawncollision( "collision_missile_128x128x10", "collider", ( -1401,5, 759,5, -158,5 ), vectorScale( ( 0, 0, 1 ), 92,40023 ) );
+	spawncollision( "collision_missile_128x128x10", "collider", ( -1309, 726,5, -158,5 ), ( 2,4, 359,9, -91,70473 ) );
+	spawncollision( "collision_missile_128x128x10", "collider", ( -1401,5, 634, -154,5 ), vectorScale( ( 0, 0, 1 ), 92,40023 ) );
+	spawncollision( "collision_missile_128x128x10", "collider", ( -1373,5, 634, -154,5 ), vectorScale( ( 0, 0, 1 ), 92,40023 ) );
+	spawncollision( "collision_missile_128x128x10", "collider", ( -1401,5, 559,5, -154,5 ), vectorScale( ( 0, 0, 1 ), 92,40023 ) );
+	spawncollision( "collision_missile_128x128x10", "collider", ( -1422, 375,5, -141,5 ), vectorScale( ( 0, 0, 1 ), 92,40023 ) );
+	spawncollision( "collision_missile_128x128x10", "collider", ( -1322,5, 438, -146 ), vectorScale( ( 0, 0, 1 ), 92,40023 ) );
+	spawncollision( "collision_missile_128x128x10", "collider", ( -1304,5, 438, -146 ), vectorScale( ( 0, 0, 1 ), 92,40023 ) );
+	spawncollision( "collision_missile_128x128x10", "collider", ( -1322,5, 378,5, -144 ), vectorScale( ( 0, 0, 1 ), 92,40023 ) );
+	spawncollision( "collision_missile_128x128x10", "collider", ( -1230, 396, -144 ), vectorScale( ( 0, 0, 1 ), 92,40023 ) );
+	spawncollision( "collision_missile_128x128x10", "collider", ( -1357, 248, -139 ), vectorScale( ( 0, 0, 1 ), 92,40023 ) );
+	spawncollision( "collision_missile_128x128x10", "collider", ( -1230, 285, -139 ), vectorScale( ( 0, 0, 1 ), 92,40023 ) );
+	spawncollision( "collision_missile_128x128x10", "collider", ( -1230, 248, -139 ), vectorScale( ( 0, 0, 1 ), 92,40023 ) );
+	spawncollision( "collision_missile_128x128x10", "collider", ( 1370, -697, -134 ), vectorScale( ( 0, 0, 1 ), 90 ) );
+	spawncollision( "collision_physics_64x64x10", "collider", ( 2432, -44, 30,5 ), ( 0, 270, -90 ) );
+	spawncollision( "collision_physics_64x64x10", "collider", ( 2113,5, -44, 30,5 ), ( 0, 270, -90 ) );
+	spawncollision( "collision_missile_32x32x128", "collider", ( -2292, -174, -7,5 ), vectorScale( ( 0, 0, 1 ), 270 ) );
+	spawncollision( "collision_missile_128x128x10", "collider", ( -2219,5, -184,5, 37 ), vectorScale( ( 0, 0, 1 ), 2,9 ) );
+	spawncollision( "collision_missile_128x128x10", "collider", ( -2197,5, -184,5, 33 ), vectorScale( ( 0, 0, 1 ), 23,9 ) );
+	spawncollision( "collision_clip_32x32x10", "collider", ( 1923,5, 553,5, 43,5 ), ( 1,265, 43,3, -90 ) );
+	maps/mp/gametypes/_spawning::level_use_unified_spawning( 1 );
+	registerclientfield( "scriptmover", "police_car_lights", 1, 1, "int" );
+	level thread destructible_lights();
+	setdvar( "r_lightGridEnableTweaks", 1 );
+	setdvar( "r_lightGridIntensity", 2 );
+	setdvar( "r_lightGridContrast", 0 );
+	level.ragdoll_override = ::ragdoll_override;
+	level.overrideplayerdeathwatchtimer = ::leveloverridetime;
+	level.useintermissionpointsonwavespawn = ::useintermissionpointsonwavespawn;
+	level thread pathing_fix();
+}
+
+levelspawndvars( reset_dvars )
+{
+	ss = level.spawnsystem;
+	ss.enemy_influencer_radius = set_dvar_float_if_unset( "scr_spawn_enemy_influencer_radius", "2400", reset_dvars );
+	ss.hq_objective_influencer_inner_radius = set_dvar_float_if_unset( "scr_spawn_hq_objective_influencer_inner_radius", "1000", reset_dvars );
+}
+
+destructible_lights()
+{
+	wait 0,05;
+	destructibles = getentarray( "destructible", "targetname" );
+	_a125 = destructibles;
+	_k125 = getFirstArrayKey( _a125 );
+	while ( isDefined( _k125 ) )
+	{
+		destructible = _a125[ _k125 ];
+		if ( destructible.destructibledef == "veh_t6_dlc_police_car_destructible" )
+		{
+			destructible thread destructible_think( "police_car_lights" );
+			destructible setclientfield( "police_car_lights", 1 );
+		}
+		_k125 = getNextArrayKey( _a125, _k125 );
+	}
+}
+
+destructible_think( clientfield )
+{
+	self waittill_any( "death", "destructible_base_piece_death" );
+	self setclientfield( clientfield, 0 );
+}
+
+ragdoll_override( idamage, smeansofdeath, sweapon, shitloc, vdir, vattackerorigin, deathanimduration, einflictor, ragdoll_jib, body )
+{
+	if ( smeansofdeath == "MOD_FALLING" )
+	{
+		deathanim = body getcorpseanim();
+		startfrac = deathanimduration / 1000;
+		if ( animhasnotetrack( deathanim, "start_ragdoll" ) )
+		{
+			times = getnotetracktimes( deathanim, "start_ragdoll" );
+			if ( isDefined( times ) )
+			{
+				startfrac = times[ 0 ];
+			}
+		}
+		self.body = body;
+		if ( !isDefined( self.switching_teams ) )
+		{
+			thread maps/mp/gametypes/_deathicons::adddeathicon( body, self, self.team, 5 );
+		}
+		self thread water_spash();
+		return 1;
+	}
+	return 0;
+}
+
+water_spash()
+{
+	self endon( "disconnect" );
+	self endon( "spawned_player" );
+	self endon( "joined_team" );
+	self endon( "joined_spectators" );
+	trace = groundtrace( self.origin, self.origin - vectorScale( ( 0, 0, 1 ), 2048 ), 0, self.body );
+	if ( trace[ "surfacetype" ] == "water" )
+	{
+		while ( self.origin[ 2 ] > ( trace[ "position" ][ 2 ] + 5 ) )
+		{
+			wait 0,05;
+		}
+		bone = self gettagorigin( "j_spinelower" );
+		origin = ( bone[ 0 ], bone[ 1 ], trace[ "position" ][ 2 ] + 2,5 );
+		self playsound( "mpl_splash_death" );
+		playfx( level._effect[ "water_splash" ], origin );
+	}
+}
+
+leveloverridetime( defaulttime )
+{
+	if ( self isinwater() )
+	{
+		return 1;
+	}
+	return defaulttime;
+}
+
+useintermissionpointsonwavespawn()
+{
+	return self isinwater();
+}
+
+isinwater()
+{
+	triggers = getentarray( "trigger_hurt", "classname" );
+	_a212 = triggers;
+	_k212 = getFirstArrayKey( _a212 );
+	while ( isDefined( _k212 ) )
+	{
+		trigger = _a212[ _k212 ];
+		if ( trigger.origin[ 2 ] > level.mapcenter[ 2 ] )
+		{
+		}
+		else
+		{
+			if ( self istouching( trigger ) )
+			{
+				return 1;
+			}
+		}
+		_k212 = getNextArrayKey( _a212, _k212 );
+	}
+	return 0;
+}
+
+pathing_fix()
+{
+	wait 1;
+	nodes = getallnodes();
+	disconnect_node( nodes[ 96 ] );
+	disconnect_node( nodes[ 600 ] );
+}
+
+disconnect_node( node )
+{
+	ent = spawn( "script_model", node.origin, 1 );
+	ent setmodel( level.deployedshieldmodel );
+	ent hide();
+	ent disconnectpaths();
+	ent.origin -= vectorScale( ( 0, 0, 1 ), 64 );
+}

patch_mp/maps/mp/mp_carrier.gsc

@@ -0,0 +1,153 @@
+#include maps/mp/_compass;
+#include maps/mp/_utility;
+
+main()
+{
+	level.levelspawndvars = ::levelspawndvars;
+	level.overrideplayerdeathwatchtimer = ::leveloverridetime;
+	level.useintermissionpointsonwavespawn = ::useintermissionpointsonwavespawn;
+	maps/mp/mp_carrier_fx::main();
+	precachemodel( "collision_physics_wall_512x512x10" );
+	precachemodel( "collision_clip_cylinder_32x128" );
+	precachemodel( "collision_physics_cylinder_32x128" );
+	precachemodel( "collision_clip_wall_32x32x10" );
+	precachemodel( "collision_physics_wall_32x32x10" );
+	precachemodel( "collision_physics_64x64x128" );
+	precachemodel( "collision_physics_32x32x128" );
+	precachemodel( "collision_physics_wall_128x128x10" );
+	precachemodel( "collision_clip_wall_64x64x10" );
+	precachemodel( "collision_physics_32x32x32" );
+	precachemodel( "collision_physics_cylinder_32x128" );
+	precachemodel( "ac_prs_fps_road_chunk_lrg_a04" );
+	precachemodel( "collision_clip_32x32x32" );
+	maps/mp/_load::main();
+	maps/mp/mp_carrier_amb::main();
+	maps/mp/_compass::setupminimap( "compass_map_mp_carrier" );
+	game[ "strings" ][ "war_callsign_a" ] = &"MPUI_CALLSIGN_MAPNAME_A";
+	game[ "strings" ][ "war_callsign_b" ] = &"MPUI_CALLSIGN_MAPNAME_B";
+	game[ "strings" ][ "war_callsign_c" ] = &"MPUI_CALLSIGN_MAPNAME_C";
+	game[ "strings" ][ "war_callsign_d" ] = &"MPUI_CALLSIGN_MAPNAME_D";
+	game[ "strings" ][ "war_callsign_e" ] = &"MPUI_CALLSIGN_MAPNAME_E";
+	game[ "strings_menu" ][ "war_callsign_a" ] = "@MPUI_CALLSIGN_MAPNAME_A";
+	game[ "strings_menu" ][ "war_callsign_b" ] = "@MPUI_CALLSIGN_MAPNAME_B";
+	game[ "strings_menu" ][ "war_callsign_c" ] = "@MPUI_CALLSIGN_MAPNAME_C";
+	game[ "strings_menu" ][ "war_callsign_d" ] = "@MPUI_CALLSIGN_MAPNAME_D";
+	game[ "strings_menu" ][ "war_callsign_e" ] = "@MPUI_CALLSIGN_MAPNAME_E";
+	spawncollision( "collision_physics_wall_512x512x10", "collider", ( -3733, -1301,22, -204,5 ), vectorScale( ( 0, 0, 1 ), 75,2 ) );
+	spawncollision( "collision_physics_wall_512x512x10", "collider", ( -3509, -1301,22, -204,56 ), vectorScale( ( 0, 0, 1 ), 75,2 ) );
+	spawncollision( "collision_physics_wall_512x512x10", "collider", ( -3733, -808,22, -334,56 ), vectorScale( ( 0, 0, 1 ), 75,2 ) );
+	spawncollision( "collision_physics_wall_512x512x10", "collider", ( -3509, -808,22, -334,56 ), vectorScale( ( 0, 0, 1 ), 75,2 ) );
+	spawncollision( "collision_clip_cylinder_32x128", "collider", ( -4821, 951, 82 ), vectorScale( ( 0, 0, 1 ), 344 ) );
+	spawncollision( "collision_clip_wall_32x32x10", "collider", ( -4820,39, 930,19, 123 ), vectorScale( ( 0, 0, 1 ), 245 ) );
+	spawncollision( "collision_clip_wall_32x32x10", "collider", ( -4820,39, 930,19, 91 ), vectorScale( ( 0, 0, 1 ), 245 ) );
+	spawncollision( "collision_clip_wall_32x32x10", "collider", ( -4820,39, 930,19, 59 ), vectorScale( ( 0, 0, 1 ), 245 ) );
+	spawncollision( "collision_physics_cylinder_32x128", "collider", ( -4821, 951, 82 ), vectorScale( ( 0, 0, 1 ), 344 ) );
+	spawncollision( "collision_physics_wall_32x32x10", "collider", ( -4820,39, 930,19, 123 ), vectorScale( ( 0, 0, 1 ), 245 ) );
+	spawncollision( "collision_physics_wall_32x32x10", "collider", ( -4820,39, 930,19, 91 ), vectorScale( ( 0, 0, 1 ), 245 ) );
+	spawncollision( "collision_physics_wall_32x32x10", "collider", ( -4820,39, 930,19, 59 ), vectorScale( ( 0, 0, 1 ), 245 ) );
+	spawncollision( "collision_physics_cylinder_32x128", "collider", ( -5448, 912, 268 ), vectorScale( ( 0, 0, 1 ), 13 ) );
+	spawncollision( "collision_physics_64x64x128", "collider", ( -2434, 806, 66 ), ( 270, 25, 0 ) );
+	spawncollision( "collision_physics_32x32x128", "collider", ( -5003, -963, -100 ), vectorScale( ( 0, 0, 1 ), 270 ) );
+	spawncollision( "collision_physics_32x32x128", "collider", ( -5003, -1091, -100 ), vectorScale( ( 0, 0, 1 ), 270 ) );
+	spawncollision( "collision_physics_32x32x128", "collider", ( -5003, -1219, -88 ), vectorScale( ( 0, 0, 1 ), 270 ) );
+	spawncollision( "collision_physics_wall_128x128x10", "collider", ( -5013, -1128, -32 ), ( 270, 270, 180 ) );
+	spawncollision( "collision_physics_wall_128x128x10", "collider", ( -3257,5, -1184,5, -45 ), ( 270, 270, 180 ) );
+	spawncollision( "collision_physics_wall_128x128x10", "collider", ( -3257,5, -1128, -45 ), ( 270, 270, 180 ) );
+	spawncollision( "collision_clip_wall_64x64x10", "collider", ( -4696,5, 662,5, 163,5 ), vectorScale( ( 0, 0, 1 ), 283,2 ) );
+	spawncollision( "collision_clip_wall_64x64x10", "collider", ( -5017, -1083,5, 40 ), ( 1, 270, 180 ) );
+	spawncollision( "collision_clip_wall_64x64x10", "collider", ( -6316, -1554,5, -30 ), vectorScale( ( 0, 0, 1 ), 49,9 ) );
+	spawncollision( "collision_physics_32x32x32", "collider", ( -5852,5, -886, 159,5 ), vectorScale( ( 0, 0, 1 ), 2,59995 ) );
+	spawncollision( "collision_physics_32x32x32", "collider", ( -5875,5, -887, 159,5 ), vectorScale( ( 0, 0, 1 ), 2,59995 ) );
+	spawncollision( "collision_physics_cylinder_32x128", "collider", ( -5331,5, 727, 247,5 ), vectorScale( ( 0, 0, 1 ), 90 ) );
+	spawncollision( "collision_clip_wall_64x64x10", "collider", ( -5838, -913,5, 85 ), vectorScale( ( 0, 0, 1 ), 19,8001 ) );
+	greenbarrel1 = spawn( "script_model", ( -5979,48, -347,391, 53,8051 ) );
+	greenbarrel1.angles = ( 0, 0, 1 );
+	greenbarrel1 setmodel( "ac_prs_fps_road_chunk_lrg_a04" );
+	greenbarrel2 = spawn( "script_model", ( -5960,64, -349,489, 59,663 ) );
+	greenbarrel2.angles = ( 5,97936, 96,3096, 13,1076 );
+	greenbarrel2 setmodel( "ac_prs_fps_road_chunk_lrg_a04" );
+	spawncollision( "collision_clip_32x32x32", "collider", ( -5987,5, -347,5, 47 ), vectorScale( ( 0, 0, 1 ), 64,8 ) );
+	spawncollision( "collision_clip_32x32x32", "collider", ( -5957,2, -356,902, 47,25 ), vectorScale( ( 0, 0, 1 ), 102,9 ) );
+	level thread water_trigger_init();
+}
+
+levelspawndvars( reset_dvars )
+{
+	ss = level.spawnsystem;
+	ss.enemy_influencer_radius = set_dvar_float_if_unset( "scr_spawn_enemy_influencer_radius", "2600", reset_dvars );
+}
+
+water_trigger_init()
+{
+	wait 3;
+	triggers = getentarray( "trigger_hurt", "classname" );
+	_a141 = triggers;
+	_k141 = getFirstArrayKey( _a141 );
+	while ( isDefined( _k141 ) )
+	{
+		trigger = _a141[ _k141 ];
+		if ( trigger.origin[ 2 ] > level.mapcenter[ 2 ] )
+		{
+		}
+		else
+		{
+			trigger thread water_trigger_think();
+		}
+		_k141 = getNextArrayKey( _a141, _k141 );
+	}
+}
+
+water_trigger_think()
+{
+	for ( ;; )
+	{
+		self waittill( "trigger", entity );
+		if ( isplayer( entity ) )
+		{
+			trace = worldtrace( entity.origin + vectorScale( ( 0, 0, 1 ), 30 ), entity.origin - vectorScale( ( 0, 0, 1 ), 256 ) );
+			if ( trace[ "surfacetype" ] == "none" )
+			{
+				entity playsound( "mpl_splash_death" );
+				playfx( level._effect[ "water_splash" ], entity.origin + vectorScale( ( 0, 0, 1 ), 40 ) );
+			}
+		}
+	}
+}
+
+leveloverridetime( defaulttime )
+{
+	if ( self isinwater() )
+	{
+		return 0,4;
+	}
+	return defaulttime;
+}
+
+useintermissionpointsonwavespawn()
+{
+	return self isinwater();
+}
+
+isinwater()
+{
+	triggers = getentarray( "trigger_hurt", "classname" );
+	_a189 = triggers;
+	_k189 = getFirstArrayKey( _a189 );
+	while ( isDefined( _k189 ) )
+	{
+		trigger = _a189[ _k189 ];
+		if ( trigger.origin[ 2 ] > level.mapcenter[ 2 ] )
+		{
+		}
+		else
+		{
+			if ( self.origin[ 2 ] < trigger.origin[ 2 ] )
+			{
+				trace = worldtrace( self.origin + vectorScale( ( 0, 0, 1 ), 30 ), self.origin - vectorScale( ( 0, 0, 1 ), 256 ) );
+				return trace[ "surfacetype" ] == "none";
+			}
+		}
+		_k189 = getNextArrayKey( _a189, _k189 );
+	}
+	return 0;
+}

patch_mp/maps/mp/mp_castaway.gsc

@@ -0,0 +1,57 @@
+#include maps/mp/_compass;
+#include maps/mp/_utility;
+
+main()
+{
+	level.levelspawndvars = ::levelspawndvars;
+	maps/mp/mp_castaway_fx::main();
+	precachemodel( "collision_physics_64x64x10" );
+	precachemodel( "collision_clip_64x64x10" );
+	precachemodel( "collision_physics_128x128x10" );
+	precachemodel( "p6_cas_rock_medium_02_trimmed" );
+	maps/mp/_load::main();
+	maps/mp/mp_castaway_amb::main();
+	maps/mp/_compass::setupminimap( "compass_map_mp_castaway" );
+	setdvar( "compassmaxrange", "2100" );
+	setdvar( "bg_dog_swim_enabled", 1 );
+	game[ "strings" ][ "war_callsign_a" ] = &"MPUI_CALLSIGN_MAPNAME_A";
+	game[ "strings" ][ "war_callsign_b" ] = &"MPUI_CALLSIGN_MAPNAME_B";
+	game[ "strings" ][ "war_callsign_c" ] = &"MPUI_CALLSIGN_MAPNAME_C";
+	game[ "strings" ][ "war_callsign_d" ] = &"MPUI_CALLSIGN_MAPNAME_D";
+	game[ "strings" ][ "war_callsign_e" ] = &"MPUI_CALLSIGN_MAPNAME_E";
+	game[ "strings_menu" ][ "war_callsign_a" ] = "@MPUI_CALLSIGN_MAPNAME_A";
+	game[ "strings_menu" ][ "war_callsign_b" ] = "@MPUI_CALLSIGN_MAPNAME_B";
+	game[ "strings_menu" ][ "war_callsign_c" ] = "@MPUI_CALLSIGN_MAPNAME_C";
+	game[ "strings_menu" ][ "war_callsign_d" ] = "@MPUI_CALLSIGN_MAPNAME_D";
+	game[ "strings_menu" ][ "war_callsign_e" ] = "@MPUI_CALLSIGN_MAPNAME_E";
+	spawncollision( "collision_physics_64x64x10", "collider", ( -1181, 1602, 242 ), ( 9,8, 270, 106 ) );
+	spawncollision( "collision_physics_64x64x10", "collider", ( -1181, 1635, 242 ), ( 9,81, 270, 106 ) );
+	spawncollision( "collision_physics_64x64x10", "collider", ( -1174, 1602, 197 ), ( 360, 270, 90 ) );
+	spawncollision( "collision_physics_64x64x10", "collider", ( -1174, 1635, 197 ), ( 360, 270, 90 ) );
+	spawncollision( "collision_physics_64x64x10", "collider", ( -329, 656, 123 ), ( 359,424, 286,385, 127,196 ) );
+	spawncollision( "collision_physics_64x64x10", "collider", ( -342, 699, 124 ), ( 354,888, 295,033, 125,723 ) );
+	spawncollision( "collision_physics_64x64x10", "collider", ( -707, 2358, 145 ), vectorScale( ( 0, 1, 0 ), 90 ) );
+	spawncollision( "collision_clip_64x64x10", "collider", ( 407,5, 518, 103 ), vectorScale( ( 0, 1, 0 ), 270 ) );
+	spawncollision( "collision_clip_64x64x10", "collider", ( 381, 552, 103 ), ( 270, 65,4, 6,57 ) );
+	spawncollision( "collision_clip_64x64x10", "collider", ( 343, 559, 103 ), ( 270, 112,8, 0 ) );
+	spawncollision( "collision_clip_64x64x10", "collider", ( 370,5, 526, 128,5 ), vectorScale( ( 0, 1, 0 ), 66,2 ) );
+	spawncollision( "collision_clip_64x64x10", "collider", ( 357, 525, 129,5 ), vectorScale( ( 0, 1, 0 ), 23 ) );
+	rock1 = spawn( "script_model", ( 373,607, 484,974, 42,6 ) );
+	rock1.angles = ( 350,899, 243,975, 4,02471 );
+	rock1 setmodel( "p6_cas_rock_medium_02_trimmed" );
+	spawncollision( "collision_physics_64x64x10", "collider", ( 479,5, 270, 75 ), ( 346,453, 344,758, 4,31137 ) );
+	spawncollision( "collision_physics_64x64x10", "collider", ( 477,5, 270, 76 ), ( 349,833, 342,352, 15,9726 ) );
+	spawncollision( "collision_physics_128x128x10", "collider", ( 1503, 186, 121 ), ( 16,2357, 331,376, -70,4431 ) );
+	spawncollision( "collision_physics_128x128x10", "collider", ( 1571, 147, 97 ), ( 16,2357, 331,376, -70,4431 ) );
+	spawncollision( "collision_clip_64x64x10", "collider", ( 1411, 118,5, 161,5 ), ( 4,9243, 334,331, 80,0809 ) );
+	level.levelkothdisable = [];
+	level.levelkothdisable[ level.levelkothdisable.size ] = spawn( "trigger_radius", ( 281,5, 443,5, 161 ), 0, 50, 50 );
+}
+
+levelspawndvars( reset_dvars )
+{
+	ss = level.spawnsystem;
+	ss.enemy_influencer_radius = set_dvar_float_if_unset( "scr_spawn_enemy_influencer_radius", "2200", reset_dvars );
+	ss.hq_objective_influencer_inner_radius = set_dvar_float_if_unset( "scr_spawn_hq_objective_influencer_inner_radius", "1000", reset_dvars );
+	ss.hq_objective_influencer_radius = 3000;
+}

patch_mp/maps/mp/mp_concert.gsc

@@ -0,0 +1,136 @@
+#include maps/mp/gametypes/_spawning;
+#include maps/mp/_compass;
+#include maps/mp/_utility;
+
+main()
+{
+	level.levelspawndvars = ::levelspawndvars;
+	level.overrideplayerdeathwatchtimer = ::leveloverridetime;
+	level.useintermissionpointsonwavespawn = ::useintermissionpointsonwavespawn;
+	maps/mp/mp_concert_fx::main();
+	maps/mp/_load::main();
+	maps/mp/mp_concert_amb::main();
+	maps/mp/_compass::setupminimap( "compass_map_mp_concert" );
+	setdvar( "compassmaxrange", "2100" );
+	game[ "strings" ][ "war_callsign_a" ] = &"MPUI_CALLSIGN_MAPNAME_A";
+	game[ "strings" ][ "war_callsign_b" ] = &"MPUI_CALLSIGN_MAPNAME_B";
+	game[ "strings" ][ "war_callsign_c" ] = &"MPUI_CALLSIGN_MAPNAME_C";
+	game[ "strings" ][ "war_callsign_d" ] = &"MPUI_CALLSIGN_MAPNAME_D";
+	game[ "strings" ][ "war_callsign_e" ] = &"MPUI_CALLSIGN_MAPNAME_E";
+	game[ "strings_menu" ][ "war_callsign_a" ] = "@MPUI_CALLSIGN_MAPNAME_A";
+	game[ "strings_menu" ][ "war_callsign_b" ] = "@MPUI_CALLSIGN_MAPNAME_B";
+	game[ "strings_menu" ][ "war_callsign_c" ] = "@MPUI_CALLSIGN_MAPNAME_C";
+	game[ "strings_menu" ][ "war_callsign_d" ] = "@MPUI_CALLSIGN_MAPNAME_D";
+	game[ "strings_menu" ][ "war_callsign_e" ] = "@MPUI_CALLSIGN_MAPNAME_E";
+	maps/mp/gametypes/_spawning::level_use_unified_spawning( 1 );
+	level.remotemotarviewup = 18;
+	level thread water_trigger_init();
+}
+
+levelspawndvars( reset_dvars )
+{
+	ss = level.spawnsystem;
+	ss.enemy_influencer_radius = set_dvar_float_if_unset( "scr_spawn_enemy_influencer_radius", "2300", reset_dvars );
+}
+
+water_trigger_init()
+{
+	wait 3;
+	triggers = getentarray( "trigger_hurt", "classname" );
+	_a61 = triggers;
+	_k61 = getFirstArrayKey( _a61 );
+	while ( isDefined( _k61 ) )
+	{
+		trigger = _a61[ _k61 ];
+		if ( trigger.origin[ 2 ] > level.mapcenter[ 2 ] )
+		{
+		}
+		else
+		{
+			trigger thread water_trigger_think();
+		}
+		_k61 = getNextArrayKey( _a61, _k61 );
+	}
+	triggers = getentarray( "water_killbrush", "targetname" );
+	_a73 = triggers;
+	_k73 = getFirstArrayKey( _a73 );
+	while ( isDefined( _k73 ) )
+	{
+		trigger = _a73[ _k73 ];
+		trigger thread player_splash_think();
+		_k73 = getNextArrayKey( _a73, _k73 );
+	}
+}
+
+player_splash_think()
+{
+	for ( ;; )
+	{
+		self waittill( "trigger", entity );
+		if ( isplayer( entity ) && isalive( entity ) )
+		{
+			self thread trigger_thread( entity, ::player_water_fx );
+		}
+	}
+}
+
+player_water_fx( player, endon_condition )
+{
+	maxs = self.origin + self getmaxs();
+	if ( maxs[ 2 ] > 60 )
+	{
+		maxs += vectorScale( ( 0, 0, 1 ), 10 );
+	}
+	origin = ( player.origin[ 0 ], player.origin[ 1 ], maxs[ 2 ] );
+	playfx( level._effect[ "water_splash_sm" ], origin );
+}
+
+water_trigger_think()
+{
+	for ( ;; )
+	{
+		self waittill( "trigger", entity );
+		if ( isplayer( entity ) )
+		{
+			entity playsound( "mpl_splash_death" );
+			playfx( level._effect[ "water_splash" ], entity.origin + vectorScale( ( 0, 0, 1 ), 40 ) );
+		}
+	}
+}
+
+leveloverridetime( defaulttime )
+{
+	if ( self isinwater() )
+	{
+		return 0,4;
+	}
+	return defaulttime;
+}
+
+useintermissionpointsonwavespawn()
+{
+	return self isinwater();
+}
+
+isinwater()
+{
+	triggers = getentarray( "trigger_hurt", "classname" );
+	_a138 = triggers;
+	_k138 = getFirstArrayKey( _a138 );
+	while ( isDefined( _k138 ) )
+	{
+		trigger = _a138[ _k138 ];
+		if ( trigger.origin[ 2 ] > level.mapcenter[ 2 ] )
+		{
+		}
+		else
+		{
+			if ( self istouching( trigger ) )
+			{
+				return 1;
+			}
+		}
+		_k138 = getNextArrayKey( _a138, _k138 );
+	}
+	return 0;
+}

patch_mp/maps/mp/mp_dig.gsc

@@ -0,0 +1,52 @@
+#include maps/mp/gametypes/_spawning;
+#include maps/mp/_compass;
+#include maps/mp/_utility;
+
+main()
+{
+	level.levelspawndvars = ::levelspawndvars;
+	maps/mp/mp_dig_fx::main();
+	precachemodel( "collision_clip_wall_32x32x10" );
+	precachemodel( "p6_dig_brick_03" );
+	maps/mp/_load::main();
+	maps/mp/mp_dig_amb::main();
+	maps/mp/_compass::setupminimap( "compass_map_mp_dig" );
+	setdvar( "compassmaxrange", "2100" );
+	game[ "strings" ][ "war_callsign_a" ] = &"MPUI_CALLSIGN_MAPNAME_A";
+	game[ "strings" ][ "war_callsign_b" ] = &"MPUI_CALLSIGN_MAPNAME_B";
+	game[ "strings" ][ "war_callsign_c" ] = &"MPUI_CALLSIGN_MAPNAME_C";
+	game[ "strings" ][ "war_callsign_d" ] = &"MPUI_CALLSIGN_MAPNAME_D";
+	game[ "strings" ][ "war_callsign_e" ] = &"MPUI_CALLSIGN_MAPNAME_E";
+	game[ "strings_menu" ][ "war_callsign_a" ] = "@MPUI_CALLSIGN_MAPNAME_A";
+	game[ "strings_menu" ][ "war_callsign_b" ] = "@MPUI_CALLSIGN_MAPNAME_B";
+	game[ "strings_menu" ][ "war_callsign_c" ] = "@MPUI_CALLSIGN_MAPNAME_C";
+	game[ "strings_menu" ][ "war_callsign_d" ] = "@MPUI_CALLSIGN_MAPNAME_D";
+	game[ "strings_menu" ][ "war_callsign_e" ] = "@MPUI_CALLSIGN_MAPNAME_E";
+	brick1 = spawn( "script_model", ( -5,6285, 604,473, 39,05 ) );
+	brick1.angles = ( 359,199, 90,0129, -0,822672 );
+	brick2 = spawn( "script_model", ( -12,63, 604,47, 39,05 ) );
+	brick2.angles = ( 359,199, 90,0129, -0,822672 );
+	brick3 = spawn( "script_model", ( -5,63, 614,97, 39,05 ) );
+	brick3.angles = ( 359,199, 90,0129, -0,822672 );
+	brick4 = spawn( "script_model", ( -12,63, 614,97, 39,05 ) );
+	brick4.angles = ( 359,199, 90,0129, -0,822672 );
+	brick5 = spawn( "script_model", ( -5,63, 629,47, 39,55 ) );
+	brick5.angles = ( 359,199, 90,0129, -0,822672 );
+	brick6 = spawn( "script_model", ( -12,63, 629,47, 39,55 ) );
+	brick6.angles = ( 359,199, 90,0129, -0,822672 );
+	brick1 setmodel( "p6_dig_brick_03" );
+	brick2 setmodel( "p6_dig_brick_03" );
+	brick3 setmodel( "p6_dig_brick_03" );
+	brick4 setmodel( "p6_dig_brick_03" );
+	brick5 setmodel( "p6_dig_brick_03" );
+	brick6 setmodel( "p6_dig_brick_03" );
+	spawncollision( "collision_clip_wall_32x32x10", "collider", ( -1404, -1126, 46,5 ), vectorScale( ( 0, 1, 0 ), 90 ) );
+	maps/mp/gametypes/_spawning::level_use_unified_spawning( 1 );
+}
+
+levelspawndvars( reset_dvars )
+{
+	ss = level.spawnsystem;
+	ss.enemy_influencer_radius = set_dvar_float_if_unset( "scr_spawn_enemy_influencer_radius", "2300", reset_dvars );
+	ss.hq_objective_influencer_inner_radius = set_dvar_float_if_unset( "scr_spawn_hq_objective_influencer_inner_radius", "1000", reset_dvars );
+}

patch_mp/maps/mp/mp_dockside.gsc

@@ -0,0 +1,195 @@
+#include maps/mp/mp_dockside_crane;
+#include maps/mp/_compass;
+#include maps/mp/_utility;
+
+main()
+{
+	level.levelspawndvars = ::levelspawndvars;
+	maps/mp/mp_dockside_fx::main();
+	precachemodel( "collision_clip_64x64x64" );
+	precachemodel( "collision_clip_32x32x32" );
+	precachemodel( "collision_missile_128x128x10" );
+	precachemodel( "collision_missile_32x32x128" );
+	maps/mp/_load::main();
+	maps/mp/mp_dockside_amb::main();
+	maps/mp/_compass::setupminimap( "compass_map_mp_dockside" );
+	level.overrideplayerdeathwatchtimer = ::leveloverridetime;
+	level.useintermissionpointsonwavespawn = ::useintermissionpointsonwavespawn;
+	game[ "strings" ][ "war_callsign_a" ] = &"MPUI_CALLSIGN_MAPNAME_A";
+	game[ "strings" ][ "war_callsign_b" ] = &"MPUI_CALLSIGN_MAPNAME_B";
+	game[ "strings" ][ "war_callsign_c" ] = &"MPUI_CALLSIGN_MAPNAME_C";
+	game[ "strings" ][ "war_callsign_d" ] = &"MPUI_CALLSIGN_MAPNAME_D";
+	game[ "strings" ][ "war_callsign_e" ] = &"MPUI_CALLSIGN_MAPNAME_E";
+	game[ "strings_menu" ][ "war_callsign_a" ] = "@MPUI_CALLSIGN_MAPNAME_A";
+	game[ "strings_menu" ][ "war_callsign_b" ] = "@MPUI_CALLSIGN_MAPNAME_B";
+	game[ "strings_menu" ][ "war_callsign_c" ] = "@MPUI_CALLSIGN_MAPNAME_C";
+	game[ "strings_menu" ][ "war_callsign_d" ] = "@MPUI_CALLSIGN_MAPNAME_D";
+	game[ "strings_menu" ][ "war_callsign_e" ] = "@MPUI_CALLSIGN_MAPNAME_E";
+	spawncollision( "collision_clip_64x64x64", "collider", ( 1095, 1489, -111 ), ( 0, 0, 1 ) );
+	spawncollision( "collision_clip_32x32x32", "collider", ( 1079, 1441, -97 ), ( 0, 0, 1 ) );
+	spawncollision( "collision_clip_wall_128x128x10", "collider", ( -1791, 2954, -23 ), vectorScale( ( 0, 0, 1 ), 270 ) );
+	setdvar( "sm_sunsamplesizenear", 0,39 );
+	setdvar( "sm_sunshadowsmall", 1 );
+	if ( getgametypesetting( "allowMapScripting" ) )
+	{
+		level maps/mp/mp_dockside_crane::init();
+	}
+	else
+	{
+		crate_triggers = getentarray( "crate_kill_trigger", "targetname" );
+		i = 0;
+		while ( i < crate_triggers.size )
+		{
+			crate_triggers[ i ] delete();
+			i++;
+		}
+	}
+	setheliheightpatchenabled( "war_mode_heli_height_lock", 0 );
+	level thread water_trigger_init();
+	rts_remove();
+/#
+	level thread devgui_dockside();
+	execdevgui( "devgui_mp_dockside" );
+#/
+}
+
+levelspawndvars( reset_dvars )
+{
+	ss = level.spawnsystem;
+	ss.enemy_influencer_radius = set_dvar_float_if_unset( "scr_spawn_enemy_influencer_radius", "2700", reset_dvars );
+}
+
+water_trigger_init()
+{
+	wait 3;
+	triggers = getentarray( "trigger_hurt", "classname" );
+	_a92 = triggers;
+	_k92 = getFirstArrayKey( _a92 );
+	while ( isDefined( _k92 ) )
+	{
+		trigger = _a92[ _k92 ];
+		if ( trigger.origin[ 2 ] > level.mapcenter[ 2 ] )
+		{
+		}
+		else
+		{
+			trigger thread water_trigger_think();
+		}
+		_k92 = getNextArrayKey( _a92, _k92 );
+	}
+}
+
+water_trigger_think()
+{
+	for ( ;; )
+	{
+		self waittill( "trigger", entity );
+		if ( isplayer( entity ) )
+		{
+			entity playsound( "mpl_splash_death" );
+			playfx( level._effect[ "water_splash" ], entity.origin + vectorScale( ( 0, 0, 1 ), 40 ) );
+		}
+	}
+}
+
+leveloverridetime( defaulttime )
+{
+	if ( self isinwater() )
+	{
+		return 0,4;
+	}
+	return defaulttime;
+}
+
+useintermissionpointsonwavespawn()
+{
+	return self isinwater();
+}
+
+isinwater()
+{
+	triggers = getentarray( "trigger_hurt", "classname" );
+	_a138 = triggers;
+	_k138 = getFirstArrayKey( _a138 );
+	while ( isDefined( _k138 ) )
+	{
+		trigger = _a138[ _k138 ];
+		if ( trigger.origin[ 2 ] > level.mapcenter[ 2 ] )
+		{
+		}
+		else
+		{
+			if ( self istouching( trigger ) )
+			{
+				return 1;
+			}
+		}
+		_k138 = getNextArrayKey( _a138, _k138 );
+	}
+	return 0;
+}
+
+rts_remove()
+{
+	removes = getentarray( "rts_only", "targetname" );
+	_a157 = removes;
+	_k157 = getFirstArrayKey( _a157 );
+	while ( isDefined( _k157 ) )
+	{
+		remove = _a157[ _k157 ];
+		if ( isDefined( remove ) )
+		{
+			remove delete();
+		}
+		_k157 = getNextArrayKey( _a157, _k157 );
+	}
+}
+
+devgui_dockside()
+{
+/#
+	setdvar( "devgui_notify", "" );
+	for ( ;; )
+	{
+		wait 0,5;
+		devgui_string = getDvar( "devgui_notify" );
+		switch( devgui_string )
+		{
+			case "":
+				break;
+			case "crane_print_dvars":
+				crane_print_dvars();
+				break;
+			default:
+			}
+			if ( getDvar( "devgui_notify" ) != "" )
+			{
+				setdvar( "devgui_notify", "" );
+			}
+#/
+		}
+	}
+}
+
+crane_print_dvars()
+{
+/#
+	dvars = [];
+	dvars[ dvars.size ] = "scr_crane_claw_move_time";
+	dvars[ dvars.size ] = "scr_crane_crate_lower_time";
+	dvars[ dvars.size ] = "scr_crane_crate_raise_time";
+	dvars[ dvars.size ] = "scr_crane_arm_y_move_time";
+	dvars[ dvars.size ] = "scr_crane_arm_z_move_time";
+	dvars[ dvars.size ] = "scr_crane_claw_drop_speed";
+	dvars[ dvars.size ] = "scr_crane_claw_drop_time_min";
+	_a211 = dvars;
+	_k211 = getFirstArrayKey( _a211 );
+	while ( isDefined( _k211 ) )
+	{
+		dvar = _a211[ _k211 ];
+		print( dvar + ": " );
+		println( getDvar( dvar ) );
+		_k211 = getNextArrayKey( _a211, _k211 );
+#/
+	}
+}

patch_mp/maps/mp/mp_dockside_crane.gsc

@@ -0,0 +1,779 @@
+#include maps/mp/killstreaks/_supplydrop;
+#include maps/mp/gametypes/_gameobjects;
+#include maps/mp/gametypes/ctf;
+#include maps/mp/gametypes/_weaponobjects;
+#include maps/mp/killstreaks/_rcbomb;
+#include maps/mp/_tacticalinsertion;
+#include common_scripts/utility;
+#include maps/mp/_utility;
+
+init()
+{
+	precachemodel( "p6_dockside_container_lrg_white" );
+	crane_dvar_init();
+	level.crate_models = [];
+	level.crate_models[ 0 ] = "p6_dockside_container_lrg_red";
+	level.crate_models[ 1 ] = "p6_dockside_container_lrg_blue";
+	level.crate_models[ 2 ] = "p6_dockside_container_lrg_white";
+	level.crate_models[ 3 ] = "p6_dockside_container_lrg_orange";
+	claw = getent( "claw_base", "targetname" );
+	claw.z_upper = claw.origin[ 2 ];
+	claw thread sound_wires_move();
+	arms_y = getentarray( "claw_arm_y", "targetname" );
+	arms_z = getentarray( "claw_arm_z", "targetname" );
+	claw.arms = arraycombine( arms_y, arms_z, 1, 0 );
+	_a32 = arms_z;
+	_k32 = getFirstArrayKey( _a32 );
+	while ( isDefined( _k32 ) )
+	{
+		arm_z = _a32[ _k32 ];
+		arm_y = getclosest( arm_z.origin, arms_y );
+		arm_z.parent = arm_y;
+		_k32 = getNextArrayKey( _a32, _k32 );
+	}
+	_a39 = arms_y;
+	_k39 = getFirstArrayKey( _a39 );
+	while ( isDefined( _k39 ) )
+	{
+		arm_y = _a39[ _k39 ];
+		arm_y.parent = claw;
+		_k39 = getNextArrayKey( _a39, _k39 );
+	}
+	claw claw_link_arms( "claw_arm_y" );
+	claw claw_link_arms( "claw_arm_z" );
+	crates = getentarray( "crate", "targetname" );
+	array_thread( crates, ::sound_pit_move );
+	crate_data = [];
+	i = 0;
+	while ( i < crates.size )
+	{
+		crates[ i ] disconnectpaths();
+		data = spawnstruct();
+		data.origin = crates[ i ].origin;
+		data.angles = crates[ i ].angles;
+		crate_data[ i ] = data;
+		i++;
+	}
+	rail = getent( "crane_rail", "targetname" );
+	rail thread sound_ring_move();
+	rail.roller = getent( "crane_roller", "targetname" );
+	rail.roller.wheel = getent( "crane_wheel", "targetname" );
+	claw.wires = getentarray( "crane_wire", "targetname" );
+	claw.z_wire_max = rail.roller.wheel.origin[ 2 ] - 50;
+	_a73 = claw.wires;
+	_k73 = getFirstArrayKey( _a73 );
+	while ( isDefined( _k73 ) )
+	{
+		wire = _a73[ _k73 ];
+		wire linkto( claw );
+		if ( wire.origin[ 2 ] > claw.z_wire_max )
+		{
+			wire ghost();
+		}
+		_k73 = getNextArrayKey( _a73, _k73 );
+	}
+	placements = getentarray( "crate_placement", "targetname" );
+	_a85 = placements;
+	_k85 = getFirstArrayKey( _a85 );
+	while ( isDefined( _k85 ) )
+	{
+		placement = _a85[ _k85 ];
+		placement.angles += vectorScale( ( 0, 0, 1 ), 90 );
+		crates[ crates.size ] = spawn( "script_model", placement.origin );
+		_k85 = getNextArrayKey( _a85, _k85 );
+	}
+	triggers = getentarray( "crate_kill_trigger", "targetname" );
+	_a93 = crates;
+	_k93 = getFirstArrayKey( _a93 );
+	while ( isDefined( _k93 ) )
+	{
+		crate = _a93[ _k93 ];
+		crate.kill_trigger = getclosest( crate.origin, triggers );
+		crate.kill_trigger.origin = crate.origin - vectorScale( ( 0, 0, 1 ), 5 );
+		crate.kill_trigger enablelinkto();
+		crate.kill_trigger linkto( crate );
+		if ( crate.model != "" )
+		{
+			crate.kill_trigger.active = 1;
+		}
+		else
+		{
+			crate.kill_trigger.active = 0;
+		}
+		_k93 = getNextArrayKey( _a93, _k93 );
+	}
+	trigger = getclosest( claw.origin, triggers );
+	trigger enablelinkto();
+	trigger linkto( claw );
+	trigger.active = 1;
+	placements = array_randomize( placements );
+	level thread crane_think( claw, rail, crates, crate_data, placements );
+}
+
+crane_dvar_init()
+{
+	set_dvar_float_if_unset( "scr_crane_claw_move_time", "5" );
+	set_dvar_float_if_unset( "scr_crane_crate_lower_time", "5" );
+	set_dvar_float_if_unset( "scr_crane_crate_raise_time", "5" );
+	set_dvar_float_if_unset( "scr_crane_arm_y_move_time", "3" );
+	set_dvar_float_if_unset( "scr_crane_arm_z_move_time", "3" );
+	set_dvar_float_if_unset( "scr_crane_claw_drop_speed", "25" );
+	set_dvar_float_if_unset( "scr_crane_claw_drop_time_min", "5" );
+}
+
+wire_render()
+{
+	self endon( "movedone" );
+	for ( ;; )
+	{
+		wait 0,05;
+		_a139 = self.wires;
+		_k139 = getFirstArrayKey( _a139 );
+		while ( isDefined( _k139 ) )
+		{
+			wire = _a139[ _k139 ];
+			if ( wire.origin[ 2 ] > self.z_wire_max )
+			{
+				wire ghost();
+			}
+			else
+			{
+				wire show();
+			}
+			_k139 = getNextArrayKey( _a139, _k139 );
+		}
+	}
+}
+
+crane_think( claw, rail, crates, crate_data, placements )
+{
+	wait 1;
+	claw arms_open();
+	for ( ;; )
+	{
+		i = 0;
+		while ( i < ( crates.size - placements.size ) )
+		{
+			crate = getclosest( crate_data[ i ].origin, crates );
+			rail crane_move( claw, crate_data[ i ], -318 );
+			level notify( "wires_move" );
+			claw claw_crate_grab( crate, 318 );
+			lower = 1;
+			target = ( i + 1 ) % ( crates.size - placements.size );
+			target_crate = getclosest( crate_data[ target ].origin, crates );
+			while ( cointoss() )
+			{
+				placement_index = 0;
+				while ( placement_index < placements.size )
+				{
+					placement = placements[ placement_index ];
+					if ( !isDefined( placement.crate ) )
+					{
+						lower = 0;
+						break;
+					}
+					else
+					{
+						placement_index++;
+					}
+				}
+			}
+			if ( !lower )
+			{
+				z_dist = crate.origin[ 2 ] - placement.origin[ 2 ] - 33;
+				rail crane_move( claw, placement, z_dist * -1 );
+				level notify( "wires_move" );
+				placement.crate = crate;
+			}
+			else
+			{
+				rail crane_move( claw, crate_data[ target ], -181 );
+				level notify( "wires_move" );
+			}
+			claw claw_crate_move( crate );
+			if ( lower )
+			{
+				crate crate_lower( target_crate, crate_data[ target ] );
+			}
+			crate = target_crate;
+			target = ( i + 2 ) % ( crates.size - placements.size );
+			target_crate = getclosest( crate_data[ target ].origin, crates );
+			if ( !lower )
+			{
+				crate = crates[ 3 + placement_index ];
+				crate.origin = target_crate.origin - vectorScale( ( 0, 0, 1 ), 137 );
+				crate.angles = target_crate.angles;
+				wait 0,25;
+				claw waittill( "movedone" );
+			}
+			crate crate_raise( target_crate, crate_data[ target ] );
+			rail crane_move( claw, crate_data[ target ], -181 );
+			level notify( "wires_move" );
+			claw claw_crate_grab( target_crate, 181 );
+			crate = target_crate;
+			target = ( i + 3 ) % ( crates.size - placements.size );
+			rail crane_move( claw, crate_data[ target ], -318 );
+			level notify( "wires_move" );
+			claw claw_crate_drop( crate, crate_data[ target ] );
+			i++;
+		}
+	}
+}
+
+crane_move( claw, desired, z_dist )
+{
+	self.roller linkto( self );
+	self.roller.wheel linkto( self.roller );
+	claw linkto( self.roller.wheel );
+	goal = ( desired.origin[ 0 ], desired.origin[ 1 ], self.origin[ 2 ] );
+	dir = vectornormalize( goal - self.origin );
+	angles = vectorToAngle( dir );
+	angles = ( self.angles[ 0 ], angles[ 1 ] + 90, self.angles[ 2 ] );
+	yawdiff = absangleclamp360( self.angles[ 1 ] - angles[ 1 ] );
+	time = yawdiff / 25;
+	self rotateto( angles, time, time * 0,35, time * 0,45 );
+	self thread physics_move();
+	level notify( "wires_stop" );
+	level notify( "ring_move" );
+	self waittill( "rotatedone" );
+	self.roller unlink();
+	goal = ( desired.origin[ 0 ], desired.origin[ 1 ], self.roller.origin[ 2 ] );
+	diff = distance2d( goal, self.roller.origin );
+	speed = getDvarFloat( #"C39D2ABF" );
+	time = diff / speed;
+	if ( time < getDvarFloat( #"F60036C0" ) )
+	{
+		time = getDvarFloat( #"F60036C0" );
+	}
+	self.roller moveto( goal, time, time * 0,25, time * 0,25 );
+	self.roller thread physics_move();
+	goal = ( desired.origin[ 0 ], desired.origin[ 1 ], self.roller.wheel.origin[ 2 ] );
+	self.roller.wheel unlink();
+	self.roller.wheel moveto( goal, time, time * 0,25, time * 0,25 );
+	self.roller.wheel rotateto( desired.angles + vectorScale( ( 0, 0, 1 ), 90 ), time, time * 0,25, time * 0,25 );
+	claw.z_initial = claw.origin[ 2 ];
+	claw unlink();
+	claw rotateto( desired.angles, time, time * 0,25, time * 0,25 );
+	claw.goal = ( goal[ 0 ], goal[ 1 ], claw.origin[ 2 ] + z_dist );
+	claw.time = time;
+	claw moveto( claw.goal, time, time * 0,25, time * 0,25 );
+	level notify( "ring_stop" );
+}
+
+physics_move()
+{
+	self endon( "rotatedone" );
+	self endon( "movedone" );
+	for ( ;; )
+	{
+		wait 0,05;
+		crates = getentarray( "care_package", "script_noteworthy" );
+		_a318 = crates;
+		_k318 = getFirstArrayKey( _a318 );
+		while ( isDefined( _k318 ) )
+		{
+			crate = _a318[ _k318 ];
+			if ( crate istouching( self ) )
+			{
+				crate physicslaunch( crate.origin, ( 0, 0, 1 ) );
+			}
+			_k318 = getNextArrayKey( _a318, _k318 );
+		}
+	}
+}
+
+claw_crate_grab( crate, z_dist )
+{
+	self thread wire_render();
+	self waittill( "movedone" );
+	level notify( "wires_stop" );
+	self playsound( "amb_crane_arms_b" );
+	self claw_z_arms( -33 );
+	self playsound( "amb_crane_arms" );
+	self arms_close( crate );
+	crate movez( 33, getDvarFloat( #"92CC26F1" ) );
+	self claw_z_arms( 33 );
+	crate linkto( self );
+	self movez( z_dist, getDvarFloat( #"33ED9F5F" ) );
+	self thread wire_render();
+	level notify( "wires_move" );
+	self waittill( "movedone" );
+	self playsound( "amb_crane_arms" );
+}
+
+sound_wires_move()
+{
+	while ( 1 )
+	{
+		level waittill( "wires_move" );
+		self playsound( "amb_crane_wire_start" );
+		self playloopsound( "amb_crane_wire_lp" );
+		level waittill( "wires_stop" );
+		self playsound( "amb_crane_wire_end" );
+		wait 0,1;
+		self stoploopsound( 0,2 );
+	}
+}
+
+sound_ring_move()
+{
+	while ( 1 )
+	{
+		level waittill( "ring_move" );
+		self playsound( "amb_crane_ring_start" );
+		self playloopsound( "amb_crane_ring_lp" );
+		level waittill( "ring_stop" );
+		self playsound( "amb_crane_ring_end" );
+		wait 0,1;
+		self stoploopsound( 0,2 );
+	}
+}
+
+sound_pit_move()
+{
+	while ( 1 )
+	{
+		level waittill( "pit_move" );
+		self playsound( "amb_crane_pit_start" );
+		self playloopsound( "amb_crane_pit_lp" );
+		level waittill( "pit_stop" );
+		self playsound( "amb_crane_pit_end" );
+		self stoploopsound( 0,2 );
+		wait 0,2;
+	}
+}
+
+claw_crate_move( crate, claw )
+{
+	self thread wire_render();
+	self waittill( "movedone" );
+	crate unlink();
+	self playsound( "amb_crane_arms_b" );
+	level notify( "wires_stop" );
+	crate movez( -33, getDvarFloat( #"92CC26F1" ) );
+	self claw_z_arms( -33 );
+	self playsound( "amb_crane_arms_b" );
+	playfxontag( level._effect[ "crane_dust" ], crate, "tag_origin" );
+	crate playsound( "amb_crate_drop" );
+	self arms_open();
+	level notify( "wires_move" );
+	self claw_z_arms( 33 );
+	z_dist = self.z_initial - self.origin[ 2 ];
+	self movez( z_dist, getDvarFloat( #"33ED9F5F" ) );
+	self thread wire_render();
+}
+
+claw_crate_drop( target, data )
+{
+	target thread crate_drop_think( self );
+	self thread wire_render();
+	self waittill( "claw_movedone" );
+	target unlink();
+	level notify( "wires_stop" );
+	self playsound( "amb_crane_arms_b" );
+	target movez( -33, getDvarFloat( #"92CC26F1" ) );
+	self claw_z_arms( -33 );
+	playfxontag( level._effect[ "crane_dust" ], target, "tag_origin" );
+	self playsound( "amb_crate_drop" );
+	target notify( "claw_done" );
+	self playsound( "amb_crane_arms" );
+	self arms_open();
+	level notify( "wires_move" );
+	target.origin = data.origin;
+	self claw_z_arms( 33 );
+	self playsound( "amb_crane_arms" );
+	self movez( 318, getDvarFloat( #"33ED9F5F" ) );
+	self thread wire_render();
+	self waittill( "movedone" );
+}
+
+crate_lower( lower, data )
+{
+	z_dist = abs( self.origin[ 2 ] - lower.origin[ 2 ] );
+	self movez( z_dist * -1, getDvarFloat( #"CFA0F999" ) );
+	lower movez( z_dist * -1, getDvarFloat( #"CFA0F999" ) );
+	level notify( "pit_move" );
+	lower waittill( "movedone" );
+	level notify( "pit_stop" );
+	lower ghost();
+	self.origin = data.origin;
+	wait 0,25;
+}
+
+crate_raise( upper, data )
+{
+	self crate_set_random_model( upper );
+	self.kill_trigger.active = 1;
+	self.origin = ( data.origin[ 0 ], data.origin[ 1 ], self.origin[ 2 ] );
+	self.angles = data.angles;
+	wait 0,2;
+	self show();
+	z_dist = abs( upper.origin[ 2 ] - self.origin[ 2 ] );
+	self movez( z_dist, getDvarFloat( #"B4D4D064" ) );
+	upper movez( z_dist, getDvarFloat( #"B4D4D064" ) );
+	level notify( "wires_stop" );
+	level notify( "pit_move" );
+	upper thread raise_think();
+}
+
+raise_think()
+{
+	self waittill( "movedone" );
+	level notify( "pit_stop" );
+}
+
+crate_set_random_model( other )
+{
+	models = array_randomize( level.crate_models );
+	_a513 = models;
+	_k513 = getFirstArrayKey( _a513 );
+	while ( isDefined( _k513 ) )
+	{
+		model = _a513[ _k513 ];
+		if ( model == other.model )
+		{
+		}
+		else
+		{
+			self setmodel( model );
+			return;
+		}
+		_k513 = getNextArrayKey( _a513, _k513 );
+	}
+}
+
+arms_open()
+{
+	self claw_move_arms( -15 );
+	self playsound( "amb_crane_arms" );
+}
+
+arms_close( crate )
+{
+	self claw_move_arms( 15, crate );
+	self playsound( "amb_crane_arms" );
+}
+
+claw_link_arms( name )
+{
+	_a541 = self.arms;
+	_k541 = getFirstArrayKey( _a541 );
+	while ( isDefined( _k541 ) )
+	{
+		arm = _a541[ _k541 ];
+		if ( arm.targetname == name )
+		{
+			arm linkto( arm.parent );
+		}
+		_k541 = getNextArrayKey( _a541, _k541 );
+	}
+}
+
+claw_unlink_arms( name )
+{
+	_a552 = self.arms;
+	_k552 = getFirstArrayKey( _a552 );
+	while ( isDefined( _k552 ) )
+	{
+		arm = _a552[ _k552 ];
+		if ( arm.targetname == name )
+		{
+			arm unlink();
+		}
+		_k552 = getNextArrayKey( _a552, _k552 );
+	}
+}
+
+claw_move_arms( dist, crate )
+{
+	claw_unlink_arms( "claw_arm_y" );
+	arms = [];
+	_a566 = self.arms;
+	_k566 = getFirstArrayKey( _a566 );
+	while ( isDefined( _k566 ) )
+	{
+		arm = _a566[ _k566 ];
+		forward = anglesToForward( arm.angles );
+		arm.goal = arm.origin + vectorScale( forward, dist );
+		if ( arm.targetname == "claw_arm_y" )
+		{
+			arms[ arms.size ] = arm;
+			arm moveto( arm.goal, getDvarFloat( #"0D6F71B0" ) );
+		}
+		_k566 = getNextArrayKey( _a566, _k566 );
+	}
+	if ( dist > 0 )
+	{
+		wait ( getDvarFloat( #"0D6F71B0" ) / 2 );
+		_a582 = self.arms;
+		_k582 = getFirstArrayKey( _a582 );
+		while ( isDefined( _k582 ) )
+		{
+			arm = _a582[ _k582 ];
+			if ( arm.targetname == "claw_arm_y" )
+			{
+				arm moveto( arm.goal, 0,1 );
+				self playsound( "amb_crane_arms_b" );
+			}
+			_k582 = getNextArrayKey( _a582, _k582 );
+		}
+		wait 0,05;
+		playfxontag( level._effect[ "crane_spark" ], crate, "tag_origin" );
+		self playsound( "amb_arms_latch" );
+	}
+/#
+	assert( arms.size == 4 );
+#/
+	waittill_multiple_ents( arms[ 0 ], "movedone", arms[ 1 ], "movedone", arms[ 2 ], "movedone", arms[ 3 ], "movedone" );
+	_a600 = self.arms;
+	_k600 = getFirstArrayKey( _a600 );
+	while ( isDefined( _k600 ) )
+	{
+		arm = _a600[ _k600 ];
+		arm.origin = arm.goal;
+		_k600 = getNextArrayKey( _a600, _k600 );
+	}
+	self claw_link_arms( "claw_arm_y" );
+}
+
+claw_z_arms( z )
+{
+	claw_unlink_arms( "claw_arm_z" );
+	arms = [];
+	_a613 = self.arms;
+	_k613 = getFirstArrayKey( _a613 );
+	while ( isDefined( _k613 ) )
+	{
+		arm = _a613[ _k613 ];
+		if ( arm.targetname == "claw_arm_z" )
+		{
+			arms[ arms.size ] = arm;
+			arm movez( z, getDvarFloat( #"92CC26F1" ) );
+		}
+		_k613 = getNextArrayKey( _a613, _k613 );
+	}
+/#
+	assert( arms.size == 4 );
+#/
+	waittill_multiple_ents( arms[ 0 ], "movedone", arms[ 1 ], "movedone", arms[ 2 ], "movedone", arms[ 3 ], "movedone" );
+	self claw_link_arms( "claw_arm_z" );
+}
+
+crate_drop_think( claw )
+{
+	self endon( "claw_done" );
+	self.disablefinalkillcam = 1;
+	claw thread claw_drop_think();
+	corpse_delay = 0;
+	for ( ;; )
+	{
+		wait 0,2;
+		entities = getdamageableentarray( self.origin, 200 );
+		_a642 = entities;
+		_k642 = getFirstArrayKey( _a642 );
+		while ( isDefined( _k642 ) )
+		{
+			entity = _a642[ _k642 ];
+			if ( !entity istouching( self.kill_trigger ) )
+			{
+			}
+			else if ( isDefined( entity.model ) && entity.model == "t6_wpn_tac_insert_world" )
+			{
+				entity maps/mp/_tacticalinsertion::destroy_tactical_insertion();
+			}
+			else
+			{
+				if ( !isalive( entity ) )
+				{
+					break;
+				}
+				else if ( isDefined( entity.targetname ) )
+				{
+					if ( entity.targetname == "talon" )
+					{
+						entity notify( "death" );
+						break;
+					}
+					else if ( entity.targetname == "rcbomb" )
+					{
+						entity maps/mp/killstreaks/_rcbomb::rcbomb_force_explode();
+						break;
+					}
+					else if ( entity.targetname == "riotshield_mp" )
+					{
+						entity dodamage( 1, self.origin + ( 0, 0, 1 ), self, self, 0, "MOD_CRUSH" );
+						break;
+					}
+				}
+				else if ( isDefined( entity.helitype ) && entity.helitype == "qrdrone" )
+				{
+					watcher = entity.owner maps/mp/gametypes/_weaponobjects::getweaponobjectwatcher( "qrdrone" );
+					watcher thread maps/mp/gametypes/_weaponobjects::waitanddetonate( entity, 0, undefined );
+					break;
+				}
+				else
+				{
+					if ( entity.classname == "grenade" )
+					{
+						if ( !isDefined( entity.name ) )
+						{
+							break;
+						}
+						else if ( !isDefined( entity.owner ) )
+						{
+							break;
+						}
+						else if ( entity.name == "proximity_grenade_mp" )
+						{
+							watcher = entity.owner getwatcherforweapon( entity.name );
+							watcher thread maps/mp/gametypes/_weaponobjects::waitanddetonate( entity, 0, undefined, "script_mover_mp" );
+							break;
+						}
+						else if ( !isweaponequipment( entity.name ) )
+						{
+							break;
+						}
+						else watcher = entity.owner getwatcherforweapon( entity.name );
+						if ( !isDefined( watcher ) )
+						{
+							break;
+						}
+						else watcher thread maps/mp/gametypes/_weaponobjects::waitanddetonate( entity, 0, undefined, "script_mover_mp" );
+						break;
+					}
+					else if ( entity.classname == "auto_turret" )
+					{
+						if ( !isDefined( entity.damagedtodeath ) || !entity.damagedtodeath )
+						{
+							entity domaxdamage( self.origin + ( 0, 0, 1 ), self, self, 0, "MOD_CRUSH" );
+						}
+						break;
+					}
+					else
+					{
+						entity dodamage( entity.health * 2, self.origin + ( 0, 0, 1 ), self, self, 0, "MOD_CRUSH" );
+						if ( isplayer( entity ) )
+						{
+							claw thread claw_drop_pause();
+							corpse_delay = getTime() + 3000;
+						}
+					}
+				}
+			}
+			_k642 = getNextArrayKey( _a642, _k642 );
+		}
+		self destroy_supply_crates();
+		if ( getTime() > corpse_delay )
+		{
+			self destroy_corpses();
+		}
+		if ( level.gametype == "ctf" )
+		{
+			_a748 = level.flags;
+			_k748 = getFirstArrayKey( _a748 );
+			while ( isDefined( _k748 ) )
+			{
+				flag = _a748[ _k748 ];
+				if ( flag.visuals[ 0 ] istouching( self.kill_trigger ) )
+				{
+					flag maps/mp/gametypes/ctf::returnflag();
+				}
+				_k748 = getNextArrayKey( _a748, _k748 );
+			}
+		}
+		else if ( level.gametype == "sd" && !level.multibomb )
+		{
+			if ( level.sdbomb.visuals[ 0 ] istouching( self.kill_trigger ) )
+			{
+				level.sdbomb maps/mp/gametypes/_gameobjects::returnhome();
+			}
+		}
+	}
+}
+
+claw_drop_think()
+{
+	self endon( "claw_pause" );
+	self waittill( "movedone" );
+	self notify( "claw_movedone" );
+}
+
+claw_drop_pause()
+{
+	self notify( "claw_pause" );
+	self endon( "claw_pause" );
+	z_diff = abs( self.goal[ 2 ] - self.origin[ 2 ] );
+	frac = z_diff / 318;
+	time = self.time * frac;
+	if ( time <= 0 )
+	{
+		return;
+	}
+	self moveto( self.origin, 0,01 );
+	wait 3;
+	self thread claw_drop_think();
+	self moveto( self.goal, time );
+}
+
+destroy_supply_crates()
+{
+	crates = getentarray( "care_package", "script_noteworthy" );
+	_a802 = crates;
+	_k802 = getFirstArrayKey( _a802 );
+	while ( isDefined( _k802 ) )
+	{
+		crate = _a802[ _k802 ];
+		if ( distancesquared( crate.origin, self.origin ) < 40000 )
+		{
+			if ( crate istouching( self ) )
+			{
+				playfx( level._supply_drop_explosion_fx, crate.origin );
+				playsoundatposition( "wpn_grenade_explode", crate.origin );
+				wait 0,1;
+				crate maps/mp/killstreaks/_supplydrop::cratedelete();
+			}
+		}
+		_k802 = getNextArrayKey( _a802, _k802 );
+	}
+}
+
+destroy_corpses()
+{
+	corpses = getcorpsearray();
+	i = 0;
+	while ( i < corpses.size )
+	{
+		if ( distancesquared( corpses[ i ].origin, self.origin ) < 40000 )
+		{
+			corpses[ i ] delete();
+		}
+		i++;
+	}
+}
+
+getwatcherforweapon( weapname )
+{
+	if ( !isDefined( self ) )
+	{
+		return undefined;
+	}
+	if ( !isplayer( self ) )
+	{
+		return undefined;
+	}
+	i = 0;
+	while ( i < self.weaponobjectwatcherarray.size )
+	{
+		if ( self.weaponobjectwatcherarray[ i ].weapon != weapname )
+		{
+			i++;
+			continue;
+		}
+		else
+		{
+			return self.weaponobjectwatcherarray[ i ];
+		}
+		i++;
+	}
+	return undefined;
+}

patch_mp/maps/mp/mp_downhill.gsc

@@ -0,0 +1,52 @@
+#include maps/mp/gametypes/_spawning;
+#include maps/mp/_compass;
+#include maps/mp/_utility;
+
+main()
+{
+	level.levelspawndvars = ::levelspawndvars;
+	maps/mp/mp_downhill_fx::main();
+	precachemodel( "collision_physics_64x64x64" );
+	precachemodel( "collision_clip_32x32x32" );
+	precachemodel( "collision_clip_64x64x64" );
+	precachemodel( "collision_physics_cylinder_32x128" );
+	precachemodel( "collision_missile_32x32x128" );
+	precachemodel( "collision_clip_64x64x64" );
+	maps/mp/_load::main();
+	maps/mp/mp_downhill_amb::main();
+	maps/mp/_compass::setupminimap( "compass_map_mp_downhill" );
+	setdvar( "compassmaxrange", "2100" );
+	game[ "strings" ][ "war_callsign_a" ] = &"MPUI_CALLSIGN_MAPNAME_A";
+	game[ "strings" ][ "war_callsign_b" ] = &"MPUI_CALLSIGN_MAPNAME_B";
+	game[ "strings" ][ "war_callsign_c" ] = &"MPUI_CALLSIGN_MAPNAME_C";
+	game[ "strings" ][ "war_callsign_d" ] = &"MPUI_CALLSIGN_MAPNAME_D";
+	game[ "strings" ][ "war_callsign_e" ] = &"MPUI_CALLSIGN_MAPNAME_E";
+	game[ "strings_menu" ][ "war_callsign_a" ] = "@MPUI_CALLSIGN_MAPNAME_A";
+	game[ "strings_menu" ][ "war_callsign_b" ] = "@MPUI_CALLSIGN_MAPNAME_B";
+	game[ "strings_menu" ][ "war_callsign_c" ] = "@MPUI_CALLSIGN_MAPNAME_C";
+	game[ "strings_menu" ][ "war_callsign_d" ] = "@MPUI_CALLSIGN_MAPNAME_D";
+	game[ "strings_menu" ][ "war_callsign_e" ] = "@MPUI_CALLSIGN_MAPNAME_E";
+	spawncollision( "collision_physics_64x64x64", "collider", ( 969,01, -2355,43, 1014,87 ), ( 2,23119, 12,5057, -9,9556 ) );
+	spawncollision( "collision_physics_64x64x64", "collider", ( 954,068, -2352,16, 1001,08 ), ( 3,17067, 17,931, -9,69974 ) );
+	spawncollision( "collision_physics_64x64x64", "collider", ( 942,933, -2359,71, 1031,9 ), ( 3,17067, 17,931, -9,69974 ) );
+	spawncollision( "collision_physics_cylinder_32x128", "collider", ( 368, -1378, 1015 ), vectorScale( ( 0, 0, 0 ), 24,9 ) );
+	spawncollision( "collision_clip_64x64x64", "collider", ( 1268,5, -2518, 1062 ), vectorScale( ( 0, 0, 0 ), 349 ) );
+	spawncollision( "collision_clip_64x64x64", "collider", ( 1122,5, 583,5, 959,5 ), vectorScale( ( 0, 0, 0 ), 41,2 ) );
+	spawncollision( "collision_clip_32x32x32", "collider", ( 1895, -1428,5, 948 ), ( 0, 0, 0 ) );
+	spawncollision( "collision_missile_32x32x128", "collider", ( 2431,5, -174, 1209,5 ), ( 0, 318,4, 90 ) );
+	spawncollision( "collision_clip_64x64x64", "collider", ( 318, 1509, 1105 ), ( 0, 34,4, 90 ) );
+	precachemodel( "fxanim_mp_downhill_cable_car_mod" );
+	maps/mp/gametypes/_spawning::level_use_unified_spawning( 1 );
+	level.cablecarlightsfx = loadfx( "maps/mp_maps/fx_mp_downhill_cablecar_lights" );
+	level thread maps/mp/mp_downhill_cablecar::main();
+	level.remotemotarviewleft = 40;
+	level.remotemotarviewright = 40;
+	level.remotemotarviewup = 15;
+	level.remotemotarviewdown = 65;
+}
+
+levelspawndvars( reset_dvars )
+{
+	ss = level.spawnsystem;
+	ss.enemy_influencer_radius = set_dvar_float_if_unset( "scr_spawn_enemy_influencer_radius", "2600", reset_dvars );
+}

patch_mp/maps/mp/mp_downhill_cablecar.gsc

@@ -0,0 +1,795 @@
+#include maps/mp/killstreaks/_supplydrop;
+#include maps/mp/gametypes/_gameobjects;
+#include maps/mp/gametypes/ctf;
+#include maps/mp/gametypes/_weaponobjects;
+#include maps/mp/killstreaks/_rcbomb;
+#include maps/mp/_tacticalinsertion;
+#include maps/mp/gametypes/_hostmigration;
+#include maps/mp/_events;
+#include maps/mp/killstreaks/_airsupport;
+#include common_scripts/utility;
+#include maps/mp/_utility;
+
+main()
+{
+	level.cablecartrack = [];
+	level.trackdistancestops = [];
+	level.distancetofirstrotate = 0;
+	precacheitem( "gondola_mp" );
+	level.gondolasounds = [];
+	level.gondolasounds[ "tower_start" ] = "veh_cable_car_roller_cross";
+	level.gondolasounds[ "rollers_start" ] = "veh_cable_car_start";
+	level.gondolasounds[ "slow_down" ] = "veh_cable_car_stop";
+	level.gondolaloopsounds = [];
+	level.gondolaloopsounds[ "start" ] = "veh_cable_car_move_loop";
+	level.gondolaloopsounds[ "rollers_start" ] = "veh_cable_car_move_loop";
+	level.gondolaloopsounds[ "rollers_end" ] = "";
+	tracklength = createcablecarpath();
+/#
+	assert( level.trackdistancestops.size == 2 );
+#/
+	if ( level.trackdistancestops.size == 2 )
+	{
+		velocity = getdvarfloatdefault( "scr_cable_car_velocity", 100 );
+		bottomoftracklength = level.trackdistancestops[ 1 ] - level.trackdistancestops[ 0 ];
+		topoftracklength = tracklength - bottomoftracklength;
+/#
+		assert( topoftracklength < bottomoftracklength );
+#/
+		extratrackrequired = bottomoftracklength - topoftracklength;
+		extratimerequired = extratrackrequired / velocity;
+		level.cablecartrack[ level.cablecartrack.size - 1 ].movetime = extratimerequired;
+		level.cablecartrack[ level.cablecartrack.size - 1 ].rotate = 1;
+		tracklength = bottomoftracklength * 2;
+	}
+	else
+	{
+		return;
+	}
+	cablecars = getentarray( "cablecar", "targetname" );
+	cablecarkilltrigger = getentarray( "cable_car_kill_trigger", "targetname" );
+/#
+	assert( isDefined( cablecars ) );
+#/
+/#
+	assert( isDefined( cablecarkilltrigger ) );
+#/
+	level.cablecardefaultangle = cablecars[ 0 ].angles;
+	distancebetweencars = tracklength / cablecars.size;
+	if ( getgametypesetting( "allowMapScripting" ) )
+	{
+		currentdistanceforcar = 0;
+	}
+	else
+	{
+		currentdistanceforcar = distancebetweencars * 0,8;
+	}
+	i = 0;
+	while ( i < cablecars.size )
+	{
+		cablecar = cablecars[ i ];
+		cablecar thread waitthenplayfx( 0,1, level.cablecarlightsfx, "tag_origin" );
+		cablecar.killtrigger = getclosest( cablecar.origin, cablecarkilltrigger );
+/#
+		assert( isDefined( cablecar.killtrigger ) );
+#/
+		cablecar.killtrigger enablelinkto();
+		cablecar.killtrigger linkto( cablecar );
+		cablecar setpointontrack( currentdistanceforcar, tracklength );
+		currentdistanceforcar += distancebetweencars;
+/#
+		debug_star( cablecar.origin, 120000, ( 0, 0, 1 ) );
+#/
+		grip = spawn( "script_model", cablecar.origin );
+		if ( cablecar.nextnodeindex >= ( level.cablecartrack.size - 1 ) )
+		{
+			grip.angles = vectorToAngle( level.cablecartrack[ cablecar.nextnodeindex - 1 ].origin - level.cablecartrack[ cablecar.nextnodeindex ].origin );
+		}
+		else
+		{
+			if ( is_true( level.cablecartrack[ cablecar.nextnodeindex ].pause ) )
+			{
+				carnode = level.cablecartrack[ cablecar.nextnodeindex + 2 ];
+			}
+			else
+			{
+				carnode = level.cablecartrack[ cablecar.nextnodeindex ];
+			}
+			grip.angles = vectorToAngle( carnode.origin - cablecar.origin );
+		}
+		grip.origin -= ( 0, cos( grip.angles[ 1 ] ) * -12, 8 );
+		grip setmodel( "dh_cable_car_top_piece" );
+		cablecar.grip = grip;
+		if ( getgametypesetting( "allowMapScripting" ) )
+		{
+			level thread cablecarrun( cablecar );
+			i++;
+			continue;
+		}
+		else
+		{
+			cablecar.origin += ( 0, cos( cablecar.angles[ 1 ] ) * -15, -66,6 );
+			cablecar disconnectpaths();
+		}
+		i++;
+	}
+}
+
+waitthenplayfx( time, fxnum, tag )
+{
+	self endon( "death" );
+	wait time;
+	for ( ;; )
+	{
+		playfxontag( fxnum, self, tag );
+		level waittill( "host_migration_end" );
+	}
+}
+
+setpointontrack( distancealongtrack, tracklength )
+{
+	pointontrack = level.cablecartrack[ 0 ].origin;
+	while ( distancealongtrack > tracklength )
+	{
+		distancealongtrack = tracklength * -1;
+	}
+	remainingdistance = distancealongtrack;
+	i = 0;
+	while ( i < level.cablecartrack.size )
+	{
+		cablecartracknode = level.cablecartrack[ i ];
+		currentnodeisstop = is_true( cablecartracknode.pause );
+		if ( currentnodeisstop )
+		{
+			velocity = getdvarfloatdefault( "scr_cable_car_velocity", 100 );
+			remainingdistance -= 3 * velocity;
+			if ( remainingdistance <= 0 )
+			{
+				pointontrack = cablecartracknode.origin;
+				self.nextnodeindex = i;
+				self.needtopauseatstart = remainingdistance / velocity;
+				break;
+			}
+		}
+		else nextnodeisstop = 0;
+		if ( level.cablecartrack.size > ( i + 1 ) )
+		{
+			nextnodeisstop = is_true( level.cablecartrack[ i + 1 ].pause );
+		}
+		currentnodeisstop = 0;
+		if ( is_true( cablecartracknode.pause ) )
+		{
+			currentnodeisstop = 1;
+		}
+		distance = cablecartracknode.stepdistance;
+		if ( nextnodeisstop || currentnodeisstop )
+		{
+			distance *= 2;
+		}
+		if ( !isDefined( distance ) )
+		{
+			pointontrack = cablecartracknode.origin;
+			self.nextnodeindex = i;
+			break;
+		}
+		else if ( remainingdistance < distance )
+		{
+			if ( distance > 0 )
+			{
+				ratio = remainingdistance / distance;
+				pointontrack = getpointonline( cablecartracknode.origin, level.cablecartrack[ i + 1 ].origin, ratio );
+			}
+			self.nextnodeindex = i;
+			break;
+		}
+		else
+		{
+			remainingdistance -= distance;
+			i++;
+		}
+	}
+	self.angles = level.cablecardefaultangle;
+	if ( distancealongtrack < level.distancetofirstrotate )
+	{
+		self.angles += vectorScale( ( 0, 0, 1 ), 180 );
+	}
+	self.origin = pointontrack;
+}
+
+createcablecarpath( cablecar )
+{
+	currentnode = getent( "cable_down_start", "targetname" );
+	startorigin = currentnode.origin;
+	velocity = getdvarfloatdefault( "scr_cable_car_velocity", 100 );
+	tracklength = 0;
+	previousnode = undefined;
+	movetime = -1;
+	while ( isDefined( currentnode ) )
+	{
+		cablecarnodestruct = spawnstruct();
+		cablecarnodestruct.origin = currentnode.origin;
+		level.cablecartrack[ level.cablecartrack.size ] = cablecarnodestruct;
+		if ( isDefined( currentnode.target ) )
+		{
+			nextnode = getent( currentnode.target, "targetname" );
+		}
+		if ( !isDefined( nextnode ) )
+		{
+			break;
+		}
+		else
+		{
+			stepdistance = distance( currentnode.origin, nextnode.origin );
+			cablecarnodestruct.stepdistance = stepdistance;
+			movetime = stepdistance / velocity;
+/#
+			assert( movetime > 0 );
+#/
+			pauseratio = 1;
+			if ( isDefined( nextnode.script_noteworthy ) && nextnode.script_noteworthy == "stop" )
+			{
+				pauseratio *= 2;
+			}
+			if ( isDefined( currentnode.script_noteworthy ) )
+			{
+				if ( currentnode.script_noteworthy == "stop" )
+				{
+					cablecarnodestruct.pause = 1;
+					tracklength += velocity * 3;
+					level.trackdistancestops[ level.trackdistancestops.size ] = tracklength;
+					pauseratio *= 2;
+					break;
+				}
+				else if ( currentnode.script_noteworthy == "rotate" )
+				{
+					cablecarnodestruct.rotate = 1;
+					break;
+				}
+				else if ( currentnode.script_noteworthy == "forceorigin" )
+				{
+					cablecarnodestruct.forceorigin = 1;
+					break;
+				}
+				else
+				{
+					if ( isDefined( level.gondolasounds[ currentnode.script_noteworthy ] ) )
+					{
+						cablecarnodestruct.playsound = level.gondolasounds[ currentnode.script_noteworthy ];
+					}
+					if ( isDefined( level.gondolaloopsounds[ currentnode.script_noteworthy ] ) )
+					{
+						cablecarnodestruct.playloopsound = level.gondolaloopsounds[ currentnode.script_noteworthy ];
+					}
+				}
+			}
+			tracklength += stepdistance * pauseratio;
+			if ( is_true( cablecarnodestruct.rotate ) )
+			{
+				level.distancetofirstrotate = tracklength;
+			}
+			cablecarnodestruct.movetime = movetime;
+			previousnode = currentnode;
+			currentnode = nextnode;
+			nextnode = undefined;
+		}
+	}
+	return tracklength;
+}
+
+watchpronetouch()
+{
+	for ( ;; )
+	{
+		self waittill( "touch", entity );
+		if ( isplayer( entity ) )
+		{
+			if ( entity.origin[ 2 ] < 940 )
+			{
+				if ( entity getstance() == "prone" )
+				{
+					entity dodamage( entity.health * 2, self.origin + ( 0, 0, 1 ), self, self, 0, "MOD_HIT_BY_OBJECT", 0, "gondola_mp" );
+				}
+			}
+		}
+	}
+}
+
+cablecarrun( cablecar )
+{
+	nextnodeindex = cablecar.nextnodeindex;
+	cablecar thread watchpronetouch();
+	cablecar thread cablecar_move_think( cablecar.killtrigger, 1 );
+	cablecar thread cablecar_ai_watch();
+	cablecar.ismoving = 1;
+	grip = cablecar.grip;
+	firstmove = 1;
+	cablecar.hidden = 0;
+	grip.forceangles = 0;
+	if ( isDefined( cablecar.needtopauseatstart ) )
+	{
+		if ( cablecar.needtopauseatstart > 0 )
+		{
+			wait cablecar.needtopauseatstart;
+		}
+	}
+	for ( ;; )
+	{
+		i = nextnodeindex;
+		while ( i < level.cablecartrack.size )
+		{
+			nextnode = level.cablecartrack[ i + 1 ];
+			if ( !isDefined( nextnode ) )
+			{
+				nextnode = level.cablecartrack[ 0 ];
+			}
+			currentnode = level.cablecartrack[ i ];
+			acceltime = 0;
+			deceltime = 0;
+			currentmovetime = currentnode.movetime;
+			if ( isDefined( nextnode.pause ) || isDefined( currentnode ) && isDefined( currentnode.pause ) )
+			{
+				currentmovetime *= 2;
+				if ( isDefined( nextnode.pause ) )
+				{
+					deceltime = currentmovetime - 0,1;
+				}
+				if ( isDefined( currentnode ) && isDefined( currentnode.pause ) )
+				{
+					acceltime = currentmovetime - 0,1;
+				}
+			}
+/#
+			debug_star( nextnode.origin, ( 0, 0, 1 ), 1000 );
+#/
+			if ( isDefined( currentnode ) )
+			{
+				if ( isDefined( currentnode.playsound ) )
+				{
+					cablecar playsound( currentnode.playsound );
+				}
+				if ( isDefined( currentnode.playloopsound ) )
+				{
+					cablecar stoploopsound();
+					cablecar playsound( "veh_cable_car_leave" );
+					if ( currentnode.playloopsound != "" )
+					{
+						cablecar playloopsound( currentnode.playloopsound );
+					}
+				}
+			}
+			if ( isDefined( currentnode.rotate ) )
+			{
+				cablecar hide();
+				grip hide();
+				cablecar.hidden = 1;
+				cablecar.origin += vectorScale( ( 0, 0, 1 ), 1000 );
+				if ( cablecar.angles[ 1 ] > 360 )
+				{
+					cablecar.angles -= vectorScale( ( 0, 0, 1 ), 180 );
+					break;
+				}
+				else
+				{
+					cablecar.angles += vectorScale( ( 0, 0, 1 ), 180 );
+				}
+			}
+			if ( isDefined( currentnode ) && isDefined( nextnode ) )
+			{
+				angles = vectorToAngle( currentnode.origin - nextnode.origin );
+				grip.nextangles = angles;
+				if ( grip.forceangles == 1 )
+				{
+					grip.forceangles = 0;
+					grip.angles = grip.nextangles;
+					break;
+				}
+				else
+				{
+					grip rotateto( grip.nextangles, 0,9 );
+				}
+			}
+			if ( firstmove == 1 )
+			{
+				firstmovedistance = distance( cablecar.origin, nextnode.origin );
+				velocity = getdvarfloatdefault( "scr_cable_car_velocity", 100 );
+				timetomove = firstmovedistance / velocity;
+				if ( timetomove > 0 )
+				{
+					cablecar moveto( nextnode.origin + ( 0, cos( cablecar.angles[ 1 ] ) * -15, -66,6 ), timetomove );
+					grip moveto( nextnode.origin - ( 0, cos( cablecar.angles[ 1 ] ) * -12, 8 ), timetomove );
+					wait timetomove;
+				}
+			}
+			else
+			{
+				heightoffset = -66,6;
+				if ( is_true( cablecar.hidden ) )
+				{
+					heightoffset += -1000;
+				}
+				if ( deceltime > 0 )
+				{
+					cablecar thread prettyslowdown( currentmovetime - deceltime );
+				}
+				grip thread hostmigrationawaremoveto( nextnode.origin - ( 0, cos( cablecar.angles[ 1 ] ) * -12, 8 ), currentmovetime, acceltime, deceltime, currentmovetime - 0,05 );
+				cablecar hostmigrationawaremoveto( nextnode.origin + ( 0, cos( cablecar.angles[ 1 ] ) * -15, heightoffset ), currentmovetime, acceltime, deceltime, currentmovetime - 0,05 );
+			}
+			if ( cablecar.hidden == 1 )
+			{
+				cablecar.hidden = 0;
+				if ( is_true( cablecar.hidden ) )
+				{
+					cablecar.origin -= vectorScale( ( 0, 0, 1 ), 1000 );
+				}
+				cablecar show();
+				grip show();
+				grip.forceangles = 1;
+			}
+			firstmove = 0;
+			if ( isDefined( nextnode.pause ) )
+			{
+				cablecar.ismoving = 0;
+				grip thread hostmigrationawaremoveto( nextnode.origin - ( 0, cos( cablecar.angles[ 1 ] ) * -12, 8 ), 300, 0, 0, 3 );
+				cablecar hostmigrationawaremoveto( nextnode.origin + ( 0, cos( cablecar.angles[ 1 ] ) * -15, -66,6 ), 300, 0, 0, 3 );
+				cablecar notify( "started_moving" );
+				cablecar thread prettyspeedup();
+				cablecar.ismoving = 1;
+			}
+			if ( isDefined( nextnode.forceorigin ) )
+			{
+				cablecar.origin = nextnode.origin + ( 0, cos( cablecar.angles[ 1 ] ) * -15, -66,6 );
+				grip.origin = nextnode.origin - ( 0, cos( cablecar.angles[ 1 ] ) * -12, 8 );
+			}
+			i++;
+		}
+		nextnodeindex = 0;
+	}
+}
+
+hostmigrationawaremoveto( origin, movetime, acceltime, deceltime, waittime )
+{
+	starttime = getTime();
+	self moveto( origin, movetime, acceltime, deceltime );
+	waitcompleted = self waitendonmigration( waittime );
+	if ( !isDefined( waitcompleted ) )
+	{
+		endtime = getTime();
+		maps/mp/gametypes/_hostmigration::waittillhostmigrationdone();
+		mstimedifference = ( starttime + ( waittime * 1000 ) ) - endtime;
+		if ( mstimedifference > 500 )
+		{
+			wait ( mstimedifference / 1000 );
+		}
+	}
+}
+
+waitendonmigration( time )
+{
+	level endon( "host_migration_begin" );
+	wait time;
+	return 1;
+}
+
+prettyslowdown( waittime )
+{
+	if ( waittime > 0 )
+	{
+		wait waittime;
+	}
+	self stoploopsound();
+	self playsound( level.gondolasounds[ "slow_down" ] );
+	originalangle = self.angles;
+	swingtime = getdvarfloatdefault( "scr_cable_swing_time", 1,5 );
+	swingbacktime = getdvarfloatdefault( "scr_cable_swing_back_time", 1,5 );
+	swingangle = getdvarfloatdefault( "scr_cable_swing_angle", 2 );
+	self rotateto( ( originalangle[ 0 ] + swingangle, originalangle[ 1 ], originalangle[ 2 ] ), swingtime, swingtime / 2, swingtime / 2 );
+	self waittill( "rotatedone" );
+	self rotateto( ( originalangle[ 0 ], originalangle[ 1 ], originalangle[ 2 ] ), swingbacktime, swingbacktime / 2, swingbacktime / 2 );
+	self waittill( "rotatedone" );
+}
+
+prettyspeedup()
+{
+	self stoploopsound();
+	self playsound( level.gondolasounds[ "rollers_start" ] );
+	self playloopsound( level.gondolaloopsounds[ "start" ] );
+	originalangle = self.angles;
+	swingtime = getdvarfloatdefault( "scr_cable_swing_time_up", 1 );
+	swingbacktime = getdvarfloatdefault( "scr_cable_swing_back_time_up", 1,5 );
+	swingangle = getdvarfloatdefault( "scr_cable_swing_angle_up", 2 );
+	self rotateto( ( originalangle[ 0 ] - swingangle, originalangle[ 1 ], originalangle[ 2 ] ), swingtime, swingtime / 2, swingtime / 2 );
+	self waittill( "rotatedone" );
+	self rotateto( ( originalangle[ 0 ], originalangle[ 1 ], originalangle[ 2 ] ), swingbacktime, swingbacktime / 2, swingbacktime / 2 );
+	self waittill( "rotatedone" );
+}
+
+cablecar_ai_watch()
+{
+	self endon( "death" );
+	self endon( "delete" );
+	for ( ;; )
+	{
+		wait 1;
+		while ( isDefined( self.nodes ) )
+		{
+			i = 0;
+			while ( i < self.nodes.size )
+			{
+				node = self.nodes[ i ];
+				_a574 = level.teams;
+				_k574 = getFirstArrayKey( _a574 );
+				while ( isDefined( _k574 ) )
+				{
+					team = _a574[ _k574 ];
+					node setdangerous( team, 0 );
+					_k574 = getNextArrayKey( _a574, _k574 );
+				}
+				i++;
+			}
+		}
+		dir = vectornormalize( anglesToForward( self.angles ) );
+		dangerorigin = self.origin - ( dir * 196 );
+		nodes = getnodesinradius( dangerorigin, 256, 0, 196 );
+		i = 0;
+		while ( i < nodes.size )
+		{
+			node = nodes[ i ];
+			_a587 = level.teams;
+			_k587 = getFirstArrayKey( _a587 );
+			while ( isDefined( _k587 ) )
+			{
+				team = _a587[ _k587 ];
+				node setdangerous( team, 1 );
+				_k587 = getNextArrayKey( _a587, _k587 );
+			}
+			i++;
+		}
+		if ( nodes.size > 0 )
+		{
+			self.nodes = nodes;
+			continue;
+		}
+		else
+		{
+			self.nodes = undefined;
+		}
+	}
+}
+
+cablecar_move_think( kill_trigger, checkmoving )
+{
+	self endon( "death" );
+	self endon( "delete" );
+	self.disablefinalkillcam = 1;
+	destroycorpses = 0;
+	for ( ;; )
+	{
+		wait 0,05;
+		pixbeginevent( "cablecar_move_think" );
+		if ( checkmoving )
+		{
+			if ( self.ismoving == 0 )
+			{
+				self waittill( "started_moving" );
+			}
+		}
+		entities = getdamageableentarray( self.origin, 200 );
+		_a626 = entities;
+		_k626 = getFirstArrayKey( _a626 );
+		while ( isDefined( _k626 ) )
+		{
+			entity = _a626[ _k626 ];
+			if ( isDefined( entity.targetname ) && entity.targetname == "cablecar" )
+			{
+			}
+			else
+			{
+				if ( !entity istouching( kill_trigger ) )
+				{
+					break;
+				}
+				else if ( isDefined( entity.model ) && entity.model == "t6_wpn_tac_insert_world" )
+				{
+					entity maps/mp/_tacticalinsertion::destroy_tactical_insertion();
+					break;
+				}
+				else
+				{
+					if ( !isalive( entity ) )
+					{
+						break;
+					}
+					else if ( isDefined( entity.targetname ) )
+					{
+						if ( entity.targetname == "talon" )
+						{
+							entity notify( "death" );
+							break;
+						}
+						else if ( entity.targetname == "rcbomb" )
+						{
+							entity maps/mp/killstreaks/_rcbomb::rcbomb_force_explode();
+							break;
+						}
+						else if ( entity.targetname == "riotshield_mp" )
+						{
+							entity dodamage( 1, self.origin + ( 0, 0, 1 ), self, self, 0, "MOD_CRUSH" );
+							break;
+						}
+					}
+					else if ( isDefined( entity.helitype ) && entity.helitype == "qrdrone" )
+					{
+						watcher = entity.owner maps/mp/gametypes/_weaponobjects::getweaponobjectwatcher( "qrdrone" );
+						watcher thread maps/mp/gametypes/_weaponobjects::waitanddetonate( entity, 0, undefined );
+						break;
+					}
+					else
+					{
+						if ( entity.classname == "grenade" )
+						{
+							if ( !isDefined( entity.name ) )
+							{
+								break;
+							}
+							else if ( !isDefined( entity.owner ) )
+							{
+								break;
+							}
+							else if ( entity.name == "satchel_charge_mp" )
+							{
+								break;
+							}
+							else if ( entity.name == "proximity_grenade_mp" )
+							{
+								watcher = entity.owner getwatcherforweapon( entity.name );
+								watcher thread maps/mp/gametypes/_weaponobjects::waitanddetonate( entity, 0, undefined, "script_mover_mp" );
+								break;
+							}
+							else if ( !isweaponequipment( entity.name ) )
+							{
+								break;
+							}
+							else watcher = entity.owner getwatcherforweapon( entity.name );
+							if ( !isDefined( watcher ) )
+							{
+								break;
+							}
+							else watcher thread maps/mp/gametypes/_weaponobjects::waitanddetonate( entity, 0, undefined, "script_mover_mp" );
+							break;
+						}
+						else if ( entity.classname == "remote_drone" )
+						{
+							break;
+						}
+						else if ( entity.classname == "auto_turret" )
+						{
+							if ( isDefined( entity.carried ) && entity.carried == 1 )
+							{
+								break;
+							}
+							else
+							{
+								if ( !isDefined( entity.damagedtodeath ) || !entity.damagedtodeath )
+								{
+									entity domaxdamage( self.origin + ( 0, 0, 1 ), self, self, 0, "MOD_CRUSH" );
+								}
+								break;
+							}
+							else
+							{
+								if ( isplayer( entity ) )
+								{
+									if ( entity getstance() == "prone" )
+									{
+										if ( entity isonground() == 0 )
+										{
+											destroycorpses = 1;
+										}
+									}
+									entity dodamage( entity.health * 2, self.origin + ( 0, 0, 1 ), self, self, 0, "MOD_HIT_BY_OBJECT", 0, "gondola_mp" );
+									break;
+								}
+								else
+								{
+									entity dodamage( entity.health * 2, self.origin + ( 0, 0, 1 ), self, self, 0, "MOD_CRUSH" );
+								}
+							}
+						}
+					}
+				}
+			}
+			_k626 = getNextArrayKey( _a626, _k626 );
+		}
+		if ( destroycorpses == 1 )
+		{
+			destroycorpses = 0;
+			self destroy_corpses();
+		}
+		self destroy_supply_crates();
+		if ( level.gametype == "ctf" )
+		{
+			_a759 = level.flags;
+			_k759 = getFirstArrayKey( _a759 );
+			while ( isDefined( _k759 ) )
+			{
+				flag = _a759[ _k759 ];
+				if ( flag.curorigin != flag.trigger.baseorigin && flag.visuals[ 0 ] istouching( kill_trigger ) )
+				{
+					flag maps/mp/gametypes/ctf::returnflag();
+				}
+				_k759 = getNextArrayKey( _a759, _k759 );
+			}
+		}
+		else if ( level.gametype == "sd" && !level.multibomb )
+		{
+			if ( level.sdbomb.visuals[ 0 ] istouching( kill_trigger ) )
+			{
+				level.sdbomb maps/mp/gametypes/_gameobjects::returnhome();
+			}
+		}
+		pixendevent();
+	}
+}
+
+getwatcherforweapon( weapname )
+{
+	if ( !isDefined( self ) )
+	{
+		return undefined;
+	}
+	if ( !isplayer( self ) )
+	{
+		return undefined;
+	}
+	i = 0;
+	while ( i < self.weaponobjectwatcherarray.size )
+	{
+		if ( self.weaponobjectwatcherarray[ i ].weapon != weapname )
+		{
+			i++;
+			continue;
+		}
+		else
+		{
+			return self.weaponobjectwatcherarray[ i ];
+		}
+		i++;
+	}
+	return undefined;
+}
+
+destroy_supply_crates()
+{
+	crates = getentarray( "care_package", "script_noteworthy" );
+	_a811 = crates;
+	_k811 = getFirstArrayKey( _a811 );
+	while ( isDefined( _k811 ) )
+	{
+		crate = _a811[ _k811 ];
+		if ( distancesquared( crate.origin, self.origin ) < 40000 )
+		{
+			if ( crate istouching( self ) )
+			{
+				playfx( level._supply_drop_explosion_fx, crate.origin );
+				playsoundatposition( "wpn_grenade_explode", crate.origin );
+				wait 0,1;
+				crate maps/mp/killstreaks/_supplydrop::cratedelete();
+			}
+		}
+		_k811 = getNextArrayKey( _a811, _k811 );
+	}
+}
+
+destroy_corpses()
+{
+	corpses = getcorpsearray();
+	i = 0;
+	while ( i < corpses.size )
+	{
+		if ( distancesquared( corpses[ i ].origin, self.origin ) < 40000 )
+		{
+			corpses[ i ] delete();
+		}
+		i++;
+	}
+}

patch_mp/maps/mp/mp_drone.gsc

@@ -0,0 +1,105 @@
+#include maps/mp/mp_drone_doors;
+#include maps/mp/_compass;
+#include maps/mp/_utility;
+
+main()
+{
+	precachemodel( "fxanim_gp_robot_arm_welder_server_side_mod" );
+	level.levelspawndvars = ::levelspawndvars;
+	welders = [];
+	welders[ welders.size ] = ( -1339,51, 76,04, 136,11 );
+	welders[ welders.size ] = ( -1339,51, -171,9, 136,11 );
+	welders[ welders.size ] = ( -1339,51, 559,04, 136,12 );
+	welders[ welders.size ] = ( -1339,51, 312,01, 136,12 );
+	maps/mp/mp_drone_fx::main();
+	precachemodel( "collision_physics_wall_512x512x10" );
+	precachemodel( "collision_physics_wall_256x256x10" );
+	precachemodel( "collision_physics_256x256x10" );
+	precachemodel( "collision_clip_32x32x10" );
+	precachemodel( "collision_clip_128x128x10" );
+	precachemodel( "collision_physics_128x128x128" );
+	precachemodel( "collision_physics_32x32x128" );
+	maps/mp/_compass::setupminimap( "compass_map_mp_drone" );
+	maps/mp/_load::main();
+	maps/mp/mp_drone_amb::main();
+	game[ "strings" ][ "war_callsign_a" ] = &"MPUI_CALLSIGN_MAPNAME_A";
+	game[ "strings" ][ "war_callsign_b" ] = &"MPUI_CALLSIGN_MAPNAME_B";
+	game[ "strings" ][ "war_callsign_c" ] = &"MPUI_CALLSIGN_MAPNAME_C";
+	game[ "strings" ][ "war_callsign_d" ] = &"MPUI_CALLSIGN_MAPNAME_D";
+	game[ "strings" ][ "war_callsign_e" ] = &"MPUI_CALLSIGN_MAPNAME_E";
+	game[ "strings_menu" ][ "war_callsign_a" ] = "@MPUI_CALLSIGN_MAPNAME_A";
+	game[ "strings_menu" ][ "war_callsign_b" ] = "@MPUI_CALLSIGN_MAPNAME_B";
+	game[ "strings_menu" ][ "war_callsign_c" ] = "@MPUI_CALLSIGN_MAPNAME_C";
+	game[ "strings_menu" ][ "war_callsign_d" ] = "@MPUI_CALLSIGN_MAPNAME_D";
+	game[ "strings_menu" ][ "war_callsign_e" ] = "@MPUI_CALLSIGN_MAPNAME_E";
+	spawncollision( "collision_physics_wall_512x512x10", "collider", ( -3252, -2085, -44 ), ( 0, 0, 0 ) );
+	spawncollision( "collision_physics_wall_512x512x10", "collider", ( -3763, -2085, -44 ), ( 0, 0, 0 ) );
+	spawncollision( "collision_physics_wall_256x256x10", "collider", ( -4146, -2085, 88 ), ( 0, 0, 0 ) );
+	spawncollision( "collision_physics_wall_512x512x10", "collider", ( -2054, -2098, -56 ), ( 0, 0, 0 ) );
+	spawncollision( "collision_clip_32x32x10", "collider", ( -1351, -1076, 202 ), ( 5,82444, 91,4567, 105,986 ) );
+	spawncollision( "collision_clip_128x128x10", "collider", ( 33,5, -1386,25, 211,5 ), vectorScale( ( 0, 0, 0 ), 90 ) );
+	spawncollision( "collision_physics_wall_256x256x10", "collider", ( -923,5, 2180, 366,5 ), vectorScale( ( 0, 0, 0 ), 270 ) );
+	spawncollision( "collision_physics_wall_256x256x10", "collider", ( -1050,5, 2303, 366,5 ), vectorScale( ( 0, 0, 0 ), 180 ) );
+	spawncollision( "collision_physics_wall_256x256x10", "collider", ( -1306,5, 2303, 366,5 ), vectorScale( ( 0, 0, 0 ), 180 ) );
+	spawncollision( "collision_physics_256x256x10", "collider", ( -1046,5, 2180, 489,5 ), ( 0, 0, 0 ) );
+	spawncollision( "collision_physics_256x256x10", "collider", ( -1302,5, 2180, 489,5 ), ( 0, 0, 0 ) );
+	spawncollision( "collision_physics_128x128x128", "collider", ( -1024, 2288, 352 ), ( 0, 0, 0 ) );
+	spawncollision( "collision_physics_32x32x128", "collider", ( -1197,5, 2589, 429,5 ), ( 0, 0, 0 ) );
+	spawncollision( "collision_physics_32x32x128", "collider", ( -1197,5, 2589, 565 ), ( 0, 0, 0 ) );
+	spawncollision( "collision_physics_32x32x128", "collider", ( -1217,5, 2602, 429,5 ), ( 0, 0, 0 ) );
+	spawncollision( "collision_physics_32x32x128", "collider", ( -1217,5, 2602, 565 ), ( 0, 0, 0 ) );
+	spawncollision( "collision_physics_128x128x128", "collider", ( 335, 3507,5, 453 ), ( 0, 0, 0 ) );
+	spawncollision( "collision_physics_128x128x128", "collider", ( 496,5, 3280, 478,5 ), ( 0, 0, 0 ) );
+	spawncollision( "collision_physics_128x128x128", "collider", ( 440, 3272, 432 ), ( 0, 0, 0 ) );
+	spawncollision( "collision_physics_128x128x128", "collider", ( 1109, 347,5, 305,5 ), ( 0, 0, 0 ) );
+	spawncollision( "collision_physics_wall_512x512x10", "collider", ( -1505, 1898, 754,5 ), ( 360, 180, 90,0003 ) );
+	spawncollision( "collision_physics_wall_512x512x10", "collider", ( -1505, 2406, 754,5 ), ( 360, 180, 90,0003 ) );
+	spawncollision( "collision_physics_wall_512x512x10", "collider", ( -1253,5, 1898, 503,5 ), ( 1, 270, 5,96 ) );
+	spawncollision( "collision_physics_wall_512x512x10", "collider", ( -1253,5, 2406, 503,5 ), ( 1, 270, 5,96 ) );
+	spawncollision( "collision_physics_wall_512x512x10", "collider", ( -1264,64, 2921,02, 754,5 ), ( 1, 133,4, 90 ) );
+	spawncollision( "collision_physics_wall_512x512x10", "collider", ( -1091,83, 2738,29, 503,5 ), ( 1, 223,4, 5,96 ) );
+	spawncollision( "collision_physics_wall_512x512x10", "collider", ( -1091,83, 3083,21, 503 ), ( 360, 136,6, -180 ) );
+	spawncollision( "collision_physics_wall_512x512x10", "collider", ( -1504,82, 1671,75, 503 ), ( 1, 174,2, -180 ) );
+	if ( getgametypesetting( "allowMapScripting" ) )
+	{
+		level maps/mp/mp_drone_doors::init();
+	}
+	level.remotemotarviewleft = 35;
+	level.remotemotarviewright = 35;
+	level.remotemotarviewup = 18;
+	setheliheightpatchenabled( "war_mode_heli_height_lock", 0 );
+	geo_changes();
+	_a109 = welders;
+	_k109 = getFirstArrayKey( _a109 );
+	while ( isDefined( _k109 ) )
+	{
+		welder = _a109[ _k109 ];
+		collision = spawn( "script_model", welder );
+		collision setmodel( "fxanim_gp_robot_arm_welder_server_side_mod" );
+		_k109 = getNextArrayKey( _a109, _k109 );
+	}
+}
+
+levelspawndvars( reset_dvars )
+{
+	ss = level.spawnsystem;
+	ss.enemy_influencer_radius = set_dvar_float_if_unset( "scr_spawn_enemy_influencer_radius", "2600", reset_dvars );
+}
+
+geo_changes()
+{
+	rts_floor = getent( "overwatch_floor", "targetname" );
+	if ( isDefined( rts_floor ) )
+	{
+		rts_floor delete();
+	}
+	removes = getentarray( "rts_only", "targetname" );
+	_a132 = removes;
+	_k132 = getFirstArrayKey( _a132 );
+	while ( isDefined( _k132 ) )
+	{
+		removal = _a132[ _k132 ];
+		removal delete();
+		_k132 = getNextArrayKey( _a132, _k132 );
+	}
+}

patch_mp/maps/mp/mp_express.gsc

@@ -0,0 +1,70 @@
+#include maps/mp/mp_express_train;
+#include maps/mp/_compass;
+#include common_scripts/utility;
+#include maps/mp/_utility;
+
+main()
+{
+	level.levelspawndvars = ::levelspawndvars;
+	maps/mp/mp_express_fx::main();
+	precachemodel( "collision_physics_cylinder_32x128" );
+	maps/mp/_load::main();
+	maps/mp/_compass::setupminimap( "compass_map_mp_express" );
+	maps/mp/mp_express_amb::main();
+	game[ "strings" ][ "war_callsign_a" ] = &"MPUI_CALLSIGN_MAPNAME_A";
+	game[ "strings" ][ "war_callsign_b" ] = &"MPUI_CALLSIGN_MAPNAME_B";
+	game[ "strings" ][ "war_callsign_c" ] = &"MPUI_CALLSIGN_MAPNAME_C";
+	game[ "strings" ][ "war_callsign_d" ] = &"MPUI_CALLSIGN_MAPNAME_D";
+	game[ "strings" ][ "war_callsign_e" ] = &"MPUI_CALLSIGN_MAPNAME_E";
+	game[ "strings_menu" ][ "war_callsign_a" ] = "@MPUI_CALLSIGN_MAPNAME_A";
+	game[ "strings_menu" ][ "war_callsign_b" ] = "@MPUI_CALLSIGN_MAPNAME_B";
+	game[ "strings_menu" ][ "war_callsign_c" ] = "@MPUI_CALLSIGN_MAPNAME_C";
+	game[ "strings_menu" ][ "war_callsign_d" ] = "@MPUI_CALLSIGN_MAPNAME_D";
+	game[ "strings_menu" ][ "war_callsign_e" ] = "@MPUI_CALLSIGN_MAPNAME_E";
+	spawncollision( "collision_physics_cylinder_32x128", "collider", ( 200,735, 759,059, 136 ), ( 0, 248,6, 90 ) );
+	spawncollision( "collision_physics_cylinder_32x128", "collider", ( 229,73, 748,06, 151 ), ( 0, 248,6, 90 ) );
+	spawncollision( "collision_physics_cylinder_32x128", "collider", ( 379,816, 1141,39, 136 ), ( 0, 244,8, 90 ) );
+	spawncollision( "collision_physics_cylinder_32x128", "collider", ( 408,023, 1128,5, 151 ), ( 0, 244,8, 90 ) );
+	registerclientfield( "vehicle", "train_moving", 1, 1, "int" );
+	registerclientfield( "scriptmover", "train_moving", 1, 1, "int" );
+	if ( getgametypesetting( "allowMapScripting" ) )
+	{
+		level thread maps/mp/mp_express_train::init();
+	}
+/#
+	level thread devgui_express();
+	execdevgui( "devgui_mp_express" );
+#/
+}
+
+levelspawndvars( reset_dvars )
+{
+	ss = level.spawnsystem;
+	ss.enemy_influencer_radius = set_dvar_float_if_unset( "scr_spawn_enemy_influencer_radius", "1900", reset_dvars );
+}
+
+devgui_express()
+{
+/#
+	setdvar( "devgui_notify", "" );
+	for ( ;; )
+	{
+		wait 0,5;
+		devgui_string = getDvar( "devgui_notify" );
+		switch( devgui_string )
+		{
+			case "":
+				break;
+			case "train_start":
+				level notify( "train_start" );
+				break;
+			default:
+			}
+			if ( getDvar( "devgui_notify" ) != "" )
+			{
+				setdvar( "devgui_notify", "" );
+			}
+#/
+		}
+	}
+}

patch_mp/maps/mp/mp_express_train.gsc

@@ -0,0 +1,677 @@
+#include maps/mp/killstreaks/_supplydrop;
+#include maps/mp/gametypes/_gameobjects;
+#include maps/mp/gametypes/ctf;
+#include maps/mp/gametypes/_weaponobjects;
+#include maps/mp/killstreaks/_rcbomb;
+#include maps/mp/_tacticalinsertion;
+#include maps/mp/_events;
+#include common_scripts/utility;
+#include maps/mp/_utility;
+
+init()
+{
+	precachevehicle( "express_train_engine_mp" );
+	precachemodel( "p6_bullet_train_car_phys" );
+	precachemodel( "p6_bullet_train_engine_rev" );
+	precacheshader( "compass_train_carriage" );
+	precachestring( &"traincar" );
+	precachestring( &"trainengine" );
+	gates = getentarray( "train_gate_rail", "targetname" );
+	brushes = getentarray( "train_gate_rail_brush", "targetname" );
+	triggers = getentarray( "train_gate_kill_trigger", "targetname" );
+	traintriggers = getentarray( "train_kill_trigger", "targetname" );
+	_a22 = brushes;
+	_k22 = getFirstArrayKey( _a22 );
+	while ( isDefined( _k22 ) )
+	{
+		brush = _a22[ _k22 ];
+		brush disconnectpaths();
+		_k22 = getNextArrayKey( _a22, _k22 );
+	}
+	waittime = 0,05;
+	_a28 = gates;
+	_k28 = getFirstArrayKey( _a28 );
+	while ( isDefined( _k28 ) )
+	{
+		gate = _a28[ _k28 ];
+		gate.waittime = waittime;
+		waittime += 0,05;
+		gate.og_origin = gate.origin;
+		brush = getclosest( gate.origin, brushes );
+		brush linkto( gate );
+		gate.kill_trigger = getclosest( gate.origin, triggers );
+		if ( isDefined( gate.kill_trigger ) )
+		{
+			gate.kill_trigger enablelinkto();
+			gate.kill_trigger linkto( gate );
+		}
+		_k28 = getNextArrayKey( _a28, _k28 );
+	}
+	start = getvehiclenode( "train_start", "targetname" );
+	endgates = getentarray( "train_gate_rail_end", "targetname" );
+	entrygate = getclosest( start.origin, endgates );
+	i = 0;
+	while ( i < endgates.size )
+	{
+		if ( endgates[ i ] == entrygate )
+		{
+			i++;
+			continue;
+		}
+		else
+		{
+			exitgate = endgates[ i ];
+			break;
+		}
+		i++;
+	}
+	cars = [];
+	cars[ 0 ] = spawnvehicle( "p6_bullet_train_engine_phys", "train", "express_train_engine_mp", start.origin, ( 0, 0, 1 ) );
+	cars[ 0 ] ghost();
+	cars[ 0 ] setcheapflag( 1 );
+	cars[ 0 ].ismagicbullet = 1;
+	killcam = spawn( "script_model", cars[ 0 ].origin + vectorScale( ( 0, 0, 1 ), 25 ) );
+	killcam.angles = cars[ 0 ].angles + vectorScale( ( 0, 0, 1 ), 10 );
+	killcam linkto( cars[ 0 ] );
+	_a69 = traintriggers;
+	_k69 = getFirstArrayKey( _a69 );
+	while ( isDefined( _k69 ) )
+	{
+		traintrigger = _a69[ _k69 ];
+		cars[ 0 ].trainkilltrigger = traintrigger;
+		traintrigger.origin = start.origin;
+		traintrigger enablelinkto();
+		traintrigger linkto( cars[ 0 ] );
+		_k69 = getNextArrayKey( _a69, _k69 );
+	}
+	i = 1;
+	while ( i < 20 )
+	{
+		cars[ i ] = spawn( "script_model", start.origin );
+		cars[ i ] setmodel( "p6_bullet_train_car_phys" );
+		cars[ i ] ghost();
+		cars[ i ] setcheapflag( 1 );
+		i++;
+	}
+	cars[ 20 ] = spawn( "script_model", start.origin );
+	cars[ 20 ] setmodel( "p6_bullet_train_engine_rev" );
+	cars[ 20 ] ghost();
+	cars[ 20 ] setcheapflag( 1 );
+	waittillframeend;
+	if ( level.timelimit )
+	{
+		seconds = level.timelimit * 60;
+		add_timed_event( int( seconds * 0,25 ), "train_start" );
+		add_timed_event( int( seconds * 0,75 ), "train_start" );
+	}
+	else
+	{
+		if ( level.scorelimit )
+		{
+			add_score_event( int( level.scorelimit * 0,25 ), "train_start" );
+			add_score_event( int( level.scorelimit * 0,75 ), "train_start" );
+		}
+	}
+	level thread train_think( gates, entrygate, exitgate, cars, start, killcam );
+}
+
+showaftertime( time )
+{
+	wait time;
+	self show();
+}
+
+train_think( gates, entrygate, exitgate, cars, start, killcam )
+{
+	level endon( "game_ended" );
+	for ( ;; )
+	{
+		level waittill( "train_start" );
+		entrygate gate_move( -172 );
+		traintiming = getdvarfloatdefault( "scr_express_trainTiming", 4 );
+		exitgate thread waitthenmove( traintiming, -172 );
+		array_func( gates, ::gate_move, -172 );
+		_a127 = gates;
+		_k127 = getFirstArrayKey( _a127 );
+		while ( isDefined( _k127 ) )
+		{
+			gate = _a127[ _k127 ];
+			gate playloopsound( "amb_train_incomming_beep" );
+			gate playsound( "amb_gate_move" );
+			_k127 = getNextArrayKey( _a127, _k127 );
+		}
+		gatedownwait = getdvarintdefault( "scr_express_gateDownWait", 2 );
+		wait gatedownwait;
+		_a135 = gates;
+		_k135 = getFirstArrayKey( _a135 );
+		while ( isDefined( _k135 ) )
+		{
+			gate = _a135[ _k135 ];
+			gate stoploopsound( 2 );
+			_k135 = getNextArrayKey( _a135, _k135 );
+		}
+		wait 2;
+		cars[ 0 ] attachpath( start );
+		cars[ 0 ].killcament = undefined;
+		if ( isDefined( cars[ 0 ].trainkilltrigger ) )
+		{
+			cars[ 0 ] thread train_move_think( cars[ 0 ].trainkilltrigger );
+		}
+		cars[ 0 ] startpath();
+		cars[ 0 ] showaftertime( 0,2 );
+		cars[ 0 ] thread record_positions();
+		cars[ 0 ] thread watch_end();
+		cars[ 0 ] playloopsound( "amb_train_lp" );
+		cars[ 0 ] setclientfield( "train_moving", 1 );
+		cars[ 0 ] thread watch_player_touch();
+		killcam.starttime = getTime();
+		cars[ 0 ].killcament = killcam;
+		next = "_b";
+		i = 1;
+		while ( i < cars.size )
+		{
+			if ( i == 1 )
+			{
+				wait 0,4;
+			}
+			else
+			{
+				wait 0,35;
+			}
+			if ( i >= 3 && ( i % 3 ) == 0 )
+			{
+				cars[ i ] playloopsound( "amb_train_lp" + next );
+				switch( next )
+				{
+					case "_b":
+						next = "_c";
+						break;
+					break;
+					case "_c":
+						next = "_d";
+						break;
+					break;
+					case "_d":
+						next = "";
+						break;
+					break;
+					default:
+						next = "_b";
+						break;
+					break;
+				}
+			}
+			cars[ i ] thread watch_player_touch();
+			if ( i == ( cars.size - 1 ) )
+			{
+				cars[ i ] thread car_move();
+				i++;
+				continue;
+			}
+			else
+			{
+				cars[ i ] thread car_move();
+			}
+			i++;
+		}
+		traintiming = getdvarfloatdefault( "scr_express_trainTiming2", 2 );
+		entrygate thread waitthenmove( traintiming );
+		gateupwait = getdvarfloatdefault( "scr_express_gateUpWait", 6,5 );
+		wait gateupwait;
+		exitgate gate_move();
+		array_func( gates, ::gate_move );
+		_a217 = gates;
+		_k217 = getFirstArrayKey( _a217 );
+		while ( isDefined( _k217 ) )
+		{
+			gate = _a217[ _k217 ];
+			gate playsound( "amb_gate_move" );
+			_k217 = getNextArrayKey( _a217, _k217 );
+		}
+		wait 6;
+	}
+}
+
+waitthenmove( time, distance )
+{
+	wait time;
+	self gate_move( distance );
+}
+
+record_positions()
+{
+	self endon( "reached_end_node" );
+	if ( isDefined( level.train_positions ) )
+	{
+		return;
+	}
+	level.train_positions = [];
+	level.train_angles = [];
+	for ( ;; )
+	{
+		level.train_positions[ level.train_positions.size ] = self.origin;
+		level.train_angles[ level.train_angles.size ] = self.angles;
+		wait 0,05;
+	}
+}
+
+watch_player_touch()
+{
+	self endon( "end_of_track" );
+	self endon( "delete" );
+	self endon( "death" );
+	self.disablefinalkillcam = 1;
+	for ( ;; )
+	{
+		self waittill( "touch", entity );
+		if ( isplayer( entity ) )
+		{
+			entity dodamage( entity.health * 2, self.origin + ( 0, 0, 1 ), self, self, 0, "MOD_CRUSH" );
+		}
+	}
+}
+
+watch_end()
+{
+	self waittill( "reached_end_node" );
+	self ghost();
+	self setclientfield( "train_moving", 0 );
+	self stoploopsound( 0,2 );
+	self playsound( "amb_train_end" );
+}
+
+car_move()
+{
+	self setclientfield( "train_moving", 1 );
+	i = 0;
+	while ( i < level.train_positions.size )
+	{
+		self.origin = level.train_positions[ i ];
+		self.angles = level.train_angles[ i ];
+		wait 0,05;
+		if ( i == 4 )
+		{
+			self show();
+		}
+		i++;
+	}
+	self notify( "end_of_track" );
+	self ghost();
+	self setclientfield( "train_moving", 0 );
+	self stoploopsound( 0,2 );
+	self playsound( "amb_train_end" );
+}
+
+gate_rotate( yaw )
+{
+	self rotateyaw( yaw, 5 );
+}
+
+gate_move( z_dist )
+{
+	if ( isDefined( self.kill_trigger ) )
+	{
+		self thread gate_move_think( isDefined( z_dist ) );
+	}
+	if ( !isDefined( z_dist ) )
+	{
+		self moveto( self.og_origin, 5 );
+	}
+	else
+	{
+		self.og_origin = self.origin;
+		self movez( z_dist, 5 );
+	}
+}
+
+train_move_think( kill_trigger )
+{
+	self endon( "movedone" );
+	self endon( "reached_end_node" );
+	for ( ;; )
+	{
+		wait 0,05;
+		pixbeginevent( "train_move_think" );
+		entities = getdamageableentarray( self.origin, 200 );
+		_a341 = entities;
+		_k341 = getFirstArrayKey( _a341 );
+		while ( isDefined( _k341 ) )
+		{
+			entity = _a341[ _k341 ];
+			if ( isDefined( entity.targetname ) && entity.targetname == "train" )
+			{
+			}
+			else
+			{
+				if ( isplayer( entity ) )
+				{
+					break;
+				}
+				else if ( !entity istouching( kill_trigger ) )
+				{
+					break;
+				}
+				else if ( isDefined( entity.model ) && entity.model == "t6_wpn_tac_insert_world" )
+				{
+					entity maps/mp/_tacticalinsertion::destroy_tactical_insertion();
+					break;
+				}
+				else
+				{
+					if ( !isalive( entity ) )
+					{
+						break;
+					}
+					else if ( isDefined( entity.targetname ) )
+					{
+						if ( entity.targetname == "talon" )
+						{
+							entity notify( "death" );
+							break;
+						}
+						else if ( entity.targetname == "rcbomb" )
+						{
+							entity maps/mp/killstreaks/_rcbomb::rcbomb_force_explode();
+							break;
+						}
+						else if ( entity.targetname == "riotshield_mp" )
+						{
+							entity dodamage( 1, self.origin + ( 0, 0, 1 ), self, self, 0, "MOD_CRUSH" );
+							break;
+						}
+					}
+					else if ( isDefined( entity.helitype ) && entity.helitype == "qrdrone" )
+					{
+						watcher = entity.owner maps/mp/gametypes/_weaponobjects::getweaponobjectwatcher( "qrdrone" );
+						watcher thread maps/mp/gametypes/_weaponobjects::waitanddetonate( entity, 0, undefined );
+						break;
+					}
+					else
+					{
+						if ( entity.classname == "grenade" )
+						{
+							if ( !isDefined( entity.name ) )
+							{
+								break;
+							}
+							else if ( !isDefined( entity.owner ) )
+							{
+								break;
+							}
+							else if ( entity.name == "proximity_grenade_mp" )
+							{
+								watcher = entity.owner getwatcherforweapon( entity.name );
+								watcher thread maps/mp/gametypes/_weaponobjects::waitanddetonate( entity, 0, undefined, "script_mover_mp" );
+								break;
+							}
+							else if ( !isweaponequipment( entity.name ) )
+							{
+								break;
+							}
+							else watcher = entity.owner getwatcherforweapon( entity.name );
+							if ( !isDefined( watcher ) )
+							{
+								break;
+							}
+							else watcher thread maps/mp/gametypes/_weaponobjects::waitanddetonate( entity, 0, undefined, "script_mover_mp" );
+							break;
+						}
+						else if ( entity.classname == "auto_turret" )
+						{
+							if ( isDefined( entity.carried ) && entity.carried == 1 )
+							{
+								break;
+							}
+							else
+							{
+								if ( !isDefined( entity.damagedtodeath ) || !entity.damagedtodeath )
+								{
+									entity domaxdamage( self.origin + ( 0, 0, 1 ), self, self, 0, "MOD_CRUSH" );
+								}
+								break;
+							}
+							else
+							{
+								entity dodamage( entity.health * 2, self.origin + ( 0, 0, 1 ), self, self, 0, "MOD_CRUSH" );
+							}
+						}
+					}
+				}
+			}
+			_k341 = getNextArrayKey( _a341, _k341 );
+		}
+		self destroy_supply_crates();
+		if ( level.gametype == "ctf" )
+		{
+			_a452 = level.flags;
+			_k452 = getFirstArrayKey( _a452 );
+			while ( isDefined( _k452 ) )
+			{
+				flag = _a452[ _k452 ];
+				if ( flag.curorigin != flag.trigger.baseorigin && flag.visuals[ 0 ] istouching( kill_trigger ) )
+				{
+					flag maps/mp/gametypes/ctf::returnflag();
+				}
+				_k452 = getNextArrayKey( _a452, _k452 );
+			}
+		}
+		else if ( level.gametype == "sd" && !level.multibomb )
+		{
+			if ( level.sdbomb.visuals[ 0 ] istouching( kill_trigger ) )
+			{
+				level.sdbomb maps/mp/gametypes/_gameobjects::returnhome();
+			}
+		}
+		pixendevent();
+	}
+}
+
+gate_move_think( ignoreplayers )
+{
+	self endon( "movedone" );
+	self.disablefinalkillcam = 1;
+	corpse_delay = 0;
+	if ( isDefined( self.waittime ) )
+	{
+		wait self.waittime;
+	}
+	for ( ;; )
+	{
+		wait 0,4;
+		pixbeginevent( "gate_move_think" );
+		entities = getdamageableentarray( self.origin, 100 );
+		_a492 = entities;
+		_k492 = getFirstArrayKey( _a492 );
+		while ( isDefined( _k492 ) )
+		{
+			entity = _a492[ _k492 ];
+			if ( ignoreplayers == 1 && isplayer( entity ) )
+			{
+			}
+			else
+			{
+				if ( !entity istouching( self.kill_trigger ) )
+				{
+					break;
+				}
+				else if ( isDefined( entity.model ) && entity.model == "t6_wpn_tac_insert_world" )
+				{
+					entity maps/mp/_tacticalinsertion::destroy_tactical_insertion();
+					break;
+				}
+				else
+				{
+					if ( !isalive( entity ) )
+					{
+						break;
+					}
+					else if ( isDefined( entity.targetname ) )
+					{
+						if ( entity.targetname == "talon" )
+						{
+							entity notify( "death" );
+							break;
+						}
+						else if ( entity.targetname == "rcbomb" )
+						{
+							entity maps/mp/killstreaks/_rcbomb::rcbomb_force_explode();
+							break;
+						}
+						else if ( entity.targetname == "riotshield_mp" )
+						{
+							entity dodamage( 1, self.origin + ( 0, 0, 1 ), self, self, 0, "MOD_CRUSH" );
+							break;
+						}
+					}
+					else if ( isDefined( entity.helitype ) && entity.helitype == "qrdrone" )
+					{
+						watcher = entity.owner maps/mp/gametypes/_weaponobjects::getweaponobjectwatcher( "qrdrone" );
+						watcher thread maps/mp/gametypes/_weaponobjects::waitanddetonate( entity, 0, undefined );
+						break;
+					}
+					else
+					{
+						if ( entity.classname == "grenade" )
+						{
+							if ( !isDefined( entity.name ) )
+							{
+								break;
+							}
+							else if ( !isDefined( entity.owner ) )
+							{
+								break;
+							}
+							else if ( entity.name == "proximity_grenade_mp" )
+							{
+								watcher = entity.owner getwatcherforweapon( entity.name );
+								watcher thread maps/mp/gametypes/_weaponobjects::waitanddetonate( entity, 0, undefined, "script_mover_mp" );
+								break;
+							}
+							else if ( !isweaponequipment( entity.name ) )
+							{
+								break;
+							}
+							else watcher = entity.owner getwatcherforweapon( entity.name );
+							if ( !isDefined( watcher ) )
+							{
+								break;
+							}
+							else watcher thread maps/mp/gametypes/_weaponobjects::waitanddetonate( entity, 0, undefined, "script_mover_mp" );
+							break;
+						}
+						else if ( entity.classname == "auto_turret" )
+						{
+							if ( isDefined( entity.carried ) && entity.carried == 1 )
+							{
+								break;
+							}
+							else
+							{
+								if ( !isDefined( entity.damagedtodeath ) || !entity.damagedtodeath )
+								{
+									entity domaxdamage( self.origin + ( 0, 0, 1 ), self, self, 0, "MOD_CRUSH" );
+								}
+								break;
+							}
+							else
+							{
+								entity dodamage( entity.health * 2, self.origin + ( 0, 0, 1 ), self, self, 0, "MOD_CRUSH" );
+							}
+						}
+					}
+				}
+			}
+			_k492 = getNextArrayKey( _a492, _k492 );
+		}
+		self destroy_supply_crates();
+		if ( getTime() > corpse_delay )
+		{
+			self destroy_corpses();
+		}
+		if ( level.gametype == "ctf" )
+		{
+			_a601 = level.flags;
+			_k601 = getFirstArrayKey( _a601 );
+			while ( isDefined( _k601 ) )
+			{
+				flag = _a601[ _k601 ];
+				if ( flag.visuals[ 0 ] istouching( self.kill_trigger ) )
+				{
+					flag maps/mp/gametypes/ctf::returnflag();
+				}
+				_k601 = getNextArrayKey( _a601, _k601 );
+			}
+		}
+		else if ( level.gametype == "sd" && !level.multibomb )
+		{
+			if ( level.sdbomb.visuals[ 0 ] istouching( self.kill_trigger ) )
+			{
+				level.sdbomb maps/mp/gametypes/_gameobjects::returnhome();
+			}
+		}
+		pixendevent();
+	}
+}
+
+getwatcherforweapon( weapname )
+{
+	if ( !isDefined( self ) )
+	{
+		return undefined;
+	}
+	if ( !isplayer( self ) )
+	{
+		return undefined;
+	}
+	i = 0;
+	while ( i < self.weaponobjectwatcherarray.size )
+	{
+		if ( self.weaponobjectwatcherarray[ i ].weapon != weapname )
+		{
+			i++;
+			continue;
+		}
+		else
+		{
+			return self.weaponobjectwatcherarray[ i ];
+		}
+		i++;
+	}
+	return undefined;
+}
+
+destroy_supply_crates()
+{
+	crates = getentarray( "care_package", "script_noteworthy" );
+	_a651 = crates;
+	_k651 = getFirstArrayKey( _a651 );
+	while ( isDefined( _k651 ) )
+	{
+		crate = _a651[ _k651 ];
+		if ( distancesquared( crate.origin, self.origin ) < 10000 )
+		{
+			if ( crate istouching( self ) )
+			{
+				playfx( level._supply_drop_explosion_fx, crate.origin );
+				playsoundatposition( "wpn_grenade_explode", crate.origin );
+				wait 0,1;
+				crate maps/mp/killstreaks/_supplydrop::cratedelete();
+			}
+		}
+		_k651 = getNextArrayKey( _a651, _k651 );
+	}
+}
+
+destroy_corpses()
+{
+	corpses = getcorpsearray();
+	i = 0;
+	while ( i < corpses.size )
+	{
+		if ( distancesquared( corpses[ i ].origin, self.origin ) < 10000 )
+		{
+			corpses[ i ] delete();
+		}
+		i++;
+	}
+}

patch_mp/maps/mp/mp_frostbite.gsc

@@ -0,0 +1,168 @@
+#include maps/mp/_compass;
+#include maps/mp/_utility;
+
+main()
+{
+	level.levelspawndvars = ::levelspawndvars;
+	level thread spawnkilltrigger();
+	maps/mp/mp_frostbite_fx::main();
+	precachemodel( "dh_facilities_sign_08" );
+	precachemodel( "p6_fro_concrete_planter" );
+	precachemodel( "p6_fro_bookstore_window_trm" );
+	precachemodel( "collision_clip_256x256x10" );
+	precachemodel( "collision_clip_64x64x10" );
+	precachemodel( "collision_physics_256x256x10" );
+	precachemodel( "collision_clip_32x32x32" );
+	precachemodel( "collision_clip_128x128x10" );
+	precachemodel( "collision_clip_wall_32x32x10" );
+	precachemodel( "collision_clip_wall_64x64x10" );
+	precachemodel( "collision_mp_frost_kitchen_weap" );
+	maps/mp/_load::main();
+	maps/mp/mp_frostbite_amb::main();
+	maps/mp/_compass::setupminimap( "compass_map_mp_frostbite" );
+	prop1 = spawn( "script_model", ( -972, 559, 182 ) );
+	prop1.angles = vectorScale( ( 0, 0, 1 ), 90 );
+	prop2 = spawn( "script_model", ( -973, 521, 182 ) );
+	prop2.angles = vectorScale( ( 0, 0, 1 ), 90 );
+	prop3 = spawn( "script_model", ( -972, 485, 182 ) );
+	prop3.angles = vectorScale( ( 0, 0, 1 ), 90 );
+	prop4 = spawn( "script_model", ( -966, 558, 182 ) );
+	prop4.angles = vectorScale( ( 0, 0, 1 ), 270 );
+	prop5 = spawn( "script_model", ( -965, 522, 182 ) );
+	prop5.angles = vectorScale( ( 0, 0, 1 ), 270 );
+	prop6 = spawn( "script_model", ( -966, 484, 182 ) );
+	prop6.angles = vectorScale( ( 0, 0, 1 ), 270 );
+	prop1 setmodel( "dh_facilities_sign_08" );
+	prop2 setmodel( "dh_facilities_sign_08" );
+	prop3 setmodel( "dh_facilities_sign_08" );
+	prop4 setmodel( "dh_facilities_sign_08" );
+	prop5 setmodel( "dh_facilities_sign_08" );
+	prop6 setmodel( "dh_facilities_sign_08" );
+	planter1 = spawn( "script_model", ( -1609, -827,405, 131,751 ) );
+	planter1.angles = ( 359,846, 90,58, 89,9993 );
+	planter2 = spawn( "script_model", ( -1609, -827,41, 81,75 ) );
+	planter2.angles = ( 359,846, 90,58, 89,9993 );
+	planter1 setmodel( "p6_fro_concrete_planter" );
+	planter2 setmodel( "p6_fro_concrete_planter" );
+	brick1 = spawn( "script_model", ( 1129, 703, 95,75 ) );
+	brick1.angles = ( 90, 180, -90 );
+	brick2 = spawn( "script_model", ( 1127,75, 712, 95,75 ) );
+	brick2.angles = ( 90, 180, -90 );
+	brick3 = spawn( "script_model", ( 1129, 703, 47,75 ) );
+	brick3.angles = ( 90, 180, -90 );
+	brick4 = spawn( "script_model", ( 1127,75, 712, 47,75 ) );
+	brick4.angles = ( 90, 180, -90 );
+	brick5 = spawn( "script_model", ( 1129, 694, 95,75 ) );
+	brick5.angles = ( 90, 180, -90 );
+	brick6 = spawn( "script_model", ( 1129, 694, 47,75 ) );
+	brick6.angles = ( 90, 180, -90 );
+	brick7 = spawn( "script_model", ( 1129, 685, 95,75 ) );
+	brick7.angles = ( 90, 180, -90 );
+	brick8 = spawn( "script_model", ( 1129, 685, 47,75 ) );
+	brick8.angles = ( 90, 180, -90 );
+	brick1 setmodel( "p6_fro_bookstore_window_trm" );
+	brick2 setmodel( "p6_fro_bookstore_window_trm" );
+	brick3 setmodel( "p6_fro_bookstore_window_trm" );
+	brick4 setmodel( "p6_fro_bookstore_window_trm" );
+	brick5 setmodel( "p6_fro_bookstore_window_trm" );
+	brick6 setmodel( "p6_fro_bookstore_window_trm" );
+	brick7 setmodel( "p6_fro_bookstore_window_trm" );
+	brick8 setmodel( "p6_fro_bookstore_window_trm" );
+	spawncollision( "collision_clip_256x256x10", "collider", ( 145, -1295,5, 115,5 ), vectorScale( ( 0, 0, 1 ), 88,9 ) );
+	spawncollision( "collision_clip_256x256x10", "collider", ( 28, -1295,5, 115,5 ), vectorScale( ( 0, 0, 1 ), 88,9 ) );
+	spawncollision( "collision_clip_256x256x10", "collider", ( 252,5, -1251,5, 114 ), ( 0, 45,1, -88,9 ) );
+	spawncollision( "collision_clip_64x64x10", "collider", ( 448, 1577, -10,5 ), vectorScale( ( 0, 0, 1 ), 277 ) );
+	spawncollision( "collision_physics_256x256x10", "collider", ( 1199, 89, 67,5 ), vectorScale( ( 0, 0, 1 ), 90 ) );
+	spawncollision( "collision_clip_32x32x32", "collider", ( 84,5, 361,75, 66,5 ), ( 359,904, 8,05247, 11,9159 ) );
+	spawncollision( "collision_clip_32x32x32", "collider", ( 80, 390, 69,5 ), vectorScale( ( 0, 0, 1 ), 9,19998 ) );
+	spawncollision( "collision_clip_32x32x32", "collider", ( 75,5, 418, 66,75 ), ( 1,00357, 9,19998, -11 ) );
+	spawncollision( "collision_clip_128x128x10", "collider", ( 244,75, -860, -45 ), vectorScale( ( 0, 0, 1 ), 27 ) );
+	spawncollision( "collision_clip_wall_32x32x10", "collider", ( 958,5, 716,5, 130 ), vectorScale( ( 0, 0, 1 ), 5,6 ) );
+	spawncollision( "collision_clip_wall_64x64x10", "collider", ( -1126, -909, 44,5 ), vectorScale( ( 0, 0, 1 ), 105,6 ) );
+	spawncollision( "collision_clip_wall_64x64x10", "collider", ( -1130, -789,5, 44,5 ), vectorScale( ( 0, 0, 1 ), 83,9 ) );
+	spawncollision( "collision_clip_wall_64x64x10", "collider", ( -1130, -789,5, 107 ), vectorScale( ( 0, 0, 1 ), 83,9 ) );
+	spawncollision( "collision_clip_wall_64x64x10", "collider", ( -1126, -909, 106 ), vectorScale( ( 0, 0, 1 ), 105,6 ) );
+	spawncollision( "collision_clip_wall_64x64x10", "collider", ( -1130, -789,5, 164,5 ), vectorScale( ( 0, 0, 1 ), 83,9 ) );
+	spawncollision( "collision_mp_frost_kitchen_weap", "collider", ( 1994, -281,5, 16 ), ( 0, 0, 1 ) );
+	setdvar( "compassmaxrange", "2100" );
+	visionsetnaked( "mp_frostbite", 1 );
+	game[ "strings" ][ "war_callsign_a" ] = &"MPUI_CALLSIGN_MAPNAME_A";
+	game[ "strings" ][ "war_callsign_b" ] = &"MPUI_CALLSIGN_MAPNAME_B";
+	game[ "strings" ][ "war_callsign_c" ] = &"MPUI_CALLSIGN_MAPNAME_C";
+	game[ "strings" ][ "war_callsign_d" ] = &"MPUI_CALLSIGN_MAPNAME_D";
+	game[ "strings" ][ "war_callsign_e" ] = &"MPUI_CALLSIGN_MAPNAME_E";
+	game[ "strings_menu" ][ "war_callsign_a" ] = "@MPUI_CALLSIGN_MAPNAME_A";
+	game[ "strings_menu" ][ "war_callsign_b" ] = "@MPUI_CALLSIGN_MAPNAME_B";
+	game[ "strings_menu" ][ "war_callsign_c" ] = "@MPUI_CALLSIGN_MAPNAME_C";
+	game[ "strings_menu" ][ "war_callsign_d" ] = "@MPUI_CALLSIGN_MAPNAME_D";
+	game[ "strings_menu" ][ "war_callsign_e" ] = "@MPUI_CALLSIGN_MAPNAME_E";
+	level.onplayerkilledextraunthreadedcbs[ level.onplayerkilledextraunthreadedcbs.size ] = ::on_player_killed;
+	level.overrideplayerdeathwatchtimer = ::leveloverridetime;
+	level glass_node_fix();
+}
+
+levelspawndvars( reset_dvars )
+{
+	ss = level.spawnsystem;
+	ss.enemy_influencer_radius = set_dvar_float_if_unset( "scr_spawn_enemy_influencer_radius", "2250", reset_dvars );
+	ss.hq_objective_influencer_inner_radius = set_dvar_float_if_unset( "scr_spawn_hq_objective_influencer_inner_radius", "1000", reset_dvars );
+}
+
+on_player_killed( einflictor, attacker, idamage, smeansofdeath, sweapon, vdir, shitloc, psoffsettime, deathanimduration )
+{
+	if ( isDefined( smeansofdeath ) && smeansofdeath == "MOD_TRIGGER_HURT" )
+	{
+		depth = self depthinwater();
+		if ( depth > 0 )
+		{
+			origin = self.origin + ( 0, 0, depth + 5 );
+			self playsound( "mpl_splash_death" );
+			playfx( level._effect[ "water_splash" ], origin );
+		}
+	}
+}
+
+leveloverridetime( defaulttime )
+{
+	if ( self.body depthinwater() > 0 )
+	{
+		return 0,4;
+	}
+	return defaulttime;
+}
+
+glass_node_fix()
+{
+	nodes = getallnodes();
+	level thread glass_node_think( nodes[ 459 ] );
+	level thread glass_node_think( nodes[ 454 ] );
+}
+
+glass_node_think( node )
+{
+	wait 0,25;
+	ent = spawn( "script_model", node.origin, 1 );
+	ent setmodel( level.deployedshieldmodel );
+	ent hide();
+	ent disconnectpaths();
+	ent.origin -= vectorScale( ( 0, 0, 1 ), 64 );
+	for ( ;; )
+	{
+		level waittill( "glass_smash", origin );
+		if ( distancesquared( origin, node.origin ) < 65536 )
+		{
+			ent delete();
+			return;
+		}
+	}
+}
+
+spawnkilltrigger()
+{
+	trigger = spawn( "trigger_radius", ( 536, -1304, -104 ), 0, 256, 128 );
+	while ( 1 )
+	{
+		trigger waittill( "trigger", player );
+		player dodamage( player.health * 2, trigger.origin, trigger, trigger, "none", "MOD_SUICIDE", 0, "lava_mp" );
+	}
+}

patch_mp/maps/mp/mp_hijacked.gsc

@@ -0,0 +1,227 @@
+#include maps/mp/_compass;
+#include maps/mp/_utility;
+
+main()
+{
+	level.levelspawndvars = ::levelspawndvars;
+	level.overrideplayerdeathwatchtimer = ::leveloverridetime;
+	level.useintermissionpointsonwavespawn = ::useintermissionpointsonwavespawn;
+	maps/mp/mp_hijacked_fx::main();
+	precachemodel( "collision_physics_64x64x10" );
+	precachemodel( "collision_physics_wall_64x64x10" );
+	precachemodel( "collision_physics_cylinder_32x128" );
+	precachemodel( "collision_clip_64x64x10" );
+	maps/mp/_load::main();
+	maps/mp/mp_hijacked_amb::main();
+	if ( level.gametype == "dm" )
+	{
+		spawn( "mp_dm_spawn", ( 82, 262, -135,5 ), 0, 187, 0 );
+		spawn( "mp_dm_spawn", ( 783,5, 90, 58 ), 0, 198, 0 );
+		spawn( "mp_dm_spawn", ( 1103,5, -187,5, 192 ), 0, 165, 0 );
+		spawn( "mp_dm_spawn", ( -3012, -178, -136 ), 0, 335, 0 );
+		spawn( "mp_dm_spawn", ( -3016, 176, -136 ), 0, 28, 0 );
+		spawn( "mp_dm_spawn", ( -1022,5, -109,5, -136 ), 0, 5, 0 );
+		spawn( "mp_dm_spawn", ( -874, 661, -14 ), 0, 5, 0 );
+		spawn( "mp_dm_spawn", ( -1048, -333, 201 ), 0, 69, 0 );
+		spawn( "mp_dm_spawn", ( -1462,5, 169,5, -8 ), 0, 48, 0 );
+	}
+	if ( level.gametype == "tdm" )
+	{
+		spawn( "mp_tdm_spawn", ( 82, 262, -135,5 ), 0, 187, 0 );
+		spawn( "mp_tdm_spawn", ( 783,5, 90, 58 ), 0, 198, 0 );
+		spawn( "mp_tdm_spawn", ( 1103,5, -187,5, 192 ), 0, 165, 0 );
+		spawn( "mp_tdm_spawn", ( -3012, -178, -136 ), 0, 335, 0 );
+		spawn( "mp_tdm_spawn", ( -3016, 176, -136 ), 0, 28, 0 );
+		spawn( "mp_tdm_spawn", ( -1022,5, -109,5, -136 ), 0, 5, 0 );
+		spawn( "mp_tdm_spawn", ( -874, 661, -14 ), 0, 5, 0 );
+		spawn( "mp_tdm_spawn", ( -1048, -333, 201 ), 0, 69, 0 );
+		spawn( "mp_tdm_spawn", ( -1462,5, 169,5, -8 ), 0, 48, 0 );
+	}
+	if ( level.gametype == "conf" )
+	{
+		spawn( "mp_tdm_spawn", ( 82, 262, -135,5 ), 0, 187, 0 );
+		spawn( "mp_tdm_spawn", ( 783,5, 90, 58 ), 0, 198, 0 );
+		spawn( "mp_tdm_spawn", ( 1103,5, -187,5, 192 ), 0, 165, 0 );
+		spawn( "mp_tdm_spawn", ( -3012, -178, -136 ), 0, 335, 0 );
+		spawn( "mp_tdm_spawn", ( -3016, 176, -136 ), 0, 28, 0 );
+		spawn( "mp_tdm_spawn", ( -1022,5, -109,5, -136 ), 0, 5, 0 );
+		spawn( "mp_tdm_spawn", ( -874, 661, -14 ), 0, 5, 0 );
+		spawn( "mp_tdm_spawn", ( -1048, -333, 201 ), 0, 69, 0 );
+		spawn( "mp_tdm_spawn", ( -1462,5, 169,5, -8 ), 0, 48, 0 );
+	}
+	if ( level.gametype == "ctf" )
+	{
+		spawn( "mp_ctf_spawn_axis", ( 82, 262, -135,5 ), 0, 187, 0 );
+		spawn( "mp_ctf_spawn_axis", ( 249, 682, 48 ), 0, 183, 0 );
+		spawn( "mp_ctf_spawn_axis", ( 1103,5, -187,5, 192 ), 0, 165, 0 );
+		spawn( "mp_ctf_spawn_allies", ( -1022,5, -109,5, -136 ), 0, 5, 0 );
+		spawn( "mp_ctf_spawn_allies", ( -874, 661, -14 ), 0, 5, 0 );
+		spawn( "mp_ctf_spawn_allies", ( -1462,5, 169,5, -8 ), 0, 48, 0 );
+	}
+	if ( level.gametype == "dom" )
+	{
+		spawn( "mp_dom_spawn", ( 82, 262, -135,5 ), 0, 187, 0 );
+		spawn( "mp_dom_spawn", ( 249, 682, 48 ), 0, 183, 0 );
+		spawn( "mp_dom_spawn", ( 1103,5, -187,5, 192 ), 0, 165, 0 );
+		spawn( "mp_dom_spawn", ( -1022,5, -109,5, -136 ), 0, 5, 0 );
+		spawn( "mp_dom_spawn", ( -874, 661, -14 ), 0, 5, 0 );
+		spawn( "mp_dom_spawn", ( -1462,5, 169,5, -8 ), 0, 48, 0 );
+		spawn( "mp_dom_spawn", ( -1048, -333, 201 ), 0, 69, 0 );
+	}
+	if ( level.gametype == "dem" )
+	{
+		spawn( "mp_dem_spawn_attacker", ( 1103,5, -187,5, 192 ), 0, 165, 0 );
+		spawn( "mp_dem_spawn_attacker", ( 783,5, 90, 58 ), 0, 198, 0 );
+	}
+	maps/mp/_compass::setupminimap( "compass_map_mp_hijacked" );
+	spawncollision( "collision_physics_64x64x10", "collider", ( 1660, 40, 59 ), vectorScale( ( 0, 0, 1 ), 90 ) );
+	spawncollision( "collision_physics_64x64x10", "collider", ( 1633, 40, 48 ), vectorScale( ( 0, 0, 1 ), 90 ) );
+	spawncollision( "collision_physics_64x64x10", "collider", ( 1660, -42, 59 ), vectorScale( ( 0, 0, 1 ), 90 ) );
+	spawncollision( "collision_physics_64x64x10", "collider", ( 1632, -42, 48 ), vectorScale( ( 0, 0, 1 ), 90 ) );
+	spawncollision( "collision_physics_64x64x10", "collider", ( 904, 18, 53 ), ( 0, 270, -90 ) );
+	spawncollision( "collision_physics_64x64x10", "collider", ( 904, 91, 90 ), ( 0, 270, -90 ) );
+	spawncollision( "collision_physics_cylinder_32x128", "collider", ( -1055, 10, 216 ), vectorScale( ( 0, 0, 1 ), 90 ) );
+	spawncollision( "collision_clip_64x64x10", "collider", ( -1912,65, -245, -76,3463 ), vectorScale( ( 0, 0, 1 ), 282 ) );
+	spawncollision( "collision_physics_wall_64x64x10", "collider", ( -1064, 412, 254 ), vectorScale( ( 0, 0, 1 ), 342,8 ) );
+	spawncollision( "collision_physics_wall_64x64x10", "collider", ( -1112, 416,5, 284 ), vectorScale( ( 0, 0, 1 ), 316,3 ) );
+	level.levelkothdisable = [];
+	level.levelkothdisable[ level.levelkothdisable.size ] = spawn( "trigger_radius", ( 402, 181,5, 35 ), 0, 70, 128 );
+	level.levelkothdisable[ level.levelkothdisable.size ] = spawn( "trigger_radius", ( -96, 320, 34 ), 0, 150, 80 );
+	level thread water_trigger_init();
+	if ( level.gametype == "koth" )
+	{
+		trigs = getentarray( "koth_zone_trigger", "targetname" );
+		_a138 = trigs;
+		_k138 = getFirstArrayKey( _a138 );
+		while ( isDefined( _k138 ) )
+		{
+			trigger = _a138[ _k138 ];
+			if ( trigger.origin == ( -239, 86, -83 ) )
+			{
+				trigger delete();
+				break;
+			}
+			else
+			{
+				_k138 = getNextArrayKey( _a138, _k138 );
+			}
+		}
+		trigger = spawn( "trigger_box", ( -204, 92, -128 ), 1, 2088, 504, 160 );
+		trigger.targetname = "koth_zone_trigger";
+	}
+}
+
+levelspawndvars( reset_dvars )
+{
+	ss = level.spawnsystem;
+	ss.enemy_influencer_radius = set_dvar_float_if_unset( "scr_spawn_enemy_influencer_radius", "1600", reset_dvars );
+	ss.dead_friend_influencer_radius = set_dvar_float_if_unset( "scr_spawn_dead_friend_influencer_radius", "1400", reset_dvars );
+	ss.dead_friend_influencer_timeout_seconds = set_dvar_float_if_unset( "scr_spawn_dead_friend_influencer_timeout_seconds", "8", reset_dvars );
+	ss.dead_friend_influencer_count = set_dvar_float_if_unset( "scr_spawn_dead_friend_influencer_count", "10", reset_dvars );
+	ss.enemy_spawned_influencer_timeout_seconds = set_dvar_float_if_unset( "scr_spawn_enemy_spawned_influencer_timeout_seconds", "12", reset_dvars );
+	ss.dom_unowned_flag_influencer_radius = set_dvar_float_if_unset( "scr_spawn_dom_unowned_flag_influencer_radius", "1200", reset_dvars );
+	ss.dom_unowned_flag_influencer_score = set_dvar_float_if_unset( "scr_spawn_dom_unowned_flag_influencer_score", "-25", reset_dvars );
+	ss.dom_enemy_flag_influencer_radius[ 0 ] = set_dvar_float_if_unset( "scr_spawn_dom_enemy_flag_A_influencer_radius", "1200", reset_dvars );
+}
+
+water_trigger_init()
+{
+	wait 3;
+	triggers = getentarray( "trigger_hurt", "classname" );
+	_a176 = triggers;
+	_k176 = getFirstArrayKey( _a176 );
+	while ( isDefined( _k176 ) )
+	{
+		trigger = _a176[ _k176 ];
+		if ( trigger.origin[ 2 ] > level.mapcenter[ 2 ] )
+		{
+		}
+		else
+		{
+			trigger thread water_trigger_think();
+		}
+		_k176 = getNextArrayKey( _a176, _k176 );
+	}
+	triggers = getentarray( "water_killbrush", "targetname" );
+	_a188 = triggers;
+	_k188 = getFirstArrayKey( _a188 );
+	while ( isDefined( _k188 ) )
+	{
+		trigger = _a188[ _k188 ];
+		trigger thread player_splash_think();
+		_k188 = getNextArrayKey( _a188, _k188 );
+	}
+}
+
+player_splash_think()
+{
+	for ( ;; )
+	{
+		self waittill( "trigger", entity );
+		if ( isplayer( entity ) && isalive( entity ) )
+		{
+			self thread trigger_thread( entity, ::player_water_fx );
+		}
+	}
+}
+
+player_water_fx( player, endon_condition )
+{
+	maxs = self.origin + self getmaxs();
+	if ( maxs[ 2 ] > 60 )
+	{
+		maxs += vectorScale( ( 0, 0, 1 ), 10 );
+	}
+	origin = ( player.origin[ 0 ], player.origin[ 1 ], maxs[ 2 ] );
+	playfx( level._effect[ "water_splash_sm" ], origin );
+}
+
+water_trigger_think()
+{
+	for ( ;; )
+	{
+		self waittill( "trigger", entity );
+		if ( isplayer( entity ) )
+		{
+			entity playsound( "mpl_splash_death" );
+			playfx( level._effect[ "water_splash" ], entity.origin + vectorScale( ( 0, 0, 1 ), 40 ) );
+		}
+	}
+}
+
+leveloverridetime( defaulttime )
+{
+	if ( self isinwater() )
+	{
+		return 0,4;
+	}
+	return defaulttime;
+}
+
+useintermissionpointsonwavespawn()
+{
+	return self isinwater();
+}
+
+isinwater()
+{
+	triggers = getentarray( "trigger_hurt", "classname" );
+	_a253 = triggers;
+	_k253 = getFirstArrayKey( _a253 );
+	while ( isDefined( _k253 ) )
+	{
+		trigger = _a253[ _k253 ];
+		if ( trigger.origin[ 2 ] > level.mapcenter[ 2 ] )
+		{
+		}
+		else
+		{
+			if ( self istouching( trigger ) )
+			{
+				return 1;
+			}
+		}
+		_k253 = getNextArrayKey( _a253, _k253 );
+	}
+	return 0;
+}

patch_mp/maps/mp/mp_hydro.gsc

@@ -0,0 +1,465 @@
+#include maps/mp/gametypes/_weaponobjects;
+#include maps/mp/killstreaks/_rcbomb;
+#include maps/mp/_tacticalinsertion;
+#include maps/mp/killstreaks/_airsupport;
+#include maps/mp/_compass;
+#include maps/mp/_events;
+#include common_scripts/utility;
+#include maps/mp/_utility;
+
+main()
+{
+	level.levelspawndvars = ::levelspawndvars;
+	precacheitem( "hydro_water_mp" );
+	maps/mp/mp_hydro_fx::main();
+	precachemodel( "collision_physics_256x256x10" );
+	precachemodel( "collision_missile_128x128x10" );
+	precachemodel( "collision_physics_64x64x64" );
+	maps/mp/_load::main();
+	maps/mp/mp_hydro_amb::main();
+	maps/mp/_compass::setupminimap( "compass_map_mp_hydro" );
+	maps/mp/mp_hydro_amb::main();
+/#
+	execdevgui( "devgui_mp_hydro" );
+#/
+	registerclientfield( "world", "pre_wave", 1, 1, "int" );
+	registerclientfield( "world", "big_wave", 1, 1, "int" );
+	setdvar( "compassmaxrange", "2300" );
+	game[ "strings" ][ "war_callsign_a" ] = &"MPUI_CALLSIGN_MAPNAME_A";
+	game[ "strings" ][ "war_callsign_b" ] = &"MPUI_CALLSIGN_MAPNAME_B";
+	game[ "strings" ][ "war_callsign_c" ] = &"MPUI_CALLSIGN_MAPNAME_C";
+	game[ "strings" ][ "war_callsign_d" ] = &"MPUI_CALLSIGN_MAPNAME_D";
+	game[ "strings" ][ "war_callsign_e" ] = &"MPUI_CALLSIGN_MAPNAME_E";
+	game[ "strings_menu" ][ "war_callsign_a" ] = "@MPUI_CALLSIGN_MAPNAME_A";
+	game[ "strings_menu" ][ "war_callsign_b" ] = "@MPUI_CALLSIGN_MAPNAME_B";
+	game[ "strings_menu" ][ "war_callsign_c" ] = "@MPUI_CALLSIGN_MAPNAME_C";
+	game[ "strings_menu" ][ "war_callsign_d" ] = "@MPUI_CALLSIGN_MAPNAME_D";
+	game[ "strings_menu" ][ "war_callsign_e" ] = "@MPUI_CALLSIGN_MAPNAME_E";
+	spawncollision( "collision_physics_256x256x10", "collider", ( 3695, 340, 84 ), ( 0, 44,8, -90 ) );
+	spawncollision( "collision_physics_256x256x10", "collider", ( 3449, 82, 84 ), ( 0, 44,8, -90 ) );
+	spawncollision( "collision_physics_64x64x64", "collider", ( 577,5, -1835, 309,5 ), ( 0, 0, 1 ) );
+	spawncollision( "collision_physics_64x64x64", "collider", ( 577,5, -1786,5, 339,5 ), ( 0, 0, 1 ) );
+	spawncollision( "collision_physics_64x64x64", "collider", ( -641,5, -1834,5, 309,5 ), ( 0, 0, 1 ) );
+	spawncollision( "collision_physics_64x64x64", "collider", ( -641,5, -1786, 339,5 ), ( 0, 0, 1 ) );
+	spawncollision( "collision_missile_128x128x10", "collider", ( -521,5, -2106, 325 ), vectorScale( ( 0, 0, 1 ), 90 ) );
+	spawncollision( "collision_missile_128x128x10", "collider", ( -521,5, -2041, 325 ), vectorScale( ( 0, 0, 1 ), 90 ) );
+	spawncollision( "collision_missile_128x128x10", "collider", ( 471,5, -2106, 325 ), vectorScale( ( 0, 0, 1 ), 90 ) );
+	spawncollision( "collision_missile_128x128x10", "collider", ( 471,5, -2041, 325 ), vectorScale( ( 0, 0, 1 ), 90 ) );
+	spawncollision( "collision_missile_128x128x10", "collider", ( 1432, -1912, 376,5 ), vectorScale( ( 0, 0, 1 ), 90 ) );
+	spawncollision( "collision_missile_128x128x10", "collider", ( 1516,5, -1912, 376,5 ), vectorScale( ( 0, 0, 1 ), 90 ) );
+	spawncollision( "collision_missile_128x128x10", "collider", ( -1490, -1916,5, 376,5 ), vectorScale( ( 0, 0, 1 ), 90 ) );
+	spawncollision( "collision_missile_128x128x10", "collider", ( -1574,5, -1916,5, 376,5 ), vectorScale( ( 0, 0, 1 ), 90 ) );
+	level.waterrushfx = loadfx( "maps/mp_maps/fx_mp_hydro_dam_water_wall" );
+	level.waterambientfxmiddlefront = loadfx( "maps/mp_maps/fx_mp_hydro_flood_splash_middle_front" );
+	level.waterambientfxmiddleback = loadfx( "maps/mp_maps/fx_mp_hydro_flood_splash_middle_back" );
+	level.waterambientfxleftfront = loadfx( "maps/mp_maps/fx_mp_hydro_flood_splash_right" );
+	level.waterambientfxleftmiddle = loadfx( "maps/mp_maps/fx_mp_hydro_flood_splash_left_mid" );
+	level.waterambientfxleftback = loadfx( "maps/mp_maps/fx_mp_hydro_flood_splash_left_back" );
+	level.waterambientfxrightfront = loadfx( "maps/mp_maps/fx_mp_hydro_flood_splash_left" );
+	level.waterambientfxrightmiddle = loadfx( "maps/mp_maps/fx_mp_hydro_flood_splash_right_mid" );
+	level.waterambientfxrightback = loadfx( "maps/mp_maps/fx_mp_hydro_flood_splash_right_back" );
+	level.waterambientfxboxfront = loadfx( "maps/mp_maps/fx_mp_hydro_flood_splash_box" );
+	level.waterambientfxboxback = loadfx( "maps/mp_maps/fx_mp_hydro_flood_splash_box_back" );
+	setdvar( "tu6_player_shallowWaterHeight", "10.5" );
+	visionsetnaked( "mp_hydro", 1 );
+	level thread removeobjectsondemovertime();
+	set_dvar_if_unset( "scr_hydro_water_rush", 1 );
+	if ( getgametypesetting( "allowMapScripting" ) )
+	{
+		level.overrideplayerdeathwatchtimer = ::leveloverridetime;
+		initwatertriggers();
+	}
+}
+
+levelspawndvars( reset_dvars )
+{
+	ss = level.spawnsystem;
+	ss.enemy_influencer_radius = set_dvar_float_if_unset( "scr_spawn_enemy_influencer_radius", "2400", reset_dvars );
+}
+
+leveloverridetime( defaulttime )
+{
+	if ( isDefined( self.lastattacker ) && isDefined( self.lastattacker.targetname ) && self.lastattacker.targetname == "water_kill_trigger" )
+	{
+		return 0,4;
+	}
+	return defaulttime;
+}
+
+initwatertriggers()
+{
+	water_kill_triggers = getentarray( "water_kill_trigger", "targetname" );
+	water_mover = spawn( "script_model", ( 0, 0, 1 ) );
+	water_mover setmodel( "tag_origin" );
+	water_ambient_mover = spawn( "script_model", ( 0, 0, 1 ) );
+	water_ambient_mover setmodel( "tag_origin" );
+	water_ambient_front_pillar = spawn( "script_model", ( -31, -888, 202 ) );
+	water_ambient_front_pillar setmodel( "tag_origin" );
+	water_ambient_front_pillar.angles = vectorScale( ( 0, 0, 1 ), 90 );
+	water_ambient_front_pillar linkto( water_ambient_mover );
+	water_ambient_back_pillar = spawn( "script_model", ( -32, -1535, 202 ) );
+	water_ambient_back_pillar setmodel( "tag_origin" );
+	water_ambient_back_pillar.angles = vectorScale( ( 0, 0, 1 ), 90 );
+	water_ambient_back_pillar linkto( water_ambient_mover );
+	water_ambient_front_block = spawn( "script_model", ( -32, -331, 193 ) );
+	water_ambient_front_block setmodel( "tag_origin" );
+	water_ambient_front_block.angles = vectorScale( ( 0, 0, 1 ), 90 );
+	water_ambient_front_block linkto( water_ambient_mover );
+	water_ambient_back_block = spawn( "script_model", ( -32, -1800, 199 ) );
+	water_ambient_back_block setmodel( "tag_origin" );
+	water_ambient_back_block.angles = vectorScale( ( 0, 0, 1 ), 90 );
+	water_ambient_back_block linkto( water_ambient_mover );
+	water_ambient_back_right = spawn( "script_model", ( -467, -1975, 190 ) );
+	water_ambient_back_right setmodel( "tag_origin" );
+	water_ambient_back_right.angles = vectorScale( ( 0, 0, 1 ), 90 );
+	water_ambient_back_right linkto( water_ambient_mover );
+	water_ambient_back_left = spawn( "script_model", ( 404, -1975, 190 ) );
+	water_ambient_back_left setmodel( "tag_origin" );
+	water_ambient_back_left.angles = vectorScale( ( 0, 0, 1 ), 90 );
+	water_ambient_back_left linkto( water_ambient_mover );
+	water_ambient_middle_right = spawn( "script_model", ( -274, -1680, 185 ) );
+	water_ambient_middle_right setmodel( "tag_origin" );
+	water_ambient_middle_right.angles = vectorScale( ( 0, 0, 1 ), 90 );
+	water_ambient_middle_right linkto( water_ambient_mover );
+	water_ambient_middle_left = spawn( "script_model", ( 215, -1680, 185 ) );
+	water_ambient_middle_left setmodel( "tag_origin" );
+	water_ambient_middle_left.angles = vectorScale( ( 0, 0, 1 ), 90 );
+	water_ambient_middle_left linkto( water_ambient_mover );
+	water_ambient_front_right = spawn( "script_model", ( -333, -302, 185 ) );
+	water_ambient_front_right setmodel( "tag_origin" );
+	water_ambient_front_right.angles = vectorScale( ( 0, 0, 1 ), 90 );
+	water_ambient_front_right linkto( water_ambient_mover );
+	water_ambient_front_left = spawn( "script_model", ( 265, -302, 185 ) );
+	water_ambient_front_left setmodel( "tag_origin" );
+	water_ambient_front_left.angles = vectorScale( ( 0, 0, 1 ), 90 );
+	water_ambient_front_left linkto( water_ambient_mover );
+	water_pa_1 = spawn( "script_model", ( 1667, -1364, 684 ) );
+	water_pa_1 setmodel( "tag_origin" );
+	water_pa_2 = spawn( "script_model", ( -1806, -1375, 783 ) );
+	water_pa_2 setmodel( "tag_origin" );
+	water_pa_3 = spawn( "script_model", ( -100, -1375, 783 ) );
+	water_pa_3 setmodel( "tag_origin" );
+	wait 0,1;
+	water_kill_triggers[ 0 ] enablelinkto();
+	water_kill_triggers[ 0 ] linkto( water_mover );
+	water_kill_triggers[ 1 ] enablelinkto();
+	water_kill_triggers[ 1 ] linkto( water_mover );
+	playfxontag( level.waterambientfxmiddlefront, water_ambient_front_pillar, "tag_origin" );
+	playfxontag( level.waterambientfxmiddleback, water_ambient_back_pillar, "tag_origin" );
+	playfxontag( level.waterambientfxboxfront, water_ambient_front_block, "tag_origin" );
+	playfxontag( level.waterambientfxboxback, water_ambient_back_block, "tag_origin" );
+	playfxontag( level.waterambientfxrightback, water_ambient_back_right, "tag_origin" );
+	playfxontag( level.waterambientfxleftback, water_ambient_back_left, "tag_origin" );
+	playfxontag( level.waterambientfxrightmiddle, water_ambient_middle_right, "tag_origin" );
+	playfxontag( level.waterambientfxleftmiddle, water_ambient_middle_left, "tag_origin" );
+	playfxontag( level.waterambientfxrightfront, water_ambient_front_right, "tag_origin" );
+	playfxontag( level.waterambientfxleftfront, water_ambient_front_left, "tag_origin" );
+	setdvar( "R_WaterWaveBase", 0 );
+	if ( level.timelimit )
+	{
+		seconds = level.timelimit * 60;
+		add_timed_event( int( seconds * 0,25 ), "hydro_water_rush" );
+		add_timed_event( int( seconds * 0,75 ), "hydro_water_rush" );
+	}
+	else
+	{
+		if ( level.scorelimit )
+		{
+			add_score_event( int( level.scorelimit * 0,25 ), "hydro_water_rush" );
+			add_score_event( int( level.scorelimit * 0,75 ), "hydro_water_rush" );
+		}
+	}
+	trigger = spawn( "trigger_radius", ( -28, -2208, -830 ), 0, 450, 40 );
+	water_kill_triggers[ water_kill_triggers.size ] = trigger;
+	self thread watchwatertrigger( water_mover, water_kill_triggers, water_pa_1, water_pa_2, water_pa_3, water_ambient_back_pillar, water_ambient_front_block, water_ambient_mover );
+	wait 5;
+	setdvar( "R_WaterWaveBase", 0 );
+}
+
+watchwatertrigger( water_mover, water_kill_triggers, water_pa_1, water_pa_2, water_pa_3, water_ambient_back, water_ambient_box, water_ambient_mover )
+{
+	thread watchdevnotify();
+	for ( ;; )
+	{
+		level waittill_any( "hydro_water_rush", "dev_water_rush" );
+		setclientfield( "pre_wave", 1 );
+		level thread waterkilltriggerthink( water_kill_triggers );
+		water_ambient_back playloopsound( "amb_train_incomming_beep" );
+		water_ambient_box playloopsound( "amb_train_incoming_beep" );
+		water_pa_1 playsound( "evt_pa_atten" );
+		water_pa_2 playsound( "evt_pa_atten" );
+		water_pa_3 playsound( "evt_pa_atten" );
+		wait 2;
+		water_pa_1 playsound( "evt_pa_online" );
+		water_pa_2 playsound( "evt_pa_online" );
+		water_pa_3 playsound( "evt_pa_online" );
+		water_fx1 = spawn( "script_model", water_kill_triggers[ 0 ].origin + vectorScale( ( 0, 0, 1 ), 1000 ) );
+		water_fx1 setmodel( "tag_origin" );
+		water_fx1.angles = vectorScale( ( 0, 0, 1 ), 90 );
+		water_fx2 = spawn( "script_model", water_kill_triggers[ 1 ].origin + vectorScale( ( 0, 0, 1 ), 1000 ) );
+		water_fx2 setmodel( "tag_origin" );
+		water_fx2.angles = vectorScale( ( 0, 0, 1 ), 90 );
+		exploder( 1005 );
+		wait 3;
+		water_pa_1 playsound( "evt_pa_online" );
+		water_pa_2 playsound( "evt_pa_online" );
+		water_pa_3 playsound( "evt_pa_online" );
+		wait 1;
+		playfxontag( level.waterrushfx, water_fx1, "tag_origin" );
+		playfxontag( level.waterrushfx, water_fx2, "tag_origin" );
+		water_fx1 playloopsound( "evt_water_wave" );
+		water_fx2 playloopsound( "evt_water_wave" );
+		water_mover.origin = ( 0, 0, 1 );
+		setclientfield( "big_wave", 1 );
+		water_mover moveto( vectorScale( ( 0, 0, 1 ), 2100 ), 2,5 );
+		water_ambient_mover moveto( vectorScale( ( 0, 0, 1 ), 20 ), 2,5 );
+		water_kill_triggers[ 2 ].origin += vectorScale( ( 0, 0, 1 ), 1000 );
+/#
+		maps/mp/killstreaks/_airsupport::debug_cylinder( water_kill_triggers[ 2 ].origin, 450, 40, ( 1, 0,1, 0,1 ), 1, 2500 );
+#/
+		level thread waterfxloopstarter( water_fx1, water_fx2, 5 );
+		thread play_exploder();
+		waterlevel = -24;
+		wait 2;
+		water_pa_1 playsound( "evt_pa_warn" );
+		water_pa_2 playsound( "evt_pa_warn" );
+		water_pa_3 playsound( "evt_pa_warn" );
+		wait 3;
+		water_pa_1 playsound( "evt_pa_offline" );
+		water_pa_2 playsound( "evt_pa_offline" );
+		water_pa_3 playsound( "evt_pa_offline" );
+		wait 1;
+		water_kill_triggers[ 2 ].origin -= vectorScale( ( 0, 0, 1 ), 1000 );
+/#
+		maps/mp/killstreaks/_airsupport::debug_cylinder( water_kill_triggers[ 2 ].origin, 450, 40, ( 1, 0,1, 0,1 ), 0, 2500 );
+#/
+		water_mover moveto( vectorScale( ( 0, 0, 1 ), 4100 ), 2,5 );
+		water_ambient_mover moveto( ( 0, 0, 1 ), 2,5 );
+		water_fx1 stoploopsound( 2 );
+		water_fx2 stoploopsound( 2 );
+		setclientfield( "pre_wave", 0 );
+		wait 1,5;
+		water_pa_1 playsound( "evt_pa_access" );
+		water_pa_2 playsound( "evt_pa_access" );
+		water_pa_3 playsound( "evt_pa_access" );
+		wait 1;
+		water_ambient_box stoploopsound( 1 );
+		water_ambient_back stoploopsound( 1 );
+		stop_exploder( 1005 );
+		setdvar( "R_WaterWaveAmplitude", "0 0 0 0" );
+		water_mover.origin = vectorScale( ( 0, 0, 1 ), 500 );
+		wait 2;
+		water_fx1 delete();
+		water_fx2 delete();
+		water_mover.origin = ( 0, 0, 1 );
+		setclientfield( "big_wave", 0 );
+		wait 5;
+		level notify( "water_stop" );
+	}
+}
+
+play_exploder()
+{
+	wait 0,2;
+	exploder( 1002 );
+	wait 0,5;
+	exploder( 1001 );
+}
+
+watchdevnotify()
+{
+	startvalue = getDvar( #"1CC516F5" );
+	for ( ;; )
+	{
+		should_water_rush = getDvar( #"1CC516F5" );
+		if ( should_water_rush != startvalue )
+		{
+			level notify( "dev_water_rush" );
+			startvalue = should_water_rush;
+		}
+		wait 0,2;
+	}
+}
+
+waterfxloopstarter( fx1, fx2, looptime )
+{
+	level thread waterfxloop( fx1, fx2 );
+}
+
+waterfxloop( fx1, fx2 )
+{
+	start1 = fx1.origin;
+	start2 = fx2.origin;
+	fx1 moveto( fx1.origin + vectorScale( ( 0, 0, 1 ), 2200 ), 2,67 );
+	fx2 moveto( fx2.origin + vectorScale( ( 0, 0, 1 ), 2200 ), 2,67 );
+	wait 2,67;
+	fx1 moveto( fx1.origin + ( 0, 600, -1000 ), 2,5 );
+	fx2 moveto( fx2.origin + ( 0, 600, -1000 ), 2,5 );
+	wait 3;
+	fx1.origin = start1;
+	fx2.origin = start2;
+}
+
+waterkilltriggerthink( triggers )
+{
+	level endon( "water_stop" );
+	for ( ;; )
+	{
+		wait 0,1;
+		entities = getdamageableentarray( triggers[ 0 ].origin, 2000 );
+		_a395 = entities;
+		_k395 = getFirstArrayKey( _a395 );
+		while ( isDefined( _k395 ) )
+		{
+			entity = _a395[ _k395 ];
+			triggertouched = 0;
+			if ( !entity istouching( triggers[ 0 ] ) )
+			{
+				triggertouched = 1;
+				if ( !entity istouching( triggers[ 1 ] ) )
+				{
+					if ( !entity istouching( triggers[ 2 ] ) )
+					{
+					}
+				}
+			}
+			else if ( isDefined( entity.model ) && entity.model == "t6_wpn_tac_insert_world" )
+			{
+				entity maps/mp/_tacticalinsertion::destroy_tactical_insertion();
+			}
+			else
+			{
+				if ( !isalive( entity ) )
+				{
+					break;
+				}
+				else if ( isDefined( entity.targetname ) )
+				{
+					if ( entity.targetname == "talon" )
+					{
+						entity notify( "death" );
+						break;
+					}
+					else if ( entity.targetname == "rcbomb" )
+					{
+						entity maps/mp/killstreaks/_rcbomb::rcbomb_force_explode();
+						break;
+					}
+					else if ( entity.targetname == "riotshield_mp" )
+					{
+						entity dodamage( 1, triggers[ triggertouched ].origin + ( 0, 0, 1 ), triggers[ triggertouched ], triggers[ triggertouched ], 0, "MOD_CRUSH" );
+						break;
+					}
+				}
+				else if ( isDefined( entity.helitype ) && entity.helitype == "qrdrone" )
+				{
+					watcher = entity.owner maps/mp/gametypes/_weaponobjects::getweaponobjectwatcher( "qrdrone" );
+					watcher thread maps/mp/gametypes/_weaponobjects::waitanddetonate( entity, 0, undefined );
+					break;
+				}
+				else
+				{
+					if ( entity.classname == "grenade" )
+					{
+						if ( !isDefined( entity.name ) )
+						{
+							break;
+						}
+						else if ( !isDefined( entity.owner ) )
+						{
+							break;
+						}
+						else if ( entity.name == "proximity_grenade_mp" )
+						{
+							watcher = entity.owner getwatcherforweapon( entity.name );
+							watcher thread maps/mp/gametypes/_weaponobjects::waitanddetonate( entity, 0, undefined, "script_mover_mp" );
+							break;
+						}
+						else if ( !isweaponequipment( entity.name ) )
+						{
+							break;
+						}
+						else watcher = entity.owner getwatcherforweapon( entity.name );
+						if ( !isDefined( watcher ) )
+						{
+							break;
+						}
+						else watcher thread maps/mp/gametypes/_weaponobjects::waitanddetonate( entity, 0, undefined, "script_mover_mp" );
+						break;
+					}
+					else if ( entity.classname == "auto_turret" )
+					{
+						if ( !isDefined( entity.damagedtodeath ) || !entity.damagedtodeath )
+						{
+							entity domaxdamage( triggers[ triggertouched ].origin + ( 0, 0, 1 ), triggers[ triggertouched ], triggers[ triggertouched ], 0, "MOD_CRUSH" );
+						}
+						break;
+					}
+					else
+					{
+						if ( isplayer( entity ) )
+						{
+							entity dodamage( entity.health * 2, triggers[ triggertouched ].origin + ( 0, 0, 1 ), triggers[ triggertouched ], triggers[ triggertouched ], 0, "MOD_HIT_BY_OBJECT", 0, "hydro_water_mp" );
+						}
+						else
+						{
+							entity dodamage( entity.health * 2, triggers[ triggertouched ].origin + ( 0, 0, 1 ), triggers[ triggertouched ], triggers[ triggertouched ], 0, "MOD_CRUSH" );
+						}
+						if ( isplayer( entity ) )
+						{
+							entity playlocalsound( "mpl_splash_death" );
+						}
+					}
+				}
+			}
+			_k395 = getNextArrayKey( _a395, _k395 );
+		}
+	}
+}
+
+getwatcherforweapon( weapname )
+{
+	if ( !isDefined( self ) )
+	{
+		return undefined;
+	}
+	if ( !isplayer( self ) )
+	{
+		return undefined;
+	}
+	i = 0;
+	while ( i < self.weaponobjectwatcherarray.size )
+	{
+		if ( self.weaponobjectwatcherarray[ i ].weapon != weapname )
+		{
+			i++;
+			continue;
+		}
+		else
+		{
+			return self.weaponobjectwatcherarray[ i ];
+		}
+		i++;
+	}
+	return undefined;
+}
+
+removeobjectsondemovertime()
+{
+	while ( level.gametype == "dem" )
+	{
+		while ( isDefined( game[ "overtime_round" ] ) )
+		{
+			objects = getentarray( "delete_dem_overtime", "script_noteworthy" );
+			while ( isDefined( objects ) )
+			{
+				i = 0;
+				while ( i < objects.size )
+				{
+					objects[ i ] delete();
+					i++;
+				}
+			}
+		}
+	}
+}

patch_mp/maps/mp/mp_la.gsc

@@ -0,0 +1,121 @@
+#include maps/mp/killstreaks/_turret_killstreak;
+#include maps/mp/_compass;
+#include common_scripts/utility;
+#include maps/mp/_utility;
+
+main()
+{
+	level.levelspawndvars = ::levelspawndvars;
+	maps/mp/mp_la_fx::main();
+	precachemodel( "collision_clip_wall_64x64x10" );
+	precachemodel( "collision_physics_wall_64x64x10" );
+	precachemodel( "collision_physics_wall_32x32x10" );
+	precachemodel( "collision_physics_256x256x256" );
+	precachemodel( "collision_physics_64x64x10" );
+	precachemodel( "collision_physics_128x128x10" );
+	precachemodel( "collision_clip_64x64x10" );
+	precachemodel( "collision_physics_cylinder_32x128" );
+	precachemodel( "collision_clip_wall_256x256x10" );
+	precachemodel( "collision_physics_128x128x128" );
+	precachemodel( "collision_clip_128x128x10" );
+	precachemodel( "collision_physics_wall_256x256x10" );
+	precachemodel( "collision_physics_wall_128x128x10" );
+	precachemodel( "p6_building_granite_tan_brokenb" );
+	if ( gamemodeismode( level.gamemode_wager_match ) )
+	{
+		maps/mp/_compass::setupminimap( "compass_map_mp_la_wager" );
+	}
+	else
+	{
+		maps/mp/_compass::setupminimap( "compass_map_mp_la" );
+	}
+	maps/mp/_load::main();
+	maps/mp/mp_la_amb::main();
+	game[ "strings" ][ "war_callsign_a" ] = &"MPUI_CALLSIGN_MAPNAME_A";
+	game[ "strings" ][ "war_callsign_b" ] = &"MPUI_CALLSIGN_MAPNAME_B";
+	game[ "strings" ][ "war_callsign_c" ] = &"MPUI_CALLSIGN_MAPNAME_C";
+	game[ "strings" ][ "war_callsign_d" ] = &"MPUI_CALLSIGN_MAPNAME_D";
+	game[ "strings" ][ "war_callsign_e" ] = &"MPUI_CALLSIGN_MAPNAME_E";
+	game[ "strings_menu" ][ "war_callsign_a" ] = "@MPUI_CALLSIGN_MAPNAME_A";
+	game[ "strings_menu" ][ "war_callsign_b" ] = "@MPUI_CALLSIGN_MAPNAME_B";
+	game[ "strings_menu" ][ "war_callsign_c" ] = "@MPUI_CALLSIGN_MAPNAME_C";
+	game[ "strings_menu" ][ "war_callsign_d" ] = "@MPUI_CALLSIGN_MAPNAME_D";
+	game[ "strings_menu" ][ "war_callsign_e" ] = "@MPUI_CALLSIGN_MAPNAME_E";
+	spawncollision( "collision_clip_wall_64x64x10", "collider", ( -698, 2945, 28 ), vectorScale( ( 0, 1, 0 ), 270 ) );
+	spawncollision( "collision_clip_wall_64x64x10", "collider", ( -698, 2984, 28 ), vectorScale( ( 0, 1, 0 ), 270 ) );
+	spawncollision( "collision_physics_wall_32x32x10", "collider", ( -1606, 3027, 154 ), vectorScale( ( 0, 1, 0 ), 270 ) );
+	spawncollision( "collision_physics_wall_32x32x10", "collider", ( -1614, 3010, 204 ), vectorScale( ( 0, 1, 0 ), 270 ) );
+	spawncollision( "collision_physics_wall_64x64x10", "collider", ( -1610, 1860, 203 ), ( 26, 271, 17 ) );
+	spawncollision( "collision_physics_wall_256x256x10", "collider", ( -849, 3145,5, -94,5 ), vectorScale( ( 0, 1, 0 ), 276,1 ) );
+	spawncollision( "collision_physics_wall_256x256x10", "collider", ( -835, 3013,5, -119 ), vectorScale( ( 0, 1, 0 ), 276,1 ) );
+	spawncollision( "collision_physics_128x128x10", "collider", ( -795,5, 3208,5, 3,5 ), vectorScale( ( 0, 1, 0 ), 5,99995 ) );
+	spawncollision( "collision_physics_128x128x10", "collider", ( -783, 3080,5, 3,5 ), vectorScale( ( 0, 1, 0 ), 7,2 ) );
+	spawncollision( "collision_physics_128x128x10", "collider", ( -767,5, 2953,5, 15 ), vectorScale( ( 0, 1, 0 ), 7,2 ) );
+	spawncollision( "collision_physics_wall_128x128x10", "collider", ( -763, 2894,5, -35 ), ( 0, 1, 0 ) );
+	spawncollision( "collision_physics_128x128x10", "collider", ( -2275,5, 5248, -227,5 ), ( 0, 23,4, -90 ) );
+	spawncollision( "collision_physics_128x128x10", "collider", ( -2464,5, 5162, -227 ), ( 0, 33,9, -90 ) );
+	spawncollision( "collision_physics_64x64x10", "collider", ( -2363,5, 5219, -192,5 ), ( 0, 11,8, -90 ) );
+	spawncollision( "collision_physics_cylinder_32x128", "collider", ( -1151,5, 1199,5, -31 ), vectorScale( ( 0, 1, 0 ), 23,4 ) );
+	spawncollision( "collision_clip_wall_256x256x10", "collider", ( -621,5, 2114, -176,5 ), ( 0, 270, -180 ) );
+	spawncollision( "collision_physics_128x128x128", "collider", ( 807,5, 855, -217,5 ), vectorScale( ( 0, 1, 0 ), 345,9 ) );
+	spawncollision( "collision_physics_128x128x128", "collider", ( 886, 835,5, -206 ), vectorScale( ( 0, 1, 0 ), 345,9 ) );
+	spawncollision( "collision_physics_128x128x128", "collider", ( 958,277, 946,957, -191,5 ), vectorScale( ( 0, 1, 0 ), 359,9 ) );
+	spawncollision( "collision_physics_128x128x128", "collider", ( 1039,22, 946,543, -173 ), vectorScale( ( 0, 1, 0 ), 359,9 ) );
+	spawncollision( "collision_physics_128x128x128", "collider", ( 853,93, 1147,29, -191,5 ), vectorScale( ( 0, 1, 0 ), 47,4 ) );
+	spawncollision( "collision_physics_128x128x128", "collider", ( 914,57, 1214,71, -173 ), vectorScale( ( 0, 1, 0 ), 47,4 ) );
+	spawncollision( "collision_clip_64x64x10", "collider", ( -1354, 2215,5, -206 ), vectorScale( ( 0, 1, 0 ), 12,2001 ) );
+	spawncollision( "collision_physics_wall_64x64x10", "collider", ( -257,5, 958, -154,5 ), ( 7,66668, 317,653, 2,55286 ) );
+	spawncollision( "collision_clip_128x128x10", "collider", ( -684, 1465, 36,5 ), ( 0, 5, 90 ) );
+	spawncollision( "collision_physics_wall_128x128x10", "collider", ( -2067, 1390, -102 ), vectorScale( ( 0, 1, 0 ), 270 ) );
+	concrete1 = spawn( "script_model", ( -2040,54, 636,504, -215,717 ) );
+	concrete1.angles = ( 0,0251585, 359,348, 178,338 );
+	concrete1 setmodel( "p6_building_granite_tan_brokenb" );
+	level.levelkothdisable = [];
+	level.levelkothdisable[ level.levelkothdisable.size ] = spawn( "trigger_radius", ( -1337, 2016, 8,5 ), 0, 40, 50 );
+	level thread maps/mp/killstreaks/_turret_killstreak::addnoturrettrigger( ( -2295, 3843,5, -193 ), 80, 64 );
+	level thread maps/mp/killstreaks/_turret_killstreak::addnoturrettrigger( ( -2341, 3917,5, -193 ), 80, 64 );
+	level thread maps/mp/killstreaks/_turret_killstreak::addnoturrettrigger( ( -2397,75, 4003,5, -193 ), 80, 64 );
+	registerclientfield( "scriptmover", "police_car_lights", 1, 1, "int" );
+	registerclientfield( "scriptmover", "ambulance_lights", 1, 1, "int" );
+	level thread destructible_lights();
+	level.remotemotarviewleft = 45;
+	level.remotemotarviewright = 45;
+}
+
+levelspawndvars( reset_dvars )
+{
+	ss = level.spawnsystem;
+	ss.enemy_influencer_radius = set_dvar_float_if_unset( "scr_spawn_enemy_influencer_radius", "2600", reset_dvars );
+}
+
+destructible_lights()
+{
+	wait 0,05;
+	destructibles = getentarray( "destructible", "targetname" );
+	_a148 = destructibles;
+	_k148 = getFirstArrayKey( _a148 );
+	while ( isDefined( _k148 ) )
+	{
+		destructible = _a148[ _k148 ];
+		if ( destructible.destructibledef == "veh_t6_police_car_destructible_mp" )
+		{
+			destructible thread destructible_think( "police_car_lights" );
+			destructible setclientfield( "police_car_lights", 1 );
+		}
+		else
+		{
+			if ( destructible.destructibledef == "veh_iw_civ_ambulance_destructible" )
+			{
+				destructible thread destructible_think( "ambulance_lights" );
+				destructible setclientfield( "ambulance_lights", 1 );
+			}
+		}
+		_k148 = getNextArrayKey( _a148, _k148 );
+	}
+}
+
+destructible_think( clientfield )
+{
+	self waittill_any( "death", "destructible_base_piece_death" );
+	self setclientfield( clientfield, 0 );
+}

patch_mp/maps/mp/mp_magma.gsc

@@ -0,0 +1,283 @@
+#include maps/mp/gametypes/_weaponobjects;
+#include maps/mp/gametypes/_spawning;
+#include maps/mp/_compass;
+#include common_scripts/utility;
+#include maps/mp/_utility;
+
+main()
+{
+	level.levelspawndvars = ::levelspawndvars;
+	level.overrideplayerdeathwatchtimer = ::leveloverridetime;
+	level thread spawnkilltrigger();
+	maps/mp/mp_magma_fx::main();
+	precachemodel( "collision_clip_64x64x10" );
+	precachemodel( "collision_physics_64x64x10" );
+	precachemodel( "collision_physics_256x256x10" );
+	precachemodel( "collision_physics_128x128x10" );
+	precachemodel( "collision_physics_64x64x10" );
+	precachemodel( "p6_mag_k_rail_barrier" );
+	precachemodel( "p6_mag_rocks_medium_02" );
+	maps/mp/_load::main();
+	maps/mp/mp_magma_amb::main();
+	maps/mp/_compass::setupminimap( "compass_map_mp_magma" );
+	setdvar( "compassmaxrange", "2100" );
+	game[ "strings" ][ "war_callsign_a" ] = &"MPUI_CALLSIGN_MAPNAME_A";
+	game[ "strings" ][ "war_callsign_b" ] = &"MPUI_CALLSIGN_MAPNAME_B";
+	game[ "strings" ][ "war_callsign_c" ] = &"MPUI_CALLSIGN_MAPNAME_C";
+	game[ "strings" ][ "war_callsign_d" ] = &"MPUI_CALLSIGN_MAPNAME_D";
+	game[ "strings" ][ "war_callsign_e" ] = &"MPUI_CALLSIGN_MAPNAME_E";
+	game[ "strings_menu" ][ "war_callsign_a" ] = "@MPUI_CALLSIGN_MAPNAME_A";
+	game[ "strings_menu" ][ "war_callsign_b" ] = "@MPUI_CALLSIGN_MAPNAME_B";
+	game[ "strings_menu" ][ "war_callsign_c" ] = "@MPUI_CALLSIGN_MAPNAME_C";
+	game[ "strings_menu" ][ "war_callsign_d" ] = "@MPUI_CALLSIGN_MAPNAME_D";
+	game[ "strings_menu" ][ "war_callsign_e" ] = "@MPUI_CALLSIGN_MAPNAME_E";
+	barrier1 = spawn( "script_model", ( 235,49, 907,91, -395,97 ) );
+	barrier1.angles = ( 2,96968, 263,594, -1,33952 );
+	barrier2 = spawn( "script_model", ( 245,37, 837,028, -401,885 ) );
+	barrier2.angles = ( 6,5989, 268,994, -0,115603 );
+	barrier1 setmodel( "p6_mag_k_rail_barrier" );
+	barrier2 setmodel( "p6_mag_k_rail_barrier" );
+	rock1 = spawn( "script_model", ( 271,92, 893,99, -494 ) );
+	rock1.angles = vectorScale( ( 1, 0, 0 ), 132 );
+	rock2 = spawn( "script_model", ( 393,42, 895,49, -494 ) );
+	rock2.angles = vectorScale( ( 1, 0, 0 ), 132 );
+	rock3 = spawn( "script_model", ( 477,92, 882,49, -509 ) );
+	rock3.angles = vectorScale( ( 1, 0, 0 ), 132 );
+	rock1 setmodel( "p6_mag_rocks_medium_02" );
+	rock2 setmodel( "p6_mag_rocks_medium_02" );
+	rock3 setmodel( "p6_mag_rocks_medium_02" );
+	spawncollision( "collision_clip_64x64x10", "collider", ( 234, 907, -391,5 ), ( 356,785, 83,5728, -83,5116 ) );
+	spawncollision( "collision_clip_64x64x10", "collider", ( 243,5, 835,5, -399 ), ( 353,903, 88,8464, -83,1852 ) );
+	spawncollision( "collision_clip_64x64x10", "collider", ( 254, 902,5, -395 ), ( 0,42985, 353,514, 3,77564 ) );
+	spawncollision( "collision_clip_64x64x10", "collider", ( 264, 835,5, -401,5 ), ( 0,0466956, 359,602, 6,69984 ) );
+	spawncollision( "collision_clip_64x64x10", "collider", ( 247,5, 831,5, -363 ), ( 353,903, 88,8464, -83,1852 ) );
+	spawncollision( "collision_clip_64x64x10", "collider", ( 237,5, 904,5, -357,5 ), ( 356,785, 83,5728, -83,5116 ) );
+	spawncollision( "collision_physics_64x64x10", "collider", ( 234, 907, -391,5 ), ( 356,785, 83,5728, -83,5116 ) );
+	spawncollision( "collision_physics_64x64x10", "collider", ( 243,5, 835,5, -399 ), ( 353,903, 88,8464, -83,1852 ) );
+	spawncollision( "collision_physics_256x256x10", "collider", ( -459, 357,5, -578,5 ), ( 270, 183,902, 86,0983 ) );
+	spawncollision( "collision_physics_128x128x10", "collider", ( -267, 233,5, -514 ), vectorScale( ( 1, 0, 0 ), 270 ) );
+	spawncollision( "collision_physics_128x128x10", "collider", ( -669,5, 216, -514 ), vectorScale( ( 1, 0, 0 ), 270 ) );
+	spawncollision( "collision_physics_64x64x10", "collider", ( -748, 95, -483,5 ), ( 270, 270,2, 1,43 ) );
+	level.levelkillbrushes = [];
+	maps/mp/gametypes/_spawning::level_use_unified_spawning( 1 );
+	level.remotemotarviewup = 20;
+	registerclientfield( "scriptmover", "police_car_lights", 1, 1, "int" );
+	precacheitem( "lava_mp" );
+	level thread destructible_lights();
+	level.overrideweaponfunc = ::overrideweaponfunc;
+	level.deleteonkillbrushoverride = ::deleteonkillbrushoverride;
+	level thread lava_trigger_init();
+	level.onplayerkilledextraunthreadedcbs[ level.onplayerkilledextraunthreadedcbs.size ] = ::checkcorpseinlava;
+}
+
+lava_trigger_init()
+{
+	wait 3;
+	killbrushes = getentarray( "trigger_hurt", "classname" );
+	i = 0;
+	while ( i < killbrushes.size )
+	{
+		if ( isDefined( killbrushes[ i ].script_noteworthy ) && killbrushes[ i ].script_noteworthy == "lava" )
+		{
+			level.levelkillbrushes[ level.levelkillbrushes.size ] = killbrushes[ i ];
+		}
+		i++;
+	}
+}
+
+levelspawndvars( reset_dvars )
+{
+	ss = level.spawnsystem;
+	ss.enemy_influencer_radius = set_dvar_float_if_unset( "scr_spawn_enemy_influencer_radius", "2600", reset_dvars );
+}
+
+overrideweaponfunc( sweapon, script_noteworthy )
+{
+	if ( isDefined( script_noteworthy ) && script_noteworthy == "lava" )
+	{
+		sweapon = "lava_mp";
+	}
+	return sweapon;
+}
+
+destructible_lights()
+{
+	wait 0,05;
+	destructibles = getentarray( "destructible", "targetname" );
+	_a150 = destructibles;
+	_k150 = getFirstArrayKey( _a150 );
+	while ( isDefined( _k150 ) )
+	{
+		destructible = _a150[ _k150 ];
+		if ( destructible.destructibledef == "veh_t6_dlc_police_car_jp_destructible" )
+		{
+			destructible thread destructible_think( "police_car_lights" );
+			destructible setclientfield( "police_car_lights", 1 );
+		}
+		_k150 = getNextArrayKey( _a150, _k150 );
+	}
+}
+
+destructible_think( clientfield )
+{
+	self waittill_any( "death", "destructible_base_piece_death" );
+	self setclientfield( clientfield, 0 );
+}
+
+checkcorpseinlava( einflictor, attacker, idamage, smeansofdeath, sweapon, vdir, shitloc, psoffsettime, deathanimduration )
+{
+	if ( !isDefined( einflictor ) || !isDefined( einflictor.script_noteworthy ) )
+	{
+		return;
+	}
+	if ( einflictor.script_noteworthy != "lava" )
+	{
+		return;
+	}
+	if ( !isDefined( self.body ) )
+	{
+		return;
+	}
+	playfxontag( level._effect[ "fx_fire_torso" ], self.body, "J_Spine4" );
+	playfxontag( level._effect[ "fx_fire_arm_left" ], self.body, "J_Elbow_LE" );
+	playfxontag( level._effect[ "fx_fire_arm_right" ], self.body, "J_Elbow_RI" );
+	playfxontag( level._effect[ "fx_fire_leg_left" ], self.body, "J_Hip_LE" );
+	playfxontag( level._effect[ "fx_fire_leg_right" ], self.body, "J_Hip_RI" );
+}
+
+leveloverridetime( defaulttime )
+{
+	if ( self isinlava() )
+	{
+		return getdvarfloatdefault( "scr_lavaPlayerDeathWatchTime", 0,5 );
+	}
+	return defaulttime;
+}
+
+isinlava()
+{
+	if ( !isDefined( self.lastattacker ) || !isDefined( self.lastattacker.script_noteworthy ) )
+	{
+		return 0;
+	}
+	if ( self.lastattacker.script_noteworthy != "lava" )
+	{
+		return 0;
+	}
+	return 1;
+}
+
+testkillbrushonstationary( lavaarray, killbrusharray, player, watcher )
+{
+	player endon( "disconnect" );
+	self endon( "death" );
+	self waittill( "stationary" );
+	wait 0,1;
+	i = 0;
+	while ( i < lavaarray.size )
+	{
+		if ( self istouching( lavaarray[ i ] ) )
+		{
+			playfx( level._effect[ "fx_fire_torso" ], self.origin );
+			watcher maps/mp/gametypes/_weaponobjects::waitanddetonate( self, 0, undefined, "lava_mp" );
+			return;
+		}
+		i++;
+	}
+	i = 0;
+	while ( i < killbrusharray.size )
+	{
+		if ( self istouching( killbrusharray[ i ] ) )
+		{
+			if ( self.origin[ 2 ] > player.origin[ 2 ] )
+			{
+				return;
+			}
+			else
+			{
+				if ( isDefined( self ) )
+				{
+					self delete();
+				}
+				return;
+			}
+			i++;
+		}
+	}
+}
+
+deleteonkillbrushoverride( player, watcher )
+{
+	player endon( "disconnect" );
+	self endon( "death" );
+	self endon( "stationary" );
+	trigger_hurtarray = getentarray( "trigger_hurt", "classname" );
+	lavaarray = [];
+	killbrusharray = [];
+	i = 0;
+	while ( i < trigger_hurtarray.size )
+	{
+		if ( isDefined( trigger_hurtarray[ i ].script_noteworthy ) && trigger_hurtarray[ i ].script_noteworthy == "lava" )
+		{
+			lavaarray[ lavaarray.size ] = trigger_hurtarray[ i ];
+			i++;
+			continue;
+		}
+		else
+		{
+			killbrusharray[ killbrusharray.size ] = trigger_hurtarray[ i ];
+		}
+		i++;
+	}
+	if ( lavaarray.size < 1 )
+	{
+		return;
+	}
+	self thread testkillbrushonstationary( lavaarray, killbrusharray, player, watcher );
+	while ( 1 )
+	{
+		i = 0;
+		while ( i < lavaarray.size )
+		{
+			if ( self istouching( lavaarray[ i ] ) )
+			{
+				wait 0,05;
+				playfx( level._effect[ "fx_fire_torso" ], self.origin );
+				watcher maps/mp/gametypes/_weaponobjects::waitanddetonate( self, 0, undefined, "lava_mp" );
+				return;
+			}
+			i++;
+		}
+		i = 0;
+		while ( i < killbrusharray.size )
+		{
+			if ( self istouching( killbrusharray[ i ] ) )
+			{
+				if ( self.origin[ 2 ] > player.origin[ 2 ] )
+				{
+					break;
+				}
+				else
+				{
+					if ( isDefined( self ) )
+					{
+						self delete();
+					}
+					return;
+				}
+				i++;
+			}
+		}
+		wait 0,1;
+	}
+}
+
+spawnkilltrigger()
+{
+	trigger = spawn( "trigger_radius", ( 2132, -1692, -708 ), 0, 250, 100 );
+	while ( 1 )
+	{
+		trigger waittill( "trigger", player );
+		player dodamage( player.health * 2, trigger.origin, trigger, trigger, "none", "MOD_SUICIDE", 0, "lava_mp" );
+	}
+}

patch_mp/maps/mp/mp_meltdown.gsc

@@ -0,0 +1,39 @@
+#include maps/mp/_compass;
+#include maps/mp/_utility;
+
+main()
+{
+	level.levelspawndvars = ::levelspawndvars;
+	maps/mp/mp_meltdown_fx::main();
+	precachemodel( "collision_physics_128x128x128" );
+	precachemodel( "collision_physics_wall_256x256x10" );
+	precachemodel( "collision_clip_wall_32x32x10" );
+	precachemodel( "collision_clip_wall_64x64x10" );
+	precachemodel( "collision_clip_64x64x10" );
+	precachemodel( "collision_clip_wall_128x128x10" );
+	precachemodel( "collision_physics_wall_64x64x10" );
+	precachemodel( "collision_clip_32x32x32" );
+	maps/mp/_load::main();
+	maps/mp/mp_meltdown_amb::main();
+	spawncollision( "collision_physics_128x128x128", "collider", ( 224, 4558,5, -117,5 ), ( 0, 0, 0 ) );
+	spawncollision( "collision_physics_wall_256x256x10", "collider", ( 216,5, 4526,5, -86 ), vectorScale( ( 0, 0, 0 ), 270 ) );
+	spawncollision( "collision_clip_wall_32x32x10", "collider", ( 486, 3219,5, -53 ), vectorScale( ( 0, 0, 0 ), 288,2 ) );
+	spawncollision( "collision_clip_wall_64x64x10", "collider", ( 505,5, 3197, -56,5 ), vectorScale( ( 0, 0, 0 ), 133,1 ) );
+	spawncollision( "collision_clip_wall_64x64x10", "collider", ( 545, 3181,5, -72,5 ), vectorScale( ( 0, 0, 0 ), 180,4 ) );
+	spawncollision( "collision_clip_wall_64x64x10", "collider", ( 582, 3194, -56,5 ), vectorScale( ( 0, 0, 0 ), 223,1 ) );
+	spawncollision( "collision_clip_wall_32x32x10", "collider", ( 602,5, 3221,5, -54 ), vectorScale( ( 0, 0, 0 ), 254,2 ) );
+	spawncollision( "collision_clip_64x64x10", "collider", ( 348,5, 615, 24 ), vectorScale( ( 0, 0, 0 ), 90 ) );
+	spawncollision( "collision_clip_wall_64x64x10", "collider", ( 1005,5, 1466, 173 ), vectorScale( ( 0, 0, 0 ), 270 ) );
+	spawncollision( "collision_clip_wall_128x128x10", "collider", ( 808, -1434,5, -120 ), ( 0, 0, 0 ) );
+	spawncollision( "collision_physics_wall_64x64x10", "collider", ( 1266, 1873,5, 86 ), vectorScale( ( 0, 0, 0 ), 35 ) );
+	spawncollision( "collision_physics_wall_64x64x10", "collider", ( 1266, 1873,5, 126 ), vectorScale( ( 0, 0, 0 ), 35 ) );
+	spawncollision( "collision_physics_32x32x32", "collider", ( 1183, 1927, 73 ), ( 0, 0, 0 ) );
+	spawncollision( "collision_physics_32x32x32", "collider", ( 555,5, 2976, -47,5 ), ( 0, 0, 0 ) );
+	maps/mp/_compass::setupminimap( "compass_map_mp_meltdown" );
+}
+
+levelspawndvars( reset_dvars )
+{
+	ss = level.spawnsystem;
+	ss.enemy_influencer_radius = set_dvar_float_if_unset( "scr_spawn_enemy_influencer_radius", "2100", reset_dvars );
+}