#include common_scripts\utility;
#include maps\_utility;
#include maps\_hud_util;
#using_animtree("generic_human");
level_notify_listener()
{
	while(1)
	{
		val = GetDvar( #"level_notify");
		if(val != "")
		{
			level notify(val);
			SetDvar("level_notify", "");
		}
		wait(0.2);
	}
}
client_notify_listener()
{
	while(1)
	{
		val = GetDvar( #"client_notify");
		if(val != "")
		{
			ClientNotify(val);
			SetDvar("client_notify", "");
		}
		wait(0.2);
	}
}
save_game_on_notify()
{
	while (1)
	{
		level waittill("save");
		SaveGame("debug_save");
	}
}
onFirstPlayerReady()
{
	level waittill( "first_player_ready", player );
	println( "*********************First player connected to game." );
}
set_early_level()
{
	level.early_level = [];
	level.early_level["cuba"] = true;
	level.early_level["vorkuta"] = true;
}
setup_simple_primary_lights()
{
	flickering_lights = GetEntArray( "generic_flickering", "targetname" );
	pulsing_lights = GetEntArray( "generic_pulsing", "targetname" );
	double_strobe = GetEntArray( "generic_double_strobe", "targetname" );
	fire_flickers = GetEntArray( "fire_flicker", "targetname" );
	array_thread( flickering_lights, maps\_lights::generic_flickering );
	array_thread( pulsing_lights, maps\_lights::generic_pulsing );
	array_thread( double_strobe, maps\_lights::generic_double_strobe );
	array_thread( fire_flickers, maps\_lights::fire_flicker );
}
weapon_ammo()
{
	ents = GetEntArray();
	for( i = 0; i < ents.size; i ++ )
	{
		if( ( IsDefined( ents[i].classname ) ) &&( GetSubStr( ents[i].classname, 0, 7 ) == "weapon_" ) )
		{
			weap = ents[i];
			change_ammo = false;
			clip = undefined;
			extra = undefined;
			if( IsDefined( weap.script_ammo_clip ) )
			{
				clip = weap.script_ammo_clip;
				change_ammo = true;
			}
			if( IsDefined( weap.script_ammo_extra ) )
			{
				extra = weap.script_ammo_extra;
				change_ammo = true;
			}
			if( change_ammo )
			{
				if( !IsDefined( clip ) )
				{
					assertmsg( "weapon: " + weap.classname + " " + weap.origin + " sets script_ammo_extra but not script_ammo_clip" );
				}
				if( !IsDefined( extra ) )
				{
					assertmsg( "weapon: " + weap.classname + " " + weap.origin + " sets script_ammo_clip but not script_ammo_extra" );
				}
				weap ItemWeaponSetAmmo( clip, extra );
				weap ItemWeaponSetAmmo( clip, extra, 1 );
			}
		}
	}
}
trigger_group()
{
	self thread trigger_group_remove();
	level endon( "trigger_group_" + self.script_trigger_group );
	self waittill( "trigger" );
	level notify( "trigger_group_" + self.script_trigger_group, self );
}
trigger_group_remove()
{
	level waittill( "trigger_group_" + self.script_trigger_group, trigger );
	if( self != trigger )
	{
		self Delete();
	}
}
exploder_load( trigger )
{
	level endon( "killexplodertridgers"+trigger.script_exploder );
	trigger waittill( "trigger" );
	if( IsDefined( trigger.script_chance ) && RandomFloat( 1 )>trigger.script_chance )
	{
		if( IsDefined( trigger.script_delay ) )
		{
			wait( trigger.script_delay );
		}
		else
		{
			wait( 4 );
		}
		level thread exploder_load( trigger );
		return;
	}
	exploder( trigger.script_exploder );
	level notify( "killexplodertridgers"+trigger.script_exploder );
}
setup_traversals()
{
	potential_traverse_nodes = GetAllNodes();
	for (i = 0; i < potential_traverse_nodes.size; i++)
	{
		node = potential_traverse_nodes[i];
		if (node.type == "Begin")
		{
			node call_overloaded_func( "animscripts\traverse\shared", "init_traverse" );
		}
	}
}
badplace_think( badplace )
{
	if( !IsDefined( level.badPlaces ) )
	{
		level.badPlaces = 0;
	}
	level.badPlaces++;
	Badplace_Cylinder( "badplace" + level.badPlaces, -1, badplace.origin, badplace.radius, 1024 );
}
setupExploders()
{
	level.exploders = [];
	ents = GetEntArray( "script_brushmodel", "classname" );
	smodels = GetEntArray( "script_model", "classname" );
	for( i = 0; i < smodels.size; i++ )
	{
		ents[ents.size] = smodels[i];
	}
	for( i = 0; i < ents.size; i++ )
	{
		if( IsDefined( ents[i].script_prefab_exploder ) )
		{
			ents[i].script_exploder = ents[i].script_prefab_exploder;
		}
		if( IsDefined( ents[i].script_exploder ) )
		{
			if( ents[i].script_exploder < 10000 )
			{
				level.exploders[ents[i].script_exploder] = true;
			}
			if( ( ents[i].model == "fx" ) &&( ( !IsDefined( ents[i].targetname ) ) ||( ents[i].targetname != "exploderchunk" ) ) )
			{
				ents[i] Hide();
			}
			else if( ( IsDefined( ents[i].targetname ) ) &&( ents[i].targetname == "exploder" ) )
			{
				ents[i] Hide();
				ents[i] NotSolid();
				if( IsDefined( ents[i].script_disconnectpaths ) )
					ents[i] ConnectPaths();
			}
			else if( ( IsDefined( ents[i].targetname ) ) &&( ents[i].targetname == "exploderchunk" ) )
			{
				ents[i] Hide();
				ents[i] NotSolid();
				if( ents[i] has_spawnflag(level.SPAWNFLAG_MODEL_DYNAMIC_PATH))
				{
					ents[i] ConnectPaths();
				}
			}
		}
	}
	script_exploders = [];
	potentialExploders = GetEntArray( "script_brushmodel", "classname" );
	for( i = 0; i < potentialExploders.size; i++ )
	{
		if( IsDefined( potentialExploders[i].script_prefab_exploder ) )
		{
			potentialExploders[i].script_exploder = potentialExploders[i].script_prefab_exploder;
		}
		if( IsDefined( potentialExploders[i].script_exploder ) )
		{
			script_exploders[script_exploders.size] = potentialExploders[i];
		}
	}
	println("Server : Potential exploders from brushmodels " + potentialExploders.size);
	potentialExploders = GetEntArray( "script_model", "classname" );
	for( i = 0; i < potentialExploders.size; i++ )
	{
		if( IsDefined( potentialExploders[i].script_prefab_exploder ) )
		{
			potentialExploders[i].script_exploder = potentialExploders[i].script_prefab_exploder;
		}
		if( IsDefined( potentialExploders[i].script_exploder ) )
		{
			script_exploders[script_exploders.size] = potentialExploders[i];
		}
	}
	println("Server : Potential exploders from script_model " + potentialExploders.size);
	potentialExploders = GetEntArray( "item_health", "classname" );
	for( i = 0; i < potentialExploders.size; i++ )
	{
		if( IsDefined( potentialExploders[i].script_prefab_exploder ) )
		{
			potentialExploders[i].script_exploder = potentialExploders[i].script_prefab_exploder;
		}
		if( IsDefined( potentialExploders[i].script_exploder ) )
		{
			script_exploders[script_exploders.size] = potentialExploders[i];
		}
	}
	println("Server : Potential exploders from item_health " + potentialExploders.size);
	if( !IsDefined( level.createFXent ) )
	{
		level.createFXent = [];
	}
	acceptableTargetnames = [];
	acceptableTargetnames["exploderchunk visible"] = true;
	acceptableTargetnames["exploderchunk"] = true;
	acceptableTargetnames["exploder"] = true;
	exploderId = 1;
	for( i = 0; i < script_exploders.size; i++ )
	{
		exploder = script_exploders[i];
		ent = createExploder( exploder.script_fxid );
		ent.v = [];
		ent.v["origin"] = exploder.origin;
		ent.v["angles"] = exploder.angles;
		ent.v["delay"] = exploder.script_delay;
		ent.v["firefx"] = exploder.script_firefx;
		ent.v["firefxdelay"] = exploder.script_firefxdelay;
		ent.v["firefxsound"] = exploder.script_firefxsound;
		ent.v["firefxtimeout"] = exploder.script_firefxtimeout;
		ent.v["trailfx"] = exploder.script_trailfx;
		ent.v["trailfxtag"] = exploder.script_trailfxtag;
		ent.v["trailfxdelay"] = exploder.script_trailfxdelay;
		ent.v["trailfxsound"] = exploder.script_trailfxsound;
		ent.v["trailfxtimeout"] = exploder.script_firefxtimeout;
		ent.v["earthquake"] = exploder.script_earthquake;
		ent.v["rumble"] = exploder.script_rumble;
		ent.v["damage"] = exploder.script_damage;
		ent.v["damage_radius"] = exploder.script_radius;
		ent.v["repeat"] = exploder.script_repeat;
		ent.v["delay_min"] = exploder.script_delay_min;
		ent.v["delay_max"] = exploder.script_delay_max;
		ent.v["target"] = exploder.target;
		ent.v["ender"] = exploder.script_ender;
		ent.v["physics"] = exploder.script_physics;
		ent.v["type"] = "exploder";
		ent.v["exploder_server"] = exploder.script_exploder_server;
		if( !IsDefined( exploder.script_fxid ) )
		{
			ent.v["fxid"] = "No FX";
		}
		else
		{
			ent.v["fxid"] = exploder.script_fxid;
		}
		ent.v["exploder"] = exploder.script_exploder;
		assertex( IsDefined( exploder.script_exploder ), "Exploder at origin " + exploder.origin + " has no script_exploder" );
		if( !IsDefined( ent.v["delay"] ) )
		{
			ent.v["delay"] = 0;
		}
		if( IsDefined( exploder.script_sound ) )
		{
			ent.v["soundalias"] = exploder.script_sound;
		}
		else if( ent.v["fxid"] != "No FX" )
		{
			if( IsDefined( level.scr_sound ) && IsDefined( level.scr_sound[ent.v["fxid"]] ) )
			{
				ent.v["soundalias"] = level.scr_sound[ent.v["fxid"]];
			}
		}
		exploder_id_set = false;
		if( IsDefined( exploder.target ) )
		{
			temp_ent = GetEnt( ent.v["target"], "targetname" );
			if( IsDefined( temp_ent ) )
			{
				exploder_id_set = true;
				temp_ent setexploderid(exploderId);
				exploderId++;
				org = temp_ent.origin;
				temp_ent transmittargetname();
			}
			else
			{
				temp_ent = GetStruct( ent.v["target"], "targetname" );
				org = temp_ent.origin;
				exploderId++;
			}
			ent.v["angles"] = VectorToAngles( org - ent.v["origin"] );
		}
		if( exploder.classname == "script_brushmodel" || IsDefined( exploder.model ) )
		{
			if(exploder_id_set == false)
			{
				exploder setexploderid(exploderId);
				exploderId++;
				exploder_id_set = true;
			}
			ent.model = exploder;
			ent.model.disconnect_paths = exploder.script_disconnectpaths;
		}
		if( IsDefined( exploder.targetname ) && IsDefined( acceptableTargetnames[exploder.targetname] ) )
		{
			ent.v["exploder_type"] = exploder.targetname;
		}
		else
		{
			ent.v["exploder_type"] = "normal";
		}
		ent maps\_createfx::post_entity_creation_function();
	}
	for(i = 0; i < level.createFXent.size;i ++ )
	{
		ent = level.createFXent[i];
		if(ent.v["type"] != "exploder")
			continue;
		ent.v["exploder_id"] = getExploderId( ent );
	}
	reportExploderIds();
}
playerDamageRumble()
{
	while( true )
	{
		self waittill( "damage", amount );
		if( IsDefined( self.specialDamage ) )
		{
			continue;
		}
		self PlayRumbleOnEntity( "damage_heavy" );
	}
}
map_is_early_in_the_game()
{
	return level.early_level[level.script];
}
player_throwgrenade_timer()
{
	self endon( "death" );
	self endon( "disconnect" );
	self.lastgrenadetime = 0;
	while( 1 )
	{
		while( ! self IsThroWingGrenade() )
		{
			wait( .05 );
		}
		self.lastgrenadetime = GetTime();
		while( self IsThroWingGrenade() )
		{
			wait( .05 );
		}
	}
}
player_special_death_hint()
{
	self endon( "disconnect" );
	self thread player_throwgrenade_timer();
	if( isSplitScreen() || coopGame() )
	{
		return;
	}
	self waittill( "death", attacker, cause, weaponName, inflicter );
	if( cause != "MOD_GRENADE" && cause != "MOD_GRENADE_SPLASH" && cause != "MOD_SUICIDE" && cause != "MOD_EXPLOSIVE" && cause != "MOD_PROJECTILE" && cause != "MOD_PROJECTILE_SPLASH" )
	{
		return;
	}
	if ( level.gameskill >= 2 )
	{
		if ( !map_is_early_in_the_game() )
			return;
	}
	if( cause == "MOD_SUICIDE" )
	{
		TimeSinceThrown = GetTime() - self.lastgrenadetime;
		if ( ( TimeSinceThrown ) < 3.5 * 1000 || ( TimeSinceThrown ) > 4.5 * 1000 )
			return;
		level notify( "new_quote_string" );
		SetDvar( "ui_deadquote", "");
		self thread grenade_death_text_hudelement( &"SCRIPT_GRENADE_SUICIDE_LINE1", &"SCRIPT_GRENADE_SUICIDE_LINE2" );
		return;
	}
	if( cause == "MOD_EXPLOSIVE" )
	{
		if( IsDefined( attacker ) && ( attacker.classname == "script_vehicle" || IsDefined( attacker.create_fake_vehicle_damage ) ) )
		{
			level notify( "new_quote_string" );
			SetDvar( "ui_deadquote", "@SCRIPT_EXPLODING_VEHICLE_DEATH" );
			thread special_death_indicator_hudelement( "hud_burningcaricon", 96, 96 );
			return;
		}
		if( IsDefined( inflicter ) && IsDefined( inflicter.destructibledef ) )
		{
			if( IsSubStr( inflicter.destructibledef, "barrel_explosive" ) )
			{
				level notify( "new_quote_string" );
				SetDvar( "ui_deadquote", "@SCRIPT_EXPLODING_BARREL_DEATH" );
				thread special_death_indicator_hudelement( "hud_burningbarrelicon", 64, 64 );
				return;
			}
			if( IsDefined( inflicter.destructiblecar ) && inflicter.destructiblecar )
			{
				level notify( "new_quote_string" );
				SetDvar( "ui_deadquote", "@SCRIPT_EXPLODING_VEHICLE_DEATH" );
				thread special_death_indicator_hudelement( "hud_burningcaricon", 96, 96 );
				return;
			}
		}
	}
	if( cause == "MOD_GRENADE" || cause == "MOD_GRENADE_SPLASH" )
	{
		if( IsDefined( weaponName ) && (!IsWeaponDetonationTimed( weaponName ) || WeaponType( weaponName) != "grenade") )
		{
			return;
		}
		level notify( "new_quote_string" );
		if (IsDefined( weaponName ) && (weaponName == "explosive_bolt_sp"))
		{
			SetDvar( "ui_deadquote", "@SCRIPT_EXPLOSIVE_BOLT_DEATH" );
			thread explosive_arrow_death_indicator_hudelement();
		}
		else
		{
			SetDvar( "ui_deadquote", "@SCRIPT_GRENADE_DEATH" );
			thread grenade_death_indicator_hudelement();
		}
		return;
	}
}
grenade_death_text_hudelement( textLine1, textLine2 )
{
	self.failingMission = true;
	SetDvar( "ui_deadquote", "" );
	wait( .5 );
	fontElem = NewHudElem();
	fontElem.elemType = "font";
	fontElem.font = "default";
	fontElem.fontscale = 1.5;
	fontElem.x = 0;
	fontElem.y = -60;
	if(IsDefined(level.zombiemode) && level.zombiemode)
	{
		fontElem.y = - 65;
	}
	fontElem.alignX = "center";
	fontElem.alignY = "middle";
	fontElem.horzAlign = "center";
	fontElem.vertAlign = "middle";
	fontElem SetText( textLine1 );
	fontElem.foreground = true;
	fontElem.alpha = 0;
	fontElem FadeOverTime( 1 );
	fontElem.alpha = 1;
	fontElem.hidewheninmenu = true;
	if( IsDefined( textLine2 ) )
	{
		fontElem = NewHudElem();
		fontElem.elemType = "font";
		fontElem.font = "default";
		fontElem.fontscale = 1.5;
		fontElem.x = 0;
		fontElem.y = -60 + level.fontHeight * fontElem.fontscale;
		if(IsDefined(level.zombiemode) && level.zombiemode)
		{
			fontElem.y = -60 + level.fontHeight * fontElem.fontscale;
		}
		fontElem.alignX = "center";
		fontElem.alignY = "middle";
		fontElem.horzAlign = "center";
		fontElem.vertAlign = "middle";
		fontElem SetText( textLine2 );
		fontElem.foreground = true;
		fontElem.alpha = 0;
		fontElem FadeOverTime( 1 );
		fontElem.alpha = 1;
		fontElem.hidewheninmenu = true;
	}
}
grenade_death_indicator_hudelement()
{
	self endon( "disconnect" );
	wait( .5 );
	overlayIcon = NewClientHudElem( self );
	overlayIcon.x = 0;
	overlayIcon.y = 68;
	overlayIcon SetShader( "hud_grenadeicon", 50, 50 );
	overlayIcon.alignX = "center";
	overlayIcon.alignY = "middle";
	overlayIcon.horzAlign = "center";
	overlayIcon.vertAlign = "middle";
	overlayIcon.foreground = true;
	overlayIcon.alpha = 0;
	overlayIcon FadeOverTime( 1 );
	overlayIcon.alpha = 1;
	overlayIcon.hidewheninmenu = true;
	overlayPointer = NewClientHudElem( self );
	overlayPointer.x = 0;
	overlayPointer.y = 25;
	overlayPointer SetShader( "hud_grenadepointer", 50, 25 );
	overlayPointer.alignX = "center";
	overlayPointer.alignY = "middle";
	overlayPointer.horzAlign = "center";
	overlayPointer.vertAlign = "middle";
	overlayPointer.foreground = true;
	overlayPointer.alpha = 0;
	overlayPointer FadeOverTime( 1 );
	overlayPointer.alpha = 1;
	overlayPointer.hidewheninmenu = true;
	self thread grenade_death_indicator_hudelement_cleanup( overlayIcon, overlayPointer );
}
explosive_arrow_death_indicator_hudelement()
{
	self endon( "disconnect" );
	wait( .5 );
	overlayIcon = NewClientHudElem( self );
	overlayIcon.x = 0;
	overlayIcon.y = 68;
	overlayIcon SetShader( "hud_explosive_arrow_icon", 50, 50 );
	overlayIcon.alignX = "center";
	overlayIcon.alignY = "middle";
	overlayIcon.horzAlign = "center";
	overlayIcon.vertAlign = "middle";
	overlayIcon.foreground = true;
	overlayIcon.alpha = 0;
	overlayIcon FadeOverTime( 1 );
	overlayIcon.alpha = 1;
	overlayIcon.hidewheninmenu = true;
	overlayPointer = NewClientHudElem( self );
	overlayPointer.x = 0;
	overlayPointer.y = 25;
	overlayPointer SetShader( "hud_grenadepointer", 50, 25 );
	overlayPointer.alignX = "center";
	overlayPointer.alignY = "middle";
	overlayPointer.horzAlign = "center";
	overlayPointer.vertAlign = "middle";
	overlayPointer.foreground = true;
	overlayPointer.alpha = 0;
	overlayPointer FadeOverTime( 1 );
	overlayPointer.alpha = 1;
	overlayPointer.hidewheninmenu = true;
	self thread grenade_death_indicator_hudelement_cleanup( overlayIcon, overlayPointer );
}
grenade_death_indicator_hudelement_cleanup( hudElemIcon, hudElemPointer )
{
	self endon( "disconnect" );
	self waittill( "spawned" );
	hudElemIcon Destroy();
	hudElemPointer Destroy();
}
special_death_indicator_hudelement( shader, iWidth, iHeight, fDelay, x, y )
{
	if( !IsDefined( fDelay ) )
	{
		fDelay = 0.5;
	}
	wait( fDelay );
	overlay = NewClientHudElem( self );
	if( IsDefined( x ) )
		overlay.x = x;
	else
		overlay.x = 0;
	if( IsDefined( y ) )
		overlay.y = y;
	else
		overlay.y = 40;
	overlay SetShader( shader, iWidth, iHeight );
	overlay.alignX = "center";
	overlay.alignY = "middle";
	overlay.horzAlign = "center";
	overlay.vertAlign = "middle";
	overlay.foreground = true;
	overlay.alpha = 0;
	overlay FadeOverTime( 1 );
	overlay.alpha = 1;
	overlay.hidewheninmenu = true;
	self thread special_death_death_indicator_hudelement_cleanup( overlay );
}
special_death_death_indicator_hudelement_cleanup( overlay )
{
	self endon( "disconnect" );
	self waittill( "spawned" );
	overlay Destroy();
}
bcTrigger( trigger )
{
	realTrigger = undefined;
	if( IsDefined( trigger.target ) )
	{
		targetEnts = GetEntArray( trigger.target, "targetname" );
		if( IsSubStr( targetEnts[0].classname, "trigger" ) )
		{
			realTrigger = targetEnts[0];
		}
	}
	if( IsDefined( realTrigger ) )
	{
		realTrigger waittill( "trigger", other );
	}
	else
	{
		trigger waittill( "trigger", other );
	}
	soldier = undefined;
	if( IsDefined( realTrigger ) )
	{
		player_touching = get_player_touching( trigger );
		if( other.team == "axis" && IsDefined( player_touching ) )
		{
			soldier = get_closest_ai( player_touching GetOrigin(), "allies" );
			if( Distance( soldier.origin, player_touching GetOrigin() ) > 512 )
			{
				return;
			}
		}
		else if( other.team == "allies" )
		{
			soldiers = GetAiArray( "axis" );
			for( index = 0; index < soldiers.size; index++ )
			{
				if( soldiers[index] IsTouching( trigger ) )
				{
					soldier = soldiers[index];
				}
			}
		}
	}
	else if( IsPlayer( other ) )
	{
		soldier = get_closest_ai( other GetOrigin(), "allies" );
		if( Distance( soldier.origin, other GetOrigin() ) > 512 )
		{
			return;
		}
	}
	else
	{
		soldier = other;
	}
	if( !IsDefined( soldier ) )
	{
		return;
	}
	soldier custom_battlechatter( trigger.script_bctrigger );
}
waterThink()
{
	assert( IsDefined( self.target ) );
	targeted = GetEnt( self.target, "targetname" );
	assert( IsDefined( targeted ) );
	waterHeight = targeted.origin[2];
	targeted = undefined;
	level.depth_allow_prone = 8;
	level.depth_allow_crouch = 33;
	level.depth_allow_stand = 50;
	for( ;; )
	{
		wait( 0.05 );
		players = get_players();
		for( i = 0; i < players.size; i++ )
		{
			if( players[i].inWater )
			{
				players[i] AllowProne( true );
				players[i] AllowCrouch( true );
				players[i] AllowStand( true );
				thread waterThink_rampSpeed( level.default_run_speed );
			}
		}
		self waittill( "trigger", other );
		if( !IsPlayer( other ) )
		{
			continue;
		}
		while( 1 )
		{
			players = get_players();
			players_in_water_count = 0;
			for( i = 0; i < players.size; i++ )
			{
				if( players[i] IsTouching( self ) )
				{
					players_in_water_count++;
					players[i].inWater = true;
					playerOrg = players[i] GetOrigin();
					d = ( playerOrg[2] - waterHeight );
					if( d > 0 )
					{
						continue;
					}
					newSpeed = Int( level.default_run_speed - abs( d * 5 ) );
					if( newSpeed < 50 )
					{
						newSpeed = 50;
					}
					assert( newSpeed <= 190 );
					thread waterThink_rampSpeed( newSpeed );
					if( abs( d ) > level.depth_allow_crouch )
					{
						players[i] AllowCrouch( false );
					}
					else
					{
						players[i] AllowCrouch( true );
					}
					if( abs( d ) > level.depth_allow_prone )
					{
						players[i] AllowProne( false );
					}
					else
					{
						players[i] AllowProne( true );
					}
				}
				else
				{
					if( players[i].inWater )
					{
						players[i].inWater = false;
					}
				}
			}
			if( players_in_water_count == 0 )
			{
				break;
			}
			wait( 0.5 );
		}
		wait( 0.05 );
	}
	prof_end( "water_stance_controller" );
}
waterThink_rampSpeed( newSpeed )
{
	level notify( "ramping_water_movement_speed" );
	level endon( "ramping_water_movement_speed" );
}
massNodeInitFunctions()
{
	nodes = GetAllNodes();
	thread maps\_mgturret::auto_mgTurretLink( nodes );
	thread maps\_mgturret::saw_mgTurretLink( nodes );
	thread maps\_colors::init_color_grouping( nodes );
}
trigger_unlock( trigger )
{
	noteworthy = "not_set";
	if( IsDefined( trigger.script_noteworthy ) )
	{
		noteworthy = trigger.script_noteworthy;
	}
	target_triggers = GetEntArray( trigger.target, "targetname" );
	trigger thread trigger_unlock_death( trigger.target );
	for( ;; )
	{
		array_thread( target_triggers, ::trigger_off );
		trigger waittill( "trigger" );
		array_thread( target_triggers, ::trigger_on );
		wait_for_an_unlocked_trigger( target_triggers, noteworthy );
		array_notify( target_triggers, "relock" );
	}
}
trigger_unlock_death( target )
{
	self waittill( "death" );
	target_triggers = GetEntArray( target, "targetname" );
	array_thread( target_triggers, ::trigger_off );
}
wait_for_an_unlocked_trigger( triggers, noteworthy )
{
	level endon( "unlocked_trigger_hit" + noteworthy );
	ent = SpawnStruct();
	for( i = 0; i < triggers.size; i++ )
	{
		triggers[i] thread report_trigger( ent, noteworthy );
	}
	ent waittill( "trigger" );
	level notify( "unlocked_trigger_hit" + noteworthy );
}
report_trigger( ent, noteworthy )
{
	self endon( "relock" );
	level endon( "unlocked_trigger_hit" + noteworthy );
	self waittill( "trigger" );
	ent notify( "trigger" );
}
get_trigger_targs()
{
	triggers = [];
	target_origin = undefined;
	if( IsDefined( self.target ) )
	{
		targets = GetEntArray( self.target, "targetname" );
		orgs = [];
		for( i = 0; i < targets.size; i ++ )
		{
			if( targets[i].classname == "script_origin" )
			{
				orgs[orgs.size] = targets[i];
			}
			if( IsSubStr( targets[i].classname, "trigger" ) )
			{
				triggers[triggers.size] = targets[i];
			}
		}
		assertex( orgs.size < 2, "Trigger at " + self.origin + " targets multiple script origins" );
		if( orgs.size == 1 )
		{
			target_origin = orgs[0].origin;
			orgs[0] Delete();
		}
	}
	assertex( IsDefined( target_origin ), self.targetname + " at " + self.origin + " has no target origin." );
	array = [];
	array["triggers"] = triggers;
	array["target_origin"] = target_origin;
	return array;
}
trigger_lookat( trigger )
{
	trigger_lookat_think( trigger, true );
}
trigger_looking( trigger )
{
	trigger_lookat_think( trigger, false );
}
trigger_lookat_think( trigger, endOnFlag )
{
	dot = 0.78;
	if( IsDefined( trigger.script_dot ) )
	{
		dot = trigger.script_dot;
	}
	array = trigger get_trigger_targs();
	triggers = array["triggers"];
	target_origin = array["target_origin"];
	has_flag = IsDefined( trigger.script_flag ) || IsDefined( trigger.script_noteworthy );
	flagName = undefined;
	if( has_flag )
	{
		flagName = trigger get_trigger_flag();
		if( !IsDefined( level.flag[flagName] ) )
		{
			flag_init( flagName );
		}
	}
	else
	{
		if( !triggers.size )
		{
			assertex( IsDefined( trigger.script_flag ) || IsDefined( trigger.script_noteworthy ), "Trigger_lookat at " + trigger.origin + " has no script_flag! The script_flag is used as a flag that gets set when the trigger is activated." );
		}
	}
	if( endOnFlag && has_flag )
	{
		level endon( flagName );
	}
	trigger endon( "death" );
	for( ;; )
	{
		if( has_flag )
		{
			flag_clear( flagName );
		}
		trigger waittill( "trigger", other );
		assertex( IsPlayer( other ), "trigger_lookat currently only supports looking from the player" );
		if( !IsPlayer( other ) )
		{
			continue;
		}
		while( other IsTouching( trigger ) )
		{
			if( !SightTracePassed( other GetEye(), target_origin, false, undefined ) )
			{
				if( has_flag )
				{
					flag_clear( flagName );
				}
				wait( 0.5 );
				continue;
			}
			normal = VectorNormalize( target_origin - other.origin );
			player_angles = other GetPlayerAngles();
			player_forward = AnglesToForward( player_angles );
			dot = VectorDot( player_forward, normal );
			if( dot >= 0.78 )
			{
				if( has_flag )
				{
					flag_set( flagName );
				}
				array_thread( triggers, ::send_notify, "trigger" );
				if( endOnFlag )
				{
					return;
				}
				wait( 2 );
			}
			else
			{
				if( has_flag )
				{
					flag_clear( flagName );
				}
			}
			wait( 0.5 );
		}
	}
}
trigger_CanSee( trigger )
{
	triggers = [];
	target_origin = undefined;
	array = trigger get_trigger_targs();
	triggers = array["triggers"];
	target_origin = array["target_origin"];
	has_flag = IsDefined( trigger.script_flag ) || IsDefined( trigger.script_noteworthy );
	flagName = undefined;
	if( has_flag )
	{
		flagName = trigger get_trigger_flag();
		if( !IsDefined( level.flag[flagName] ) )
		{
			flag_init( flagName );
		}
	}
	else
	{
		if( !triggers.size )
		{
			assertex( IsDefined( trigger.script_flag ) || IsDefined( trigger.script_noteworthy ), "Trigger_cansee at " + trigger.origin + " has no script_flag! The script_flag is used as a flag that gets set when the trigger is activated." );
		}
	}
	trigger endon( "death" );
	range = 12;
	offsets = [];
	offsets[offsets.size] = ( 0, 0, 0 );
	offsets[offsets.size] = ( range, 0, 0 );
	offsets[offsets.size] = ( range * -1, 0, 0 );
	offsets[offsets.size] = ( 0, range, 0 );
	offsets[offsets.size] = ( 0, range * -1, 0 );
	offsets[offsets.size] = ( 0, 0, range );
	for( ;; )
	{
		if( has_flag )
		{
			flag_clear( flagName );
		}
		trigger waittill( "trigger", other );
		assertex( IsPlayer( other ), "trigger_cansee currently only supports looking from the player" );
		while( other IsTouching( trigger ) )
		{
			if( !( other cantraceto( target_origin, offsets ) ) )
			{
				if( has_flag )
				{
					flag_clear( flagName );
				}
				wait( 0.1 );
				continue;
			}
			if( has_flag )
			{
				flag_set( flagName );
			}
			array_thread( triggers, ::send_notify, "trigger" );
			wait( 0.5 );
		}
	}
}
cantraceto( target_origin, offsets )
{
	for( i = 0; i < offsets.size; i++ )
	{
		if( SightTracePassed( self GetEye(), target_origin + offsets[i], true, self ) )
		{
			return true;
		}
	}
	return false;
}
indicate_start( start )
{
	hudelem = NewHudElem();
	hudelem.alignX = "left";
	hudelem.alignY = "middle";
	hudelem.x = 70;
	hudelem.y = 400;
	hudelem.label = start;
	hudelem.alpha = 0;
	hudelem.fontScale = 3;
	wait( 1 );
	hudelem FadeOverTime( 1 );
	hudelem.alpha = 1;
	wait( 5 );
	hudelem FadeOverTime( 1 );
	hudelem.alpha = 0;
	wait( 1 );
	hudelem Destroy();
}
trigger_notify( trigger, msg )
{
	trigger endon( "death" );
	trigger waittill( "trigger", other );
	if(IsDefined(trigger.target))
	{
		notify_ent = GetEnt(trigger.target, "targetname");
		if(IsDefined(notify_ent))
		{
			notify_ent notify( msg, other );
		}
	}
	level notify( msg, other );
}
flag_set_player_trigger( trigger )
{
	flag = trigger get_trigger_flag();
	if( !IsDefined( level.flag[flag] ) )
	{
		flag_init( flag );
	}
	for( ;; )
	{
		trigger waittill( "trigger", other );
		if( !IsPlayer( other ) )
		{
			continue;
		}
		self script_delay();
		flag_set( flag );
	}
}
flag_set_trigger( trigger, flag_name )
{
	trigger endon( "death" );
	flag = trigger get_trigger_flag(flag_name);
	if( !IsDefined( level.flag[flag] ) )
	{
		flag_init( flag );
	}
	for( ;; )
	{
		trigger waittill( "trigger" );
		if (IsDefined(trigger.targetname) && (trigger.targetname == "flag_set"))
		{
			self script_delay();
		}
		flag_set( flag );
	}
}
flag_clear_trigger( trigger, flag_name )
{
	trigger endon( "death" );
	flag = trigger get_trigger_flag(flag_name);
	if( !IsDefined( level.flag[flag] ) )
	{
		flag_init( flag );
	}
	for( ;; )
	{
		trigger waittill( "trigger" );
		if (IsDefined(trigger.targetname) && (trigger.targetname == "flag_clear"))
		{
			self script_delay();
		}
		flag_clear( flag );
	}
}
add_tokens_to_trigger_flags( tokens )
{
	for( i = 0; i < tokens.size; i++ )
	{
		flag = tokens[i];
		if( !IsDefined( level.trigger_flags[flag] ) )
		{
			level.trigger_flags[flag] = [];
		}
		level.trigger_flags[flag][level.trigger_flags[flag].size] = self;
	}
}
script_flag_false_trigger( trigger )
{
	tokens = create_flags_and_return_tokens( trigger.script_flag_false );
	trigger add_tokens_to_trigger_flags( tokens );
	trigger update_trigger_based_on_flags();
}
script_flag_true_trigger( trigger )
{
	tokens = create_flags_and_return_tokens( trigger.script_flag_true );
	trigger add_tokens_to_trigger_flags( tokens );
	trigger update_trigger_based_on_flags();
}
wait_for_flag( tokens )
{
	for( i = 0; i < tokens.size; i++ )
	{
		level endon( tokens[i] );
	}
	level waittill( "foreverrr" );
}
friendly_respawn_trigger( trigger )
{
	spawners = GetEntArray( trigger.target, "targetname" );
	assertex( spawners.size == 1, "friendly_respawn_trigger targets multiple spawner with targetname " + trigger.target + ". Should target just 1 spawner." );
	spawner = spawners[0];
	assertex( !IsDefined( spawner.script_forcecolor ), "targeted spawner at " + spawner.origin + " should not have script_forcecolor set!" );
	spawners = undefined;
	spawner endon( "death" );
	for( ;; )
	{
		trigger waittill( "trigger" );
		if( IsDefined( trigger.script_forcecolor ) )
		{
			level.respawn_spawners_specific[trigger.script_forcecolor] = spawner;
		}
		else
		{
			level.respawn_spawner = spawner;
		}
		flag_set( "respawn_friendlies" );
		wait( 0.5 );
	}
}
friendly_respawn_clear( trigger )
{
	for( ;; )
	{
		trigger waittill( "trigger" );
		flag_clear( "respawn_friendlies" );
		wait( 0.5 );
	}
}
trigger_ignore( trigger )
{
	thread trigger_runs_function_on_touch( trigger, ::set_ignoreme, ::get_ignoreme );
}
trigger_pacifist( trigger )
{
	thread trigger_runs_function_on_touch( trigger, ::set_pacifist, ::get_pacifist );
}
trigger_runs_function_on_touch( trigger, set_func, get_func )
{
	for( ;; )
	{
		trigger waittill( "trigger", other );
		if( !IsAlive( other ) )
		{
			continue;
		}
		if( other[[get_func]]() )
		{
			continue;
		}
		other thread touched_trigger_runs_func( trigger, set_func );
	}
}
touched_trigger_runs_func( trigger, set_func )
{
	self endon( "death" );
	self.ignoreme = true;
	[[set_func]]( true );
	self.ignoretriggers = true;
	wait( 1 );
	self.ignoretriggers = false;
	while( self IsTouching( trigger ) )
	{
		wait( 1 );
	}
	[[set_func]]( false );
}
trigger_turns_off( trigger )
{
	trigger waittill( "trigger" );
	trigger trigger_off();
	if( !IsDefined( trigger.script_linkTo ) )
	{
		return;
	}
	tokens = Strtok( trigger.script_linkto, " " );
	for( i = 0; i < tokens.size; i++ )
	{
		array_thread( GetEntArray( tokens[i], "script_linkname" ), ::trigger_off );
	}
}
script_gen_dump_checksaved()
{
	signatures = GetArrayKeys( level.script_gen_dump );
	for( i = 0; i < signatures.size; i++ )
	{
		if( !IsDefined( level.script_gen_dump2[signatures[i]] ) )
		{
			level.script_gen_dump[signatures[i]] = undefined;
			level.script_gen_dump_reasons[level.script_gen_dump_reasons.size] = "Signature unmatched( removed feature ): "+signatures[i];
		}
	}
}
script_gen_dump()
{
	assertex( !level.bScriptgened, "SCRIPTGEN generated: follow instructions listed above this error in the console" );
	if( level.bScriptgened )
	{
		assertmsg( "SCRIPTGEN updated: Rebuild fast file and run map again" );
	}
	flag_set( "scriptgen_done" );
}
script_gen_csvdumpprintln( file, signature )
{
	prefix = undefined;
	writtenprefix = undefined;
	path = "";
	extension = "";
	if( IsSubStr( signature, "ignore" ) )
	{
		prefix = "ignore";
	}
	else if( IsSubStr( signature, "col_map_sp" ) )
	{
		prefix = "col_map_sp";
	}
	else if( IsSubStr( signature, "gfx_map" ) )
	{
		prefix = "gfx_map";
	}
	else if( IsSubStr( signature, "rawfile" ) )
	{
		prefix = "rawfile";
	}
	else if( IsSubStr( signature, "sound" ) )
	{
		prefix = "sound";
	}
	else if( IsSubStr( signature, "xmodel" ) )
	{
		prefix = "xmodel";
	}
	else if( IsSubStr( signature, "xanim" ) )
	{
		prefix = "xanim";
	}
	else if( IsSubStr( signature, "item" ) )
	{
		prefix = "item";
		writtenprefix = "weapon";
		path = "sp/";
	}
	else if( IsSubStr( signature, "fx" ) )
	{
		prefix = "fx";
	}
	else if( IsSubStr( signature, "menu" ) )
	{
		prefix = "menu";
		writtenprefix = "menufile";
		path = "ui/scriptmenus/";
		extension = ".menu";
	}
	else if( IsSubStr( signature, "rumble" ) )
	{
		prefix = "rumble";
		writtenprefix = "rawfile";
		path = "rumble/";
	}
	else if( IsSubStr( signature, "shader" ) )
	{
		prefix = "shader";
		writtenprefix = "material";
	}
	else if( IsSubStr( signature, "shock" ) )
	{
		prefix = "shock";
		writtenprefix = "rawfile";
		extension = ".shock";
		path = "shock/";
	}
	else if( IsSubStr( signature, "string" ) )
	{
		prefix = "string";
		assertmsg( "string not yet supported by scriptgen" );
	}
	else if( IsSubStr( signature, "turret" ) )
	{
		prefix = "turret";
		writtenprefix = "weapon";
		path = "sp/";
	}
	else if( IsSubStr( signature, "vehicle" ) )
	{
		prefix = "vehicle";
		writtenprefix = "rawfile";
		path = "vehicles/";
	}
	if( !IsDefined( prefix ) )
	{
		return;
	}
	if( !IsDefined( writtenprefix ) )
	{
		string = prefix+", "+GetSubStr( signature, prefix.size+1, signature.size );
	}
	else
	{
		string = writtenprefix+", "+path+GetSubStr( signature, prefix.size+1, signature.size )+extension;
	}
	if( file == -1 || !level.bCSVgened )
	{
		println( string );
	}
	else
	{
		FPrintLn( file, string );
	}
}
script_gen_dumpprintln( file, string )
{
	if( file == -1 || !level.bScriptgened )
	{
		println( string );
	}
	else
	{
		FPrintLn( file, string );
	}
}
trigger_hInt( trigger )
{
	assertex( IsDefined( trigger.script_hint ), "Trigger_hint at " + trigger.origin + " has no .script_hint" );
	trigger endon( "death" );
	if( !IsDefined( level.displayed_hints ) )
	{
		level.displayed_hints = [];
	}
	waittillframeend;
	hint = trigger.script_hint;
	assertex( IsDefined( level.trigger_hint_string[hint] ), "Trigger_hint with hint " + hint + " had no hint string assigned to it. Define hint strings with add_hint_string()" );
	trigger waittill( "trigger", other );
	assertex( IsPlayer( other ), "Tried to do a trigger_hint on a non player entity" );
	if( IsDefined( level.displayed_hints[hint] ) )
	{
		return;
	}
	level.displayed_hints[hint] = true;
	display_hInt( hint );
}
throw_grenade_at_player_trigger( trigger )
{
	trigger endon( "death" );
	trigger waittill( "trigger" );
	ThrowGrenadeAtPlayerASAP();
}
flag_on_cleared( trigger )
{
	flag = trigger get_trigger_flag();
	if( !IsDefined( level.flag[flag] ) )
	{
		flag_init( flag );
	}
	for( ;; )
	{
		trigger waittill( "trigger" );
		wait( 1 );
		if( trigger found_toucher() )
		{
			continue;
		}
		break;
	}
	flag_set( flag );
}
found_toucher()
{
	ai = GetAiArray( "axis" );
	for( i = 0; i < ai.size; i++ )
	{
		guy = ai[i];
		if( !IsAlive( guy ) )
		{
			continue;
		}
		if( guy IsTouching( self ) )
		{
			return true;
		}
		wait( 0.1 );
	}
	ai = GetAiArray( "axis" );
	for( i = 0; i < ai.size; i++ )
	{
		guy = ai[i];
		if( guy IsTouching( self ) )
		{
			return true;
		}
	}
	return false;
}
trigger_delete_on_touch( trigger )
{
	for( ;; )
	{
		trigger waittill( "trigger", other );
		if( IsDefined( other ) )
		{
			other Delete();
		}
	}
}
flag_set_touching( trigger )
{
	flag = trigger get_trigger_flag();
	if( !IsDefined( level.flag[flag] ) )
	{
		flag_init( flag );
	}
	for( ;; )
	{
		trigger waittill( "trigger", other );
		flag_set( flag );
		while( IsAlive( other ) && other IsTouching( trigger ) && IsDefined( trigger ) )
		{
			wait( 0.25 );
		}
		flag_clear( flag );
	}
}
add_nodes_mins_maxs( nodes )
{
	for( index = 0; index < nodes.size; index++ )
	{
		origin = nodes[index].origin;
		level.nodesMins = expandMins( level.nodesMins, origin );
		level.nodesMaxs = expandMaxs( level.nodesMaxs, origin );
	}
}
calculate_map_center()
{
	if( !IsDefined( level.mapCenter ) )
	{
		level.nodesMins = ( 0, 0, 0 );
		level.nodesMaxs = ( 0, 0, 0 );
		nodes = GetAllNodes();
		if( IsDefined( nodes[0] ) )
		{
			level.nodesMins = nodes[0].origin;
			level.nodesMaxs = nodes[0].origin;
		}
		add_nodes_mins_maxs( nodes );
		level.mapCenter = findBoxCenter( level.nodesMins, level.nodesMaxs );
		SetMapCenter( level.mapCenter );
	}
}
SetObjectiveTextColors()
{
	MY_TEXTBRIGHTNESS_DEFAULT = "1.0 1.0 1.0";
	MY_TEXTBRIGHTNESS_90 = "0.9 0.9 0.9";
	MY_TEXTBRIGHTNESS_85 = "0.85 0.85 0.85";
	if( level.script == "armada" )
	{
		SetSavedDvar( "con_typewriterColorBase", MY_TEXTBRIGHTNESS_90 );
		return;
	}
	SetSavedDvar( "con_typewriterColorBase", MY_TEXTBRIGHTNESS_DEFAULT );
}
get_script_linkto_targets()
{
	targets = [];
	if( !IsDefined( self.script_linkto ) )
	{
		return targets;
	}
	tokens = Strtok( self.script_linkto, " " );
	for( i = 0; i < tokens.size; i++ )
	{
		token = tokens[i];
		target = GetEnt( token, "script_linkname" );
		if( IsDefined( target ) )
		{
			targets[targets.size] = target;
		}
	}
	return targets;
}
delete_link_chain( trigger )
{
	trigger waittill( "trigger" );
	targets = trigger get_script_linkto_targets();
	array_thread( targets, ::delete_links_then_self );
}
delete_links_then_self()
{
	targets = get_script_linkto_targets();
	array_thread( targets, ::delete_links_then_self );
	self Delete();
}
defer_vision_set_naked(vision, time)
{
	if(NumRemoteClients())
	{
		wait_network_frame();
	}
	self VisionSetNaked( vision, time );
}
trigger_fog( trigger )
{
	trigger endon( "death" );
	dofog = true;
	if( !IsDefined( trigger.script_start_dist ) )
	{
		dofog = false;
	}
	if( !IsDefined( trigger.script_halfway_dist ) )
	{
		dofog = false;
	}
	if( !IsDefined( trigger.script_halfway_height ) )
	{
		dofog = false;
	}
	if( !IsDefined( trigger.script_base_height ) )
	{
		dofog = false;
	}
	if( !IsDefined( trigger.script_color ) )
	{
		dofog = false;
	}
	if( !IsDefined( trigger.script_color_scale ) )
	{
		dofog = false;
	}
	if( !IsDefined( trigger.script_transition_time ) )
	{
		dofog = false;
	}
	if( !IsDefined( trigger.script_sun_color ) )
	{
		dofog = false;
	}
	if( !IsDefined( trigger.script_sun_direction ) )
	{
		dofog = false;
	}
	if( !IsDefined( trigger.script_sun_start_ang ) )
	{
		dofog = false;
	}
	if( !IsDefined( trigger.script_sun_stop_ang ) )
	{
		dofog = false;
	}
	if( !IsDefined( trigger.script_max_fog_opacity ) )
	{
		dofog = false;
	}
	do_sunsamplesize = false;
	sunsamplesize_time = undefined;
	if( IsDefined( trigger.script_sunsample ) )
	{
		do_sunsamplesize = false;
		trigger.lerping_dvar["sm_sunSampleSizeNear"] = false;
		sunsamplesize_time = 1;
		if( IsDefined( trigger.script_transition_time ) )
		{
			sunsamplesize_time = trigger.script_sunsample_time;
		}
		if( IsDefined( trigger.script_sunsample_time ) )
		{
			sunsamplesize_time = trigger.script_sunsample_time;
		}
	}
	for( ;; )
	{
		trigger waittill( "trigger", other );
		assertex( IsPlayer( other ), "Non-player entity touched a trigger_fog." );
		wait( 0.05 );
		players = get_players();
		for(i = 0; i < players.size; i ++)
		{
			player = players[i];
			if(player istouching(trigger))
			{
				if( !IsSplitscreen() )
				{
					if( dofog && ( !isdefined(player.fog_trigger_current) || player.fog_trigger_current != trigger ))
					{
						player SetVolFog( trigger.script_start_dist,
						trigger.script_halfway_dist,
						trigger.script_halfway_height,
						trigger.script_base_height,
						trigger.script_color[0],
						trigger.script_color[1],
						trigger.script_color[2],
						trigger.script_color_scale,
						trigger.script_sun_color[0],
						trigger.script_sun_color[1],
						trigger.script_sun_color[2],
						trigger.script_sun_direction[0],
						trigger.script_sun_direction[1],
						trigger.script_sun_direction[2],
						trigger.script_sun_start_ang,
						trigger.script_sun_stop_ang,
						trigger.script_transition_time,
						trigger.script_max_fog_opacity );
					}
				}
				if( (IsDefined( trigger.script_vision ) && IsDefined( trigger.script_vision_time )) && ( !isdefined(player.fog_trigger_current) || player.fog_trigger_current != trigger ) )
				{
					player thread defer_vision_set_naked(trigger.script_vision, trigger.script_vision_time);
				}
				player.fog_trigger_current = trigger;
			}
		}
		players = get_players();
		if( players.size > 1 )
		{
			if( do_sunsamplesize )
			{
				dvar = "sm_sunSampleSizeNear";
				if( !trigger.lerping_dvar[dvar] && GetDvar( dvar ) != trigger.script_sunsample )
				{
					level thread lerp_trigger_dvar_value( trigger, dvar, trigger.script_sunsample, sunsamplesize_time );
				}
			}
		}
	}
}
lerp_trigger_dvar_value( trigger, dvar, value, time )
{
	trigger.lerping_dvar[dvar] = true;
	steps = time * 20;
	curr_value = GetDvarFloat( dvar );
	diff = ( curr_value - value ) / steps;
	for( i = 0; i < steps; i++ )
	{
		curr_value = curr_value - diff;
		SetSavedDvar( dvar, curr_value );
		wait( 0.05 );
	}
	SetSavedDvar( dvar, value );
	trigger.lerping_dvar[dvar] = false;
}
set_fog_progress( progress )
{
	anti_progress = 1 - progress;
	startdist = self.script_start_dist * anti_progress + self.script_start_dist * progress;
	halfwayDist = self.script_halfway_dist * anti_progress + self.script_halfway_dist * progress;
	color = self.script_color * anti_progress + self.script_color * progress;
	SetVolFog( startdist, halfwaydist, self.script_halfway_height, self.script_base_height, color[0], color[1], color[2], 0.4 );
}
remove_level_first_frame()
{
	wait( 0.05 );
	level.first_frame = undefined;
}
no_crouch_or_prone_think( trigger )
{
	for( ;; )
	{
		trigger waittill( "trigger", other );
		if( !IsPlayer( other ) )
		{
			continue;
		}
		while( other IsTouching( trigger ) )
		{
			other AllowProne( false );
			other AllowCrouch( false );
			wait( 0.05 );
		}
		other AllowProne( true );
		other AllowCrouch( true );
	}
}
no_prone_think( trigger )
{
	for( ;; )
	{
		trigger waittill( "trigger", other );
		if( !IsPlayer( other ) )
		{
			continue;
		}
		while( other IsTouching( trigger ) )
		{
			other AllowProne( false );
			wait( 0.05 );
		}
		other AllowProne( true );
	}
}
check_flag_for_stat_tracking( msg )
{
	if( !issuffix( msg, "aa_" ) )
	{
		return;
	}
	[[level.sp_stat_tracking_func]]( msg );
}
precache_script_models()
{
	if( !IsDefined( level.scr_model ) )
	{
		return;
	}
	models = GetArrayKeys( level.scr_model );
	for( i = 0; i < models.size; i++ )
	{
		PrecacheModel( level.scr_model[models[i]] );
	}
}
arcademode_save()
{
}
player_death_detection()
{
	SetDvar( "player_died_recently", "0" );
	thread player_died_recently_degrades();
	level add_wait( ::flag_wait, "missionfailed" );
	self add_wait( ::waittill_msg, "death" );
	do_wait_any();
	recently_skill = [];
	recently_skill[0] = 70;
	recently_skill[1] = 30;
	recently_skill[2] = 0;
	recently_skill[3] = 0;
	SetDvar( "player_died_recently", recently_skill[level.gameskill] );
}
player_died_recently_degrades()
{
	for( ;; )
	{
		recent_death_time = GetDvarInt( #"player_died_recently" );
		if( recent_death_time > 0 )
		{
			recent_death_time -= 5;
			SetDvar( "player_died_recently", recent_death_time );
		}
		wait( 5 );
	}
}
all_players_connected()
{
	while(1)
	{
		num_con = getnumconnectedplayers();
		num_exp = getnumexpectedplayers();
		println( "all_players_connected(): getnumconnectedplayers=", num_con, "getnumexpectedplayers=", num_exp );
		if(num_con == num_exp && (num_exp != 0))
		{
			flag_set( "all_players_connected" );
			SetDvar( "all_players_are_connected", "1" );
			return;
		}
		wait( 0.05 );
	}
}
all_players_spawned()
{
	flag_wait( "all_players_connected" );
	waittillframeend;
	while(1)
	{
		players = get_players();
		count = 0;
		for( i = 0; i < players.size; i++ )
		{
			if( players[i].sessionstate == "playing" )
			{
				count++;
			}
		}
		if( count == players.size )
		{
			break;
		}
		wait( 0.05 );
	}
	flag_set( "all_players_spawned" );
}
adjust_placed_weapons()
{
	weapons = GetEntArray( "placed_weapon", "targetname" );
	flag_wait( "all_players_connected" );
	players = get_players();
	player_count = players.size;
	for( i = 0; i < weapons.size; i++ )
	{
		if( IsDefined( weapons[i].script_player_min ) && player_count < weapons[i].script_player_min )
		{
			weapons[i] Delete();
		}
	}
}
explodable_volume()
{
	self thread explodable_volume_think();
	exploder = GetEnt(self.target, "targetname");
	if (IsDefined(exploder) && IsDefined(exploder.script_exploder))
	{
		level waittill("exploder" + exploder.script_exploder);
	}
	else
	{
		exploder waittill("exploding");
	}
	self Delete();
}
explodable_volume_think()
{
	assertex(IsDefined(self.target), "Explodable Volume must be targeting an exploder or an explodable object.");
	target = GetEnt(self.target, "targetname");
	assertex(IsDefined(target), "Explodable Volume has an invalid target.");
	if (IsDefined(target.remove))
	{
		target = target.remove;
	}
	self._explodable_target = target;
	while (true)
	{
		self waittill("trigger", ent);
		ent thread explodable_volume_ent_think(self, target);
		wait .5;
	}
}
explodable_volume_ent_think(volume, target)
{
	if (!IsDefined(self._explodable_volumes))
	{
		self._explodable_volumes = [];
	}
	if (is_in_array(self._explodable_volumes, volume))
	{
		return;
	}
	if (!IsDefined(self._explodable_targets))
	{
		self._explodable_targets = [];
	}
	self._explodable_volumes = array_add(self._explodable_volumes, volume);
	self._explodable_targets = array_add(self._explodable_targets, target);
	while (IsAlive(self) && IsDefined(volume) && self IsTouching(volume))
	{
		wait .5;
	}
	if (IsDefined(self))
	{
		self._explodable_volumes = array_remove(self._explodable_volumes, volume);
		self._explodable_targets = array_remove(self._explodable_targets, target);
	}
}
update_script_forcespawn_based_on_flags()
{
	spawners = GetSpawnerArray();
	for( i = 0; i < spawners.size; i++ )
	{
		if( spawners[i] has_spawnflag( level.SPAWNFLAG_ACTOR_SCRIPTFORCESPAWN ) )
		{
			spawners[i].script_forcespawn = 1;
		}
	}
}
trigger_once(trig)
{
	trig waittill("trigger");
	waittillframeend;
	if (IsDefined(trig))
	{
		trig Delete();
	}
}