Initial commit of IW4x rawfiles as of IW4x version 0.6.1

iw4x/iw4x_00/maps/mp/_explosive_barrels.gsc

@@ -0,0 +1,402 @@
+main()
+{
+	//------------------
+	//EFECTS DEFINITIONS
+	//------------------
+	
+		qBarrels = false;
+		precacheItem( "barrel_mp" );
+		barrels = getentarray ("explodable_barrel","targetname");
+		if ( (isdefined(barrels)) && (barrels.size > 0) )
+			qBarrels = true;
+		barrels = getentarray ("explodable_barrel","script_noteworthy");
+		if ( (isdefined(barrels)) && (barrels.size > 0) )
+			qBarrels = true;
+		if (qBarrels)
+		{
+			level.breakables_fx["barrel"]["explode"] 	= loadfx ("props/barrelExp");
+			level.breakables_fx["barrel"]["burn_start"]	= loadfx ("props/barrel_ignite");
+			level.breakables_fx["barrel"]["burn"]	 	= loadfx ("props/barrel_fire_top");
+		}
+		oilspill = getentarray ("oil_spill","targetname");
+		if(isdefined(oilspill) && oilspill.size > 0)
+		{
+			level.breakables_fx["oilspill"]["burn"]		= loadfx ("props/barrel_fire");	
+			level.breakables_fx["oilspill"]["spark"]	= loadfx("impacts/small_metalhit_1"); 
+		}
+		
+	//------------------
+	//------------------
+	
+	
+	//-----------------
+	//SOUND DEFINITIONS
+	//-----------------
+		level.barrelExpSound = "explo_metal_rand";
+	//-----------------
+	//-----------------
+	
+		
+		level.barrelHealth = 150;
+		maxBrokenPieces = 25;
+	//-------------
+	//-------------
+	
+	level.precachemodeltype = [];
+	level.barrelExplodingThisFrame = false;
+	level.breakables_clip = [];
+	
+	temp = getentarray ("breakable clip","targetname");
+	for (i=0;i<temp.size;i++)
+		level.breakables_clip[level.breakables_clip.size] = temp[i];
+	level._breakable_utility_modelarray = [];
+	level._breakable_utility_modelindex = 0;
+	level._breakable_utility_maxnum = maxBrokenPieces;
+	common_scripts\utility::array_thread(getentarray ("explodable_barrel","targetname"), ::explodable_barrel_think);
+	//common_scripts\utility::array_thread(getentarray ("explodable_barrel","script_noteworthy"), ::explodable_barrel_think); ASK MO
+	common_scripts\utility::array_thread(getentarray ("oil_spill", "targetname"), ::oil_spill_think);
+}
+
+oil_spill_think()
+{
+	self.end = getstruct(self.target, "targetname");
+	self.start = getstruct(self.end.target, "targetname");
+	self.barrel = getClosestEnt(self.start.origin, getentarray ("explodable_barrel","targetname"));
+	self.extra = getent(self.target, "targetname");
+	self setcandamage(true);
+	
+	if(isdefined(self.barrel))
+	{
+		self.barrel.oilspill = true;
+		self thread oil_spill_burn_after();
+	}
+	
+	while(1)
+	{
+		self waittill("damage", other, damage, direction_vec, P, type );
+		if(type == "MOD_MELEE" || type == "MOD_IMPACT")
+			continue;
+		
+		self.damageOwner = other;
+		
+		playfx (level.breakables_fx["oilspill"]["spark"], P, direction_vec);
+		//P = pointOnSegmentNearestToPoint(self.start.origin, self.end.origin, P);
+		thread oil_spill_burn_section(P);
+		self thread oil_spill_burn(P, self.start.origin);
+		self thread oil_spill_burn(P, self.end.origin);
+		break;
+	}
+	if(isdefined(self.barrel))
+		self.barrel waittill("exploding");
+	
+	self.extra delete();
+	self hide();
+	
+	wait 10;
+	self delete();
+}
+
+getClosestEnt(org, array)
+{
+	if (array.size < 1)
+		return;
+		
+//	dist = distance(array[0] getorigin(), org);
+//	ent = array[0];
+	dist = 256;
+	ent = undefined;
+	for (i=0;i<array.size;i++)
+	{
+		newdist = distance(array[i] getorigin(), org);
+		if (newdist >= dist)
+			continue;
+		dist = newdist;
+		ent = array[i];
+	}
+	return ent;
+}
+
+oil_spill_burn_after()
+{
+	while(1)
+	{
+		self.barrel waittill("damage", amount ,attacker, direction_vec, P, type);
+		if(type == "MOD_MELEE" || type == "MOD_IMPACT")
+			continue;
+		break;
+	}
+	self.damageOwner = attacker;
+	
+	// do not pass damage owner if they have disconnected before the barrels explode
+	if ( !isdefined( self.damageOwner ) ) 
+		self radiusdamage (self.origin, 4, 10, 10 );
+	else
+		self radiusdamage (self.origin, 4, 10, 10, self.damageOwner);
+}
+
+oil_spill_burn(P, dest)
+{
+	
+	forward = vectornormalize(dest - P);
+	dist = distance(p, dest);
+	range = 8;
+	interval = common_scripts\utility::vector_multiply(forward, range);	
+	angle = vectortoangles(forward);
+	right = anglestoright(angle);
+	
+	barrels = getentarray ("explodable_barrel","targetname");
+	distsqr = 22 * 22;
+	
+	test = spawn("script_origin", P);
+	test hide();
+	
+	num = 0;
+	while(1)
+	{
+		dist -= range;
+		if(dist < range *.1)
+			break;
+			
+		p += (interval + common_scripts\utility::vector_multiply(right, randomfloatrange(-6, 6)));		
+		
+		thread oil_spill_burn_section(P);
+		num++;
+		if(num == 4)
+		{
+			num = 0;
+		}
+		
+		test.origin = P;
+		
+		remove = [];
+		barrels = common_scripts\utility::array_removeUndefined(barrels);
+		for(i=0; i<barrels.size; i++)
+		{
+			vec = anglestoup(barrels[i].angles);
+			start = barrels[i].origin + (common_scripts\utility::vector_multiply(vec, 22));
+			pos = physicstrace(start, start + (0,0,-64));
+			
+			if(distancesquared(P, pos) < distsqr) 
+			{
+				remove[remove.size] = barrels[i];
+				d = (80 + randomfloat(10));
+				
+				if ( !isdefined ( self.damageOwner ) )
+					self radiusdamage (barrels[i].origin, 4, d, d);
+				else
+					self radiusdamage (barrels[i].origin, 4, d, d, self.damageOwner);
+				//barrels[i] dodamage(  , P);
+			}
+		}
+		for(i=0; i<remove.size; i++)
+			barrels = common_scripts\utility::array_remove(barrels, remove[i]);	
+		wait .1;
+	}		
+	
+	if(!isdefined(self.barrel))
+		return;
+	if( distance(P, self.start.origin) < 32)
+	{
+		d = (80 + randomfloat(10));
+		if ( !isdefined ( self.damageOwner ) )
+			self radiusdamage (self.barrel.origin, 4, d, d);
+		else
+			self radiusdamage (self.barrel.origin, 4, d, d, self.damageOwner);
+	}
+}
+
+oil_spill_burn_section(P)
+{
+	count = 0;
+	time = 0;
+	playfx (level.breakables_fx["oilspill"]["burn"], P);
+	
+	while(time < 5)
+	{
+		if ( !isdefined ( self.damageOwner ) )
+			self radiusdamage(P, 32, 5, 1);
+		else
+			self radiusdamage(P, 32, 5, 1, self.damageOwner);
+		time += 1;
+		wait 1;
+	}
+}
+
+explodable_barrel_think()
+{	
+	if (self.classname != "script_model")
+		return;
+//	if ( (self.model != "com_barrel_benzin") && (self.model != "com_barrel_benzin_snow") )
+//		return;
+	if(!isdefined(level.precachemodeltype["com_barrel_benzin"]))
+	{
+		level.precachemodeltype["com_barrel_benzin"] = true;
+		precacheModel("com_barrel_piece");
+		precacheModel("com_barrel_piece2");	
+	}
+	self endon ("exploding");
+	
+	self breakable_clip();
+	self.damageTaken = 0;
+	self setcandamage(true);
+	for (;;)
+	{
+		self waittill("damage", amount ,attacker, direction_vec, P, type);
+		if(type == "MOD_MELEE" || type == "MOD_IMPACT")
+			continue;
+		
+		self.damagetype = type;
+		
+		self.damageOwner = attacker;
+			
+		if (level.barrelExplodingThisFrame)
+			wait randomfloat(1);
+		self.damageTaken += amount;
+		if (self.damageTaken == amount)
+			self thread explodable_barrel_burn();
+	}
+}
+
+explodable_barrel_burn()
+{
+	count = 0;
+	startedfx = false;
+	
+	up = anglestoup(self.angles);
+	worldup = anglestoup((0,90,0));
+	dot = vectordot(up, worldup);
+	
+	offset1 = (0,0,0);
+	offset2 =  common_scripts\utility::vector_multiply(up, 44);
+	
+	if(dot < .5)
+	{
+		offset1 = common_scripts\utility::vector_multiply(up, 22) - (0,0,30);
+		offset2 = common_scripts\utility::vector_multiply(up, 22) + (0,0,14);	
+	}
+	
+	if( self.damagetype != "MOD_GRENADE_SPLASH" && self.damagetype != "MOD_GRENADE" )
+	{
+		while (self.damageTaken < level.barrelHealth)
+		{
+			if (!startedfx)
+			{
+				playfx (level.breakables_fx["barrel"]["burn_start"], self.origin + offset1);
+				startedfx = true;
+			}
+			if (count > 20)
+				count = 0;
+			
+			playfx (level.breakables_fx["barrel"]["burn"], self.origin + offset2);
+			
+			if (count == 0)
+			{
+				self.damageTaken += (10 + randomfloat(10));
+			}
+			count++;
+			wait 0.05;
+		}
+	}
+	self thread explodable_barrel_explode();
+}
+
+explodable_barrel_explode()
+{
+	self notify ("exploding");
+	self notify ("death");
+
+	up = anglestoup(self.angles);
+	worldup = anglestoup((0,90,0));
+	dot = vectordot(up, worldup);
+	
+	offset = (0,0,0);
+	if(dot < .5)
+	{
+		start = (self.origin + common_scripts\utility::vector_multiply(up, 22));
+		end  = physicstrace(start, (start + (0,0,-64)));
+		offset = end - self.origin;
+	}
+	offset += (0,0,4);
+	
+	self playsound (level.barrelExpSound);
+	//level thread play_sound_in_space(level.barrelExpSound, self.origin);
+	playfx (level.breakables_fx["barrel"]["explode"], self.origin + offset);
+	
+	level.barrelExplodingThisFrame = true;
+	
+	if (isdefined (self.remove))
+	{
+		self.remove delete();
+	}
+	
+	phyExpMagnitude = 2;
+	minDamage = 1;
+	maxDamage = 250;
+	blastRadius = 250;
+	if (isdefined(self.radius))
+		blastRadius = self.radius;
+	
+	// do not pass damage owner if they have disconnected before the barrels explode
+	if ( !isdefined( self.damageOwner ) ) 
+		self radiusDamage(self.origin + (0,0,30), blastRadius, maxDamage, minDamage, undefined, "MOD_EXPLOSIVE", "barrel_mp");
+	else
+		self radiusDamage(self.origin + (0,0,30), blastRadius, maxDamage, minDamage, self.damageOwner, "MOD_EXPLOSIVE", "barrel_mp" );
+		
+	physicsExplosionSphere( self.origin + (0,0,30), blastRadius, blastRadius/2, phyExpMagnitude );
+	
+	self maps\mp\gametypes\_shellshock::barrel_earthQuake();
+		
+	if (randomint(2) == 0)
+		self setModel("com_barrel_piece");
+	else
+		self setModel("com_barrel_piece2");
+	self setCanDamage( false );
+	
+	if(dot < .5)
+	{
+		start = (self.origin + common_scripts\utility::vector_multiply(up, 22));
+		pos = physicstrace(start, (start + (0,0,-64)));
+		
+		self.origin = pos;
+		self.angles += (0,0,90);
+			
+	}
+	wait 0.05;
+	level.barrelExplodingThisFrame = false;
+}
+
+getstruct(name, type)
+{
+	if(!isdefined(level.struct_class_names))
+		return undefined;
+	
+	array = level.struct_class_names[type][name];
+	if(!isdefined(array))
+		return undefined;
+	if(array.size > 1)
+	{
+		assertMsg ("getstruct used for more than one struct of type " + type + " called " + name +".");
+		return undefined;
+	}
+	return array[0];
+}
+
+breakable_clip()
+{
+	//targeted brushmodels take priority over proximity based breakables - nate
+	if (isdefined(self.target))
+	{
+		targ = getent(self.target,"targetname");
+		if(targ.classname == "script_brushmodel")
+		{
+			self.remove = targ;
+			return;
+		}
+	}
+	//setup it's removable clip part
+	if ((isdefined (level.breakables_clip)) && (level.breakables_clip.size > 0))
+		self.remove = getClosestEnt( self.origin , level.breakables_clip );
+	if (isdefined (self.remove))
+		level.breakables_clip = common_scripts\utility::array_remove ( level.breakables_clip , self.remove );
+}
+

iw4x/iw4x_00/maps/mp/co_hunted.gsc

@@ -0,0 +1,37 @@
+/******************************************************/
+/*         Map by momo5502, xetal & Dasfonia          */
+/******************************************************/
+
+
+#include common_scripts\utility;
+#include maps\mp\_utility;
+#include maps\mp\gametypes\_hud_util;
+ 
+main()
+{
+	SetDvarIfUninitialized( "hunted_weather", 2 ); // 0 = Fog | 1 = Rain | 2 = Dynamic weather
+	
+	level.hunted_weather = GetDvarInt( "hunted_weather" );
+		
+	if( level.hunted_weather < 0 || level.hunted_weather > 2 )
+		level.hunted_weather = ( randomint( 65534 ) % 3 );
+
+    maps\mp\_load::main();
+	maps\createart\co_hunted_art::main();
+	maps\mp\co_hunted_fx::main();
+	maps\mp\hunted_precache::main();
+	
+    game[ "attackers" ] = "allies";
+    game[ "defenders" ] = "axis";
+	
+    maps\mp\_compass::setupMiniMap( "compass_map_hunted" );		
+    setdvar( "compassmaxrange", "3000" );
+	
+	if( level.hunted_weather == 0 )
+		ambientPlay( "ambient_mp_rural", 0 );
+		
+	else if( level.hunted_weather == 1 )
+		ambientPlay( "ambient_mp_rain", 0 );
+	
+	level notify("village_start_weather");
+}

iw4x/iw4x_00/maps/mp/co_hunted_fx.gsc

@@ -0,0 +1,92 @@
+#include common_scripts\utility;
+#include maps\mp\_utility;
+
+main()
+{
+	//level._effect["firelp_vhc_lrg_pm_farview"]		= loadfx ("fire/firelp_vhc_lrg_pm_farview");
+	//level._effect["lighthaze"]						= loadfx ("misc/lighthaze"); 
+	level._effect[ "firelp_med_pm" ]					 = loadfx( "fire/firelp_med_pm" );
+	level._effect[ "firelp_small_pm" ]				 = loadfx( "fire/firelp_small_pm" );
+	level._effect[ "firelp_small_pm_a" ]				 = loadfx( "fire/firelp_small_pm_a" );
+	level._effect[ "fog_hunted" ]						 = loadfx( "weather/fog_hunted" );
+	level._effect[ "fog_hunted_a" ]					 = loadfx( "weather/fog_hunted_a" );
+	level._effect[ "bird_pm" ]						 = loadfx( "misc/bird_pm" );
+	level._effect[ "bird_takeoff_pm" ]				 = loadfx( "misc/bird_takeoff_pm" );
+	level._effect[ "leaves" ]							 = loadfx( "misc/leaves" );
+	level._effect[ "leaves_runner" ]					 = loadfx( "misc/leaves_runner" );
+	level._effect[ "leaves_runner_1" ]				 = loadfx( "misc/leaves_runner_1" );
+	level._effect[ "leaves_lp" ]						 = loadfx( "misc/leaves_lp" );
+	level._effect[ "leaves_gl" ]						 = loadfx( "misc/leaves_gl" );
+	level._effect[ "leaves_gl_a" ]					 = loadfx( "misc/leaves_gl_a" );
+	level._effect[ "leaves_gl_b" ]					 = loadfx( "misc/leaves_gl_b" );
+	level._effect[ "hunted_vl" ]						 = loadfx( "misc/hunted_vl" );
+	level._effect[ "hunted_vl_sm" ]					 = loadfx( "misc/hunted_vl_sm" );
+	level._effect[ "hunted_vl_od_lrg" ]				 = loadfx( "misc/hunted_vl_od_lrg" );
+	level._effect[ "hunted_vl_od_lrg_a" ]				 = loadfx( "misc/hunted_vl_od_lrg_a" );
+	level._effect[ "hunted_vl_od_sml" ]				 = loadfx( "misc/hunted_vl_od_sml" );
+	level._effect[ "hunted_vl_od_sml_a" ]				 = loadfx( "misc/hunted_vl_od_sml_a" );
+	level._effect[ "hunted_vl_od_dtl_a" ]				 = loadfx( "misc/hunted_vl_od_dtl_a" );
+	level._effect[ "hunted_vl_od_dtl_b" ]				 = loadfx( "misc/hunted_vl_od_dtl_b" );
+	level._effect[ "mist_hunted_add" ]				 = loadfx( "weather/mist_hunted_add" );
+	level._effect[ "insects_light_hunted" ]			 = loadfx( "misc/insects_light_hunted" );
+	level._effect[ "insects_light_hunted_a" ]			 = loadfx( "misc/insects_light_hunted_a" );
+	level._effect[ "hunted_vl_white_eql" ]			 = loadfx( "misc/hunted_vl_white_eql" );
+//	level._effect["hunted_vl_white_eql_flare"]		= loadfx ("misc/hunted_vl_white_eql_flare");
+	level._effect[ "hunted_vl_white_eql_a" ]			 = loadfx( "misc/hunted_vl_white_eql_a" );
+//	level._effect["grenadeexp_fuel"]				= loadfx ("explosions/grenadeexp_fuel");
+//	level._effect["hunted_fel"]						= loadfx ("misc/hunted_fel");	
+	level._effect[ "greenhouse_fog_spot_lit" ]		 = loadfx( "smoke/greenhouse_fog_spot_lit" );
+	level._effect[ "waterfall_hunted" ]				 = loadfx( "misc/waterfall_hunted" );
+	level._effect[ "stream_hunted" ]					 = loadfx( "misc/stream_hunted" );
+
+	//footstep fx
+	
+	setFootstepEffect( "asphalt", 		loadfx( "impacts/footstep_dust_dark" ) );
+	setFootstepEffect( "brick", 		loadfx( "impacts/footstep_dust_dark" ) );
+	setFootstepEffect( "carpet", 		loadfx( "impacts/footstep_dust_dark" ) );
+	setFootstepEffect( "cloth", 		loadfx( "impacts/footstep_dust_dark" ) );
+	setFootstepEffect( "concrete", 		loadfx( "impacts/footstep_dust_dark" ) );
+	setFootstepEffect( "dirt", 			loadfx( "impacts/footstep_dust_dark" ) );
+	setFootstepEffect( "foliage", 		loadfx( "impacts/footstep_dust_dark" ) );
+	setFootstepEffect( "grass", 		loadfx( "impacts/footstep_dust_dark" ) );
+	setFootstepEffect( "metal", 		loadfx( "impacts/footstep_dust_dark" ) );
+	setFootstepEffect( "mud", 			loadfx( "impacts/footstep_mud_dark" ) );
+	setFootstepEffect( "rock", 			loadfx( "impacts/footstep_dust_dark" ) );
+	setFootstepEffect( "sand", 			loadfx( "impacts/footstep_dust_dark" ) );
+	setFootstepEffect( "water", 		loadfx( "impacts/footstep_water_dark" ) );
+	setFootstepEffect( "wood", 			loadfx( "impacts/footstep_dust_dark" ) );
+
+	//Rain Fx :D
+	level._effect[ "rain_mp_storm" ]						= loadfx( "weather/rain_mp_storm" );
+	level._effect[ "rain_noise_splashes" ]					= loadfx( "weather/rain_noise_splashes" );
+	level._effect[ "rain_splash_lite_128x128" ]				= loadfx( "weather/rain_splash_lite_128x128" );
+	level._effect[ "drips_fast" ]							= loadfx( "misc/drips_fast" );
+	level._effect[ "lightning" ]							= loadfx( "weather/lightning_mp_storm" );
+	level._effect[ "waterfall_drainage_mp" ] 				= loadfx( "water/waterfall_drainage_mp" );
+	level._effect[ "waterfall_drainage_splash_mp" ] 		= loadfx( "water/waterfall_drainage_splash_mp" );
+	
+	maps\createfx\co_hunted_fx::main();
+}
+
+setFootstepEffect( name, fx )
+{
+	assertEx( isdefined( name ), "Need to define the footstep surface type." );
+	assertEx( isdefined( fx ), "Need to define the mud footstep effect." );
+	if( !isdefined( anim.optionalStepEffects ) )
+		anim.optionalStepEffects = [];
+	anim.optionalStepEffects[ anim.optionalStepEffects.size ] = name;
+	level._effect[ "step_" + name ] = fx;
+	anim.optionalStepEffectFunction = playFootStepEffect();
+}
+
+playFootStepEffect(foot, groundType)
+{
+	for (i=0;i<anim.optionalStepEffects.size;i++)
+	{
+		if (groundType != anim.optionalStepEffects[i])
+			continue;
+		org = self gettagorigin(foot);
+		playfx(level._effect["step_" + anim.optionalStepEffects[i]], org, org + (0,0,100));
+		return;
+	}
+}

iw4x/iw4x_00/maps/mp/gametypes/_globallogic.gsc

@@ -0,0 +1,261 @@
+#include maps\mp\_utility;
+#include maps\mp\gametypes\_hud_util;
+#include common_scripts\utility;
+
+init()
+{
+	level.splitscreen = isSplitScreen();
+	level.ps3 = (getDvar( "ps3Game" ) == "true");
+	level.xenon = (getDvar( "xenonGame" ) == "true");
+	level.console = (level.ps3 || level.xenon);
+
+	level.onlineGame = getDvarInt( "onlinegame" );
+
+	//level.rankedMatch = ( level.onlineGame );
+	setDvarIfUninitialized ("scr_classic", 0);
+	setDvarIfUninitialized ("scr_rankedmatch", 1);
+	level.rankedMatch = ((getDvarInt( "scr_rankedmatch" ) == 1) && level.onlineGame);
+	
+	/#
+	if ( getdvarint( "scr_forcerankedmatch" ) == 1 )
+	{
+		level.onlineGame = true;
+		level.rankedMatch = true;
+	}
+	#/
+
+	level.script = toLower( getDvar( "mapname" ) );
+	level.gametype = toLower( getDvar( "g_gametype" ) );
+
+	level.otherTeam["allies"] = "axis";
+	level.otherTeam["axis"] = "allies";
+
+	level.teamBased = false;
+	
+	level.objectiveBased = false;
+	
+	level.endGameOnTimeLimit = true;
+	
+	level.showingFinalKillcam = false;
+	
+	level.tiSpawnDelay = getDvarInt( "scr_tispawndelay" );
+	
+	// hack to allow maps with no scripts to run correctly
+	if ( !isDefined( level.tweakablesInitialized ) )
+		maps\mp\gametypes\_tweakables::init();
+	
+	precacheString( &"MP_HALFTIME" );
+	precacheString( &"MP_OVERTIME" );
+	precacheString( &"MP_ROUNDEND" );
+	precacheString( &"MP_INTERMISSION" );
+	precacheString( &"MP_SWITCHING_SIDES" );
+	precacheString( &"MP_FRIENDLY_FIRE_WILL_NOT" );
+	precacheString( &"PLATFORM_REVIVE" );
+	
+	precacheString( &"MP_OBITUARY_NEUTRAL" );
+	precacheString( &"MP_OBITUARY_FRIENDLY" );
+	precacheString( &"MP_OBITUARY_ENEMY" );
+
+	if ( level.splitScreen )
+		precacheString( &"MP_ENDED_GAME" );
+	else
+		precacheString( &"MP_HOST_ENDED_GAME" );
+	
+	level.halftimeType = "halftime";
+	level.halftimeSubCaption = &"MP_SWITCHING_SIDES";
+	
+	level.lastStatusTime = 0;
+	level.wasWinning = "none";
+	
+	level.lastSlowProcessFrame = 0;
+	
+	level.placement["allies"] = [];
+	level.placement["axis"] = [];
+	level.placement["all"] = [];
+	
+	level.postRoundTime = 5.0;
+	
+	level.playersLookingForSafeSpawn = [];
+	
+	registerDvars();
+
+	precacheModel( "vehicle_mig29_desert" );
+	precacheModel( "projectile_cbu97_clusterbomb" );
+	precacheModel( "tag_origin" );	
+
+	level.fx_airstrike_afterburner = loadfx ("fire/jet_afterburner");
+	level.fx_airstrike_contrail = loadfx ("smoke/jet_contrail");
+	
+	if ( level.console )
+		precacheLeaderboards( "LB_KILLS LB_WINS LB_TOTALXP LB_ACCURACY" );
+
+	level.teamCount["allies"] = 0;
+	level.teamCount["axis"] = 0;
+	level.teamCount["spectator"] = 0;
+
+	level.aliveCount["allies"] = 0;
+	level.aliveCount["axis"] = 0;
+	level.aliveCount["spectator"] = 0;
+	
+	level.livesCount["allies"] = 0;
+	level.livesCount["axis"] = 0;
+
+	level.oneLeftTime = [];
+	
+	level.hasSpawned["allies"] = 0;
+	level.hasSpawned["axis"] = 0;
+
+	/#
+	if ( getdvarint( "scr_runlevelandquit" ) == 1 )
+	{
+		thread runLevelAndQuit();
+	}
+	#/
+}
+
+
+/#
+runLevelAndQuit()
+{
+	wait 1;
+	while ( level.players.size < 1 )
+	{
+		wait 0.5;
+	}
+	wait 0.5;
+	level notify( "game_ended" );
+	exitLevel();	
+}
+#/
+
+
+registerDvars()
+{
+	makeDvarServerInfo( "ui_bomb_timer", 0 );
+	makeDvarServerInfo( "ui_danger_team", "" );	
+	
+	makeDvarServerInfo( "camera_thirdPerson", getDvarInt( "scr_thirdPerson" ) );
+
+	makeDvarServerInfo( "ranked", level.rankedMatch );
+}
+
+SetupCallbacks()
+{
+	level.onXPEvent = ::onXPEvent;
+	
+	level.getSpawnPoint = ::blank;
+	level.onSpawnPlayer = ::blank;
+	level.onRespawnDelay = ::blank;
+
+	level.onTimeLimit = maps\mp\gametypes\_gamelogic::default_onTimeLimit;
+	level.onHalfTime = maps\mp\gametypes\_gamelogic::default_onHalfTime;
+	level.onDeadEvent = maps\mp\gametypes\_gamelogic::default_onDeadEvent;
+	level.onOneLeftEvent = maps\mp\gametypes\_gamelogic::default_onOneLeftEvent;
+	
+	level.onPrecacheGametype = ::blank;
+	level.onStartGameType = ::blank;
+	level.onPlayerKilled = ::blank;
+
+	level.autoassign = maps\mp\gametypes\_menus::menuAutoAssign;
+	level.spectator = maps\mp\gametypes\_menus::menuSpectator;
+	level.class = maps\mp\gametypes\_menus::menuClass;
+	level.allies = maps\mp\gametypes\_menus::menuAllies;
+	level.axis = maps\mp\gametypes\_menus::menuAxis;
+}
+
+
+
+blank( arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10 )
+{
+}
+
+
+
+/#
+xpRateThread()
+{
+	self endon ( "death" );
+	self endon ( "disconnect" );
+	level endon ( "game_ended" );
+
+	gameFlagWait( "prematch_done" );
+
+	for ( ;; )
+	{
+		wait ( 5.0 );
+		if ( level.players[0].pers["team"] == "allies" || level.players[0].pers["team"] == "axis" )
+			self maps\mp\gametypes\_rank::giveRankXP( "kill", int(min( getDvarInt( "scr_xprate" ), 50 )) );
+	}
+}
+#/
+
+testMenu()
+{
+	self endon ( "death" );
+	self endon ( "disconnect" );
+	
+	for ( ;; )
+	{
+		wait ( 10.0 );
+		
+		notifyData = spawnStruct();
+		notifyData.titleText = &"MP_CHALLENGE_COMPLETED";
+		notifyData.notifyText = "wheee";
+		notifyData.sound = "mp_challenge_complete";
+	
+		self thread maps\mp\gametypes\_hud_message::notifyMessage( notifyData );
+	}
+}
+
+testShock()
+{
+	self endon ( "death" );
+	self endon ( "disconnect" );
+	
+	for ( ;; )
+	{
+		wait ( 3.0 );
+
+		numShots = randomInt( 6 );
+		
+		for ( i = 0; i < numShots; i++ )
+		{
+			iPrintLnBold( numShots );
+			self shellShock( "frag_grenade_mp", 0.2 );
+			wait ( 0.1 );
+		}
+	}
+}
+
+
+onXPEvent( event )
+{
+	//self thread maps\mp\_loot::giveMoney( event, 10 );
+	self thread maps\mp\gametypes\_rank::giveRankXP( event );
+}
+
+
+
+fakeLag()
+{
+	self endon ( "disconnect" );
+	self.fakeLag = randomIntRange( 50, 150 );
+	
+	for ( ;; )
+	{
+		self setClientDvar( "fakelag_target", self.fakeLag );
+		wait ( randomFloatRange( 5.0, 15.0 ) );
+	}
+}
+
+
+
+
+debugLine( start, end )
+{
+	for ( i = 0; i < 50; i++ )
+	{
+		line( start, end );
+		wait .05;
+	}
+}

iw4x/iw4x_00/maps/mp/gametypes/_killcam.gsc

@@ -0,0 +1,594 @@
+#include maps\mp\_utility;
+#include maps\mp\gametypes\_hud_util;
+
+init()
+{
+	precacheString(&"PLATFORM_PRESS_TO_SKIP");
+	precacheString(&"PLATFORM_PRESS_TO_RESPAWN");
+	precacheString(&"PLATFORM_PRESS_TO_COPYCAT");
+	precacheShader("specialty_copycat");
+	
+	level.killcam = maps\mp\gametypes\_tweakables::getTweakableValue( "game", "allowkillcam" );
+}
+
+killcam(
+	attackerNum, // entity number of the attacker
+	killcamentityindex, // entity number of the entity to view (grenade, airstrike, etc)
+	killcamentitystarttime, // time at which the killcamentity came into being
+	sWeapon, // killing weapon
+	predelay, // time between player death and beginning of killcam
+	offsetTime, // something to do with how far back in time the killer was seeing the world when he made the kill; latency related, sorta
+	timeUntilRespawn, // will the player be allowed to respawn after the killcam?
+	maxtime, // time remaining until map ends; the killcam will never last longer than this. undefined = no limit
+	attacker, // entity object of attacker
+	victim // entity object of the victim
+)
+{
+	// monitors killcam and hides HUD elements during killcam session
+	//if ( !level.splitscreen )
+	//	self thread killcam_HUD_off();
+	
+	self endon("disconnect");
+	self endon("spawned");
+	level endon("game_ended");
+	
+	if ( attackerNum < 0 )
+		return;
+
+	// length from killcam start to killcam end
+	if (getdvar("scr_killcam_time") == "") {
+		if ( sWeapon == "artillery_mp" || sWeapon == "stealth_bomb_mp" )
+			camtime = (gettime() - killcamentitystarttime) / 1000 - predelay - .1;
+		else if ( level.showingFinalKillcam	)
+			camtime = 4.0;
+		else if ( sWeapon == "javelin_mp" )
+			camtime = 8;
+		else if ( issubstr( sWeapon, "remotemissile_" ) )
+			camtime = 5;
+		else if ( !timeUntilRespawn || timeUntilRespawn > 5.0 ) // if we're not going to respawn, we can take more time to watch what happened
+			camtime = 5.0;
+		else if ( sWeapon == "frag_grenade_mp" || sWeapon == "frag_grenade_short_mp" || sWeapon == "semtex_mp" )
+			camtime = 4.25; // show long enough to see grenade thrown
+		else
+			camtime = 2.5;
+	}
+	else
+		camtime = getdvarfloat("scr_killcam_time");
+
+	if (isdefined(maxtime)) {
+		if (camtime > maxtime)
+			camtime = maxtime;
+		if (camtime < .05)
+			camtime = .05;
+	}
+	
+	// time after player death that killcam continues for
+	if (getdvar("scr_killcam_posttime") == "")
+		postdelay = 2;
+	else {
+		postdelay = getdvarfloat("scr_killcam_posttime");
+		if (postdelay < 0.05)
+			postdelay = 0.05;
+	}
+	
+	/* timeline:
+	
+	|        camtime       |      postdelay      |
+	|                      |   predelay    |
+	
+	^ killcam start        ^ player death        ^ killcam end
+	                                       ^ player starts watching killcam
+	
+	*/
+	
+	killcamlength = camtime + postdelay;
+	
+	// don't let the killcam last past the end of the round.
+	if (isdefined(maxtime) && killcamlength > maxtime)
+	{
+		// first trim postdelay down to a minimum of 1 second.
+		// if that doesn't make it short enough, trim camtime down to a minimum of 1 second.
+		// if that's still not short enough, cancel the killcam.
+		if ( maxtime < 2 )
+			return;
+
+		if (maxtime - camtime >= 1) {
+			// reduce postdelay so killcam ends at end of match
+			postdelay = maxtime - camtime;
+		}
+		else {
+			// distribute remaining time over postdelay and camtime
+			postdelay = 1;
+			camtime = maxtime - 1;
+		}
+		
+		// recalc killcamlength
+		killcamlength = camtime + postdelay;
+	}
+
+	killcamoffset = camtime + predelay;
+	
+	startTime = getTime();
+	self notify ( "begin_killcam", startTime );
+	
+	self.sessionstate = "spectator";
+	self.forcespectatorclient = attackerNum;
+	self.killcamentity = -1;
+	if ( killcamentityindex >= 0 )
+		self thread setKillCamEntity( killcamentityindex, killcamoffset, killcamentitystarttime );
+	self.archivetime = killcamoffset;
+	self.killcamlength = killcamlength;
+	self.psoffsettime = offsetTime;
+	
+	// ignore spectate permissions
+	self allowSpectateTeam("allies", true);
+	self allowSpectateTeam("axis", true);
+	self allowSpectateTeam("freelook", true);
+	self allowSpectateTeam("none", true);
+
+	if ( isDefined( attacker ) && level.showingFinalKillcam ) // attacker may have disconnected
+	{
+		self openMenu( "killedby_card_display" );
+		self SetCardDisplaySlot( attacker, 7 );
+	}
+	
+	self thread endedKillcamCleanup();
+
+	// wait till the next server frame to allow code a chance to update archivetime if it needs trimming
+	wait 0.05;	
+	
+	assertex( self.archivetime <= killcamoffset + 0.0001, "archivetime: " + self.archivetime + ", killcamoffset: " + killcamoffset );
+	if ( self.archivetime < killcamoffset )
+		println( "WARNING: Code trimmed killcam time by " + (killcamoffset - self.archivetime) + " seconds because it doesn't have enough game time recorded!" );
+	
+	camtime = self.archivetime - .05 - predelay;
+	killcamlength = camtime + postdelay;
+	self.killcamlength = killcamlength;
+	
+	if ( camtime <= 0 ) // if we're not looking back in time far enough to even see the death, cancel
+	{
+		println( "Cancelling killcam because we don't even have enough recorded to show the death." );
+		
+		self.sessionstate = "dead";
+		self.forcespectatorclient = -1;
+		self.killcamentity = -1;
+		self.archivetime = 0;
+		self.psoffsettime = 0;
+		
+		self notify ( "killcam_ended" );
+		
+		return;
+	}
+	
+	if ( level.showingFinalKillcam )
+		thread doFinalKillCamFX( camtime );
+	
+	self.killcam = true;
+
+	self initKCElements();
+
+	if ( !level.splitscreen )
+	{	
+		self.kc_timer.alpha = 1;
+		self.kc_timer setTenthsTimer(camtime);
+	}
+
+	if ( timeUntilRespawn && !level.gameEnded )
+	{
+		if ( timeUntilRespawn > 0 )
+			setLowerMessage( "kc_info", game["strings"]["waiting_to_spawn"], timeUntilRespawn );
+		else
+			setLowerMessage( "kc_info", &"PLATFORM_PRESS_TO_SKIP" );
+	}
+	else if ( !level.gameEnded )
+	{
+		setLowerMessage( "kc_info", &"PLATFORM_PRESS_TO_RESPAWN" );
+	}
+	
+	if ( !level.showingFinalKillcam )
+		self.kc_skiptext.alpha = 1;
+	else
+		self.kc_skiptext.alpha = 0;
+
+	self.kc_othertext.alpha = 0;
+	self.kc_icon.alpha = 0;
+
+	self thread spawnedKillcamCleanup();
+
+	if ( self == victim && victim _hasPerk( "specialty_copycat" ) && isDefined( victim.pers["copyCatLoadout"] ) )
+		self thread waitKCCopyCatButton( attacker );
+
+	if ( !level.showingFinalKillcam )
+		self thread waitSkipKillcamButton( timeUntilRespawn );
+	else
+		self notify ( "showing_final_killcam" );
+	
+	self thread endKillcamIfNothingToShow();
+	
+	self waittillKillcamOver();
+	
+	if ( level.showingFinalKillcam )
+	{
+		self thread maps\mp\gametypes\_playerlogic::spawnEndOfGame();
+		return;
+	}
+	
+	self thread calculateKillCamTime( startTime );
+	
+	self thread killcamCleanup( true );
+}
+
+
+doFinalKillCamFX( camTime )
+{
+	if ( isDefined( level.doingFinalKillcamFx ) )
+		return;
+	level.doingFinalKillcamFx = true;
+	
+	intoSlowMoTime = camTime;
+	if ( intoSlowMoTime > 1.0 )
+	{
+		intoSlowMoTime = 1.0;
+		wait( camTime - 1.0 );
+	}
+	
+	//setSlowMotion( 1.0, 0.25, intoSlowMoTime ); // start timescale, end timescale, lerp duration
+	wait( intoSlowMoTime + .5 );
+	//setSlowMotion( 0.25, 1, 1.0 );
+	
+	level.doingFinalKillcamFx = undefined;
+}
+
+
+calculateKillCamTime( startTime )
+{
+	watchedTime = int(getTime() - startTime);
+	self incPlayerStat( "killcamtimewatched", watchedTime );
+}
+
+waittillKillcamOver()
+{
+	self endon("abort_killcam");
+	
+	wait(self.killcamlength - 0.05);
+}
+
+setKillCamEntity( killcamentityindex, killcamoffset, starttime )
+{
+	self endon("disconnect");
+	self endon("killcam_ended");
+	
+	killcamtime = (gettime() - killcamoffset * 1000);
+	
+	if ( starttime > killcamtime )
+	{
+		wait .05;
+		// code may have trimmed archivetime after the first frame if we couldn't go back in time as far as requested.
+		killcamoffset = self.archivetime;
+		killcamtime = (gettime() - killcamoffset * 1000);
+		
+		if ( starttime > killcamtime )
+			wait (starttime - killcamtime) / 1000;
+	}
+	self.killcamentity = killcamentityindex;
+}
+
+waitSkipKillcamButton( timeUntilRespawn )
+{
+	self endon("disconnect");
+	self endon("killcam_ended");
+
+	while(self useButtonPressed())
+		wait .05;
+
+	while(!(self useButtonPressed()))
+		wait .05;
+		
+	if ( !matchMakingGame() )
+		self incPlayerStat( "killcamskipped", 1 );
+
+	if ( timeUntilRespawn <= 0 )
+		clearLowerMessage( "kc_info" );
+	
+	self notify("abort_killcam");
+}
+
+waitKCCopyCatButton( attacker )
+{
+	self endon("disconnect");
+	self endon("killcam_ended");
+
+	self waitCopyCatButton( attacker );
+
+	self notify("abort_killcam");
+}
+
+waitDeathCopyCatButton( attacker )
+{
+	self endon ( "disconnect" );
+
+	self initKCElements();
+	
+	usedCopycat = self waitCopyCatButton( attacker );
+
+	if ( !isDefined( usedCopycat ) )
+	{
+		self.kc_icon.alpha = 0;
+		self.kc_othertext.alpha = 0;
+	}
+}
+
+waitCopyCatButton( attacker )
+{
+	self endon ( "spawned_player" );
+	self endon ( "death_delay_finished" );
+	self.kc_icon setShader( "specialty_copycat", 48, 48 );
+	self.kc_othertext setText( &"PLATFORM_PRESS_TO_COPYCAT" );
+	self.kc_othertext.alpha = 1;
+	self.kc_icon.alpha = 1;
+	
+	self notifyOnPlayerCommand( "use_copycat", "weapnext" );
+	
+	self waittill( "use_copycat" );
+	
+	self.pers["copyCatLoadout"]["inUse"] = true;
+	self.pers["copyCatLoadout"]["owner"] = attacker;
+
+	self.kc_othertext fadeOverTime( 0.5 );
+	self.kc_othertext.alpha = 0;
+
+	self.kc_icon fadeOverTime( 0.25 );
+	self.kc_icon scaleOverTime( 0.25, 512, 512 );
+	self.kc_icon.alpha = 0;
+	
+	if ( isDefined( attacker ) )
+		attacker thread maps\mp\gametypes\_hud_message::playerCardSplashNotify( "copied", self );
+
+	self playLocalSound( "copycat_steal_class" );
+		
+	return true;
+}
+
+waitSkipKillcamSafeSpawnButton()
+{
+	self endon("disconnect");
+	self endon("killcam_ended");
+	
+	if ( !self maps\mp\gametypes\_playerlogic::maySpawn() )
+		return;
+	
+	while(self fragButtonPressed())
+		wait .05;
+
+	while(!(self fragButtonPressed()))
+		wait .05;
+	
+	self.wantSafeSpawn = true;
+
+	self notify("abort_killcam");
+}
+
+endKillcamIfNothingToShow()
+{
+	self endon("disconnect");
+	self endon("killcam_ended");
+	
+	while(1)
+	{
+		// code may trim our archivetime to zero if there is nothing "recorded" to show.
+		// this can happen when the person we're watching in our killcam goes into killcam himself.
+		// in this case, end the killcam.
+		if ( self.archivetime <= 0 )
+			break;
+		wait .05;
+	}
+	
+	self notify("abort_killcam");
+}
+
+spawnedKillcamCleanup()
+{
+	self endon("disconnect");
+	self endon("killcam_ended");
+	
+	self waittill("spawned");
+	self thread killcamCleanup( false );
+}
+
+endedKillcamCleanup()
+{
+	self endon("disconnect");
+	self endon("killcam_ended");
+	
+	level waittill("game_ended");
+
+	self thread killcamCleanup( true );
+}
+
+killcamCleanup( clearState )
+{
+	if(isDefined(self.kc_skiptext))
+		self.kc_skiptext.alpha = 0;
+
+	if(isDefined(self.kc_timer))
+		self.kc_timer.alpha = 0;
+
+	if(isDefined(self.kc_icon))
+		self.kc_icon.alpha = 0;
+
+	if(isDefined(self.kc_othertext))
+		self.kc_othertext.alpha = 0;
+
+	self.killcam = undefined;
+
+	if ( !level.gameEnded )
+		self clearLowerMessage( "kc_info" );
+	
+	self thread maps\mp\gametypes\_spectating::setSpectatePermissions();
+	
+	self notify("killcam_ended"); // do this last, in case this function was called from a thread ending on it
+
+	if ( !clearState )
+		return;
+			
+	self.sessionstate = "dead";
+	self ClearKillcamState();
+}
+
+
+
+cancelKillCamOnUse()
+{
+	self.cancelKillcam = false;
+	self thread cancelKillCamOnUse_specificButton( ::cancelKillCamUseButton, ::cancelKillCamCallback );
+	//self thread cancelKillCamOnUse_specificButton( ::cancelKillCamSafeSpawnButton, ::cancelKillCamSafeSpawnCallback );
+}
+
+cancelKillCamUseButton()
+{
+	return self useButtonPressed();
+}
+cancelKillCamSafeSpawnButton()
+{
+	return self fragButtonPressed();
+}
+cancelKillCamCallback()
+{
+	self.cancelKillcam = true;
+}
+cancelKillCamSafeSpawnCallback()
+{
+	self.cancelKillcam = true;
+	self.wantSafeSpawn = true;
+}
+
+cancelKillCamOnUse_specificButton( pressingButtonFunc, finishedFunc )
+{
+	self endon ( "death_delay_finished" );
+	self endon ( "disconnect" );
+	level endon ( "game_ended" );
+	
+	for ( ;; )
+	{
+		if ( !self [[pressingButtonFunc]]() )
+		{
+			wait ( 0.05 );
+			continue;
+		}
+		
+		buttonTime = 0;
+		while( self [[pressingButtonFunc]]() )
+		{
+			buttonTime += 0.05;
+			wait ( 0.05 );
+		}
+		
+		if ( buttonTime >= 0.5 )
+			continue;
+		
+		buttonTime = 0;
+		
+		while ( !self [[pressingButtonFunc]]() && buttonTime < 0.5 )
+		{
+			buttonTime += 0.05;
+			wait ( 0.05 );
+		}
+		
+		if ( buttonTime >= 0.5 )
+			continue;
+			
+		self [[finishedFunc]]();
+		return;
+	}	
+}
+
+initKCElements()
+{
+	if ( !isDefined( self.kc_skiptext ) )
+	{
+		self.kc_skiptext = newClientHudElem(self);
+		self.kc_skiptext.archived = false;
+		self.kc_skiptext.x = 0;
+		self.kc_skiptext.alignX = "center";
+		self.kc_skiptext.alignY = "top";
+		self.kc_skiptext.horzAlign = "center_adjustable";
+		self.kc_skiptext.vertAlign = "top_adjustable";
+		self.kc_skiptext.sort = 1; // force to draw after the bars
+		self.kc_skiptext.font = "default";
+		self.kc_skiptext.foreground = true;
+		self.kc_skiptext.hideWhenInMenu = true;
+		
+		if ( level.splitscreen )
+		{
+			self.kc_skiptext.y = 20;
+			self.kc_skiptext.fontscale = 1.2; // 1.8/1.5
+		}
+		else
+		{
+			self.kc_skiptext.y = 32;
+			self.kc_skiptext.fontscale = 1.8;
+		}
+	}
+	
+	if ( !isDefined( self.kc_othertext ) )
+	{
+		self.kc_othertext = newClientHudElem(self);
+		self.kc_othertext.archived = false;		
+		self.kc_othertext.y = 18;
+		self.kc_othertext.alignX = "left";
+		self.kc_othertext.alignY = "top";
+		self.kc_othertext.horzAlign = "center";
+		self.kc_othertext.vertAlign = "middle";
+		self.kc_othertext.sort = 10; // force to draw after the bars
+		self.kc_othertext.font = "small";
+		self.kc_othertext.foreground = true;
+		self.kc_othertext.hideWhenInMenu = true;
+		
+		if ( level.splitscreen )
+		{
+			self.kc_othertext.x = 16;
+			self.kc_othertext.fontscale = 1.2;
+		}
+		else
+		{
+			self.kc_othertext.x = 62;
+			self.kc_othertext.fontscale = 1.6;
+		}
+	}
+
+	if ( !isDefined( self.kc_icon ) )
+	{
+		self.kc_icon = newClientHudElem(self);
+		self.kc_icon.archived = false;
+		self.kc_icon.x = 16;
+		self.kc_icon.y = 16;
+		self.kc_icon.alignX = "left";
+		self.kc_icon.alignY = "top";
+		self.kc_icon.horzAlign = "center";
+		self.kc_icon.vertAlign = "middle";
+		self.kc_icon.sort = 1; // force to draw after the bars
+		self.kc_icon.foreground = true;
+		self.kc_icon.hideWhenInMenu = true;		
+	}
+
+	if ( !level.splitscreen )
+	{
+		if ( !isdefined( self.kc_timer ) )
+		{
+			self.kc_timer = createFontString( "hudbig", 1.0 );
+			self.kc_timer.archived = false;
+			self.kc_timer.x = 0;
+			self.kc_timer.alignX = "center";
+			self.kc_timer.alignY = "middle";
+			self.kc_timer.horzAlign = "center_safearea";
+			self.kc_timer.vertAlign = "top_adjustable";
+			self.kc_timer.y = 42;
+			self.kc_timer.sort = 1; // force to draw after the bars
+			self.kc_timer.font = "hudbig";
+			self.kc_timer.foreground = true;
+			self.kc_timer.color = (0.85,0.85,0.85);
+			self.kc_timer.hideWhenInMenu = true;
+		}
+	}
+}
+

iw4x/iw4x_00/maps/mp/gametypes/_menus.gsc

@@ -0,0 +1,584 @@
+#include maps\mp\_utility;
+
+init()
+{
+	//Intricate - Create DVAR for forcing auto assign, useful for server that would like it.
+	SetDvarIfUninitialized("scr_player_forceautoassign", true);
+	if ( !isDefined( game["gamestarted"] ) )
+	{
+		game["menu_team"] = "team_marinesopfor";
+		game["menu_class_allies"] = "class_marines";
+		game["menu_changeclass_allies"] = "changeclass_marines";
+		game["menu_initteam_allies"] = "initteam_marines";
+		game["menu_class_axis"] = "class_opfor";
+		game["menu_changeclass_axis"] = "changeclass_opfor";
+		game["menu_initteam_axis"] = "initteam_opfor";
+		game["menu_class"] = "class";
+		game["menu_changeclass"] = "changeclass";
+		game["menu_onemanarmy"] = "onemanarmy";
+		game["menu_controls"] = "ingame_controls";
+	
+		if ( !level.console )
+		{
+			game["menu_muteplayer"] = "muteplayer";
+			precacheMenu(game["menu_muteplayer"]);			
+		}
+		else
+		{
+			//game["menu_options"] = "ingame_options";
+			game["menu_leavegame"] = "popup_leavegame";
+	
+			if(level.splitscreen)
+			{
+				game["menu_team"] += "_splitscreen";
+				game["menu_class_allies"] += "_splitscreen";
+				game["menu_changeclass_allies"] += "_splitscreen";
+				game["menu_class_axis"] += "_splitscreen";
+				game["menu_changeclass_axis"] += "_splitscreen";
+				game["menu_class"] += "_splitscreen";
+				game["menu_controls"] += "_splitscreen";
+				//game["menu_options"] += "_splitscreen";
+				game["menu_leavegame"] += "_splitscreen";
+				game["menu_onemanarmy"] += "_splitscreen";
+
+				game["menu_changeclass_defaults_splitscreen"] = "changeclass_defaults_splitscreen";
+				game["menu_changeclass_custom_splitscreen"] = "changeclass_custom_splitscreen";
+				game["menu_onemanarmy_defaults_splitscreen"] = "onemanarmy_defaults_splitscreen";
+				game["menu_onemanarmy_custom_splitscreen"] = "onemanarmy_custom_splitscreen";
+				
+				precacheMenu(game["menu_changeclass_defaults_splitscreen"]);
+				precacheMenu(game["menu_changeclass_custom_splitscreen"]);
+				precacheMenu(game["menu_onemanarmy_defaults_splitscreen"]);
+				precacheMenu(game["menu_onemanarmy_custom_splitscreen"]);
+			}
+	
+			precacheMenu(game["menu_controls"]);
+			//precacheMenu(game["menu_options"]);
+			precacheMenu(game["menu_leavegame"]);
+			
+			//precacheMenu("status_update");
+		}
+	
+		precacheMenu("scoreboard");
+		precacheMenu(game["menu_team"]);
+		precacheMenu(game["menu_class_allies"]);
+		precacheMenu(game["menu_changeclass_allies"]);
+		precacheMenu(game["menu_initteam_allies"]);
+		precacheMenu(game["menu_class_axis"]);
+		precacheMenu(game["menu_changeclass_axis"]);
+		precacheMenu(game["menu_class"]);
+		precacheMenu(game["menu_changeclass"]);
+		precacheMenu(game["menu_initteam_axis"]);
+		precacheMenu(game["menu_onemanarmy"]);
+		
+		precacheString( &"MP_HOST_ENDED_GAME" );
+		precacheString( &"MP_HOST_ENDGAME_RESPONSE" );
+	}
+
+	level thread onPlayerConnect();
+}
+
+onPlayerConnect()
+{
+	for(;;)
+	{
+		level waittill("connected", player);
+
+		player thread onMenuResponse();
+	}
+}
+
+
+isOptionsMenu( menu )
+{
+	if ( menu == game["menu_changeclass"] )
+		return true;
+		
+	if ( menu == game["menu_team"] )
+		return true;
+
+	if ( menu == game["menu_controls"] )
+		return true;
+
+	if ( isSubStr( menu, "pc_options" ) )
+		return true;
+
+	return false;
+}
+
+
+onMenuResponse()
+{
+	self endon("disconnect");
+	
+	for(;;)
+	{
+		self waittill("menuresponse", menu, response);
+		
+		if ( response == "back" )
+		{
+			self closepopupMenu();
+			self closeInGameMenu();
+
+			if ( isOptionsMenu( menu ) )
+			{
+				if( self.pers["team"] == "allies" )
+					self openpopupMenu( game["menu_class_allies"] );
+				if( self.pers["team"] == "axis" )
+					self openpopupMenu( game["menu_class_axis"] );
+			}
+			continue;
+		}
+		
+		if(response == "changeteam")
+		{
+			self closepopupMenu();
+			self closeInGameMenu();
+			self openpopupMenu(game["menu_team"]);
+		}
+	
+		if(response == "changeclass_marines" )
+		{
+			self closepopupMenu();
+			self closeInGameMenu();
+			if ( getDvar( "g_gametype" ) != "oitc" && getDvar( "g_gametype" ) != "gg" && getDvar( "g_gametype" ) != "ss" && !isDefined(level.customClassCB) )
+			{
+				self openpopupMenu( game["menu_changeclass_allies"] );
+			}
+			continue;
+		}
+
+		if(response == "changeclass_opfor" )
+		{
+			self closepopupMenu();
+			self closeInGameMenu();
+			if ( getDvar( "g_gametype" ) != "oitc" && getDvar( "g_gametype" ) != "gg" && getDvar( "g_gametype" ) != "ss" && !isDefined(level.customClassCB) )
+			{
+				self openpopupMenu( game["menu_changeclass_axis"] );
+			}
+			continue;
+		}
+
+		if(response == "changeclass_marines_splitscreen" )
+			self openpopupMenu( "changeclass_marines_splitscreen" );
+
+		if(response == "changeclass_opfor_splitscreen" )
+			self openpopupMenu( "changeclass_opfor_splitscreen" );
+		
+		if(response == "endgame")
+		{
+			if(level.splitscreen)
+			{
+				endparty();
+
+				if ( !level.gameEnded )
+				{
+					level thread maps\mp\gametypes\_gamelogic::forceEnd();
+				}
+			}
+				
+			continue;
+		}
+
+		if ( response == "endround" )
+		{
+			if ( !self isHost() )
+			{
+				continue;
+			}
+			
+			if ( !level.gameEnded )
+			{
+				setDvar("sv_dontrotate", 1);
+				level thread maps\mp\gametypes\_gamelogic::forceEnd();
+			}
+			else
+			{
+				self closepopupMenu();
+				self closeInGameMenu();
+				self iprintln( &"MP_HOST_ENDGAME_RESPONSE" );
+			}			
+			continue;
+		}
+
+		if(menu == game["menu_team"])
+		{
+			switch(response)
+			{
+			case "allies":
+				self [[level.allies]]();
+				break;
+
+			case "axis":
+				self [[level.axis]]();
+				break;
+
+			case "autoassign":
+				self [[level.autoassign]]();
+				break;
+
+			case "spectator":
+				self [[level.spectator]]();
+				break;
+			}
+		}	// the only responses remain are change class events
+		else if ( menu == game["menu_changeclass"] ||
+				( isDefined( game["menu_changeclass_defaults_splitscreen"] ) && menu == game["menu_changeclass_defaults_splitscreen"] ) ||
+				( isDefined( game["menu_changeclass_custom_splitscreen"] ) && menu == game["menu_changeclass_custom_splitscreen"] ) )
+		{
+			self closepopupMenu();
+			self closeInGameMenu();
+
+			self.selectedClass = true;
+			self [[level.class]](response);
+		}
+		else if ( !level.console )
+		{
+			if(menu == game["menu_quickcommands"])
+				maps\mp\gametypes\_quickmessages::quickcommands(response);
+			else if(menu == game["menu_quickstatements"])
+				maps\mp\gametypes\_quickmessages::quickstatements(response);
+			else if(menu == game["menu_quickresponses"])
+				maps\mp\gametypes\_quickmessages::quickresponses(response);
+		}
+	}
+}
+
+
+getTeamAssignment()
+{
+	teams[0] = "allies";
+	teams[1] = "axis";
+	
+	if ( !level.teamBased )
+		return teams[randomInt(2)];
+
+	if ( self.sessionteam != "none" && self.sessionteam != "spectator" && self.sessionstate != "playing" && self.sessionstate != "dead" )
+	{
+		assignment = self.sessionteam;
+	}
+	else
+	{
+		playerCounts = self maps\mp\gametypes\_teams::CountPlayers();
+				
+		// if teams are equal return the team with the lowest score
+		if ( playerCounts["allies"] == playerCounts["axis"] )
+		{
+			if( getTeamScore( "allies" ) == getTeamScore( "axis" ) )
+				assignment = teams[randomInt(2)];
+			else if ( getTeamScore( "allies" ) < getTeamScore( "axis" ) )
+				assignment = "allies";
+			else
+				assignment = "axis";
+		}
+		else if( playerCounts["allies"] < playerCounts["axis"] )
+		{
+			assignment = "allies";
+		}
+		else
+		{
+			assignment = "axis";
+		}
+	}
+	
+	return assignment;
+}
+
+
+menuAutoAssign()
+{
+	self closeMenus();
+
+	assignment = getTeamAssignment();
+		
+	if ( isDefined( self.pers["team"] ) && (self.sessionstate == "playing" || self.sessionstate == "dead") )
+	{
+		if ( assignment == self.pers["team"] )
+		{
+			self beginClassChoice();
+			return;
+		}
+		else
+		{
+			self.switching_teams = true;
+			self.joining_team = assignment;
+			self.leaving_team = self.pers["team"];
+			self suicide();
+		}
+	}
+
+	self addToTeam( assignment );
+	self.pers["class"] = undefined;
+	self.class = undefined;
+	
+	if ( !isAlive( self ) )
+		self.statusicon = "hud_status_dead";
+	
+	self notify("end_respawn");
+	
+	self beginClassChoice();
+}
+
+
+beginClassChoice( forceNewChoice )
+{
+	assert( self.pers["team"] == "axis" || self.pers["team"] == "allies" );
+
+	if ( getDvar( "g_gametype" ) == "oitc" || getDvar( "g_gametype" ) == "gg" || getDvar( "g_gametype" ) == "ss" || isDefined(level.customClassCB) )
+	{
+		if ( !isAlive( self ) )
+			self thread maps\mp\gametypes\_playerlogic::predictAboutToSpawnPlayerOverTime( 0.1 );
+		
+		self.selectedClass = true;
+		self menuClass( "assault_mp,0" );
+
+		return;
+	}
+	
+	team = self.pers["team"];
+
+	// menu_changeclass_team is the one where you choose one of the n classes to play as.
+	// menu_class_team is where you can choose to change your team, class, controls, or leave game.
+	self openpopupMenu( game[ "menu_changeclass_" + team ] );
+	
+	if ( !isAlive( self ) )
+		self thread maps\mp\gametypes\_playerlogic::predictAboutToSpawnPlayerOverTime( 0.1 );
+}
+
+
+beginTeamChoice()
+{
+	//Intricate - We put the auto assign where the actual team selection is. Also make sure that a mod isn't loaded, mainly to prevent bugs with them.
+	if( GetDvar("scr_player_forceautoassign") && GetDvar("fs_game") == ""  )
+		self notify("menuresponse", game["menu_team"], "autoassign");
+	else
+		self openpopupMenu( game["menu_team"] );
+	
+}
+
+
+showMainMenuForTeam()
+{
+	assert( self.pers["team"] == "axis" || self.pers["team"] == "allies" );
+	
+	team = self.pers["team"];
+	
+	// menu_changeclass_team is the one where you choose one of the n classes to play as.
+	// menu_class_team is where you can choose to change your team, class, controls, or leave game.	
+	self openpopupMenu( game[ "menu_class_" + team ] );
+}
+
+menuAllies()
+{
+	self closeMenus();
+	
+	if(self.pers["team"] != "allies")
+	{
+		if( level.teamBased && !maps\mp\gametypes\_teams::getJoinTeamPermissions( "allies" ) )
+		{
+			self openpopupMenu(game["menu_team"]);
+			return;
+		}
+		
+		// allow respawn when switching teams during grace period.
+		if ( level.inGracePeriod && !self.hasDoneCombat )
+			self.hasSpawned = false;
+			
+		if(self.sessionstate == "playing")
+		{
+			self.switching_teams = true;
+			self.joining_team = "allies";
+			self.leaving_team = self.pers["team"];
+			self suicide();
+		}
+
+		self addToTeam( "allies" );
+		self.pers["class"] = undefined;
+		self.class = undefined;
+
+		self notify("end_respawn");
+	}
+	
+	self beginClassChoice();
+}
+
+
+menuAxis()
+{
+	self closeMenus();
+	
+	if(self.pers["team"] != "axis")
+	{
+		if( level.teamBased && !maps\mp\gametypes\_teams::getJoinTeamPermissions( "axis" ) )
+		{
+			self openpopupMenu(game["menu_team"]);
+			return;
+		}
+
+		// allow respawn when switching teams during grace period.
+		if ( level.inGracePeriod && !self.hasDoneCombat )
+			self.hasSpawned = false;
+
+		if(self.sessionstate == "playing")
+		{
+			self.switching_teams = true;
+			self.joining_team = "axis";
+			self.leaving_team = self.pers["team"];
+			self suicide();
+		}
+
+		self addToTeam( "axis" );
+		self.pers["class"] = undefined;
+		self.class = undefined;
+
+		self notify("end_respawn");
+	}
+	
+	self beginClassChoice();
+}
+
+
+menuSpectator()
+{
+	self closeMenus();
+	
+	if( isDefined( self.pers["team"] ) && self.pers["team"] == "spectator" )
+		return;
+
+	if( isAlive( self ) )
+	{
+		assert( isDefined( self.pers["team"] ) );
+		self.switching_teams = true;
+		self.joining_team = "spectator";
+		self.leaving_team = self.pers["team"];
+		self suicide();
+	}
+
+	self addToTeam( "spectator" );
+	self.pers["class"] = undefined;
+	self.class = undefined;
+
+	self thread maps\mp\gametypes\_playerlogic::spawnSpectator();
+}
+
+menuClass( response )
+{
+	self closeMenus();
+	
+	// clear new status of unlocked classes
+	if ( response == "demolitions_mp,0" && self getPlayerData( "featureNew", "demolitions" ) )
+	{
+		self setPlayerData( "featureNew", "demolitions", false );
+	}
+	if ( response == "sniper_mp,0" && self getPlayerData( "featureNew", "sniper" ) )
+	{
+		self setPlayerData( "featureNew", "sniper", false );
+	}
+
+	// this should probably be an assert
+	if(!isDefined(self.pers["team"]) || (self.pers["team"] != "allies" && self.pers["team"] != "axis"))
+		return;
+
+	class = self maps\mp\gametypes\_class::getClassChoice( response );
+	primary = self maps\mp\gametypes\_class::getWeaponChoice( response );
+
+	if ( class == "restricted" )
+	{
+		self beginClassChoice();
+		return;
+	}
+
+	if( (isDefined( self.pers["class"] ) && self.pers["class"] == class) && 
+		(isDefined( self.pers["primary"] ) && self.pers["primary"] == primary) )
+		return;
+
+	if ( self.sessionstate == "playing" )
+	{
+		self.pers["class"] = class;
+		self.class = class;
+		self.pers["primary"] = primary;
+
+		if ( game["state"] == "postgame" )
+			return;
+
+		if ( level.inGracePeriod && !self.hasDoneCombat ) // used weapons check?
+		{
+			self maps\mp\gametypes\_class::setClass( self.pers["class"] );
+			self.tag_stowed_back = undefined;
+			self.tag_stowed_hip = undefined;
+			self maps\mp\gametypes\_class::giveLoadout( self.pers["team"], self.pers["class"] );
+		}
+		else
+		{
+			self iPrintLnBold( game["strings"]["change_class"] );
+		}
+	}
+	else
+	{
+		self.pers["class"] = class;
+		self.class = class;
+		self.pers["primary"] = primary;
+
+		if ( game["state"] == "postgame" )
+			return;
+
+		if ( game["state"] == "playing" && !isInKillcam() )
+			self thread maps\mp\gametypes\_playerlogic::spawnClient();
+	}
+
+	self thread maps\mp\gametypes\_spectating::setSpectatePermissions();
+}
+
+
+
+addToTeam( team, firstConnect )
+{
+	// UTS update playerCount remove from team
+	if ( isDefined( self.team ) )
+		self maps\mp\gametypes\_playerlogic::removeFromTeamCount();
+		
+	self.pers["team"] = team;
+	// this is the only place self.team should ever be set
+	self.team = team;
+	
+	// session team is readonly in ranked matches on console
+	if ( !matchMakingGame() || isDefined( self.pers["isBot"] ) )
+	{
+		if ( level.teamBased )
+		{
+			self.sessionteam = team;
+		}
+		else
+		{
+			if ( team == "spectator" )
+				self.sessionteam = "spectator";
+			else
+				self.sessionteam = "none";
+		}
+	}
+
+	// UTS update playerCount add to team
+	if ( game["state"] != "postgame" )
+		self maps\mp\gametypes\_playerlogic::addToTeamCount();	
+
+	self updateObjectiveText();
+
+	// give "joined_team" and "joined_spectators" handlers a chance to start
+	// these are generally triggered from the "connected" notify, which can happen on the same
+	// frame as these notifies
+	if ( isDefined( firstConnect ) && firstConnect )
+		waittillframeend;
+
+	self updateMainMenu();
+
+	if ( team == "spectator" )
+	{
+		self notify( "joined_spectators" );
+		level notify( "joined_team" );
+	}
+	else
+	{
+		self notify( "joined_team" );
+		level notify( "joined_team" );
+	}
+}

iw4x/iw4x_00/maps/mp/gametypes/_music_and_dialog.gsc

@@ -0,0 +1,505 @@
+#include common_scripts\utility;
+#include maps\mp\_utility;
+#include maps\mp\gametypes\_hud_util;
+
+init()
+{
+	
+	game["music"]["spawn_allies"] = maps\mp\gametypes\_teams::getTeamVoicePrefix( "allies" ) + "spawn_music";
+	game["music"]["defeat_allies"] = maps\mp\gametypes\_teams::getTeamVoicePrefix( "allies" ) + "defeat_music";
+	game["music"]["victory_allies"] = maps\mp\gametypes\_teams::getTeamVoicePrefix( "allies" ) + "victory_music";
+	game["music"]["winning_allies"] = maps\mp\gametypes\_teams::getTeamVoicePrefix( "allies" ) + "winning_music";
+	game["music"]["losing_allies"] = maps\mp\gametypes\_teams::getTeamVoicePrefix( "allies" ) + "losing_music";
+	game["voice"]["allies"] = maps\mp\gametypes\_teams::getTeamVoicePrefix( "allies" ) + "1mc_";
+
+	game["music"]["spawn_axis"] = maps\mp\gametypes\_teams::getTeamVoicePrefix( "axis" ) + "spawn_music";
+	game["music"]["defeat_axis"] = maps\mp\gametypes\_teams::getTeamVoicePrefix( "axis" ) + "defeat_music";
+	game["music"]["victory_axis"] = maps\mp\gametypes\_teams::getTeamVoicePrefix( "axis" ) + "victory_music";
+	game["music"]["winning_axis"] = maps\mp\gametypes\_teams::getTeamVoicePrefix( "axis" ) + "winning_music";
+	game["music"]["losing_axis"] = maps\mp\gametypes\_teams::getTeamVoicePrefix( "axis" ) + "losing_music";
+	game["voice"]["axis"] = maps\mp\gametypes\_teams::getTeamVoicePrefix( "axis" ) + "1mc_";
+	
+	game["music"]["defeat"] 			= "mp_defeat";
+	game["music"]["victory_spectator"] 	= "mp_defeat";
+	game["music"]["winning_time"] 		= "mp_time_running_out_winning";
+	game["music"]["losing_time"] 		= "mp_time_running_out_losing";
+	game["music"]["winning_score"] 		= "mp_time_running_out_winning";
+	game["music"]["losing_score"] 		= "mp_time_running_out_losing";
+	game["music"]["victory_tie"] 		= "mp_defeat";
+	
+	game["music"]["suspense"] = [];
+	game["music"]["suspense"][game["music"]["suspense"].size] = "mp_suspense_01";
+	game["music"]["suspense"][game["music"]["suspense"].size] = "mp_suspense_02";
+	game["music"]["suspense"][game["music"]["suspense"].size] = "mp_suspense_03";
+	game["music"]["suspense"][game["music"]["suspense"].size] = "mp_suspense_04";
+	game["music"]["suspense"][game["music"]["suspense"].size] = "mp_suspense_05";
+	game["music"]["suspense"][game["music"]["suspense"].size] = "mp_suspense_06";
+
+	game["dialog"]["mission_success"] = "mission_success";
+	game["dialog"]["mission_failure"] = "mission_fail";
+	game["dialog"]["mission_draw"] = "draw";
+
+	game["dialog"]["round_success"] = "encourage_win";
+	game["dialog"]["round_failure"] = "encourage_lost";
+	game["dialog"]["round_draw"] = "draw";
+	
+	// status
+	game["dialog"]["timesup"] = "timesup";
+	game["dialog"]["winning_time"] = "winning";
+	game["dialog"]["losing_time"] = "losing";
+	game["dialog"]["winning_score"] = "winning_fight";
+	game["dialog"]["losing_score"] = "losing_fight";
+	game["dialog"]["lead_lost"] = "lead_lost";
+	game["dialog"]["lead_tied"] = "tied";
+	game["dialog"]["lead_taken"] = "lead_taken";
+	game["dialog"]["last_alive"] = "lastalive";
+
+	game["dialog"]["boost"] = "boost";
+
+	if ( !isDefined( game["dialog"]["offense_obj"] ) )
+		game["dialog"]["offense_obj"] = "boost";
+	if ( !isDefined( game["dialog"]["defense_obj"] ) )
+		game["dialog"]["defense_obj"] = "boost";
+	
+	game["dialog"]["hardcore"] = "hardcore";
+	game["dialog"]["highspeed"] = "highspeed";
+	game["dialog"]["tactical"] = "tactical";
+
+	game["dialog"]["challenge"] = "challengecomplete";
+	game["dialog"]["promotion"] = "promotion";
+
+	game["dialog"]["bomb_taken"] = "acheive_bomb";
+	game["dialog"]["bomb_lost"] = "bomb_taken";
+	game["dialog"]["bomb_defused"] = "bomb_defused";
+	game["dialog"]["bomb_planted"] = "bomb_planted";
+
+	game["dialog"]["obj_taken"] = "securedobj";
+	game["dialog"]["obj_lost"] = "lostobj";
+
+	game["dialog"]["obj_defend"] = "obj_defend";
+	game["dialog"]["obj_destroy"] = "obj_destroy";
+	game["dialog"]["obj_capture"] = "capture_obj";
+	game["dialog"]["objs_capture"] = "capture_objs";
+
+	game["dialog"]["hq_located"] = "hq_located";
+	game["dialog"]["hq_enemy_captured"] = "hq_captured";
+	game["dialog"]["hq_enemy_destroyed"] = "hq_destroyed";
+	game["dialog"]["hq_secured"] = "hq_secured";
+	game["dialog"]["hq_offline"] = "hq_offline";
+	game["dialog"]["hq_online"] = "hq_online";
+
+	game["dialog"]["move_to_new"] = "new_positions";
+
+	game["dialog"]["push_forward"] = "pushforward";
+
+	game["dialog"]["attack"] = "attack";
+	game["dialog"]["defend"] = "defend";
+	game["dialog"]["offense"] = "offense";
+	game["dialog"]["defense"] = "defense";
+
+	game["dialog"]["halftime"] = "halftime";
+	game["dialog"]["overtime"] = "overtime";
+	game["dialog"]["side_switch"] = "switching";
+
+	game["dialog"]["flag_taken"] = "ourflag";
+	game["dialog"]["flag_dropped"] = "ourflag_drop";
+	game["dialog"]["flag_returned"] = "ourflag_return";
+	game["dialog"]["flag_captured"] = "ourflag_capt";
+	game["dialog"]["flag_getback"] = "getback_ourflag";
+	game["dialog"]["enemy_flag_bringhome"] = "enemyflag_tobase";
+	game["dialog"]["enemy_flag_taken"] = "enemyflag";
+	game["dialog"]["enemy_flag_dropped"] = "enemyflag_drop";
+	game["dialog"]["enemy_flag_returned"] = "enemyflag_return";
+	game["dialog"]["enemy_flag_captured"] = "enemyflag_capt";
+
+	game["dialog"]["capturing_a"] = "capturing_a";
+	game["dialog"]["capturing_b"] = "capturing_b";
+	game["dialog"]["capturing_c"] = "capturing_c";
+	game["dialog"]["captured_a"] = "capture_a";
+	game["dialog"]["captured_b"] = "capture_c";
+	game["dialog"]["captured_c"] = "capture_b";
+
+	game["dialog"]["securing_a"] = "securing_a";
+	game["dialog"]["securing_b"] = "securing_b";
+	game["dialog"]["securing_c"] = "securing_c";
+	game["dialog"]["secured_a"] = "secure_a";
+	game["dialog"]["secured_b"] = "secure_b";
+	game["dialog"]["secured_c"] = "secure_c";
+
+	game["dialog"]["losing_a"] = "losing_a";
+	game["dialog"]["losing_b"] = "losing_b";
+	game["dialog"]["losing_c"] = "losing_c";
+	game["dialog"]["lost_a"] = "lost_a";
+	game["dialog"]["lost_b"] = "lost_b";
+	game["dialog"]["lost_c"] = "lost_c";
+
+	game["dialog"]["enemy_taking_a"] = "enemy_take_a";
+	game["dialog"]["enemy_taking_b"] = "enemy_take_b";
+	game["dialog"]["enemy_taking_c"] = "enemy_take_c";
+	game["dialog"]["enemy_has_a"] = "enemy_has_a";
+	game["dialog"]["enemy_has_b"] = "enemy_has_b";
+	game["dialog"]["enemy_has_c"] = "enemy_has_c";
+
+	game["dialog"]["lost_all"] = "take_positions";
+	game["dialog"]["secure_all"] = "positions_lock";
+
+	game["dialog"]["destroy_sentry"] = "dest_sentrygun";
+	game["music"]["nuke_music"] = "nuke_music";
+
+	game["dialog"]["sentry_gone"] = "sentry_gone";
+	game["dialog"]["sentry_destroyed"] = "sentry_gone";
+	game["dialog"]["ti_gone"] = "ti_cancelled";
+	game["dialog"]["ti_destroyed"] = "ti_blocked";
+	
+	level thread onPlayerConnect();
+	level thread onLastAlive();
+	level thread musicController();
+	level thread onGameEnded();
+	level thread onRoundSwitch();
+}
+
+
+onPlayerConnect()
+{
+	for(;;)
+	{
+		level waittill ( "connected", player );
+
+		player thread onPlayerSpawned();
+		player thread finalKillcamMusic();
+	}
+}
+
+
+onPlayerSpawned()
+{
+	self endon ( "disconnect" );
+
+	self waittill( "spawned_player" );
+
+	if ( !level.splitscreen || level.splitscreen && !isDefined( level.playedStartingMusic ) )
+	{
+		self playLocalSound( game["music"]["spawn_" + self.team] );
+		
+
+		if ( level.splitscreen )
+			level.playedStartingMusic = true;
+	}
+
+	if ( isDefined( game["dialog"]["gametype"] ) && (!level.splitscreen || self == level.players[0]) )
+		self leaderDialogOnPlayer( "gametype" );
+
+	gameFlagWait( "prematch_done" );
+
+	if ( self.team == game["attackers"] )
+		self leaderDialogOnPlayer( "offense_obj", "introboost" );
+	else
+		self leaderDialogOnPlayer( "defense_obj", "introboost" );
+}
+
+
+onLastAlive()
+{
+	level endon ( "game_ended" );
+
+	level waittill ( "last_alive", player );
+	
+	if ( !isAlive( player )	)
+		return;
+	
+	player leaderDialogOnPlayer( "last_alive" );
+}
+
+
+onRoundSwitch()
+{
+	level waittill ( "round_switch", switchType );
+
+	switch( switchType )
+	{
+		case "halftime":
+			foreach ( player in level.players )
+				player leaderDialogOnPlayer( "halftime" );
+			break;
+		case "overtime":
+			foreach ( player in level.players )
+				player leaderDialogOnPlayer( "overtime" );
+			break;
+		default:
+			foreach ( player in level.players )
+				player leaderDialogOnPlayer( "side_switch" );
+			break;
+	}
+}
+
+
+onGameEnded()
+{
+	level thread roundWinnerDialog();
+	level thread gameWinnerDialog();
+	
+	level waittill ( "game_win", winner );
+	
+	if ( isDefined( level.nukeDetonated ) )
+	{
+		if ( !level.splitScreen )
+			playSoundOnPlayers( game["music"]["nuke_music"] );
+		else
+			level.players[0] playLocalSound( game["music"]["nuke_music"] );
+			
+		return;
+	}
+
+	if ( level.teamBased )
+	{
+		if ( level.splitscreen )
+		{
+			if ( winner == "allies" )
+				playSoundOnPlayers( game["music"]["victory_allies"], "allies" );
+			else if ( winner == "axis" )
+				playSoundOnPlayers( game["music"]["victory_axis"], "axis" );
+			else
+				playSoundOnPlayers( game["music"]["nuke_music"] );
+		}
+		else
+		{
+			if ( winner == "allies" )
+			{
+				playSoundOnPlayers( game["music"]["victory_allies"], "allies" );
+				playSoundOnPlayers( game["music"]["defeat_axis"], "axis" );
+			}
+			else if ( winner == "axis" )
+			{
+				playSoundOnPlayers( game["music"]["victory_axis"], "axis" );
+				playSoundOnPlayers( game["music"]["defeat_allies"], "allies" );
+			}
+			else
+			{
+				playSoundOnPlayers( game["music"]["nuke_music"] );
+			}
+		}
+	}
+	else
+	{
+		foreach ( player in level.players )
+		{
+			if ( player.pers["team"] != "allies" && player.pers["team"] != "axis" )
+				player playLocalSound( game["music"]["nuke_music"] );			
+			else if ( isDefined( winner ) && player == winner )
+				player playLocalSound( game["music"]["victory_" + player.pers["team"] ] );
+			else if ( !level.splitScreen )
+				player playLocalSound( game["music"]["defeat_" + player.pers["team"] ] );
+		}
+	}
+}
+
+
+roundWinnerDialog()
+{
+	level waittill ( "round_win", winner );
+
+	delay = level.roundEndDelay / 4;
+	if ( delay > 0 )
+		wait ( delay );
+
+	if ( !isDefined( winner ) || isPlayer( winner ) || isDefined( level.nukeDetonated ) )
+		return;
+
+	if ( winner == "allies" )
+	{
+		leaderDialog( "round_success", "allies" );
+		leaderDialog( "round_failure", "axis" );
+	}
+	else if ( winner == "axis" )
+	{
+		leaderDialog( "round_success", "axis" );
+		leaderDialog( "round_failure", "allies" );
+	}
+}
+
+
+gameWinnerDialog()
+{
+	level waittill ( "game_win", winner );
+	
+	delay = level.postRoundTime / 2;
+	if ( delay > 0 )
+		wait ( delay );
+
+	if ( !isDefined( winner ) || isPlayer( winner ) || isDefined( level.nukeDetonated ) )
+		return;
+
+	if ( winner == "allies" )
+	{
+		leaderDialog( "mission_success", "allies" );
+		leaderDialog( "mission_failure", "axis" );
+	}
+	else if ( winner == "axis" )
+	{
+		leaderDialog( "mission_success", "axis" );
+		leaderDialog( "mission_failure", "allies" );
+	}
+	else
+	{
+		leaderDialog( "mission_draw" );
+	}	
+}
+
+
+musicController()
+{
+	level endon ( "game_ended" );
+	
+	if ( !level.hardcoreMode )
+		thread suspenseMusic();
+	
+	level waittill ( "match_ending_soon", reason );
+	assert( isDefined( reason ) );
+
+	if ( getWatchedDvar( "roundlimit" ) == 1 || game["roundsPlayed"] == (getWatchedDvar( "roundlimit" ) - 1) )
+	{	
+		if ( !level.splitScreen )
+		{
+			if ( reason == "time" )
+			{
+				if ( level.teamBased )
+				{
+					if ( game["teamScores"]["allies"] > game["teamScores"]["axis"] )
+					{
+						if ( !level.hardcoreMode )
+						{
+							playSoundOnPlayers( game["music"]["winning_allies"], "allies" );
+							playSoundOnPlayers( game["music"]["losing_axis"], "axis" );
+						}
+				
+						leaderDialog( "winning_time", "allies" );
+						leaderDialog( "losing_time", "axis" );
+					}
+					else if ( game["teamScores"]["axis"] > game["teamScores"]["allies"] )
+					{
+						if ( !level.hardcoreMode )
+						{
+							playSoundOnPlayers( game["music"]["winning_axis"], "axis" );
+							playSoundOnPlayers( game["music"]["losing_allies"], "allies" );
+						}
+							
+						leaderDialog( "winning_time", "axis" );
+						leaderDialog( "losing_time", "allies" );
+					}
+					else if ( game["teamScores"]["axis"] == game["teamScores"]["allies"] )
+					{
+						if ( !level.hardcoreMode )
+						{
+							playSoundOnPlayers( game["music"]["losing_axis"], "axis" );
+							playSoundOnPlayers( game["music"]["losing_allies"], "allies" );
+						}
+							
+						leaderDialog( "lead_tied", "axis" );
+						leaderDialog( "lead_tied", "allies" );
+					}
+				}
+				else
+				{
+					if ( !level.hardcoreMode )
+						playSoundOnPlayers( game["music"]["losing_time"] );
+	
+					leaderDialog( "timesup" );
+				}
+			}	
+			else if ( reason == "score" )
+			{
+				if ( level.teamBased )
+				{
+					if ( game["teamScores"]["allies"] > game["teamScores"]["axis"] )
+					{
+						if ( !level.hardcoreMode )
+						{
+							playSoundOnPlayers( game["music"]["winning_allies"], "allies" );
+							playSoundOnPlayers( game["music"]["losing_axis"], "axis" );
+						}
+				
+						leaderDialog( "winning_score", "allies" );
+						leaderDialog( "losing_score", "axis" );
+					}
+					else if ( game["teamScores"]["axis"] > game["teamScores"]["allies"] )
+					{
+						if ( !level.hardcoreMode )
+						{
+							playSoundOnPlayers( game["music"]["winning_axis"], "axis" );
+							playSoundOnPlayers( game["music"]["losing_allies"], "allies" );
+						}
+							
+						leaderDialog( "winning_score", "axis" );
+						leaderDialog( "losing_score", "allies" );
+					}
+					else if ( game["teamScores"]["axis"] == game["teamScores"]["allies"] )
+					{
+						if ( !level.hardcoreMode )
+						{
+							playSoundOnPlayers( game["music"]["losing_axis"], "axis" );
+							playSoundOnPlayers( game["music"]["losing_allies"], "allies" );
+						}
+							
+						leaderDialog( "lead_tied", "axis" );
+						leaderDialog( "lead_tied", "allies" );
+					}
+				}
+				else
+				{
+					winningPlayer = maps\mp\gametypes\_gamescore::getHighestScoringPlayer();
+					losingPlayers = maps\mp\gametypes\_gamescore::getLosingPlayers();
+					excludeList[0] = winningPlayer;
+
+					if ( !level.hardcoreMode )
+					{
+						winningPlayer playLocalSound( game["music"]["winning_" + winningPlayer.pers["team"] ] );
+						
+						foreach ( otherPlayer in level.players )
+						{
+							if ( otherPlayer == winningPlayer )
+								continue;
+								
+							otherPlayer playLocalSound( game["music"]["losing_" + otherPlayer.pers["team"] ] );							
+						}
+					}
+	
+					winningPlayer leaderDialogOnPlayer( "winning_score" );
+					leaderDialogOnPlayers( "losing_score", losingPlayers );
+				}
+			}
+			
+			level waittill ( "match_ending_very_soon" );
+			leaderDialog( "timesup" );
+		}
+	}
+	else
+	{
+		if ( !level.hardcoreMode )
+			playSoundOnPlayers( game["music"]["losing_allies"] );
+
+		leaderDialog( "timesup" );
+	}
+}
+
+
+suspenseMusic()
+{
+	level endon ( "game_ended" );
+	level endon ( "match_ending_soon" );
+	
+	numTracks = game["music"]["suspense"].size;
+	for ( ;; )
+	{
+		wait ( randomFloatRange( 60, 120 ) );
+		
+		playSoundOnPlayers( game["music"]["suspense"][randomInt(numTracks)] ); 
+	}
+}
+
+
+finalKillcamMusic()
+{
+	self waittill ( "showing_final_killcam" );
+	
+//	self playLocalSound( game["music"]["winning"] );
+}

iw4x/iw4x_00/maps/mp/gametypes/_quickmessages.gsc

@@ -0,0 +1,270 @@
+init()
+{
+	game["menu_quickcommands"] = "quickcommands";
+	game["menu_quickstatements"] = "quickstatements";
+	game["menu_quickresponses"] = "quickresponses";
+
+	precacheMenu(game["menu_quickcommands"]);
+	precacheMenu(game["menu_quickstatements"]);
+	precacheMenu(game["menu_quickresponses"]);
+	precacheHeadIcon("talkingicon");
+
+	precacheString( &"QUICKMESSAGE_FOLLOW_ME" );
+	precacheString( &"QUICKMESSAGE_MOVE_IN" );
+	precacheString( &"QUICKMESSAGE_FALL_BACK" );
+	precacheString( &"QUICKMESSAGE_SUPPRESSING_FIRE" );
+	precacheString( &"QUICKMESSAGE_ATTACK_LEFT_FLANK" );
+	precacheString( &"QUICKMESSAGE_ATTACK_RIGHT_FLANK" );
+	precacheString( &"QUICKMESSAGE_HOLD_THIS_POSITION" );
+	precacheString( &"QUICKMESSAGE_REGROUP" );
+	precacheString( &"QUICKMESSAGE_ENEMY_SPOTTED" );
+	precacheString( &"QUICKMESSAGE_ENEMIES_SPOTTED" );
+	precacheString( &"QUICKMESSAGE_IM_IN_POSITION" );
+	precacheString( &"QUICKMESSAGE_AREA_SECURE" );
+	precacheString( &"QUICKMESSAGE_GRENADE" );
+	precacheString( &"QUICKMESSAGE_SNIPER" );
+	precacheString( &"QUICKMESSAGE_NEED_REINFORCEMENTS" );
+	precacheString( &"QUICKMESSAGE_HOLD_YOUR_FIRE" );
+	precacheString( &"QUICKMESSAGE_YES_SIR" );
+	precacheString( &"QUICKMESSAGE_NO_SIR" );
+	precacheString( &"QUICKMESSAGE_IM_ON_MY_WAY" );
+	precacheString( &"QUICKMESSAGE_SORRY" );
+	precacheString( &"QUICKMESSAGE_GREAT_SHOT" );
+	precacheString( &"QUICKMESSAGE_TOOK_LONG_ENOUGH" );
+	precacheString( &"QUICKMESSAGE_ARE_YOU_CRAZY" );	
+	precacheString( &"QUICKMESSAGE_WATCH_SIX" );	
+	precacheString( &"QUICKMESSAGE_COME_ON" );	
+}
+
+quickcommands(response)
+{
+	self endon ( "disconnect" );
+	
+	if(!isdefined(self.pers["team"]) || self.pers["team"] == "spectator" || isdefined(self.spamdelay))
+		return;
+
+	self.spamdelay = true;
+	
+	switch(response)		
+	{
+		case "1":
+			soundalias = "mp_cmd_followme";
+			saytext = &"QUICKMESSAGE_FOLLOW_ME";
+			//saytext = "Follow Me!";
+			break;
+
+		case "2":
+			soundalias = "mp_cmd_movein";
+			saytext = &"QUICKMESSAGE_MOVE_IN";
+			//saytext = "Move in!";
+			break;
+
+		case "3":
+			soundalias = "mp_cmd_fallback";
+			saytext = &"QUICKMESSAGE_FALL_BACK";
+			//saytext = "Fall back!";
+			break;
+
+		case "4":
+			soundalias = "mp_cmd_suppressfire";
+			saytext = &"QUICKMESSAGE_SUPPRESSING_FIRE";
+			//saytext = "Suppressing fire!";
+			break;
+
+		case "5":
+			soundalias = "mp_cmd_attackleftflank";
+			saytext = &"QUICKMESSAGE_ATTACK_LEFT_FLANK";
+			//saytext = "Attack left flank!";
+			break;
+
+		case "6":
+			soundalias = "mp_cmd_attackrightflank";
+			saytext = &"QUICKMESSAGE_ATTACK_RIGHT_FLANK";
+			//saytext = "Attack right flank!";
+			break;
+
+		case "7":
+			soundalias = "mp_cmd_holdposition";
+			saytext = &"QUICKMESSAGE_HOLD_THIS_POSITION";
+			//saytext = "Hold this position!";
+			break;
+
+		default:
+			assert(response == "8");
+			soundalias = "mp_cmd_regroup";
+			saytext = &"QUICKMESSAGE_REGROUP";
+			//saytext = "Regroup!";
+			break;
+	}
+
+	self saveHeadIcon();
+	self doQuickMessage(soundalias, saytext);
+
+	wait 2;
+	self.spamdelay = undefined;
+	self restoreHeadIcon();	
+}
+
+quickstatements(response)
+{
+	if(!isdefined(self.pers["team"]) || self.pers["team"] == "spectator" || isdefined(self.spamdelay))
+		return;
+
+	self.spamdelay = true;
+	
+	switch(response)		
+	{
+		case "1":
+			soundalias = "mp_stm_grenade";
+			saytext = &"QUICKMESSAGE_ENEMY_SPOTTED";
+			//saytext = "Enemy spotted!";
+			break;
+
+		case "2":
+			soundalias = "mp_stm_enemyspotted";
+			saytext = &"QUICKMESSAGE_ENEMIES_SPOTTED";
+			//saytext = "Enemy down!";
+			break;
+
+		case "3":
+			soundalias = "mp_stm_iminposition";
+			saytext = &"QUICKMESSAGE_IM_IN_POSITION";
+			//saytext = "I'm in position.";
+			break;
+
+		case "4":
+			soundalias = "mp_stm_areasecure";
+			saytext = &"QUICKMESSAGE_AREA_SECURE";
+			//saytext = "Area secure!";
+			break;
+
+		case "5":
+			soundalias = "mp_stm_holdyourfire";
+			saytext = &"QUICKMESSAGE_WATCH_SIX";
+			//saytext = "Hold your fire!";
+			break;
+
+		case "6":
+			soundalias = "mp_stm_sniper";
+			saytext = &"QUICKMESSAGE_SNIPER";
+			//saytext = "Sniper!";
+			break;
+
+		default:
+			assert(response == "7");
+			soundalias = "mp_stm_needreinforcements";
+			saytext = &"QUICKMESSAGE_NEED_REINFORCEMENTS";
+			//saytext = "Need reinforcements!";
+			break;
+	}
+
+	self saveHeadIcon();
+	self doQuickMessage(soundalias, saytext);
+
+	wait 2;
+	self.spamdelay = undefined;
+	self restoreHeadIcon();
+}
+
+quickresponses(response)
+{
+	if(!isdefined(self.pers["team"]) || self.pers["team"] == "spectator" || isdefined(self.spamdelay))
+		return;
+
+	self.spamdelay = true;
+
+	switch(response)		
+	{
+		case "1":
+			soundalias = "mp_rsp_yessir";
+			saytext = &"QUICKMESSAGE_YES_SIR";
+			//saytext = "Yes Sir!";
+			break;
+
+		case "2":
+			soundalias = "mp_rsp_nosir";
+			saytext = &"QUICKMESSAGE_NO_SIR";
+			//saytext = "No Sir!";
+			break;
+
+		case "3":
+			soundalias = "mp_rsp_onmyway";
+			saytext = &"QUICKMESSAGE_IM_ON_MY_WAY";
+			//saytext = "On my way.";
+			break;
+
+		case "4":
+			soundalias = "mp_rsp_sorry";
+			saytext = &"QUICKMESSAGE_SORRY";
+			//saytext = "Sorry.";
+			break;
+
+		case "5":
+			soundalias = "mp_rsp_greatshot";
+			saytext = &"QUICKMESSAGE_GREAT_SHOT";
+			//saytext = "Great shot!";
+			break;
+
+		default:
+			assert(response == "6");
+			soundalias = "mp_rsp_areyoucrazy";
+			saytext = &"QUICKMESSAGE_COME_ON";
+			//saytext = "Come on!";
+			break;
+	}
+
+	self saveHeadIcon();
+	self doQuickMessage(soundalias, saytext);
+
+	wait 2;
+	self.spamdelay = undefined;
+	self restoreHeadIcon();
+}
+
+doQuickMessage( soundalias, saytext )
+{
+	if(self.sessionstate != "playing")
+		return;
+
+	prefix = maps\mp\gametypes\_teams::getTeamVoicePrefix( self.team );
+
+	if(isdefined(level.QuickMessageToAll) && level.QuickMessageToAll)
+	{
+		self.headiconteam = "none";
+		self.headicon = "talkingicon";
+
+		self playSound( prefix+soundalias );
+		self sayAll(saytext);
+	}
+	else
+	{
+		if(self.sessionteam == "allies")
+			self.headiconteam = "allies";
+		else if(self.sessionteam == "axis")
+			self.headiconteam = "axis";
+		
+		self.headicon = "talkingicon";
+
+		self playSound( prefix+soundalias );
+		self sayTeam( saytext );
+		self pingPlayer();
+	}
+}
+
+saveHeadIcon()
+{
+	if(isdefined(self.headicon))
+		self.oldheadicon = self.headicon;
+
+	if(isdefined(self.headiconteam))
+		self.oldheadiconteam = self.headiconteam;
+}
+
+restoreHeadIcon()
+{
+	if(isdefined(self.oldheadicon))
+		self.headicon = self.oldheadicon;
+
+	if(isdefined(self.oldheadiconteam))
+		self.headiconteam = self.oldheadiconteam;
+}

iw4x/iw4x_00/maps/mp/gametypes/ctf.gsc

@@ -0,0 +1,773 @@
+#include common_scripts\utility;
+#include maps\mp\_utility;
+#include maps\mp\gametypes\_hud_util;
+/*
+	One Flag CTF
+*/
+
+/*QUAKED mp_ctf_spawn_axis (0.75 0.0 0.5) (-16 -16 0) (16 16 72)
+Axis players spawn away from enemies and near their team at one of these positions.*/
+
+/*QUAKED mp_ctf_spawn_allies (0.0 0.75 0.5) (-16 -16 0) (16 16 72)
+Allied players spawn away from enemies and near their team at one of these positions.*/
+
+/*QUAKED mp_ctf_spawn_axis_start (1.0 0.0 0.5) (-16 -16 0) (16 16 72)
+Axis players spawn away from enemies and near their team at one of these positions at the start of a round.*/
+
+/*QUAKED mp_ctf_spawn_allies_start (0.0 1.0 0.5) (-16 -16 0) (16 16 72)
+Allied players spawn away from enemies and near their team at one of these positions at the start of a round.*/
+
+main()
+{
+	maps\mp\gametypes\_globallogic::init();
+	maps\mp\gametypes\_callbacksetup::SetupCallbacks();
+	maps\mp\gametypes\_globallogic::SetupCallbacks();
+
+	registerTimeLimitDvar( level.gameType, 3, 0, 1440 );
+	registerScoreLimitDvar( level.gameType, 1, 0, 10000 );
+	registerRoundLimitDvar( level.gameType, 0, 0, 30 );
+	registerWinLimitDvar( level.gameType, 4, 0, 10 );
+	registerRoundSwitchDvar( level.gameType, 3, 0, 30 );
+	registerNumLivesDvar( level.gameType, 0, 0, 10 );
+	registerHalfTimeDvar( level.gameType, 1, 0, 1 );
+
+	setOverTimeLimitDvar( 4 );
+	
+	level.teamBased = true;
+	level.onPrecacheGameType = ::onPrecacheGameType;
+	level.onStartGameType = ::onStartGameType;
+	level.getSpawnPoint = ::getSpawnPoint;
+	level.onPlayerKilled = ::onPlayerKilled;
+	level.initGametypeAwards = ::initGametypeAwards;
+	level.onTimeLimit = ::onTimeLimit;
+	level.onSpawnPlayer = ::onSpawnPlayer;
+
+	level.flagReturnTime = getIntProperty( "scr_ctf_returntime", 30 );
+
+	game["dialog"]["gametype"] = "captureflag";
+
+	if ( getDvarInt( "g_hardcore" ) )
+		game["dialog"]["gametype"] = "hc_" + game["dialog"]["gametype"];
+	else if ( getDvarInt( "camera_thirdPerson" ) )
+		game["dialog"]["gametype"] = "thirdp_" + game["dialog"]["gametype"];
+	else if ( getDvarInt( "scr_diehard" ) )
+		game["dialog"]["gametype"] = "dh_" + game["dialog"]["gametype"];
+	else if (getDvarInt( "scr_" + level.gameType + "_promode" ) )
+		game["dialog"]["gametype"] = game["dialog"]["gametype"] + "_pro";
+
+	game["dialog"]["offense_obj"] = "capture_obj";
+	game["dialog"]["defense_obj"] = "capture_obj";
+}
+
+onPrecacheGameType()
+{
+	precacheString(&"MP_FLAG_TAKEN_BY");
+	precacheString(&"MP_ENEMY_FLAG_TAKEN_BY");
+	precacheString(&"MP_FLAG_CAPTURED_BY");
+	precacheString(&"MP_ENEMY_FLAG_CAPTURED_BY");
+	precacheString(&"MP_FLAG_RETURNED");
+	precacheString(&"MP_ENEMY_FLAG_RETURNED");
+	precacheString(&"MP_YOUR_FLAG_RETURNING_IN");
+	precacheString(&"MP_ENEMY_FLAG_RETURNING_IN");
+	precacheString(&"MP_ENEMY_FLAG_DROPPED_BY");
+	precacheString(&"MP_DOM_NEUTRAL_FLAG_CAPTURED");
+	precacheString(&"MP_GRABBING_FLAG");
+	precacheString(&"MP_RETURNING_FLAG");
+}
+
+
+onSpawnPlayer()
+{
+	if( ( inOvertime() ) && !isDefined( self.otSpawned ) )
+		self thread printOTHint();
+}
+
+
+printOTHint()
+{
+	self endon ( "disconnect" );
+	// give the "Overtime!" message time to show
+	wait ( 0.25 );
+
+	self.otSpawned = true;
+	hintMessage = getObjectiveHintText( self.team );
+	self thread maps\mp\gametypes\_hud_message::hintMessage( hintMessage );
+}
+
+
+onStartGameType()
+{
+	if ( !isdefined( game["switchedsides"] ) )
+		game["switchedsides"] = false;
+
+	if ( !isdefined( game["original_defenders"] ) )
+		game["original_defenders"] = game["defenders"];
+
+	if ( game["switchedsides"] )
+	{
+		oldAttackers = game["attackers"];
+		oldDefenders = game["defenders"];
+		game["attackers"] = oldDefenders;
+		game["defenders"] = oldAttackers;
+	}
+
+	setClientNameMode("auto_change");
+	
+	if ( level.splitscreen )
+	{
+		if ( inOvertime() )
+		{
+			setObjectiveScoreText( game["attackers"], &"OBJECTIVES_GRAB_FLAG" );
+			setObjectiveScoreText( game["defenders"], &"OBJECTIVES_GRAB_FLAG" );
+		}
+		else
+		{
+			setObjectiveScoreText( game["attackers"], &"OBJECTIVES_ONE_FLAG_ATTACKER" );
+			setObjectiveScoreText( game["defenders"], &"OBJECTIVES_ONE_FLAG_DEFENDER" );
+		}
+	}
+	else
+	{
+		if ( inOvertime() )
+		{
+			setObjectiveScoreText( game["attackers"], &"OBJECTIVES_GRAB_FLAG_SCORE" );
+			setObjectiveScoreText( game["defenders"], &"OBJECTIVES_GRAB_FLAG_SCORE" );
+		}
+		else
+		{
+			setObjectiveScoreText( game["attackers"], &"OBJECTIVES_ONE_FLAG_ATTACKER_SCORE" );
+			setObjectiveScoreText( game["defenders"], &"OBJECTIVES_ONE_FLAG_DEFENDER_SCORE" );
+		}
+	}
+	
+	if ( inOvertime() )
+	{
+		setObjectiveText( game["attackers"], &"OBJECTIVES_OVERTIME_CTF" );
+		setObjectiveText( game["defenders"], &"OBJECTIVES_OVERTIME_CTF" );
+		setObjectiveHintText( game["attackers"], &"OBJECTIVES_GRAB_FLAG_HINT" );
+		setObjectiveHintText( game["defenders"], &"OBJECTIVES_GRAB_FLAG_HINT" );
+	}
+	else
+	{
+		setObjectiveText( game["attackers"], &"OBJECTIVES_CTF" );
+		setObjectiveText( game["defenders"], &"OBJECTIVES_CTF" );
+		setObjectiveHintText( game["attackers"], &"OBJECTIVES_ONE_FLAG_ATTACKER_HINT" );
+		setObjectiveHintText( game["defenders"], &"OBJECTIVES_ONE_FLAG_DEFENDER_HINT" );
+	}
+
+	level.spawnMins = ( 0, 0, 0 );
+	level.spawnMaxs = ( 0, 0, 0 );
+	maps\mp\gametypes\_spawnlogic::placeSpawnPoints( "mp_ctf_spawn_allies_start" );
+	maps\mp\gametypes\_spawnlogic::placeSpawnPoints( "mp_ctf_spawn_axis_start" );
+	maps\mp\gametypes\_spawnlogic::addSpawnPoints( "allies", "mp_ctf_spawn_allies" );
+	maps\mp\gametypes\_spawnlogic::addSpawnPoints( "axis", "mp_ctf_spawn_axis" );
+	
+	level.mapCenter = maps\mp\gametypes\_spawnlogic::findBoxCenter( level.spawnMins, level.spawnMaxs );
+	setMapCenter( level.mapCenter );
+	
+	thread maps\mp\gametypes\_dev::init();
+	
+	maps\mp\gametypes\_rank::registerScoreInfo( "kill", 50 );
+	maps\mp\gametypes\_rank::registerScoreInfo( "headshot", 50 );
+	maps\mp\gametypes\_rank::registerScoreInfo( "assist", 20 );
+	
+	maps\mp\gametypes\_rank::registerScoreInfo( "pickup", 50 );
+	maps\mp\gametypes\_rank::registerScoreInfo( "return", 50 );
+	maps\mp\gametypes\_rank::registerScoreInfo( "capture", 250 );
+	
+	maps\mp\gametypes\_rank::registerScoreInfo( "kill_carrier", 50 );
+	
+	maps\mp\gametypes\_rank::registerScoreInfo( "defend", 100 );
+	maps\mp\gametypes\_rank::registerScoreInfo( "defend_assist", 100 );
+	
+	maps\mp\gametypes\_rank::registerScoreInfo( "assault", 200 );
+	maps\mp\gametypes\_rank::registerScoreInfo( "assault_assist", 40 );
+	
+	allowed[0] = "ctf";
+	maps\mp\gametypes\_gameobjects::main(allowed);
+		
+	thread ctf();
+}
+
+
+getSpawnPoint()
+{
+	if ( self.team == "axis" )
+		spawnTeam = game["attackers"];
+	else
+		spawnTeam = game["defenders"];
+
+//	if ( game["switchedsides"] )
+//		spawnTeam = getOtherTeam( spawnteam );
+	
+	if ( level.inGracePeriod )
+	{
+		if ( getDvar( "mapname" ) == "mp_shipment_long" )
+		{
+			spawnPoints = getentarray("mp_cha_spawn_" + spawnteam + "_start", "classname");		
+			spawnPoint = maps\mp\gametypes\_spawnlogic::getSpawnpoint_Random( spawnPoints );
+		}
+		else
+		{
+			spawnPoints = getentarray("mp_ctf_spawn_" + spawnteam + "_start", "classname");		
+			spawnPoint = maps\mp\gametypes\_spawnlogic::getSpawnpoint_Random( spawnPoints );
+		}
+	}
+	else
+	{
+		if ( getDvar( "mapname" ) == "mp_shipment_long" )
+		{
+			spawnPoints = maps\mp\gametypes\_spawnlogic::getSpawnpointArray( "mp_cha_spawn_" + spawnteam );
+			spawnPoint = maps\mp\gametypes\_spawnlogic::getSpawnpoint_Random( spawnPoints );
+		}
+		else
+		{
+			spawnPoints = maps\mp\gametypes\_spawnlogic::getTeamSpawnPoints( spawnteam );
+			spawnPoint = maps\mp\gametypes\_spawnlogic::getSpawnpoint_NearTeam( spawnPoints );
+		}
+	}
+	
+	return spawnPoint;
+}
+
+
+ctf()
+{
+	level.flagModel["allies"] = maps\mp\gametypes\_teams::getTeamFlagModel( "allies" );
+	level.icon2D["allies"] = maps\mp\gametypes\_teams::getTeamFlagIcon( "allies" );
+	level.carryFlag["allies"] = maps\mp\gametypes\_teams::getTeamFlagCarryModel( "allies" );
+
+	precacheModel( level.flagModel["allies"] );
+	precacheModel( level.carryFlag["allies"] );
+
+	level.flagModel["axis"] = maps\mp\gametypes\_teams::getTeamFlagModel( "axis" );
+	level.icon2D["axis"] = maps\mp\gametypes\_teams::getTeamFlagIcon( "axis" );
+	level.carryFlag["axis"] = maps\mp\gametypes\_teams::getTeamFlagCarryModel( "axis" );
+
+	precacheModel( level.flagModel["axis"] );
+	precacheModel( level.carryFlag["axis"] );
+	
+	level.iconEscort3D = "waypoint_escort";
+	level.iconEscort2D = "waypoint_escort";
+	precacheShader( level.iconEscort3D );
+	precacheShader( level.iconEscort2D );
+	//level.iconEscort2D = level.iconEscort3D; // flags with words on compass
+
+	level.iconKill3D = "waypoint_kill";
+	level.iconKill2D = "waypoint_kill";
+	precacheShader( level.iconKill3D );
+	precacheShader( level.iconKill2D );
+	//level.iconKill2D = level.iconKill3D; // flags with words on compass
+
+	level.iconCaptureFlag3D = "waypoint_capture_flag";
+	level.iconCaptureFlag2D = "waypoint_capture_flag";
+	precacheShader( level.iconCaptureFlag3D );
+	precacheShader( level.iconCaptureFlag2D );
+	//level.iconCaptureFlag2D = level.iconCaptureFlag3D; // flags with words on compass
+
+	level.iconDefendFlag3D = "waypoint_defend_flag";
+	level.iconDefendFlag2D = "waypoint_defend_flag";
+	precacheShader( level.iconDefendFlag3D );
+	precacheShader( level.iconDefendFlag2D );
+	//level.iconDefendFlag2D = level.iconDefendFlag3D; // flags with words on compass
+
+	level.iconReturnFlag3D = "waypoint_return_flag";
+	level.iconReturnFlag2D = "waypoint_return_flag";
+	precacheShader( level.iconReturnFlag3D );
+	precacheShader( level.iconReturnFlag2D );
+	//level.iconReturnFlag2D = level.iconReturnFlag3D; // flags with words on compass
+
+	level.iconWaitForFlag3D = "waypoint_waitfor_flag";
+	level.iconWaitForFlag2D = "waypoint_waitfor_flag";
+	precacheShader( level.iconWaitForFlag3D );
+	precacheShader( level.iconWaitForFlag2D );
+	//level.iconWaitForFlag2D = level.iconWaitForFlag3D; // flags with words on compass
+	
+	precacheShader( level.icon2D["axis"] );
+	precacheShader( level.icon2D["allies"] );
+	
+	precacheShader( "waypoint_flag_friendly" );
+	precacheShader( "waypoint_flag_enemy" );
+
+	precacheString( &"OBJECTIVES_FLAG_HOME" );
+	precacheString( &"OBJECTIVES_FLAG_NAME" );
+	precacheString( &"OBJECTIVES_FLAG_AWAY" );
+	
+	level.teamFlags[game["defenders"]] = createTeamFlag( game["defenders"], "allies" );
+	level.teamFlags[game["attackers"]] = createTeamFlag( game["attackers"], level.otherTeam["allies"] );
+
+	level.capZones[game["defenders"]] = createCapZone( game["defenders"], "allies" );
+	level.capZones[game["attackers"]] = createCapZone( game["attackers"], level.otherTeam["allies"] );
+	
+	if ( level.splitScreen )
+		hudElemAlpha = 0;
+	else
+		hudElemAlpha = 0.85;
+	
+	level.friendlyFlagStatusIcon["allies"] = createServerIcon( "waypoint_flag_friendly", 32, 32, "allies" );
+	level.friendlyFlagStatusIcon["allies"] setPoint( "TOP LEFT", "TOP LEFT", 132, 0 );
+	level.friendlyFlagStatusIcon["allies"].alpha = hudElemAlpha;
+	level.friendlyFlagStatusIcon["allies"].hideWhenInMenu = true;
+
+	level.friendlyFlagStatusText["allies"] = createServerFontString( "small", 1.6, "allies" );	
+	level.friendlyFlagStatusText["allies"] setParent( level.friendlyFlagStatusIcon["allies"] );
+	level.friendlyFlagStatusText["allies"] setPoint( "LEFT", "RIGHT", 4 );
+	level.friendlyFlagStatusText["allies"] setText( &"OBJECTIVES_FLAG_HOME" );
+	level.friendlyFlagStatusText["allies"].alpha = hudElemAlpha;
+	level.friendlyFlagStatusText["allies"].color = (1,1,1);
+	level.friendlyFlagStatusText["allies"].glowAlpha = 1;
+	level.friendlyFlagStatusText["allies"].hideWhenInMenu = true;
+
+	level.enemyFlagStatusIcon["allies"] = createServerIcon( "waypoint_flag_enemy", 24, 24, "allies" );
+	level.enemyFlagStatusIcon["allies"] setPoint( "TOP LEFT", "TOP LEFT", 132, 26 );
+	level.enemyFlagStatusIcon["allies"].alpha = hudElemAlpha;
+	level.enemyFlagStatusIcon["allies"].hideWhenInMenu = true;
+
+	level.enemyFlagStatusText["allies"] = createServerFontString( "small", 1.6, "allies" );
+	level.enemyFlagStatusText["allies"] setParent( level.enemyFlagStatusIcon["allies"] );
+	level.enemyFlagStatusText["allies"] setPoint( "LEFT", "RIGHT", 4 );
+	level.enemyFlagStatusText["allies"] setText( &"OBJECTIVES_FLAG_HOME" );	
+	level.enemyFlagStatusText["allies"].alpha = hudElemAlpha;
+	level.enemyFlagStatusText["allies"].color = (1,1,1);
+	level.enemyFlagStatusText["allies"].glowAlpha = 1;
+	level.enemyFlagStatusText["allies"].hideWhenInMenu = true;
+
+
+	level.friendlyFlagStatusIcon["axis"] = createServerIcon( "waypoint_flag_friendly", 32, 32, "axis" );
+	level.friendlyFlagStatusIcon["axis"] setPoint( "TOP LEFT", "TOP LEFT", 132, 0 );
+	level.friendlyFlagStatusIcon["axis"].alpha = hudElemAlpha;
+	level.friendlyFlagStatusIcon["axis"].hideWhenInMenu = true;
+
+	level.friendlyFlagStatusText["axis"] = createServerFontString( "small", 1.6, "axis" );	
+	level.friendlyFlagStatusText["axis"] setParent( level.friendlyFlagStatusIcon["axis"] );
+	level.friendlyFlagStatusText["axis"] setPoint( "LEFT", "RIGHT", 4 );
+	level.friendlyFlagStatusText["axis"] setText( &"OBJECTIVES_FLAG_HOME" );
+	level.friendlyFlagStatusText["axis"].alpha = hudElemAlpha;
+	level.friendlyFlagStatusText["axis"].color = (1,1,1);
+	level.friendlyFlagStatusText["axis"].glowAlpha = 1;
+	level.friendlyFlagStatusText["axis"].hideWhenInMenu = true;
+
+	level.enemyFlagStatusIcon["axis"] = createServerIcon( "waypoint_flag_enemy", 24, 24, "axis" );
+	level.enemyFlagStatusIcon["axis"] setPoint( "TOP LEFT", "TOP LEFT", 132, 26 );
+	level.enemyFlagStatusIcon["axis"].alpha = hudElemAlpha;
+	level.enemyFlagStatusIcon["axis"].hideWhenInMenu = true;
+
+	level.enemyFlagStatusText["axis"] = createServerFontString( "small", 1.6, "axis" );
+	level.enemyFlagStatusText["axis"] setParent( level.enemyFlagStatusIcon["axis"] );
+	level.enemyFlagStatusText["axis"] setPoint( "LEFT", "RIGHT", 4 );
+	level.enemyFlagStatusText["axis"] setText( &"OBJECTIVES_FLAG_HOME" );	
+	level.enemyFlagStatusText["axis"].alpha = hudElemAlpha;
+	level.enemyFlagStatusText["axis"].color = (1,1,1);
+	level.enemyFlagStatusText["axis"].glowAlpha = 1;
+	level.enemyFlagStatusText["axis"].hideWhenInMenu = true;
+}
+
+//sets overtime and associated variables
+onTimeLimit()
+{
+	if ( !inOvertime() && game["teamScores"]["allies"] == game["teamScores"]["axis"] && game["switchedsides"] )
+	{
+		thread maps\mp\gametypes\_gamelogic::endGame( "overtime", game["strings"]["time_limit_reached"] );
+	}
+	else if( game["teamScores"]["axis"] > game["teamScores"]["allies"] )
+	{
+		thread maps\mp\gametypes\_gamelogic::endGame( "axis", game["strings"]["time_limit_reached"] );
+	}
+	else if( game["teamScores"]["axis"] < game["teamScores"]["allies"] )
+	{
+		thread maps\mp\gametypes\_gamelogic::endGame( "allies", game["strings"]["time_limit_reached"] );
+	}
+	else if ( inOvertime() )
+	{
+		thread maps\mp\gametypes\_gamelogic::endGame( "tie", game["strings"]["time_limit_reached"] );
+	}
+}
+
+spawnFxDelay( fxid, pos, forward, right, delay )
+{
+	wait delay;
+	effect = spawnFx( fxid, pos, forward, right );
+	triggerFx( effect );
+}
+
+createTeamFlag( team, entityTeam )
+{
+	trigger = getEnt( "ctf_zone_" + entityTeam, "targetname" );
+	if ( !isDefined( trigger ) ) 
+	{
+		error( "No ctf_zone_" + entityTeam + " trigger found in map." );
+		return;
+	}
+	visuals[0] = getEnt( "ctf_flag_" + entityTeam, "targetname" );
+	if ( !isDefined( visuals[0] ) ) 
+	{
+		error( "No ctf_flag_" + entityTeam + " script_model found in map." );
+		return;
+	}
+	
+	cloneTrigger = spawn( "trigger_radius", trigger.origin, 0, 96, trigger.height );
+	trigger = cloneTrigger;
+	
+	visuals[0] setModel( level.flagModel[team] );
+	
+	teamFlag = maps\mp\gametypes\_gameobjects::createCarryObject( team, trigger, visuals, (0,0,85) );
+	teamFlag maps\mp\gametypes\_gameobjects::setTeamUseTime( "friendly", 0.5 );
+	teamFlag maps\mp\gametypes\_gameobjects::setTeamUseTime( "enemy", 0.5 );
+	teamFlag maps\mp\gametypes\_gameobjects::setTeamUseText( "enemy", &"MP_GRABBING_FLAG" );
+	teamFlag maps\mp\gametypes\_gameobjects::setTeamUseText( "friendly", &"MP_RETURNING_FLAG" );
+	teamFlag maps\mp\gametypes\_gameobjects::allowCarry( "enemy" );
+	
+	teamFlag maps\mp\gametypes\_gameobjects::setVisibleTeam( "none" );
+	teamFlag maps\mp\gametypes\_gameobjects::set2DIcon( "friendly", level.iconKill2D );
+	teamFlag maps\mp\gametypes\_gameobjects::set3DIcon( "friendly", level.iconKill3D );
+	teamFlag maps\mp\gametypes\_gameobjects::set2DIcon( "enemy", level.iconEscort2D );
+	teamFlag maps\mp\gametypes\_gameobjects::set3DIcon( "enemy", level.iconEscort3D );
+
+	teamFlag maps\mp\gametypes\_gameobjects::setCarryIcon( level.icon2D[team] );
+	teamFlag.objIDPingFriendly = true;
+	teamFlag.allowWeapons = true;
+	teamFlag.onPickup = ::onPickup;
+	teamFlag.onPickupFailed = ::onPickup;
+	teamFlag.onDrop = ::onDrop;
+	teamFlag.onReset = ::onReset;
+	
+	teamFlag.oldRadius = trigger.radius;
+
+	traceStart = trigger.origin + (0,0,32);
+	traceEnd = trigger.origin + (0,0,-32);
+	trace = bulletTrace( traceStart, traceEnd, false, undefined );
+	
+	fx = maps\mp\gametypes\_teams::getTeamFlagFX( team );
+	fxid = loadfx( fx );
+	
+	upangles = vectorToAngles( trace["normal"] );
+	forward = anglesToForward( upangles );
+	right = anglesToRight( upangles );
+	
+	thread spawnFxDelay( fxid, trace["position"], forward, right, 0.5 );
+	
+	return teamFlag;
+}
+
+createCapZone( team, entityTeam )
+{
+	trigger = getEnt( "ctf_zone_" + entityTeam, "targetname" );
+	if ( !isDefined( trigger ) ) 
+	{
+		error("No ctf_zone_" + entityTeam + " trigger found in map.");
+		return;
+	}
+	
+	visuals = [];
+	capZone = maps\mp\gametypes\_gameobjects::createUseObject( team, trigger, visuals, (0,0,85) );
+	capZone maps\mp\gametypes\_gameobjects::allowUse( "friendly" );
+
+	capZone maps\mp\gametypes\_gameobjects::setVisibleTeam( "any" );
+	capZone maps\mp\gametypes\_gameobjects::set2DIcon( "friendly", level.iconDefendFlag2D );
+	capZone maps\mp\gametypes\_gameobjects::set3DIcon( "friendly", level.iconDefendFlag3D );
+	capZone maps\mp\gametypes\_gameobjects::set2DIcon( "enemy", level.iconCaptureFlag2D );
+	capZone maps\mp\gametypes\_gameobjects::set3DIcon( "enemy", level.iconCaptureFlag3D );
+
+	capZone maps\mp\gametypes\_gameobjects::setUseTime( 0 );
+	capZone maps\mp\gametypes\_gameobjects::setKeyObject( level.teamFlags[ getOtherTeam( team ) ] );
+	
+	capZone.onUse = ::onUse;
+	capZone.onCantUse = ::onCantUse;
+		
+	traceStart = trigger.origin + (0,0,32);
+	traceEnd = trigger.origin + (0,0,-32);
+	trace = bulletTrace( traceStart, traceEnd, false, undefined );
+	
+	fx = maps\mp\gametypes\_teams::getTeamFlagFX( team );
+	fxid = loadfx( fx );
+	
+	upangles = vectorToAngles( trace["normal"] );
+	forward = anglesToForward( upangles );
+	right = anglesToRight( upangles );
+	
+	thread spawnFxDelay( fxid, trace["position"], forward, right, 0.5 );
+	
+	return capZone;
+}
+
+
+onBeginUse( player )
+{
+	team = player.pers["team"];
+
+	if ( team == self maps\mp\gametypes\_gameobjects::getOwnerTeam() )
+		self.trigger.radius = 1024;
+	else
+		self.trigger.radius = self.oldRadius;
+}
+
+
+onEndUse( player, team, success )
+{
+	self.trigger.radius = self.oldRadius;
+}
+
+
+onPickup( player )
+{
+	self notify ( "picked_up" );
+
+	team = player.pers["team"];
+
+	if ( team == "allies" )
+		otherTeam = "axis";
+	else
+		otherTeam = "allies";
+		
+	if ( team == self maps\mp\gametypes\_gameobjects::getOwnerTeam() )
+	{
+		player thread maps\mp\gametypes\_hud_message::SplashNotify( "flagreturn", maps\mp\gametypes\_rank::getScoreInfoValue( "return" ) );
+		player thread [[level.onXPEvent]]( "return" );
+		self thread returnFlag();
+		player incPlayerStat( "flagsreturned", 1 );
+		player thread maps\mp\_matchdata::logGameEvent( "return", player.origin );
+
+		printAndSoundOnEveryone( team, getOtherTeam( team ), &"MP_FLAG_RETURNED", &"MP_ENEMY_FLAG_RETURNED", "mp_obj_returned", "mp_obj_returned", "" );
+		leaderDialog( "enemy_flag_returned", otherteam, "status" );
+		leaderDialog( "flag_returned", team, "status" );	
+
+		level.friendlyFlagStatusText[team] setText( &"OBJECTIVES_FLAG_HOME" );
+		level.friendlyFlagStatusText[team].glowColor = (1,1,1);
+		level.friendlyFlagStatusText[team].glowAlpha = 0;			
+		level.enemyFlagStatusText[otherTeam] setText( &"OBJECTIVES_FLAG_HOME" );
+		level.enemyFlagStatusText[otherTeam].glowColor = (1,1,1);
+		level.enemyFlagStatusText[otherTeam].glowAlpha = 0;
+	}
+	else
+	{
+		if ( inOvertime() )
+		{
+			if ( isDefined( level.flagCaptured ) )
+			{
+				// denied splash!
+				return;
+			}
+			
+			level thread teamPlayerCardSplash( "callout_grabbedtheflag", player );
+
+			level.teamFlags[team] maps\mp\gametypes\_gameobjects::allowUse( "none" );
+			level.teamFlags[otherTeam] maps\mp\gametypes\_gameobjects::allowUse( "none" );
+			level.capZones[team] maps\mp\gametypes\_gameobjects::setVisibleTeam( "none" );
+			level.capZones[otherTeam] maps\mp\gametypes\_gameobjects::setVisibleTeam( "none" );
+
+			level.flagCaptured = true;
+
+			//wait ( 1.5 );
+
+			maps\mp\gametypes\_gamescore::giveTeamScoreForObjective( team, 1 );
+			thread maps\mp\gametypes\_gamelogic::endGame( "winner", game["strings"]["grabbed_flag"] );		
+		}
+		
+		player attachFlag();
+
+		level.friendlyFlagStatusText[otherTeam] setPlayerNameString( player );
+		level.friendlyFlagStatusText[otherTeam].glowColor = (0.75,0.25,0.25);
+		level.friendlyFlagStatusText[otherTeam].glowAlpha = 1;
+		
+		level.enemyFlagStatusText[team] setPlayerNameString( player );
+		level.enemyFlagStatusText[team].glowColor = (0.25,0.75,0.25);
+		level.enemyFlagStatusText[team].glowAlpha = 1;
+
+		self maps\mp\gametypes\_gameobjects::setVisibleTeam( "any" );
+		self maps\mp\gametypes\_gameobjects::set2DIcon( "friendly", level.iconKill2D );
+		self maps\mp\gametypes\_gameobjects::set3DIcon( "friendly", level.iconKill3D );
+		self maps\mp\gametypes\_gameobjects::set2DIcon( "enemy", level.iconEscort2D );
+		self maps\mp\gametypes\_gameobjects::set3DIcon( "enemy", level.iconEscort3D );
+
+		level.capZones[otherTeam] maps\mp\gametypes\_gameobjects::allowUse( "none" );
+		level.capZones[otherTeam] maps\mp\gametypes\_gameobjects::setVisibleTeam( "none" );
+		//level.capZones[otherTeam] maps\mp\gametypes\_gameobjects::set3DIcon( "friendly", level.iconKill3D );
+		//level.capZones[otherTeam] maps\mp\gametypes\_gameobjects::set2DIcon( "friendly", level.iconKill3D );
+
+		if ( !level.teamFlags[ team ] maps\mp\gametypes\_gameobjects::isHome() )
+		{
+			level.capZones[ team ].trigger maps\mp\_entityheadIcons::setHeadIcon( player, level.iconWaitForFlag3D, (0,0,85) );	
+			
+			if ( isDefined( level.teamFlags[ team ].carrier ) )
+				level.capZones[ otherTeam ].trigger maps\mp\_entityheadIcons::setHeadIcon( level.teamFlags[ team ].carrier, level.iconWaitForFlag3D, (0,0,85) );				
+		}
+		
+		printAndSoundOnEveryone( team, otherteam, &"MP_ENEMY_FLAG_TAKEN_BY", &"MP_FLAG_TAKEN_BY", "mp_obj_taken", "mp_enemy_obj_taken", player );
+
+		leaderDialog( "enemy_flag_taken", team, "status" );
+		leaderDialog( "flag_taken", otherteam, "status" );
+
+		thread teamPlayerCardSplash( "callout_flagpickup", player );
+		player thread maps\mp\gametypes\_hud_message::SplashNotify( "flagpickup", maps\mp\gametypes\_rank::getScoreInfoValue( "pickup" ) );
+		maps\mp\gametypes\_gamescore::givePlayerScore( "pickup", player );
+		player thread [[level.onXPEvent]]( "pickup" );
+		player incPlayerStat( "flagscarried", 1 );
+		player thread maps\mp\_matchdata::logGameEvent( "pickup", player.origin );
+	}
+}
+
+
+returnFlag()
+{
+	self maps\mp\gametypes\_gameobjects::returnHome();
+}
+
+
+onDrop( player )
+{
+	team = self maps\mp\gametypes\_gameobjects::getOwnerTeam();
+	otherTeam = level.otherTeam[team];
+
+	self maps\mp\gametypes\_gameobjects::allowCarry( "any" );
+	self maps\mp\gametypes\_gameobjects::setVisibleTeam( "any" );
+	self maps\mp\gametypes\_gameobjects::set2DIcon( "friendly", level.iconReturnFlag2D );
+	self maps\mp\gametypes\_gameobjects::set3DIcon( "friendly", level.iconReturnFlag3D );
+	self maps\mp\gametypes\_gameobjects::set2DIcon( "enemy", level.iconCaptureFlag2D );
+	self maps\mp\gametypes\_gameobjects::set3DIcon( "enemy", level.iconCaptureFlag3D );
+
+	level.friendlyFlagStatusText[team] setText( &"OBJECTIVES_FLAG_AWAY" );
+	level.friendlyFlagStatusText[team].glowColor = (1,1,1);
+	level.friendlyFlagStatusText[team].glowAlpha = 0;	
+	level.enemyFlagStatusText[otherTeam] setText( &"OBJECTIVES_FLAG_AWAY" );
+	level.enemyFlagStatusText[otherTeam].glowColor = (1,1,1);
+	level.enemyFlagStatusText[otherTeam].glowAlpha = 0;	
+
+	level.capZones[otherTeam].trigger maps\mp\_entityheadIcons::setHeadIcon( "none", "", (0,0,0) );
+
+	if ( isDefined( player ) )
+	{
+ 		if ( isDefined( player.carryFlag ) )
+			player detachFlag();
+		
+		printAndSoundOnEveryone( otherTeam, "none", &"MP_ENEMY_FLAG_DROPPED_BY", "", "mp_war_objective_lost", "", player );		
+	}
+	else
+	{
+		playSoundOnPlayers( "mp_war_objective_lost", otherTeam );
+	}
+
+	leaderDialog( "enemy_flag_dropped", otherTeam, "status" );
+	leaderDialog( "flag_dropped", team, "status" );
+	
+	self thread returnAfterTime();
+}
+
+returnAfterTime()
+{
+	self endon ( "picked_up" );
+	
+	wait ( level.flagReturnTime );
+	
+	self maps\mp\gametypes\_gameobjects::returnHome();
+}
+
+
+onReset()
+{
+	team = self maps\mp\gametypes\_gameobjects::getOwnerTeam();
+	otherTeam = level.otherTeam[team];
+
+	self maps\mp\gametypes\_gameobjects::allowCarry( "enemy" );
+	self maps\mp\gametypes\_gameobjects::setVisibleTeam( "none" );
+	self maps\mp\gametypes\_gameobjects::set2DIcon( "friendly", level.iconKill2D );
+	self maps\mp\gametypes\_gameobjects::set3DIcon( "friendly", level.iconKill3D );
+	self maps\mp\gametypes\_gameobjects::set2DIcon( "enemy", level.iconEscort2D );
+	self maps\mp\gametypes\_gameobjects::set3DIcon( "enemy", level.iconEscort3D );
+
+	level.friendlyFlagStatusText[team] setText( &"OBJECTIVES_FLAG_HOME" );
+	level.friendlyFlagStatusText[team].glowColor = (1,1,1);
+	level.friendlyFlagStatusText[team].glowAlpha = 0;	
+
+	level.enemyFlagStatusText[otherTeam] setText( &"OBJECTIVES_FLAG_HOME" );
+	level.enemyFlagStatusText[otherTeam].glowColor = (1,1,1);
+	level.enemyFlagStatusText[otherTeam].glowAlpha = 0;	
+	
+	level.capZones[team] maps\mp\gametypes\_gameobjects::allowUse( "friendly" );
+	level.capZones[team] maps\mp\gametypes\_gameobjects::setVisibleTeam( "any" );
+	level.capZones[team] maps\mp\gametypes\_gameobjects::set2DIcon( "friendly", level.iconDefendFlag2D );
+	level.capZones[team] maps\mp\gametypes\_gameobjects::set3DIcon( "friendly", level.iconDefendFlag3D );
+	level.capZones[team] maps\mp\gametypes\_gameobjects::set2DIcon( "enemy", level.iconCaptureFlag2D );
+	level.capZones[team] maps\mp\gametypes\_gameobjects::set3DIcon( "enemy", level.iconCaptureFlag3D );
+
+	level.capZones[team].trigger maps\mp\_entityheadIcons::setHeadIcon( "none", "", (0,0,0) );
+}
+
+
+onUse( player )
+{
+	team = player.pers["team"];
+	if ( team == "allies" )
+		otherTeam = "axis";
+	else
+		otherTeam = "allies";
+
+	leaderDialog( "enemy_flag_captured", team, "status" );
+	leaderDialog( "flag_captured", otherteam, "status" );	
+
+	thread teamPlayerCardSplash( "callout_flagcapture", player );
+	maps\mp\gametypes\_gamescore::giveTeamScoreForObjective( team, 1 );	
+	player thread maps\mp\gametypes\_hud_message::SplashNotify( "flag_capture", maps\mp\gametypes\_rank::getScoreInfoValue( "capture" ) );
+	maps\mp\gametypes\_gamescore::givePlayerScore( "capture", player );
+	player thread [[level.onXPEvent]]( "capture" );
+	player incPlayerStat( "flagscaptured", 1 );
+	player notify( "objective", "captured" );
+	player thread maps\mp\_matchdata::logGameEvent( "capture", player.origin );
+
+	printAndSoundOnEveryone( team, otherteam, &"MP_ENEMY_FLAG_CAPTURED_BY", &"MP_FLAG_CAPTURED_BY", "mp_obj_captured", "mp_enemy_obj_captured", player );
+
+	if ( isDefined( player.carryFlag ) )
+		player detachFlag();
+
+	level.teamFlags[otherTeam]	returnFlag();
+}
+
+
+onCantUse( player )
+{
+//	player iPrintLnBold( &"MP_CANT_PLANT_WITHOUT_BOMB" );
+}
+
+
+onPlayerKilled( eInflictor, attacker, iDamage, sMeansOfDeath, sWeapon, vDir, sHitLoc, psOffsetTime, deathAnimDuration, killId )
+{
+	if ( isDefined( attacker ) && isPlayer( attacker ) && attacker.pers["team"] != self.pers["team"] )
+	{
+		if ( isDefined( attacker.carryFlag ) )
+			attacker incPlayerStat( "killsasflagcarrier", 1 );
+
+		if ( isDefined( self.carryFlag ) )
+		{
+			attacker thread [[level.onXPEvent]]( "kill_carrier" );
+			maps\mp\gametypes\_gamescore::givePlayerScore( "kill_carrier", attacker );
+			attacker incPlayerStat( "flagcarrierkills", 1 );
+			
+			thread maps\mp\_matchdata::logKillEvent( killId, "carrying" );
+			
+			self detachFlag();
+		}
+	}
+}
+
+
+attachFlag()
+{
+	otherTeam = level.otherTeam[self.pers["team"]];
+	
+	self attach( level.carryFlag[otherTeam], "J_spine4", true );
+	self.carryFlag = level.carryFlag[otherTeam];
+}
+
+detachFlag()
+{
+	self detach( self.carryFlag, "J_spine4" );
+	self.carryFlag = undefined;
+}
+
+initGametypeAwards()
+{
+	maps\mp\_awards::initStatAward( "flagscaptured",		0, maps\mp\_awards::highestWins );
+	maps\mp\_awards::initStatAward( "flagsreturned", 		0, maps\mp\_awards::highestWins );
+	maps\mp\_awards::initStatAward( "flagcarrierkills", 	0, maps\mp\_awards::highestWins );
+	maps\mp\_awards::initStatAward( "flagscarried",			0, maps\mp\_awards::highestWins );
+	maps\mp\_awards::initStatAward( "killsasflagcarrier", 	0, maps\mp\_awards::highestWins );
+}

iw4x/iw4x_00/maps/mp/gametypes/dd.gsc

@@ -0,0 +1,909 @@
+#include common_scripts\utility;
+#include maps\mp\_utility;
+#include maps\mp\gametypes\_hud_util;
+
+/*
+	Action SAB/SD = DD
+	Attackers objective: Bomb both of 2 positions
+	Defenders objective: Defend these 2 positions / Defuse planted bombs
+	Round ends:	When one team defends for duration of match, both sites are destroyed.
+	Map ends:	When one team reaches the score limit, or time limit or round limit is reached
+	Respawning:	Players respawn indefinetly and immediately
+
+	Level requirements
+	------------------
+		Allied Spawnpoints:
+			classname		mp_sd_spawn_attacker
+			Allied players spawn from these. Place at least 16 of these relatively close together.
+
+		Axis Spawnpoints:
+			classname		mp_sd_spawn_defender
+			Axis players spawn from these. Place at least 16 of these relatively close together.
+
+		Spectator Spawnpoints:
+			classname		mp_global_intermission
+			Spectators spawn from these and intermission is viewed from these positions.
+			Atleast one is required, any more and they are randomly chosen between.
+
+		Bombzones:
+			classname					trigger_multiple
+			targetname					bombzone
+			script_gameobjectname		bombzone
+			script_bombmode_original	<if defined this bombzone will be used in the original bomb mode>
+			script_bombmode_single		<if defined this bombzone will be used in the single bomb mode>
+			script_bombmode_dual		<if defined this bombzone will be used in the dual bomb mode>
+			script_team					Set to allies or axis. This is used to set which team a bombzone is used by in dual bomb mode.
+			script_label				Set to A or B. This sets the letter shown on the compass in original mode.
+			This is a volume of space in which the bomb can planted. Must contain an origin brush.
+
+		Bomb:
+			classname				trigger_lookat
+			targetname				bombtrigger
+			script_gameobjectname	bombzone
+			This should be a 16x16 unit trigger with an origin brush placed so that it's center lies on the bottom plane of the trigger.
+			Must be in the level somewhere. This is the trigger that is used when defusing a bomb.
+			It gets moved to the position of the planted bomb model.
+
+	Level script requirements
+	-------------------------
+		Team Definitions:
+			game["attackers"] = "allies";
+			game["defenders"] = "axis";
+			This sets which team is attacking and which team is defending. Attackers plant the bombs. Defenders protect the targets.
+
+		Exploder Effects:
+			Setting script_noteworthy on a bombzone trigger to an exploder group can be used to trigger additional effects.
+	
+	multiple bombs
+	multiple targets
+	spawning
+	round handling when both sites are destroyed
+
+*/
+
+/*QUAKED mp_dd_spawn_attacker_a (0.75 0.0 0.5) (-16 -16 0) (16 16 72)
+Axis players spawn near bomb a.*/
+
+/*QUAKED mp_dd_spawn_attacker_b (0.75 0.0 0.5) (-16 -16 0) (16 16 72)
+Axis players spawn near bomb b.*/
+
+/*QUAKED mp_dd_spawn_attacker (0.75 0.0 0.5) (-16 -16 0) (16 16 72)
+Axis players spawn away from enemies and near their team at one of these positions.*/
+
+/*QUAKED mp_dd_spawn_defender (0.0 0.75 0.5) (-16 -16 0) (16 16 72)
+Allied players spawn away from enemies and near their team at one of these positions.*/
+
+/*QUAKED mp_dd_spawn_defender_a (0.0 0.75 0.5) (-16 -16 0) (16 16 72)
+Allied players spawn near bomb site a.*/
+
+/*QUAKED mp_dd_spawn_defender_b (0.0 0.75 0.5) (-16 -16 0) (16 16 72)
+Allied players spawn near bomb site b.*/
+
+/*QUAKED mp_dd_spawn_attacker_start (0.0 1.0 0.0) (-16 -16 0) (16 16 72)
+Attacking players spawn randomly at one of these positions at the beginning of a round.*/
+
+/*QUAKED mp_dd_spawn_defender_start (1.0 0.0 0.0) (-16 -16 0) (16 16 72)
+Defending players spawn randomly at one of these positions at the beginning of a round.*/
+
+main()
+{
+	if(getdvar("mapname") == "mp_background")
+		return;
+	
+	maps\mp\gametypes\_globallogic::init();
+	maps\mp\gametypes\_callbacksetup::SetupCallbacks();
+	maps\mp\gametypes\_globallogic::SetupCallbacks();
+	
+	registerRoundSwitchDvar( level.gameType, 1, 0, 9 );
+	registerTimeLimitDvar( level.gameType, 3, 0, 1440 );
+	registerScoreLimitDvar( level.gameType, 0, 0, 500 );
+	registerRoundLimitDvar( level.gameType, 3, 0, 12 );
+	registerWinLimitDvar( level.gameType, 2, 0, 12 );
+	registerNumLivesDvar( level.gameType, 0, 0, 10 );
+	registerHalfTimeDvar( level.gameType, 0, 0, 1 );
+	
+	level.objectiveBased = true;
+	level.teamBased = true;
+	level.onPrecacheGameType = ::onPrecacheGameType;
+	level.onStartGameType = ::onStartGameType;
+	level.getSpawnPoint = ::getSpawnPoint;
+	level.onSpawnPlayer = ::onSpawnPlayer;
+	level.onDeadEvent = ::onDeadEvent;
+	level.onTimeLimit = ::onTimeLimit;
+	level.onNormalDeath = ::onNormalDeath;
+	level.initGametypeAwards = ::initGametypeAwards;
+	level.dd = true;
+	level.bombsPlanted = 0;
+	level.ddBombModel = []
+	
+	setBombTimerDvar();
+	
+	makeDvarServerInfo( "ui_bombtimer_a", -1 );
+	makeDvarServerInfo( "ui_bombtimer_b", -1 );
+	
+	game["dialog"]["gametype"] = "demolition";
+	
+	if ( getDvarInt( "g_hardcore" ) )
+		game["dialog"]["gametype"] = "hc_" + game["dialog"]["gametype"];
+	else if ( getDvarInt( "camera_thirdPerson" ) )
+		game["dialog"]["gametype"] = "thirdp_" + game["dialog"]["gametype"];
+	else if ( getDvarInt( "scr_diehard" ) )
+		game["dialog"]["gametype"] = "dh_" + game["dialog"]["gametype"];
+	else if (getDvarInt( "scr_" + level.gameType + "_promode" ) )
+		game["dialog"]["gametype"] = game["dialog"]["gametype"] + "_pro";
+	
+	game["dialog"]["offense_obj"] = "obj_destroy";
+	game["dialog"]["defense_obj"] = "obj_defend";
+}
+
+
+onPrecacheGameType()
+{
+	game["bomb_dropped_sound"] = "mp_war_objective_lost";
+	game["bomb_recovered_sound"] = "mp_war_objective_taken";
+
+	precacheShader("waypoint_bomb");
+	precacheShader("hud_suitcase_bomb");
+	precacheShader("waypoint_target");
+	precacheShader("waypoint_target_a");
+	precacheShader("waypoint_target_b");
+	precacheShader("waypoint_defend");
+	precacheShader("waypoint_defend_a");
+	precacheShader("waypoint_defend_b");
+	precacheShader("waypoint_defuse_a");
+	precacheShader("waypoint_defuse_b");
+	precacheShader("waypoint_target");
+	precacheShader("waypoint_target_a");
+	precacheShader("waypoint_target_b");
+	precacheShader("waypoint_defend");
+	precacheShader("waypoint_defend_a");
+	precacheShader("waypoint_defend_b");
+	precacheShader("waypoint_defuse");
+	precacheShader("waypoint_defuse_a");
+	precacheShader("waypoint_defuse_b");
+	
+	precacheString( &"MP_EXPLOSIVES_RECOVERED_BY" );
+	precacheString( &"MP_EXPLOSIVES_DROPPED_BY" );
+	precacheString( &"MP_EXPLOSIVES_PLANTED_BY" );
+	precacheString( &"MP_EXPLOSIVES_DEFUSED_BY" );
+	precacheString( &"PLATFORM_HOLD_TO_PLANT_EXPLOSIVES" );
+	precacheString( &"PLATFORM_HOLD_TO_DEFUSE_EXPLOSIVES" );
+	precacheString( &"MP_CANT_PLANT_WITHOUT_BOMB" );	
+	precacheString( &"MP_PLANTING_EXPLOSIVE" );	
+	precacheString( &"MP_DEFUSING_EXPLOSIVE" );	
+	precacheString( &"MP_BOMB_A_TIMER" );
+	precacheString( &"MP_BOMB_B_TIMER" );	
+	precacheString( &"MP_BOMBSITE_IN_USE" );
+}
+
+onStartGameType()
+{
+	if ( !isDefined( game["switchedsides"] ) )
+		game["switchedsides"] = false;
+	
+	if ( game["switchedsides"] )
+	{
+		oldAttackers = game["attackers"];
+		oldDefenders = game["defenders"];
+		game["attackers"] = oldDefenders;
+		game["defenders"] = oldAttackers;
+	}
+	
+	level.useStartSpawns = true;
+	
+	setClientNameMode( "manual_change" );
+	
+	game["strings"]["target_destroyed"] = &"MP_TARGET_DESTROYED";
+	game["strings"]["bomb_defused"] = &"MP_BOMB_DEFUSED";
+	
+	precacheString( game["strings"]["target_destroyed"] );
+	precacheString( game["strings"]["bomb_defused"] );
+
+	level._effect["bombexplosion"] = loadfx("explosions/tanker_explosion");
+	
+	setObjectiveText( game["attackers"], &"OBJECTIVES_DD_ATTACKER" );
+	setObjectiveText( game["defenders"], &"OBJECTIVES_DD_DEFENDER" );
+
+	if ( level.splitscreen )
+	{
+		setObjectiveScoreText( game["attackers"], &"OBJECTIVES_DD_ATTACKER" );
+		setObjectiveScoreText( game["defenders"], &"OBJECTIVES_DD_DEFENDER" );
+	}
+	else
+	{
+		setObjectiveScoreText( game["attackers"], &"OBJECTIVES_DD_ATTACKER_SCORE" );
+		setObjectiveScoreText( game["defenders"], &"OBJECTIVES_DD_DEFENDER_SCORE" );
+	}
+	setObjectiveHintText( game["attackers"], &"OBJECTIVES_DD_ATTACKER_HINT" );
+	setObjectiveHintText( game["defenders"], &"OBJECTIVES_DD_DEFENDER_HINT" );
+
+	level.spawnMins = ( 0, 0, 0 );
+	level.spawnMaxs = ( 0, 0, 0 );	
+	
+	
+	if ( getDvar( "mapname" ) == "mp_shipment_long" )
+		maps\mp\gametypes\_spawnlogic::addSpawnPoints( game["defenders"], "mp_cha_spawn_axis" );
+	else
+		maps\mp\gametypes\_spawnlogic::addSpawnPoints( game["defenders"], "mp_dd_spawn_defender" );
+	
+	maps\mp\gametypes\_spawnlogic::addSpawnPoints( game["defenders"], "mp_dd_spawn_defender_a", true );
+	maps\mp\gametypes\_spawnlogic::addSpawnPoints( game["defenders"], "mp_dd_spawn_defender_b", true );
+	
+	if ( getDvar( "mapname" ) == "mp_shipment_long" )
+		maps\mp\gametypes\_spawnlogic::placeSpawnPoints( "mp_cha_spawn_axis_start" );
+	else
+		maps\mp\gametypes\_spawnlogic::placeSpawnPoints( "mp_dd_spawn_defender_start" );
+
+	if ( getDvar( "mapname" ) == "mp_shipment_long" )
+		maps\mp\gametypes\_spawnlogic::addSpawnPoints( game["attackers"], "mp_cha_spawn_allies" );
+	else
+		maps\mp\gametypes\_spawnlogic::addSpawnPoints( game["attackers"], "mp_dd_spawn_attacker" );
+		
+	maps\mp\gametypes\_spawnlogic::addSpawnPoints( game["attackers"], "mp_dd_spawn_attacker_a", true );
+	maps\mp\gametypes\_spawnlogic::addSpawnPoints( game["attackers"], "mp_dd_spawn_attacker_b", true );
+	
+	if ( getDvar( "mapname" ) == "mp_shipment_long" )
+		maps\mp\gametypes\_spawnlogic::placeSpawnPoints( "mp_cha_spawn_allies_start" );
+	else
+		maps\mp\gametypes\_spawnlogic::placeSpawnPoints( "mp_dd_spawn_attacker_start" );
+	
+	if ( getDvar( "mapname" ) == "mp_shipment_long" )
+		level.spawn_attackers = maps\mp\gametypes\_spawnlogic::getSpawnpointArray( "mp_cha_spawn_axis" );
+	else
+		level.spawn_attackers = maps\mp\gametypes\_spawnlogic::getSpawnpointArray( "mp_dd_spawn_defender" );
+		
+	level.spawn_defenders_a = maps\mp\gametypes\_spawnlogic::getSpawnpointArray( "mp_dd_spawn_defender_a" );
+	level.spawn_defenders_a = array_combine( level.spawn_defenders, level.spawn_defenders_a );
+	level.spawn_defenders_b = maps\mp\gametypes\_spawnlogic::getSpawnpointArray( "mp_dd_spawn_defender_b" );
+	level.spawn_defenders_b = array_combine( level.spawn_defenders, level.spawn_defenders_b );
+	
+	if ( getDvar( "mapname" ) == "mp_shipment_long" )
+		level.spawn_attackers = maps\mp\gametypes\_spawnlogic::getSpawnpointArray( "mp_cha_spawn_allies" );
+	else
+		level.spawn_attackers = maps\mp\gametypes\_spawnlogic::getSpawnpointArray( "mp_dd_spawn_attacker" );
+		
+	level.spawn_attackers_a = maps\mp\gametypes\_spawnlogic::getSpawnpointArray( "mp_dd_spawn_attacker_a" );
+	level.spawn_attackers_a = array_combine( level.spawn_attackers, level.spawn_attackers_a );
+	level.spawn_attackers_b = maps\mp\gametypes\_spawnlogic::getSpawnpointArray( "mp_dd_spawn_attacker_b" );
+	level.spawn_attackers_b = array_combine( level.spawn_attackers, level.spawn_attackers_b );
+	
+	if ( getDvar( "mapname" ) == "mp_shipment_long" )
+	{
+		level.spawn_defenders_start = maps\mp\gametypes\_spawnlogic::getSpawnpointArray( "mp_cha_spawn_axis_start" );
+		level.spawn_attackers_start = maps\mp\gametypes\_spawnlogic::getSpawnpointArray( "mp_cha_spawn_allies_start" );
+	}
+	else
+	{
+		level.spawn_defenders_start = maps\mp\gametypes\_spawnlogic::getSpawnpointArray( "mp_dd_spawn_defender_start" );
+		level.spawn_attackers_start = maps\mp\gametypes\_spawnlogic::getSpawnpointArray( "mp_dd_spawn_attacker_start" );
+	}
+	
+	level.mapCenter = maps\mp\gametypes\_spawnlogic::findBoxCenter( level.spawnMins, level.spawnMaxs );
+	level.aPlanted = false;
+	level.bPlanted = false;
+	
+	setMapCenter( level.mapCenter );
+	
+	maps\mp\gametypes\_rank::registerScoreInfo( "win", 2 );
+	maps\mp\gametypes\_rank::registerScoreInfo( "loss", 1 );
+	maps\mp\gametypes\_rank::registerScoreInfo( "tie", 1.5 );
+	
+	maps\mp\gametypes\_rank::registerScoreInfo( "kill", 50 );
+	maps\mp\gametypes\_rank::registerScoreInfo( "headshot", 50 );
+	maps\mp\gametypes\_rank::registerScoreInfo( "assist", 20 );
+	maps\mp\gametypes\_rank::registerScoreInfo( "plant", 100 );
+	maps\mp\gametypes\_rank::registerScoreInfo( "defuse", 100 );
+	
+	thread updateGametypeDvars();
+	thread waitToProcess();
+	
+	winlimit = getWatchedDvar("winlimit");
+	
+	allowed[0] = "dd";
+	bombZones = getEntArray( "dd_bombzone", "targetname" );
+	if ( bombZones.size )
+		allowed[1] = "dd_bombzone";
+	else
+		allowed[1] = "bombzone";
+	allowed[2] = "blocker";
+	maps\mp\gametypes\_gameobjects::main(allowed);
+	
+	thread bombs();
+}
+
+waitToProcess()
+{
+	level endon( "game_end" );
+
+	for ( ;; )
+	{
+		if ( level.inGracePeriod == 0 )
+			break;
+			
+		wait ( 0.05 );	
+	}
+	
+	level.useStartSpawns = false;
+		
+}
+
+getSpawnPoint()
+{
+	spawnteam = self.pers["team"];
+
+	if ( level.useStartSpawns )
+	{
+		if ( spawnteam == game["attackers"] )
+			spawnpoint = maps\mp\gametypes\_spawnlogic::getSpawnpoint_Random(level.spawn_attackers_start);
+		else
+			spawnpoint = maps\mp\gametypes\_spawnlogic::getSpawnpoint_Random(level.spawn_defenders_start);
+	}	
+	else
+	{
+		if (spawnteam == game["attackers"] )
+		{
+			if ( (!level.aPlanted && !level.bPlanted) )
+				spawnPoints = maps\mp\gametypes\_spawnlogic::getTeamSpawnPoints( spawnteam );
+			else if ( level.aPlanted && !level.bPlanted )
+				spawnPoints = level.spawn_attackers_a;
+			else if ( level.bPlanted && !level.aPlanted )
+				spawnPoints = level.spawn_attackers_b;
+			else
+				spawnPoints = maps\mp\gametypes\_spawnlogic::getTeamSpawnPoints( spawnteam );
+			
+			spawnpoint = maps\mp\gametypes\_spawnlogic::getSpawnpoint_NearTeam( spawnPoints );
+		}
+		else
+		{
+			if ( (!level.aPlanted && !level.bPlanted) )
+				spawnPoints = maps\mp\gametypes\_spawnlogic::getTeamSpawnPoints( spawnteam );
+			else if ( level.aPlanted && !level.bPlanted )
+				spawnPoints = level.spawn_defenders_a;
+			else if ( level.bPlanted && !level.aPlanted )
+				spawnPoints = level.spawn_defenders_b;
+			else
+				spawnPoints = maps\mp\gametypes\_spawnlogic::getTeamSpawnPoints( spawnteam );
+			
+			spawnpoint = maps\mp\gametypes\_spawnlogic::getSpawnpoint_NearTeam( spawnPoints );
+		}
+	}
+	
+	assert( isDefined(spawnpoint) );
+
+	return spawnpoint;
+}
+
+onSpawnPlayer()
+{
+	
+	if ( self.pers["team"] == game["attackers"] )
+	{
+		self.isPlanting = false;
+		self.isDefusing = false;
+		self.isBombCarrier = true;
+		
+		if ( level.splitscreen )
+		{
+			self.carryIcon = createIcon( "hud_suitcase_bomb", 33, 33 );
+			self.carryIcon setPoint( "BOTTOM RIGHT", "BOTTOM RIGHT", 0, -78 );
+			self.carryIcon.alpha = 0.75;
+		}
+		else
+		{
+			self.carryIcon = createIcon( "hud_suitcase_bomb", 50, 50 );
+			self.carryIcon setPoint( "BOTTOM RIGHT", "BOTTOM RIGHT", -90, -65 );
+			self.carryIcon.alpha = 0.75;
+		}
+	}
+	else
+	{
+		self.isPlanting = false;
+		self.isDefusing = false;
+		self.isBombCarrier = false;
+		
+		if ( isDefined( self.carryIcon ) )
+		{
+			self.carryIcon Destroy();
+		}
+	}
+
+	level notify ( "spawned_player" );
+}
+
+
+dd_endGame( winningTeam, endReasonText )
+{
+	thread maps\mp\gametypes\_gamelogic::endGame( winningTeam, endReasonText );
+}
+
+
+onDeadEvent( team )
+{
+	if ( level.bombExploded || level.bombDefused )
+		return;
+	
+	if ( team == "all" )
+	{
+		if ( level.bombPlanted )
+			dd_endGame( game["attackers"], game["strings"][game["defenders"]+"_eliminated"] );
+		else
+			dd_endGame( game["defenders"], game["strings"][game["attackers"]+"_eliminated"] );
+	}
+	else if ( team == game["attackers"] )
+	{
+		if ( level.bombPlanted )
+			return;
+
+		level thread dd_endGame( game["defenders"], game["strings"][game["attackers"]+"_eliminated"] );
+	}
+	else if ( team == game["defenders"] )
+	{
+		level thread dd_endGame( game["attackers"], game["strings"][game["defenders"]+"_eliminated"] );
+	}
+}
+
+
+onNormalDeath( victim, attacker, lifeId )
+{
+	score = maps\mp\gametypes\_rank::getScoreInfoValue( "kill" );
+	assert( isDefined( score ) );
+
+	team = victim.team;
+	
+	if ( game["state"] == "postgame" && (victim.team == game["defenders"] || !level.bombPlanted) )
+		attacker.finalKill = true;
+		
+	if ( victim.isPlanting )
+	{
+		thread maps\mp\_matchdata::logKillEvent( lifeId, "planting" );
+	}
+	else if ( victim.isDefusing )
+	{
+		thread maps\mp\_matchdata::logKillEvent( lifeId, "defusing" );
+	}
+}
+
+
+onTimeLimit()
+{
+	dd_endGame( game["defenders"], game["strings"]["time_limit_reached"] );
+}
+
+
+updateGametypeDvars()
+{
+	level.plantTime = dvarFloatValue( "planttime", 5, 0, 20 );
+	level.defuseTime = dvarFloatValue( "defusetime", 5, 0, 20 );
+	level.bombTimer = dvarIntValue( "bombtimer", 45, 1, 300 );
+	level.ddTimeToAdd = dvarFloatValue( "addtime", 2, 0, 5 );; //how much time is added to the match when a target is destroyed
+}
+
+
+bombs()
+{
+	level.bombPlanted = false;
+	level.bombDefused = false;
+	level.bombExploded = 0;
+
+	level.bombZones = [];
+	
+	bombZones = getEntArray( "dd_bombzone", "targetname" );
+	if ( !bombZones.size )	
+		bombZones = getEntArray( "bombzone", "targetname" );
+	
+	for ( index = 0; index < bombZones.size; index++ )
+	{
+		trigger = bombZones[index];
+		visuals = getEntArray( bombZones[index].target, "targetname" );
+		
+		bombZone = maps\mp\gametypes\_gameobjects::createUseObject( game["defenders"], trigger, visuals, (0,0,64) );
+		bombZone maps\mp\gametypes\_gameobjects::allowUse( "enemy" );
+		bombZone maps\mp\gametypes\_gameobjects::setUseTime( level.plantTime );
+		bombZone maps\mp\gametypes\_gameobjects::setUseText( &"MP_PLANTING_EXPLOSIVE" );
+		bombZone maps\mp\gametypes\_gameobjects::setUseHintText( &"PLATFORM_HOLD_TO_PLANT_EXPLOSIVES" );
+		bombZone maps\mp\gametypes\_gameobjects::setKeyObject( level.ddBomb );
+	
+		label = bombZone maps\mp\gametypes\_gameobjects::getLabel();
+		bombZone.label = label;
+		bombZone.index = index;
+		bombZone maps\mp\gametypes\_gameobjects::set2DIcon( "friendly", "waypoint_defend" + label );
+		bombZone maps\mp\gametypes\_gameobjects::set3DIcon( "friendly", "waypoint_defend" + label );
+		bombZone maps\mp\gametypes\_gameobjects::set2DIcon( "enemy", "waypoint_target" + label );
+		bombZone maps\mp\gametypes\_gameobjects::set3DIcon( "enemy", "waypoint_target" + label );
+		bombZone maps\mp\gametypes\_gameobjects::setVisibleTeam( "any" );
+		bombZone.onBeginUse = ::onBeginUse;
+		bombZone.onEndUse = ::onEndUse;
+		bombZone.onUse = ::onUseObject;
+		bombZone.onCantUse = ::onCantUse;
+		bombZone.useWeapon = "briefcase_bomb_mp";
+		bombZone.visuals[0].killCamEnt = spawn( "script_model", bombZone.visuals[0].origin + (0,0,128) );
+		
+		for ( i = 0; i < visuals.size; i++ )
+		{
+			if ( isDefined( visuals[i].script_exploder ) )
+			{
+				bombZone.exploderIndex = visuals[i].script_exploder;
+				break;
+			}
+		}
+		
+		level.bombZones[level.bombZones.size] = bombZone;
+		
+		bombZone.bombDefuseTrig = getent( visuals[0].target, "targetname" );
+		assert( isdefined( bombZone.bombDefuseTrig ) );
+		bombZone.bombDefuseTrig.origin += (0,0,-10000);
+		bombZone.bombDefuseTrig.label = label;
+	}
+	
+	for ( index = 0; index < level.bombZones.size; index++ )
+	{
+		array = [];
+		for ( otherindex = 0; otherindex < level.bombZones.size; otherindex++ )
+		{
+			if ( otherindex != index )
+				array[ array.size ] = level.bombZones[otherindex];
+		}
+		level.bombZones[index].otherBombZones = array;
+	}
+}
+
+onUseObject( player )
+{
+	team = player.pers["team"];
+	otherTeam = level.otherTeam[team];
+
+	if ( !self maps\mp\gametypes\_gameobjects::isFriendlyTeam( player.pers["team"] ) )
+	{
+		player notify ( "bomb_planted" );
+		player playSound( "mp_bomb_plant" );
+
+		thread teamPlayerCardSplash( "callout_bombplanted", player );
+		//iPrintLn( &"MP_EXPLOSIVES_PLANTED_BY", player );
+		leaderDialog( "bomb_planted" );
+
+		player thread maps\mp\gametypes\_hud_message::SplashNotify( "plant", maps\mp\gametypes\_rank::getScoreInfoValue( "plant" ) );
+		player thread maps\mp\gametypes\_rank::giveRankXP( "plant" );
+		maps\mp\gametypes\_gamescore::givePlayerScore( "plant", player );		
+		player incPlayerStat( "bombsplanted", 1 );
+		player thread maps\mp\_matchdata::logGameEvent( "plant", player.origin );
+		player.bombPlantedTime = getTime();
+
+		level thread bombPlanted( self, player );
+
+		level.bombOwner = player;
+		self.useWeapon = "briefcase_bomb_defuse_mp";
+		self setUpForDefusing();
+	}
+	else // defused the bomb
+	{
+		self thread bombHandler( player, "defused" );
+	}
+}
+
+
+resetBombZone()
+{
+	self maps\mp\gametypes\_gameobjects::allowUse( "enemy" );
+	self maps\mp\gametypes\_gameobjects::setUseTime( level.plantTime );
+	self maps\mp\gametypes\_gameobjects::setUseText( &"MP_PLANTING_EXPLOSIVE" );
+	self maps\mp\gametypes\_gameobjects::setUseHintText( &"PLATFORM_HOLD_TO_PLANT_EXPLOSIVES" );
+	self maps\mp\gametypes\_gameobjects::setKeyObject( level.ddBomb );
+	self maps\mp\gametypes\_gameobjects::set2DIcon( "friendly", "waypoint_defend" + self.label );
+	self maps\mp\gametypes\_gameobjects::set3DIcon( "friendly", "waypoint_defend" + self.label  );
+	self maps\mp\gametypes\_gameobjects::set2DIcon( "enemy", "waypoint_target" + self.label );
+	self maps\mp\gametypes\_gameobjects::set3DIcon( "enemy", "waypoint_target" + self.label );
+	self maps\mp\gametypes\_gameobjects::setVisibleTeam( "any" );
+	self.useWeapon = "briefcase_bomb_mp";
+}
+
+setUpForDefusing()
+{
+	self maps\mp\gametypes\_gameobjects::allowUse( "friendly" );
+	self maps\mp\gametypes\_gameobjects::setUseTime( level.defuseTime );
+	self maps\mp\gametypes\_gameobjects::setUseText( &"MP_DEFUSING_EXPLOSIVE" );
+	self maps\mp\gametypes\_gameobjects::setUseHintText( &"PLATFORM_HOLD_TO_DEFUSE_EXPLOSIVES" );
+	self maps\mp\gametypes\_gameobjects::setKeyObject( undefined );
+	self maps\mp\gametypes\_gameobjects::set2DIcon( "friendly", "waypoint_defuse" + self.label );
+	self maps\mp\gametypes\_gameobjects::set3DIcon( "friendly", "waypoint_defuse" + self.label );
+	self maps\mp\gametypes\_gameobjects::set2DIcon( "enemy", "waypoint_defend" + self.label );
+	self maps\mp\gametypes\_gameobjects::set3DIcon( "enemy", "waypoint_defend" + self.label );
+	self maps\mp\gametypes\_gameobjects::setVisibleTeam( "any" );
+}
+
+onBeginUse( player )
+{
+	if ( self maps\mp\gametypes\_gameobjects::isFriendlyTeam( player.pers["team"] ) )
+	{
+		player playSound( "mp_bomb_defuse" );
+		player.isDefusing = true;
+		
+		bestDistance = 9000000;
+		closestBomb = undefined;
+		
+		if ( isDefined( level.ddBombModel ) )
+		{
+			foreach ( bomb in level.ddBombModel )
+			{
+				if ( !isDefined( bomb ) )
+					continue;
+				
+				dist = distanceSquared( player.origin, bomb.origin );
+				
+				if (  dist < bestDistance )
+				{
+					bestDistance = dist;			
+					closestBomb = bomb;
+				}
+			}
+			
+			assert( isDefined(closestBomb) );
+			player.defusing = closestBomb;
+			closestBomb hide();
+		}
+	}
+	else
+	{
+		player.isPlanting = true;
+	}
+}
+
+onEndUse( team, player, result )
+{
+	if ( !isDefined( player ) )
+		return;
+	
+	if ( isAlive( player ) )
+	{
+		player.isDefusing = false;
+		player.isPlanting = false;
+	}
+	
+	if ( self maps\mp\gametypes\_gameobjects::isFriendlyTeam( player.pers["team"] ) )
+	{
+		if ( isDefined( player.defusing ) && !result )
+		{
+			player.defusing show();
+		}
+	}
+}
+
+onCantUse( player )
+{
+	player iPrintLnBold( &"MP_BOMBSITE_IN_USE" );
+}
+
+onReset()
+{
+}
+
+bombPlanted( destroyedObj, player )
+{
+	destroyedObj endon( "defused" );
+	
+	level.bombsPlanted += 1;
+	self setBombTimerDvar();
+	maps\mp\gametypes\_gamelogic::pauseTimer();
+	level.timePauseStart = getTime();
+	level.timeLimitOverride = true;
+	
+	level.bombPlanted = true;
+	level.destroyedObject = destroyedObj;
+	
+	if ( level.destroyedObject.label == "_a" )
+		level.aPlanted = true;
+	else
+		level.bPlanted = true; 
+	
+	level.destroyedObject.bombPlanted = true;
+	
+	destroyedObj.visuals[0] thread playDemolitionTickingSound(destroyedObj);
+	level.tickingObject = destroyedObj.visuals[0];
+	
+	self dropBombModel( player, destroyedObj.label );
+	destroyedObj.bombDefused = false;	
+	destroyedObj maps\mp\gametypes\_gameobjects::allowUse( "none" );
+	destroyedObj maps\mp\gametypes\_gameobjects::setVisibleTeam( "none" );
+	destroyedObj setUpForDefusing();
+	
+	destroyedObj BombTimerWait(destroyedObj); //waits for bomb to explode!
+	
+	destroyedObj thread bombHandler( player ,"explode" );
+	
+}
+
+bombHandler( player, destType )
+{
+	self.visuals[0] notify( "stopTicking" );
+	level.bombsPlanted -= 1;
+	
+	if ( self.label == "_a" )
+		level.aPlanted = false;
+	else
+		level.bPlanted = false; 
+		
+	self.bombPlanted = 0;
+	
+	self restartTimer();
+	self setBombTimerDvar();
+
+	setDvar( "ui_bombtimer" + self.label, -1 );
+	//self maps\mp\gametypes\_gameobjects::updateTimer( 0, false );
+	
+	if ( level.gameEnded )
+		return;
+	
+	if ( destType == "explode" )
+	{
+		level.bombExploded += 1;
+		
+		explosionOrigin = self.curorigin;
+		level.ddBombModel[ self.label ] Delete();
+		
+		if ( isdefined( player ) )
+		{
+			self.visuals[0] radiusDamage( explosionOrigin, 512, 200, 20, player );
+			player incPlayerStat( "targetsdestroyed", 1 );
+		}
+		else
+		{
+			self.visuals[0] radiusDamage( explosionOrigin, 512, 200, 20 );
+		}
+		
+		rot = randomfloat(360);
+		explosionEffect = spawnFx( level._effect["bombexplosion"], explosionOrigin + (0,0,50), (0,0,1), (cos(rot),sin(rot),0) );
+		triggerFx( explosionEffect );
+		
+		PlayRumbleOnPosition( "grenade_rumble", explosionOrigin );
+		earthquake( 0.75, 2.0, explosionOrigin, 2000 );
+		
+		thread playSoundinSpace( "exp_suitcase_bomb_main", explosionOrigin );
+		
+		sabBomb = getEnt( "sab_bomb", "targetname" );
+		sabBomb Delete();
+		
+		if ( isDefined( self.exploderIndex ) )
+			exploder( self.exploderIndex );
+		
+		self maps\mp\gametypes\_gameobjects::disableObject();
+
+		if ( level.bombExploded < 2 )
+		{
+			foreach ( splashPlayer in level.players )
+				splashPlayer thread maps\mp\gametypes\_hud_message::SplashNotify( "time_added" );
+		}
+	
+		wait 2;
+		
+		if ( level.bombExploded > 1 )
+			dd_endGame( game["attackers"], game["strings"]["target_destroyed"] );
+		else
+			level thread teamPlayerCardSplash( "callout_time_added", player );
+	}
+	else //defused
+	{
+		player notify ( "bomb_defused" );
+		self notify( "defused" );
+
+//		if ( !level.hardcoreMode )
+//			iPrintLn( &"MP_EXPLOSIVES_DEFUSED_BY", player );
+
+		leaderDialog( "bomb_defused" );
+
+		level thread teamPlayerCardSplash( "callout_bombdefused", player );
+
+		level thread bombDefused( self );
+		self resetBombzone();
+
+		if ( isDefined( level.bombOwner ) && ( level.bombOwner.bombPlantedTime + 4000 + (level.defuseTime*1000) ) > getTime() && isReallyAlive( level.bombOwner ) )
+			player thread maps\mp\gametypes\_hud_message::SplashNotify( "ninja_defuse", ( maps\mp\gametypes\_rank::getScoreInfoValue( "defuse" ) ) );
+		else
+			player thread maps\mp\gametypes\_hud_message::SplashNotify( "defuse", maps\mp\gametypes\_rank::getScoreInfoValue( "defuse" ) );
+					
+		player thread maps\mp\gametypes\_rank::giveRankXP( "defuse" );
+		maps\mp\gametypes\_gamescore::givePlayerScore( "defuse", player );
+		player incPlayerStat( "bombsdefused", 1 );
+		player thread maps\mp\_matchdata::logGameEvent( "defuse", player.origIn );
+	}
+	
+}
+
+playDemolitionTickingSound( site )
+{
+	self endon("death");
+	self endon("stopTicking");
+	level endon("game_ended");
+	
+	while(1)
+	{
+		self playSound( "ui_mp_suitcasebomb_timer" );
+		
+		if ( !isDefined( site.waitTime ) || site.waitTime > 10 )
+			wait 1.0;
+		else if ( isDefined( site.waitTime ) && site.waitTime > 5  )
+			wait 0.5;
+		else 
+			wait 0.25;
+		maps\mp\gametypes\_hostmigration::waitTillHostMigrationDone();
+	}
+}
+
+setBombTimerDvar()
+{
+	println( "BOMBS PLANTED: " + level.bombsPlanted );
+	
+	if ( level.bombsPlanted == 1 )
+		setDvar( "ui_bomb_timer", 2 );
+	else if ( level.bombsPlanted == 2 )
+		setDvar( "ui_bomb_timer", 3 );
+	else
+		setDvar( "ui_bomb_timer", 0 );
+}
+
+
+dropBombModel( player, site )
+{
+	trace = bulletTrace( player.origin + (0,0,20), player.origin - (0,0,2000), false, player );
+
+	tempAngle = randomfloat( 360 );
+	forward = (cos( tempAngle ), sin( tempAngle ), 0);
+	forward = vectornormalize( forward - common_scripts\utility::vector_multiply( trace["normal"], vectordot( forward, trace["normal"] ) ) );
+	dropAngles = vectortoangles( forward );
+	
+	level.ddBombModel[ site ] = spawn( "script_model", trace["position"] );
+	level.ddBombModel[ site ].angles = dropAngles;
+	level.ddBombModel[ site ] setModel( "prop_suitcase_bomb" );
+}
+
+
+restartTimer()
+{
+	if ( level.bombsPlanted <= 0 )
+	{
+		maps\mp\gametypes\_gamelogic::resumeTimer();
+		level.timePaused = ( getTime() - level.timePauseStart ) ;
+		level.timeLimitOverride = false;
+	}
+}
+
+
+BombTimerWait(siteLoc)
+{
+	level endon("game_ended");
+	level endon("bomb_defused" + siteLoc.label );
+
+	siteLoc.waitTime = level.bombTimer;
+	
+	while ( siteLoc.waitTime >= 0 )
+	{
+		siteLoc.waitTime--;
+		setDvar( "ui_bombtimer" + siteLoc.label, siteLoc.waitTime );
+
+		//self maps\mp\gametypes\_gameobjects::updateTimer( waitTime, true );
+		
+		if ( siteLoc.waitTime >= 0 )
+			wait( 1 );
+		
+		maps\mp\gametypes\_hostmigration::waitTillHostMigrationDone();
+	}
+}
+
+bombDefused( siteDefused )
+{
+	level.tickingObject maps\mp\gametypes\_gamelogic::stopTickingSound();
+	siteDefused.bombDefused = true;
+	self setBombTimerDvar();
+	
+	setDvar( "ui_bombtimer" + siteDefused.label, -1 );
+	
+	level notify("bomb_defused" + siteDefused.label);	
+}
+
+initGametypeAwards()
+{
+	maps\mp\_awards::initStatAward( "targetsdestroyed", 	0, maps\mp\_awards::highestWins );
+	maps\mp\_awards::initStatAward( "bombsplanted", 		0, maps\mp\_awards::highestWins );
+	maps\mp\_awards::initStatAward( "bombsdefused", 		0, maps\mp\_awards::highestWins );
+	maps\mp\_awards::initStatAward( "bombcarrierkills", 	0, maps\mp\_awards::highestWins );
+	maps\mp\_awards::initStatAward( "bombscarried", 		0, maps\mp\_awards::highestWins );
+	maps\mp\_awards::initStatAward( "killsasbombcarrier", 	0, maps\mp\_awards::highestWins );
+}

iw4x/iw4x_00/maps/mp/gametypes/dm.gsc

@@ -0,0 +1,100 @@
+#include maps\mp\_utility;
+#include maps\mp\gametypes\_hud_util;
+/*
+	Deathmatch
+	Objective: 	Score points by eliminating other players
+	Map ends:	When one player reaches the score limit, or time limit is reached
+	Respawning:	No wait / Away from other players
+
+	Level requirements
+	------------------
+		Spawnpoints:
+			classname		mp_dm_spawn
+			All players spawn from these. The spawnpoint chosen is dependent on the current locations of enemies at the time of spawn.
+			Players generally spawn away from enemies.
+
+		Spectator Spawnpoints:
+			classname		mp_global_intermission
+			Spectators spawn from these and intermission is viewed from these positions.
+			Atleast one is required, any more and they are randomly chosen between.
+*/
+
+/*QUAKED mp_dm_spawn (1.0 0.5 0.0) (-16 -16 0) (16 16 72)
+Players spawn away from enemies at one of these positions.*/
+
+main()
+{
+	maps\mp\gametypes\_globallogic::init();
+	maps\mp\gametypes\_callbacksetup::SetupCallbacks();
+	maps\mp\gametypes\_globallogic::SetupCallbacks();
+
+	registerTimeLimitDvar( level.gameType, 10, 0, 1440 );
+	registerScoreLimitDvar( level.gameType, 1000, 0, 5000 );
+	registerWinLimitDvar( level.gameType, 1, 0, 5000 );
+	registerRoundLimitDvar( level.gameType, 1, 0, 10 );
+	registerNumLivesDvar( level.gameType, 0, 0, 10 );
+	registerHalfTimeDvar( level.gameType, 0, 0, 1 );
+
+	level.onStartGameType = ::onStartGameType;
+	level.getSpawnPoint = ::getSpawnPoint;
+
+	game["dialog"]["gametype"] = "freeforall";
+
+	if ( getDvarInt( "g_hardcore" ) )
+		game["dialog"]["gametype"] = "hc_" + game["dialog"]["gametype"];
+	else if ( getDvarInt( "camera_thirdPerson" ) )
+		game["dialog"]["gametype"] = "thirdp_" + game["dialog"]["gametype"];
+	else if ( getDvarInt( "scr_diehard" ) )
+		game["dialog"]["gametype"] = "dh_" + game["dialog"]["gametype"];
+	else if (getDvarInt( "scr_" + level.gameType + "_promode" ) )
+		game["dialog"]["gametype"] = game["dialog"]["gametype"] + "_pro";
+}
+
+
+onStartGameType()
+{
+	setClientNameMode("auto_change");
+
+	setObjectiveText( "allies", &"OBJECTIVES_DM" );
+	setObjectiveText( "axis", &"OBJECTIVES_DM" );
+
+	if ( level.splitscreen )
+	{
+		setObjectiveScoreText( "allies", &"OBJECTIVES_DM" );
+		setObjectiveScoreText( "axis", &"OBJECTIVES_DM" );
+	}
+	else
+	{
+		setObjectiveScoreText( "allies", &"OBJECTIVES_DM_SCORE" );
+		setObjectiveScoreText( "axis", &"OBJECTIVES_DM_SCORE" );
+	}
+	setObjectiveHintText( "allies", &"OBJECTIVES_DM_HINT" );
+	setObjectiveHintText( "axis", &"OBJECTIVES_DM_HINT" );
+
+	level.spawnMins = ( 0, 0, 0 );
+	level.spawnMaxs = ( 0, 0, 0 );
+	maps\mp\gametypes\_spawnlogic::addSpawnPoints( "allies", "mp_dm_spawn" );
+	maps\mp\gametypes\_spawnlogic::addSpawnPoints( "axis", "mp_dm_spawn" );
+	level.mapCenter = maps\mp\gametypes\_spawnlogic::findBoxCenter( level.spawnMins, level.spawnMaxs );
+	setMapCenter( level.mapCenter );
+	
+	allowed[0] = "dm";
+	maps\mp\gametypes\_gameobjects::main(allowed);
+
+	maps\mp\gametypes\_rank::registerScoreInfo( "kill", 50 );
+	maps\mp\gametypes\_rank::registerScoreInfo( "headshot", 50 );
+	maps\mp\gametypes\_rank::registerScoreInfo( "assist", 10 );
+	maps\mp\gametypes\_rank::registerScoreInfo( "suicide", 0 );
+	maps\mp\gametypes\_rank::registerScoreInfo( "teamkill", 0 );
+	
+	level.QuickMessageToAll = true;
+}
+
+
+getSpawnPoint()
+{
+	spawnPoints = maps\mp\gametypes\_spawnlogic::getTeamSpawnPoints( self.pers["team"] );
+	spawnPoint = maps\mp\gametypes\_spawnlogic::getSpawnpoint_DM( spawnPoints );
+
+	return spawnPoint;
+}

iw4x/iw4x_00/maps/mp/gametypes/dom.gsc

@@ -0,0 +1,976 @@
+#include common_scripts\utility;
+#include maps\mp\_utility;
+#include maps\mp\gametypes\_hud_util;
+/*
+	Domination
+	Objective: 	Capture all the flags by touching them
+	Map ends:	When one team captures all the flags, or time limit is reached
+	Respawning:	No wait / Near teammates
+
+	Level requirements
+	------------------
+		Spawnpoints:
+			classname		mp_tdm_spawn
+			All players spawn from these. The spawnpoint chosen is dependent on the current locations of owned flags, teammates and 
+			enemies at the time of spawn. Players generally spawn behind their teammates relative to the direction of enemies.
+			Optionally, give a spawnpoint a script_linkto to specify which flag it "belongs" to (see Flag Descriptors).
+
+		Spectator Spawnpoints:
+			classname		mp_global_intermission
+			Spectators spawn from these and intermission is viewed from these positions.
+			Atleast one is required, any more and they are randomly chosen between.
+
+		Flags:
+			classname       trigger_radius
+			targetname      flag_primary or flag_secondary
+			Flags that need to be captured to win. Primary flags take time to capture; secondary flags are instant.
+		
+		Flag Descriptors:
+			classname       script_origin
+			targetname      flag_descriptor
+			Place one flag descriptor close to each flag. Use the script_linkname and script_linkto properties to say which flags
+			it can be considered "adjacent" to in the level. For instance, if players have a primary path from flag1 to flag2, and 
+			from flag2 to flag3, flag2 would have a flag_descriptor with these properties:
+			script_linkname flag2
+			script_linkto flag1 flag3
+			
+			Set scr_domdebug to 1 to see flag connections and what spawnpoints are considered connected to each flag.
+*/
+
+/*QUAKED mp_dom_spawn (0.5 0.5 1.0) (-16 -16 0) (16 16 72)
+Players spawn near their flags at one of these positions.*/
+
+/*QUAKED mp_dom_spawn_axis_start (1.0 0.0 1.0) (-16 -16 0) (16 16 72)
+Axis players spawn away from enemies and near their team at one of these positions at the start of a round.*/
+
+/*QUAKED mp_dom_spawn_allies_start (0.0 1.0 1.0) (-16 -16 0) (16 16 72)
+Allied players spawn away from enemies and near their team at one of these positions at the start of a round.*/
+
+main()
+{
+	if(getdvar("mapname") == "mp_background")
+		return;
+
+	maps\mp\gametypes\_globallogic::init();
+	maps\mp\gametypes\_callbacksetup::SetupCallbacks();
+	maps\mp\gametypes\_globallogic::SetupCallbacks();
+
+	registerTimeLimitDvar( level.gameType, 30, 0, 1440 );
+	registerScoreLimitDvar( level.gameType, 300, 0, 1000 );
+	registerRoundLimitDvar( level.gameType, 1, 0, 10 );
+	registerWinLimitDvar( level.gameType, 1, 0, 10 );
+	registerNumLivesDvar( level.gameType, 0, 0, 10 );
+	registerHalfTimeDvar( level.gameType, 0, 0, 1 );
+
+	level.teamBased = true;
+	level.onStartGameType = ::onStartGameType;
+	level.getSpawnPoint = ::getSpawnPoint;
+	level.onPlayerKilled = ::onPlayerKilled;
+	level.onPrecacheGameType = ::onPrecacheGameType;
+	level.initGametypeAwards = ::initGametypeAwards;
+	level.onSpawnPlayer = ::onSpawnPlayer;
+	
+	game["dialog"]["gametype"] = "domination";
+
+	if ( getDvarInt( "g_hardcore" ) )
+		game["dialog"]["gametype"] = "hc_" + game["dialog"]["gametype"];
+	else if ( getDvarInt( "camera_thirdPerson" ) )
+		game["dialog"]["gametype"] = "thirdp_" + game["dialog"]["gametype"];
+	else if ( getDvarInt( "scr_diehard" ) )
+		game["dialog"]["gametype"] = "dh_" + game["dialog"]["gametype"];
+	else if (getDvarInt( "scr_" + level.gameType + "_promode" ) )
+		game["dialog"]["gametype"] = game["dialog"]["gametype"] + "_pro";
+
+	game["dialog"]["offense_obj"] = "capture_objs";
+	game["dialog"]["defense_obj"] = "capture_objs";
+}
+
+
+onPrecacheGameType()
+{
+	precacheShader( "waypoint_captureneutral" );
+	precacheShader( "waypoint_capture" );
+	precacheShader( "waypoint_defend" );
+	precacheShader( "waypoint_captureneutral_a" );
+	precacheShader( "waypoint_capture_a" );
+	precacheShader( "waypoint_defend_a" );
+	precacheShader( "waypoint_captureneutral_b" );
+	precacheShader( "waypoint_capture_b" );
+	precacheShader( "waypoint_defend_b" );
+	precacheShader( "waypoint_captureneutral_c" );
+	precacheShader( "waypoint_capture_c" );
+	precacheShader( "waypoint_defend_c" );
+
+	precacheShader( "waypoint_captureneutral" );
+	precacheShader( "waypoint_capture" );
+	precacheShader( "waypoint_defend" );
+	precacheShader( "waypoint_captureneutral_a" );
+	precacheShader( "waypoint_capture_a" );
+	precacheShader( "waypoint_defend_a" );
+	precacheShader( "waypoint_captureneutral_b" );
+	precacheShader( "waypoint_capture_b" );
+	precacheShader( "waypoint_defend_b" );
+	precacheShader( "waypoint_captureneutral_c" );
+	precacheShader( "waypoint_capture_c" );
+	precacheShader( "waypoint_defend_c" );
+}
+
+
+onStartGameType()
+{	
+	setObjectiveText( "allies", &"OBJECTIVES_DOM" );
+	setObjectiveText( "axis", &"OBJECTIVES_DOM" );
+
+	if ( level.splitscreen )
+	{
+		setObjectiveScoreText( "allies", &"OBJECTIVES_DOM" );
+		setObjectiveScoreText( "axis", &"OBJECTIVES_DOM" );
+	}
+	else
+	{
+		setObjectiveScoreText( "allies", &"OBJECTIVES_DOM_SCORE" );
+		setObjectiveScoreText( "axis", &"OBJECTIVES_DOM_SCORE" );
+	}
+	setObjectiveHintText( "allies", &"OBJECTIVES_DOM_HINT" );
+	setObjectiveHintText( "axis", &"OBJECTIVES_DOM_HINT" );
+
+	setClientNameMode("auto_change");
+
+	level.spawnMins = ( 0, 0, 0 );
+	level.spawnMaxs = ( 0, 0, 0 );
+	maps\mp\gametypes\_spawnlogic::placeSpawnPoints( "mp_dom_spawn_allies_start" );
+	maps\mp\gametypes\_spawnlogic::placeSpawnPoints( "mp_dom_spawn_axis_start" );
+	maps\mp\gametypes\_spawnlogic::addSpawnPoints( "allies", "mp_dom_spawn" );
+	maps\mp\gametypes\_spawnlogic::addSpawnPoints( "axis", "mp_dom_spawn" );
+	
+	level.mapCenter = maps\mp\gametypes\_spawnlogic::findBoxCenter( level.spawnMins, level.spawnMaxs );
+	setMapCenter( level.mapCenter );
+	
+	level.spawn_all = maps\mp\gametypes\_spawnlogic::getSpawnpointArray( "mp_dom_spawn" );
+	if ( getDvar( "mapname" ) == "mp_shipment_long" )
+	{
+		level.spawn_axis_start = maps\mp\gametypes\_spawnlogic::getSpawnpointArray( "mp_cha_spawn_axis_start" );
+		level.spawn_allies_start = maps\mp\gametypes\_spawnlogic::getSpawnpointArray( "mp_cha_spawn_allies_start" );
+	}
+	else
+	{
+		level.spawn_axis_start = maps\mp\gametypes\_spawnlogic::getSpawnpointArray( "mp_dom_spawn_axis_start" );
+		level.spawn_allies_start = maps\mp\gametypes\_spawnlogic::getSpawnpointArray( "mp_dom_spawn_allies_start" );
+	}
+	
+	level.startPos["allies"] = level.spawn_allies_start[0].origin;
+	level.startPos["axis"] = level.spawn_axis_start[0].origin;
+	
+	level.flagBaseFXid[ "allies" ] = loadfx( maps\mp\gametypes\_teams::getTeamFlagFX( "allies" ) );
+	level.flagBaseFXid[ "axis"   ] = loadfx( maps\mp\gametypes\_teams::getTeamFlagFX( "axis" ) );
+	
+	allowed[0] = "dom";
+//	allowed[1] = "hardpoint";
+	maps\mp\gametypes\_gameobjects::main(allowed);
+
+	maps\mp\gametypes\_rank::registerScoreInfo( "kill", 50 );
+	maps\mp\gametypes\_rank::registerScoreInfo( "headshot", 50 );
+	maps\mp\gametypes\_rank::registerScoreInfo( "assist", 10 );
+
+	maps\mp\gametypes\_rank::registerScoreInfo( "capture", 150 );
+
+	maps\mp\gametypes\_rank::registerScoreInfo( "defend", 50 );
+	maps\mp\gametypes\_rank::registerScoreInfo( "defend_assist", 10 );
+
+	maps\mp\gametypes\_rank::registerScoreInfo( "assault", 50 );
+	maps\mp\gametypes\_rank::registerScoreInfo( "assault_assist", 10 );
+		
+	thread domFlags();
+	thread updateDomScores();	
+}
+
+
+getSpawnPoint()
+{
+	spawnpoint = undefined;
+	
+	if ( !level.useStartSpawns )
+	{
+		flagsOwned = 0;
+		enemyFlagsOwned = 0;
+		myTeam = self.pers["team"];
+		enemyTeam = getOtherTeam( myTeam );
+		for ( i = 0; i < level.flags.size; i++ )
+		{
+			team = level.flags[i] getFlagTeam();
+			if ( team == myTeam )
+				flagsOwned++;
+			else if ( team == enemyTeam )
+				enemyFlagsOwned++;
+		}
+		
+		if ( flagsOwned == level.flags.size )
+		{
+			// own all flags! pretend we don't own the last one we got, so enemies can spawn there
+			enemyBestSpawnFlag = level.bestSpawnFlag[ getOtherTeam( self.pers["team"] ) ];
+			
+			spawnpoint = maps\mp\gametypes\_spawnlogic::getSpawnpoint_NearTeam( level.spawn_all, getSpawnsBoundingFlag( enemyBestSpawnFlag ) );
+		}
+		else if ( flagsOwned > 0 )
+		{
+			// spawn near any flag we own that's nearish something we can capture
+			spawnpoint = maps\mp\gametypes\_spawnlogic::getSpawnpoint_NearTeam( level.spawn_all, getBoundaryFlagSpawns( myTeam ) );
+		}
+		else
+		{
+			// own no flags!
+			bestFlag = undefined;
+			if ( enemyFlagsOwned > 0 && enemyFlagsOwned < level.flags.size )
+			{
+				// there should be an unowned one to use
+				bestFlag = getUnownedFlagNearestStart( myTeam );
+			}
+			if ( !isdefined( bestFlag ) )
+			{
+				// pretend we still own the last one we lost
+				bestFlag = level.bestSpawnFlag[ self.pers["team"] ];
+			}
+			level.bestSpawnFlag[ self.pers["team"] ] = bestFlag;
+			
+			spawnpoint = maps\mp\gametypes\_spawnlogic::getSpawnpoint_NearTeam( level.spawn_all, bestFlag.nearbyspawns );
+		}
+	}
+	
+	if ( !isdefined( spawnpoint ) )
+	{
+		if (self.pers["team"] == "axis")
+			spawnpoint = maps\mp\gametypes\_spawnlogic::getSpawnpoint_Random(level.spawn_axis_start);
+		else
+			spawnpoint = maps\mp\gametypes\_spawnlogic::getSpawnpoint_Random(level.spawn_allies_start);
+	}
+	
+	//spawnpoint = maps\mp\gametypes\_spawnlogic::getSpawnpoint_NearTeam( level.spawn_all );
+	
+	assert( isDefined(spawnpoint) );
+	
+	return spawnpoint;
+}
+
+
+domFlags()
+{
+	level.lastStatus["allies"] = 0;
+	level.lastStatus["axis"] = 0;
+	
+	game["flagmodels"] = [];
+	game["flagmodels"]["neutral"] = "prop_flag_neutral";
+
+	game["flagmodels"]["allies"] = maps\mp\gametypes\_teams::getTeamFlagModel( "allies" );
+	game["flagmodels"]["axis"] = maps\mp\gametypes\_teams::getTeamFlagModel( "axis" );
+	
+	precacheModel( game["flagmodels"]["neutral"] );
+	precacheModel( game["flagmodels"]["allies"] );
+	precacheModel( game["flagmodels"]["axis"] );
+	
+	precacheString( &"MP_SECURING_POSITION" );	
+	
+	primaryFlags = getEntArray( "flag_primary", "targetname" );
+	secondaryFlags = getEntArray( "flag_secondary", "targetname" );
+	
+	if ( (primaryFlags.size + secondaryFlags.size) < 2 )
+	{
+		printLn( "^1Not enough domination flags found in level!" );
+		maps\mp\gametypes\_callbacksetup::AbortLevel();
+		return;
+	}
+	
+	level.flags = [];
+	for ( index = 0; index < primaryFlags.size; index++ )
+		level.flags[level.flags.size] = primaryFlags[index];
+	
+	for ( index = 0; index < secondaryFlags.size; index++ )
+		level.flags[level.flags.size] = secondaryFlags[index];
+	
+	level.domFlags = [];
+	for ( index = 0; index < level.flags.size; index++ )
+	{
+		trigger = level.flags[index];
+		if ( isDefined( trigger.target ) )
+		{
+			visuals[0] = getEnt( trigger.target, "targetname" );
+		}
+		else
+		{
+			visuals[0] = spawn( "script_model", trigger.origin );
+			visuals[0].angles = trigger.angles;
+		}
+
+		visuals[0] setModel( game["flagmodels"]["neutral"] );
+
+		domFlag = maps\mp\gametypes\_gameobjects::createUseObject( "neutral", trigger, visuals, (0,0,100) );
+		domFlag maps\mp\gametypes\_gameobjects::allowUse( "enemy" );
+		domFlag maps\mp\gametypes\_gameobjects::setUseTime( 10.0 );
+		domFlag maps\mp\gametypes\_gameobjects::setUseText( &"MP_SECURING_POSITION" );
+		label = domFlag maps\mp\gametypes\_gameobjects::getLabel();
+		domFlag.label = label;
+		domFlag maps\mp\gametypes\_gameobjects::set2DIcon( "friendly", "waypoint_defend" + label );
+		domFlag maps\mp\gametypes\_gameobjects::set3DIcon( "friendly", "waypoint_defend" + label );
+		domFlag maps\mp\gametypes\_gameobjects::set2DIcon( "enemy", "waypoint_captureneutral" + label );
+		domFlag maps\mp\gametypes\_gameobjects::set3DIcon( "enemy", "waypoint_captureneutral" + label );
+		domFlag maps\mp\gametypes\_gameobjects::setVisibleTeam( "any" );
+		domFlag.onUse = ::onUse;
+		domFlag.onBeginUse = ::onBeginUse;
+		domFlag.onUseUpdate = ::onUseUpdate;
+		domFlag.onEndUse = ::onEndUse;
+		
+		
+		traceStart = visuals[0].origin + (0,0,32);
+		traceEnd = visuals[0].origin + (0,0,-32);
+		trace = bulletTrace( traceStart, traceEnd, false, undefined );
+	
+		upangles = vectorToAngles( trace["normal"] );
+		domFlag.baseeffectforward = anglesToForward( upangles );
+		domFlag.baseeffectright = anglesToRight( upangles );
+		
+		domFlag.baseeffectpos = trace["position"];
+		
+		// legacy spawn code support
+		level.flags[index].useObj = domFlag;
+		level.flags[index].adjflags = [];
+		level.flags[index].nearbyspawns = [];
+		
+		domFlag.levelFlag = level.flags[index];
+		
+		level.domFlags[level.domFlags.size] = domFlag;
+	}
+	
+	// level.bestSpawnFlag is used as a last resort when the enemy holds all flags.
+	level.bestSpawnFlag = [];
+	level.bestSpawnFlag[ "allies" ] = getUnownedFlagNearestStart( "allies", undefined );
+	level.bestSpawnFlag[ "axis" ] = getUnownedFlagNearestStart( "axis", level.bestSpawnFlag[ "allies" ] );
+	
+	flagSetup();
+	
+	/#
+	thread domDebug();
+	#/
+}
+
+getUnownedFlagNearestStart( team, excludeFlag )
+{
+	best = undefined;
+	bestdistsq = undefined;
+	for ( i = 0; i < level.flags.size; i++ )
+	{
+		flag = level.flags[i];
+		
+		if ( flag getFlagTeam() != "neutral" )
+			continue;
+		
+		distsq = distanceSquared( flag.origin, level.startPos[team] );
+		if ( (!isDefined( excludeFlag ) || flag != excludeFlag) && (!isdefined( best ) || distsq < bestdistsq) )
+		{
+			bestdistsq = distsq;
+			best = flag;
+		}
+	}
+	return best;
+}
+
+/#
+domDebug()
+{
+	while(1)
+	{
+		if (getdvar("scr_domdebug") != "1") {
+			wait 2;
+			continue;
+		}
+		
+		while(1)
+		{
+			if (getdvar("scr_domdebug") != "1")
+				break;
+			// show flag connections and each flag's spawnpoints
+			for (i = 0; i < level.flags.size; i++) {
+				for (j = 0; j < level.flags[i].adjflags.size; j++) {
+					line(level.flags[i].origin, level.flags[i].adjflags[j].origin, (1,1,1));
+				}
+				
+				for (j = 0; j < level.flags[i].nearbyspawns.size; j++) {
+					line(level.flags[i].origin, level.flags[i].nearbyspawns[j].origin, (.2,.2,.6));
+				}
+				
+				if ( level.flags[i] == level.bestSpawnFlag["allies"] )
+					print3d( level.flags[i].origin, "allies best spawn flag" );
+				if ( level.flags[i] == level.bestSpawnFlag["axis"] )
+					print3d( level.flags[i].origin, "axis best spawn flag" );
+			}
+			wait .05;
+		}
+	}
+}
+#/
+
+onBeginUse( player )
+{
+	ownerTeam = self maps\mp\gametypes\_gameobjects::getOwnerTeam();
+	self.didStatusNotify = false;
+
+	if ( ownerTeam == "neutral" )
+	{
+		statusDialog( "securing"+self.label, player.pers["team"] );
+		self.objPoints[player.pers["team"]] thread maps\mp\gametypes\_objpoints::startFlashing();
+		return;
+	}
+		
+	if ( ownerTeam == "allies" )
+		otherTeam = "axis";
+	else
+		otherTeam = "allies";
+
+	self.objPoints["allies"] thread maps\mp\gametypes\_objpoints::startFlashing();
+	self.objPoints["axis"] thread maps\mp\gametypes\_objpoints::startFlashing();
+}
+
+
+onUseUpdate( team, progress, change )
+{
+	if ( progress > 0.05 && change && !self.didStatusNotify )
+	{
+		ownerTeam = self maps\mp\gametypes\_gameobjects::getOwnerTeam();
+		if ( ownerTeam == "neutral" )
+		{
+			statusDialog( "securing"+self.label, team );
+		}
+		else
+		{
+			statusDialog( "losing"+self.label, ownerTeam );
+			statusDialog( "securing"+self.label, team );
+		}
+
+		self.didStatusNotify = true;
+	}
+}
+
+
+statusDialog( dialog, team, forceDialog )
+{
+	time = getTime();
+	
+	if ( getTime() < level.lastStatus[team] + 5000 && (!isDefined( forceDialog ) || !forceDialog) )
+		return;
+		
+	thread delayedLeaderDialog( dialog, team );
+	level.lastStatus[team] = getTime();	
+}
+
+
+onEndUse( team, player, success )
+{
+	self.objPoints["allies"] thread maps\mp\gametypes\_objpoints::stopFlashing();
+	self.objPoints["axis"] thread maps\mp\gametypes\_objpoints::stopFlashing();
+}
+
+
+resetFlagBaseEffect()
+{
+	if ( isdefined( self.baseeffect ) )
+		self.baseeffect delete();
+	
+	team = self maps\mp\gametypes\_gameobjects::getOwnerTeam();
+	
+	if ( team != "axis" && team != "allies" )
+		return;
+	
+	fxid = level.flagBaseFXid[ team ];
+
+	self.baseeffect = spawnFx( fxid, self.baseeffectpos, self.baseeffectforward, self.baseeffectright );
+	triggerFx( self.baseeffect );
+}
+
+onUse( player )
+{
+	team = player.pers["team"];
+	oldTeam = self maps\mp\gametypes\_gameobjects::getOwnerTeam();
+	label = self maps\mp\gametypes\_gameobjects::getLabel();
+	
+	//player logString( "flag captured: " + self.label );
+	
+	self.captureTime = getTime();
+	
+	self maps\mp\gametypes\_gameobjects::setOwnerTeam( team );
+	self maps\mp\gametypes\_gameobjects::set2DIcon( "enemy", "waypoint_capture" + label );
+	self maps\mp\gametypes\_gameobjects::set3DIcon( "enemy", "waypoint_capture" + label );
+	self.visuals[0] setModel( game["flagmodels"][team] );
+	
+	self resetFlagBaseEffect();
+	
+	level.useStartSpawns = false;
+	
+	assert( team != "neutral" );
+	
+	if ( oldTeam == "neutral" )
+	{
+		otherTeam = getOtherTeam( team );
+		thread printAndSoundOnEveryone( team, otherTeam, undefined, undefined, "mp_war_objective_taken", undefined, player );
+		
+		statusDialog( "secured"+self.label, team, true );
+		statusDialog( "enemy_has"+self.label, otherTeam, true );
+	}
+	else
+	{
+		thread printAndSoundOnEveryone( team, oldTeam, undefined, undefined, "mp_war_objective_taken", "mp_war_objective_lost", player );
+		
+//		thread delayedLeaderDialogBothTeams( "obj_lost", oldTeam, "obj_taken", team );
+
+		if ( getTeamFlagCount( team ) == level.flags.size )
+		{
+			statusDialog( "secure_all", team );
+			statusDialog( "lost_all", oldTeam );
+		}
+		else
+		{	
+			statusDialog( "secured"+self.label, team, true );
+			statusDialog( "lost"+self.label, oldTeam, true );
+		}
+		
+		level.bestSpawnFlag[ oldTeam ] = self.levelFlag;
+	}
+	
+	player notify( "objective", "captured" );
+	self thread giveFlagCaptureXP( self.touchList[team] );
+}
+
+giveFlagCaptureXP( touchList )
+{
+	level endon ( "game_ended" );
+	
+	players = getArrayKeys( touchList );
+	for ( index = 0; index < players.size; index++ )
+	{
+		player = touchList[players[index]].player;
+		player thread maps\mp\gametypes\_hud_message::SplashNotify( "capture", maps\mp\gametypes\_rank::getScoreInfoValue( "capture" ) );
+		player thread updateCPM();
+		player thread maps\mp\gametypes\_rank::giveRankXP( "capture", maps\mp\gametypes\_rank::getScoreInfoValue( "capture" ) * player getCapXPScale() );
+		printLn( maps\mp\gametypes\_rank::getScoreInfoValue( "capture" ) * player getCapXPScale() );
+		maps\mp\gametypes\_gamescore::givePlayerScore( "capture", player );
+		player incPlayerStat( "pointscaptured", 1 );
+	}
+	
+	player = self maps\mp\gametypes\_gameobjects::getEarliestClaimPlayer();
+
+	level thread teamPlayerCardSplash( "callout_securedposition" + self.label, player );
+
+	player thread maps\mp\_matchdata::logGameEvent( "capture", player.origin );	
+}
+
+delayedLeaderDialog( sound, team )
+{
+	level endon ( "game_ended" );
+	wait .1;
+	WaitTillSlowProcessAllowed();
+	
+	leaderDialog( sound, team );
+}
+delayedLeaderDialogBothTeams( sound1, team1, sound2, team2 )
+{
+	level endon ( "game_ended" );
+	wait .1;
+	WaitTillSlowProcessAllowed();
+	
+	leaderDialogBothTeams( sound1, team1, sound2, team2 );
+}
+
+
+updateDomScores()
+{
+	level endon ( "game_ended" );
+	
+	while ( !level.gameEnded )
+	{
+		domFlags = getOwnedDomFlags();
+		
+		if ( domFlags.size )
+		{
+			for ( i = 1; i < domFlags.size; i++ )
+			{
+				domFlag = domFlags[i];
+				flagScore = getTime() - domFlag.captureTime;
+				for ( j = i - 1; j >= 0 && flagScore > (getTime() - domFlags[j].captureTime); j-- )
+					domFlags[j + 1] = domFlags[j];
+				domFlags[j + 1] = domFlag;
+			}
+			
+			foreach( domFlag in domFlags )
+			{
+				team = domFlag maps\mp\gametypes\_gameobjects::getOwnerTeam();
+				assert( team == "allies" || team == "axis" );
+				maps\mp\gametypes\_gamescore::giveTeamScoreForObjective( team, 1 );	
+			}
+		}
+		
+		// end the game if people aren't playing
+		if ( (((getTimePassed() / 1000) > 120 && domFlags.size < 2) || ((getTimePassed() / 1000) > 300 && domFlags.size < 3)) && matchMakingGame() )
+		{
+			thread maps\mp\gametypes\_gamelogic::endGame( "none", game["strings"]["time_limit_reached"] );
+			return;			
+		}
+		
+		wait ( 5.0 );
+		maps\mp\gametypes\_hostmigration::waitTillHostMigrationDone();
+	}
+}
+
+
+onPlayerKilled( eInflictor, attacker, iDamage, sMeansOfDeath, sWeapon, vDir, sHitLoc, psOffsetTime, deathAnimDuration, killId )
+{
+	if ( !isPlayer( attacker ) || (!self.touchTriggers.size && !attacker.touchTriggers.size) || attacker.pers["team"] == self.pers["team"] )
+		return;
+
+	awardedAssault = false;
+	awardedDefend = false;
+
+	foreach ( trigger in self.touchTriggers )
+	{
+		// TODO: way to check for dom specific triggers
+		if ( !isDefined( trigger.useObj ) )
+			continue;
+		
+		ownerTeam = trigger.useObj.ownerTeam;
+		team = self.pers["team"];
+
+		if ( ownerTeam == "neutral" )
+			continue;
+		
+		if ( team == ownerTeam )
+		{
+			awardedAssault = true;
+			attacker thread maps\mp\gametypes\_hud_message::SplashNotify( "assault", maps\mp\gametypes\_rank::getScoreInfoValue( "assault" ) );
+			attacker thread maps\mp\gametypes\_rank::giveRankXP( "assault" );
+			maps\mp\gametypes\_gamescore::givePlayerScore( "assault", attacker );
+
+			thread maps\mp\_matchdata::logKillEvent( killId, "defending" );
+		}
+		else
+		{
+			awardedDefend = true;
+			attacker thread maps\mp\gametypes\_hud_message::SplashNotify( "defend", maps\mp\gametypes\_rank::getScoreInfoValue( "defend" ) );
+			attacker thread maps\mp\gametypes\_rank::giveRankXP( "defend" );
+			maps\mp\gametypes\_gamescore::givePlayerScore( "defend", attacker );
+
+			thread maps\mp\_matchdata::logKillEvent( killId, "assaulting" );
+		}
+	}
+
+	foreach ( trigger in attacker.touchTriggers )
+	{
+		// TODO: way to check for dom specific triggers
+		if ( !isDefined( trigger.useObj ) )
+			continue;
+		
+		ownerTeam = trigger.useObj.ownerTeam;
+		team = attacker.pers["team"];
+		
+		if ( ownerTeam == "neutral" )
+			continue;
+		
+		if ( team == ownerTeam )
+		{
+			if ( !awardedDefend )
+				attacker thread maps\mp\gametypes\_hud_message::SplashNotify( "defend", maps\mp\gametypes\_rank::getScoreInfoValue( "defend" ) );
+			attacker thread maps\mp\gametypes\_rank::giveRankXP( "defend" );
+			maps\mp\gametypes\_gamescore::givePlayerScore( "defend", attacker );
+
+			thread maps\mp\_matchdata::logKillEvent( killId, "assaulting" );
+		}
+		else
+		{
+			if ( !awardedAssault )
+				attacker thread maps\mp\gametypes\_hud_message::SplashNotify( "assault", maps\mp\gametypes\_rank::getScoreInfoValue( "assault" ) );
+			attacker thread maps\mp\gametypes\_rank::giveRankXP( "assault" );
+			maps\mp\gametypes\_gamescore::givePlayerScore( "assault", attacker );		
+
+			thread maps\mp\_matchdata::logKillEvent( killId, "defending" );
+		}
+	}
+}
+
+
+getOwnedDomFlags()
+{
+	domFlags = [];
+	foreach ( domFlag in level.domFlags )
+	{
+		if ( domFlag maps\mp\gametypes\_gameobjects::getOwnerTeam() != "neutral" && isDefined( domFlag.captureTime ) )
+			domFlags[domFlags.size] = domFlag;
+	}
+	
+	return domFlags;
+}
+
+
+getTeamFlagCount( team )
+{
+	score = 0;
+	for (i = 0; i < level.flags.size; i++) 
+	{
+		if ( level.domFlags[i] maps\mp\gametypes\_gameobjects::getOwnerTeam() == team )
+			score++;
+	}	
+	return score;
+}
+
+getFlagTeam()
+{
+	return self.useObj maps\mp\gametypes\_gameobjects::getOwnerTeam();
+}
+
+getBoundaryFlags()
+{
+	// get all flags which are adjacent to flags that aren't owned by the same team
+	bflags = [];
+	for (i = 0; i < level.flags.size; i++)
+	{
+		for (j = 0; j < level.flags[i].adjflags.size; j++)
+		{
+			if (level.flags[i].useObj maps\mp\gametypes\_gameobjects::getOwnerTeam() != level.flags[i].adjflags[j].useObj maps\mp\gametypes\_gameobjects::getOwnerTeam() )
+			{
+				bflags[bflags.size] = level.flags[i];
+				break;
+			}
+		}
+	}
+	
+	return bflags;
+}
+
+getBoundaryFlagSpawns(team)
+{
+	spawns = [];
+	
+	bflags = getBoundaryFlags();
+	for (i = 0; i < bflags.size; i++)
+	{
+		if (isdefined(team) && bflags[i] getFlagTeam() != team)
+			continue;
+		
+		for (j = 0; j < bflags[i].nearbyspawns.size; j++)
+			spawns[spawns.size] = bflags[i].nearbyspawns[j];
+	}
+	
+	return spawns;
+}
+
+getSpawnsBoundingFlag( avoidflag )
+{
+	spawns = [];
+
+	for (i = 0; i < level.flags.size; i++)
+	{
+		flag = level.flags[i];
+		if ( flag == avoidflag )
+			continue;
+		
+		isbounding = false;
+		for (j = 0; j < flag.adjflags.size; j++)
+		{
+			if ( flag.adjflags[j] == avoidflag )
+			{
+				isbounding = true;
+				break;
+			}
+		}
+		
+		if ( !isbounding )
+			continue;
+		
+		for (j = 0; j < flag.nearbyspawns.size; j++)
+			spawns[spawns.size] = flag.nearbyspawns[j];
+	}
+	
+	return spawns;
+}
+
+// gets an array of all spawnpoints which are near flags that are
+// owned by the given team, or that are adjacent to flags owned by the given team.
+getOwnedAndBoundingFlagSpawns(team)
+{
+	spawns = [];
+
+	for (i = 0; i < level.flags.size; i++)
+	{
+		if ( level.flags[i] getFlagTeam() == team )
+		{
+			// add spawns near this flag
+			for (s = 0; s < level.flags[i].nearbyspawns.size; s++)
+				spawns[spawns.size] = level.flags[i].nearbyspawns[s];
+		}
+		else
+		{
+			for (j = 0; j < level.flags[i].adjflags.size; j++)
+			{
+				if ( level.flags[i].adjflags[j] getFlagTeam() == team )
+				{
+					// add spawns near this flag
+					for (s = 0; s < level.flags[i].nearbyspawns.size; s++)
+						spawns[spawns.size] = level.flags[i].nearbyspawns[s];
+					break;
+				}
+			}
+		}
+	}
+	
+	return spawns;
+}
+
+// gets an array of all spawnpoints which are near flags that are
+// owned by the given team
+getOwnedFlagSpawns(team)
+{
+	spawns = [];
+
+	for (i = 0; i < level.flags.size; i++)
+	{
+		if ( level.flags[i] getFlagTeam() == team )
+		{
+			// add spawns near this flag
+			for (s = 0; s < level.flags[i].nearbyspawns.size; s++)
+				spawns[spawns.size] = level.flags[i].nearbyspawns[s];
+		}
+	}
+	
+	return spawns;
+}
+
+flagSetup()
+{
+	maperrors = [];
+	descriptorsByLinkname = [];
+
+	// (find each flag_descriptor object)
+	descriptors = getentarray("flag_descriptor", "targetname");
+	
+	flags = level.flags;
+	
+	for (i = 0; i < level.domFlags.size; i++)
+	{
+		closestdist = undefined;
+		closestdesc = undefined;
+		for (j = 0; j < descriptors.size; j++)
+		{
+			dist = distance(flags[i].origin, descriptors[j].origin);
+			if (!isdefined(closestdist) || dist < closestdist) {
+				closestdist = dist;
+				closestdesc = descriptors[j];
+			}
+		}
+		
+		if (!isdefined(closestdesc)) {
+			maperrors[maperrors.size] = "there is no flag_descriptor in the map! see explanation in dom.gsc";
+			break;
+		}
+		if (isdefined(closestdesc.flag)) {
+			maperrors[maperrors.size] = "flag_descriptor with script_linkname \"" + closestdesc.script_linkname + "\" is nearby more than one flag; is there a unique descriptor near each flag?";
+			continue;
+		}
+		flags[i].descriptor = closestdesc;
+		closestdesc.flag = flags[i];
+		descriptorsByLinkname[closestdesc.script_linkname] = closestdesc;
+	}
+	
+	if (maperrors.size == 0)
+	{
+		// find adjacent flags
+		for (i = 0; i < flags.size; i++)
+		{
+			if (isdefined(flags[i].descriptor.script_linkto))
+				adjdescs = strtok(flags[i].descriptor.script_linkto, " ");
+			else
+				adjdescs = [];
+			for (j = 0; j < adjdescs.size; j++)
+			{
+				otherdesc = descriptorsByLinkname[adjdescs[j]];
+				if (!isdefined(otherdesc) || otherdesc.targetname != "flag_descriptor") {
+					maperrors[maperrors.size] = "flag_descriptor with script_linkname \"" + flags[i].descriptor.script_linkname + "\" linked to \"" + adjdescs[j] + "\" which does not exist as a script_linkname of any other entity with a targetname of flag_descriptor (or, if it does, that flag_descriptor has not been assigned to a flag)";
+					continue;
+				}
+				adjflag = otherdesc.flag;
+				if (adjflag == flags[i]) {
+					maperrors[maperrors.size] = "flag_descriptor with script_linkname \"" + flags[i].descriptor.script_linkname + "\" linked to itself";
+					continue;
+				}
+				flags[i].adjflags[flags[i].adjflags.size] = adjflag;
+			}
+		}
+	}
+	
+	// assign each spawnpoint to nearest flag
+	spawnpoints = maps\mp\gametypes\_spawnlogic::getSpawnpointArray( "mp_dom_spawn" );
+	for (i = 0; i < spawnpoints.size; i++)
+	{
+		if (isdefined(spawnpoints[i].script_linkto)) {
+			desc = descriptorsByLinkname[spawnpoints[i].script_linkto];
+			if (!isdefined(desc) || desc.targetname != "flag_descriptor") {
+				maperrors[maperrors.size] = "Spawnpoint at " + spawnpoints[i].origin + "\" linked to \"" + spawnpoints[i].script_linkto + "\" which does not exist as a script_linkname of any entity with a targetname of flag_descriptor (or, if it does, that flag_descriptor has not been assigned to a flag)";
+				continue;
+			}
+			nearestflag = desc.flag;
+		}
+		else {
+			nearestflag = undefined;
+			nearestdist = undefined;
+			for (j = 0; j < flags.size; j++)
+			{
+				dist = distancesquared(flags[j].origin, spawnpoints[i].origin);
+				if (!isdefined(nearestflag) || dist < nearestdist)
+				{
+					nearestflag = flags[j];
+					nearestdist = dist;
+				}
+			}
+		}
+		nearestflag.nearbyspawns[nearestflag.nearbyspawns.size] = spawnpoints[i];
+	}
+	
+	if (maperrors.size > 0)
+	{
+		println("^1------------ Map Errors ------------");
+		for(i = 0; i < maperrors.size; i++)
+			println(maperrors[i]);
+		println("^1------------------------------------");
+		
+		error("Map errors. See above");
+		maps\mp\gametypes\_callbacksetup::AbortLevel();
+		
+		return;
+	}
+}
+
+initGametypeAwards()
+{
+	maps\mp\_awards::initStatAward( "pointscaptured", 0, maps\mp\_awards::highestWins );
+}
+
+onSpawnPlayer()
+{
+}
+
+updateCPM()
+{
+	if ( !isDefined( self.CPM ) )
+	{
+		self.numCaps = 0;
+		self.CPM = 0;
+	}
+	
+	self.numCaps++;
+	
+	if ( getMinutesPassed() < 1 )
+		return;
+		
+	self.CPM = self.numCaps / getMinutesPassed();
+}
+
+getCapXPScale()
+{
+	if ( self.CPM < 4 )
+		return 1;
+	else
+		return 0.25;
+}

iw4x/iw4x_00/maps/mp/gametypes/gtnw.gsc

@@ -0,0 +1,507 @@
+#include common_scripts\utility;
+#include maps\mp\_utility;
+#include maps\mp\gametypes\_hud_util;
+/*
+	Global Thermal Nuclear War
+*/
+
+/*QUAKED mp_ctf_spawn_axis (0.75 0.0 0.5) (-16 -16 0) (16 16 72)
+Axis players spawn away from enemies and near their team at one of these positions.*/
+
+/*QUAKED mp_ctf_spawn_allies (0.0 0.75 0.5) (-16 -16 0) (16 16 72)
+Allied players spawn away from enemies and near their team at one of these positions.*/
+
+/*QUAKED mp_ctf_spawn_axis_start (1.0 0.0 0.5) (-16 -16 0) (16 16 72)
+Axis players spawn away from enemies and near their team at one of these positions at the start of a round.*/
+
+/*QUAKED mp_ctf_spawn_allies_start (0.0 1.0 0.5) (-16 -16 0) (16 16 72)
+Allied players spawn away from enemies and near their team at one of these positions at the start of a round.*/
+
+main()
+{
+	maps\mp\gametypes\_globallogic::init();
+	maps\mp\gametypes\_callbacksetup::SetupCallbacks();
+	maps\mp\gametypes\_globallogic::SetupCallbacks();
+
+	registerTimeLimitDvar( level.gameType, 3, 0, 1440 );
+	registerScoreLimitDvar( level.gameType, 101, 0, 10000 );
+	registerRoundLimitDvar( level.gameType, 1, 0, 30 );
+	registerWinLimitDvar( level.gameType, 1, 0, 10 );
+	registerRoundSwitchDvar( level.gameType, 0, 0, 30 );
+	registerNumLivesDvar( level.gameType, 0, 0, 10 );
+	registerHalfTimeDvar( level.gameType, 0, 0, 1 );
+	
+	level.teamBased = true;
+	level.onPrecacheGameType = ::onPrecacheGameType;
+	level.onStartGameType = ::onStartGameType;
+	level.getSpawnPoint = ::getSpawnPoint;
+	level.onDeadEvent = ::onDeadEvent;
+	level.initGametypeAwards = ::initGametypeAwards;
+	level.onTimeLimit = ::onTimeLimit;
+	level.onNormalDeath = ::onNormalDeath;
+	level.gtnw = true;
+	
+	game["dialog"]["gametype"] = "gtw";
+	
+	if ( getDvarInt( "g_hardcore" ) )
+		game["dialog"]["gametype"] = "hc_" + game["dialog"]["gametype"];
+	else if ( getDvarInt( "camera_thirdPerson" ) )
+		game["dialog"]["gametype"] = "thirdp_" + game["dialog"]["gametype"];
+	else if ( getDvarInt( "scr_diehard" ) )
+		game["dialog"]["gametype"] = "dh_" + game["dialog"]["gametype"];
+	else if (getDvarInt( "scr_" + level.gameType + "_promode" ) )
+		game["dialog"]["gametype"] = game["dialog"]["gametype"] + "_pro";
+	
+	game["dialog"]["offense_obj"] = "obj_destroy";
+	game["dialog"]["defense_obj"] = "obj_defend";
+	level thread onPlayerConnect();
+}
+
+gtnw_endGame( winningTeam, endReasonText )
+{
+	thread maps\mp\gametypes\_gamelogic::endGame( winningTeam, endReasonText );
+}
+
+
+onPlayerConnect()
+{
+	for(;;)
+	{
+		level waittill( "connected", player );
+		
+		useBar = player createPrimaryProgressBar();
+   		useBarText = player createPrimaryProgressBarText();
+    	useBarText setText( &"MP_CAPTURING_NUKE" );
+    	
+    	useBar.useTime = 100;
+    	player.useBar = useBar;
+    	player.useBar hideElem();
+    	player.useBarText = useBarText;
+    	player.useBarText hideElem();
+	}
+}
+
+
+onStartGameType()
+{
+	if ( !isdefined( game["switchedsides"] ) )
+		game["switchedsides"] = false;
+
+	if ( !isdefined( game["original_defenders"] ) )
+		game["original_defenders"] = game["defenders"];
+
+	if ( game["switchedsides"] )
+	{
+		oldAttackers = game["attackers"];
+		oldDefenders = game["defenders"];
+		game["attackers"] = oldDefenders;
+		game["defenders"] = oldAttackers;
+	}
+
+	setClientNameMode("auto_change");
+	
+	
+	if ( level.splitscreen )
+	{
+		setObjectiveScoreText( game["attackers"], &"OBJECTIVES_GTNW" );
+		setObjectiveScoreText( game["defenders"], &"OBJECTIVES_GTNW" );
+	}
+	else
+	{
+		setObjectiveScoreText( game["attackers"], &"OBJECTIVES_GTNW_SCORE" );
+		setObjectiveScoreText( game["defenders"], &"OBJECTIVES_GTNW_SCORE" );
+	}
+	
+	setObjectiveText( game["attackers"], &"OBJECTIVES_GTNW" );
+	setObjectiveText( game["defenders"], &"OBJECTIVES_GTNW" );
+	
+	setObjectiveHintText( game["attackers"], &"OBJECTIVES_GTNW_HINT" );
+	setObjectiveHintText( game["defenders"], &"OBJECTIVES_GTNW_HINT" );
+	
+	level.spawnMins = ( 0, 0, 0 );
+	level.spawnMaxs = ( 0, 0, 0 );
+	maps\mp\gametypes\_spawnlogic::placeSpawnPoints( "mp_ctf_spawn_allies_start" );
+	maps\mp\gametypes\_spawnlogic::placeSpawnPoints( "mp_ctf_spawn_axis_start" );
+	maps\mp\gametypes\_spawnlogic::addSpawnPoints( "allies", "mp_ctf_spawn_allies" );
+	maps\mp\gametypes\_spawnlogic::addSpawnPoints( "axis", "mp_ctf_spawn_axis" );
+	
+	level.mapCenter = maps\mp\gametypes\_spawnlogic::findBoxCenter( level.spawnMins, level.spawnMaxs );
+	setMapCenter( level.mapCenter );
+	
+	thread maps\mp\gametypes\_dev::init();
+	
+	maps\mp\gametypes\_rank::registerScoreInfo( "kill", 50 );
+	maps\mp\gametypes\_rank::registerScoreInfo( "headshot", 100 );
+	maps\mp\gametypes\_rank::registerScoreInfo( "assist", 20 );
+	maps\mp\gametypes\_rank::registerScoreInfo( "capture", 500 );
+
+	allowed[0] = "airdrop_pallet";
+	allowed[1] = "gtnw";
+	allowed[2] = "gtnw_zone";
+	maps\mp\gametypes\_gameobjects::main(allowed);
+	
+	thread setupNukeSite();
+	
+}
+
+onPrecacheGameType()
+{
+	precacheShader("waypoint_defend");
+	precacheShader("waypoint_target");
+	precacheShader("waypoint_capture");
+	
+	precacheString( &"MP_CAPTURING_NUKE" );
+	return;
+}
+
+setupNukeSite()
+{
+	level.lastStatus["allies"] = 0;
+	level.lastStatus["axis"] = 0;
+	
+	nukeZone = getEnt( "gtnw_zone", "targetname" );
+	assertEx( isDefined( nukeZone ), "GTNW Zone prefab doesn't exist in this map" );
+	visuals = [];
+	
+	nukeSite  = maps\mp\gametypes\_gameobjects::createUseObject( "neutral", nukeZone, visuals, (0,0,100) );
+	
+	nukeSite maps\mp\gametypes\_gameobjects::set2DIcon( "friendly", "waypoint_defend");
+	nukeSite maps\mp\gametypes\_gameobjects::set3DIcon( "friendly", "waypoint_defend" );
+
+	nukeSite maps\mp\gametypes\_gameobjects::set2DIcon( "enemy", "waypoint_captureneutral" );
+	nukeSite maps\mp\gametypes\_gameobjects::set3DIcon( "enemy", "waypoint_captureneutral" );
+	
+	nukeSite maps\mp\gametypes\_gameobjects::allowUse( "enemy" );
+	nukeSite.noUseBar = true;
+	nukeSite maps\mp\gametypes\_gameobjects::setVisibleTeam( "any" );
+	
+	nukeSite.onBeginUse = ::onBeginUse;
+    nukeSite.onEndUse = ::onEndUse;
+                                
+	level.nukeSite = nukeSite;
+	nukeSite thread scoreCounter();
+}
+
+
+getSpawnPoint()
+{
+	if ( self.team == "axis" )
+		spawnTeam = game["attackers"];
+	else
+		spawnTeam = game["defenders"];
+		
+	if ( level.inGracePeriod )
+	{
+		if ( getDvar( "mapname" ) == "mp_shipment_long" )
+		{
+			spawnPoints = getentarray("mp_cha_spawn_" + spawnteam + "_start", "classname");		
+			spawnPoint = maps\mp\gametypes\_spawnlogic::getSpawnpoint_Random( spawnPoints );
+		}
+		else
+		{
+			spawnPoints = getentarray("mp_ctf_spawn_" + spawnteam + "_start", "classname");		
+			spawnPoint = maps\mp\gametypes\_spawnlogic::getSpawnpoint_Random( spawnPoints );
+		}
+	}
+	else
+	{
+		if ( getDvar( "mapname" ) == "mp_shipment_long" )
+		{
+			spawnPoints = maps\mp\gametypes\_spawnlogic::getSpawnpointArray( "mp_cha_spawn_" + spawnteam );
+			spawnPoint = maps\mp\gametypes\_spawnlogic::getSpawnpoint_Random( spawnPoints );
+		}
+		else
+		{
+			spawnPoints = maps\mp\gametypes\_spawnlogic::getTeamSpawnPoints( spawnteam );
+			spawnPoint = maps\mp\gametypes\_spawnlogic::getSpawnpoint_NearTeam( spawnPoints );
+		}
+	}
+	
+	return spawnPoint;
+}
+
+
+spawnFxDelay( fxid, pos, forward, right, delay )
+{
+	wait delay;
+	effect = spawnFx( fxid, pos, forward, right );
+	triggerFx( effect );
+}
+
+
+onDeadEvent( team )
+{
+	if ( ( isDefined( level.nukeIncoming ) && level.nukeIncoming ) || ( isDefined( level.nukeDetonated ) && level.nukeDetonated ) )
+		return;
+	
+	if ( team == game["attackers"] )
+	{
+		maps\mp\gametypes\_gamescore::giveTeamScoreForObjective( team, 1 );	
+		level thread gtnw_endGame( game["defenders"], game["strings"][game["attackers"]+"_eliminated"] );
+	}
+	else if ( team == game["defenders"] )
+	{
+		maps\mp\gametypes\_gamescore::giveTeamScoreForObjective( team, 1 );	
+		level thread gtnw_endGame( game["attackers"], game["strings"][game["defenders"]+"_eliminated"] );
+	}
+}
+
+initGametypeAwards()
+{
+	return;
+}
+
+onTimeLimit()
+{
+	if ( game["teamScores"]["allies"] == game["teamScores"]["axis"] )
+	{
+		level thread overtimeThread();
+	}
+	else if( game["teamScores"]["axis"] > game["teamScores"]["allies"] )
+	{
+		thread maps\mp\gametypes\_gamelogic::endGame( "axis", game["strings"]["time_limit_reached"] );
+	}
+	else if( game["teamScores"]["axis"] < game["teamScores"]["allies"] )
+	{
+		thread maps\mp\gametypes\_gamelogic::endGame( "allies", game["strings"]["time_limit_reached"] );
+	}
+}
+
+overtimeThread( time )
+{
+	level endon( "game_ended" );
+
+	level.inOvertime = true;
+	level thread disableSpawning( 5 );
+	
+	level.endGameTime = 120;
+	
+	time = level.endGameTime;
+
+	foreach ( player in level.players )
+		player thread maps\mp\gametypes\_hud_message::SplashNotify( "gtnw_overtime" );
+	
+	maps\mp\gametypes\_gamelogic::pauseTimer();
+	level.timeLimitOverride = true;
+	setGameEndTime( int( getTime() + ( level.endGameTime * 1000 ) ) );
+	
+	maps\mp\gametypes\_hostmigration::waitLongDurationWithGameEndTimeUpdate( time );
+	
+	if ( game["teamScores"]["axis"] > game["teamScores"]["allies"] )
+	{
+		thread maps\mp\gametypes\_gamelogic::endGame( "axis", game["strings"]["time_limit_reached"] );
+	}
+	else if ( game["teamScores"]["axis"] < game["teamScores"]["allies"]  )
+	{
+		thread maps\mp\gametypes\_gamelogic::endGame( "allies", game["strings"]["time_limit_reached"] );
+	}
+	else
+	{
+		thread maps\mp\gametypes\_gamelogic::endGame( "tie", game["strings"]["time_limit_reached"] );
+	}
+
+}
+
+disableSpawning( waitTime )
+{
+	level endon( "game_ended" );
+	
+	wait ( 5 );
+	level.disableSpawning = true;
+}
+
+
+onBeginUse( player )
+{
+	player.useBar showElem();
+	player.useBarText showElem();
+	return;
+}
+
+onEndUse( team, player, success )
+{
+	player.useBar hideElem();
+	player.useBarText hideElem();	
+	return;
+}
+
+scoreCounter()
+{
+	level endon( "game_ended" );
+	self endon( "stop_counting" );
+	
+	for ( ;; )
+	{
+		
+		if ( !self.touchList["axis"].size && !self.touchlist["allies"].size )
+		{
+			setDvar( "ui_danger_team", "none" );
+			
+			self maps\mp\gametypes\_gameobjects::set2DIcon( "enemy", "waypoint_captureneutral" );
+			self maps\mp\gametypes\_gameobjects::set3DIcon( "enemy", "waypoint_captureneutral" );
+			
+			self maps\mp\gametypes\_gameobjects::setOwnerTeam( "none" );
+			self updateHudElems();
+			wait 1;
+			continue;	
+		}
+		
+		self maps\mp\gametypes\_gameobjects::set2DIcon( "friendly", "waypoint_defend");
+		self maps\mp\gametypes\_gameobjects::set3DIcon( "friendly", "waypoint_defend" );
+		self maps\mp\gametypes\_gameobjects::set2DIcon( "enemy", "waypoint_capture" );
+		self maps\mp\gametypes\_gameobjects::set3DIcon( "enemy", "waypoint_capture" );
+		
+		if ( self.touchList["axis"].size > self.touchList["allies"].size )
+		{
+			if ( maps\mp\gametypes\_gamescore::_getTeamScore( "axis" ) < 100 )
+				maps\mp\gametypes\_gamescore::giveTeamScoreForObjective( "axis", 1 );	
+			
+			self thread setUseBarScore( "axis" );
+			setDvar( "ui_danger_team", "allies" );
+			self maps\mp\gametypes\_gameobjects::setOwnerTeam( "axis" );
+			
+			if ( maps\mp\gametypes\_gamescore::_getTeamScore( "axis" ) >= 100 )
+			{
+				self maps\mp\gametypes\_gameobjects::allowUse( "none" );
+				activateNuke( "axis" );
+				self notify( "stop_counting" );
+			}
+		}
+		else if ( self.touchList["axis"].size < self.touchList["allies"].size )
+		{
+			if ( maps\mp\gametypes\_gamescore::_getTeamScore( "allies" ) < 100 )
+				maps\mp\gametypes\_gamescore::giveTeamScoreForObjective( "allies", 1 );
+			
+			self thread setUseBarScore( "allies" );
+			setDvar( "ui_danger_team", "axis" );
+			self maps\mp\gametypes\_gameobjects::setOwnerTeam( "allies" );
+			
+			if ( maps\mp\gametypes\_gamescore::_getTeamScore( "allies" ) >= 100 )
+			{
+				self maps\mp\gametypes\_gameobjects::allowUse( "none" );
+				activateNuke( "allies" );
+				self notify( "stop_counting" );
+			}
+		}
+		else
+		{
+			self maps\mp\gametypes\_gameobjects::set2DIcon( "enemy", "waypoint_captureneutral" );
+			self maps\mp\gametypes\_gameobjects::set3DIcon( "enemy", "waypoint_captureneutral" );
+			
+			self maps\mp\gametypes\_gameobjects::setOwnerTeam( "none" );
+			setDvar( "ui_danger_team", "contested" );
+		}
+		updateHudElems();
+		
+		wait( 1 );
+	}
+}
+
+
+activateNuke( team )
+{
+	self giveFlagCaptureXP( self.touchList[team] );
+	self maps\mp\gametypes\_gameobjects::setVisibleTeam( "none" );
+	self maps\mp\gametypes\_gameobjects::allowUse( "none" );
+	
+	
+	bestTime = 99999999;
+	nukeOwner = undefined;
+	
+	foreach( player in level.players )
+	{
+		if ( !isDefined( player ) )
+			continue;
+			
+		player.useBar hideElem();
+		player.useBarText hideElem();	
+		
+		if ( player.team != team )
+			continue;
+		
+		if ( !isDefined( self.touchlist[team][player.guid] ) )
+			continue;
+		
+		timeStarted = self.touchlist[team][player.guid].startTime;
+		
+		if ( timeStarted < bestTime )
+		{
+			nukeOwner = player;
+			bestTime = timeStarted;
+		}
+	}
+	assert( isDefined( nukeOwner ) );
+	
+	nukeOwner maps\mp\killstreaks\_nuke::tryUseNuke( 1 );	
+}
+
+
+giveFlagCaptureXP( touchList )
+{
+	level endon ( "game_ended" );
+	wait .05;
+	WaitTillSlowProcessAllowed();
+	
+	players = getArrayKeys( touchList );
+	for ( index = 0; index < players.size; index++ )
+	{
+		player = touchList[players[index]].player;
+		player thread maps\mp\gametypes\_hud_message::SplashNotify( "captured_nuke", maps\mp\gametypes\_rank::getScoreInfoValue( "capture" ) );
+		player thread [[level.onXPEvent]]( "capture" );
+		maps\mp\gametypes\_gamescore::givePlayerScore( "capture", player );
+	}
+}
+
+setUseBarScore( team )
+{
+	teamScore = getTeamScore( team );
+
+	foreach( player in level.players )
+	{
+		if ( !isDefined( player ) )
+			continue;
+		
+		if ( player.team != team )
+			continue;
+		
+		if ( !isDefined( self.touchlist[team][player.guid] ) )
+			continue;
+		
+		//player thread maps\mp\gametypes\_rank::giveRankXP( "challenge",50 );
+		
+		player.useBar updateBar( teamScore/100, 0 );
+	}
+}
+
+updateHudElems()
+{
+	foreach( player in level.players )
+	{
+		if ( !isDefined( player ) )
+			continue;
+		
+		if ( !isDefined( self.touchlist["axis"][player.guid] ) && !isDefined( self.touchlist["allies"][player.guid] ) )
+		{
+			player.useBar hideElem();
+			player.useBarText hideElem();	
+		}	
+		
+		if ( isDefined( self.touchlist["axis"][player.guid] ) || isDefined( self.touchlist["allies"][player.guid] ) )
+		{
+			player.useBar showElem();
+			player.useBarText showElem();
+		}
+	}
+}
+
+
+onNormalDeath( victim, attacker, lifeId )
+{
+	if ( !isDefined( level.inOvertime ) || !level.inOvertime )
+		return;
+		
+	team = victim.team;
+	
+	if ( game["state"] == "postgame" )
+		attacker.finalKill = true;
+}

iw4x/iw4x_00/maps/mp/gametypes/oneflag.gsc

@@ -0,0 +1,577 @@
+#include common_scripts\utility;
+#include maps\mp\_utility;
+#include maps\mp\gametypes\_hud_util;
+/*
+	One Flag CTF
+*/
+
+/*QUAKED mp_ctf_spawn_axis (0.75 0.0 0.5) (-16 -16 0) (16 16 72)
+Axis players spawn away from enemies and near their team at one of these positions.*/
+
+/*QUAKED mp_ctf_spawn_allies (0.0 0.75 0.5) (-16 -16 0) (16 16 72)
+Allied players spawn away from enemies and near their team at one of these positions.*/
+
+/*QUAKED mp_ctf_spawn_axis_start (1.0 0.0 0.5) (-16 -16 0) (16 16 72)
+Axis players spawn away from enemies and near their team at one of these positions at the start of a round.*/
+
+/*QUAKED mp_ctf_spawn_allies_start (0.0 1.0 0.5) (-16 -16 0) (16 16 72)
+Allied players spawn away from enemies and near their team at one of these positions at the start of a round.*/
+
+main()
+{
+	maps\mp\gametypes\_globallogic::init();
+	maps\mp\gametypes\_callbacksetup::SetupCallbacks();
+	maps\mp\gametypes\_globallogic::SetupCallbacks();
+
+	registerTimeLimitDvar( level.gameType, 3, 0, 1440 );
+	registerScoreLimitDvar( level.gameType, 1, 0, 10000 );
+	registerRoundLimitDvar( level.gameType, 0, 0, 30 );
+	registerWinLimitDvar( level.gameType, 4, 0, 10 );
+	registerRoundSwitchDvar( level.gameType, 3, 0, 30 );
+	registerNumLivesDvar( level.gameType, 0, 0, 10 );
+	registerHalfTimeDvar( level.gameType, 0, 0, 1 );
+	
+	level.objectiveBased = true;
+	level.teamBased = true;
+	level.onPrecacheGameType = ::onPrecacheGameType;
+	level.onStartGameType = ::onStartGameType;
+	level.getSpawnPoint = ::getSpawnPoint;
+	level.onSpawnPlayer = ::onSpawnPlayer;
+	level.onPlayerKilled = ::onPlayerKilled;
+	level.onTimeLimit = ::onTimeLimit;
+	level.initGametypeAwards = ::initGametypeAwards;
+
+	game["dialog"]["gametype"] = "captureflag";
+
+	if ( getDvarInt( "g_hardcore" ) )
+		game["dialog"]["gametype"] = "hc_" + game["dialog"]["gametype"];
+	else if ( getDvarInt( "camera_thirdPerson" ) )
+		game["dialog"]["gametype"] = "thirdp_" + game["dialog"]["gametype"];
+	else if ( getDvarInt( "scr_diehard" ) )
+		game["dialog"]["gametype"] = "dh_" + game["dialog"]["gametype"];
+	else if (getDvarInt( "scr_" + level.gameType + "_promode" ) )
+		game["dialog"]["gametype"] = game["dialog"]["gametype"] + "_pro";
+		
+	game["dialog"]["offense_obj"] = "capture_obj";
+	game["dialog"]["defense_obj"] = "capture_obj";
+
+	if ( getdvar("scr_oneflag_returntime") == "" )
+		setdvar("scr_oneflag_returntime", "15");
+	level.flagReturnTime = getdvarint( "scr_oneflag_returntime" );
+}
+
+onPrecacheGameType()
+{
+	precacheString(&"MP_FLAG_TAKEN_BY");
+	precacheString(&"MP_ENEMY_FLAG_TAKEN_BY");
+	precacheString(&"MP_FLAG_CAPTURED_BY");
+	precacheString(&"MP_ENEMY_FLAG_CAPTURED_BY");
+	//precacheString(&"MP_FLAG_RETURNED_BY");
+	precacheString(&"MP_FLAG_RETURNED");
+	precacheString(&"MP_ENEMY_FLAG_RETURNED");
+	precacheString(&"MP_YOUR_FLAG_RETURNING_IN");
+	precacheString(&"MP_ENEMY_FLAG_RETURNING_IN");
+	precacheString(&"MP_ENEMY_FLAG_DROPPED_BY");
+	precacheString( &"MP_DOM_NEUTRAL_FLAG_CAPTURED" );
+}
+
+
+onStartGameType()
+{
+	if ( !isdefined( game["switchedsides"] ) )
+		game["switchedsides"] = false;
+
+	if ( !isdefined( game["original_defenders"] ) )
+		game["original_defenders"] = game["defenders"];
+
+	if ( game["switchedsides"] )
+	{
+		oldAttackers = game["attackers"];
+		oldDefenders = game["defenders"];
+		game["attackers"] = oldDefenders;
+		game["defenders"] = oldAttackers;
+	}
+	
+	
+	setClientNameMode("auto_change");
+	
+	setObjectiveText( game["attackers"], &"OBJECTIVES_CTF" );
+	setObjectiveText( game["defenders"], &"OBJECTIVES_CTF" );
+
+	if ( level.splitscreen )
+	{
+		setObjectiveScoreText( game["attackers"], &"OBJECTIVES_ONE_FLAG_ATTACKER" );
+		setObjectiveScoreText( game["defenders"], &"OBJECTIVES_ONE_FLAG_DEFENDER" );
+	}
+	else
+	{
+		setObjectiveScoreText( game["attackers"], &"OBJECTIVES_ONE_FLAG_ATTACKER_SCORE" );
+		setObjectiveScoreText( game["defenders"], &"OBJECTIVES_ONE_FLAG_DEFENDER_SCORE" );
+	}
+	setObjectiveHintText( game["attackers"], &"OBJECTIVES_ONE_FLAG_ATTACKER_HINT" );
+	setObjectiveHintText( game["defenders"], &"OBJECTIVES_ONE_FLAG_DEFENDER_HINT" );
+	
+
+	level.spawnMins = ( 0, 0, 0 );
+	level.spawnMaxs = ( 0, 0, 0 );
+	maps\mp\gametypes\_spawnlogic::placeSpawnPoints( "mp_ctf_spawn_allies_start" );
+	maps\mp\gametypes\_spawnlogic::placeSpawnPoints( "mp_ctf_spawn_axis_start" );
+	maps\mp\gametypes\_spawnlogic::addSpawnPoints( "allies", "mp_ctf_spawn_allies" );
+	maps\mp\gametypes\_spawnlogic::addSpawnPoints( "axis", "mp_ctf_spawn_axis" );
+	
+	level.mapCenter = maps\mp\gametypes\_spawnlogic::findBoxCenter( level.spawnMins, level.spawnMaxs );
+	setMapCenter( level.mapCenter );
+	
+	thread maps\mp\gametypes\_dev::init();
+	
+	allowed[0] = "ctf";
+	maps\mp\gametypes\_gameobjects::main(allowed);
+	
+	maps\mp\gametypes\_rank::registerScoreInfo( "kill", 100 );
+	maps\mp\gametypes\_rank::registerScoreInfo( "headshot", 100 );
+	maps\mp\gametypes\_rank::registerScoreInfo( "assist", 20 );
+	
+	maps\mp\gametypes\_rank::registerScoreInfo( "pickup", 100 );
+	maps\mp\gametypes\_rank::registerScoreInfo( "return", 50 );
+	maps\mp\gametypes\_rank::registerScoreInfo( "capture", 500 );
+	
+	maps\mp\gametypes\_rank::registerScoreInfo( "kill_carrier", 100 );
+	
+	maps\mp\gametypes\_rank::registerScoreInfo( "defend", 100 );
+	maps\mp\gametypes\_rank::registerScoreInfo( "defend_assist", 100 );
+	
+	maps\mp\gametypes\_rank::registerScoreInfo( "assault", 200 );
+	maps\mp\gametypes\_rank::registerScoreInfo( "assault_assist", 40 );
+	
+	thread oneflag_ctf();
+}
+
+
+getSpawnPoint()
+{
+	spawnteam = self.pers["team"];
+	if ( game["switchedsides"] )
+		spawnteam = getOtherTeam( spawnteam );
+	
+	if ( level.inGracePeriod )
+	{
+		if ( getDvar( "mapname" ) == "mp_shipment_long" )
+		{
+			spawnPoints = getentarray("mp_cha_spawn_" + spawnteam + "_start", "classname");		
+			spawnPoint = maps\mp\gametypes\_spawnlogic::getSpawnpoint_Random( spawnPoints );
+		}
+		else
+		{
+			spawnPoints = getentarray("mp_ctf_spawn_" + spawnteam + "_start", "classname");		
+			spawnPoint = maps\mp\gametypes\_spawnlogic::getSpawnpoint_Random( spawnPoints );
+		}
+	}
+	else
+	{
+		if ( getDvar( "mapname" ) == "mp_shipment_long" )
+		{
+			spawnPoints = maps\mp\gametypes\_spawnlogic::getSpawnpointArray( "mp_cha_spawn_" + spawnteam );
+			spawnPoint = maps\mp\gametypes\_spawnlogic::getSpawnpoint_Random( spawnPoints );
+		}
+		else
+		{
+			spawnPoints = maps\mp\gametypes\_spawnlogic::getTeamSpawnPoints( spawnteam );
+			spawnPoint = maps\mp\gametypes\_spawnlogic::getSpawnpoint_NearTeam( spawnPoints );
+		}
+	}
+	
+	return spawnPoint;
+}
+
+
+onSpawnPlayer()
+{
+	self.usingObj = undefined;
+}
+
+
+oneflag_ctf()
+{
+
+	level.flagModel["allies"] = maps\mp\gametypes\_teams::getTeamFlagModel( "allies" );
+	level.icon2D["allies"] = maps\mp\gametypes\_teams::getTeamFlagIcon( "allies" );
+	level.carryFlag["allies"] = maps\mp\gametypes\_teams::getTeamFlagCarryModel( "allies" );
+
+	precacheModel( level.flagModel["allies"] );
+	precacheModel( level.carryFlag["allies"] );
+
+	level.flagModel["axis"] = maps\mp\gametypes\_teams::getTeamFlagModel( "axis" );
+	level.icon2D["axis"] = maps\mp\gametypes\_teams::getTeamFlagIcon( "axis" );
+	level.carryFlag["axis"] = maps\mp\gametypes\_teams::getTeamFlagCarryModel( "axis" );
+
+	precacheModel( level.flagModel["axis"] );
+	precacheModel( level.carryFlag["axis"] );
+	
+	level.iconCapture3D = "waypoint_capture_flag";
+	level.iconTarget3D = "waypoint_captureneutral";
+	level.iconDefend3D = "waypoint_defend_flag";
+	level.iconCapture2D = "waypoint_capture_flag";
+	level.iconTarget2D = "waypoint_captureneutral";
+	level.iconDefend2D = "waypoint_defend_flag";
+	
+	precacheShader( level.icon2D["axis"] );
+	precacheShader( level.icon2D["allies"] );
+
+	precacheShader( level.iconCapture3D );
+	precacheShader( level.iconDefend3D );
+
+	precacheShader( level.iconCapture2D );
+	precacheShader( level.iconDefend2D );
+
+	precacheShader( level.iconTarget3D );
+	precacheShader( level.iconTarget2D );
+
+	precacheShader( "waypoint_kill" );
+	
+	level.teamFlags[game["defenders"]] = createTeamFlag( game["defenders"] );
+	level.capZones[game["attackers"]] = createCapZone( game["attackers"] );
+	level.flagCaptured = false;
+}
+
+
+spawnFxDelay( fxid, pos, forward, right, delay )
+{
+	wait delay;
+	effect = spawnFx( fxid, pos, forward, right );
+	triggerFx( effect );
+}
+
+createTeamFlag( team )
+{
+	entityTeam = game["original_defenders"];
+
+	trigger = getEnt( "ctf_trig_" + entityTeam, "targetname" );
+	if ( !isDefined( trigger ) ) 
+	{
+		error( "No ctf_trig_" + entityTeam + " trigger found in map." );
+		return;
+	}
+	visuals[0] = getEnt( "ctf_flag_" + entityTeam, "targetname" );
+	if ( !isDefined( visuals[0] ) ) 
+	{
+		error( "No ctf_flag_" + entityTeam + " script_model found in map." );
+		return;
+	}
+	
+	cloneTrigger = spawn( "trigger_radius", trigger.origin, 0, 96, trigger.height );
+	trigger delete();
+	trigger = cloneTrigger;
+	
+	visuals[0] setModel( level.flagModel[team] );
+	
+	teamFlag = maps\mp\gametypes\_gameobjects::createCarryObject( team, trigger, visuals, (0,0,85) );
+	teamFlag maps\mp\gametypes\_gameobjects::setTeamUseTime( "friendly", 15.0 );
+	teamFlag maps\mp\gametypes\_gameobjects::setTeamUseTime( "enemy", 0 );
+	teamFlag maps\mp\gametypes\_gameobjects::setTeamUseText( "enemy", &"MP_CAPTURING_FLAG" );
+	teamFlag maps\mp\gametypes\_gameobjects::setTeamUseText( "friendly", &"MP_RETURNING_FLAG" );
+
+	teamFlag maps\mp\gametypes\_gameobjects::allowCarry( "enemy" );
+	teamFlag maps\mp\gametypes\_gameobjects::setVisibleTeam( "any" );
+	teamFlag maps\mp\gametypes\_gameobjects::set2DIcon( "friendly", level.iconDefend2D );
+	teamFlag maps\mp\gametypes\_gameobjects::set3DIcon( "friendly", level.iconDefend3D );
+	teamFlag maps\mp\gametypes\_gameobjects::set2DIcon( "enemy", level.iconCapture2D );
+	teamFlag maps\mp\gametypes\_gameobjects::set3DIcon( "enemy", level.iconCapture3D );
+	teamFlag maps\mp\gametypes\_gameobjects::setCarryIcon( level.icon2D[team] );
+	teamFlag.allowWeapons = true;
+	teamFlag.onPickup = ::onPickup;
+	teamFlag.onPickupFailed = ::onPickup;
+	teamFlag.onDrop = ::onDrop;
+	teamFlag.onReset = ::onReset;
+	//teamFlag.onBeginUse = ::onBeginUse;	
+	//teamFlag.onEndUse = ::onEndUse;
+	
+	teamFlag.oldRadius = trigger.radius;
+
+	traceStart = trigger.origin + (0,0,32);
+	traceEnd = trigger.origin + (0,0,-32);
+	trace = bulletTrace( traceStart, traceEnd, false, undefined );
+	
+	fx = maps\mp\gametypes\_teams::getTeamFlagFX( team );
+	fxid = loadfx( fx );
+	
+	upangles = vectorToAngles( trace["normal"] );
+	forward = anglesToForward( upangles );
+	right = anglesToRight( upangles );
+	
+	thread spawnFxDelay( fxid, trace["position"], forward, right, 0.5 );
+	
+	return teamFlag;
+}
+
+createCapZone( team )
+{
+	entityTeam = level.otherTeam[game["original_defenders"]];
+
+	trigger = getEnt( "ctf_zone_" + entityTeam, "targetname" );
+	if ( !isDefined( trigger ) ) 
+	{
+		error("No ctf_zone_" + entityTeam + " trigger found in map.");
+		return;
+	}
+
+	visuals[0] = getEnt( "ctf_flag_" + entityTeam, "targetname" );
+	if ( !isDefined( visuals[0] ) ) 
+	{
+		error( "No ctf_flag_" + entityTeam + " script_model found in map." );
+		return;
+	}
+
+	visuals[0] hide();
+	
+	visuals = [];
+	capZone = maps\mp\gametypes\_gameobjects::createUseObject( team, trigger, visuals, (0,0,85) );
+	capZone maps\mp\gametypes\_gameobjects::allowUse( "friendly" );
+	capZone maps\mp\gametypes\_gameobjects::setVisibleTeam( "none" );
+	capZone maps\mp\gametypes\_gameobjects::set2DIcon( "friendly", level.iconTarget2D );
+	capZone maps\mp\gametypes\_gameobjects::set3DIcon( "friendly", level.iconTarget3D );
+
+	capZone maps\mp\gametypes\_gameobjects::setUseTime( 0 );
+	capZone maps\mp\gametypes\_gameobjects::setKeyObject( level.teamFlags[ getOtherTeam( team ) ] );
+	
+	capZone.onUse = ::onUse;
+	capZone.onCantUse = ::onCantUse;
+		
+	traceStart = trigger.origin + (0,0,32);
+	traceEnd = trigger.origin + (0,0,-32);
+	trace = bulletTrace( traceStart, traceEnd, false, undefined );
+	
+	fx = maps\mp\gametypes\_teams::getTeamFlagFX( team );
+	fxid = loadfx( fx );
+	
+	upangles = vectorToAngles( trace["normal"] );
+	forward = anglesToForward( upangles );
+	right = anglesToRight( upangles );
+	
+	thread spawnFxDelay( fxid, trace["position"], forward, right, 0.5 );
+	
+	return capZone;
+}
+
+
+onBeginUse( player )
+{
+	team = player.pers["team"];
+
+	if ( team == self maps\mp\gametypes\_gameobjects::getOwnerTeam() )
+		self.trigger.radius = 1024;
+	else
+		self.trigger.radius = self.oldRadius;
+}
+
+
+onEndUse( player, team, success )
+{
+	self.trigger.radius = self.oldRadius;
+}
+
+
+onPickup( player )
+{
+	team = player.pers["team"];
+
+	if ( team == "allies" )
+		otherTeam = "axis";
+	else
+		otherTeam = "allies";
+
+
+	if ( team == self maps\mp\gametypes\_gameobjects::getOwnerTeam() )
+	{
+		player thread maps\mp\gametypes\_hud_message::SplashNotify( "flagreturn", maps\mp\gametypes\_rank::getScoreInfoValue( "pickup" ) );
+		player thread [[level.onXPEvent]]( "pickup" );
+		self thread returnFlag();
+		player incPlayerStat( "flagsreturned", 1 );
+		player thread maps\mp\_matchdata::logGameEvent( "return", player.origin );
+	}
+	else
+	{
+		player attachFlag();
+
+		level.capZones[team] maps\mp\gametypes\_gameobjects::setVisibleTeam( "any" );
+
+		//self maps\mp\gametypes\_gameobjects::setVisibleTeam( "enemy" );
+		self maps\mp\gametypes\_gameobjects::set3DIcon( "enemy", "waypoint_defend" );
+		self maps\mp\gametypes\_gameobjects::set3DIcon( "friendly", "waypoint_kill" );
+		self maps\mp\gametypes\_gameobjects::set2DIcon( "friendly", level.iconTarget2D );
+
+		printAndSoundOnEveryone( team, otherteam, &"MP_ENEMY_FLAG_TAKEN_BY", &"MP_FLAG_TAKEN_BY", "mp_obj_taken", "mp_enemy_obj_taken", player );
+
+		leaderDialog( "enemy_flag_taken", team, "status" );
+		leaderDialog( "flag_taken", otherteam, "status" );
+
+		player thread maps\mp\gametypes\_hud_message::SplashNotify( "flagpickup", maps\mp\gametypes\_rank::getScoreInfoValue( "pickup" ) );
+		maps\mp\gametypes\_gamescore::givePlayerScore( "pickup", player );
+		player thread [[level.onXPEvent]]( "pickup" );
+		player incPlayerStat( "flagscarried", 1 );
+		player thread maps\mp\_matchdata::logGameEvent( "pickup", player.origin );
+	}
+}
+
+
+returnFlag()
+{
+	team = self maps\mp\gametypes\_gameobjects::getOwnerTeam();
+	otherTeam = level.otherTeam[team];
+	
+	self maps\mp\gametypes\_gameobjects::returnHome();
+	self maps\mp\gametypes\_gameobjects::setVisibleTeam( "any" );
+	self maps\mp\gametypes\_gameobjects::allowCarry( "enemy" );
+
+	level.capZones[otherTeam] maps\mp\gametypes\_gameobjects::setVisibleTeam( "none" );
+	
+	printAndSoundOnEveryone( team, getOtherTeam( team ), &"MP_FLAG_RETURNED", &"MP_ENEMY_FLAG_RETURNED", "mp_obj_returned", "mp_obj_returned", "" );
+	leaderDialog( "enemy_flag_returned", otherteam, "status" );
+	leaderDialog( "flag_returned", team, "status" );	
+}
+
+
+onDrop( player )
+{
+	team = self maps\mp\gametypes\_gameobjects::getOwnerTeam();
+	otherTeam = level.otherTeam[team];
+	
+	self maps\mp\gametypes\_gameobjects::set3DIcon( "friendly", level.iconDefend3D );
+	self maps\mp\gametypes\_gameobjects::set2DIcon( "friendly", level.iconDefend2D );
+	self maps\mp\gametypes\_gameobjects::set3DIcon( "enemy",    level.iconCapture3D );
+	self maps\mp\gametypes\_gameobjects::setVisibleTeam( "any" );
+	self maps\mp\gametypes\_gameobjects::allowCarry( "any" );
+
+	level.capZones[otherTeam] maps\mp\gametypes\_gameobjects::setVisibleTeam( "none" );
+	
+	if ( isDefined( player ) )
+	{
+ 		if ( isDefined( player.carryFlag ) )
+			player detachFlag();
+		
+		printAndSoundOnEveryone( otherTeam, "none", &"MP_ENEMY_FLAG_DROPPED_BY", "", "mp_war_objective_lost", "", player );		
+	}
+	else
+	{
+		playSoundOnPlayers( "mp_war_objective_lost", otherTeam );
+	}
+
+	leaderDialog( "enemy_flag_dropped", otherTeam, "status" );
+	leaderDialog( "flag_dropped", team, "status" );	
+}
+
+
+onReset()
+{
+	self notify ( "flag_reset" );
+
+	team = self maps\mp\gametypes\_gameobjects::getOwnerTeam();
+	otherTeam = level.otherTeam[team];
+	
+	self maps\mp\gametypes\_gameobjects::setVisibleTeam( "any" );
+	self maps\mp\gametypes\_gameobjects::set3DIcon( "friendly", level.iconDefend3D );
+	self maps\mp\gametypes\_gameobjects::set2DIcon( "friendly", level.iconDefend2D );
+	self maps\mp\gametypes\_gameobjects::set3DIcon( "enemy",    level.iconCapture3D );
+
+	level.capZones[otherTeam] maps\mp\gametypes\_gameobjects::setVisibleTeam( "none" );
+}
+
+
+onUse( player )
+{
+	team = player.pers["team"];
+	if ( team == "allies" )
+		otherTeam = "axis";
+	else
+		otherTeam = "allies";
+
+	leaderDialog( "enemy_flag_captured", team, "status" );
+	leaderDialog( "flag_captured", otherteam, "status" );	
+
+	maps\mp\gametypes\_gamescore::givePlayerScore( "capture", player );
+	player thread [[level.onXPEvent]]( "capture" );
+	player incPlayerStat( "flagscaptured", 1 );
+	player notify( "objective", "captured" );
+	player thread maps\mp\_matchdata::logGameEvent( "capture", player.origin );
+
+	// round win here, no reset necessary
+
+	printAndSoundOnEveryone( team, otherteam, &"MP_ENEMY_FLAG_CAPTURED_BY", &"MP_FLAG_CAPTURED_BY", "mp_obj_captured", "mp_enemy_obj_captured", player );
+
+	thread flagCaptured( team, &"MP_DOM_NEUTRAL_FLAG_CAPTURED" );
+
+	level.teamFlags[otherTeam] maps\mp\gametypes\_gameobjects::allowCarry( "none" );
+	level.teamFlags[otherTeam] maps\mp\gametypes\_gameobjects::setVisibleTeam( "none" );
+	level.teamFlags[otherTeam] maps\mp\gametypes\_gameobjects::disableObject();
+	level.capZones[team] maps\mp\gametypes\_gameobjects::allowUse( "none" );
+
+	if ( isDefined( player.carryFlag ) )
+		player detachFlag();
+}
+
+
+flagCaptured( winningTeam, endReasonText )
+{
+	maps\mp\gametypes\_gamelogic::endGame( winningTeam, endReasonText );
+	level.flagCaptured = true;
+}
+
+
+onTimeLimit()
+{
+	if ( level.flagCaptured )
+		return; 
+
+	// TODO: change to "Flag Defended" or some such
+	maps\mp\gametypes\_gamelogic::endGame( game["defenders"], game["strings"]["time_limit_reached"] );
+}
+
+
+onCantUse( player )
+{
+//	player iPrintLnBold( &"MP_CANT_PLANT_WITHOUT_BOMB" );
+}
+
+
+onPlayerKilled( eInflictor, attacker, iDamage, sMeansOfDeath, sWeapon, vDir, sHitLoc, psOffsetTime, deathAnimDuration, killId )
+{
+	if ( isDefined( attacker ) && isPlayer( attacker ) && attacker.pers["team"] != self.pers["team"] )
+	{
+		if ( isDefined( attacker.carryFlag ) )
+			attacker incPlayerStat( "killsasflagcarrier", 1 );
+
+		if ( isDefined( self.carryFlag ) )
+		{
+			attacker thread [[level.onXPEvent]]( "kill_carrier" );
+			maps\mp\gametypes\_gamescore::givePlayerScore( "kill_carrier", attacker );
+			attacker incPlayerStat( "flagcarrierkills", 1 );
+			
+			thread maps\mp\_matchdata::logKillEvent( killId, "carrying" );
+			
+			self detachFlag();
+		}
+	}
+}
+
+
+attachFlag()
+{
+	otherTeam = level.otherTeam[self.pers["team"]];
+	
+	self attach( level.carryFlag[otherTeam], "J_spine4", true );
+	self.carryFlag = level.carryFlag[otherTeam];
+}
+
+detachFlag()
+{
+	self detach( self.carryFlag, "J_spine4" );
+	self.carryFlag = undefined;
+}
+
+initGametypeAwards()
+{
+	maps\mp\_awards::initStatAward( "flagscaptured",		0, maps\mp\_awards::highestWins );
+	maps\mp\_awards::initStatAward( "flagsreturned", 		0, maps\mp\_awards::highestWins );
+	maps\mp\_awards::initStatAward( "flagcarrierkills", 	0, maps\mp\_awards::highestWins );
+	maps\mp\_awards::initStatAward( "flagscarried",			0, maps\mp\_awards::highestWins );
+	maps\mp\_awards::initStatAward( "killsasflagcarrier", 	0, maps\mp\_awards::highestWins );
+}

iw4x/iw4x_00/maps/mp/gametypes/sab.gsc

@@ -0,0 +1,926 @@
+#include common_scripts\utility;
+#include maps\mp\_utility;
+#include maps\mp\gametypes\_hud_util;
+/*
+	Sabotage
+	
+	// ...etc...
+*/
+
+/*QUAKED mp_sab_spawn_axis (0.75 0.0 0.5) (-16 -16 0) (16 16 72)
+Axis players spawn away from enemies and near their team at one of these positions.*/
+
+/*QUAKED mp_sab_spawn_axis_planted (0.75 0.0 0.5) (-16 -16 0) (16 16 72)
+Axis players spawn away from enemies and near their team at one of these positions.*/
+
+/*QUAKED mp_sab_spawn_allies (0.0 0.75 0.5) (-16 -16 0) (16 16 72)
+Allied players spawn away from enemies and near their team at one of these positions.*/
+
+/*QUAKED mp_sab_spawn_allies_planted (0.0 0.75 0.5) (-16 -16 0) (16 16 72)
+Allied players spawn away from enemies and near their team at one of these positions.*/
+
+/*QUAKED mp_sab_spawn_axis_start (1.0 0.0 0.5) (-16 -16 0) (16 16 72)
+Axis players spawn away from enemies and near their team at one of these positions at the start of a round.*/
+
+/*QUAKED mp_sab_spawn_allies_start (0.0 1.0 0.5) (-16 -16 0) (16 16 72)
+Allied players spawn away from enemies and near their team at one of these positions at the start of a round.*/
+
+main()
+{
+	if ( getdvar("mapname") == "mp_background" )
+		return;
+	
+	maps\mp\gametypes\_globallogic::init();
+	maps\mp\gametypes\_callbacksetup::SetupCallbacks();
+	maps\mp\gametypes\_globallogic::SetupCallbacks();
+	
+	//level.objectiveBased = true;
+	level.teamBased = true;
+
+	registerRoundSwitchDvar( level.gameType, 0, 0, 9 );
+	registerTimeLimitDvar( level.gameType, 10, 0, 1440 );
+	registerScoreLimitDvar( level.gameType, 0, 0, 500 );
+	registerRoundLimitDvar( level.gameType, 1, 0, 10 );
+	registerWinLimitDvar( level.gameType, 1, 0, 10 );
+	registerNumLivesDvar( level.gameType, 0, 0, 10 );
+	registerHalfTimeDvar( level.gameType, 0, 0, 1 );
+
+	setOverTimeLimitDvar( 2 );
+
+	level.onPrecacheGameType = ::onPrecacheGameType;
+	level.onStartGameType = ::onStartGameType;
+	level.getSpawnPoint = ::getSpawnPoint;
+	level.onSpawnPlayer = ::onSpawnPlayer;
+	level.onOneLeftEvent = ::onOneLeftEvent;
+	level.onTimeLimit = ::onTimeLimit;
+	level.onNormalDeath = ::onNormalDeath;
+	level.initGametypeAwards = ::initGametypeAwards;
+	
+	game["dialog"]["gametype"] = "sabotage";
+
+	if ( getDvarInt( "g_hardcore" ) )
+		game["dialog"]["gametype"] = "hc_" + game["dialog"]["gametype"];
+	else if ( getDvarInt( "camera_thirdPerson" ) )
+		game["dialog"]["gametype"] = "thirdp_" + game["dialog"]["gametype"];
+	else if ( getDvarInt( "scr_diehard" ) )
+		game["dialog"]["gametype"] = "dh_" + game["dialog"]["gametype"];
+	else if (getDvarInt( "scr_" + level.gameType + "_promode" ) )
+		game["dialog"]["gametype"] = game["dialog"]["gametype"] + "_pro";
+	
+	game["dialog"]["offense_obj"] = "capture_obj";
+	game["dialog"]["defense_obj"] = "capture_obj";
+
+	badtrig = getent( "sab_bomb_defuse_allies", "targetname" );
+	if ( isdefined( badtrig ) )
+		badtrig delete();
+
+	badtrig = getent( "sab_bomb_defuse_axis", "targetname" );
+	if ( isdefined( badtrig ) )
+		badtrig delete();
+}
+
+onPrecacheGameType()
+{
+	game["bomb_dropped_sound"] = "mp_war_objective_lost";
+	game["bomb_recovered_sound"] = "mp_war_objective_taken";
+	
+	precacheShader("waypoint_bomb");
+	precacheShader("waypoint_kill");
+	precacheShader("waypoint_bomb_enemy");
+	precacheShader("waypoint_defend");
+	precacheShader("waypoint_defuse");
+	precacheShader("waypoint_target");
+	precacheShader("waypoint_escort");
+	precacheShader("waypoint_bomb");
+	precacheShader("waypoint_defend");
+	precacheShader("waypoint_defuse");
+	precacheShader("waypoint_target");
+	precacheShader("hud_suitcase_bomb");
+	
+	precacheString(&"MP_EXPLOSIVES_RECOVERED_BY");
+	precacheString(&"MP_EXPLOSIVES_DROPPED_BY");
+	precacheString(&"MP_EXPLOSIVES_PLANTED_BY");
+	precacheString(&"MP_EXPLOSIVES_DEFUSED_BY");
+	precacheString(&"MP_YOU_HAVE_RECOVERED_THE_BOMB");
+	precacheString(&"PLATFORM_HOLD_TO_PLANT_EXPLOSIVES");
+	precacheString(&"PLATFORM_HOLD_TO_DEFUSE_EXPLOSIVES");
+	precacheString(&"MP_PLANTING_EXPLOSIVE");
+	precacheString(&"MP_DEFUSING_EXPLOSIVE");
+	precacheString(&"MP_TARGET_DESTROYED");
+	precacheString(&"MP_NO_RESPAWN");
+	precacheString(&"MP_TIE_BREAKER");	
+	precacheString(&"MP_NO_RESPAWN");
+	precacheString(&"MP_SUDDEN_DEATH");
+}
+
+
+onStartGameType()
+{
+	if ( !isdefined( game["switchedsides"] ) )
+		game["switchedsides"] = false;
+
+	setClientNameMode("auto_change");
+	
+	game["strings"]["target_destroyed"] = &"MP_TARGET_DESTROYED";
+	game["strings"]["target_defended"] = &"MP_TARGET_DEDEFEND";
+
+	setObjectiveText( "allies", &"OBJECTIVES_SAB" );
+	setObjectiveText( "axis", &"OBJECTIVES_SAB" );
+
+	if ( level.splitscreen )
+	{
+		setObjectiveScoreText( "allies", &"OBJECTIVES_SAB" );
+		setObjectiveScoreText( "axis", &"OBJECTIVES_SAB" );
+	}
+	else
+	{
+		setObjectiveScoreText( "allies", &"OBJECTIVES_SAB_SCORE" );
+		setObjectiveScoreText( "axis", &"OBJECTIVES_SAB_SCORE" );
+	}
+	setObjectiveHintText( "allies", &"OBJECTIVES_SAB_HINT" );
+	setObjectiveHintText( "axis", &"OBJECTIVES_SAB_HINT" );
+	
+	level.spawnMins = ( 0, 0, 0 );
+	level.spawnMaxs = ( 0, 0, 0 );	
+	maps\mp\gametypes\_spawnlogic::placeSpawnPoints( "mp_sab_spawn_allies_start" );
+	maps\mp\gametypes\_spawnlogic::placeSpawnPoints( "mp_sab_spawn_axis_start" );
+	maps\mp\gametypes\_spawnlogic::addSpawnPoints( "allies", "mp_sab_spawn_allies" );
+	maps\mp\gametypes\_spawnlogic::addSpawnPoints( "axis", "mp_sab_spawn_axis" );
+	maps\mp\gametypes\_spawnlogic::addSpawnPoints("allies", "mp_sab_spawn_allies_planted", true );
+	maps\mp\gametypes\_spawnlogic::addSpawnPoints("axis", "mp_sab_spawn_axis_planted", true );
+	
+	level.mapCenter = maps\mp\gametypes\_spawnlogic::findBoxCenter( level.spawnMins, level.spawnMaxs );
+	setMapCenter( level.mapCenter );
+
+	if ( getDvar( "mapname" ) == "mp_shipment_long" )
+	{
+		level.spawn_axis = maps\mp\gametypes\_spawnlogic::getSpawnpointArray( "mp_cha_spawn_axis" );
+		level.spawn_axis_planted = maps\mp\gametypes\_spawnlogic::getSpawnpointArray( "mp_cha_spawn_axis_start" );
+		level.spawn_axis_planted = array_combine( level.spawn_axis_planted, level.spawn_axis );
+		
+		level.spawn_allies = maps\mp\gametypes\_spawnlogic::getSpawnpointArray( "mp_cha_spawn_allies" );
+		level.spawn_allies_planted = maps\mp\gametypes\_spawnlogic::getSpawnpointArray( "mp_cha_spawn_allies_start" );
+		level.spawn_allies_planted = array_combine( level.spawn_allies_planted, level.spawn_allies );
+
+		level.spawn_axis_start = maps\mp\gametypes\_spawnlogic::getSpawnpointArray( "mp_cha_spawn_axis_start" );
+		level.spawn_allies_start = maps\mp\gametypes\_spawnlogic::getSpawnpointArray( "mp_cha_spawn_allies_start" );
+	}
+	else
+	{
+		level.spawn_axis = maps\mp\gametypes\_spawnlogic::getSpawnpointArray( "mp_sab_spawn_axis" );
+		level.spawn_axis_planted = maps\mp\gametypes\_spawnlogic::getSpawnpointArray( "mp_sab_spawn_axis_planted" );
+		level.spawn_axis_planted = array_combine( level.spawn_axis_planted, level.spawn_axis );
+		
+		level.spawn_allies = maps\mp\gametypes\_spawnlogic::getSpawnpointArray( "mp_sab_spawn_allies" );
+		level.spawn_allies_planted = maps\mp\gametypes\_spawnlogic::getSpawnpointArray( "mp_sab_spawn_allies_planted" );
+		level.spawn_allies_planted = array_combine( level.spawn_allies_planted, level.spawn_allies );
+		
+		level.spawn_axis_start = maps\mp\gametypes\_spawnlogic::getSpawnpointArray( "mp_sab_spawn_axis_start" );
+		level.spawn_allies_start = maps\mp\gametypes\_spawnlogic::getSpawnpointArray( "mp_sab_spawn_allies_start" );
+	}
+
+	maps\mp\gametypes\_rank::registerScoreInfo( "plant", 200 );
+	maps\mp\gametypes\_rank::registerScoreInfo( "destroy", 1000 );
+	maps\mp\gametypes\_rank::registerScoreInfo( "defuse", 150 );
+
+	allowed[0] = "sab";
+	maps\mp\gametypes\_gameobjects::main(allowed);
+		
+	thread updateGametypeDvars();
+	
+	thread sabotage();
+}
+
+
+getSpawnPoint()
+{
+	spawnteam = self.pers["team"];
+	if ( game["switchedsides"] )
+		spawnteam = getOtherTeam( spawnteam );
+
+	if ( level.useStartSpawns )
+	{
+		if (spawnteam == "axis")
+			spawnpoint = maps\mp\gametypes\_spawnlogic::getSpawnpoint_Random(level.spawn_axis_start);
+		else
+			spawnpoint = maps\mp\gametypes\_spawnlogic::getSpawnpoint_Random(level.spawn_allies_start);
+	}	
+	else
+	{
+		if ( isDefined( level.bombplanted ) && level.bombplanted && ( isDefined( level.bombOwner ) && spawnTeam == level.bombOwner.team ) )
+		{
+			if (spawnteam == "axis")
+				spawnpoint = maps\mp\gametypes\_spawnlogic::getSpawnpoint_NearTeam( level.spawn_axis_planted );
+			else
+				spawnpoint = maps\mp\gametypes\_spawnlogic::getSpawnpoint_NearTeam( level.spawn_allies_planted );
+			
+		}
+		else
+		{
+			if (spawnteam == "axis")
+				spawnpoint = maps\mp\gametypes\_spawnlogic::getSpawnpoint_NearTeam(level.spawn_axis);
+			else
+				spawnpoint = maps\mp\gametypes\_spawnlogic::getSpawnpoint_NearTeam(level.spawn_allies);
+		}
+	}
+
+	assert( isDefined(spawnpoint) );
+
+	return spawnpoint;
+}
+
+
+onSpawnPlayer()
+{
+	self.isPlanting = false;
+	self.isDefusing = false;
+	self.isBombCarrier = false;	
+
+	if( ( inOvertime() ) && !isDefined( self.otSpawned ) )
+		self thread printOTHint();
+}
+
+
+printOTHint()
+{
+	self endon ( "disconnect" );
+
+	// give the "Overtime!" message time to show
+	wait ( 0.25 );
+
+	self thread maps\mp\gametypes\_hud_message::SplashNotify( "sudden_death" );
+	self.otSpawned = true;
+	
+}
+
+updateGametypeDvars()
+{
+	level.plantTime = dvarFloatValue( "planttime", 5, 0, 20 );
+	level.defuseTime = dvarFloatValue( "defusetime", 5, 0, 20 );
+	level.bombTimer = dvarFloatValue( "bombtimer", 45, 1, 300 );
+	level.hotPotato = dvarIntValue( "hotpotato", 1, 0, 1 );
+	level.scoreMode = getWatchedDvar( "scorelimit" );
+}
+
+
+sabotage()
+{
+	level.bombPlanted = false;
+	level.bombExploded = false;
+		
+	level._effect["bombexplosion"] = loadfx("explosions/tanker_explosion");
+
+	trigger = getEnt( "sab_bomb_pickup_trig", "targetname" );
+	if ( !isDefined( trigger ) ) 
+	{
+		error( "No sab_bomb_pickup_trig trigger found in map." );
+		return;
+	}
+
+	visuals[0] = getEnt( "sab_bomb", "targetname" );
+	if ( !isDefined( visuals[0] ) ) 
+	{
+		error( "No sab_bomb script_model found in map." );
+		return;
+	}
+	
+	precacheModel( "prop_suitcase_bomb" );	
+	visuals[0] setModel( "prop_suitcase_bomb" );
+	level.sabBomb = maps\mp\gametypes\_gameobjects::createCarryObject( "neutral", trigger, visuals, (0,0,32) );
+	level.sabBomb maps\mp\gametypes\_gameobjects::allowCarry( "any" );
+	level.sabBomb maps\mp\gametypes\_gameobjects::set2DIcon( "enemy", "waypoint_bomb" );
+	level.sabBomb maps\mp\gametypes\_gameobjects::set3DIcon( "enemy", "waypoint_bomb" );
+	level.sabBomb maps\mp\gametypes\_gameobjects::set2DIcon( "friendly", "waypoint_bomb" );
+	level.sabBomb maps\mp\gametypes\_gameobjects::set3DIcon( "friendly", "waypoint_bomb" );
+	level.sabBomb maps\mp\gametypes\_gameobjects::setCarryIcon( "hud_suitcase_bomb" );
+	level.sabBomb maps\mp\gametypes\_gameobjects::setVisibleTeam( "any" );
+	level.sabBomb.objIDPingEnemy = true;
+	level.sabBomb.onPickup = ::onPickup;
+	level.sabBomb.onDrop = ::onDrop;
+	level.sabBomb.allowWeapons = true;
+	level.sabBomb.objPoints["allies"].archived = true;
+	level.sabBomb.objPoints["axis"].archived = true;
+	level.sabBomb.autoResetTime = 60.0;
+	
+	if ( !isDefined( getEnt( "sab_bomb_axis", "targetname" ) ) ) 
+	{
+		error("No sab_bomb_axis trigger found in map.");
+		return;
+	}
+	if ( !isDefined( getEnt( "sab_bomb_allies", "targetname" ) ) )
+	{
+		error("No sab_bomb_allies trigger found in map.");
+		return;
+	}
+
+	if ( game["switchedsides"] )
+	{
+		level.bombZones["allies"] = createBombZone( "allies", getEnt( "sab_bomb_axis", "targetname" ) );
+		level.bombZones["axis"] = createBombZone( "axis", getEnt( "sab_bomb_allies", "targetname" ) );
+	}
+	else
+	{
+		level.bombZones["allies"] = createBombZone( "allies", getEnt( "sab_bomb_allies", "targetname" ) );
+		level.bombZones["axis"] = createBombZone( "axis", getEnt( "sab_bomb_axis", "targetname" ) );
+	}
+
+	if ( level.scoreMode )
+		level thread scoreThread();
+		
+	if ( inOvertime() )
+		level thread overtimeThread();
+}
+
+
+getClosestSite()
+{
+	if ( distance2d( self.origin, level.bombZones["allies"].trigger.origin ) < distance2d( self.origin, level.bombZones["axis"].trigger.origin ) )
+		return ( "allies" );
+	else
+		return ( "axis" );
+}
+
+distanceToSite( team )
+{
+	return ( distance2d( self.origin, level.bombZones[team].trigger.origin ) );
+}
+
+scoreThread()
+{
+	level.bombDistance = distance2d( getEnt( "sab_bomb_axis", "targetname" ) getOrigin(), getEnt( "sab_bomb_allies", "targetname" ) getOrigin() );
+
+	threatDistance = (level.bombDistance/2) - 384;
+	
+	bombEnt = level.sabBomb.trigger;
+	
+	// failsafe for bad bomb placement
+	if ( threatDistance > bombEnt distanceToSite( "allies" ) || threatDistance > bombEnt distanceToSite( "axis" ) )
+		threatDistance = bombEnt distanceToSite( bombEnt getClosestSite() ) - 128;
+	
+	dangerTeam = "";
+
+	for ( ;; )
+	{	
+		if ( isDefined( level.sabBomb.carrier ) )
+			bombEnt = level.sabBomb.carrier;
+		else
+			bombEnt = level.sabBomb.trigger;
+
+		lastDangerTeam = dangerTeam;
+		dangerTeam = "none";
+
+		if ( bombEnt distanceToSite( "allies" ) < threatDistance )
+			dangerTeam = level.bombZones["allies"] maps\mp\gametypes\_gameobjects::getOwnerTeam();
+		else if ( bombEnt distanceToSite( "axis" ) < threatDistance )
+			dangerTeam = level.bombZones["axis"] maps\mp\gametypes\_gameobjects::getOwnerTeam();
+		else if ( bombEnt distanceToSite( "allies" ) > level.bombDistance && bombEnt getClosestSite() != "allies" )
+			dangerTeam = level.bombZones["axis"] maps\mp\gametypes\_gameobjects::getOwnerTeam();
+		else if ( bombEnt distanceToSite( "axis" ) > level.bombDistance && bombEnt getClosestSite() != "axis" )
+			dangerTeam = level.bombZones["allies"] maps\mp\gametypes\_gameobjects::getOwnerTeam();
+
+		if ( dangerTeam != "none" )
+		{
+			if ( !level.bombPlanted || !getWatchedDvar( "scorelimit" ) || (level.bombPlanted && (maps\mp\gametypes\_gamescore::_getTeamScore( level.otherTeam[dangerTeam] ) < getWatchedDvar( "scorelimit" ) - 1)) )
+			{
+				maps\mp\gametypes\_gamescore::_setTeamScore( level.otherTeam[dangerTeam], maps\mp\gametypes\_gamescore::_getTeamScore( level.otherTeam[dangerTeam] ) + 1 );
+				maps\mp\gametypes\_gamescore::updateTeamScore( level.otherTeam[dangerTeam] );
+			}
+		}
+
+		if ( dangerTeam != lastDangerTeam && !level.bombExploded )
+		{
+			setDvar( "ui_danger_team", dangerTeam );
+		}
+		
+		wait ( 2.5 );
+	}
+}
+
+createBombZone( team, trigger )
+{
+	visuals = getEntArray( trigger.target, "targetname" );
+	
+	bombZone = maps\mp\gametypes\_gameobjects::createUseObject( team, trigger, visuals, (0,0,64) );
+	bombZone resetBombsite();
+	bombZone.onUse = ::onUse;
+	bombZone.onBeginUse = ::onBeginUse;
+	bombZone.onEndUse = ::onEndUse;
+	bombZone.onCantUse = ::onCantUse;
+	bombZone.useWeapon = "briefcase_bomb_mp";
+	
+	for ( i = 0; i < visuals.size; i++ )
+	{
+		if ( isDefined( visuals[i].script_exploder ) )
+		{
+			bombZone.exploderIndex = visuals[i].script_exploder;
+			break;
+		}
+	}
+	
+	return bombZone;
+}
+
+
+onBeginUse( player )
+{
+	// planted the bomb
+	if ( !self maps\mp\gametypes\_gameobjects::isFriendlyTeam( player.pers["team"] ) )
+		player.isPlanting = true;
+	else
+		player.isDefusing = true;
+}
+
+onEndUse( team, player, result )
+{
+	if ( !isAlive( player ) )
+		return;
+	
+	player.isPlanting = false;
+	player.isDefusing = false;
+}
+
+
+onPickup( player )
+{
+	level notify ( "bomb_picked_up" );
+	
+	self.autoResetTime = 60.0;
+	
+	level.useStartSpawns = false;
+	
+	team = player.pers["team"];
+	
+	if ( team == "allies" )
+		otherTeam = "axis";
+	else
+		otherTeam = "allies";
+	
+	player playLocalSound( "mp_suitcase_pickup" );
+	
+	player leaderDialogOnPlayer( "obj_destroy", "bomb" );
+	excludeList[0] = player;
+	leaderDialog( "bomb_taken", team, "bomb", excludeList );
+
+	if ( !level.splitscreen )
+	{
+		leaderDialog( "bomb_lost", otherTeam, "bomb" );
+		leaderDialog( "obj_defend", otherTeam, "bomb" );
+	}
+	player.isBombCarrier = true;
+
+	// recovered the bomb before abandonment timer elapsed
+	if ( team == self maps\mp\gametypes\_gameobjects::getOwnerTeam() )
+	{
+		//printOnTeamArg( &"MP_EXPLOSIVES_RECOVERED_BY", team, player );
+		playSoundOnPlayers( game["bomb_recovered_sound"], team );
+	}
+	else
+	{
+		//printOnTeamArg( &"MP_EXPLOSIVES_RECOVERED_BY", team, player );
+		playSoundOnPlayers( game["bomb_recovered_sound"] );
+	}
+	
+	self maps\mp\gametypes\_gameobjects::setOwnerTeam( team );
+	self maps\mp\gametypes\_gameobjects::setVisibleTeam( "any" );
+	self maps\mp\gametypes\_gameobjects::set2DIcon( "enemy", "waypoint_target" );
+	self maps\mp\gametypes\_gameobjects::set3DIcon( "enemy", "waypoint_kill" );
+	self maps\mp\gametypes\_gameobjects::set2DIcon( "friendly", "waypoint_escort" );
+	self maps\mp\gametypes\_gameobjects::set3DIcon( "friendly", "waypoint_escort" );
+		
+	level.bombZones[team] maps\mp\gametypes\_gameobjects::setVisibleTeam( "none" );
+	level.bombZones[otherTeam] maps\mp\gametypes\_gameobjects::setVisibleTeam( "any" );
+	
+	player incPlayerStat( "bombscarried", 1 );
+	player thread maps\mp\_matchdata::logGameEvent( "pickup", player.origin );
+}
+
+
+onDrop( player )
+{
+	if ( level.bombPlanted )
+	{
+		
+	}
+	else
+	{
+		if ( isDefined( player ) )
+			printOnTeamArg( &"MP_EXPLOSIVES_DROPPED_BY", self maps\mp\gametypes\_gameobjects::getOwnerTeam(), player );
+	
+		playSoundOnPlayers( game["bomb_dropped_sound"], self maps\mp\gametypes\_gameobjects::getOwnerTeam() );
+			
+		thread abandonmentThink( 0.0 );
+	}
+}
+
+
+abandonmentThink( delay )
+{
+	level endon ( "bomb_picked_up" );
+	
+	wait ( delay );
+
+	if ( isDefined( self.carrier ) )
+		return;
+
+	if ( self maps\mp\gametypes\_gameobjects::getOwnerTeam() == "allies" )
+		otherTeam = "axis";
+	else
+		otherTeam = "allies";
+
+//	printOnTeamArg( &"MP_EXPLOSIVES_DROPPED_BY", otherTeam, &"MP_THE_ENEMY" );
+	playSoundOnPlayers( game["bomb_dropped_sound"], otherTeam );
+
+	self maps\mp\gametypes\_gameobjects::setOwnerTeam( "neutral" );
+	self maps\mp\gametypes\_gameobjects::setVisibleTeam( "any" );
+	self maps\mp\gametypes\_gameobjects::set2DIcon( "enemy", "waypoint_bomb" );
+	self maps\mp\gametypes\_gameobjects::set3DIcon( "enemy", "waypoint_bomb" );
+	self maps\mp\gametypes\_gameobjects::set2DIcon( "friendly", "waypoint_bomb" );
+	self maps\mp\gametypes\_gameobjects::set3DIcon( "friendly", "waypoint_bomb" );
+
+	level.bombZones["allies"] maps\mp\gametypes\_gameobjects::setVisibleTeam( "none" );
+	level.bombZones["axis"] maps\mp\gametypes\_gameobjects::setVisibleTeam( "none" );		
+}
+
+
+onUse( player )
+{
+	team = player.pers["team"];
+	otherTeam = level.otherTeam[team];
+	// planted the bomb
+	if ( !self maps\mp\gametypes\_gameobjects::isFriendlyTeam( player.pers["team"] ) )
+	{
+		player notify ( "bomb_planted" );
+
+		player playSound( "mp_bomb_plant" );
+
+		level thread teamPlayerCardSplash( "callout_bombplanted", player );
+
+		leaderDialog( "bomb_planted" );
+
+		player thread maps\mp\gametypes\_hud_message::SplashNotify( "plant", maps\mp\gametypes\_rank::getScoreInfoValue( "plant" ) );
+		player thread maps\mp\gametypes\_rank::giveRankXP( "plant" );
+		maps\mp\gametypes\_gamescore::givePlayerScore( "plant", player );		
+		player incPlayerStat( "bombsplanted", 1 );
+		player thread maps\mp\_matchdata::logGameEvent( "plant", player.origin );
+		player.bombPlantedTime = getTime();
+
+		//if ( !inOvertime() )
+		level thread bombPlanted( self, player.pers["team"] );
+
+		level.bombOwner = player;
+
+		level.sabBomb.autoResetTime = undefined;
+		level.sabBomb maps\mp\gametypes\_gameobjects::allowCarry( "none" );
+		level.sabBomb maps\mp\gametypes\_gameobjects::setVisibleTeam( "none" );
+		level.sabBomb maps\mp\gametypes\_gameobjects::setDropped();
+		self.useWeapon = "briefcase_bomb_defuse_mp";
+		
+		self setUpForDefusing();
+	}
+	else // defused the bomb
+	{
+		player notify ( "bomb_defused" );
+
+		leaderDialog( "bomb_defused" );
+
+		level thread teamPlayerCardSplash( "callout_bombdefused", player );
+	
+		if ( isDefined( level.bombOwner ) && ( level.bombOwner.bombPlantedTime + 3000 + (level.defuseTime*1000) ) > getTime() && isReallyAlive( level.bombOwner ) )
+			player thread maps\mp\gametypes\_hud_message::SplashNotify( "ninja_defuse", ( maps\mp\gametypes\_rank::getScoreInfoValue( "defuse" ) ) );
+		else
+			player thread maps\mp\gametypes\_hud_message::SplashNotify( "defuse", maps\mp\gametypes\_rank::getScoreInfoValue( "defuse" ) );
+
+		player thread maps\mp\gametypes\_rank::giveRankXP( "defuse" );
+		maps\mp\gametypes\_gamescore::givePlayerScore( "defuse", player );
+		player incPlayerStat( "bombsdefused", 1 );
+		player thread maps\mp\_matchdata::logGameEvent( "defuse", player.origin );
+
+		if ( inOvertime() )
+		{
+			thread maps\mp\gametypes\_gamelogic::endGame( team, game["strings"]["target_destroyed"] );
+			return;
+		}
+
+		level thread bombDefused( self );
+
+		self resetBombsite();
+		
+		level.sabBomb maps\mp\gametypes\_gameobjects::allowCarry( "any" );
+		level.sabBomb maps\mp\gametypes\_gameobjects::setPickedUp( player );
+	}
+}
+
+
+onCantUse( player )
+{
+	player iPrintLnBold( &"MP_CANT_PLANT_WITHOUT_BOMB" );
+}
+
+
+bombPlanted( destroyedObj, team )
+{
+	level endon ( "overtime" );
+	
+	maps\mp\gametypes\_gamelogic::pauseTimer();
+	level.bombPlanted = true;
+	level.timeLimitOverride = true;
+	level.scoreLimitOverride = true;
+	setDvar( "ui_bomb_timer", 1 );
+	
+	// communicate timer information to menus
+	setGameEndTime( int( getTime() + (level.bombTimer * 1000) ) );
+	
+	destroyedObj.visuals[0] thread maps\mp\gametypes\_gamelogic::playTickingSound();
+	
+	starttime = gettime();
+	bombTimerWait();
+	
+	setDvar( "ui_bomb_timer", 0 );
+	destroyedObj.visuals[0] maps\mp\gametypes\_gamelogic::stopTickingSound();	
+
+	if ( !level.bombPlanted )
+	{
+		if ( level.hotPotato )
+		{
+			timePassed = (gettime() - starttime) / 1000;
+			level.bombTimer -= timePassed;
+		}
+		return;
+	}
+
+	explosionOrigin = level.sabBomb.visuals[0].origin;
+	level.bombExploded = true;	
+	setDvar( "ui_danger_team", "BombExploded" );
+	
+	if ( isdefined( level.bombowner ) )
+	{
+		destroyedObj.visuals[0] radiusDamage( explosionOrigin, 512, 200, 20, level.bombowner );
+		level.bombowner incPlayerStat( "targetsdestroyed", 1 );
+	}
+	else
+		destroyedObj.visuals[0] radiusDamage( explosionOrigin, 512, 200, 20 );
+	
+	rot = randomfloat(360);
+	explosionEffect = spawnFx( level._effect["bombexplosion"], explosionOrigin + (0,0,50), (0,0,1), (cos(rot),sin(rot),0) );
+	triggerFx( explosionEffect );
+
+	PlayRumbleOnPosition( "grenade_rumble", explosionOrigin );
+	earthquake( 0.75, 2.0, explosionOrigin, 2000 );
+	
+	thread playSoundinSpace( "exp_suitcase_bomb_main", explosionOrigin );
+	
+	sabBomb = getEnt( "sab_bomb", "targetname" );
+	sabBomb Delete();
+	
+	if ( isDefined( destroyedObj.exploderIndex ) )
+		exploder( destroyedObj.exploderIndex );
+
+	level.sabBomb maps\mp\gametypes\_gameobjects::setVisibleTeam( "none" );
+	level.bombZones["allies"] maps\mp\gametypes\_gameobjects::setVisibleTeam( "none" );
+	level.bombZones["axis"] maps\mp\gametypes\_gameobjects::setVisibleTeam( "none" );	
+	
+	setGameEndTime( 0 );
+	
+	level.scoreLimitOverride = true;
+
+	if ( level.scoreMode )
+		maps\mp\gametypes\_gamescore::_setTeamScore( team, int( max( getWatchedDvar( "scorelimit" ), maps\mp\gametypes\_gamescore::_getTeamScore( level.otherTeam[team] ) + 1 ) ) );
+	else
+		maps\mp\gametypes\_gamescore::_setTeamScore( team, 1 );
+	maps\mp\gametypes\_gamescore::updateTeamScore( team );
+
+	if ( isDefined( level.bombOwner ) )
+	{
+		level.bombOwner thread maps\mp\gametypes\_rank::giveRankXP( "destroy" );
+		maps\mp\gametypes\_gamescore::givePlayerScore( "destroy", level.bombOwner );		
+		level thread teamPlayerCardSplash( "callout_destroyed_objective", level.bombOwner );
+	}
+	
+	wait 3;
+
+	thread maps\mp\gametypes\_gamelogic::endGame( team, game["strings"]["target_destroyed"] );
+}
+
+
+bombTimerWait()
+{
+	level endon("bomb_defused");
+	level endon("overtime_ended");
+	
+	maps\mp\gametypes\_hostmigration::waitLongDurationWithGameEndTimeUpdate( level.bombTimer );
+}
+
+
+giveLastOnTeamWarning()
+{
+	self endon("death");
+	self endon("disconnect");
+	level endon( "game_ended" );
+		
+	self waitTillRecoveredHealth( 3 );
+	
+	otherTeam = getOtherTeam( self.pers["team"] );
+	level thread teamPlayerCardSplash( "callout_lastteammemberalive", self, self.pers["team"] );
+	level thread teamPlayerCardSplash( "callout_lastenemyalive", self, otherTeam );
+	level notify ( "last_alive", self );	
+	//self maps\mp\gametypes\_missions::lastManSD();
+}
+
+
+onTimeLimit()
+{
+	if ( level.bombExploded )
+		return;
+		
+	if( game["teamScores"]["axis"] > game["teamScores"]["allies"] )
+	{
+		thread maps\mp\gametypes\_gamelogic::endGame( "axis", game["strings"]["time_limit_reached"] );
+	}
+	else if( game["teamScores"]["axis"] < game["teamScores"]["allies"] )
+	{
+		thread maps\mp\gametypes\_gamelogic::endGame( "allies", game["strings"]["time_limit_reached"] );
+	}
+	else if( game["teamScores"]["axis"] == game["teamScores"]["allies"] )
+	{
+		if ( inOvertime() )
+			thread maps\mp\gametypes\_gamelogic::endGame( "tie", game["strings"]["time_limit_reached"] );
+		else
+			thread maps\mp\gametypes\_gamelogic::endGame( "overtime", game["strings"]["time_limit_reached"] );
+	}
+}
+
+
+overtimeThread( time )
+{
+	level endon( "game_ended" );
+
+	level.inOvertime = true;
+	
+	wait ( 5.0 );
+	level.disableSpawning = true;
+}
+
+
+/*
+overtimeThread()
+{
+	level.inOvertime = getTime();
+	level notify ( "overtime" );
+
+	thread bombDistanceThread();
+
+	foreach ( player in level.players )
+		player thread maps\mp\gametypes\_hud_message::SplashNotify( "sab_overtime" );
+
+	maps\mp\gametypes\_gamelogic::pauseTimer();
+	level.bombPlanted = true;
+	level.timeLimitOverride = true;
+	setDvar( "ui_bomb_timer", 1 );
+
+	// communicate timer information to menus
+	setGameEndTime( int( getTime() + (level.bombTimer * 1000) ) );
+	
+	maps\mp\gametypes\_hostmigration::waitLongDurationWithGameEndTimeUpdate( level.bombTimer );
+	
+	setDvar( "ui_bomb_timer", 0 );
+
+	if ( isDefined( level.sabBomb.carrier ) )
+	{
+		explosionEnt = level.sabBomb.carrier;
+	}
+	else
+	{
+		explosionEnt = level.sabBomb.visuals[0];
+	}
+
+	level.bombExploded = true;	
+	
+	if ( isdefined( level.bombowner ) )
+		explosionEnt radiusDamage( explosionEnt.origin, 512, 200, 20, level.bombowner );
+	else
+		explosionEnt radiusDamage( explosionEnt.origin, 512, 200, 20 );
+	
+	rot = randomfloat(360);
+	explosionEffect = spawnFx( level._effect["bombexplosion"], explosionEnt.origin + (0,0,50), (0,0,1), (cos(rot),sin(rot),0) );
+	triggerFx( explosionEffect );
+	
+	thread playSoundinSpace( "exp_suitcase_bomb_main", explosionEnt.origin );
+	
+	setGameEndTime( 0 );
+
+	team = getOtherTeam( level.dangerTeam );
+
+	wait 3;
+	
+	//maps\mp\gametypes\_gamescore::giveTeamScoreForObjective( team, 1 );
+	maps\mp\gametypes\_gamelogic::endGame( team, game["strings"]["target_destroyed"] );
+}
+*/
+
+bombDistanceThread()
+{
+	level endon ( "game_ended" );
+	
+	if ( cointoss() )
+		level.dangerTeam = "allies";
+	else
+		level.dangerTeam = "axis";
+	
+	for ( ;; )
+	{
+		if ( isDefined( level.sabBomb.carrier ) )
+			bombEnt = level.sabBomb.carrier;
+		else
+			bombEnt = level.sabBomb.visuals[0];
+
+		if ( distance( bombEnt.origin, level.bombZones[getOtherTeam(level.dangerTeam)].visuals[0].origin ) < distance( bombEnt.origin, level.bombZones[level.dangerTeam].visuals[0].origin ) )
+			level.dangerTeam = getOtherTeam( level.dangerTeam );
+
+		wait ( 0.05 );
+	}
+}	
+
+
+resetBombsite()
+{
+	self maps\mp\gametypes\_gameobjects::allowUse( "enemy" );
+	self maps\mp\gametypes\_gameobjects::setUseTime( level.plantTime );
+	self maps\mp\gametypes\_gameobjects::setUseText( &"MP_PLANTING_EXPLOSIVE" );
+	self maps\mp\gametypes\_gameobjects::setUseHintText( &"PLATFORM_HOLD_TO_PLANT_EXPLOSIVES" );
+	self maps\mp\gametypes\_gameobjects::setKeyObject( level.sabBomb );
+	self maps\mp\gametypes\_gameobjects::set2DIcon( "friendly", "waypoint_defend" );
+	self maps\mp\gametypes\_gameobjects::set3DIcon( "friendly", "waypoint_defend" );
+	self maps\mp\gametypes\_gameobjects::set2DIcon( "enemy", "waypoint_target" );
+	self maps\mp\gametypes\_gameobjects::set3DIcon( "enemy", "waypoint_target" );
+	self maps\mp\gametypes\_gameobjects::setVisibleTeam( "none" );
+	self.useWeapon = "briefcase_bomb_mp";
+}
+
+
+setUpForDefusing()
+{
+	self maps\mp\gametypes\_gameobjects::allowUse( "friendly" );
+	self maps\mp\gametypes\_gameobjects::setUseTime( level.defuseTime );
+	self maps\mp\gametypes\_gameobjects::setUseText( &"MP_DEFUSING_EXPLOSIVE" );
+	self maps\mp\gametypes\_gameobjects::setUseHintText( &"PLATFORM_HOLD_TO_DEFUSE_EXPLOSIVES" );
+	self maps\mp\gametypes\_gameobjects::setKeyObject( undefined );
+	self maps\mp\gametypes\_gameobjects::set2DIcon( "friendly", "waypoint_defuse" );
+	self maps\mp\gametypes\_gameobjects::set3DIcon( "friendly", "waypoint_defuse" );
+	self maps\mp\gametypes\_gameobjects::set2DIcon( "enemy", "waypoint_defend" );
+	self maps\mp\gametypes\_gameobjects::set3DIcon( "enemy", "waypoint_defend" );
+	self maps\mp\gametypes\_gameobjects::setVisibleTeam( "any" );
+}
+
+
+bombDefused( object )
+{
+	setDvar( "ui_bomb_timer", 0 );
+	maps\mp\gametypes\_gamelogic::resumeTimer();
+	level.bombPlanted = false;
+	level.timeLimitOverride = false;
+	level.scoreLimitOverride = false;
+
+	level notify("bomb_defused");	
+}
+
+
+onOneLeftEvent( team )
+{
+	if ( level.bombExploded )
+		return;
+
+	lastPlayer = getLastLivingPlayer( team );
+
+	lastPlayer thread giveLastOnTeamWarning();
+}
+
+
+onNormalDeath( victim, attacker, lifeId, lifeId )
+{
+	if ( victim.isPlanting )
+	{
+		thread maps\mp\_matchdata::logKillEvent( lifeId, "planting" );
+	}
+	else if ( victim.isBombCarrier )
+	{
+		attacker incPlayerStat( "bombcarrierkills", 1 );
+		thread maps\mp\_matchdata::logKillEvent( lifeId, "carrying" );
+	}
+	else if ( victim.isDefusing )
+	{
+		thread maps\mp\_matchdata::logKillEvent( lifeId, "defusing" );
+	}
+		
+	if ( attacker.isBombCarrier )
+		attacker incPlayerStat( "killsasbombcarrier", 1 );
+}
+
+initGametypeAwards()
+{
+	maps\mp\_awards::initStatAward( "targetsdestroyed", 	0, maps\mp\_awards::highestWins );
+	maps\mp\_awards::initStatAward( "bombsplanted", 		0, maps\mp\_awards::highestWins );
+	maps\mp\_awards::initStatAward( "bombsdefused", 		0, maps\mp\_awards::highestWins );
+	maps\mp\_awards::initStatAward( "bombcarrierkills", 	0, maps\mp\_awards::highestWins );
+	maps\mp\_awards::initStatAward( "bombscarried", 		0, maps\mp\_awards::highestWins );
+	maps\mp\_awards::initStatAward( "killsasbombcarrier", 	0, maps\mp\_awards::highestWins );
+}

iw4x/iw4x_00/maps/mp/gametypes/sd.gsc

@@ -0,0 +1,807 @@
+#include common_scripts\utility;
+#include maps\mp\_utility;
+#include maps\mp\gametypes\_hud_util;
+// Rallypoints should be destroyed on leaving your team/getting killed
+// Compass icons need to be looked at
+// Doesn't seem to be setting angle on spawn so that you are facing your rallypoint
+
+/*
+	Search and Destroy
+	Attackers objective: Bomb one of 2 positions
+	Defenders objective: Defend these 2 positions / Defuse planted bombs
+	Round ends:	When one team is eliminated, bomb explodes, bomb is defused, or roundlength time is reached
+	Map ends:	When one team reaches the score limit, or time limit or round limit is reached
+	Respawning:	Players remain dead for the round and will respawn at the beginning of the next round
+
+	Level requirements
+	------------------
+		Allied Spawnpoints:
+			classname		mp_sd_spawn_attacker
+			Allied players spawn from these. Place at least 16 of these relatively close together.
+
+		Axis Spawnpoints:
+			classname		mp_sd_spawn_defender
+			Axis players spawn from these. Place at least 16 of these relatively close together.
+
+		Spectator Spawnpoints:
+			classname		mp_global_intermission
+			Spectators spawn from these and intermission is viewed from these positions.
+			Atleast one is required, any more and they are randomly chosen between.
+
+		Bombzones:
+			classname					trigger_multiple
+			targetname					bombzone
+			script_gameobjectname		bombzone
+			script_bombmode_original	<if defined this bombzone will be used in the original bomb mode>
+			script_bombmode_single		<if defined this bombzone will be used in the single bomb mode>
+			script_bombmode_dual		<if defined this bombzone will be used in the dual bomb mode>
+			script_team					Set to allies or axis. This is used to set which team a bombzone is used by in dual bomb mode.
+			script_label				Set to A or B. This sets the letter shown on the compass in original mode.
+			This is a volume of space in which the bomb can planted. Must contain an origin brush.
+
+		Bomb:
+			classname				trigger_lookat
+			targetname				bombtrigger
+			script_gameobjectname	bombzone
+			This should be a 16x16 unit trigger with an origin brush placed so that it's center lies on the bottom plane of the trigger.
+			Must be in the level somewhere. This is the trigger that is used when defusing a bomb.
+			It gets moved to the position of the planted bomb model.
+
+	Level script requirements
+	-------------------------
+		Team Definitions:
+			game["attackers"] = "allies";
+			game["defenders"] = "axis";
+			This sets which team is attacking and which team is defending. Attackers plant the bombs. Defenders protect the targets.
+
+		Exploder Effects:
+			Setting script_noteworthy on a bombzone trigger to an exploder group can be used to trigger additional effects.
+*/
+
+/*QUAKED mp_sd_spawn_attacker (0.0 1.0 0.0) (-16 -16 0) (16 16 72)
+Attacking players spawn randomly at one of these positions at the beginning of a round.*/
+
+/*QUAKED mp_sd_spawn_defender (1.0 0.0 0.0) (-16 -16 0) (16 16 72)
+Defending players spawn randomly at one of these positions at the beginning of a round.*/
+
+main()
+{
+	if(getdvar("mapname") == "mp_background")
+		return;
+	
+	maps\mp\gametypes\_globallogic::init();
+	maps\mp\gametypes\_callbacksetup::SetupCallbacks();
+	maps\mp\gametypes\_globallogic::SetupCallbacks();
+	
+	registerRoundSwitchDvar( level.gameType, 3, 0, 9 );
+	registerTimeLimitDvar( level.gameType, 2.5, 0, 1440 );
+	registerScoreLimitDvar( level.gameType, 1, 0, 500 );
+	registerRoundLimitDvar( level.gameType, 0, 0, 12 );
+	registerWinLimitDvar( level.gameType, 4, 0, 12 );
+	registerNumLivesDvar( level.gameType, 1, 0, 10 );
+	registerHalfTimeDvar( level.gameType, 0, 0, 1 );
+	
+	level.objectiveBased = true;
+	level.teamBased = true;
+	level.onPrecacheGameType = ::onPrecacheGameType;
+	level.onStartGameType = ::onStartGameType;
+	level.getSpawnPoint = ::getSpawnPoint;
+	level.onSpawnPlayer = ::onSpawnPlayer;
+	level.onPlayerKilled = ::onPlayerKilled;
+	level.onDeadEvent = ::onDeadEvent;
+	level.onOneLeftEvent = ::onOneLeftEvent;
+	level.onTimeLimit = ::onTimeLimit;
+	level.onNormalDeath = ::onNormalDeath;
+	level.initGametypeAwards = ::initGametypeAwards;
+	
+	game["dialog"]["gametype"] = "searchdestroy";
+
+	if ( getDvarInt( "g_hardcore" ) )
+		game["dialog"]["gametype"] = "hc_" + game["dialog"]["gametype"];
+	else if ( getDvarInt( "camera_thirdPerson" ) )
+		game["dialog"]["gametype"] = "thirdp_" + game["dialog"]["gametype"];
+	else if ( getDvarInt( "scr_diehard" ) )
+		game["dialog"]["gametype"] = "dh_" + game["dialog"]["gametype"];
+	else if (getDvarInt( "scr_" + level.gameType + "_promode" ) )
+		game["dialog"]["gametype"] = game["dialog"]["gametype"] + "_pro";
+
+	game["dialog"]["offense_obj"] = "obj_destroy";
+	game["dialog"]["defense_obj"] = "obj_defend";
+}
+
+
+onPrecacheGameType()
+{
+	game["bomb_dropped_sound"] = "mp_war_objective_lost";
+	game["bomb_recovered_sound"] = "mp_war_objective_taken";
+
+	precacheShader("waypoint_bomb");
+	precacheShader("hud_suitcase_bomb");
+	precacheShader("waypoint_target");
+	precacheShader("waypoint_target_a");
+	precacheShader("waypoint_target_b");
+	precacheShader("waypoint_defend");
+	precacheShader("waypoint_defend_a");
+	precacheShader("waypoint_defend_b");
+	precacheShader("waypoint_defuse");
+	precacheShader("waypoint_defuse_a");
+	precacheShader("waypoint_defuse_b");
+	precacheShader("waypoint_escort");
+/*
+	precacheShader("waypoint_target");
+	precacheShader("waypoint_target_a");
+	precacheShader("waypoint_target_b");
+	precacheShader("waypoint_defend");
+	precacheShader("waypoint_defend_a");
+	precacheShader("waypoint_defend_b");
+	precacheShader("waypoint_defuse");
+	precacheShader("waypoint_defuse_a");
+	precacheShader("waypoint_defuse_b");
+*/	
+	precacheString( &"MP_EXPLOSIVES_RECOVERED_BY" );
+	precacheString( &"MP_EXPLOSIVES_DROPPED_BY" );
+	precacheString( &"MP_EXPLOSIVES_PLANTED_BY" );
+	precacheString( &"MP_EXPLOSIVES_DEFUSED_BY" );
+	precacheString( &"PLATFORM_HOLD_TO_PLANT_EXPLOSIVES" );
+	precacheString( &"PLATFORM_HOLD_TO_DEFUSE_EXPLOSIVES" );
+	precacheString( &"MP_CANT_PLANT_WITHOUT_BOMB" );	
+	precacheString( &"MP_PLANTING_EXPLOSIVE" );	
+	precacheString( &"MP_DEFUSING_EXPLOSIVE" );	
+}
+
+
+onStartGameType()
+{
+	if ( !isDefined( game["switchedsides"] ) )
+		game["switchedsides"] = false;
+	
+	if ( game["switchedsides"] )
+	{
+		oldAttackers = game["attackers"];
+		oldDefenders = game["defenders"];
+		game["attackers"] = oldDefenders;
+		game["defenders"] = oldAttackers;
+	}
+	
+	setClientNameMode( "manual_change" );
+	
+	game["strings"]["target_destroyed"] = &"MP_TARGET_DESTROYED";
+	game["strings"]["bomb_defused"] = &"MP_BOMB_DEFUSED";
+	
+	precacheString( game["strings"]["target_destroyed"] );
+	precacheString( game["strings"]["bomb_defused"] );
+
+	level._effect["bombexplosion"] = loadfx("explosions/tanker_explosion");
+	
+	setObjectiveText( game["attackers"], &"OBJECTIVES_SD_ATTACKER" );
+	setObjectiveText( game["defenders"], &"OBJECTIVES_SD_DEFENDER" );
+
+	if ( level.splitscreen )
+	{
+		setObjectiveScoreText( game["attackers"], &"OBJECTIVES_SD_ATTACKER" );
+		setObjectiveScoreText( game["defenders"], &"OBJECTIVES_SD_DEFENDER" );
+	}
+	else
+	{
+		setObjectiveScoreText( game["attackers"], &"OBJECTIVES_SD_ATTACKER_SCORE" );
+		setObjectiveScoreText( game["defenders"], &"OBJECTIVES_SD_DEFENDER_SCORE" );
+	}
+	setObjectiveHintText( game["attackers"], &"OBJECTIVES_SD_ATTACKER_HINT" );
+	setObjectiveHintText( game["defenders"], &"OBJECTIVES_SD_DEFENDER_HINT" );
+
+	level.spawnMins = ( 0, 0, 0 );
+	level.spawnMaxs = ( 0, 0, 0 );	
+	maps\mp\gametypes\_spawnlogic::placeSpawnPoints( "mp_sd_spawn_attacker" );
+	maps\mp\gametypes\_spawnlogic::placeSpawnPoints( "mp_sd_spawn_defender" );
+	
+	level.mapCenter = maps\mp\gametypes\_spawnlogic::findBoxCenter( level.spawnMins, level.spawnMaxs );
+	setMapCenter( level.mapCenter );
+	
+	allowed[0] = "sd";
+	allowed[1] = "bombzone";
+	allowed[2] = "blocker";
+	maps\mp\gametypes\_gameobjects::main(allowed);
+	
+	maps\mp\gametypes\_rank::registerScoreInfo( "win", 2 );
+	maps\mp\gametypes\_rank::registerScoreInfo( "loss", 1 );
+	maps\mp\gametypes\_rank::registerScoreInfo( "tie", 1.5 );
+	
+	maps\mp\gametypes\_rank::registerScoreInfo( "kill", 50 );
+	maps\mp\gametypes\_rank::registerScoreInfo( "headshot", 50 );
+	maps\mp\gametypes\_rank::registerScoreInfo( "assist", 20 );
+	maps\mp\gametypes\_rank::registerScoreInfo( "plant", 100 );
+	maps\mp\gametypes\_rank::registerScoreInfo( "defuse", 100 );
+	
+	thread updateGametypeDvars();
+	
+	thread bombs();
+}
+
+
+getSpawnPoint()
+{
+	if ( getDvar( "mapname" ) == "mp_shipment_long" )
+	{
+		if(self.pers["team"] == game["attackers"])
+			spawnPointName = "mp_cha_spawn_allies_start";
+		else
+			spawnPointName = "mp_cha_spawn_axis_start";
+	}
+	else
+	{
+		if(self.pers["team"] == game["attackers"])
+			spawnPointName = "mp_sd_spawn_attacker";
+		else
+			spawnPointName = "mp_sd_spawn_defender";
+	}
+
+	spawnPoints = maps\mp\gametypes\_spawnlogic::getSpawnpointArray( spawnPointName );
+	assert( spawnPoints.size );
+	spawnpoint = maps\mp\gametypes\_spawnlogic::getSpawnpoint_Random( spawnPoints );
+
+	return spawnpoint;
+}
+
+onSpawnPlayer()
+{
+	self.isPlanting = false;
+	self.isDefusing = false;
+	self.isBombCarrier = false;
+	
+	if ( level.multiBomb && !isDefined( self.carryIcon ) && self.pers["team"] == game["attackers"] && !level.bombPlanted )
+	{
+		if ( level.splitscreen )
+		{
+			self.carryIcon = createIcon( "hud_suitcase_bomb", 33, 33 );
+			self.carryIcon setPoint( "BOTTOM RIGHT", "BOTTOM RIGHT", 0, -78 );
+			self.carryIcon.alpha = 0.75;
+		}
+		else
+		{
+			self.carryIcon = createIcon( "hud_suitcase_bomb", 50, 50 );
+			self.carryIcon setPoint( "BOTTOM RIGHT", "BOTTOM RIGHT", -90, -65 );
+			self.carryIcon.alpha = 0.75;
+		}
+	}
+	
+	level notify ( "spawned_player" );
+}
+
+
+onPlayerKilled(eInflictor, attacker, iDamage, sMeansOfDeath, sWeapon, vDir, sHitLoc, psOffsetTime, deathAnimDuration, killId)
+{
+	thread checkAllowSpectating();
+}
+
+
+checkAllowSpectating()
+{
+	wait ( 0.05 );
+	
+	update = false;
+	if ( !level.aliveCount[ game["attackers"] ] )
+	{
+		level.spectateOverride[game["attackers"]].allowEnemySpectate = 1;
+		update = true;
+	}
+	if ( !level.aliveCount[ game["defenders"] ] )
+	{
+		level.spectateOverride[game["defenders"]].allowEnemySpectate = 1;
+		update = true;
+	}
+	if ( update )
+		maps\mp\gametypes\_spectating::updateSpectateSettings();
+}
+
+
+sd_endGame( winningTeam, endReasonText )
+{
+	thread maps\mp\gametypes\_gamelogic::endGame( winningTeam, endReasonText );
+}
+
+
+onDeadEvent( team )
+{
+	if ( level.bombExploded || level.bombDefused )
+		return;
+	
+	if ( team == "all" )
+	{
+		if ( level.bombPlanted )
+			sd_endGame( game["attackers"], game["strings"][game["defenders"]+"_eliminated"] );
+		else
+			sd_endGame( game["defenders"], game["strings"][game["attackers"]+"_eliminated"] );
+	}
+	else if ( team == game["attackers"] )
+	{
+		if ( level.bombPlanted )
+			return;
+
+		level thread sd_endGame( game["defenders"], game["strings"][game["attackers"]+"_eliminated"] );
+	}
+	else if ( team == game["defenders"] )
+	{
+		level thread sd_endGame( game["attackers"], game["strings"][game["defenders"]+"_eliminated"] );
+	}
+}
+
+
+onOneLeftEvent( team )
+{
+	if ( level.bombExploded || level.bombDefused )
+		return;
+
+	lastPlayer = getLastLivingPlayer( team );
+
+	lastPlayer thread giveLastOnTeamWarning();
+}
+
+
+onNormalDeath( victim, attacker, lifeId )
+{
+	score = maps\mp\gametypes\_rank::getScoreInfoValue( "kill" );
+	assert( isDefined( score ) );
+
+	team = victim.team;
+	
+	if ( game["state"] == "postgame" && (victim.team == game["defenders"] || !level.bombPlanted) )
+		attacker.finalKill = true;
+		
+	if ( victim.isPlanting )
+	{
+		thread maps\mp\_matchdata::logKillEvent( lifeId, "planting" );
+	}
+	else if ( victim.isBombCarrier )
+	{
+		attacker incPlayerStat( "bombcarrierkills", 1 );
+		thread maps\mp\_matchdata::logKillEvent( lifeId, "carrying" );
+	}
+	else if ( victim.isDefusing )
+	{
+		thread maps\mp\_matchdata::logKillEvent( lifeId, "defusing" );
+	}
+		
+	if ( attacker.isBombCarrier )
+		attacker incPlayerStat( "killsasbombcarrier", 1 );
+}
+
+
+giveLastOnTeamWarning()
+{
+	self endon("death");
+	self endon("disconnect");
+	level endon( "game_ended" );
+		
+	self waitTillRecoveredHealth( 3 );
+	
+	otherTeam = getOtherTeam( self.pers["team"] );
+	level thread teamPlayerCardSplash( "callout_lastteammemberalive", self, self.pers["team"] );
+	level thread teamPlayerCardSplash( "callout_lastenemyalive", self, otherTeam );
+	level notify ( "last_alive", self );	
+	self maps\mp\gametypes\_missions::lastManSD();
+}
+
+
+onTimeLimit()
+{
+	sd_endGame( game["defenders"], game["strings"]["time_limit_reached"] );
+}
+
+
+updateGametypeDvars()
+{
+	level.plantTime = dvarFloatValue( "planttime", 5, 0, 20 );
+	level.defuseTime = dvarFloatValue( "defusetime", 5, 0, 20 );
+	level.bombTimer = dvarFloatValue( "bombtimer", 45, 1, 300 );
+	level.multiBomb = dvarIntValue( "multibomb", 0, 0, 1 );
+}
+
+
+bombs()
+{
+	level.bombPlanted = false;
+	level.bombDefused = false;
+	level.bombExploded = false;
+
+	trigger = getEnt( "sd_bomb_pickup_trig", "targetname" );
+	if ( !isDefined( trigger ) )
+	{
+		error("No sd_bomb_pickup_trig trigger found in map.");
+		return;
+	}
+	
+	visuals[0] = getEnt( "sd_bomb", "targetname" );
+	if ( !isDefined( visuals[0] ) )
+	{
+		error("No sd_bomb script_model found in map.");
+		return;
+	}
+
+	precacheModel( "prop_suitcase_bomb" );	
+	visuals[0] setModel( "prop_suitcase_bomb" );
+	
+	if ( !level.multiBomb )
+	{
+		level.sdBomb = maps\mp\gametypes\_gameobjects::createCarryObject( game["attackers"], trigger, visuals, (0,0,32) );
+		level.sdBomb maps\mp\gametypes\_gameobjects::allowCarry( "friendly" );
+		level.sdBomb maps\mp\gametypes\_gameobjects::set2DIcon( "friendly", "waypoint_bomb" );
+		level.sdBomb maps\mp\gametypes\_gameobjects::set3DIcon( "friendly", "waypoint_bomb" );
+		level.sdBomb maps\mp\gametypes\_gameobjects::setVisibleTeam( "friendly" );
+		level.sdBomb maps\mp\gametypes\_gameobjects::setCarryIcon( "hud_suitcase_bomb" );
+		level.sdBomb.allowWeapons = true;
+		level.sdBomb.onPickup = ::onPickup;
+		level.sdBomb.onDrop = ::onDrop;
+	}
+	else
+	{
+		trigger delete();
+		visuals[0] delete();
+	}
+	
+	
+	level.bombZones = [];
+	
+	bombZones = getEntArray( "bombzone", "targetname" );
+	
+	for ( index = 0; index < bombZones.size; index++ )
+	{
+		trigger = bombZones[index];
+		visuals = getEntArray( bombZones[index].target, "targetname" );
+		
+		bombZone = maps\mp\gametypes\_gameobjects::createUseObject( game["defenders"], trigger, visuals, (0,0,64) );
+		bombZone maps\mp\gametypes\_gameobjects::allowUse( "enemy" );
+		bombZone maps\mp\gametypes\_gameobjects::setUseTime( level.plantTime );
+		bombZone maps\mp\gametypes\_gameobjects::setUseText( &"MP_PLANTING_EXPLOSIVE" );
+		bombZone maps\mp\gametypes\_gameobjects::setUseHintText( &"PLATFORM_HOLD_TO_PLANT_EXPLOSIVES" );
+		if ( !level.multiBomb )
+			bombZone maps\mp\gametypes\_gameobjects::setKeyObject( level.sdBomb );
+		label = bombZone maps\mp\gametypes\_gameobjects::getLabel();
+		bombZone.label = label;
+		bombZone maps\mp\gametypes\_gameobjects::set2DIcon( "friendly", "waypoint_defend" + label );
+		bombZone maps\mp\gametypes\_gameobjects::set3DIcon( "friendly", "waypoint_defend" + label );
+		bombZone maps\mp\gametypes\_gameobjects::set2DIcon( "enemy", "waypoint_target" + label );
+		bombZone maps\mp\gametypes\_gameobjects::set3DIcon( "enemy", "waypoint_target" + label );
+		bombZone maps\mp\gametypes\_gameobjects::setVisibleTeam( "any" );
+		bombZone.onBeginUse = ::onBeginUse;
+		bombZone.onEndUse = ::onEndUse;
+		bombZone.onUse = ::onUsePlantObject;
+		bombZone.onCantUse = ::onCantUse;
+		bombZone.useWeapon = "briefcase_bomb_mp";
+		
+		for ( i = 0; i < visuals.size; i++ )
+		{
+			if ( isDefined( visuals[i].script_exploder ) )
+			{
+				bombZone.exploderIndex = visuals[i].script_exploder;
+				break;
+			}
+		}
+		
+		level.bombZones[level.bombZones.size] = bombZone;
+		
+		bombZone.bombDefuseTrig = getent( visuals[0].target, "targetname" );
+		assert( isdefined( bombZone.bombDefuseTrig ) );
+		bombZone.bombDefuseTrig.origin += (0,0,-10000);
+		bombZone.bombDefuseTrig.label = label;
+	}
+	
+	for ( index = 0; index < level.bombZones.size; index++ )
+	{
+		array = [];
+		for ( otherindex = 0; otherindex < level.bombZones.size; otherindex++ )
+		{
+			if ( otherindex != index )
+				array[ array.size ] = level.bombZones[otherindex];
+		}
+		level.bombZones[index].otherBombZones = array;
+	}
+}
+
+onBeginUse( player )
+{
+	if ( self maps\mp\gametypes\_gameobjects::isFriendlyTeam( player.pers["team"] ) )
+	{
+		player playSound( "mp_bomb_defuse" );
+		player.isDefusing = true;
+		
+		if ( isDefined( level.sdBombModel ) )
+			level.sdBombModel hide();
+	}
+	else
+	{
+		player.isPlanting = true;
+
+		if ( level.multibomb )
+		{
+			for ( i = 0; i < self.otherBombZones.size; i++ )
+			{
+				//self.otherBombZones[i] maps\mp\gametypes\_gameobjects::disableObject();
+				self.otherBombZones[i] maps\mp\gametypes\_gameobjects::allowUse( "none" );
+				self.otherBombZones[i] maps\mp\gametypes\_gameobjects::setVisibleTeam( "friendly" );
+			}
+		}
+	}
+}
+
+onEndUse( team, player, result )
+{
+	if ( !isDefined( player ) )
+		return;
+	
+	if ( isAlive( player ) )
+	{
+		player.isDefusing = false;
+		player.isPlanting = false;
+	}
+	
+	if ( self maps\mp\gametypes\_gameobjects::isFriendlyTeam( player.pers["team"] ) )
+	{
+		if ( isDefined( level.sdBombModel ) && !result )
+		{
+			level.sdBombModel show();
+		}
+	}
+	else
+	{
+		if ( level.multibomb && !result )
+		{
+			for ( i = 0; i < self.otherBombZones.size; i++ )
+			{
+				//self.otherBombZones[i] maps\mp\gametypes\_gameobjects::enableObject();
+				self.otherBombZones[i] maps\mp\gametypes\_gameobjects::allowUse( "enemy" );
+				self.otherBombZones[i] maps\mp\gametypes\_gameobjects::setVisibleTeam( "any" );
+			}
+		}
+	}
+}
+
+onCantUse( player )
+{
+	player iPrintLnBold( &"MP_CANT_PLANT_WITHOUT_BOMB" );
+}
+
+onUsePlantObject( player )
+{
+	// planted the bomb
+	if ( !self maps\mp\gametypes\_gameobjects::isFriendlyTeam( player.pers["team"] ) )
+	{
+		level thread bombPlanted( self, player );
+		//player logString( "bomb planted: " + self.label );
+		
+		// disable all bomb zones except this one
+		for ( index = 0; index < level.bombZones.size; index++ )
+		{
+			if ( level.bombZones[index] == self )
+				continue;
+				
+			level.bombZones[index] maps\mp\gametypes\_gameobjects::disableObject();
+		}
+		
+		player playSound( "mp_bomb_plant" );
+		player notify ( "bomb_planted" );
+
+		//if ( !level.hardcoreMode )
+		//	iPrintLn( &"MP_EXPLOSIVES_PLANTED_BY", player );
+
+		leaderDialog( "bomb_planted" );
+
+		level thread teamPlayerCardSplash( "callout_bombplanted", player );
+
+		level.bombOwner = player;
+		player thread maps\mp\gametypes\_hud_message::SplashNotify( "plant", maps\mp\gametypes\_rank::getScoreInfoValue( "plant" ) );
+		player thread maps\mp\gametypes\_rank::giveRankXP( "plant" );
+		player.bombPlantedTime = getTime();
+		maps\mp\gametypes\_gamescore::givePlayerScore( "plant", player );	
+		player incPlayerStat( "bombsplanted", 1 );
+		player thread maps\mp\_matchdata::logGameEvent( "plant", player.origin );
+	}
+}
+
+onUseDefuseObject( player )
+{
+	player notify ( "bomb_defused" );
+	//player logString( "bomb defused: " + self.label );
+	level thread bombDefused();
+	
+	// disable this bomb zone
+	self maps\mp\gametypes\_gameobjects::disableObject();
+	
+	//if ( !level.hardcoreMode )
+	//	iPrintLn( &"MP_EXPLOSIVES_DEFUSED_BY", player );
+	leaderDialog( "bomb_defused" );
+
+	level thread teamPlayerCardSplash( "callout_bombdefused", player );
+
+	if ( isDefined( level.bombOwner ) && ( level.bombOwner.bombPlantedTime + 3000 + (level.defuseTime*1000) ) > getTime() && isReallyAlive( level.bombOwner ) )
+		player thread maps\mp\gametypes\_hud_message::SplashNotify( "ninja_defuse", ( maps\mp\gametypes\_rank::getScoreInfoValue( "defuse" ) ) );
+	else
+		player thread maps\mp\gametypes\_hud_message::SplashNotify( "defuse", maps\mp\gametypes\_rank::getScoreInfoValue( "defuse" ) );
+	
+	player thread maps\mp\gametypes\_rank::giveRankXP( "defuse" );
+	maps\mp\gametypes\_gamescore::givePlayerScore( "defuse", player );		
+	player incPlayerStat( "bombsdefused", 1 );
+		player thread maps\mp\_matchdata::logGameEvent( "defuse", player.origin );
+}
+
+
+onDrop( player )
+{
+	self maps\mp\gametypes\_gameobjects::set2DIcon( "friendly", "waypoint_bomb" );
+	self maps\mp\gametypes\_gameobjects::set3DIcon( "friendly", "waypoint_bomb" );
+	
+	maps\mp\_utility::playSoundOnPlayers( game["bomb_dropped_sound"], game["attackers"] );
+}
+
+
+onPickup( player )
+{
+	player.isBombCarrier = true;
+	player incPlayerStat( "bombscarried", 1 );
+	player thread maps\mp\_matchdata::logGameEvent( "pickup", player.origin );
+	
+	self maps\mp\gametypes\_gameobjects::set2DIcon( "friendly", "waypoint_escort" );
+	self maps\mp\gametypes\_gameobjects::set3DIcon( "friendly", "waypoint_escort" );
+
+	if ( !level.bombDefused )
+	{
+		teamPlayerCardSplash( "callout_bombtaken", player, player.team );		
+		leaderDialog( "bomb_taken", player.pers["team"] );
+	}
+	maps\mp\_utility::playSoundOnPlayers( game["bomb_recovered_sound"], game["attackers"] );
+}
+
+
+onReset()
+{
+}
+
+
+bombPlanted( destroyedObj, player )
+{
+	maps\mp\gametypes\_gamelogic::pauseTimer();
+	level.bombPlanted = true;
+	
+	destroyedObj.visuals[0] thread maps\mp\gametypes\_gamelogic::playTickingSound();
+	level.tickingObject = destroyedObj.visuals[0];
+
+	level.timeLimitOverride = true;
+	setGameEndTime( int( gettime() + (level.bombTimer * 1000) ) );
+	setDvar( "ui_bomb_timer", 1 );
+	
+	if ( !level.multiBomb )
+	{
+		level.sdBomb maps\mp\gametypes\_gameobjects::allowCarry( "none" );
+		level.sdBomb maps\mp\gametypes\_gameobjects::setVisibleTeam( "none" );
+		level.sdBomb maps\mp\gametypes\_gameobjects::setDropped();
+		level.sdBombModel = level.sdBomb.visuals[0];
+	}
+	else
+	{
+		
+		for ( index = 0; index < level.players.size; index++ )
+		{
+			if ( isDefined( level.players[index].carryIcon ) )
+				level.players[index].carryIcon destroyElem();
+		}
+
+		trace = bulletTrace( player.origin + (0,0,20), player.origin - (0,0,2000), false, player );
+		
+		tempAngle = randomfloat( 360 );
+		forward = (cos( tempAngle ), sin( tempAngle ), 0);
+		forward = vectornormalize( forward - common_scripts\utility::vector_multiply( trace["normal"], vectordot( forward, trace["normal"] ) ) );
+		dropAngles = vectortoangles( forward );
+		
+		level.sdBombModel = spawn( "script_model", trace["position"] );
+		level.sdBombModel.angles = dropAngles;
+		level.sdBombModel setModel( "prop_suitcase_bomb" );
+	}
+	destroyedObj maps\mp\gametypes\_gameobjects::allowUse( "none" );
+	destroyedObj maps\mp\gametypes\_gameobjects::setVisibleTeam( "none" );
+	/*
+	destroyedObj maps\mp\gametypes\_gameobjects::set2DIcon( "friendly", undefined );
+	destroyedObj maps\mp\gametypes\_gameobjects::set2DIcon( "enemy", undefined );
+	destroyedObj maps\mp\gametypes\_gameobjects::set3DIcon( "friendly", undefined );
+	destroyedObj maps\mp\gametypes\_gameobjects::set3DIcon( "enemy", undefined );
+	*/
+	label = destroyedObj maps\mp\gametypes\_gameobjects::getLabel();
+	
+	// create a new object to defuse with.
+	trigger = destroyedObj.bombDefuseTrig;
+	trigger.origin = level.sdBombModel.origin;
+	visuals = [];
+	defuseObject = maps\mp\gametypes\_gameobjects::createUseObject( game["defenders"], trigger, visuals, (0,0,32) );
+	defuseObject maps\mp\gametypes\_gameobjects::allowUse( "friendly" );
+	defuseObject maps\mp\gametypes\_gameobjects::setUseTime( level.defuseTime );
+	defuseObject maps\mp\gametypes\_gameobjects::setUseText( &"MP_DEFUSING_EXPLOSIVE" );
+	defuseObject maps\mp\gametypes\_gameobjects::setUseHintText( &"PLATFORM_HOLD_TO_DEFUSE_EXPLOSIVES" );
+	defuseObject maps\mp\gametypes\_gameobjects::setVisibleTeam( "any" );
+	defuseObject maps\mp\gametypes\_gameobjects::set2DIcon( "friendly", "waypoint_defuse" + label );
+	defuseObject maps\mp\gametypes\_gameobjects::set2DIcon( "enemy", "waypoint_defend" + label );
+	defuseObject maps\mp\gametypes\_gameobjects::set3DIcon( "friendly", "waypoint_defuse" + label );
+	defuseObject maps\mp\gametypes\_gameobjects::set3DIcon( "enemy", "waypoint_defend" + label );
+	defuseObject.label = label;
+	defuseObject.onBeginUse = ::onBeginUse;
+	defuseObject.onEndUse = ::onEndUse;
+	defuseObject.onUse = ::onUseDefuseObject;
+	defuseObject.useWeapon = "briefcase_bomb_defuse_mp";
+	
+	BombTimerWait();
+	setDvar( "ui_bomb_timer", 0 );
+	
+	destroyedObj.visuals[0] maps\mp\gametypes\_gamelogic::stopTickingSound();
+	
+	if ( level.gameEnded || level.bombDefused )
+		return;
+	
+	level.bombExploded = true;
+	
+	explosionOrigin = level.sdBombModel.origin;
+	level.sdBombModel hide();
+	
+	if ( isdefined( player ) )
+	{
+		destroyedObj.visuals[0] radiusDamage( explosionOrigin, 512, 200, 20, player );
+		player incPlayerStat( "targetsdestroyed", 1 );
+	}
+	else
+		destroyedObj.visuals[0] radiusDamage( explosionOrigin, 512, 200, 20 );
+	
+	rot = randomfloat(360);
+	explosionEffect = spawnFx( level._effect["bombexplosion"], explosionOrigin + (0,0,50), (0,0,1), (cos(rot),sin(rot),0) );
+	triggerFx( explosionEffect );
+
+	PlayRumbleOnPosition( "grenade_rumble", explosionOrigin );
+	earthquake( 0.75, 2.0, explosionOrigin, 2000 );
+	
+	thread playSoundinSpace( "exp_suitcase_bomb_main", explosionOrigin );
+	
+	sabBomb = getEnt( "sab_bomb", "targetname" );
+	sabBomb Delete();
+	
+	if ( isDefined( destroyedObj.exploderIndex ) )
+		exploder( destroyedObj.exploderIndex );
+	
+	for ( index = 0; index < level.bombZones.size; index++ )
+		level.bombZones[index] maps\mp\gametypes\_gameobjects::disableObject();
+	defuseObject maps\mp\gametypes\_gameobjects::disableObject();
+	
+	setGameEndTime( 0 );
+	
+	wait 3;
+	
+	sd_endGame( game["attackers"], game["strings"]["target_destroyed"] );
+}
+
+BombTimerWait()
+{
+	level endon( "game_ended" );
+	level endon( "bomb_defused" );
+	
+	maps\mp\gametypes\_hostmigration::waitLongDurationWithGameEndTimeUpdate( level.bombTimer );
+}
+
+
+bombDefused()
+{
+	level.tickingObject maps\mp\gametypes\_gamelogic::stopTickingSound();
+	level.bombDefused = true;
+	setDvar( "ui_bomb_timer", 0 );
+	
+	level notify("bomb_defused");
+	
+	wait 1.5;
+	
+	setGameEndTime( 0 );
+	
+	sd_endGame( game["defenders"], game["strings"]["bomb_defused"] );
+}
+
+initGametypeAwards()
+{
+	maps\mp\_awards::initStatAward( "targetsdestroyed", 	0, maps\mp\_awards::highestWins );
+	maps\mp\_awards::initStatAward( "bombsplanted", 		0, maps\mp\_awards::highestWins );
+	maps\mp\_awards::initStatAward( "bombsdefused", 		0, maps\mp\_awards::highestWins );
+	maps\mp\_awards::initStatAward( "bombcarrierkills", 	0, maps\mp\_awards::highestWins );
+	maps\mp\_awards::initStatAward( "bombscarried", 		0, maps\mp\_awards::highestWins );
+	maps\mp\_awards::initStatAward( "killsasbombcarrier", 	0, maps\mp\_awards::highestWins );
+}

iw4x/iw4x_00/maps/mp/gametypes/war.gsc

@@ -0,0 +1,179 @@
+#include maps\mp\_utility;
+#include maps\mp\gametypes\_hud_util;
+/*
+	War
+	Objective: 	Score points for your team by eliminating players on the opposing team
+	Map ends:	When one team reaches the score limit, or time limit is reached
+	Respawning:	No wait / Near teammates
+
+	Level requirementss
+	------------------
+		Spawnpoints:
+			classname		mp_tdm_spawn
+			All players spawn from these. The spawnpoint chosen is dependent on the current locations of teammates and enemies
+			at the time of spawn. Players generally spawn behind their teammates relative to the direction of enemies.
+
+		Spectator Spawnpoints:
+			classname		mp_global_intermission
+			Spectators spawn from these and intermission is viewed from these positions.
+			Atleast one is required, any more and they are randomly chosen between.
+*/
+
+/*QUAKED mp_tdm_spawn (0.0 0.0 1.0) (-16 -16 0) (16 16 72)
+Players spawn away from enemies and near their team at one of these positions.*/
+
+/*QUAKED mp_tdm_spawn_axis_start (0.5 0.0 1.0) (-16 -16 0) (16 16 72)
+Axis players spawn away from enemies and near their team at one of these positions at the start of a round.*/
+
+/*QUAKED mp_tdm_spawn_allies_start (0.0 0.5 1.0) (-16 -16 0) (16 16 72)
+Allied players spawn away from enemies and near their team at one of these positions at the start of a round.*/
+
+main()
+{
+	if(getdvar("mapname") == "mp_background")
+		return;
+	
+	maps\mp\gametypes\_globallogic::init();
+	maps\mp\gametypes\_callbacksetup::SetupCallbacks();
+	maps\mp\gametypes\_globallogic::SetupCallbacks();
+
+	registerRoundSwitchDvar( level.gameType, 0, 0, 9 );
+	registerTimeLimitDvar( level.gameType, 10, 0, 1440 );
+	registerScoreLimitDvar( level.gameType, 500, 0, 5000 );
+	registerRoundLimitDvar( level.gameType, 1, 0, 10 );
+	registerWinLimitDvar( level.gameType, 1, 0, 10 );
+	registerRoundSwitchDvar( level.gameType, 3, 0, 30 );
+	registerNumLivesDvar( level.gameType, 0, 0, 10 );
+	registerHalfTimeDvar( level.gameType, 0, 0, 1 );
+
+	level.teamBased = true;
+	level.onStartGameType = ::onStartGameType;
+	level.getSpawnPoint = ::getSpawnPoint;
+	level.onNormalDeath = ::onNormalDeath;
+	//level.onTimeLimit = ::onTimeLimit;	// overtime not fully supported yet
+
+	game["dialog"]["gametype"] = "tm_death";
+	
+	if ( getDvarInt( "g_hardcore" ) )
+		game["dialog"]["gametype"] = "hc_" + game["dialog"]["gametype"];
+	else if ( getDvarInt( "camera_thirdPerson" ) )
+		game["dialog"]["gametype"] = "thirdp_" + game["dialog"]["gametype"];
+	else if ( getDvarInt( "scr_diehard" ) )
+		game["dialog"]["gametype"] = "dh_" + game["dialog"]["gametype"];
+	else if (getDvarInt( "scr_" + level.gameType + "_promode" ) )
+		game["dialog"]["gametype"] = game["dialog"]["gametype"] + "_pro";
+	
+	game["strings"]["overtime_hint"] = &"MP_FIRST_BLOOD";
+}
+
+
+onStartGameType()
+{
+	setClientNameMode("auto_change");
+
+	if ( !isdefined( game["switchedsides"] ) )
+		game["switchedsides"] = false;
+
+	if ( game["switchedsides"] )
+	{
+		oldAttackers = game["attackers"];
+		oldDefenders = game["defenders"];
+		game["attackers"] = oldDefenders;
+		game["defenders"] = oldAttackers;
+	}
+
+	setObjectiveText( "allies", &"OBJECTIVES_WAR" );
+	setObjectiveText( "axis", &"OBJECTIVES_WAR" );
+	
+	if ( level.splitscreen )
+	{
+		setObjectiveScoreText( "allies", &"OBJECTIVES_WAR" );
+		setObjectiveScoreText( "axis", &"OBJECTIVES_WAR" );
+	}
+	else
+	{
+		setObjectiveScoreText( "allies", &"OBJECTIVES_WAR_SCORE" );
+		setObjectiveScoreText( "axis", &"OBJECTIVES_WAR_SCORE" );
+	}
+	setObjectiveHintText( "allies", &"OBJECTIVES_WAR_HINT" );
+	setObjectiveHintText( "axis", &"OBJECTIVES_WAR_HINT" );
+			
+	level.spawnMins = ( 0, 0, 0 );
+	level.spawnMaxs = ( 0, 0, 0 );	
+	maps\mp\gametypes\_spawnlogic::placeSpawnPoints( "mp_tdm_spawn_allies_start" );
+	maps\mp\gametypes\_spawnlogic::placeSpawnPoints( "mp_tdm_spawn_axis_start" );
+	maps\mp\gametypes\_spawnlogic::addSpawnPoints( "allies", "mp_tdm_spawn" );
+	maps\mp\gametypes\_spawnlogic::addSpawnPoints( "axis", "mp_tdm_spawn" );
+	
+	level.mapCenter = maps\mp\gametypes\_spawnlogic::findBoxCenter( level.spawnMins, level.spawnMaxs );
+	setMapCenter( level.mapCenter );
+	
+	allowed[0] = level.gameType;
+	allowed[1] = "airdrop_pallet";
+	
+	maps\mp\gametypes\_gameobjects::main(allowed);	
+}
+
+
+getSpawnPoint()
+{
+	spawnteam = self.pers["team"];
+	if ( game["switchedsides"] )
+		spawnteam = getOtherTeam( spawnteam );
+
+	if ( level.inGracePeriod )
+	{
+		if ( getDvar( "mapname" ) == "mp_shipment_long" )
+		{
+			spawnPoints = maps\mp\gametypes\_spawnlogic::getSpawnpointArray( "mp_cha_spawn_" + spawnteam + "_start" );
+			spawnPoint = maps\mp\gametypes\_spawnlogic::getSpawnpoint_Random( spawnPoints );
+		}
+		else
+		{
+			spawnPoints = maps\mp\gametypes\_spawnlogic::getSpawnpointArray( "mp_tdm_spawn_" + spawnteam + "_start" );
+			spawnPoint = maps\mp\gametypes\_spawnlogic::getSpawnpoint_Random( spawnPoints );
+		}
+	}
+	else
+	{
+		spawnPoints = maps\mp\gametypes\_spawnlogic::getTeamSpawnPoints( spawnteam );
+		spawnPoint = maps\mp\gametypes\_spawnlogic::getSpawnpoint_NearTeam( spawnPoints );
+	}
+	
+	return spawnPoint;
+}
+
+
+onNormalDeath( victim, attacker, lifeId )
+{
+	score = maps\mp\gametypes\_rank::getScoreInfoValue( "kill" );
+	assert( isDefined( score ) );
+
+	attacker maps\mp\gametypes\_gamescore::giveTeamScoreForObjective( attacker.pers["team"], score );
+	
+	if ( game["state"] == "postgame" && game["teamScores"][attacker.team] > game["teamScores"][level.otherTeam[attacker.team]] )
+		attacker.finalKill = true;
+}
+
+
+onTimeLimit()
+{
+	if ( game["status"] == "overtime" )
+	{
+		winner = "forfeit";
+	}
+	else if ( game["teamScores"]["allies"] == game["teamScores"]["axis"] )
+	{
+		winner = "overtime";
+	}
+	else if ( game["teamScores"]["axis"] > game["teamScores"]["allies"] )
+	{
+		winner = "axis";
+	}
+	else
+	{
+		winner = "allies";
+	}
+	
+	thread maps\mp\gametypes\_gamelogic::endGame( winner, game["strings"]["time_limit_reached"] );
+}

iw4x/iw4x_00/maps/mp/hunted_precache.gsc

@@ -0,0 +1,18 @@
+// this file is autogenerated, modifying parameters is ok, other lines will be removed.
+main()
+{
+	maps\co_ac130_anim::main();
+	common_scripts\_destructible_types_anim_airconditioner::main();
+	common_scripts\_destructible_types_anim_light_fluo_single::main();
+	//common_scripts\_destructible_types_anim_lockers::main();
+	//common_scripts\_destructible_types_anim_wallfan::main();
+	maps\animated_models\foliage_dead_pine_lg_sway2::main();
+	maps\animated_models\foliage_dead_pine_med_sway2::main();
+	maps\animated_models\foliage_tree_oak_1::main();
+	maps\animated_models\highrise_fencetarp_04b_wind_a::main();
+	maps\animated_models\highrise_fencetarp_04b_wind_b::main();
+	maps\animated_models\highrise_fencetarp_04b_wind_c::main();
+	maps\animated_models\highrise_fencetarp_07b_wind_a::main();
+	maps\animated_models\highrise_fencetarp_07b_wind_b::main();
+	maps\animated_models\highrise_fencetarp_07b_wind_c::main();
+}

iw4x/iw4x_00/maps/mp/iw4_credits.gsc

@@ -0,0 +1,50 @@
+#include common_scripts\utility;
+ 
+main()
+{
+
+ 
+        maps\mp\_load::main();
+ 
+
+
+ 
+        game[ "attackers" ] = "allies";
+        game[ "defenders" ] = "axis";
+ 
+        maps\mp\_compass::setupMiniMap( "compass_map_hunted" );
+        setdvar( "compassmaxrange", "4000" );
+ 
+ 
+        array_thread( getentarray( "compassTriggers", "targetname" ), ::compass_triggers_think );
+
+}
+ 
+self_delete()
+{
+        self delete();
+}
+
+
+compass_triggers_think()
+{
+        assertex( isdefined( self.script_noteworthy ), "compassTrigger at " + self.origin + " needs to have a script_noteworthy with the name of the minimap to use" );
+        while( true )
+        {
+                wait( 1 );
+                self waittill( "trigger" );
+                maps\mp\_compass::setupMiniMap( self.script_noteworthy );
+        }
+}
+ 
+createSpawnpoint( classname, origin, yaw )
+{
+        spawnpoint = spawn( "script_origin", origin );
+        spawnpoint.angles = (0,yaw,0);
+       
+        if ( !isdefined( level.extraspawnpoints ) )
+                level.extraspawnpoints = [];
+        if ( !isdefined( level.extraspawnpoints[classname] ) )
+                level.extraspawnpoints[classname] = [];
+        level.extraspawnpoints[classname][ level.extraspawnpoints[classname].size ] = spawnpoint;
+}

iw4x/iw4x_00/maps/mp/mp_bloc.gsc

@@ -0,0 +1,20 @@
+main()
+{
+	maps\createart\mp_bloc_art::main();
+	maps\mp\mp_bloc_fx::main();
+	maps\mp\_load::main();
+
+	maps\mp\_compass::setupMiniMap( "compass_map_mp_bloc" );
+
+	setdvar( "compassmaxrange", "2000" );
+	
+    ambientPlay( "ambient_trainer_ext2" ); 
+
+	game["attackers"] = "axis";
+	game["defenders"] = "allies";
+
+	// raise up planes to avoid them flying through buildings
+	level.airstrikeHeightScale = 1.8;
+	
+	setdvar( "r_specularcolorscale", "2" );
+}

iw4x/iw4x_00/maps/mp/mp_bloc_fx.gsc

@@ -0,0 +1,14 @@
+main()
+{
+	thread precache_createfx_fx();
+}
+
+precache_createfx_fx()
+{
+
+	level._effect[ "snow_light" ]		 = loadfx( "weather/snow_light_mp_bloc" );
+	level._effect[ "hallway_smoke" ]	 = loadfx( "smoke/hallway_smoke_light" );
+	level._effect[ "snow_wind" ]		 = loadfx( "weather/snow_wind" );
+	
+	maps\createfx\mp_bloc_fx::main();
+}

iw4x/iw4x_00/maps/mp/mp_bloc_sh.gsc

@@ -0,0 +1,23 @@
+main()
+{
+	maps\createart\mp_bloc_sh_art::main();
+	maps\mp\mp_bloc_sh_precache::main();
+	maps\createfx\mp_bloc_sh_fx::main();
+	maps\mp\mp_bloc_sh_fx::main();
+	maps\mp\_load::main();
+
+	maps\mp\_compass::setupMiniMap( "compass_map_mp_bloc_sh" );
+
+	setdvar( "compassmaxrange", "2000" );
+	
+    ambientPlay( "ambient_trainer_ext2" ); 
+
+	game["attackers"] = "axis";
+	game["defenders"] = "allies";
+
+	// raise up planes to avoid them flying through buildings
+	level.airstrikeHeightScale = 1.8;
+	
+	setdvar( "r_specularcolorscale", "2.2" );
+	setdvar( "r_diffusecolorscale", "1.2" );
+}

iw4x/iw4x_00/maps/mp/mp_bloc_sh_fx.gsc

@@ -0,0 +1,14 @@
+main()
+{
+	level._effect["hallway_smoke"]				        = loadfx ("smoke/hallway_smoke_dark");  
+    level._effect[ "room_dust_200_mp_vacant" ]	        = loadfx( "dust/room_dust_200_blend_mp_vacant" );	
+    level._effect[ "leaves_ground_gentlewind_dust" ]	= loadfx( "misc/leaves_ground_gentlewind_dust_sh" );
+    level._effect[ "dust_wind_slow_yel_loop" ]	        = loadfx( "dust/dust_wind_slow_yel_loop_sh" );
+    //level._effect[ "drips_player_hand" ]	            = loadfx( "water/drips_player_hand_sh" );
+    level._effect["water_spill_fall"]				    = loadfx("maps/mp_maps/fx_mp_water_spill"); 
+
+/#
+	if ( getdvar( "clientSideEffects" ) != "1" )
+		maps\createfx\mp_bloc_sh_fx::main();
+#/		
+}

iw4x/iw4x_00/maps/mp/mp_bloc_sh_precache.gsc

@@ -0,0 +1,12 @@
+// this file is autogenerated, modifying parameters is ok, other lines will be removed.
+main()
+{
+	maps\animated_models\foliage_red_pine_med_sh::main();
+	maps\animated_models\foliage_red_pine_lg_sh::main();
+	maps\animated_models\foliage_red_pine_xl_sh::main();
+	maps\animated_models\foliage_red_pine_xxl_sh::main();
+	maps\animated_models\hanging_apron_wind_medium::main();
+	maps\animated_models\hanging_longsleeve_wind_medium::main();
+	maps\animated_models\hanging_sheet_wind_medium::main();
+	maps\animated_models\hanging_shortsleeve_wind_medium::main();
+}

iw4x/iw4x_00/maps/mp/mp_bog_sh.gsc

@@ -0,0 +1,20 @@
+main()
+{
+	maps\mp\_load::main();
+
+	maps\mp\mp_bog_sh_fx::main();
+	maps\mp\mp_bog_sh_precache::main();
+	
+	maps\createfx\mp_bog_sh_fx::main();
+	maps\createart\mp_bog_sh_art::main();
+	
+	
+	maps\mp\_compass::setupMiniMap("compass_map_mp_bog_sh");
+
+	ambientPlay("ambient_crossfire");
+
+	game["attackers"] = "axis";
+	game["defenders"] = "allies";
+	
+	setDvar("compassmaxrange","1800");
+}

iw4x/iw4x_00/maps/mp/mp_bog_sh_fx.gsc

@@ -0,0 +1,16 @@
+main()
+{
+
+	level._effect["antiair_runner"]						= loadfx ("misc/antiair_runner_night");	
+	level._effect["fog_bog_a"]							= loadfx ("weather/fog_bog_a");
+	level._effect["firelp_barrel_pm"]					= loadfx ("fire/firelp_barrel_pm");
+	level._effect["mp_bog_horizon_flash"]				= loadfx ("ambient_runners/mp_bog_horizon_flash");
+	level._effect["battlefield_smokebank_S"]			= loadfx ("smoke/battlefield_smokebank_S");
+
+	
+/#
+	if ( getdvar( "clientSideEffects" ) != "1" )
+		maps\createfx\mp_bog_sh_fx::main();
+#/
+
+}

iw4x/iw4x_00/maps/mp/mp_bog_sh_precache.gsc

@@ -0,0 +1,8 @@
+// this file is autogenerated, modifying parameters is ok, other lines will be removed.
+main()
+{
+	common_scripts\_destructible_types_anim_airconditioner::main();
+	
+	maps\animated_models\foliage_tree_palm_bushy_1::main();
+	maps\animated_models\foliage_tree_palm_bushy_2::main();
+}

iw4x/iw4x_00/maps/mp/mp_cargoship.gsc

@@ -0,0 +1,22 @@
+main()
+{
+	maps\mp\_load::main();
+	maps\mp\mp_cargoship_fx::main();
+	
+	maps\createart\mp_cargoship_art::main();
+	maps\createfx\mp_cargoship_fx::main();
+	
+	ambientPlay( "ambient_mp_rain" );
+
+    game["attackers"] = "axis";
+    game["defenders"] = "allies";
+ 
+    maps\mp\_compass::setupMiniMap( "compass_map_mp_cargoship" );
+
+	setdvar( "r_specularcolorscale", "1.5" );
+	
+	level.airstrikeHeightScale = 2;
+
+	setdvar("compassmaxrange","2100");
+
+}

iw4x/iw4x_00/maps/mp/mp_cargoship_fx.gsc

@@ -0,0 +1,33 @@
+main()
+{
+	thread precache_createfx_fx();
+	if ( !getdvarint( "1106" ) )
+		maps\createfx\mp_cargoship_fx::main();
+}
+
+precache_createfx_fx()
+{
+
+	level._effect[ "wood" ]					 				= loadfx( "explosions/grenadeExp_wood" );
+	level._effect[ "dust" ]					 				= loadfx( "explosions/grenadeExp_dirt_1" );
+	level._effect[ "brick" ]								= loadfx( "explosions/grenadeExp_concrete_1" );
+	level._effect[ "coolaidmanbrick" ]		 				= loadfx( "explosions/grenadeExp_concrete_1" );
+
+	// rainfx
+	level._effect[ "rain_heavy_mist" ]		 				= loadfx( "weather/rain_mp_cargoship" );
+	level._effect[ "lightning" ]			 				= loadfx( "weather/lightning_mp_farm" );
+	level._effect[ "cgoshp_drips" ]			 				= loadfx( "misc/cgoshp_drips" );
+	level._effect[ "cgoshp_drips_a" ]		 				= loadfx( "misc/cgoshp_drips_a" );
+//	level._effect[ "rain_noise" ]		 					= loadfx( "weather/rain_noise" );
+//	level._effect[ "rain_noise_ud" ]		 				= loadfx( "weather/rain_noise_ud" );
+
+	level._effect[ "mp_cargoship_rain_noise01" ]			= loadfx( "ambient_runners/mp_cargoship_rain_noise01" );
+	level._effect[ "mp_cargoship_rain_noise02" ]			= loadfx( "ambient_runners/mp_cargoship_rain_noise02" );
+	level._effect[ "mp_cargoship_rain_noise03" ]			= loadfx( "ambient_runners/mp_cargoship_rain_noise03" );
+	level._effect[ "mp_cargoship_rain_noise04" ]			= loadfx( "ambient_runners/mp_cargoship_rain_noise04" );
+	level._effect[ "mp_cargoship_rain_noise05" ]			= loadfx( "ambient_runners/mp_cargoship_rain_noise05" );
+
+	level._effect[ "mp_cargoship_rain_noise_ud01" ]			= loadfx( "ambient_runners/mp_cargoship_rain_noise_ud01" );
+	level._effect[ "mp_cargoship_rain_noise_ud02" ]			= loadfx( "ambient_runners/mp_cargoship_rain_noise_ud02" );
+	level._effect[ "mp_cargoship_rain_noise_ud03" ]			= loadfx( "ambient_runners/mp_cargoship_rain_noise_ud03" );	
+}

iw4x/iw4x_00/maps/mp/mp_cargoship_sh.gsc

@@ -0,0 +1,19 @@
+main()
+{
+	maps\mp\_load::main();
+	maps\mp\mp_cargoship_sh_fx::main();
+	
+	maps\createart\mp_cargoship_sh_art::main();
+	maps\createfx\mp_cargoship_sh_fx::main();
+	
+	ambientPlay( "ambient_mp_snow" );
+	
+	game["attackers"] = "axis";
+	game["defenders"] = "allies";
+	
+	maps\mp\_compass::setupMiniMap("compass_map_mp_cargoship_sh");
+	
+	level.airstrikeHeightScale = 2;
+	
+	setdvar("compassmaxrange","2100");
+}

iw4x/iw4x_00/maps/mp/mp_cargoship_sh_fx.gsc

@@ -0,0 +1,37 @@
+main()
+{
+	thread precache_createfx_fx(); 	
+}
+
+precache_createfx_fx()
+{
+
+	level._effect["snow_medium_2"]					= loadfx ("snow/snow_medium_2");	
+	level._effect["snow_wind_sh"]							= loadfx ("snow/snow_wind_sh");
+	level._effect["mp_cargoship_rain_noise01"]			= loadfx ("ambient_runners/mp_cargoship_rain_noise01");
+	level._effect["mp_cargoship_rain_noise02"]			= loadfx ("ambient_runners/mp_cargoship_rain_noise02");
+	level._effect["mp_cargoship_rain_noise03"]			= loadfx ("ambient_runners/mp_cargoship_rain_noise03");
+	level._effect["mp_cargoship_rain_noise04"]			= loadfx ("ambient_runners/mp_cargoship_rain_noise04");
+	level._effect["mp_cargoship_rain_noise05"]			= loadfx ("ambient_runners/mp_cargoship_rain_noise05");
+	level._effect["mp_cargoship_rain_noise_ud01"]		= loadfx ("ambient_runners/mp_cargoship_rain_noise_ud01");
+	level._effect["mp_cargoship_rain_noise_ud02"]		= loadfx ("ambient_runners/mp_cargoship_rain_noise_ud02");
+	level._effect["mp_cargoship_rain_noise_ud03"]		= loadfx ("ambient_runners/mp_cargoship_rain_noise_ud03");
+	level._effect["cgoshp_drips_a"]						= loadfx ("misc/cgoshp_drips_a");
+	level._effect["cgoshp_drips"]						= loadfx ("misc/cgoshp_drips");
+	
+	level._effect["snow_light"]						= loadfx ("snow/snow_light");
+	level._effect["snow_light_cargoship_sh"]					= loadfx ("snow/snow_light_cargoship_sh");
+	level._effect["snow_spiral_runner_sh"]				= loadfx ("snow/snow_spiral_runner_sh");
+	level._effect["snow_spray_detail_oriented_runner_sh"]				= loadfx ("snow/snow_spray_detail_oriented_runner_sh");
+	level._effect["snow_spray_detail_oriented_large_runner_sh"]				= loadfx ("snow/snow_spray_detail_oriented_large_runner_sh");
+	level._effect["snow_spray_detail_oriented_runner_400x400_sh"]				= loadfx ("snow/snow_spray_detail_oriented_runner_400x400_sh");
+	level._effect[ "tree_snow_fallen_heavy" ]						= loadfx( "snow/tree_snow_fallen_heavy" );
+	level._effect[ "tree_snow_dump" ]								= loadfx( "snow/tree_snow_dump_sh" );
+	level._effect[ "tree_snow_fallen_small" ]						= loadfx( "snow/tree_snow_fallen_small" );
+	level._effect[ "snow_clouds_sh" ]						= loadfx( "snow/snow_clouds_sh" );
+	level._effect["fire_cargo"]		          = loadfx ("fire/fire_cargo");
+	level._effect["red_light"]		          = loadfx ("fire/red_light");
+	level._effect["codo_fx_ray_ceiling_amber_dim_sm"]		          = loadfx ("env/light/codo_fx_ray_ceiling_amber_dim_sm");
+	level._effect["codo_fx_ray_ceiling_amber_dim_sm01"]		          = loadfx ("env/light/codo_fx_ray_ceiling_amber_dim_sm01");
+	level._effect["cargo_redlight"]		          = loadfx ("env/light/cargo_redlight");
+}

iw4x/iw4x_00/maps/mp/mp_crash_tropical.gsc

@@ -0,0 +1,24 @@
+main()
+{
+	maps\mp\mp_crash_tropical_fx::main();
+	maps\createfx\mp_crash_tropical_fx::main();
+	maps\mp\mp_crash_tropical_precache::main();
+	maps\createart\mp_crash_tropical_art::main();
+	
+	maps\mp\_load::main();
+
+	maps\mp\_compass::setupMiniMap( "compass_map_mp_crash_dlc" );
+	setdvar( "compassmaxrange", "1600" );
+	
+	AmbientPlay( "ambient_mp_favela" );
+
+	game["attackers"] = "axis";
+	game["defenders"] = "allies";
+
+	setdvar( "r_specularcolorscale", "2.117" );
+	setdvar( "r_diffusecolorscale", "1.35" );
+	
+	setdvar( "r_lightGridEnableTweaks", 1 );
+	setdvar( "r_lightGridIntensity", 1.10 );
+	setdvar( "r_lightGridContrast", 1 );
+}

iw4x/iw4x_00/maps/mp/mp_crash_tropical_fx.gsc

@@ -0,0 +1,36 @@
+main()
+{
+
+	level._effect[ "firelp_med_pm" ]				 = loadfx( "fire/firelp_med_pm_nodistort" );
+	level._effect[ "firelp_small_pm" ]				 = loadfx( "fire/firelp_small_pm" );
+	level._effect[ "fog_ground_200_heavy_rundown_tropical" ]				 = loadfx( "smoke/fog_ground_200_heavy_rundown_tropical" );
+	level._effect[ "rain_mp_storm" ]				     = loadfx( "weather/rain_mp_storm" );
+	level._effect[ "firelp_small_pm_a" ]			 = loadfx( "fire/firelp_small_pm_a" );
+	level._effect[ "dust_wind_fast" ]				 = loadfx( "dust/dust_wind_fast_paper_tropical" );
+	level._effect[ "dust_wind_slow" ]				 = loadfx( "dust/dust_wind_slow_paper_tropical" );
+	level._effect[ "dust_wind_spiral" ]				 = loadfx( "misc/trash_spiral_runner_tropical" );
+	level._effect[ "moth_runner" ]				     = loadfx( "misc/moth_runner" );
+	level._effect[ "battlefield_smokebank_S" ]		 = loadfx( "smoke/battlefield_smokebank_S_tropical" );
+	level._effect[ "hallway_smoke_light" ]			 = loadfx( "smoke/hallway_smoke_light" );
+	//level._effect[ "extraction_smoke" ] = loadfx( "smoke/signal_smoke_green" );
+	
+	/*
+	//level._effect[ "airplane_crash_embers" ] 		= LoadFX( "fire/airplane_crash_embers" );
+	//level._effect[ "firelp_small_pm_a_nolight" ] 	= LoadFX( "fire/firelp_small_pm_a_nolight" );
+	//level._effect[ "firelp_small_pm_nolight" ] 		= LoadFX( "fire/firelp_small_pm_nolight" );
+	//level._effect["firelp_med_pm"]					= LoadFX( "fire/firelp_med_pm");
+	//level._effect[ "ground_fog" ] 							= LoadFX( "dust/ground_fog" );
+	//level._effect[ "ground_fog_a" ] 						= LoadFX( "dust/ground_fog_a" );
+	//level._effect[ "ground_fog_b" ] 						= LoadFX( "dust/ground_fog_b" );
+	//level._effect[ "missile_explosion" ]				 = loadfx( "explosions/small_vehicle_explosion" );
+	//level._effect[ "player_death_explosion" ]			= loadfx( "explosions/player_death_explosion" );
+	//level._effect[ "green_flare" ] 								= loadfx( "misc/handflare_green" );
+	*/
+	
+ /#
+	if ( common_scripts\utility::shouldRunServerSideEffects() )
+		maps\createfx\mp_crash_tropical_fx::main();
+ 
+#/
+
+}

iw4x/iw4x_00/maps/mp/mp_crash_tropical_precache.gsc

@@ -0,0 +1,18 @@
+// this file is autogenerated, modifying parameters is ok, other lines will be removed.
+main()
+{
+	common_scripts\_destructible_types_anim_light_fluo_single::main();
+	
+	//maps\animated_models\foliage_tree_palm_tall_3::main();
+	maps\animated_models\foliage_tree_palm_med_1::main();
+	maps\animated_models\foliage_tree_palm_med_2::main();
+	maps\animated_models\foliage_tree_palm_med_2_tropical::main();
+	maps\animated_models\foliage_pacific_fern01::main();
+	maps\animated_models\foliage_tree_palm_bushy_3::main();
+	maps\animated_models\foliage_pacific_palms06::main();
+	
+	maps\animated_models\hanging_apron_wind_medium::main();
+	maps\animated_models\hanging_sheet_wind_medium::main();
+	maps\animated_models\hanging_longsleeve_wind_medium::main();
+	maps\animated_models\hanging_shortsleeve_wind_medium::main();
+}

iw4x/iw4x_00/maps/mp/mp_cross_fire.gsc

@@ -0,0 +1,21 @@
+main()
+{
+	maps\mp\_load::main();
+	
+	maps\mp\mp_cross_fire_fx::main();
+	maps\mp\mp_cross_fire_precache::main();
+	
+	maps\createfx\mp_cross_fire_fx::main();
+	maps\createart\mp_cross_fire_art::main();
+	
+	maps\mp\_compass::setupMiniMap( "compass_map_mp_cross_fire" );
+	
+	ambientPlay("ambient_trainer_ext2");
+	
+	game[ "attackers" ] = "axis";
+	game[ "defenders" ] = "allies";
+	
+	setdvar( "r_specularcolorscale", "4.5" );
+
+	setdvar( "compassmaxrange", "2100" );
+}

iw4x/iw4x_00/maps/mp/mp_cross_fire_fx.gsc

@@ -0,0 +1,26 @@
+main()
+{
+	level._effect[ "wood" ]				 = loadfx( "explosions/grenadeExp_wood" );
+	level._effect[ "dust" ]				 = loadfx( "explosions/grenadeExp_dirt_1" );
+	level._effect[ "brick" ]			 = loadfx( "explosions/grenadeExp_concrete_1" );
+	
+	//Ambient FX
+	level._effect["paper_falling"]						= loadfx( "misc/paper_falling" );
+	level._effect["battlefield_smokebank_S"]			= loadfx( "smoke/battlefield_smokebank_S" );
+	level._effect["thin_black_smoke_M"]					= loadfx( "smoke/thin_black_smoke_M" );
+	level._effect["thin_black_smoke_L"]					= loadfx( "smoke/thin_black_smoke_L" );
+	level._effect["dust_wind_slow"]						= loadfx( "dust/dust_wind_slow_yel_loop" );
+	
+/#		
+	if ( getdvar( "clientSideEffects" ) != "1" )
+		maps\createfx\mp_cross_fire_fx::main();
+#/
+}
+
+/*
+/#		
+	if ( common_scripts\utility::shouldRunServerSideEffects() )
+		maps\createfx\mp_cross_fire_fx::main();
+#/
+}
+*/

iw4x/iw4x_00/maps/mp/mp_cross_fire_precache.gsc

@@ -0,0 +1,10 @@
+// this file is autogenerated, modifying parameters is ok, other lines will be removed.
+main()
+{
+
+	common_scripts\_destructible_types_anim_airconditioner::main();
+
+	maps\animated_models\foliage_tree_palm_bushy_1::main();
+	maps\animated_models\foliage_tree_palm_tall_1::main();
+	
+}

iw4x/iw4x_00/maps/mp/mp_estate_tropical.gsc

@@ -0,0 +1,29 @@
+main()
+{
+
+	maps\mp\_load::main();
+	
+	maps\mp\mp_estate_tropical_fx::main();
+	maps\mp\mp_estate_tropical_precache::main();
+	maps\mp\_compass::setupMiniMap( "compass_map_mp_estate_tropical" );
+	
+	maps\createart\mp_estate_tropical_art::main();
+
+
+	
+	ambientPlay( "ambient_mp_estate" );
+
+	game[ "attackers" ] = "allies";
+	game[ "defenders" ] = "axis";
+
+	setdvar( "r_specularcolorscale", "3" );
+	setdvar( "r_diffusecolorscale", "1.5" );
+	setdvar( "sm_sunsamplesizenear", "0.38" );
+	
+	setdvar( "compassmaxrange", "3500" );
+	
+	setdvar( "r_lightGridEnableTweaks", 1 );
+	setdvar( "r_lightGridIntensity", 1.3 );
+	setdvar( "r_lightGridContrast", 0 );
+
+}

iw4x/iw4x_00/maps/mp/mp_estate_tropical_fx.gsc

@@ -0,0 +1,22 @@
+main()
+{
+	//ambient fx
+	level._effect[ "moth_runner" ]									 = loadfx( "misc/moth_runner" );
+	level._effect[ "insect_trail_runner_icbm" ]						 = loadfx( "misc/insect_trail_runner_icbm" );
+	level._effect[ "leaves_ground_gentlewind_codo" ]				 = loadfx( "misc/leaves_ground_gentlewind_codo" );
+	level._effect[ "leaves_fall_gentlewind_codo" ]				     = loadfx( "misc/leaves_fall_gentlewind_codo" );
+
+	level._effect[ "insects_carcass_runner" ]						= loadfx( "misc/insects_carcass_runner" );
+	level._effect[ "waterfall_drainage_splash" ] 					= loadfx( "water/waterfall_drainage_splash_estate" );
+	level._effect[ "waterfall_splash_large" ] 						= loadfx( "water/waterfall_splash_large_estate" );
+	level._effect[ "waterfall_splash_large_drops" ]					= loadfx( "water/waterfall_splash_large_drops_estate" );
+	level._effect[ "falling_water_trickle" ]	 					= loadfx( "water/falling_water_trickle" );
+
+	level._effect[ "hallway_smoke_light" ]							= loadfx( "smoke/hallway_smoke_light" );
+
+/#
+	if ( getdvar( "clientSideEffects" ) != "1" )
+		maps\createfx\mp_estate_tropical_fx::main();
+#/
+
+}

iw4x/iw4x_00/maps/mp/mp_estate_tropical_precache.gsc

@@ -0,0 +1,25 @@
+// this file is autogenerated, modifying parameters is ok, other lines will be removed.
+main()
+{
+	
+	common_scripts\_destructible_types_anim_generator::main();
+	common_scripts\_destructible_types_anim_wallfan::main();
+	
+	maps\animated_models\foliage_tropical_estate_1::main();
+	maps\animated_models\foliage_codo_short_palm_1::main();
+	maps\animated_models\foliage_codo_plantain_1::main();
+	maps\animated_models\foliage_palm_bare_3::main();
+	maps\animated_models\foliage_palm_bare_2::main();
+	maps\animated_models\foliage_palm_bare_1::main();
+
+	/*
+	foliage_tropical_estate_sway
+	foliage_palm_bare_3_sway
+	foliage_palm_bare_2_sway
+	foliage_palm_bare_1_sway
+	foliage_palm_tree_1_sway
+	foliage_codo_short_palm_1_sway
+	foliage_codo_plantain_sway
+	*/
+
+}

iw4x/iw4x_00/maps/mp/mp_fav_tropical.gsc

@@ -0,0 +1,31 @@
+main()
+{
+	maps\mp\mp_fav_tropical_precache::main();
+
+	maps\createart\mp_fav_tropical_art::main();
+	maps\mp\mp_fav_tropical_fx::main();
+
+	maps\mp\_load::main();
+
+	maps\mp\_compass::setupMiniMap( "compass_map_mp_fav_tropical" );
+
+	// raise up planes to avoid them flying through buildings
+	level.airstrikeHeightScale = 1.5;
+
+	ambientPlay( "ambient_mp_favela" );
+
+	switch ( level.gameType )
+	{	
+		case "oneflag":
+			game[ "attackers" ] = "allies";
+			game[ "defenders" ] = "axis";
+			break;
+		default:
+			game[ "attackers" ] = "axis";
+			game[ "defenders" ] = "allies";
+			break;
+	}
+
+	setdvar( "r_specularcolorscale", "2.8" );
+	setdvar( "compassmaxrange", "1500" );
+}

iw4x/iw4x_00/maps/mp/mp_fav_tropical_fx.gsc

@@ -0,0 +1,22 @@
+main()
+{
+	//ambient fx
+	level._effect[ "insects_carcass_runner" ]			= loadfx( "misc/insects_carcass_runner" );
+
+	level._effect[ "firelp_med_pm" ]					= loadfx( "fire/firelp_med_pm" );
+	level._effect[ "firelp_small_pm" ]				 	= loadfx( "fire/firelp_small_pm" );
+	level._effect[ "firelp_small_pm_a" ]				= loadfx( "fire/firelp_small_pm_a" );
+
+	level._effect[ "trash_spiral_runner" ]				= loadfx( "misc/trash_spiral_runner" );
+	level._effect[ "leaves_fall_gentlewind" ]		 	= loadfx( "misc/leaves_fall_gentlewind" );
+
+	level._effect[ "hallway_smoke_light" ]				= loadfx( "smoke/hallway_smoke_light" );
+	level._effect[ "room_smoke_200" ]					= loadfx( "smoke/room_smoke_200" );
+	
+
+/#
+	if ( getdvar( "clientSideEffects" ) != "1" )
+		maps\createfx\mp_fav_tropical_fx::main();
+#/
+
+}

iw4x/iw4x_00/maps/mp/mp_fav_tropical_precache.gsc

@@ -0,0 +1,16 @@
+// this file is autogenerated, modifying parameters is ok, other lines will be removed.
+main()
+{
+
+	common_scripts\_destructible_types_anim_airconditioner::main();
+	common_scripts\_destructible_types_anim_light_fluo_single::main();
+	common_scripts\_destructible_types_anim_me_fanceil1_spin::main();
+	
+	maps\animated_models\foliage_palm_tree_1::main();
+	maps\animated_models\foliage_codo_short_palm_1::main();
+	maps\animated_models\hanging_apron_wind_medium::main();
+	maps\animated_models\hanging_longsleeve_wind_medium::main();
+	maps\animated_models\hanging_sheet_wind_medium::main();
+	maps\animated_models\hanging_shortsleeve_wind_medium::main();
+	
+}

iw4x/iw4x_00/maps/mp/mp_firingrange.gsc

@@ -0,0 +1,458 @@
+#include maps\mp\_utility;
+#include common_scripts\utility;
+
+main()
+{
+	maps\mp\_load::main();
+	
+	maps\mp\mp_firingrange_fx::main();
+	maps\createart\mp_firingrange_art::main();
+	maps\createfx\mp_firingrange_fx::main();
+	
+	maps\mp\_explosive_barrels::main();
+	
+	ambientPlay( "ambient_mp_estate" );
+	
+	maps\mp\_compass::setupMiniMap("compass_map_mp_firingrange");
+	
+	setdvar ( "r_diffusecolorscale", "1.5");
+
+	/****** GET ENTITIES ******/
+	//TRIGGERS
+	alleyTrigger = getent("alleyTrigger","targetname");
+	windowTrigger = getent("triggerwindowTarget","targetname");
+
+	//TARGETS
+	target1 = getent("fieldTarget_BackLeft","targetname");	
+	target2 = getent("fieldTarget_FrontLeft","targetname");	
+	target3 = getent("fieldTarget_Middle","targetname");
+	target4 = getent("fieldTarget_BackRight","targetname");
+	target5 = getent("fieldTarget_FrontRight","targetname");
+	target6 = getent("trenchTarget_GroundWall","targetname");
+	target7 = getent("trailerTarget_Window","targetname");
+	target8 = getent("alleyTarget_Cover","targetname");
+	target9 = getent("alleyTarget_Path","targetname");
+	target10 = getent("centerTarget_Sandbags","targetname");
+	target11 = getent("towerTarget_Front","targetname");
+	target12 = getent("towerTarget_Back","targetname");
+	target13 = getent("centerTarget_Path","targetname");
+	target14 = getent("centerTarget_PathBunkerL","targetname");
+	target15 = getent("centerTarget_PathBunkerR","targetname");
+	target16 = getent("steelBuildingTarget_Slide1","targetname");
+	target17 = getent("steelBuildingTarget_PopUp","targetname");
+	target18 = getent("target_alleyWindow1","targetname");
+	target19 = getent("target_alleyWindow2","targetname");
+	target20 = getent("target_alleyWindow3","targetname");
+
+	//TARGET LIGHTs
+
+	//Props
+	targetLight1_off = getent("steelBuildingTargetLight1_off", "targetname");
+	targetLight1_on = getent("steelBuildingTargetLight1_on", "targetname");
+
+	targetLight2_off = getent("steelBuildingTargetLight2_off", "targetname");
+	targetLight2_on = getent("steelBuildingTargetLight2_on", "targetname");
+
+	//Lights
+
+	level.const_fx_exploder_red_light_1 = 1001;
+	level.const_fx_exploder_red_light_2 = 1002;
+
+	//LOUDSPEAKERS
+	speaker1 = getent("loudspeaker1", "targetname");
+	speaker2 = getent("loudspeaker2", "targetname");
+
+	//PROPANE TANKS
+	/*propaneTank1 = getent("explodingPropaneTank","targetname");
+	propaneTank2 = getent("explodingPropaneTank2","targetname");
+	propaneTank3 = getent("explodingPropaneTank3","targetname");*/
+
+	/****** HIDE ON TARGET LIGHTS ******/
+	//Keep the on versions of the light model hidden until appropriate target takes damage.
+	targetLight1_on Hide();
+	targetLight2_on Hide();
+
+	/****** DAMAGE OBJECTS ********/
+
+	//TARGETS
+	target1 SetCanDamage(true);
+	target2 SetCanDamage(true);
+	target3 SetCanDamage(true);
+	target4 SetCanDamage(true);
+	target5 SetCanDamage(true);
+	target8 SetCanDamage(true);
+	target9 SetCanDamage(true);
+	target10 SetCanDamage(true);
+	target13 SetCanDamage(true);
+	target14 SetCanDamage(true);
+	target15 SetCanDamage(true);
+	target16 SetCanDamage(true);
+	target17 SetCanDamage(true);
+	target18 SetCanDamage(true);
+	target19 SetCanDamage(true);
+	target20 SetCanDamage(true);
+	
+	target1 thread damageTarget(1);
+	target2 thread damageTarget(1);
+	target3 thread damageTarget(1);
+	target4 thread damageTarget(1);
+	target5 thread damageTarget(1);
+	target8 thread damageTarget(2);
+	target9 thread damageTarget(2);
+	target10 thread damageTarget(2);
+	target13 thread damageTarget(2);
+	target14 thread damageTarget(3);
+	target15 thread damageTarget(3);
+	//target16 thread damageTargetLights(targetLight1_on, targetLight1_off, speaker1, "amb_target_buzzer", level.const_fx_exploder_red_light_2 );
+	//target17 thread damageTargetLights(targetLight2_on, targetLight2_off, speaker2, "amb_target_buzzer", level.const_fx_exploder_red_light_1 );
+	target18 thread damageTarget(4);
+	target19 thread damageTarget(4);
+	target20 thread damageTarget(5);
+
+	//PROPANE TANKS
+	/*propaneTank1 SetCanDamage(true);
+	propaneTank2 SetCanDamage(true);
+	propaneTank3 SetCanDamage(true);
+
+	propaneTank1 thread damagePropaneTank("mpl_kls_artillery_impact");
+	propaneTank2 thread damagePropaneTank("mpl_kls_artillery_impact");
+	propaneTank3 thread damagePropaneTank("mpl_kls_artillery_impact");*/
+
+	
+	/****** MOVE TARGETS ******/
+	//Sliding Targets
+	target1 thread moveTarget(4, 220, 10.1);	
+	target2 thread moveTarget(4, 220, 5.2);	
+	target3 thread moveTarget(4, 220, 10.3);	
+	target4 thread moveTarget(3, 290, 8.4);	
+	target5 thread moveTarget(3, 285, 3);
+	target6 thread moveTarget(1, 228, 8.1);
+	target7 thread moveTarget(7, (57, 23, 0), 3);
+	target8 thread moveTarget(1, 250, 5.5);
+	target9 thread moveTarget(1, 146, 8.6);
+	target10 thread moveTarget(1, 165, 8.7);
+	target11 thread moveTarget(4, 136, 5.05);
+	target12 thread moveTarget(3, 136, 7.15);
+	target13 thread moveTarget(1, 228, 8.25);
+	target16 thread moveTarget(4, 164, 5.35);
+	target17 thread moveTarget(5, 48, 5.45);
+	target18 thread moveTarget(3, 270, 8.55);
+	target19 thread moveTarget(6, 70, 6.65);
+	target20 thread moveTarget(1, 130, 5.75);
+
+
+
+	//Hinge Targets
+	//targetHinge1 thread rotateTarget(2, 90, 0.5, 3);	//-Z direction, 90 degrees, in .5 seconds, wait inbetween for 3 seconds.
+	target11 thread rotateTarget(2, 90, 0.5, 2);
+	target12 thread rotateTarget(1, 90, 0.7, 3);
+
+	//TRIGGERS
+	target9.triggeroff = true;
+	alleyTrigger thread triggerCheck(target9);
+	target7.triggeroff = true;
+	windowTrigger thread triggerCheck(target7);
+}
+
+triggerCheck(target)
+{
+	self endon("game_ended");
+	while(1)
+	{
+		self waittill("trigger", player);
+
+		//If the target is close enough to the player to cause a possible issue, tell the target to go back the other direction.
+		distance = Distance(target.origin, self.origin);
+		if(distance <= 90)
+		{
+			if( isDefined(target.triggeroff))
+				target.triggeroff = false; //Stop the target.
+
+			target notify("targetStopMoving");
+
+			while( isdefined( player) && player isTouching(self) && distance <= 90)
+			{
+				wait 0.1;
+			}
+			if( isDefined(target.triggeroff))
+				target.triggeroff = true; //Start the target.
+
+			target notify("targetStopMoving");
+		}
+	}
+}
+
+damageTarget(dir)
+{
+	self endon("game_ended");
+	while(1)
+	{
+		self waittill("damage", damage, attacker, direction);
+
+		switch(dir)
+		{
+		case 1:
+			self rotateroll(self.angles[1] + 90, .1);
+			wait(.2);
+			self rotateroll(self.angles[1] - 90, .1);
+			wait(.2);
+			self PlaySound ("amb_target_flip");
+			break;
+		case 2:
+		{
+			rotation = 1;
+			if ( isdefined( attacker ) && isPlayer( attacker ) )
+			{
+				//yaw = get2DYaw( attacker.origin, self.origin );
+				//if ( attacker.angles[1] > yaw ) 
+				//	rotation = -1;
+				
+			}
+			
+			self rotateyaw(self.angles[2] + (180 * rotation), .3);
+			self PlaySound ("amb_target_twirl");
+			self waittill("rotatedone");
+		}
+			break;
+		case 3:
+			self rotatepitch(self.angles[1] + 90, .1);
+			wait(.2);
+			self rotatepitch(self.angles[1] - 90, .1);
+			wait(.2);
+			self PlaySound ("amb_target_flip");
+			break;
+		case 4:
+			self rotateroll(self.angles[1] - 90, .1);
+			wait(.2);
+			self rotateroll(self.angles[1] + 90, .1);
+			wait(.2);
+			self PlaySound ("amb_target_flip");
+			break;
+		case 5:
+			self rotatepitch(self.angles[1] - 90, .1);
+			wait(.2);
+			self rotatepitch(self.angles[1] + 90, .1);
+			wait(.2);
+			self PlaySound ("amb_target_flip");
+			break;
+
+		}
+	}
+}
+
+//Pass in one of the following to define the start direction of the target: 1 for +y, 2 for -y, 3 for +x, 4 for -x, 5 for +Z, 6 for -Z.
+//Pass in the distance in units the target is to travel.
+//Pass in the ammount of time in seconds that it will take the target to travel that distance.
+moveTarget(dir, dis, speed)
+{
+	self endon("game_ended");
+	keepMoving = true;	//Local var to decide if the target needs to be paused or not.
+
+	//Get the targets starting position or nearPos
+	startPOS = self.origin;
+	//Find out the targets far position.
+	FarPOS = self.origin;
+	
+	sound = Spawn ("script_origin", self.origin);
+	sound LinkTo(self);
+	sound PlayLoopSound ("amb_target_chain");
+	
+	switch(dir)
+	{
+	case 1://+Y
+		farPOS = self.origin + (0,dis,0);
+		break;
+	case 2://-Y
+		farPOS = self.origin - (0,dis,0);
+		break;
+	case 3://+X
+		farPOS = self.origin + (dis,0,0);
+		break;
+	case 4://-X
+		farPOS = self.origin - (dis,0,0);
+		break;
+	case 5://+Z
+		farPOS = self.origin + (0,0,dis);
+		break;
+	case 6://-Z
+		farPOS = self.origin - (0,0,dis);
+		break;
+	case 7://Custom
+		farPOS = self.origin - dis;
+		break;
+	}
+	
+	//Move the target
+	while(1)
+	{
+		if( isDefined(self.triggeroff)) //Does the target have the Key triggeroff? If so, set keepMoving to its value.
+			keepMoving = self.triggeroff;
+
+		switch(dir)
+		{
+		case 1: //+Y
+			self moveto(farPOS, speed);
+			self waittill_any("movedone","targetStopMoving");
+			self PlaySound ("amb_target_stop");
+
+			if( isDefined(self.triggeroff)) //Does the target have the Key triggeroff? If so, set keepMoving to its value.
+				keepMoving = self.triggeroff;
+
+			if(keepMoving == false)
+				break;
+			self moveto(startPOS, speed);
+			self waittill_any("movedone","targetStopMoving");
+			self PlaySound ("amb_target_stop");
+			break;
+		case 2: //-Y
+			self moveto(farPOS, speed);
+			self waittill_any("movedone","targetStopMoving");
+			self PlaySound ("amb_target_stop");
+
+			if( isDefined(self.triggeroff)) //Does the target have the Key triggeroff? If so, set keepMoving to its value.
+				keepMoving = self.triggeroff;
+
+			if(keepMoving == false)
+				break;
+			self moveto(startPOS, speed);
+			self waittill_any("movedone","targetStopMoving");
+			self PlaySound ("amb_target_stop");
+			break;
+		case 3: //+X
+			self moveto(farPOS, speed);
+			self waittill_any("movedone","targetStopMoving");
+			self PlaySound ("amb_target_stop");
+
+			if( isDefined(self.triggeroff)) //Does the target have the Key triggeroff? If so, set keepMoving to its value.
+				keepMoving = self.triggeroff;
+
+			if(keepMoving == false)
+				break;
+			self moveto(startPOS, speed);
+			self waittill_any("movedone","targetStopMoving");
+			self PlaySound ("amb_target_stop");
+			break;
+		case 4: //-X
+			self moveto(farPOS, speed);
+			self waittill_any("movedone","targetStopMoving");
+			self PlaySound ("amb_target_stop");
+
+			if( isDefined(self.triggeroff)) //Does the target have the Key triggeroff? If so, set keepMoving to its value.
+				keepMoving = self.triggeroff;
+
+			if(keepMoving == false)
+				break;
+			self moveto(startPOS, speed);
+			self waittill_any("movedone","targetStopMoving");
+			self PlaySound ("amb_target_stop");
+			break;
+		case 5: //+Z
+			self moveto(farPOS, speed);
+			self waittill_any("movedone","targetStopMoving");
+			self PlaySound ("amb_target_stop");
+
+			if( isDefined(self.triggeroff)) //Does the target have the Key triggeroff? If so, set keepMoving to its value.
+				keepMoving = self.triggeroff;
+
+			if(keepMoving == false)
+				break;
+			self moveto(startPOS, speed);
+			self waittill_any("movedone","targetStopMoving");
+			self PlaySound ("amb_target_stop");
+			break;
+		case 6: //-Z
+			self moveto(farPOS, speed);
+			self waittill_any("movedone","targetStopMoving");
+			self PlaySound ("amb_target_stop");
+			if( isDefined(self.triggeroff)) //Does the target have the Key triggeroff? If so, set keepMoving to its value.
+				keepMoving = self.triggeroff;
+
+			if(keepMoving == false)
+				break;
+			self moveto(startPOS, speed);
+			self waittill_any("movedone","targetStopMoving");
+			self PlaySound ("amb_target_stop");
+			break;
+		case 7: //Custom
+			if(keepMoving == false)
+				self waittill("targetStopMoving"); //Wait here till the player leaves the trigger.
+
+			self moveto(farPOS, speed);
+			self waittill_any("movedone","targetStopMoving");
+			self PlaySound ("amb_target_stop");
+			if( isDefined(self.triggeroff)) //Does the target have the Key triggeroff? If so, set keepMoving to its value.
+				keepMoving = self.triggeroff;
+
+			if(keepMoving == false)
+				self waittill("targetStopMoving"); //Wait here till the player leaves the trigger.
+			self moveto(StartPOS, speed);
+			self waittill_any("movedone","targetStopMoving");
+			self PlaySound ("amb_target_stop");
+		
+			
+		}
+	}
+}
+
+
+rotateTarget(dir, deg, speed, pauseTime)
+{
+	self endon("game_ended");
+	while(1)
+	{
+		switch(dir)
+		{
+		case 1:	//+Z
+			self rotateyaw(self.angles[2] + deg, speed);
+			self PlaySound ("amb_target_rotate");
+			wait(pauseTime);
+			self rotateyaw(self.angles[2] - deg, speed);
+			self PlaySound ("amb_target_rotate");
+			wait(pauseTime);
+			break;
+		case 2: //-Z
+			self rotateyaw(self.angles[2] - deg, speed);
+			self PlaySound ("amb_target_rotate");
+			wait(pauseTime);
+			self rotateyaw(self.angles[2] + deg, speed);
+			self PlaySound ("amb_target_rotate");
+			wait(pauseTime);
+			break;
+		case 3: //+X
+			self rotateroll(self.angles[0] + deg, speed);
+			self PlaySound ("amb_target_rotate");
+			wait(pauseTime);
+			self rotateroll(self.angles[0] - deg, speed);
+			self PlaySound ("amb_target_rotate");
+			wait(pauseTime);
+			break;
+		case 4: //-X
+			self rotateroll(self.angles[0] - deg, speed);
+			self PlaySound ("amb_target_rotate");
+			wait(pauseTime);
+			self rotateroll(self.angles[0] + deg, speed);
+			self PlaySound ("amb_target_rotate");
+			wait(pauseTime);
+			break;
+		case 5: //+Y
+			self rotateroll(self.angles[1] + deg, speed);
+			self PlaySound ("amb_target_rotate");
+			wait(pauseTime);
+			self rotateroll(self.angles[1] - deg, speed);
+			self PlaySound ("amb_target_rotate");
+			wait(pauseTime);
+			break;
+		case 6: //-Y
+			self rotatepitch(self.angles[1] - deg, speed);
+			wait(pauseTime);
+			self rotatepitch(self.angles[1] + deg, speed);
+			wait(pauseTime);
+			break;
+		case 7: //Custom
+			self rotateto( (self.angles[0] + 90, self.angles[1] - 90, self.angles[2] + 45), speed);
+			wait(pauseTime);
+			self rotateto( (self.angles[0] - 90, self.angles[1] + 90, self.angles[2] - 45), speed);
+			wait(pauseTime);
+		}
+	}
+}

iw4x/iw4x_00/maps/mp/mp_firingrange_fx.gsc

@@ -0,0 +1,49 @@
+#include maps\mp\_utility; 
+
+// Scripted effects
+precache_scripted_fx()
+{
+	//level._effect["rocket_blast_trail"]								= loadfx("vehicle/exhaust/fx_russian_rocket_exhaust_mp");
+	//level._effect["mig_trail"]												= loadfx("trail/fx_geotrail_jet_contrail");
+	//level._effect["rocket_explosion"]									= loadfx("maps/flashpoint/fx_exp_rocket_soyuz");
+}
+
+precache_createfx_fx()
+{
+
+//	level._effect["fx_mp_sand_dust_devil"]								= loadfx("maps/mp_maps/fx_mp_sand_dust_devil");
+	
+	level._effect["fx_mp_sand_blowing_lg_slow"]						= loadfx("maps/mp_maps/fx_mp_sand_blowing_lg_slow");	
+	
+	level._effect["fx_sand_windy_slow_door_os"]						= loadfx("maps/mp_maps/fx_mp_sand_windy_slow_door_os");
+	level._effect["fx_sand_windy_heavy_sm_slow"]					= loadfx("maps/mp_maps/fx_mp_sand_windy_heavy_sm_slow");
+	level._effect["fx_mp_sand_windy_pcloud_lg_slow"]			= loadfx("maps/mp_maps/fx_mp_sand_windy_pcloud_lg_slow_dense");
+
+	level._effect["fx_smk_plume_md_wht_wispy"]						= loadfx("maps/mp_maps/fx_mp_smk_plume_md_wht_wispy");
+
+	level._effect["fx_mp_distortion_heat_field_lg"]				= loadfx("maps/mp_maps/fx_mp_distortion_heat_field_lg");		
+	level._effect["fx_mp_distortion_heat_field_sm"]				= loadfx("maps/mp_maps/fx_mp_distortion_heat_field_sm");
+	level._effect["fx_mp_distortion_heat_field_xsm"]			= loadfx("maps/mp_maps/fx_mp_distortion_heat_field_xsm");
+
+	level._effect["fx_water_drip_light_short"]						= loadfx("env/water/fx_water_drip_light_short");	
+	
+	level._effect["fx_mp_light_dust_motes_md"]						= loadfx("maps/mp_maps/fx_mp_light_dust_motes_md");
+	
+	level._effect["fx_grass_blowing_slow"]								= loadfx("env/foliage/fx_grass_blowing_slow");
+	
+	level._effect["fx_seagulls_shore_distant"]						= 	loadfx("bio/animals/fx_seagulls_shore_distant");
+	
+	level._effect["fx_light_red_on_lg"]										= 	loadfx("maps/mp_maps/fx_mp_light_red_firingrange");
+	level._effect["fx_light_floodlight_int_blue_short"]		= 	loadfx("env/light/fx_light_floodlight_int_blue_short");	
+	level._effect[ "codo_godray_afgan" ]			 	= loadfx( "env/light/codo_godray_afgan" );
+	level._effect[ "tropical_bird_runner" ]			 	= loadfx( "animals/tropical_bird_runner" );
+	level._effect[ "fx_mp_flies_carcass" ]			 	= loadfx( "maps/mp_maps/fx_mp_flies_carcass" );		
+
+
+}
+
+main()
+{
+	precache_scripted_fx();
+	precache_createfx_fx();
+}

iw4x/iw4x_00/maps/mp/mp_killhouse.gsc

@@ -0,0 +1,20 @@
+main()
+{
+	//maps\mp\mp_killhouse_fx::main();
+	maps\createart\mp_killhouse_art::main();
+	//maps\createfx\mp_killhouse_fx::main();
+	
+	maps\mp\_load::main();
+	maps\mp\_compass::setupMiniMap( "compass_map_mp_killhouse" );
+
+	ambientPlay("ambient_scoutsniper_ext0");
+
+	game[ "attackers" ] = "allies";
+	game[ "defenders" ] = "axis";
+
+	setdvar("compassmaxrange","2200");
+	setdvar("r_specularcolorscale", "1");
+	setdvar("sm_sunSampleSizeNear", "0.35"); //This fixes the shadow errors
+	
+}
+

iw4x/iw4x_00/maps/mp/mp_killhouse_fx.gsc

@@ -0,0 +1,19 @@
+main()
+{
+//	level._effect[ "wood" ]				 = loadfx( "explosions/grenadeExp_wood" );
+//	level._effect[ "dust" ]				 = loadfx( "explosions/grenadeExp_dirt_1" );
+//	level._effect[ "brick" ]			 = loadfx( "explosions/grenadeExp_concrete_1" );
+
+	level._effect[ "paper_falling_burning" ]			= loadfx( "misc/paper_falling_burning" );
+	level._effect[ "ground_smoke_launch_a" ]			= loadfx( "smoke/ground_smoke_launch_a" );
+	level._effect[ "amb_dust_hangar" ]					= loadfx( "dust/amb_dust_hangar_mp" );
+	level._effect[ "light_shaft_dust_large" ]			= loadfx( "dust/light_shaft_dust_large" );
+	level._effect[ "light_shaft_dust_med" ]				= loadfx( "dust/light_shaft_dust_med" );
+
+
+/#		
+	if ( getdvar( "clientSideEffects" ) != "1" )
+		maps\createfx\mp_killhouse_fx::main();
+#/
+
+}

iw4x/iw4x_00/maps/mp/mp_nuked.gsc

@@ -0,0 +1,139 @@
+#include common_scripts\utility;
+ 
+main()
+{
+	maps\mp\_load::main();
+	maps\mp\mp_nuked_fx::main();
+
+	//setexpfog(874.792, 2740, 0.776471, 0.588235, 0.47451, 0.5, 0, 0.803922, 0.717647, 0.6, (-0.432962, -0.395847, 0.809845), 0, 61.0525, 5.68252);
+	setexpfog(1074.792, 3540, 0.934471, 0.838235, 0.694513, 0.5, 0, 0.803922, 0.717647, 0.6, (-0.432962, -0.395847, 0.809845), 0, 61.0525, 5.68252);
+	ambientPlay( "ambient_mp_desert" );
+
+	game[ "attackers" ] = "allies";
+	game[ "defenders" ] = "axis";
+ 
+	maps\mp\_compass::setupMiniMap( "compass_map_mp_nuked" );
+	//setdvar( "compassmaxrange", "4000" );
+	
+	nuked_doomsday_clock_init();
+	level thread nuked_population_sign_think();
+ 
+	array_thread( getentarray( "compassTriggers", "targetname" ), ::compass_triggers_think );
+}
+ 
+self_delete()
+{
+	self delete();
+}
+
+
+compass_triggers_think()
+{
+	assertex( isdefined( self.script_noteworthy ), "compassTrigger at " + self.origin + " needs to have a script_noteworthy with the name of the minimap to use" );
+	while( true )
+	{
+		wait( 1 );
+		self waittill( "trigger" );
+		maps\mp\_compass::setupMiniMap( self.script_noteworthy );
+	}
+}
+ 
+createSpawnpoint( classname, origin, yaw )
+{
+	spawnpoint = spawn( "script_origin", origin );
+	spawnpoint.angles = (0,yaw,0);
+       
+	if ( !isdefined( level.extraspawnpoints ) )
+		level.extraspawnpoints = [];
+	if ( !isdefined( level.extraspawnpoints[classname] ) )
+		level.extraspawnpoints[classname] = [];
+	level.extraspawnpoints[classname][ level.extraspawnpoints[classname].size ] = spawnpoint;
+}
+
+nuked_population_sign_think()
+{
+        tens_model = GetEnt( "counter_tens", "targetname" );
+        ones_model = GetEnt( "counter_ones", "targetname" );
+ 
+        step = ( 360 / 10 ); // 10 digits (0-9) on the dial
+ 
+        // put the dials at 0
+        ones = 0;
+        tens = 0;
+ 
+        tens_model RotateRoll( step, 0.05 );
+        ones_model RotateRoll( step, 0.05 );
+ 
+        for ( ;; )
+        {
+            wait( 1 );
+ 
+			for ( ;; )
+			{
+				num_players = level.players.size;
+				dial = ones + ( tens * 10 );
+ 
+			if ( num_players < dial )
+			{
+					ones--;
+					time = 0.5;
+                if ( ones < 0 )
+                {
+					ones = 9;
+					tens_model RotateRoll( 0 - step, time );
+					tens--;
+                }
+ 
+				ones_model RotateRoll( 0 - step, time );
+				ones_model waittill( "rotatedone" );
+			}
+			else if ( num_players > dial )
+			{
+				ones++;
+				time = 0.5;
+ 
+                if ( ones > 9 )
+                {
+					ones = 0;
+					tens_model RotateRoll( step, time );
+					tens++;
+				}
+ 
+				ones_model RotateRoll( step, time );
+				ones_model waittill( "rotatedone" );
+			}
+			else
+			{
+				break;
+			}
+		}
+	}
+}
+       
+nuked_doomsday_clock_init()
+{
+	min_hand_model = GetEnt( "clock_min_hand", "targetname" );
+	sec_hand_model = GetEnt( "clock_sec_hand", "targetname" );
+	start_angle = 318;
+	min_hand_model RotatePitch( start_angle, 0.05 );
+	min_hand_model waittill( "rotatedone" );
+   
+	if ( level.timelimit > 0 )
+	{
+		min_hand_model RotatePitch( 360 - start_angle, level.timelimit * 60 );
+		sec_hand_model RotatePitch( 360 * level.timelimit, level.timelimit * 60 );
+	}
+	else
+	{
+		sec_hand_model thread nuked_doomsday_clock_seconds_think();
+	}
+}
+ 
+nuked_doomsday_clock_seconds_think()
+{
+	for ( ;; )
+	{
+		self RotatePitch( 360, 60 );
+		self waittill( "rotatedone" );
+	}
+}

iw4x/iw4x_00/maps/mp/mp_nuked_fx.gsc

@@ -0,0 +1,66 @@
+#include maps\mp\_utility; 
+
+// fx used by utility scripts
+precache_util_fx()
+{
+}
+
+/*
+// fx prop anim effects
+#using_animtree ( "fxanim_props" );
+precache_fx_prop_anims()
+{
+	level.nuked_fxanims = [];
+	level.nuked_fxanims["fxanim_mp_dustdevil_anim"]		= %fxanim_mp_dustdevil_anim;
+	level.nuked_fx["fx_mp_sand_dust_devil"]				= loadfx( "maps/mp_maps/fx_mp_sand_dust_devil" );
+}
+*/
+
+// Scripted effects
+precache_scripted_fx()
+{
+}
+
+// Ambient effects
+precache_createfx_fx()
+{
+
+	level._effect["fx_insects_butterfly_flutter"]								= loadfx("bio/insects/fx_insects_butterfly_flutter");
+	level._effect["fx_insects_butterfly_flutter_radial"]				= loadfx("bio/insects/fx_insects_butterfly_flutter_radial");	
+	
+	level._effect["fx_mp_nuked_glint"]													= loadfx("maps/mp_maps/fx_mp_nuked_glint");	
+    level._effect["fx_glow_codolamp"]													= loadfx("env/light/fx_glow_codolamp");
+	level._effect["fx_mp_nuked_glint_sm"]												= loadfx("maps/mp_maps/fx_mp_nuked_glint_sm");
+	level._effect["fx_mp_nuked_glint_lg"]												= loadfx("maps/mp_maps/fx_mp_nuked_glint_lg");	
+	level._effect["fx_mp_nuked_double_rainbow"]									= loadfx("maps/mp_maps/fx_mp_nuked_double_rainbow");	
+	level._effect["fx_mp_nuked_double_rainbow_lg"]							= loadfx("maps/mp_maps/fx_mp_nuked_double_rainbow_lg");	
+	
+	//level._effect["fx_mp_sand_blowing_xlg_distant"]							= loadfx("maps/mp_maps/fx_mp_sand_blowing_xlg_distant");
+	//level._effect["fx_mp_sand_windy_heavy_sm_slow"]							= loadfx("maps/mp_maps/fx_mp_sand_windy_heavy_sm_slow");	
+	
+//	level._effect["fx_cloud3d_cmls_lg1"]												= loadfx("env/weather/fx_cloud3d_cmls_lg1");
+
+	level._effect["fx_mp_nuked_nuclear_explosion"]							= loadfx( "maps/mp_maps/fx_mp_nuked_nuclear_explosion" );
+
+	level._effect["fx_mp_nuked_sprinkler"]											= loadfx( "maps/mp_maps/fx_mp_nuked_sprinkler" );	
+	level._effect["fx_mp_nuked_hose_spray"]											= loadfx("maps/mp_maps/fx_mp_nuked_hose_spray");
+		
+	level._effect["fx_mp_nuked_glass_break"]										= loadfx( "maps/mp_maps/fx_mp_nuked_glass_break" );		
+
+}
+
+main()
+{
+	precache_util_fx();
+	precache_createfx_fx();
+	precache_scripted_fx();
+	//precache_fx_prop_anims();
+	maps\createfx\mp_nuked_fx::main();
+	//maps\createart\mp_nuked_art::main();
+	
+/#
+	if ( getdvar( "clientSideEffects" ) != "1" )
+	maps\createfx\mp_nuked_fx::main();
+ #/
+
+}

iw4x/iw4x_00/maps/mp/mp_rust_long.gsc

@@ -0,0 +1,23 @@
+#include maps\mp\_utility;
+
+main()
+{
+
+	maps\mp\mp_rust_long_precache::main();
+	maps\createart\mp_rust_long_art::main();
+	maps\createfx\mp_rust_long_fx::main();
+	maps\mp\mp_rust_long_fx::main();
+
+	maps\mp\_load::main();
+
+	maps\mp\_compass::setupMiniMap( "compass_map_mp_rust_long" );
+
+	setdvar( "compassmaxrange", "1400" );
+
+	ambientPlay( "ambient_mp_duststorm" );
+
+	game[ "attackers" ] = "allies";
+	game[ "defenders" ] = "axis";
+	
+	setdvar( "r_diffusecolorscale", "1.4" );
+}

iw4x/iw4x_00/maps/mp/mp_rust_long_fx.gsc

@@ -0,0 +1,16 @@
+main()
+{
+	//ambient fx
+	level._effect[ "sand_storm_light" ]						= loadfx( "weather/sand_storm_mp_rust" );
+	level._effect[ "sand_spray_detail_runner0x400" ]	 	= loadfx( "dust/sand_spray_detail_runner_0x400" );
+	level._effect[ "sand_spray_detail_runner400x400" ]	 	= loadfx( "dust/sand_spray_detail_runner_400x400" );
+	level._effect[ "sand_spray_detail_oriented_runner" ]	= loadfx( "dust/sand_spray_detail_oriented_runner" );
+	level._effect[ "sand_spray_cliff_oriented_runner" ] 	= loadfx( "dust/sand_spray_cliff_oriented_runner" );
+	//level._effect[ "fx_rcbomb_light_red_sh" ] 	            = loadfx( "vehicle/light/fx_rcbomb_light_red_sh" );
+	level._effect[ "field_fire_distant_01" ] 	            = loadfx( "fire/field_fire_distant_01" );
+	level._effect[ "oil_rig_fire_mp" ] 	            = loadfx( "fire/oil_rig_fire_mp" );
+	
+	if ( !getdvarint( "clientSideEffects" ) )
+		maps\createfx\mp_rust_long_fx::main();
+
+}

iw4x/iw4x_00/maps/mp/mp_rust_long_precache.gsc

@@ -0,0 +1,6 @@
+// this file is autogenerated, modifying parameters is ok, other lines will be removed.
+main()
+{
+	maps\animated_models\highrise_fencetarp_07b_wind_c::main();
+	maps\animated_models\highrise_fencetarp_04b_wind_b::main();
+}

iw4x/iw4x_00/maps/mp/mp_shipment.gsc

@@ -0,0 +1,165 @@
+main()
+{
+	maps\mp\mp_shipment_fx::main();
+	maps\createart\mp_shipment_art::main();
+	maps\createfx\mp_shipment_fx::main();
+	maps\mp\_load::main();
+	
+	maps\mp\_compass::setupMiniMap("compass_map_mp_shipment");
+	
+	ambientPlay("ambient_trainer_ext2"); //TODO: get proper ambient
+
+	game["attackers"] = "axis";
+	game["defenders"] = "allies";
+
+	setdvar( "r_specularcolorscale", "1.7" );
+	setdvar( "r_diffusecolorscale", "1.3" );
+
+	setdvar("compassmaxrange","1400");
+	
+	level thread deleteChaModels();
+}
+
+deleteChaModels()
+{	
+	count = 0;
+	count2 = 0;
+	count3 = 0;
+	globalIntermission = getEntArray ( "mp_global_intermission", "targetname" );
+	dmSpawns = getEntArray ( "mp_dm_spawn", "targetname" );
+	domSpawns = getEntArray ( "mp_dom_spawn", "targetname" );
+	tdmSpawns = getEntArray ( "mp_tdm_spawn", "targetname" );
+
+	// ---- DEFINING GAMETYPE OBJECTS ----
+	
+	universalExploderAB = getEntArray ( "exploder", "targetname" );
+	
+	// - CTF -
+	flagRemoveAllies = getEntArray ( "ctf_flag_allies", "targetname" );
+	flagTrigRemoveAllies = getEntArray ( "ctf_trig_allies", "targetname" );
+	flagZoneRemoveAllies = getEntArray ( "ctf_zone_allies", "targetname" );
+	flagRemoveAxis = getEntArray ( "ctf_flag_axis", "targetname" );
+	flagTrigRemoveAxis = getEntArray ( "ctf_trig_axis", "targetname" );
+	flagZoneRemoveAxis = getEntArray ( "ctf_zone_axis", "targetname" );
+	
+	// - DD -
+	ddbombzonesTouchAB = getEntArray ( "dd_bombzone", "targetname" );
+	ddbombzonesModelA = getEntArray ( "pf408_auto1", "targetname" ) ;
+	ddbombzonesTrigA = getEntArray ( "pf408_auto2", "targetname" );
+	ddbombzonesModelB = getEntArray ( "pf409_auto1", "targetname" ) ;
+	ddbombzonesTrigB = getEntArray ( "pf409_auto2", "targetname" );
+	ddbombzonesCollA = getEntArray ( "dd_bombzone_clip_a", "targetname" );
+	ddbombzonesCollB = getEntArray ( "dd_bombzone_clip_b", "targetname" );
+	
+	// - Dom -
+	flagPrimary = getEntArray ( "flag_primary", "targetname" );
+	flagDescriptor = getEntArray ("flag_descriptor", "targetname" );
+	
+	// - Sab -
+	sabbombzonesColl = getEntArray ( "sab_bomb_col", "targetname" );
+	sabbombzonesTouchAllies = getEntArray ( "sab_bomb_allies", "targetname" );
+	sabbombzonesDefuseAllies = getEntArray ( "sab_bomb_defuse_allies", "targetname" );
+	sabbombzonesSiteModelAllies = getEntArray ( "pf397_auto1", "targetname" );
+	sabbombzonesTouchAxis = getEntArray ( "sab_bomb_axis", "targetname" );
+	sabbombzonesDefuseAxis = getEntArray ( "sab_bomb_defuse_axis", "targetname" );
+	sabbombzonesSiteModelAxis = getEntArray ( "pf398_auto1", "targetname" );
+	
+	// - SnD -
+	bombzonesTouchAB = getEntArray ( "bombzone", "targetname" );
+	bombzonesCollAB = getEntArray ( "bomb_col", "targetname" );
+	bombzonesModelA = getEntArray ( "pf393_auto1", "targetname" );
+	bombzonesTrigA = getEntArray ( "pf393_auto2", "targetname" );
+	bombzonesModelB = getEntArray ( "pf394_auto1", "targetname" );
+	bombzonesTrigB = getEntArray ( "pf394_auto2", "targetname" );
+	bombzonesBrief = getEntArray ( "sd_bomb", "targetname" );
+	bombzonesBriefTrig = getEntArray ( "sd_bomb_pickup_trig", "targetname" );
+	
+	// ---- DELETING GAMETYPE OBJECTS ----
+	
+	foreach( ent in dmSpawns )
+	{
+		count2++;
+		if (count2 > 7)
+		{
+			dmSpawns[count2] Delete();
+		}
+	}
+	
+	flagRemoveAllies[0] Delete();
+	flagTrigRemoveAllies[0] Delete();
+	flagZoneRemoveAllies[0] Delete();
+	flagRemoveAxis[0] Delete();
+	flagTrigRemoveAxis[0] Delete();
+	flagZoneRemoveAxis[0] Delete();
+	foreach( ent in domSpawns )
+	{
+		count++;
+		if (count > 7)
+		{
+			domSpawns[count] Delete();
+		}
+	}
+	
+	ddbombzonesTouchAB[0] Delete();
+	ddbombzonesTouchAB[1] Delete();
+	ddbombzonesModelA[0] Delete();
+	ddbombzonesTrigA[0] Delete();
+	ddbombzonesModelB[0] Delete();
+	ddbombzonesTrigB[0] Delete();
+	universalExploderAB[8] Delete();
+	universalExploderAB[9] Delete();
+	ddbombzonesCollA[0] Delete();
+	ddbombzonesCollB[0] Delete();
+	
+	flagPrimary[0] Delete();
+	flagPrimary[1] Delete();
+	flagPrimary[2] Delete();
+	flagDescriptor[0] Delete();
+	flagDescriptor[1] Delete();
+	flagDescriptor[2] Delete();
+	
+	sabbombzonesColl[0] Delete();
+	sabbombzonesColl[1] Delete();
+	sabbombzonesTouchAllies[0] Delete();
+	sabbombzonesDefuseAllies[0] Delete();
+	sabbombzonesSiteModelAllies[0] Delete();
+	sabbombzonesTouchAxis[0] Delete();
+	sabbombzonesDefuseAxis[0] Delete();
+	sabbombzonesSiteModelAxis[0] Delete();
+	universalExploderAB[4] Delete();
+	universalExploderAB[5] Delete();
+	
+	bombzonesTouchAB[0] Delete();
+	bombzonesTouchAB[1] Delete();
+	universalExploderAB[0] Delete();
+	universalExploderAB[1] Delete();
+	bombzonesCollAB[0] Delete();
+	bombzonesCollAB[1] Delete();
+	bombzonesModelA[0] Delete();
+	bombzonesModelB[0] Delete();
+	bombzonesTrigA[0] Delete();
+	bombzonesTrigB[0] Delete();
+	bombzonesBrief[0] Delete();
+	bombzonesBriefTrig[0] Delete();
+	
+	foreach( ent in tdmSpawns )
+	{
+		count3++;
+		if (count3 > 7)
+		{
+			tdmSpawns[count3] Delete();
+		}
+	}
+	
+	
+	// - Removing the barrels -
+	
+	chaRemove = getEntArray ( "cha", "targetname" );
+	
+	foreach( ent in chaRemove )
+	{
+		ent Delete();
+	}
+	
+	globalIntermission[0] Delete();
+}

iw4x/iw4x_00/maps/mp/mp_shipment_fx.gsc

@@ -0,0 +1,10 @@
+main()
+{
+
+	level._effect[ "bird_seagull_flock_large" ]		= loadfx( "misc/bird_seagull_flock_large" );
+	level._effect[ "cloud_bank_far" ]				= loadfx( "weather/jeepride_cloud_bank_far" );
+	level._effect[ "mist_hunted_fav" ]					= loadfx( "weather/mist_hunted_fav" );
+	
+	if ( !getdvarint( "clientSideEffects" ) )
+		maps\createfx\mp_shipment_fx::main();
+}

iw4x/iw4x_00/maps/mp/mp_shipment_long.gsc

@@ -0,0 +1,157 @@
+main()
+{
+	maps\mp\mp_shipment_long_fx::main();
+	maps\createart\mp_shipment_long_art::main();
+	maps\createfx\mp_shipment_long_fx::main();
+	maps\mp\_load::main();
+	
+	maps\mp\_compass::setupMiniMap("compass_map_mp_shipment");
+	
+	ambientPlay("ambient_mp_rain");
+
+	game["attackers"] = "axis";
+	game["defenders"] = "allies";
+
+	setdvar( "r_specularcolorscale", "1" );
+	setdvar( "r_diffusecolorscale", "0.8" );
+
+	setdvar("compassmaxrange", "1400");
+	
+	//Too lazy to set up Head Quarters!
+	if ( getDvar( "g_gametype" ) != "koth" )
+		level thread deleteChaModels();
+	else
+		level thread deleteBarrels();
+}
+
+deleteChaModels()
+{	
+	maps\mp\_compass::setupMiniMap("compass_map_mp_shipment_long");
+	globalIntermission = getEntArray ( "mp_global_intermission", "targetname" );
+	dmSpawns = getEntArray ( "mp_dm_spawn", "targetname" );
+	domSpawns = getEntArray ( "mp_dom_spawn", "targetname" );
+	tdmSpawns = getEntArray ( "mp_tdm_spawn", "targetname" );
+
+	// ---- DEFINING GAMETYPE OBJECTS ----
+	
+	universalExploderAB = getEntArray ( "exploder", "targetname" );
+	
+	// - CTF -
+	flagRemoveAllies = getEntArray ( "ctf_flag_allies", "targetname" );
+	flagTrigRemoveAllies = getEntArray ( "ctf_trig_allies", "targetname" );
+	flagZoneRemoveAllies = getEntArray ( "ctf_zone_allies", "targetname" );
+	flagRemoveAxis = getEntArray ( "ctf_flag_axis", "targetname" );
+	flagTrigRemoveAxis = getEntArray ( "ctf_trig_axis", "targetname" );
+	flagZoneRemoveAxis = getEntArray ( "ctf_zone_axis", "targetname" );
+	
+	// - DD -
+	ddbombzonesTouchAB = getEntArray ( "dd_bombzone", "targetname" );
+	ddbombzonesModelA = getEntArray ( "pf408_auto1", "targetname" ) ;
+	ddbombzonesTrigA = getEntArray ( "pf408_auto2", "targetname" );
+	ddbombzonesModelB = getEntArray ( "pf409_auto1", "targetname" ) ;
+	ddbombzonesTrigB = getEntArray ( "pf409_auto2", "targetname" );
+	ddbombzonesCollA = getEntArray ( "dd_bombzone_clip_a", "targetname" );
+	ddbombzonesCollB = getEntArray ( "dd_bombzone_clip_b", "targetname" );
+	
+	// - Dom -
+	flagPrimary = getEntArray ( "flag_primary", "targetname" );
+	flagDescriptor = getEntArray ("flag_descriptor", "targetname" );
+	
+	// - Sab -
+	sabbombzonesColl = getEntArray ( "sab_bomb_col", "targetname" );
+	sabbombzonesTouchAllies = getEntArray ( "sab_bomb_allies", "targetname" );
+	sabbombzonesDefuseAllies = getEntArray ( "sab_bomb_defuse_allies", "targetname" );
+	sabbombzonesSiteModelAllies = getEntArray ( "pf397_auto1", "targetname" );
+	sabbombzonesTouchAxis = getEntArray ( "sab_bomb_axis", "targetname" );
+	sabbombzonesDefuseAxis = getEntArray ( "sab_bomb_defuse_axis", "targetname" );
+	sabbombzonesSiteModelAxis = getEntArray ( "pf398_auto1", "targetname" );
+	
+	// - SnD -
+	bombzonesTouchAB = getEntArray ( "bombzone", "targetname" );
+	bombzonesCollAB = getEntArray ( "bomb_col", "targetname" );
+	bombzonesModelA = getEntArray ( "pf393_auto1", "targetname" );
+	bombzonesTrigA = getEntArray ( "pf393_auto2", "targetname" );
+	bombzonesModelB = getEntArray ( "pf394_auto1", "targetname" );
+	bombzonesTrigB = getEntArray ( "pf394_auto2", "targetname" );
+	bombzonesBrief = getEntArray ( "sd_bomb", "targetname" );
+	bombzonesBriefTrig = getEntArray ( "sd_bomb_pickup_trig", "targetname" );
+	
+	dmSpawns[6] Delete();
+	dmSpawns[7] Delete();
+	
+	flagRemoveAllies[1] Delete();
+	flagTrigRemoveAllies[1] Delete();
+	flagZoneRemoveAllies[1] Delete();
+	flagRemoveAxis[1] Delete();
+	flagTrigRemoveAxis[1] Delete();
+	flagZoneRemoveAxis[1] Delete();
+	
+	ddbombzonesTouchAB[2] Delete();
+	ddbombzonesTouchAB[3] Delete();
+	ddbombzonesModelA[1] Delete();
+	ddbombzonesTrigA[1] Delete();
+	ddbombzonesModelB[1] Delete();
+	ddbombzonesTrigB[1] Delete();
+	universalExploderAB[10] Delete();
+	universalExploderAB[11] Delete();
+	ddbombzonesCollA[1] Delete();
+	ddbombzonesCollB[1] Delete();
+	
+	flagPrimary[3] Delete();
+	flagPrimary[4] Delete();
+	flagPrimary[5] Delete();
+	flagDescriptor[3] Delete();
+	flagDescriptor[4] Delete();
+	flagDescriptor[5] Delete();
+	domSpawns[4] Delete();
+	domSpawns[5] Delete();
+	
+	sabbombzonesColl[2] Delete();
+	sabbombzonesColl[3] Delete();
+	sabbombzonesTouchAllies[1] Delete();
+	sabbombzonesDefuseAllies[1] Delete();
+	sabbombzonesSiteModelAllies[1] Delete();
+	sabbombzonesTouchAxis[1] Delete();
+	sabbombzonesDefuseAxis[1] Delete();
+	sabbombzonesSiteModelAxis[1] Delete();
+	universalExploderAB[6] Delete();
+	universalExploderAB[7] Delete();
+	
+	bombzonesTouchAB[2] Delete();
+	bombzonesTouchAB[3] Delete();
+	universalExploderAB[2] Delete();
+	universalExploderAB[3] Delete();
+	bombzonesCollAB[2] Delete();
+	bombzonesCollAB[3] Delete();
+	bombzonesModelA[1] Delete();
+	bombzonesModelB[1] Delete();
+	bombzonesTrigA[1] Delete();
+	bombzonesTrigB[1] Delete();
+	bombzonesBrief[1] Delete();
+	bombzonesBriefTrig[1] Delete();
+	
+	tdmSpawns[4] Delete();
+	tdmSpawns[5] Delete();
+	
+	chargeRemove = getEntArray ( "charge_remove", "targetname" );
+	
+	foreach( ent in chargeRemove )
+	{
+		ent Delete();
+	}
+		
+	globalIntermission[1] Delete();
+}
+
+deleteBarrels()
+{	
+	globalIntermission = getEntArray ( "mp_global_intermission", "targetname" );
+	chaRemove = getEntArray ( "cha", "targetname" );
+	
+	foreach( ent in chaRemove )
+	{
+		ent Delete();
+	}
+	
+	globalIntermission[0] Delete();
+}

iw4x/iw4x_00/maps/mp/mp_shipment_long_fx.gsc

@@ -0,0 +1,20 @@
+main()
+{
+
+	level._effect[ "bird_seagull_flock_large" ]		= loadfx( "misc/bird_seagull_flock_large" );
+	level._effect[ "cloud_bank_far" ]				= loadfx( "weather/jeepride_cloud_bank_far" );
+	level._effect[ "mist_hunted_fav" ]					= loadfx( "weather/mist_hunted_fav" );
+	
+	//rain effects
+	level._effect[ "rain_mp_storm" ]				= loadfx( "weather/rain_mp_storm" );
+    level._effect[ "rain_noise_splashes_fade" ]			= loadfx( "weather/rain_noise_splashes_fade" );
+	level._effect[ "rain_splash_lite_64x64" ]		= loadfx( "weather/rain_splash_lite_64x64" );
+	level._effect[ "waterfall_drainage_mp" ]		= loadfx( "water/waterfall_drainage_mp" );
+    level._effect[ "waterfall_drainage_splash_mp" ]	= loadfx( "water/waterfall_drainage_splash_mp" );
+	level._effect[ "lightning_mp_storm" ]		    = loadfx( "weather/lightning_mp_storm" );
+	level._effect[ "rain_heavy_mist" ]	            = loadfx ("weather/rain_heavy_mist_ex");
+	level._effect[ "drips_fast" ]							= loadfx( "misc/drips_fast" );	
+	
+	if ( !getdvarint( "clientSideEffects" ) )
+		maps\createfx\mp_shipment_long_fx::main();
+}

iw4x/iw4x_00/maps/mp/mp_storm_spring.gsc

@@ -0,0 +1,20 @@
+main()
+{
+	maps\mp\mp_storm_spring_precache::main();
+	maps\mp\mp_storm_spring_fx::main();
+	maps\createart\mp_storm_spring_art::main();
+	maps\createfx\mp_storm_spring_fx::main();
+	maps\createfx\mp_storm_spring_ex_fx::main();
+	maps\mp\_load::main();
+
+	maps\mp\_compass::setupMiniMap( "compass_map_mp_storm_spring" );
+
+	ambientPlay( "ambient_mp_snow" );
+
+	game[ "attackers" ] = "axis";
+	game[ "defenders" ] = "allies";
+
+	setdvar( "r_specularcolorscale", "2" );
+	setdvar( "r_diffusecolorscale", "1.2" );
+	setdvar( "compassmaxrange", "2300" );
+}

iw4x/iw4x_00/maps/mp/mp_storm_spring_fx.gsc

@@ -0,0 +1,22 @@
+main()
+{
+	
+	//ambient fx
+	//level._effect[ "gas_coop_storm" ] 			= loadfx( "weather/gas_coop_storm" );
+	level._effect[ "smoke_plume_white_01" ] 				= loadfx( "smoke/smoke_plume_white_01" );
+	level._effect[ "smoke_plume_white_02" ] 				= loadfx( "smoke/smoke_plume_white_02" );
+	//level._effect[ "heater_big" ] 				            = loadfx( "distortion/heater_big" );
+	level._effect[ "insects_carcass_flies_c" ] 				= loadfx( "misc/insects_carcass_flies_c" );
+	level._effect[ "oxygen_leak" ] 				    = loadfx( "distortion/oxygen_leak" );
+	//level._effect[ "drips_fast" ]                           = loadfx( "smoke/drips_fast" );
+	//level._effect[ "smoke_grenade_11sec_mp" ]               = loadfx( "smoke/smoke_grenade_11sec_mp" );
+	
+	//level._effect[ "light_c4_blink_nodlight" ] 			= loadfx( "misc/light_c4_blink_nodlight" );
+	level._effect["bombexplosion"] = loadfx("explosions/tanker_explosion");
+	
+/#
+	if ( getdvar( "clientSideEffects" ) != "1" )
+		maps\createfx\mp_storm_spring_fx::main();
+#/
+
+}

iw4x/iw4x_00/maps/mp/mp_storm_spring_precache.gsc

@@ -0,0 +1,12 @@
+// this file is autogenerated, modifying parameters is ok, other lines will be removed.
+main()
+{
+	common_scripts\_destructible_types_anim_airconditioner::main();
+	common_scripts\_destructible_types_anim_light_fluo_single::main();
+	maps\animated_models\highrise_fencetarp_04b_wind_a::main();
+	maps\animated_models\highrise_fencetarp_04b_wind_b::main();
+	maps\animated_models\highrise_fencetarp_04b_wind_c::main();
+	maps\animated_models\highrise_fencetarp_07b_wind_a::main();
+	maps\animated_models\highrise_fencetarp_07b_wind_b::main();
+	maps\animated_models\highrise_fencetarp_07b_wind_c::main();
+}

iw4x/iw4x_00/maps/mp/oilrig.gsc

@@ -0,0 +1,149 @@
+#include common_scripts\utility;
+#include maps\mp\_utility;
+#include maps\mp\gametypes\_hud_util;
+
+main()
+{
+
+	maps\mp\_load::main();
+	
+
+	game[ "attackers" ] = "allies";
+	game[ "defenders" ] = "axis";
+
+	maps\mp\_compass::setupMiniMap( "compass_map_oilrig_lvl_3" );
+	setdvar( "compassmaxrange", "4000" );
+
+	array_thread( getentarray( "breach_solid", "targetname" ), ::self_delete );
+
+	array_thread( getentarray( "compassTriggers", "targetname" ), ::compass_triggers_think );
+	
+	
+	CreateRamps((1676, 1330, -70), (2489, 1844, 900));
+	CreateRamps((-965, 256, -200), (-854, -77, 54));
+	thread custom_killtrigger();
+	thread level_think();
+	thread level_think2();
+}
+
+self_delete()
+{
+	self delete();
+}
+
+
+custom_killtrigger()
+{
+	while (true)
+	{
+		wait 0.1;
+
+		foreach (player in level.players)
+		{
+			if (!isDefined(player) || !isPlayer(player))
+			{
+				continue;
+			}
+
+			if (player.origin[2] < -350.0)
+			{
+				player suicide();
+			}
+		}
+	}
+}
+
+
+compass_triggers_think()
+{
+	assertex( isdefined( self.script_noteworthy ), "compassTrigger at " + self.origin + " needs to have a script_noteworthy with the name of the minimap to use" );
+	while( true )
+	{
+		wait( 1 );
+		self waittill( "trigger" );
+		maps\mp\_compass::setupMiniMap( self.script_noteworthy );
+	}
+}
+
+CreateRamps(top, bottom)
+{
+	D = Distance(top, bottom);
+	blocks = roundUp(D/30);
+	CX = top[0] - bottom[0];
+	CY = top[1] - bottom[1];
+	CZ = top[2] - bottom[2];
+	XA = CX/blocks;
+	YA = CY/blocks;
+	ZA = CZ/blocks;
+	CXY = Distance((top[0], top[1], 0), (bottom[0], bottom[1], 0));
+	Temp = VectorToAngles(top - bottom);
+	BA = (Temp[2], Temp[1] + 90, Temp[0]);
+	for(b = 0; b < blocks; b++){
+		block = spawn("script_model", (bottom + ((XA, YA, ZA) * b)));
+		//block setModel("com_plasticcase_friendly");
+		block.angles = BA;
+		block Solid();
+		block CloneBrushmodelToScriptmodel( level.airDropCrateCollision );
+		wait 0.01;
+	}
+	block = spawn("script_model", (bottom + ((XA, YA, ZA) * blocks) - (0, 0, 5)));
+	//block setModel("com_plasticcase_friendly");
+	block.angles = (BA[0], BA[1], 0);
+	block Solid();
+	block CloneBrushmodelToScriptmodel( level.airDropCrateCollision );
+	wait 0.01;
+}
+
+
+roundUp( floatVal )
+{
+	if ( int( floatVal ) != floatVal )
+		return int( floatVal+1 );
+	else
+		return int( floatVal );
+}
+
+
+level_think()
+{
+
+	/*-----------------------
+	MOVING DERRICK DRILL THING
+	-------------------------*/
+	eDerrick_thing = getent( "derrick_thing", "targetname" );
+	eDerrick_thing.origin = eDerrick_thing.origin + ( 0, 0, -2816 );
+	assert( isdefined( eDerrick_thing ) );
+	time = 2;
+	speed = 300;
+	while ( true )
+	{
+		eDerrick_thing rotatevelocity( ( 0, speed, 0 ), time );
+		wait( time );
+	}
+
+}
+level_think2()
+{
+	model1 = getent( "fx_spotlight_beam", "targetname" );
+	model2 = getent( "com_blackhawk_spotlight_on_mg_setup", "targetname" );
+	assert( isdefined( model1 ) );
+	assert( isdefined( model2 ) );
+	
+	time = 10;
+	while ( true )
+	{
+		model1 rotateto(model1.angles+(0,45,0),time);
+		model2 rotateto(model2.angles+(0,45,0),time);
+		wait( time );
+		model1 rotateto(model1.angles+(0,-45,0),time);
+		model2 rotateto(model2.angles+(0,-45,0),time);
+		wait( time );
+		model1 rotateto(model1.angles+(10,45,0),time);
+		model2 rotateto(model2.angles+(10,45,0),time);
+		wait( time );
+		model1 rotateto(model1.angles+(-10,-45,0),time);
+		model2 rotateto(model2.angles+(-10,-45,0),time);
+		wait( time );
+	}
+
+}

iw4x/iw4x_00/maps/mp/oilrig_fx.gsc

@@ -0,0 +1,91 @@
+#include common_scripts\utility;
+
+main()
+{
+	thread precacheFX();
+	maps\createfx\oilrig_fx::main();
+}
+
+precacheFX()
+{
+	level._effect[ "pipe_steam" ]		 = LoadFX( "impacts/pipe_steam" );
+	level._effect[ "firelp_small_pm_nolight" ]					= loadfx( "fire/firelp_small_pm_nolight" );
+	level._effect[ "firelp_small_pm" ]							= loadfx( "fire/firelp_small_pm" );
+	level._effect[ "minigun_shell_eject" ] 								= loadfx( "shellejects/20mm_mp" );
+	
+	level._effect[ "cold_breath" ]				 = loadfx( "misc/cold_breath" );
+	level._effect[ "player_death_explosion" ]				 = loadfx( "explosions/player_death_explosion" );
+	
+	level._effect[ "smokescreen" ]	 = loadfx( "smoke/smoke_screen" );
+
+	level._effect[ "sdv_prop_wash_1" ]	 					= loadfx( "water/sdv_prop_wash_1" );
+	//level._effect[ "sub_prop_wash_1" ]	 					= loadfx( "water/sdv_prop_wash_1" );
+	level._effect[ "sdv_contrail" ]							= loadfx( "smoke/jet_contrail" );
+	
+	level._effect[ "scuba_bubbles" ]			 			= loadfx( "water/scuba_bubbles_breath" );
+	level._effect[ "scuba_bubbles_friendly" ]				= loadfx( "water/scuba_bubbles_breath" );
+	level._effect[ "oilrig_underwater_ambient" ]			= loadfx( "water/oilrig_underwater_ambient" );
+	level._effect[ "oilrig_underwater_ambient_emitter" ]	= loadfx( "water/oilrig_underwater_ambient_emitter" );
+	level._effect[ "oilrig_underwater_ambient_looped" ]		= loadfx( "water/oilrig_underwater_ambient_looped" );
+	level._effect[ "fish_school01" ]	 					= loadfx( "animals/fish_school01" );
+	level._effect[ "fish_school_top_oilrig_base" ]	 		= loadfx( "animals/fish_school_top_oilrig_base" );
+	level._effect[ "fish_school_side_med" ]	 				= loadfx( "animals/fish_school_side_med" );
+	level._effect[ "fish_school_side_large" ]	 			= loadfx( "animals/fish_school_side_large" );
+	level._effect[ "oilrig_underwater_caustic" ]	 		= loadfx( "water/oilrig_underwater_caustic" );
+
+	level._effect[ "bloodspurt_underwater" ]	 			= loadfx( "water/blood_spurt_underwater" );
+	level._effect[ "deathfx_bloodpool_underwater" ]	 		= loadfx( "impacts/deathfx_bloodpool_underwater" );
+	level._effect[ "splash_underwater_stealthkill" ]	 	= loadfx( "water/splash_underwater_stealthkill" );
+	
+	level._effect[ "drips_player_hand" ]	 				= loadfx( "water/drips_player_hand" );
+
+	level._effect[ "oil_rig_fire" ]						 = loadfx( "fire/oil_rig_fire" );
+	level._effect[ "wavebreak_oilrig_runner" ]			 = loadfx( "misc/wavebreak_oilrig_runner" );
+	level._effect[ "water_froth_oilrig" ]				 = loadfx( "misc/water_froth_oilrig" );
+	level._effect[ "water_froth_oilrig_leg_runner" ]	 = loadfx( "misc/water_froth_oilrig_leg_runner" );
+	level._effect[ "bird_seagull_flock_large" ]			 = loadfx( "misc/bird_seagull_flock_large" );
+	level._effect[ "powerline_runner" ]					 = loadfx( "explosions/powerline_runner" );
+
+ 	level._effect[ "oilrig_drips_riser" ]				= loadfx( "water/oilrig_drips_riser" );
+
+ 	level._effect[ "splash_ring_32_oilrig" ]			= loadfx( "water/splash_ring_32_oilrig" );
+ 	level._effect[ "drips_slow" ]					 	= loadfx( "misc/drips_slow" );
+ 	level._effect[ "steam_vent_small" ]					= loadfx( "smoke/steam_vent_small" );
+ 	level._effect[ "steam_manhole" ]					= loadfx( "smoke/steam_manhole" );
+ 	level._effect[ "steam_room_100" ]					= loadfx( "smoke/steam_room_100" );
+ 	level._effect[ "steam_hall_200" ]					= loadfx( "smoke/steam_hall_200" );
+ 	level._effect[ "steam_room_100_orange" ]			= loadfx( "smoke/steam_room_100_orange" );
+ 	level._effect[ "steam_hall_200_orange" ]			= loadfx( "smoke/steam_hall_200_orange" );
+	level._effect[ "light_glow_grating_yellow" ]		= loadfx( "misc/light_glow_grating_yellow" );
+	level._effect[ "oilrig_debri_large" ]		 		= loadfx( "misc/oilrig_debri_large" );
+ 	level._effect[ "ground_fog_oilrig" ]				= loadfx( "smoke/ground_fog_oilrig" );
+ 	level._effect[ "ground_fog_oilrig_far" ]			= loadfx( "smoke/ground_fog_oilrig_far" );
+
+	level._effect[ "thin_black_smoke_M" ]				 = loadfx( "smoke/thin_black_smoke_M_nofog" );
+	level._effect[ "thin_black_smoke_L" ]				 = loadfx( "smoke/thin_black_smoke_L_nofog" );
+	level._effect[ "thin_black_smoke_S" ]				 = loadfx( "smoke/thin_black_smoke_S_nofog" );
+
+	level._effect[ "underwater_particulates_01" ]		= loadfx( "dust/light_shaft_dust_large" );
+ 	level._effect[ "underwater_particulates_02" ]		= loadfx( "dust/room_dust_200" );
+ 	level._effect[ "underwater_particulates_03" ]		= loadfx( "dust/room_dust_100" );
+
+
+	level._effect[ "body_splash_railing" ]			 	= loadfx( "impacts/water_splash_bodydump" );
+
+	level._effect[ "ambush_explosion_03" ]			 	= loadfx( "explosions/window_explosion_1_oilrig" );
+	level._effect[ "ambush_explosion_room" ]			= loadfx( "explosions/room_explosion_oilrig" );
+	level._effect[ "light_c4_blink_nodlight" ] 			= loadfx( "misc/light_c4_blink_nodlight" );
+
+	level._effect[ "zodiac_wake_geotrail_oilrig" ]		= loadfx( "treadfx/zodiac_wake_geotrail_oilrig" );
+
+	level._effect[ "sub_surface_runner" ]			 	 = loadfx( "water/sub_surface_runner" );
+
+	// "hunted light" required zfeather == 1 and r_zfeather is undefined on console.  So, test for != "0".
+	if ( getdvarint( "sm_enable" ) && getdvar( "r_zfeather" ) != "0" )
+		level._effect[ "spotlight" ]						 = loadfx( "misc/hunted_spotlight_model" );
+	else
+		level._effect[ "spotlight" ]						 = loadfx( "misc/spotlight_large" );
+
+	level._effect[ "heli_dlight_blue" ]					 = loadfx( "misc/aircraft_light_cockpit_blue" );
+
+}

iw4x/iw4x_00/maps/mp/perks/_perks.gsc

@@ -0,0 +1,400 @@
+#include common_scripts\utility;
+#include maps\mp\_utility;
+#include maps\mp\gametypes\_hud_util;
+#include maps\mp\perks\_perkfunctions;
+
+init()
+{
+	level.perkFuncs = [];
+
+	precacheShader( "combathigh_overlay" );	
+	precacheShader( "specialty_painkiller" );
+
+	precacheModel( "weapon_riot_shield_mp" );	
+	precacheModel( "viewmodel_riot_shield_mp" );
+	precacheString( &"MPUI_CHANGING_KIT" );
+
+	//level.spawnGlowSplat = loadfx( "misc/flare_ambient_destroy" );
+
+	level.spawnGlowModel["enemy"] = "mil_emergency_flare_mp";
+	level.spawnGlowModel["friendly"] = "mil_emergency_flare_mp";
+	level.spawnGlow["enemy"] = loadfx( "misc/flare_ambient" );
+	level.spawnGlow["friendly"] = loadfx( "misc/flare_ambient_green" );
+	level.c4Death = loadfx( "explosions/oxygen_tank_explosion" );
+
+	level.spawnFire = loadfx( "props/barrelexp" );
+	
+	precacheModel( level.spawnGlowModel["friendly"] );
+	precacheModel( level.spawnGlowModel["enemy"] );
+	
+	precacheString( &"MP_DESTROY_TI" );
+	
+	precacheShaders();
+
+	level._effect["ricochet"] = loadfx( "impacts/large_metalhit_1" );
+
+	// perks that currently only exist in script: these will error if passed to "setPerk", etc... CASE SENSITIVE! must be lower
+	level.scriptPerks = [];
+	level.perkSetFuncs = [];
+	level.perkUnsetFuncs = [];
+	level.fauxPerks = [];
+
+	level.scriptPerks["specialty_blastshield"] = true;
+	level.scriptPerks["_specialty_blastshield"] = true;
+	level.scriptPerks["specialty_akimbo"] = true;
+	level.scriptPerks["specialty_siege"] = true;
+	level.scriptPerks["specialty_falldamage"] = true;
+	level.scriptPerks["specialty_fmj"] = true;
+	level.scriptPerks["specialty_shield"] = true;
+	level.scriptPerks["specialty_feigndeath"] = true;
+	level.scriptPerks["specialty_shellshock"] = true;
+	level.scriptPerks["specialty_delaymine"] = true;
+	level.scriptPerks["specialty_localjammer"] = true;
+	level.scriptPerks["specialty_thermal"] = true;
+	level.scriptPerks["specialty_finalstand"] = true;
+	level.scriptPerks["specialty_blackbox"] = true;
+	level.scriptPerks["specialty_steelnerves"] = true;
+	level.scriptPerks["specialty_flashgrenade"] = true;
+	level.scriptPerks["specialty_smokegrenade"] = true;
+	level.scriptPerks["specialty_concussiongrenade"] = true;
+	level.scriptPerks["specialty_challenger"] = true;	
+	level.scriptPerks["specialty_tacticalinsertion"] = true;
+	level.scriptPerks["specialty_saboteur"] = true;
+	level.scriptPerks["specialty_endgame"] = true;
+	level.scriptPerks["specialty_rearview"] = true;
+	level.scriptPerks["specialty_hardline"] = true;
+	level.scriptPerks["specialty_ac130"] = true;
+	level.scriptPerks["specialty_sentry_minigun"] = true;
+	level.scriptPerks["specialty_predator_missile"] = true;
+	level.scriptPerks["specialty_helicopter_minigun"] = true;
+	level.scriptPerks["specialty_tank"] = true;
+	level.scriptPerks["specialty_precision_airstrike"] = true;
+	level.scriptPerks["specialty_bling"] = true;
+	level.scriptPerks["specialty_carepackage"] = true;
+	level.scriptPerks["specialty_onemanarmy"] = true;
+	level.scriptPerks["specialty_littlebird_support"] = true;
+	level.scriptPerks["specialty_primarydeath"] = true;
+	level.scriptPerks["specialty_secondarybling"] = true;	
+	level.scriptPerks["specialty_combathigh"] = true;
+	level.scriptPerks["specialty_c4death"] = true;
+	level.scriptPerks["specialty_explosivedamage"] = true;
+	level.scriptPerks["specialty_copycat"] = true;
+	level.scriptPerks["specialty_laststandoffhand"] = true;
+	level.scriptPerks["specialty_dangerclose"] = true;
+
+	level.scriptPerks["specialty_extraspecialduration"] = true;
+	level.scriptPerks["specialty_rollover"] = true;
+	level.scriptPerks["specialty_armorpiercing"] = true;
+	level.scriptPerks["specialty_omaquickchange"] = true;
+	level.scriptPerks["specialty_fastmeleerecovery"] = true;
+
+	level.scriptPerks["_specialty_rearview"] = true;
+	level.scriptPerks["_specialty_onemanarmy"] = true;
+	
+	level.fauxPerks["specialty_tacticalinsertion"] = true;
+	level.fauxPerks["specialty_shield"] = true;
+
+
+	/*
+	level.perkSetFuncs[""] = ::;
+	level.perkUnsetFuncs[""] = ::;
+	*/
+
+	level.perkSetFuncs["specialty_blastshield"] = ::setBlastShield;
+	level.perkUnsetFuncs["specialty_blastshield"] = ::unsetBlastShield;
+
+	level.perkSetFuncs["specialty_siege"] = ::setSiege;
+	level.perkUnsetFuncs["specialty_siege"] = ::unsetSiege;
+	
+	level.perkSetFuncs["specialty_falldamage"] = ::setFreefall;
+	level.perkUnsetFuncs["specialty_falldamage"] = ::unsetFreefall;
+	
+	level.perkSetFuncs["specialty_localjammer"] = ::setLocalJammer;
+	level.perkUnsetFuncs["specialty_localjammer"] = ::unsetLocalJammer;
+
+	level.perkSetFuncs["specialty_thermal"] = ::setThermal;
+	level.perkUnsetFuncs["specialty_thermal"] = ::unsetThermal;
+	
+	level.perkSetFuncs["specialty_blackbox"] = ::setBlackBox;
+	level.perkUnsetFuncs["specialty_blackbox"] = ::unsetBlackBox;
+	
+	level.perkSetFuncs["specialty_lightweight"] = ::setLightWeight;
+	level.perkUnsetFuncs["specialty_lightweight"] = ::unsetLightWeight;
+	
+	level.perkSetFuncs["specialty_steelnerves"] = ::setSteelNerves;
+	level.perkUnsetFuncs["specialty_steelnerves"] = ::unsetSteelNerves;
+	
+	level.perkSetFuncs["specialty_delaymine"] = ::setDelayMine;
+	level.perkUnsetFuncs["specialty_delaymine"] = ::unsetDelayMine;
+			
+	level.perkSetFuncs["specialty_finalstand"] = ::setFinalStand;
+	level.perkUnsetFuncs["specialty_finalstand"] = ::unsetFinalStand;
+	
+	level.perkSetFuncs["specialty_combathigh"] = ::setCombatHigh;
+	level.perkUnsetFuncs["specialty_combathigh"] = ::unsetCombatHigh;
+	
+	level.perkSetFuncs["specialty_challenger"] = ::setChallenger;
+	level.perkUnsetFuncs["specialty_challenger"] = ::unsetChallenger;
+	
+	level.perkSetFuncs["specialty_saboteur"] = ::setSaboteur;
+	level.perkUnsetFuncs["specialty_saboteur"] = ::unsetSaboteur;
+	
+	level.perkSetFuncs["specialty_endgame"] = ::setEndGame;
+	level.perkUnsetFuncs["specialty_endgame"] = ::unsetEndGame;
+
+	level.perkSetFuncs["specialty_rearview"] = ::setRearView;
+	level.perkUnsetFuncs["specialty_rearview"] = ::unsetRearView;
+
+	level.perkSetFuncs["specialty_ac130"] = ::setAC130;
+	level.perkUnsetFuncs["specialty_ac130"] = ::unsetAC130;
+
+	level.perkSetFuncs["specialty_sentry_minigun"] = ::setSentryMinigun;
+	level.perkUnsetFuncs["specialty_sentry_minigun"] = ::unsetSentryMinigun;
+
+	level.perkSetFuncs["specialty_predator_missile"] = ::setPredatorMissile;
+	level.perkUnsetFuncs["specialty_predator_missile"] = ::unsetPredatorMissile;
+	
+	level.perkSetFuncs["specialty_tank"] = ::setTank;
+	level.perkUnsetFuncs["specialty_tank"] = ::unsetTank;
+
+	level.perkSetFuncs["specialty_precision_airstrike"] = ::setPrecision_airstrike;
+	level.perkUnsetFuncs["specialty_precision_airstrike"] = ::unsetPrecision_airstrike;
+	
+	level.perkSetFuncs["specialty_helicopter_minigun"] = ::setHelicopterMinigun;
+	level.perkUnsetFuncs["specialty_helicopter_minigun"] = ::unsetHelicopterMinigun;
+	
+	level.perkSetFuncs["specialty_carepackage"] = ::setCarePackage;
+	level.perkUnsetFuncs["specialty_carepackage"] = ::unsetCarePackage;	
+
+	level.perkSetFuncs["specialty_onemanarmy"] = ::setOneManArmy;
+	level.perkUnsetFuncs["specialty_onemanarmy"] = ::unsetOneManArmy;	
+	
+	level.perkSetFuncs["specialty_littlebird_support"] = ::setLittlebirdSupport;
+	level.perkUnsetFuncs["specialty_littlebird_support"] = ::unsetLittlebirdSupport;
+	
+	level.perkSetFuncs["specialty_c4death"] = ::setC4Death;
+	level.perkUnsetFuncs["specialty_c4death"] = ::unsetC4Death;
+	
+	level.perkSetFuncs["specialty_tacticalinsertion"] = ::setTacticalInsertion;
+	level.perkUnsetFuncs["specialty_tacticalinsertion"] = ::unsetTacticalInsertion;
+
+	initPerkDvars();
+
+	level thread onPlayerConnect();
+}
+
+
+
+precacheShaders()
+{
+	precacheShader( "specialty_blastshield" );
+}
+
+
+givePerk( perkName )
+{	
+	if ( IsSubStr( perkName, "_mp" ) )
+	{
+		if ( perkName == "frag_grenade_mp" )
+			self SetOffhandPrimaryClass( "frag" );
+		if ( perkName == "throwingknife_mp" )
+			self SetOffhandPrimaryClass( "throwingknife" );
+		
+		self _giveWeapon( perkName, 0 );
+		self giveStartAmmo( perkName );
+		
+		self setPerk( perkName, false );
+		return;
+	}
+
+	if ( isSubStr( perkName, "specialty_null" ) || isSubStr( perkName, "specialty_weapon_" ) )
+	{
+		self setPerk( perkName, false );
+		return;
+	}
+		
+	self _setPerk( perkName );
+
+}
+
+
+validatePerk( perkIndex, perkName )
+{	
+	if ( getDvarInt ( "scr_game_perks" ) == 0 )
+	{
+		if ( tableLookup( "mp/perkTable.csv", 1, perkName, 5 ) != "equipment" )
+			return "specialty_null";
+	}
+
+	/* Validation disabled for now	
+	if ( tableLookup( "mp/perkTable.csv", 1, perkName, 5 ) != ("perk"+perkIndex) )
+	{
+		println( "^1Warning: (" + self.name + ") Perk " + perkName + " is not allowed for perk slot index " + perkIndex + "; replacing with no perk" );
+		return "specialty_null";
+	}
+	*/
+
+	return perkName;
+}
+
+
+onPlayerConnect()
+{
+	for(;;)
+	{
+		level waittill( "connected", player );
+		player thread onPlayerSpawned();		
+	}
+}
+
+
+onPlayerSpawned()
+{
+	self endon( "disconnect" );
+
+	self.perks = [];
+	self.weaponList = [];
+	self.omaClassChanged = false;
+		 
+	for( ;; )
+	{
+		self waittill( "spawned_player" );
+
+		self.omaClassChanged = false;
+		self thread gambitUseTracker();
+	}
+}
+
+
+drawLine( start, end, timeSlice )
+{
+	drawTime = int(timeSlice * 20);
+	for( time = 0; time < drawTime; time++ )
+	{
+		line( start, end, (1,0,0),false, 1 );
+		wait ( 0.05 );
+	}
+}
+
+
+cac_modified_damage( victim, attacker, damage, meansofdeath, weapon, impactPoint, impactDir, hitLoc )
+{
+	assert( isPlayer( victim ) );
+	assert( isDefined( victim.team ) );
+	
+	damageAdd = 0;
+
+	if ( isPrimaryDamage( meansOfDeath ) )
+	{	
+		assert( isDefined( attacker ) );
+
+		if ( isPlayer( attacker ) && weaponInheritsPerks( weapon ) && attacker _hasPerk( "specialty_bulletdamage" ) && victim _hasPerk( "specialty_armorvest" ) )
+			damageAdd += 0;
+		else if ( isPlayer( attacker ) && weaponInheritsPerks( weapon ) && attacker _hasPerk( "specialty_bulletdamage" ) )
+			damageAdd += damage*level.bulletDamageMod;
+		else if ( victim _hasPerk( "specialty_armorvest" ) )
+			damageAdd -= damage*(1-level.armorVestMod);
+
+		if ( isPlayer( attacker ) && attacker _hasPerk( "specialty_fmj" ) && victim _hasPerk ( "specialty_armorvest" ) )
+			damageAdd += damage*level.hollowPointDamageMod;	
+	}
+	else if ( isExplosiveDamage( meansOfDeath ) )
+	{
+		if ( isPlayer( attacker ) && weaponInheritsPerks( weapon ) && attacker _hasPerk( "specialty_explosivedamage" ) && victim _hasPerk( "_specialty_blastshield" ) )
+			damageAdd += 0;
+		else if ( isPlayer( attacker ) && weaponInheritsPerks( weapon ) && attacker _hasPerk( "specialty_explosivedamage" ) )
+			damageAdd += damage*level.explosiveDamageMod;
+		else if ( victim _hasPerk( "_specialty_blastshield" ) )
+			damageAdd -= damage*(1-level.blastShieldMod);
+			
+		if ( isKillstreakWeapon( weapon ) && isPlayer( attacker ) && attacker _hasPerk("specialty_dangerclose") )
+			damageAdd += damage*level.dangerCloseMod;
+	}
+	else if (meansOfDeath == "MOD_FALLING")
+	{
+		if ( victim _hasPerk( "specialty_falldamage" ) )
+		{	
+			//eventually set a msg to do a roll
+			damageAdd = 0;
+			damage = 0;
+		}	
+	}
+	
+	if ( ( victim.xpScaler == 2 && isDefined( attacker ) ) && ( isPlayer( attacker ) || attacker.classname == "scrip_vehicle" ) )
+		damageAdd += 200;
+	
+	/*if ( victim _hasperk( "specialty_combathigh" ) )
+	{
+		if ( IsDefined( self.damageBlockedTotal ) && (!level.teamBased || (isDefined( attacker ) && isDefined( attacker.team ) && victim.team != attacker.team)) )
+		{
+			damageTotal = damage + damageAdd;
+			damageBlocked = (damageTotal - ( damageTotal / 3 ));
+			self.damageBlockedTotal += damageBlocked;
+			
+			if ( self.damageBlockedTotal >= 101 )
+			{
+				self notify( "combathigh_survived" );
+				self.damageBlockedTotal = undefined;
+			}
+		}
+
+		if ( weapon != "throwingknife_mp" )
+		{
+			switch ( meansOfDeath )
+			{
+				case "MOD_FALLING":
+				case "MOD_MELEE":
+					break;
+				default:
+					damage = damage/3;
+					damageAdd = damageAdd/3;
+					break;
+			}
+		}
+	}*/	
+	
+	return int( damage + damageAdd );
+}
+
+initPerkDvars()
+{	
+	level.bulletDamageMod = getIntProperty( "perk_bulletDamage", 40 )/100;			// increased bullet damage by this %
+	level.hollowPointDamageMod = getIntProperty( "perk_hollowPointDamage", 65 )/100;	// increased bullet damage by this %
+	level.armorVestMod = getIntProperty( "perk_armorVest", 75 )/100;					// percentage of damage you take
+	level.explosiveDamageMod = getIntProperty( "perk_explosiveDamage", 40 )/100;		// increased explosive damage by this %
+	level.blastShieldMod = getIntProperty( "perk_blastShield", 45 )/100;					// percentage of damage you take
+	level.riotShieldMod = getIntProperty( "perk_riotShield", 100 )/100;
+	level.dangerCloseMod = getIntProperty( "perk_dangerClose", 100 )/100;
+	level.armorPiercingMod = getIntProperty( "perk_armorPiercingDamage", 40 )/100;			// increased bullet damage by this %
+}
+
+// CAC: Selector function, calls the individual cac features according to player's class settings
+// Info: Called every time player spawns during loadout stage
+cac_selector()
+{
+	perks = self.specialty;
+
+	/*
+	self.detectExplosives = false;
+
+	if ( self _hasPerk( "specialty_detectexplosive" ) )
+		self.detectExplosives = true;
+		
+	maps\mp\gametypes\_weapons::setupBombSquad();
+	*/
+}
+
+
+gambitUseTracker()
+{
+	self endon ( "death" );
+	self endon ( "disconnect" );
+	level endon ( "game_ended" );
+
+	if ( getDvarInt ( "scr_game_perks" ) != 1 )
+		return;
+		
+	gameFlagWait( "prematch_done" );
+
+	self notifyOnPlayerCommand( "gambit_on", "+frag" );
+}