globalize_all_functions

//=========================================================
//	_utility
//
//=========================================================

int functionref( bool = false ) ornull te = null
int EntTracker = 0

global const C_PLAYFX_SINGLE	= 0
global const C_PLAYFX_MULTIPLE	= 1
global const C_PLAYFX_LOOP		= 2

global const MUTEALLFADEIN 		= 2

global struct ZipLine
{
	entity start
	entity mid
	entity end
}

global int HUMAN_RAGDOLL_IMPACT_TABLE_IDX = -1

global struct ArrayDotResultStruct
{
	entity ent
	float dot
}

global struct ShieldDamageModifier
{
	float permanentDamageFrac = TITAN_SHIELD_PERMAMENT_DAMAGE_FRAC
	bool normalizeShieldDamage = false
	float damageScale = 1.0
}


struct
{
	bool isSkyboxView = false
} file

void function Utility_Init()
{
	te = TotalEnts
	EntTracker = 0

	#document( "SetDeathFuncName", "Sets the name of a function that runs when the NPC dies." )
	#document( "CenterPrint", "Print to the screen" )
	#document( "GetAllSoldiers", "Get all living soldiers." )
	#document( "ClearDeathFuncName", "Clears the script death function." )

	HUMAN_RAGDOLL_IMPACT_TABLE_IDX = PrecacheImpactEffectTable( "ragdoll_human" )

	RegisterSignal( "PetTitanUpdated" )
	RegisterSignal( "WaitDeadTimeOut" )
	RegisterSignal( "InventoryChanged" )

	AddClientCommandCallback( "OnDevnetBugScreenshot", ClientCommand_OnDevnetBugScreenshot )
	#if DEV
		FlagInit( "AimAssistSwitchTest_Enabled" )
		AddClientCommandCallback( "DoomTitan", ClientCommand_DoomTitan )
	#endif
}

void function GiveAllTitans()
{

	array<entity> players = GetPlayerArray()
	foreach ( player in players )
	{
		#if MP
		GiveTitanToPlayer( player )
		#endif

		if ( player.IsTitan() )
		{
			entity soul = player.GetTitanSoul()
			if ( soul )
			{
				SoulTitanCore_SetNextAvailableTime( soul, 1 )
			}
		}
	}

	array<entity> titans = GetNPCArrayByClass( "npc_titan" )
	foreach ( titan in titans )
	{
		entity soul = titan.GetTitanSoul()
		if ( soul )
			SoulTitanCore_SetNextAvailableTime( soul, 1 )
	}
}

#if DEV

void function KillAllBadguys()
{
	array<entity> npcs = GetNPCArrayOfEnemies( GetPlayerArray()[0].GetTeam() )
	foreach ( n in npcs )
	{
		if ( n.GetClassName() == "npc_bullseye" )
			continue

		if ( !IsAlive( n ) )
			continue
		n.Die()
	}
}

bool function ClientCommand_DoomTitan( entity player, array<string> args )
{
	entity titan
	if ( player.IsTitan() )
		titan = player
	else
		titan = player.GetPetTitan()

	if ( !IsAlive( titan ) )
		return true

	if ( GetDoomedState( titan ) )
		return true

	entity soul = titan.GetTitanSoul()
	soul.SetShieldHealth( 0 )

	titan.TakeDamage( titan.GetHealth(), null, null, { damageSourceId=damagedef_suicide, scriptType = DF_SKIP_DAMAGE_PROT } )

	return true
}
#endif

void function PrintPlaylists()
{
	printt( "=== PLAYLIST NAMES: ===" )

	int count = GetPlaylistCount()
	for ( int i = 0; i < count; i++ )
	{
		printt( "--", GetPlaylistName( i ) )
	}
}

entity function CreateEntity( string name )
{
//	if ( name == "npc_titan" )
//	{
//		DumpStack(3)
//	}
//	if ( name == "info_particle_system" )
//	{
//		printl( " " )
//		DumpStack(3)
//	}
	return Entities_CreateByClassname( name )
}

// used from the console to quick-test fields
void function setnpcfields( string key, var val )
{
	array<entity> npcs = GetNPCArrayByClass( "npc_soldier" )
	foreach ( npc in npcs )
	{
		npc.kv[ key ] = val
	}
}

void function WaitUntilNumDead( array<entity> guys, int numDead )
{
	Assert( numDead <= guys.len(), "asked for " + numDead + " guys to die, but only passed in an array of " + guys.len() + " guys." )
	float timeout = -1
	__WaitUntilDeadInternal( guys, numDead, timeout, __WaitUntilDeadTracker )
}

void function WaitUntilNumDeadWithTimeout( array<entity> guys, int numDead, float timeout )
{
	Assert( numDead <= guys.len(), "asked for " + numDead + " guys to die, but only passed in an array of " + guys.len() + " guys." )
	Assert( timeout > 0 )
	__WaitUntilDeadInternal( guys, numDead, timeout, __WaitUntilDeadTracker )
}

void function WaitUntilAllDead( array<entity> guys )
{
	int count = guys.len()
	float timeout = -1
	__WaitUntilDeadInternal( guys, count, timeout, __WaitUntilDeadTracker )
}

void function WaitUntilAllDeadWithTimeout( array<entity> guys, float timeout )
{
	int count = guys.len()
	Assert( timeout > 0 )
	__WaitUntilDeadInternal( guys, count, timeout, __WaitUntilDeadTracker )
}

void function WaitUntilNumDeadOrLeeched( array<entity> guys, int numDead )
{
	Assert( numDead <= guys.len(), "asked for " + numDead + " guys to die, but only passed in an array of " + guys.len() + " guys." )
	float timeout = -1
	__WaitUntilDeadInternal( guys, numDead, timeout, __WaitUntilDeadOrLeechedTracker )
}

void function WaitUntilNumDeadOrLeechedWithTimeout( array<entity> guys, int numDead, float timeout )
{
	Assert( numDead <= guys.len(), "asked for " + numDead + " guys to die, but only passed in an array of " + guys.len() + " guys." )
	Assert( timeout > 0 )
	__WaitUntilDeadInternal( guys, numDead, timeout, __WaitUntilDeadOrLeechedTracker )
}

void function WaitUntilAllDeadOrLeeched( array<entity> guys )
{
	int count = guys.len()
	float timeout = -1
	__WaitUntilDeadInternal( guys, count, timeout, __WaitUntilDeadOrLeechedTracker )
}

void function WaitUntilAllDeadOrLeechedWithTimeout( array<entity> guys, float timeout )
{
	int count = guys.len()
	Assert( timeout > 0 )
	__WaitUntilDeadInternal( guys, count, timeout, __WaitUntilDeadOrLeechedTracker )
}

void function __WaitUntilDeadInternal( array<entity> guys, int numDead, float timeout, void functionref( entity, table<string, int> ) deathTrackerFunc )
{
	table<string, int> master = { count = numDead }

	if ( timeout > 0.0 )
		thread __WaitUntilDeadTrackerDelayedSignal( master, "WaitDeadTimeOut", timeout )

	//when the thread ends, let child threads know
	OnThreadEnd(
		function() : ( master )
		{
			Signal( master, "OnDestroy" )
		}
	)

	foreach ( guy in guys )
		thread deathTrackerFunc( guy, master )

	while ( master.count > 0 )
	{
		table result = WaitSignal( master, "OnDeath", "WaitDeadTimeOut" )
		if ( result.signal == "WaitDeadTimeOut" ) //can't do endsignal, because it will kill the calling function too
			return
	}
}

void function __WaitUntilDeadTrackerDelayedSignal( table<string, int> master, string signal, float delay )
{
	EndSignal( master, signal )

	wait delay
	if ( IsValid( master ) )
		Signal( master, signal )
}

void function __WaitUntilDeadTracker( entity guy, table<string, int> master )
{
	EndSignal( master, "OnDestroy" )
	if ( IsAlive( guy ) )
		WaitSignal( guy, "OnDeath", "OnDestroy" )

	master.count--
	Signal( master, "OnDeath" )
}

void function __WaitUntilDeadOrLeechedTracker( entity guy, table<string, int> master )
{
	EndSignal( master, "OnDestroy" )
	if ( IsAlive( guy ) )
		WaitSignal( guy, "OnDeath", "OnDestroy", "OnLeeched" )

	master.count--
	Signal( master, "OnDeath" )
}

void function SetRebreatherMaskVisible( entity ent, bool visible )
{
	asset modelname = ent.GetModelName()

	int maskIdx = ent.FindBodyGroup( "mask" )
	if ( maskIdx == -1 )
		return

	int visibleIdx = 1
	if ( !visible )
		visibleIdx = 0

	ent.SetBodygroup( maskIdx, visibleIdx )
}

int function EntHasSpawnflag( entity ent, int spawnflagHexVal )
{
	return ( expect int( ent.kv.spawnflags ) & spawnflagHexVal )
}

entity function CreateInfoTarget( vector origin = <0,0,0>, vector angles = <0,0,0> )
{
	entity info_target = CreateEntity( "info_target" )
	info_target.SetOrigin( origin )
	info_target.SetAngles( angles )
	DispatchSpawn( info_target )
	return info_target
}

entity function CreateExpensiveScriptMover( vector origin = <0.0, 0.0, 0.0>, vector angles = <0.0, 0.0, 0.0>, int solidType = 0 )
{
	entity script_mover = CreateEntity( "script_mover" )
	script_mover.kv.solid = solidType
	script_mover.SetValueForModelKey( $"models/dev/empty_model.mdl" )
	script_mover.kv.SpawnAsPhysicsMover = 0
	script_mover.SetOrigin( origin )
	script_mover.SetAngles( angles )

	DispatchSpawn( script_mover )
	return script_mover
}

entity function CreateScriptMover( vector origin = <0.0, 0.0, 0.0>, vector angles = <0.0, 0.0, 0.0>, int solidType = 0 )
{
	entity script_mover = CreateEntity( "script_mover_lightweight" )
	script_mover.kv.solid = solidType
	script_mover.SetValueForModelKey( $"models/dev/empty_model.mdl" )
	script_mover.kv.SpawnAsPhysicsMover = 0
	script_mover.SetOrigin( origin )
	script_mover.SetAngles( angles )
	DispatchSpawn( script_mover )
	return script_mover
}

entity function CreateScriptMoverModel( asset model, vector origin = <0.0, 0.0, 0.0>, vector angles = <0.0, 0.0, 0.0>, int solidType = 0, float fadeDist = -1 )
{
	entity script_mover = CreateEntity( "script_mover_lightweight" )
	script_mover.kv.solid = solidType
	script_mover.kv.fadedist = fadeDist
	script_mover.SetValueForModelKey( model )
	script_mover.kv.SpawnAsPhysicsMover = 0
	script_mover.SetOrigin( origin )
	script_mover.SetAngles( angles )
	DispatchSpawn( script_mover )
	return script_mover
}

entity function CreateExpensiveScriptMoverModel( asset model, vector origin = <0.0, 0.0, 0.0>, vector angles = <0.0, 0.0, 0.0>, int solidType = 0, float fadeDist = -1 )
{
	entity script_mover = CreateEntity( "script_mover" )
	script_mover.kv.solid = solidType
	script_mover.kv.fadedist = fadeDist
	script_mover.SetValueForModelKey( model )
	script_mover.kv.SpawnAsPhysicsMover = 0
	script_mover.SetOrigin( origin )
	script_mover.SetAngles( angles )
	DispatchSpawn( script_mover )
	return script_mover
}

entity function CreateOwnedScriptMover( entity owner )
{
	entity script_mover = CreateEntity( "script_mover" )
	script_mover.kv.solid = 0
	script_mover.SetValueForModelKey( $"models/dev/empty_model.mdl" )
	script_mover.kv.SpawnAsPhysicsMover = 0
	script_mover.SetOrigin( owner.GetOrigin() )
	script_mover.SetAngles( owner.GetAngles() )
	DispatchSpawn( script_mover )
	script_mover.Hide()

	script_mover.SetOwner( owner )
	return script_mover
}

// useful for finding out what ents are in a level. Should only be used for debugging.
int function TotalEnts( bool hidden = false )
{
	array<entity> entities

	EntTracker++

	entity ent = Entities_FindInSphere( null, < 0, 0, 0 >, 90000 )
	string name
	for ( ;; )
	{
		if ( ent == null )
			break

		entities.append( ent )

		name = ent.GetTargetName()

		string strPrefix = "Old ent"
		if ( ent.e.totalEntsStoredID == 0 )
		{
			string strPrefix = "* New ent"
			ent.e.totalEntsStoredID = EntTracker
		}

		string strPostfix = ""
		if ( name != "" )
			strPostfix = " \"" + name + "\""

		if ( !hidden )
			printl( strPrefix + " (" + ent.e.totalEntsStoredID + "): " + ent + strPostfix )

		ent = Entities_FindInSphere( ent, < 0, 0, 0 >, 90000 )
	}

	if ( !hidden )
		printl( "Total entities " + entities.len() )

	return entities.len()
}

bool function IsThreadTop()
{
	return getstackinfos( 3 ) == null
}

string function ThisFunc()
{
	return expect string( expect table( getstackinfos( 2 ) )[ "func" ] )
}

entity function ge( int index ) // shorthand version for typing from console
{
	return GetEntByIndex( index )
}

entity function GetEnt( string name )
{
	entity ent = Entities_FindByName( null, name )
	if ( ent == null )
	{
		ent = Entities_FindByClassname( null, name )
		Assert( Entities_FindByClassname( ent, name ) == null, "Tried to GetEnt but there were multiple entities with that name" )
	}
	else
	{
		Assert( Entities_FindByName( ent, name ) == null, "Tried to GetEnt but there were multiple entities with name " + name )
	}

	return ent
}

array<entity> function ArrayWithinCenter( array<entity> ents, vector start, int range )
{
	array<entity> Array
	foreach ( ent in ents )
	{
		if ( Distance( start, ent.GetWorldSpaceCenter() ) > range )
			continue

		Array.append( ent )
	}

	return Array
}

vector function GetCenter( array<entity> ents )
{
	vector total

	foreach ( ent in ents )
	{
		total += ent.GetOrigin()
	}

	total.x /= float( ents.len() )
	total.y /= float( ents.len() )
	total.z /= float( ents.len() )

	return total
}

void function TableRemoveInvalid( table<entity, entity> Table )
{
	array<entity> deleteKey = []

	foreach ( entity key, entity value in Table )
	{
		if ( !IsValid_ThisFrame( key ) )
			deleteKey.append( key )

		if ( !IsValid_ThisFrame( value ) )
			deleteKey.append( key )
	}

	foreach ( key in deleteKey )
	{
		// in this search, two things could end up on the same key
		if ( key in Table )
			delete Table[ key ]
	}
}

void function TableRemoveInvalidByValue( table<entity, entity> Table )
{
	array<entity> deleteKey = []

	foreach ( key, entity value in Table )
	{
		if ( !IsValid_ThisFrame( value ) )
			deleteKey.append( key )
	}

	foreach ( key in deleteKey )
	{
		delete Table[ key ]
	}
}

void function TableRemoveDeadByKey( table<entity, entity> Table )
{
	array<entity> deleteKey = []

	foreach ( key, value in Table )
	{
		if ( !IsAlive( key ) )
			deleteKey.append( key )
	}

	foreach ( key in deleteKey )
	{
		delete Table[ key ]
	}
}


void function ArrayDump( array<var> Array )
{
	for ( int i = 0; i < Array.len(); i++ )
	{
		printl( "index " + i + " is: " + Array[i] )
	}
}


int function DotCompareLargest( ArrayDotResultStruct a, ArrayDotResultStruct b )
{
	if ( a.dot < b.dot )
		return 1
	else if ( a.dot > b.dot )
		return -1

	return 0
}

int function DotCompareSmallest( ArrayDotResultStruct a, ArrayDotResultStruct b )
{
	if ( a.dot > b.dot )
		return 1
	else if ( a.dot < b.dot )
		return -1

	return 0
}

array<ArrayDotResultStruct> function ArrayDotResults( array<entity> Array, entity ent )
{
	array<ArrayDotResultStruct> allResults

	foreach ( arrayEnt in Array )
	{
		ArrayDotResultStruct results

		results.dot = VectorDot_EntToEnt( ent, arrayEnt )
		results.ent = arrayEnt
		allResults.append( results )
	}

	return allResults
}


// Return an array of entities ordered from closest to furthest from the facing of the entity
array<entity> function ArrayClosestToView( array<entity> Array, entity ent )
{
	Assert( type( Array ) == "array" )
	array<ArrayDotResultStruct> allResults = ArrayDotResults( Array, ent )

	allResults.sort( DotCompareLargest )

	array<entity> returnEntities = []

	foreach ( index, result in allResults )
	{
		//printl( "Results are " + result.dot )
		returnEntities.insert( index, result.ent )
	}

	// the actual distances aren't returned
	return returnEntities
}


entity function SpawnRefEnt( entity ent )
{
	printl( "Ent model " + ent.GetValueForModelKey() )
	int attach = ent.LookupAttachment( "ref" )
	vector origin = ent.GetAttachmentOrigin( attach )
	vector angles = ent.GetAttachmentAngles( attach )

	entity ref = CreateEntity( "prop_dynamic" )
	//ref.kv.SpawnAsPhysicsMover = 0
	ref.SetValueForModelKey( $"models/dev/empty_model.mdl" )
	DispatchSpawn( ref )

	ref.SetOrigin( origin )
	ref.SetAngles( angles )
	ref.Hide()
	return ref
}

entity function CreateScriptRef( vector ornull origin = null, vector ornull angles = null )
{
	entity ent = CreateEntity( "script_ref" )

	if ( origin )
		ent.SetOrigin( expect vector( origin ) )

	if ( angles )
		ent.SetAngles( expect vector( angles ) )

	DispatchSpawn( ent )
	return ent
}

entity function CreateScriptRefMinimap( vector origin, vector angles )
{
	entity ent = CreateEntity( "script_ref_minimap" )

	ent.SetOrigin( origin )
	ent.SetAngles( angles )

	DispatchSpawn( ent )

	return ent
}

bool function exists( table tbl, string val )
{
	if ( !(val in tbl) )
		return false

	return tbl[ val ] != null
}

var function TableRandomIndex( table Table )
{
	array Array = []

	foreach ( index, _ in Table )
	{
		Array.append( index )
	}

	return Array.getrandom()
}

// should improve this
float function YawDifference( float yaw1, float yaw2 )
{
	Assert( yaw1 >= 0 )
	Assert( yaw1 <= 360 )
	Assert( yaw2 >= 0 )
	Assert( yaw2 <= 360 )

	float diff = fabs( yaw1 - yaw2 )

	if ( diff > 180 )
	    return 360 - diff
	else
	    return diff

	unreachable
}



/*function TrackIsTouching( ent )
{
	return // now uses IsTouching

	//ent.s.touching <- {}
	//ent.ConnectOutput( "OnStartTouch", TrackIsTouching_OnStartTouch )
	//ent.ConnectOutput( "OnEndTouch", TrackIsTouching_OnEndTouch )
}

void function TrackIsTouching_OnStartTouch( entity self, entity activator, entity caller, var value )
{
	if ( activator )
	{
		self.s.touching[ activator ] <- true
	}
}

void function TrackIsTouching_OnEndTouch( entity self, entity activator, entity caller, var value )
{
	if ( activator )
	{
		if ( activator in self.s.touching )
		{
			delete self.s.touching[ activator ]
		}
	}
}*/

void function NPC_NoTarget( entity self )
{
	self.SetNoTarget( true )
	self.SetNoTargetSmartAmmo( true )
}

vector function GetSimpleTraceEnd( vector start, vector end, float frac )
{
	vector vec = end - start
	vec *= frac
	return start + vec
}

bool function LoadedMain()
{
	if ( "LoadedMain" in level )
		return true

	level.LoadedMain <- true

	return false
}

void function Warning( string msg )
{
	printl( "*** WARNING ***" )
	printl( msg )
	DumpStack()
	printl( "*** WARNING ***" )
}

void function TimeOut( float time )
{
	table Table = {}
	EndSignal( Table, "OnDeath" )
	delaythread( time ) Signal( Table, "OnDeath" )
}

string function GetActiveWeaponClass( entity player )
{
	entity weapon = player.GetActiveWeapon()
	Assert( weapon != null )

	string weaponclass = weapon.GetWeaponClassName()
	return weaponclass
}

bool function HasWeapon( entity ent, string weaponClassName, array<string> mods = [] )
{
	Assert( ent.IsPlayer() || ent.IsNPC() )

	array<entity> weaponArray = ent.GetMainWeapons()
	foreach ( weapon in weaponArray )
	{
		if ( weapon.GetWeaponClassName() == weaponClassName )
		{
			if ( WeaponHasSameMods( weapon, mods ) )
				return true
		}
	}

	return false
}

bool function HasOrdnance( entity ent, string weaponClassName, array<string> mods = [] )
{
	return HasOffhandForSlot( ent, OFFHAND_ORDNANCE, weaponClassName, mods )
}

bool function HasCoreAbility( entity ent, string weaponClassName, array<string> mods = [] )
{
	return HasOffhandForSlot( ent, OFFHAND_EQUIPMENT, weaponClassName, mods )
}

bool function HasSpecial( entity ent, string weaponClassName, array<string> mods = [] )
{
	return HasOffhandForSlot( ent, OFFHAND_SPECIAL, weaponClassName, mods )
}

bool function HasAntiRodeo( entity ent, string weaponClassName, array<string> mods = [] )
{
	return HasOffhandForSlot( ent, OFFHAND_ANTIRODEO, weaponClassName, mods )
}

bool function HasMelee( entity ent, string weaponClassName, array<string> mods = [] )
{
	return HasOffhandForSlot( ent, OFFHAND_MELEE, weaponClassName, mods )
}

bool function HasOffhandForSlot( entity ent, int slot, string weaponClassName, array<string> mods = [] )
{
	Assert( ent.IsPlayer() || ent.IsNPC() )

	entity weapon = ent.GetOffhandWeapon( slot )
	if ( !IsValid( weapon ) )
		return false

	if ( weapon.GetWeaponClassName() != weaponClassName )
		return false

	return WeaponHasSameMods( weapon, mods )
}

bool function WeaponHasSameMods( entity weapon, array<string> mods = [] )
{
	array hasMods = clone mods
	foreach ( mod in weapon.GetMods() )
	{
		hasMods.removebyvalue( mod )
	}

	// has all the same mods.
	return hasMods.len() == 0
}

bool function HasOffhandWeapon( entity ent, string weaponClassName )
{
	Assert( ent.IsPlayer() || ent.IsNPC() )

	array<entity> weaponArray = ent.GetOffhandWeapons()
	foreach ( weapon in weaponArray )
	{
		if ( weapon.GetWeaponClassName() == weaponClassName )
			return true
	}

	return false
}

float function GetFraction( float value, float min, float max )
{
	return ( value - min ) / ( max - min )
}

float function GetFractionClamped( float value, float min, float max )
{
	float frac = GetFraction( value, min, max )
	return clamp( frac, 0.0, 1.0 )
}

float function GetValueFromFraction( float value, float value_min, float value_max, float return_min, float return_max )
{
	float frac = GetFractionClamped( value, value_min, value_max )
	float retVal = return_min + ( ( return_max - return_min ) * frac )
	return clamp( retVal, return_min, return_max )
}

bool function VectorCompare( vector vec1, vector vec2 )
{
	if ( vec1.x != vec2.x )
		return false

	if ( vec1.y != vec2.y )
		return false

	return vec1.z == vec2.z
}

// returns vectordot from viewEnt to targetEnt
float function VectorDot_EntToEnt( entity viewEnt, entity targetEnt )
{
	vector maxs = targetEnt.GetBoundingMaxs()
	vector mins = targetEnt.GetBoundingMins()
	maxs += mins
	maxs.x *= 0.5
	maxs.y *= 0.5
	maxs.z *= 0.5
	vector targetOrg = targetEnt.GetOrigin() + maxs

	maxs = viewEnt.GetBoundingMaxs()
	mins = viewEnt.GetBoundingMins()
	maxs += mins
	maxs.x *= 0.5
	maxs.y *= 0.5
	maxs.z *= 0.5
	vector viewOrg = viewEnt.GetOrigin() + maxs

	//DebugDrawLine( targetOrg, viewOrg, 255, 255, 255, true, 0.5 )
	vector vecToEnt = ( targetOrg - viewOrg )
	vecToEnt = Normalize( vecToEnt )

	float dotVal = DotProduct( vecToEnt, viewEnt.GetForwardVector() )
	return dotVal
}

void function PrecacheEffect( asset effectName )
{
	entity warningParticle = CreateEntity( "info_particle_system" )
	warningParticle.SetValueForEffectNameKey( effectName )
	warningParticle.kv.start_active = 0
	DispatchSpawn( warningParticle )
	warningParticle.Destroy()
}

void function PrecacheEntity( string entName, asset model = $"" )
{
	entity tempEnt = CreateEntity( entName )

	if ( model != $"" )
		tempEnt.SetValueForModelKey( model )

	tempEnt.kv.spawnflags = SF_NPC_ALLOW_SPAWN_SOLID

	DispatchSpawn( tempEnt )
	tempEnt.Destroy()
}

void function PrecacheProjectileEntity( string entName, string weaponClassName, asset model = $"" )
{
	entity tempEnt = Entities_CreateProjectileByClassname( entName, weaponClassName )

	if ( model != $"" )
		tempEnt.SetValueForModelKey( model )

	tempEnt.kv.spawnflags = SF_NPC_ALLOW_SPAWN_SOLID

	DispatchSpawn( tempEnt )
	tempEnt.Destroy()
}

void function PrecacheSprite( asset spriteName )
{
	entity sprite = CreateEntity( "env_sprite_oriented" )
	sprite.SetValueForModelKey( spriteName )
	sprite.kv.spawnflags = 1
	DispatchSpawn( sprite )
	sprite.Destroy()
}

entity function CreatePointMessage( string msg, vector origin, int displayRadius = 512 )
{
	entity point_message = CreateEntity( "point_message" )
	point_message.SetOrigin( origin )
	point_message.kv.message = msg
	point_message.kv.radius = displayRadius

	DispatchSpawn( point_message )

	return point_message
}

entity function CreateGameText( string msg, float xPos, float yPos, int channel, string color = "255 255 255", float fadein = 2, float fadeout = 0.5, float holdtime = 2 )
{
	entity game_text = CreateEntity( "game_text" )

	game_text.SetScriptName( "gt" + UniqueString()  )
	game_text.kv.message = msg
	game_text.kv["x"] = xPos
	game_text.kv["y"] = yPos
	game_text.kv.channel = channel
	game_text.kv.color = color
	game_text.kv.color2 = "240 110 0"  // doesn't appear to do anything atm, not supporting in params
	game_text.kv.fadein = fadein
	game_text.kv.fadeout = fadeout
	game_text.kv.holdtime = holdtime
	game_text.kv.fxtime = "0.25"

	DispatchSpawn( game_text )

	return game_text
}

// pass the origin where the player's feet would be
// tests a player sized box for any collision and returns true only if it's clear
bool function PlayerCanTeleportHere( entity player, vector testOrg, entity ignoreEnt = null ) //TODO: This is a copy of SP's PlayerPosInSolid(). Not changing it to avoid patching SP. Merge into one function next game
{
	int solidMask = TRACE_MASK_PLAYERSOLID
	vector mins
	vector maxs
	int collisionGroup = TRACE_COLLISION_GROUP_PLAYER
	array<entity> ignoreEnts = [ player ]

	if ( IsValid( ignoreEnt ) )
		ignoreEnts.append( ignoreEnt )
	TraceResults result

	mins = player.GetPlayerMins()
	maxs = player.GetPlayerMaxs()
	result = TraceHull( testOrg, testOrg + < 0, 0, 1 >, mins, maxs, ignoreEnts, solidMask, collisionGroup )

	if ( result.startSolid )
		return false

	return true
}


enum eAttach
{
	No
	ViewAndTeleport
	View
	Teleport
	ThirdPersonView
}


void function LoadDiamond()
{
    printl( " " )
    printl( " " )
    printl( " " )

    // Draw a diamond of a random size and phase (of the moon) so it is easy to separate sections of logs.
    int random_spread = RandomIntRange( 4, 7 )
    float random_fullness = RandomFloat( 2.0 )
    bool functionref( int, int ) compare_func
    string msg

    if ( RandomFloat( 1.0 ) > 0.5 )
    {
	    compare_func = bool function( int a, int b )
	    {
		    return a <= b
	    }
    }
    else
    {
	    compare_func = bool function( int a, int b )
	    {
		    return a >= b
	    }
    }

    for ( int i = 0; i <= random_spread - 2; i++ )
    {
	    msg = ""

	    for ( int p = 0; p <= random_spread - i; p++ )
	    {
		    msg = msg + " "
	    }

	    for ( int p = 0; p <= i * 2; p++ )
	    {
		    if ( p == i * 2 || p == 0 )
		    {
			    msg = msg + "*"
		    }
		    else
		    {
			    int an_int = int( i * random_fullness )

			    if ( compare_func( p, an_int ) )
				    msg = msg + "*"
			    else
				    msg = msg + " "
		    }
	    }

	    printl( msg )
    }

    for ( int i = random_spread - 1; i >= 0; i-- )
    {
	    msg = ""

	    for ( int p = 0; p <= random_spread - i; p++ )
	    {
		    msg = msg + " "
	    }


	    for ( int p = 0; p <= i * 2; p++ )
	    {
		    if ( p == i * 2 || p == 0 )
		    {
			    msg = msg + "*"
		    }
		    else
		    {
			    if ( compare_func( p, int( i * random_fullness ) ) )
			    {
				    msg = msg + "*"
			    }
			    else
			    {
				    msg = msg + " "
			    }
		    }
	    }

	    printl( msg )
    }

    printl( " " )
    printl( " " )
    printl( " " )
}

// this will clear all dropped weapons in the map
void function ClearDroppedWeapons( float delayTime = 0.0 )
{
	if ( delayTime > 0 )
		wait delayTime

	bool onlyNotOwnedWeapons = true  // don't get the ones in guys' hands
	array<entity> weapons = GetWeaponArray( onlyNotOwnedWeapons )

	foreach ( weapon in weapons )
	{
		// don't clean up weapon pickups that were placed in leveled
		int spawnflags = expect string( weapon.kv.spawnflags ).tointeger()
		if ( spawnflags & SF_WEAPON_START_CONSTRAINED )
			continue

		weapon.Destroy()
	}
}

void function ClearActiveProjectilesForTeam( int team, vector searchOrigin = <0,0,0>, float searchDist = -1 )
{
	array<entity> projectiles = GetProjectileArrayEx( "any", team, TEAM_ANY, searchOrigin, searchDist )

	printt( "cleaning up", projectiles.len(), "weapon projectiles for team", team )

	foreach ( proj in projectiles )
	{
		if( !IsValid( proj ) )
			continue

		proj.Destroy()
	}
}

void function RestockPlayerAmmo_Silent( entity player = null )
{
	RestockPlayerAmmo( player, true )
}

void function RestockPlayerAmmo( entity player = null, bool isSilent = false )
{
	array<entity> players
	if ( IsAlive( player ) )
		players.append( player )
	else
		players = GetPlayerArray_Alive()

	foreach( player in players )
	{
		player.RefillAllAmmo()

		if ( !isSilent )
			EmitSoundOnEntityOnlyToPlayer( player, player, "Coop_AmmoBox_AmmoRefill" )
	}
}

entity function CreateLightSprite( vector origin, vector angles, string lightcolor = "255 0 0", float scale = 0.5 )
{
	// attach a light so we can see it
	entity env_sprite = CreateEntity( "env_sprite" )
	env_sprite.SetScriptName( UniqueString( "molotov_sprite" ) )
	env_sprite.kv.rendermode = 5
	env_sprite.kv.origin = origin
	env_sprite.kv.angles = angles
	env_sprite.kv.rendercolor = lightcolor
	env_sprite.kv.renderamt = 255
	env_sprite.kv.framerate = "10.0"
	env_sprite.SetValueForModelKey( $"sprites/glow_05.vmt" )
	env_sprite.kv.scale = string( scale )
	env_sprite.kv.spawnflags = 1
	env_sprite.kv.GlowProxySize = 16.0
	env_sprite.kv.HDRColorScale = 1.0
	DispatchSpawn( env_sprite )
	EntFireByHandle( env_sprite, "ShowSprite", "", 0, null, null )

	return env_sprite
}

// defaultWinner: if it's a tie, return this value
int function GetCurrentWinner( int defaultWinner = TEAM_MILITIA )
{
	int imcScore
	int militiaScore

	if ( IsRoundBased() )
	{
		imcScore = GameRules_GetTeamScore2( TEAM_IMC )
		militiaScore = GameRules_GetTeamScore2( TEAM_MILITIA )

		if ( IsRoundBasedUsingTeamScore() && ( imcScore == militiaScore ) )
		{
			imcScore = GameRules_GetTeamScore( TEAM_IMC )
			militiaScore = GameRules_GetTeamScore( TEAM_MILITIA )
		}
	}
	else
	{
		imcScore = GameRules_GetTeamScore( TEAM_IMC )
		militiaScore = GameRules_GetTeamScore( TEAM_MILITIA )
	}

	int currentWinner = defaultWinner

	if ( militiaScore > imcScore )
		currentWinner = TEAM_MILITIA
	else if ( imcScore > militiaScore )
		currentWinner = TEAM_IMC

	return currentWinner
}

void function SetNpcFollowsPlayerOverride( entity player, void functionref( entity, entity ) override )
{
	player.p.followPlayerOverride = override
}

void function ClearNpcFollowsPlayerOverride( entity player )
{
	player.p.followPlayerOverride = null
}

void function AddCallback_GameStateEnter( int gameState, void functionref() callbackFunc )
{
	Assert( gameState < svGlobal.gameStateEnterCallbacks.len() )

	Assert( !svGlobal.gameStateEnterCallbacks[ gameState ].contains( callbackFunc ), "Already added " + string( callbackFunc ) + " with AddCallback_GameStateEnter" )

	svGlobal.gameStateEnterCallbacks[ gameState ].append( callbackFunc )
}

void function GM_SetObserverFunc( void functionref( entity ) callbackFunc )
{
	svGlobal.observerFunc = callbackFunc
}

void function GM_AddPlayingThinkFunc( void functionref() callbackFunc )
{
	Assert( !svGlobal.playingThinkFuncTable.contains( callbackFunc ), "Already added " + string( callbackFunc ) + " with GM_AddPlayingThinkFunc" )

	svGlobal.playingThinkFuncTable.append( callbackFunc )
}

void function GM_AddThirtySecondsLeftFunc( void functionref() callbackFunc )
{
	Assert( !svGlobal.thirtySecondsLeftFuncTable.contains( callbackFunc ), "Already added " + string( callbackFunc ) + " with GM_AddThirtySecondsLeftFunc" )

	svGlobal.thirtySecondsLeftFuncTable.append( callbackFunc )
}

void function GM_SetMatchProgressAnnounceFunc( void functionref( int ) callbackFunc )
{
	svGlobal.matchProgressAnnounceFunc = callbackFunc
}

// Get an absolute offset poistion to an entity even if it's been rotated in world space
vector function GetEntPosPlusOffset( entity ent, float offsetX, float offsetY, float offsetZ )
{
	vector entAngles = ent.GetAngles()
	vector entOrg = ent.GetOrigin()

	vector right = AnglesToRight( entAngles )
	right = Normalize( right )
	vector pos = entOrg + ( right * offsetY )

	vector forward = AnglesToForward( entAngles )
	forward = Normalize( forward )
	pos = pos + ( forward * offsetX )

	vector up = AnglesToUp( entAngles )
	up = Normalize( up )
	pos = pos + ( up * offsetZ )

	return pos
}

void function EmitSoundToTeamPlayers( string alias, int team )
{
	array<entity> players = GetPlayerArrayOfTeam( team )

	foreach ( player in players )
		EmitSoundOnEntityOnlyToPlayer( player, player, alias )
}

void function EmitDifferentSoundsAtPositionForPlayerAndWorld( string soundForPlayer, string soundForWorld, vector position, entity player, int teamNum )
{
	if ( IsValid( player ) && player.IsPlayer() )
	{
		EmitSoundAtPositionExceptToPlayer( teamNum, position, player, soundForWorld )
		EmitSoundAtPositionOnlyToPlayer( teamNum, position, player, soundForPlayer)
	}
	else
	{
		EmitSoundAtPosition( teamNum, position, soundForWorld )
	}
}

void function EmitDifferentSoundsOnEntityForPlayerAndWorld( string soundForPlayer, string soundForWorld, entity soundEnt, entity player )
{
	if ( IsValid( player ) && player.IsPlayer() )
	{
		EmitSoundOnEntityExceptToPlayerNotPredicted( soundEnt, player, soundForWorld )
		EmitSoundOnEntityOnlyToPlayer(soundEnt, player, soundForPlayer)
	}
	else
	{
		EmitSoundOnEntity( soundEnt, soundForWorld )
	}
}

// Drop an entity to the ground by tracing straight down from its z-axis
void function DropToGround( entity ent )
{
	vector targetOrigin = OriginToGround( ent.GetOrigin() + <0,0,1> )
	ent.SetOrigin( targetOrigin )
}

void function DropTitanToGround( entity titan, array<entity> ignoreEnts )
{
	vector endOrigin = titan.GetOrigin() - < 0, 0, 20000 >
	vector mins = GetBoundsMin( HULL_TITAN )
	vector maxs = GetBoundsMax( HULL_TITAN )
	TraceResults traceResult = TraceHull( titan.GetOrigin(), endOrigin, mins, maxs, ignoreEnts, TRACE_MASK_TITANSOLID, TRACE_COLLISION_GROUP_NONE )

	titan.SetOrigin( traceResult.endPos )
}

vector function OriginToGround( vector origin )
{
	vector endOrigin = origin - < 0, 0, 20000 >
	TraceResults traceResult = TraceLine( origin, endOrigin, [], TRACE_MASK_NPCWORLDSTATIC, TRACE_COLLISION_GROUP_NONE )

	return traceResult.endPos
}

float function GetVerticalClearance( vector origin )
{
	vector endOrigin = origin + < 0, 0, 20000 >
	TraceResults traceResult = TraceLine( origin, endOrigin, [], TRACE_MASK_NPCWORLDSTATIC, TRACE_COLLISION_GROUP_NONE )
	vector endPos = traceResult.endPos
	float zDelta = ( endPos.z - origin.z )

	return zDelta
}

// ---------------------------------------------------------------------
// Determine if an entity is a valid player spawnpoint
// ---------------------------------------------------------------------
bool function PlayerSpawnpointIsValid( entity ent )
{
	if ( ent.GetClassName() != "prop_dynamic" )
		return false
	if ( ent.GetValueForModelKey() != $"models/humans/pete/mri_male.mdl" )
		return false

	return true
}

// ---------------------------------------------------------------------
// Make an NPC or the player invincible (true/false)
//	(_npc.nut intercepts incoming damage and negates it if the ent is tagged as invincible)
// ---------------------------------------------------------------------
void function MakeInvincible( entity ent )
{
	Assert( IsValid( ent ), "Tried to make invalid " + ent + " invincible" )
	Assert( ent.IsNPC() || ent.IsPlayer(), "MakeInvincible() can only be called on NPCs and the player" )
	Assert( IsAlive( ent ), "Tried to make dead ent " + ent + " invincible" )

	ent.SetInvulnerable()
}

void function ClearInvincible( entity ent )
{
	Assert( IsValid( ent ), "Tried to clear invalid " + ent + " invincible" )

	ent.ClearInvulnerable()
}

bool function IsInvincible( entity ent )
{
	return ent.IsInvulnerable()
}

//-------------------------------------
// Teleport an entity (teleporter) to an entity's org and angles (ent)
//--------------------------------------
void function TeleportToEnt( entity teleporter, entity ent )
{
	Assert( teleporter != null, "Unable to teleport null entity" )
	Assert( ent != null, "Unable to teleport to a null entity" )
	teleporter.SetOrigin( ent.GetOrigin() )
	teleporter.SetAngles( ent.GetAngles() )
}

//-----------------------------------------------------------
// CreateShake() - create and fire an env_shake at a specified origin
// - returns the shake in case you want to parent it
//------------------------------------------------------------

entity function CreateShake_internal( vector org, float amplitude, float frequency, float duration, float radius, int spawnFlags )
{
	entity env_shake = CreateEntity( "env_shake" )
	env_shake.kv.amplitude = amplitude
	env_shake.kv.radius = radius
	env_shake.kv.duration = duration
	env_shake.kv.frequency = frequency
	env_shake.kv.spawnflags = spawnFlags

	DispatchSpawn( env_shake )

	env_shake.SetOrigin( org )

	EntFireByHandle( env_shake, "StartShake", "", 0, null, null )
	EntFireByHandle( env_shake, "Kill", "", ( duration + 1 ), null, null )

	return env_shake
}

entity function CreateShake( vector org, float amplitude = 16, float frequency = 150, float duration = 1.5, float radius = 2048 )
{
	return CreateShake_internal( org, amplitude, frequency, duration, radius, 0 );
}

entity function CreateShakeRumbleOnly( vector org, float amplitude = 16, float frequency = 150, float duration = 1.5, float radius = 2048 )
{
	return CreateShake_internal( org, amplitude, frequency, duration, radius, SF_SHAKE_RUMBLE_ONLY );
}

entity function CreateShakeNoRumble( vector org, float amplitude = 16, float frequency = 150, float duration = 1.5, float radius = 2048 )
{
	return CreateShake_internal( org, amplitude, frequency, duration, radius, SF_SHAKE_NO_RUMBLE );
}

entity function CreateAirShake( vector org, float amplitude = 16, float frequency = 150, float duration = 1.5, float radius = 2048 )
{
	return CreateShake_internal( org, amplitude, frequency, duration, radius, SF_SHAKE_INAIR );
}

entity function CreateAirShakeRumbleOnly( vector org, float amplitude = 16, float frequency = 150, float duration = 1.5, float radius = 2048 )
{
	return CreateShake_internal( org, amplitude, frequency, duration, radius, (SF_SHAKE_INAIR | SF_SHAKE_RUMBLE_ONLY) );
}

entity function CreateAirShakeNoRumble( vector org, float amplitude = 16, float frequency = 150, float duration = 1.5, float radius = 2048 )
{
	return CreateShake_internal( org, amplitude, frequency, duration, radius, (SF_SHAKE_INAIR | SF_SHAKE_NO_RUMBLE) );
}

//-------------------------------------
// CreatePhysExplosion - physExplosion...small, medium or large
//--------------------------------------
entity function CreatePhysExplosion( vector org, float radius, int magnitude = 1, int flags = 1, bool dealsDamage = true )
{
	entity env_physexplosion = CreateEntity( "env_physexplosion" )
	env_physexplosion.kv.spawnflags = flags // default 1 = No Damage - Only Force
	env_physexplosion.kv.magnitude = magnitude
	env_physexplosion.kv.radius = string( radius )
	env_physexplosion.SetOrigin( org )
	env_physexplosion.kv.scriptDamageType = damageTypes.explosive
	DispatchSpawn( env_physexplosion )

	EntFireByHandle( env_physexplosion, "Explode", "", 0, null, null )
	EntFireByHandle( env_physexplosion, "Kill", "", 2, null, null )
}

//-----------------------------------------------------------
// CreatePropDynamic( model ) - create a generic prop_dynamic with default properties
//------------------------------------------------------------
entity function CreatePropDynamic( asset model, vector ornull origin = null, vector ornull angles = null, var solidType = 0, float fadeDist = -1 )
{
	entity prop_dynamic = CreateEntity( "prop_dynamic" )
	prop_dynamic.SetValueForModelKey( model )
	prop_dynamic.kv.fadedist = fadeDist
	prop_dynamic.kv.renderamt = 255
	prop_dynamic.kv.rendercolor = "255 255 255"
	prop_dynamic.kv.solid = solidType // 0 = no collision, 2 = bounding box, 6 = use vPhysics, 8 = hitboxes only
	if ( origin )
	{
		// hack: Setting origin twice. SetOrigin needs to happen before DispatchSpawn, otherwise the prop may not touch triggers
		prop_dynamic.SetOrigin( expect vector( origin ) )
		if ( angles )
			prop_dynamic.SetAngles( expect vector( angles ) )
	}
	DispatchSpawn( prop_dynamic )
	if ( origin )
	{
		// hack: Setting origin twice. SetOrigin needs to happen after DispatchSpawn, otherwise origin is snapped to nearest whole unit
		prop_dynamic.SetOrigin( expect vector( origin ) )
		if ( angles )
			prop_dynamic.SetAngles( expect vector( angles ) )
	}

	return prop_dynamic
}


//-----------------------------------------------------------
// CreatePropDynamicLightweight( model ) - create a generic prop_dynamic_lightweight with default properties
//------------------------------------------------------------
entity function CreatePropDynamicLightweight( asset model, vector ornull origin = null, vector ornull angles = null, var solidType = 0, float fadeDist = -1 )
{
	entity prop_dynamic = CreateEntity( "prop_dynamic_lightweight" )
	prop_dynamic.SetValueForModelKey( model )
	prop_dynamic.kv.fadedist = fadeDist
	prop_dynamic.kv.renderamt = 255
	prop_dynamic.kv.rendercolor = "255 255 255"
	prop_dynamic.kv.solid = solidType // 0 = no collision, 2 = bounding box, 6 = use vPhysics, 8 = hitboxes only
	if ( origin )
	{
		// hack: Setting origin twice. SetOrigin needs to happen before DispatchSpawn, otherwise the prop may not touch triggers
		prop_dynamic.SetOrigin( expect vector( origin ) )
		if ( angles )
			prop_dynamic.SetAngles( expect vector( angles ) )
	}
	DispatchSpawn( prop_dynamic )
	if ( origin )
	{
		// hack: Setting origin twice. SetOrigin needs to happen after DispatchSpawn, otherwise origin is snapped to nearest whole unit
		prop_dynamic.SetOrigin( expect vector( origin ) )
		if ( angles )
			prop_dynamic.SetAngles( expect vector( angles ) )
	}

	return prop_dynamic
}


//-----------------------------------------------------------
// CreatePropScript( model ) - create a generic prop_script with default properties
//------------------------------------------------------------
entity function CreatePropScript( asset model, vector ornull origin = null, vector ornull angles = null, int solidType = 0, float fadeDist = -1 )
{
	entity prop_script = CreateEntity( "prop_script" )
	prop_script.SetValueForModelKey( model )
	prop_script.kv.fadedist = fadeDist
	prop_script.kv.renderamt = 255
	prop_script.kv.rendercolor = "255 255 255"
	prop_script.kv.solid = solidType // 0 = no collision, 2 = bounding box, 6 = use vPhysics, 8 = hitboxes only
	if ( origin )
	{
		// hack: Setting origin twice. SetOrigin needs to happen before DispatchSpawn, otherwise the prop may not touch triggers
		prop_script.SetOrigin( expect vector( origin ) )
		if ( angles )
			prop_script.SetAngles( expect vector( angles ) )
	}
	DispatchSpawn( prop_script )
	if ( origin )
	{
		// hack: Setting origin twice. SetOrigin needs to happen after DispatchSpawn, otherwise origin is snapped to nearest whole unit
		prop_script.SetOrigin( expect vector( origin ) )
		if ( angles )
			prop_script.SetAngles( expect vector( angles ) )
	}

	return prop_script
}



//-----------------------------------------------------------
// CreatePropPhysics( model ) - create a generic prop_physics with default properties
//------------------------------------------------------------
entity function CreatePropPhysics( asset model, vector origin, vector angles )
{
	entity prop_physics = CreateEntity( "prop_physics" )
	prop_physics.SetValueForModelKey( model )
	prop_physics.kv.spawnflags = 0
	prop_physics.kv.fadedist = -1
	prop_physics.kv.physdamagescale = 0.1
	prop_physics.kv.inertiaScale = 1.0
	prop_physics.kv.renderamt = 255
	prop_physics.kv.rendercolor = "255 255 255"
	SetTeam( prop_physics, TEAM_BOTH )	// need to have a team other then 0 or it won't take impact damage

	prop_physics.SetOrigin( origin )
	prop_physics.SetAngles( angles )
	DispatchSpawn( prop_physics )

	return prop_physics
}

//-----------------------------------------------------------
// SpawnBullseye() - creates a npc_bullseye and attaches it to an entity
//------------------------------------------------------------
entity function SpawnBullseye( int team, entity ent = null )
{
	entity bullseye = CreateEntity( "npc_bullseye" )
	bullseye.SetScriptName( UniqueString( "bullseye" ) )
	bullseye.kv.rendercolor = "255 255 255"
	bullseye.kv.renderamt = 0
	bullseye.kv.health = 9999
	bullseye.kv.max_health = -1
	bullseye.kv.spawnflags = 516
	bullseye.kv.FieldOfView = 0.5
	bullseye.kv.FieldOfViewAlert = 0.2
	bullseye.kv.AccuracyMultiplier = 1.0
	bullseye.kv.physdamagescale = 1.0
	bullseye.kv.WeaponProficiency = eWeaponProficiency.VERYGOOD
	bullseye.kv.minangle = "360"
	DispatchSpawn( bullseye )

	SetTeam( bullseye, team )

	if ( ent )
	{
		vector bounds = ent.GetBoundingMaxs()
		bullseye.SetOrigin( ent.GetOrigin() + < 0, 0, bounds.z * 0.5 > )
		bullseye.SetParent( ent )
	}

	return bullseye
}

void function CenterPrint( ... )
{
	string msg = ""
	for ( int i = 0; i < vargc; i++ )
		msg = ( msg + " " + string( vargv[ i ] ) )

	int words = expect int( vargc )
	if ( words < 1 )
		words = 1

	float delay = GraphCapped( float( words ), 2.0, 8.0, 2.1, 3.5 )

	entity ent = CreateGameText( msg, -1, 0.5, 10, "255 255 255", 0.25, 0.25, delay )
	EntFireByHandle( ent, "Display", "", 0, null, null )

	thread DestroyCenterPrint( ent, delay )
}

void function DestroyCenterPrint( entity ent, float delay )
{
	wait( delay )
	ent.Destroy()
}

bool function IsValidPlayer( entity player )
{
	if ( !IsValid( player ) )
		return false

	if ( !player.IsPlayer() )
		return false

	if ( IsDisconnected( player ) )
		return false

	return true
}

bool function IsDisconnected( entity player )
{
	return player.p.isDisconnected
}

/****************************************************************************************************\
/*
|*											PLAY FX
\*
\****************************************************************************************************/

entity function PlayFX( asset effectName, vector org, vector ornull optionalAng = null, vector ornull overrideAngle = null )
{
	return __CreateFxInternal( effectName, null, "", org, optionalAng, C_PLAYFX_SINGLE, null, -1, null, overrideAngle )
}

entity function PlayFXWithControlPoint( asset effectName, vector org, entity cpoint1, int visibilityFlagOverride = -1, entity visibilityFlagEntOverride = null, vector ornull overrideAngle = null, int _type = C_PLAYFX_SINGLE )
{
	return __CreateFxInternal( effectName, null, "", org, null, _type, cpoint1, visibilityFlagOverride, visibilityFlagEntOverride, overrideAngle)
}

entity function PlayFXOnEntityWithControlPoint( asset effectName, entity ent, entity cpoint1, int visibilityFlagOverride = -1, entity visibilityFlagEntOverride = null, vector ornull overrideAngle = null, int _type = C_PLAYFX_SINGLE )
{
	return __CreateFxInternal( effectName, ent, "", null, null, _type, cpoint1, visibilityFlagOverride, visibilityFlagEntOverride, overrideAngle)
}

entity function PlayFXOnEntity( asset effectName, entity ent, string optionalTag = "", vector ornull optionalTranslation = null, vector ornull optionalRotation = null, int visibilityFlagOverride = -1, entity visibilityFlagEntOverride = null, vector ornull overrideAngle = null )
{
	return __CreateFxInternal( effectName, ent, optionalTag, optionalTranslation, optionalRotation, C_PLAYFX_SINGLE, null,  visibilityFlagOverride, visibilityFlagEntOverride, overrideAngle )
}

entity function PlayFXForPlayer( asset effectName, entity player, vector ornull org, vector ornull optionalAng = null )
{
	return __CreateFxInternal( effectName, null, "", org, optionalAng, C_PLAYFX_SINGLE, null, ENTITY_VISIBLE_TO_OWNER, player )
}

entity function PlayFXOnEntityForEveryoneExceptPlayer( asset effectName, entity ent, entity player, string optionalTag = "", vector ornull optionalTranslation = null, vector ornull optionalRotation = null )
{
	return __CreateFxInternal( effectName, ent, optionalTag, optionalTranslation, optionalRotation, C_PLAYFX_SINGLE, null, (ENTITY_VISIBLE_TO_FRIENDLY | ENTITY_VISIBLE_TO_ENEMY), player )
}

entity function PlayFXForEveryoneExceptPlayer( asset effectName, entity player, vector ornull org, vector ornull optionalAng = null )
{
	return __CreateFxInternal( effectName, null, "", org, optionalAng, C_PLAYFX_SINGLE, null, (ENTITY_VISIBLE_TO_FRIENDLY | ENTITY_VISIBLE_TO_ENEMY), player )
}

void function PlayFXOnTitanPlayerForTime( asset effectName, entity titan, string attachment, float duration )
{
	titan.EndSignal( "OnDeath" )
	titan.EndSignal( "DisembarkingTitan" )
	titan.EndSignal( "TitanEjectionStarted" )

	entity fx = PlayFXOnEntityForEveryoneExceptPlayer( effectName, titan, titan, attachment )

	OnThreadEnd(
	function() : ( fx )
		{
			if ( IsValid(fx) )
			{
				fx.Destroy()
			}
		}
	)

	wait duration
}

entity function ClientStylePlayFXOnEntity( asset effectName, entity ent, string tag, float duration = 2.0 )
{
	string name = ent.GetScriptName()
	ent.SetScriptName( UniqueString() ) // hack because you can only specify control points by name
	// hack this is also not quite right because we can't specify the attachment type on the server... should be trivial to add in code:
	// change DEFINE_FIELD( m_parentAttachmentType, FIELD_INTEGER ), to DEFINE_KEYFIELD( m_parentAttachmentType, FIELD_INTEGER, "attachmentType" ),
	entity result = __CreateFxInternal( effectName, ent, tag, null, null, C_PLAYFX_SINGLE, ent, (ENTITY_VISIBLE_TO_FRIENDLY | ENTITY_VISIBLE_TO_ENEMY), ent )
	EntFireByHandle( result, "Kill", "", duration, null, null )
	ent.SetScriptName( name )

	return result
}

entity function PlayLoopFX( asset effectName, vector ornull org, vector ornull optionalAng = null )
{
	return __CreateFxInternal( effectName, null, "", org, optionalAng, C_PLAYFX_LOOP )
}

entity function PlayLoopFXOnEntity( asset effectName, entity ent, string optionalTag = "", vector ornull optionalTranslation = null, vector ornull optionalRotation = null, int visibilityFlagOverride = -1, entity visibilityFlagEntOverride = null )
{
	return __CreateFxInternal( effectName, ent, optionalTag, optionalTranslation, optionalRotation, C_PLAYFX_LOOP, null, visibilityFlagOverride, visibilityFlagEntOverride )
}

entity function __CreateFxInternal( asset effectName, entity ent, string optionalTag = "", vector ornull optionalTranslation = <0,0,0>, vector ornull optionalRotation = <0,0,0>,
									int _type = C_PLAYFX_SINGLE, entity cpointEnt1 = null, int visibilityFlagOverride = -1, entity visibilityFlagEntOverride = null, vector ornull overrideAngle = null )
{
	entity fx = CreateEntity( "info_particle_system" )
	fx.SetValueForEffectNameKey( effectName )
	if( visibilityFlagOverride != -1 )
		fx.kv.VisibilityFlags = visibilityFlagOverride
	else
		fx.kv.VisibilityFlags = ENTITY_VISIBLE_TO_EVERYONE
	fx.kv.start_active = 1
	fx.e.fxType = _type

	if ( _type == C_PLAYFX_SINGLE )
		fx.DoNotCreateFXOnRestore();

	vector coreOrg
	vector coreAng

	//are we attaching to an ent?
	if ( ent )
	{
		//are we attaching to a tag on an ent
		if ( optionalTag != "" )
		{
			int attachID = ent.LookupAttachment( optionalTag )
			coreOrg = ent.GetAttachmentOrigin( attachID )
			coreAng = ent.GetAttachmentAngles( attachID )
		}
		else
		{
			coreOrg = ent.GetOrigin()
			coreAng = ent.GetAngles()
		}

		fx.Code_SetTeam( ent.GetTeam() );
	}
	else //if not we're just playing in space
	{
		optionalTag = ""
		coreOrg = < 0, 0, 0 >
		coreAng = < 0, 0, 0 >
	}

	if ( optionalTranslation )
	{
		expect vector( optionalTranslation )
		if ( ent )
			coreOrg = PositionOffsetFromEnt( ent, optionalTranslation.x, optionalTranslation.y, optionalTranslation.z )
		else
			coreOrg = coreOrg + optionalTranslation
	}

	coreOrg = ClampToWorldspace( coreOrg )
	fx.SetOrigin( coreOrg )

	if ( overrideAngle )
	{
		expect vector( overrideAngle )
		fx.SetAngles( overrideAngle )
	}
	else if ( optionalRotation )
	{
		expect vector( optionalRotation )
		fx.SetAngles( coreAng + optionalRotation )
	}
	else
	{
		fx.SetAngles( coreAng )
	}

	if ( ent )
	{
		if ( !ent.IsMarkedForDeletion() ) // TODO: This is a hack for shipping. The real solution is to spawn the FX before deleting the parent entity.
		{
			fx.SetParent( ent, optionalTag, true )
		}
	}

	if ( visibilityFlagEntOverride != null )
		fx.SetOwner( visibilityFlagEntOverride )

	if ( cpointEnt1 )
		fx.kv.cpoint1 = cpointEnt1.GetTargetName()

	DispatchSpawn( fx )
	thread __DeleteFxInternal( fx )

	//SetTargetName( fx, "FX_" + effectName )
	return fx
}

void function __DeleteFxInternal( entity fx )
{
	//if it loops or is multiple then don't delete internally
	if ( fx.e.fxType == C_PLAYFX_MULTIPLE )
		return

	if ( fx.e.fxType == C_PLAYFX_LOOP )
		return

	wait 30 //no way to know when an effect is over
	if ( !IsValid( fx ) )
		return

	fx.ClearParent()
	fx.Destroy()
}

void function StartFX( entity fx )
{
	Assert( fx.e.fxType == C_PLAYFX_LOOP, "Tried to use StartFX() on effect that is not LOOPING" )
	EntFireByHandle( fx, "Start", "", 0, null, null )
}

void function StopFX( entity fx )
{
	Assert( fx.e.fxType == C_PLAYFX_LOOP, "Tried to use StopFX() on effect that is not LOOPING" )
	EntFireByHandle( fx, "Stop", "", 0, null, null )
}

void function ReplayFX( entity fx )
{
	Assert( fx.e.fxType == C_PLAYFX_MULTIPLE, "Tried to use ReplayFX() on effect that is not MULTIPLE" )
	//thread it because there is a WaitFrame() inside the function
	thread __ReplayFXInternal( fx )
}

void function __ReplayFXInternal( entity fx )
{
	//for non-looping fx, we must stop first before we can fire again
	EntFireByHandle( fx, "Stop", "", 0, null, null )
	//we can't start in the same frame, WaitFrame() skips 1 false
	//it should be noted that "WaitFrame()" doesn't work with a timescale above 1
	WaitFrame()
	//may have died since the last frame
	if ( IsValid( fx ) )
		EntFireByHandle( fx, "Start", "", 0, null, null )
}

void function Entity_StopFXArray( entity ent )
{
	foreach( fx in ent.e.fxArray )
	{
		if ( IsValid( fx ) )
		{
			StopFX( fx )
			fx.Destroy()
		}
	}
}

/****************************************************************************************************\
|*											end play fx
\****************************************************************************************************/


table function GetDamageTableFromInfo( var damageInfo )
{
	table Table = {}
	Table.damageSourceId <- DamageInfo_GetDamageSourceIdentifier( damageInfo )
	Table.origin <- DamageInfo_GetDamagePosition( damageInfo )
	Table.force <- DamageInfo_GetDamageForce( damageInfo )
	Table.scriptType <- DamageInfo_GetCustomDamageType( damageInfo )

	return Table
}

bool function EntityInSolid( entity ent, entity ignoreEnt = null, int buffer = 0 ) //TODO:  This function returns true for a player standing inside a friendly grunt. It also returns true if you are right up against a ceiling.Needs fixing for next game
{
	Assert( IsValid( ent ) )
	int solidMask
	vector mins
	vector maxs
	int collisionGroup
	array<entity> ignoreEnts = []

	ignoreEnts.append( ent )

	if ( IsValid( ignoreEnt ) )
	{
		ignoreEnts.append( ignoreEnt )
	}

	if ( ent.IsTitan() )
		solidMask = TRACE_MASK_TITANSOLID
	else if ( ent.IsPlayer() )
		solidMask = TRACE_MASK_PLAYERSOLID
	else
		solidMask = TRACE_MASK_NPCSOLID

	if ( ent.IsPlayer() )
	{
		mins = ent.GetPlayerMins()
		maxs = ent.GetPlayerMaxs()
		collisionGroup = TRACE_COLLISION_GROUP_PLAYER
	}
	else
	{
		Assert( ent.IsNPC() )
		mins = ent.GetBoundingMins()
		maxs = ent.GetBoundingMaxs()
		collisionGroup = TRACE_COLLISION_GROUP_NONE
	}

	if ( buffer > 0 )
	{
		mins.x -= float( buffer )
		mins.y -= float( buffer )
		maxs.x += float( buffer )
		maxs.y += float( buffer )
	}

	// if we got into solid, teleport back to safe place
	vector currentOrigin = ent.GetOrigin()
	TraceResults result = TraceHull( currentOrigin, currentOrigin + < 0, 0, 1 >, mins, maxs, ignoreEnts, solidMask, collisionGroup )
	//PrintTable( result )
	//DrawArrow( result.endPos, Vector(0,0,0), 5, 150 )
	if ( result.startSolid )
		return true

	return result.fraction < 1.0 // TODO: Probably not needed according to Jiesang. Fix after ship.
}

bool function EntityInSpecifiedEnt( entity ent, entity specifiedEnt, int buffer = 0 )
{
	Assert( IsValid( ent ) )
	Assert( IsValid( specifiedEnt ) )

	int solidMask
	vector mins
	vector maxs
	int collisionGroup

	if ( ent.IsTitan() )
		solidMask = TRACE_MASK_TITANSOLID
	else if ( ent.IsPlayer() )
		solidMask = TRACE_MASK_PLAYERSOLID
	else
		solidMask = TRACE_MASK_NPCSOLID

	if ( ent.IsPlayer() )
	{
		mins = ent.GetPlayerMins()
		maxs = ent.GetPlayerMaxs()
		collisionGroup = TRACE_COLLISION_GROUP_PLAYER
	}
	else
	{
		Assert( ent.IsNPC() )
		mins = ent.GetBoundingMins()
		maxs = ent.GetBoundingMaxs()
		collisionGroup = TRACE_COLLISION_GROUP_NONE
	}

	if ( buffer > 0 )
	{
		mins.x -= float( buffer )
		mins.y -= float( buffer )
		maxs.x += float( buffer )
		maxs.y += float( buffer )
	}

	// if we got into solid, teleport back to safe place
	vector currentOrigin = ent.GetOrigin()
	TraceResults result = TraceHull( currentOrigin, currentOrigin + < 0, 0, 1 >, mins, maxs, null, solidMask, collisionGroup )
	//PrintTable( result )
	//DrawArrow( result.endPos, Vector(0,0,0), 5, 150 )
	if ( result.startSolid == false )
		return false

	return result.hitEnt == specifiedEnt
}

void function KillFromInfo( entity ent, var damageInfo )
{
	entity attacker = DamageInfo_GetAttacker( damageInfo )
	entity weapon = DamageInfo_GetWeapon( damageInfo )
	//float amount = DamageInfo_GetDamage( damageInfo )

	// JFS: if the player became invalid, the attacker becomes the projectile which is bad
	if ( attacker.IsProjectile() )
		attacker = svGlobal.worldspawn

	if ( !weapon )
		weapon = attacker

	table Table = GetDamageTableFromInfo( damageInfo )
	Table.forceKill <- true

	ent.TakeDamage( 9999, attacker, weapon, Table )
}


entity function GetPlayerTitanInMap( entity player )
{
	// temporarily flipped
	entity petTitan = player.GetPetTitan()
	if ( IsValid( petTitan ) && IsAlive( petTitan ) )
		return petTitan

	// first try to return the player's actual titan
	if ( player.IsTitan() )
		return player

	return null
}


entity function GetPlayerTitanFromSouls( entity player )
{
	// returns the first owned titan found
	array<entity> souls = GetTitanSoulArray()
	foreach ( soul in souls )
	{
		if ( !IsValid( soul ) )
			continue

		if ( soul.GetBossPlayer() != player )
			continue

		if ( !IsAlive( soul.GetTitan() ) )
			continue

		return soul.GetTitan()
	}

	return null
}

void function DisableTitanShield( entity titan )
{
	entity soul = titan.GetTitanSoul()

	soul.SetShieldHealth( 0 )
	soul.SetShieldHealthMax( 0 )
}

void function DisableShield( entity ent )
{
	entity soul = ent.GetTitanSoul()

	if ( soul )
	{
		DisableTitanShield( ent )
		return
	}

	ent.SetShieldHealth( 0 )
	ent.SetShieldHealthMax( 0 )
}

void function SetVelocityTowardsEntity( entity entToMove, entity targetEnt, float speed )
{
	Assert( speed > 0 )
	Assert( IsValid( entToMove ) )
	Assert( IsValid( targetEnt ) )

	vector direction = ( targetEnt.GetWorldSpaceCenter() - entToMove.GetOrigin() )
	direction = Normalize( direction ) * speed
	entToMove.SetVelocity( direction )
}

void function SetVelocityTowardsEntityTag( entity entToMove, entity targetEnt, string targetTag, float speed )
{
	Assert( speed > 0 )
	Assert( IsValid( entToMove ) )
	Assert( IsValid( targetEnt ) )

	int attachID = targetEnt.LookupAttachment( targetTag )
	vector attachOrigin = targetEnt.GetAttachmentOrigin( attachID )

	vector direction = ( attachOrigin - entToMove.GetOrigin() )
	direction = Normalize( direction ) * speed
	entToMove.SetVelocity( direction )
}

void function EntityDemigod_TryAdjustDamageInfo( entity ent, var damageInfo )
{
	float dmg = DamageInfo_GetDamage( damageInfo )
	if ( dmg <= 0 )
		return

	if ( ent.IsTitan() && !GetDoomedState( ent ) ) //Allow demigod titans to go into doomed
		return

	int bottomLimit = 5
	// Set it up so that you at least take 1 damage, for hit indicators etc to trigger
	if ( ent.GetHealth() <= bottomLimit )
	{
		// Prevent going over max health to avoid a server crash.
		int newHealth = bottomLimit + 1
		ent.SetHealth( ent.GetMaxHealth() < newHealth ? ent.GetMaxHealth() : newHealth )
	}

	int health = ent.GetHealth()

	if ( health - dmg <= bottomLimit )
	{
		int newdmg = health - bottomLimit
		DamageInfo_SetDamage( damageInfo, newdmg )
		//printt( "setting damage to ", newdmg )
	}
}

void function DebugDamageInfo( entity ent, var damageInfo )
{
	printt( "damage to " + ent + ": " + DamageInfo_GetDamage( damageInfo ) )
	int damageType = DamageInfo_GetCustomDamageType( damageInfo )
	printt( "explosive: " + ( damageType & DF_EXPLOSION ) )
	printt( "bullet: " + ( damageType & DF_BULLET ) )
	printt( "gib: " + ( damageType & DF_GIB ) )

	vector dampos = DamageInfo_GetDamagePosition( damageInfo )
	vector org = DamageInfo_GetInflictor( damageInfo ).GetOrigin()
	DebugDrawLine( dampos, org, 255, 0, 0, true, 10.0 )
	DebugDrawLine( org, ent.GetOrigin(), 255, 255, 0, true, 10.0 )
}

vector function RandomVecInDome( vector dir )
{
	vector angles = VectorToAngles( dir )
	vector forward = AnglesToForward( angles )
	vector right = AnglesToRight( angles )
	vector up = AnglesToUp( angles )

	float offsetRight = RandomFloatRange( -1, 1 )
	float offsetUp = RandomFloatRange( -1, 1 )
	float offsetForward = RandomFloat( 1.0 )

	vector endPos = < 0, 0, 0 >
	endPos += forward * offsetForward
	endPos += up * offsetUp
	endPos += right * offsetRight
	endPos.Norm()

	return endPos
}

float function GetAnimEventTime( asset modelname, string anim, string event )
{
	entity dummy = CreatePropDynamic( modelname )
	dummy.Hide()

	float duration 	= dummy.GetSequenceDuration( anim )
	float frac 		= dummy.GetScriptedAnimEventCycleFrac( anim, event )

	dummy.Destroy()

	//this might cause some issues in R2 - but we'll fix them as we go - it's important this doesn't silently fail
	Assert( frac > 0.0, "event: " + event + " doesn't exist in animation: " + anim )
	Assert( frac < 1.0, "event: " + event + " doesn't exist in animation: " + anim )

	return duration * frac
}

void function SetDeathFuncName( entity npc, string functionNameString )
{
	Assert( npc.kv.deathScriptFuncName == "", "deathScriptFuncName was already set" )
	npc.kv.deathScriptFuncName = functionNameString
}

void function ClearDeathFuncName( entity npc )
{
	npc.kv.deathScriptFuncName = ""
}

/*function PushSunLightAngles( x, y, z )
{
	entity clight = GetEnt( "env_cascade_light" )
	Assert( clight )

	clight.PushAngles( x, y, z )
}

function PopSunLightAngles()
{
	entity clight = GetEnt( "env_cascade_light" )
	Assert( clight )

	clight.PopAngles()
}*/

entity function GetPilotAntiPersonnelWeapon( entity player )
{
	array<entity> weaponsArray = player.GetMainWeapons()
	foreach( weapon in weaponsArray )
	{
			int weaponType = weapon.GetWeaponType()
			if ( weaponType == WT_SIDEARM || weaponType == WT_ANTITITAN )
				continue;

			return weapon
	}

	return null
}

entity function GetPilotSideArmWeapon( entity player )
{
	array<entity> weaponsArray = player.GetMainWeapons()
	foreach( weapon in weaponsArray )
	{
		if ( weapon.GetWeaponType() == WT_SIDEARM )
			return weapon
	}

	return null
}

entity function GetPilotAntiTitanWeapon( entity player )
{
	array<entity> weaponsArray = player.GetMainWeapons()
	foreach( weapon in weaponsArray )
	{
		if ( weapon.GetWeaponType() == WT_ANTITITAN )
			return weapon
	}

	return null
}

bool function PilotHasSniperWeapon( entity player )
{
	array<entity> weaponsArray = player.GetMainWeapons()
	foreach ( weapon in weaponsArray )
	{
		if ( IsValid( weapon ) && weapon.GetWeaponInfoFileKeyField( "is_sniper" ) == 1 )
			return true
	}

	return false
}

bool function PilotActiveWeaponIsSniper( entity player )
{
	entity weapon = player.GetActiveWeapon()

	if ( IsValid( weapon ) && weapon.GetWeaponInfoFileKeyField( "is_sniper" ) == 1 )
		return true

	return false
}

void function ScreenFadeToColor( entity player, float r, float g, float b, float a, float fadeTime = 1.7, float holdTime = 0.0 )
{
	Assert( IsValid( player ) )

	ScreenFade( player, r, g, b, a, fadeTime, holdTime, FFADE_OUT | FFADE_PURGE )
}


void function ScreenFadeFromColor( entity player, float r, float g, float b, float a, float fadeTime = 2.0, float holdTime = 2.0 )
{
	Assert( IsValid( player ) )

	ScreenFade( player, r, g, b, a, fadeTime, holdTime, FFADE_IN | FFADE_PURGE )
}

void function ScreenFadeToBlack( entity player, float fadeTime, float holdTime )
{
	Assert( IsValid( player ) )

	ScreenFade( player, 0, 0, 1, 255, fadeTime, holdTime, FFADE_OUT | FFADE_PURGE )
}

void function ScreenFadeFromBlack( entity player, float fadeTime = 2.0, float holdTime = 2.0 )
{
	Assert( IsValid( player ) )

	ScreenFade( player, 0, 1, 0, 255, fadeTime, holdTime, FFADE_IN | FFADE_PURGE )
}

void function ScreenFadeToBlackForever( entity player, float fadeTime = 1.7 )
{
	Assert( IsValid( player ) )

	ScreenFade( player, 0, 0, 1, 255, fadeTime, 0, FFADE_OUT | FFADE_STAYOUT )
}

/*******************************************************
/ Server Effects
/
/	CreateServerEffect_Friendly( effectName, team )
/	CreateServerEffect_Enemy( effectName, team )
/	CreateServerEffect_Owner( effectName, owner )
/	SetServerEffectControlPoint( effectEnt, controlPoint, vecValue )
/	StartServerEffect( effectEnt )
/	StartServerEffectInWorld( effectEnt, origin, angles )
/	StartServerEffectOnEntity( effectEnt, ent, tag = null )
/
*******************************************************/

// NOTE: this does not play the effect, use StartEffectOnEntity
entity function CreateServerEffect_Friendly( asset effectName, int team )
{
	entity friendlyEffect = _CreateServerEffect( effectName, 2 ) // ENTITY_VISIBLE_TO_FRIENDLY
	friendlyEffect.kv.TeamNum = team
	friendlyEffect.kv.teamnumber = team

	return friendlyEffect
}

// NOTE: this does not play the effect, use StartEffectOnEntity
entity function CreateServerEffect_Enemy( asset effectName, int team )
{
	entity enemyEffect = _CreateServerEffect( effectName, 4 ) // ENTITY_VISIBLE_TO_ENEMY
	enemyEffect.kv.TeamNum = team
	enemyEffect.kv.teamnumber = team

	return enemyEffect
}

// NOTE: this does not play the effect, use StartEffectOnEntity
entity function CreateServerEffect_Owner( asset effectName, entity owner )
{
	Assert( IsValid( owner ) )

	entity ownerEffect = _CreateServerEffect( effectName, 1 ) // ENTITY_VISIBLE_TO_OWNER
	ownerEffect.kv.TeamNum = owner.GetTeam()
	ownerEffect.SetOwner( owner )

	return ownerEffect
}

entity function _CreateServerEffect( asset effectName, int visFlags )
{
	entity serverEffect = CreateEntity( "info_particle_system" )
	serverEffect.SetOrigin( <0, 0, 0> )
	serverEffect.SetAngles( <0, 0, 0> )
	serverEffect.SetValueForEffectNameKey( effectName )
	serverEffect.kv.start_active = 1
	serverEffect.kv.VisibilityFlags = visFlags

	thread _ServerEffectCleanup( serverEffect )
	return serverEffect
}

entity function SetServerEffectControlPoint( entity effectEnt, int controlPoint, vector vecValue ) // for now, only support static
{
	entity helper = CreateEntity( "info_placement_helper" )
	helper.SetOrigin( vecValue )
	effectEnt.SetControlPointEnt( controlPoint, helper )
	effectEnt.e.fxControlPoints.append( helper )

	return helper
}

void function StartServerEffect( entity effectEnt )
{
	DispatchSpawn( effectEnt )
}

void function StartServerEffectInWorld( entity effectEnt, vector origin, vector angles )
{
	effectEnt.SetOrigin( origin )
	effectEnt.SetAngles( angles )
	DispatchSpawn( effectEnt )
}

void function StartServerEffectOnEntity( entity effectEnt, entity ent, string tag = "" )
{
	Assert( IsValid( effectEnt ) )
	Assert( IsValid( ent ) )

	if ( tag != "" )
	{
		int attachID = ent.LookupAttachment( tag )
		vector origin = ent.GetAttachmentOrigin( attachID )
		vector angles = ent.GetAttachmentAngles( attachID )

		origin = ClampToWorldspace( origin )
		effectEnt.SetOrigin( origin )
		effectEnt.SetAngles( angles )
		effectEnt.SetParent( ent, tag, true )
	}
	else
	{
		effectEnt.SetParent( ent )
	}

	DispatchSpawn( effectEnt )
}

void function _ServerEffectCleanup( entity effectEnt )
{
	effectEnt.WaitSignal( "OnDestroy" )

	foreach ( entity controlPoint in effectEnt.e.fxControlPoints )
	{
		controlPoint.Destroy()
	}
}

float function GetYaw( vector org1, vector org2 )
{
	vector vec = org2 - org1
	vector angles = VectorToAngles( vec )
	return angles.y
}

void function HideName( entity ent )
{
	ent.SetNameVisibleToFriendly( false )
	ent.SetNameVisibleToEnemy( false )
	ent.SetNameVisibleToNeutral( false )
	ent.SetNameVisibleToOwner( false )
}

void function ShowName( entity ent )
{
	ent.SetNameVisibleToFriendly( true )
	ent.SetNameVisibleToEnemy( true )
	ent.SetNameVisibleToNeutral( true )
	ent.SetNameVisibleToOwner( true )
}

void function ShowNameToAllExceptOwner( entity ent )
{
	ent.SetNameVisibleToFriendly( true )
	ent.SetNameVisibleToEnemy( true )
	ent.SetNameVisibleToNeutral( true )
	ent.SetNameVisibleToOwner( false )
}

void function EmitSoundOnEntityToTeamExceptPlayer( entity ent, string sound, int team, entity excludePlayer )
{
	array<entity> players = GetPlayerArrayOfTeam( team )

	foreach ( player in players )
	{
		if ( player == excludePlayer )
			continue

		EmitSoundOnEntityOnlyToPlayer( ent, player, sound )
	}
}

#if DEV
// DEV function to toggle player view between the skybox and the real world.
void function ToggleSkyboxView( float scale = 0.001 )
{
	entity player = GetEntByIndex( 1 )

	entity skyboxCamLevel = GetEnt( "skybox_cam_level" )

	Assert( IsValid( skyboxCamLevel ), "Could not find a sky_camera entity named \"skybox_cam_level\" in this map." )

	vector skyOrigin = skyboxCamLevel.GetOrigin()

	if ( !file.isSkyboxView )
	{
		if ( !player.IsNoclipping() )
		{
			ClientCommand( player, "noclip" )
			wait( 0.25 )
		}

		ClientCommand( player, "sv_noclipspeed 0.1" )
		file.isSkyboxView = true
		vector offset = player.GetOrigin()
		offset *= scale

		player.SetOrigin( skyOrigin + offset - < 0.0, 0.0, 60.0 - (60.0 * scale) > )
	}
	else
	{
		ClientCommand( player, "sv_noclipspeed 5" )
		file.isSkyboxView = false
		vector offset = player.GetOrigin() - skyOrigin + < 0.0, 0.0, 60.0 - (60.0 * scale) >
		offset *= 1.0 / scale

		offset = ClampToWorldspace( offset )

		player.SetOrigin( offset )
	}
}

void function DamageRange( float value, float headShotMultiplier, int playerHealth = 200 )
{
	printt( "Damage Range: ", value, headShotMultiplier )

	float bodyShot = value
	float headShot = value * headShotMultiplier

	int maxHeadshots = 0

	int simHealth = playerHealth
	while ( simHealth > 0 )
	{
		simHealth = (simHealth.tofloat() - headShot).tointeger()
		maxHeadshots++
	}

	printt( "HeadShots:    BodyShots:     Total:" )

	simHealth = playerHealth
	int numHeadshots = 0
	while ( numHeadshots < maxHeadshots )
	{
		simHealth = playerHealth
		for ( int hsIdx = 0; hsIdx < numHeadshots; hsIdx++ )
		{
			simHealth = (simHealth.tofloat() - headShot).tointeger()
		}

		int numBodyShots = 0
		while ( simHealth > 0 )
		{
			simHealth = (simHealth.tofloat() - bodyShot).tointeger()
			numBodyShots++
		}
		printt( format( "%i             %i              %i", numHeadshots, numBodyShots, numHeadshots + numBodyShots ) )
		numHeadshots++
	}

	printt( format( "%i             %i              %i", numHeadshots, 0, numHeadshots ) )
}

#endif // DEV

void function MuteAll( entity player, int fadeOutTime = 2 )
{
	//DumpStack(2)
	Assert( player.IsPlayer() )

	Assert( fadeOutTime >= 1 && fadeOutTime <= 4 , "Only have 4 kinds of fadeout to play, time must be in the range [1,4]" )

	string fadeoutSoundString

	switch( fadeOutTime )
	{
		case 1:
			fadeoutSoundString = "1_second_fadeout"
			break

		case 2:
			fadeoutSoundString = "2_second_fadeout"
			break

		case 3:
			fadeoutSoundString = "3_second_fadeout"
			break

		case 4:
			fadeoutSoundString = "4_second_fadeout"
			break

		default:
			unreachable

	}

	printt( "Apply " +  fadeoutSoundString + " to player: " + player )

	EmitSoundOnEntityOnlyToPlayer( player, player, fadeoutSoundString )
}

//Mutes all except halftime sounds and dialogue
void function MuteHalfTime( entity player )
{
	Assert( player.IsPlayer() )
	printt( "Apply HalfTime_fadeout to player: " + player )
	EmitSoundOnEntityOnlyToPlayer( player, player, "HalfTime_fadeout" )
}

void function UnMuteAll( entity player )
{
	//DumpStack(2)
	Assert( player.IsPlayer() )

	//Just stop all the possible fadeout sounds.
	printt( "Stopping all fadeout for player: " + player )
	StopSoundOnEntity( player, "1_second_fadeout" )
	StopSoundOnEntity( player, "2_second_fadeout" )
	StopSoundOnEntity( player, "3_second_fadeout" )
	StopSoundOnEntity( player, "4_second_fadeout" )
	StopSoundOnEntity( player, "HalfTime_fadeout" )
}

void function AllPlayersMuteAll( int time = MUTEALLFADEIN )
{
	array<entity> players = GetPlayerArray()

	foreach ( player in players )
		MuteAll( player, time )
}

void function AllPlayersUnMuteAll()
{
	array<entity> players = GetPlayerArray()

	foreach ( player in players )
		UnMuteAll( player )
}

void function TakeAmmoFromPlayer( entity player )
{
	array<entity> mainWeapons = player.GetMainWeapons()
	array<entity> offhandWeapons = player.GetOffhandWeapons()

	foreach ( weapon in mainWeapons )
	{
		weapon.SetWeaponPrimaryAmmoCount( 0 )

		if ( weapon.GetWeaponPrimaryClipCountMax() > 0 )
			weapon.SetWeaponPrimaryClipCount( 0 )
	}

	foreach ( weapon in offhandWeapons )
	{
		weapon.SetWeaponPrimaryAmmoCount( 0 )

		if ( weapon.GetWeaponPrimaryClipCountMax() > 0 )
			weapon.SetWeaponPrimaryClipCount( 0 )
	}
}


bool function NearFlagSpawnPoint( vector dropPoint )
{
	if ( "flagSpawnPoint" in level && IsValid( level.flagSpawnPoint ) )
	{
		vector fspOrigin = expect entity( level.flagSpawnPoint ).GetOrigin()
		if ( Distance( fspOrigin, dropPoint ) < SAFE_TITANFALL_DISTANCE_CTF )
			return true
	}

	if ( "flagReturnPoint" in level && IsValid( level.flagReturnPoint ) )
	{
		vector fspOrigin = expect entity( level.flagReturnPoint ).GetOrigin()
		if ( Distance( fspOrigin, dropPoint ) < SAFE_TITANFALL_DISTANCE_CTF )
			return true
	}

	if ( "flagSpawnPoints" in level )
	{
		foreach ( flagSpawnPoint in svGlobal.flagSpawnPoints )
		{
			vector fspOrigin = flagSpawnPoint.GetOrigin()
			if ( Distance( fspOrigin, dropPoint ) < SAFE_TITANFALL_DISTANCE_CTF )
				return true
		}
	}

	return false
}

bool function HasCinematicFlag( entity player, int flag )
{
	Assert( player.IsPlayer() )
	Assert( IsValid( player ) )
	return ( player.GetCinematicEventFlags() & flag ) != 0
}

void function AddCinematicFlag( entity player, int flag )
{
	Assert( player.IsPlayer() )
	Assert( IsValid( player ) )
	player.SetCinematicEventFlags( player.GetCinematicEventFlags() | flag )
	player.Signal( "CE_FLAGS_CHANGED" )
}

void function RemoveCinematicFlag( entity player, int flag )
{
	Assert( player.IsPlayer() )
	Assert( IsValid( player ) )
	player.SetCinematicEventFlags( player.GetCinematicEventFlags() & ( ~flag ) )
	player.Signal( "CE_FLAGS_CHANGED" )
}

void function SkyScaleDefault( entity ent, float time = 1.0 )
{
	if ( IsValid( ent ) )
		ent.LerpSkyScale( SKYSCALE_DEFAULT, time )
}

void function MoveSpawn( string targetName, vector origin, vector angles )
{
	entity ent = GetEnt( targetName )
	ent.SetOrigin( origin )
	ent.SetAngles( angles )
}

/*
function CheckDailyChallengeAchievement( entity player )
{
	if ( player.GetPersistentVar( "cu8achievement.ach_allDailyChallengesForDay" ) == true )
		return

	int maxRefs = PersistenceGetArrayCount( "activeDailyChallenges" )
	int todaysDailiesComplete = 0
	int today = Daily_GetDayForCurrentTime()
	for ( int i = 0; i < maxRefs; i++ )
	{
		int day = player.GetPersistentVarAsInt( "activeDailyChallenges[" + i + "].day" )
		if ( day != today )
			continue

		local ref = player.GetPersistentVar( "activeDailyChallenges[" + i + "].ref" )
		if ( !IsChallengeComplete( ref, player ) )
			continue

		todaysDailiesComplete++
	}

	if ( todaysDailiesComplete >= 3 )
		player.SetPersistentVar( "cu8achievement.ach_allDailyChallengesForDay", true )
}
*/

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Get an array of all linked entities targeted to one after the other down the chain
array<entity> function GetEntityTargetChain_Deprecated( entity ent )
{
	array<entity> entityChain = []
	entity currentEnt = ent
	entity nextEnt

	while ( true )
	{
		nextEnt = GetEnt( currentEnt.GetTarget_Deprecated() )
		if ( IsValid( nextEnt ) )
			entityChain.append( nextEnt )
		else
			return entityChain
		currentEnt = nextEnt
	}

	unreachable
}

void function PlayImpactFXTable( vector origin, entity owner, string impactFX, int flags = 0 )
{
	Explosion(
		origin,										//center,
		owner,										//attacker,
		owner,										//inflictor,flags
		0,											//damage,
		0,											//damageHeavyArmor,
		1,											//innerRadius,
		1,											//outerRadius,
		flags,										//flags,
		origin,										//projectileLaunchOrigin,
		0,											//explosionForce,
		damageTypes.explosive,						//scriptDamageFlags,
		-1,											//scriptDamageSourceIdentifier,
		impactFX )									//impactEffectTableName
}

void function SetSignalDelayed( entity ent, string signal, float delay )
{
	thread __SetSignalDelayedThread( ent, signal, delay )
}

void function __SetSignalDelayedThread( entity ent, string signal, float delay )
{
	EndSignal( ent, signal )	// so that if we call this again with the same signal on the same ent we won't get multiple signal events.

	wait delay
	if ( IsValid( ent ) )
		Signal( ent, signal )
}

#if DEV
table function GetPlayerPos( entity player = null )
{
	if ( !player )
		player = gp()[0]

	vector org = player.GetOrigin()
	vector vec = player.GetViewVector()
	vector ang = VectorToAngles( vec )

	return { origin = org, angles = ang }
}

string function GetScriptPos( entity player = null )
{
	table playerPos = GetPlayerPos( player )
	vector origin = expect vector( playerPos.origin )
	vector angles = expect vector( playerPos.angles )

	string returnStr = CreateOriginAnglesString( origin, <0, angles.y, 0> )
	return returnStr
}

string function CreateOriginAnglesString( vector origin, vector angles )
{
	string returnStr = "< " + origin.x + ", " + origin.y + ", " + origin.z + " >, < " + angles.x + ", " + angles.y + ", " + angles.z + " >"
	return returnStr
}

void function DistCheck_SetTestPoint()
{
	svGlobal.distCheckTestPoint = expect vector( GetPlayerPos().origin )
	printt( "DistCheck test point set to:", svGlobal.distCheckTestPoint )
}

void function DistCheck()
{
	vector here = expect vector( GetPlayerPos().origin )
	float dist = Distance( here, svGlobal.distCheckTestPoint )
	printt( "Distance:", dist, "units from", svGlobal.distCheckTestPoint )
}
#endif // DEV

void function ClearChildren( entity parentEnt ) //Probably should have code give us a GetChildren() function that returns a list instead of having to iterate through NextMovePeer
{
	entity childEnt = parentEnt.FirstMoveChild()
	entity nextChildEnt

	while ( childEnt != null )
	{
		nextChildEnt = childEnt.NextMovePeer()
		childEnt.ClearParent()

		childEnt = nextChildEnt
	}
}

void function ForceTimeLimitDone()
{
	level.devForcedWin = true
	level.devForcedTimeLimit = true
	svGlobal.levelEnt.Signal( "devForcedWin" )
	ServerCommand( "mp_enabletimelimit 1" )
	ServerCommand( "mp_enablematchending 1" )
}


void function UpdateBadRepPresent()
{
	array<entity> players = GetPlayerArray()
	bool found = false
/*	always set to false for now
	foreach ( player in players )
	{
		if ( player.HasBadReputation() )
		{
			found = true
			break
		}
	}
*/
	level.nv.badRepPresent = found
	level.ui.badRepPresent = found
}

void function Dev_PrintMessage( entity player, string text, string subText = "", float duration = 7.0, string soundAlias = "" )
{
	#if DEV
	// Build the message on the client
	string sendMessage
	for ( int textType = 0 ; textType < 2 ; textType++ )
	{
		sendMessage = textType == 0 ? text : subText

		for ( int i = 0; i < sendMessage.len(); i++ )
		{
			Remote_CallFunction_NonReplay( player, "Dev_BuildClientMessage", textType, sendMessage[i] )
		}
	}
	Remote_CallFunction_NonReplay( player, "Dev_PrintClientMessage", duration )
	if ( soundAlias != "" )
		EmitSoundOnEntity( player, soundAlias )
	#endif
}

bool function IsAttackDefendBased() //If needed to, we can make this a .nv and then move this function into utility_shared
{
	return expect bool( level.attackDefendBased )
}

bool function IsRoundBasedUsingTeamScore()  //If needed to, we can make this a .nv and then move this function into utility_shared
{
	return IsRoundBased() && expect bool( level.roundBasedUsingTeamScore )
}

bool function ShouldResetRoundBasedTeamScore()
{
	return IsRoundBased() && svGlobal.roundBasedTeamScore_RoundReset
}

void function CreateZipline( vector startPos, vector endPos )
{
	string startpointName = UniqueString( "rope_startpoint" )
	string endpointName = UniqueString( "rope_endpoint" )

	entity rope_start = CreateEntity( "move_rope" )
	SetTargetName( rope_start, startpointName )
	rope_start.kv.NextKey = endpointName
	rope_start.kv.MoveSpeed = 64
	rope_start.kv.Slack = 25
	rope_start.kv.Subdiv = "2"
	rope_start.kv.Width = "2"
	rope_start.kv.Type = "0"
	rope_start.kv.TextureScale = "1"
	rope_start.kv.RopeMaterial = "cable/zipline.vmt"
	rope_start.kv.PositionInterpolator = 2
	rope_start.kv.Zipline = "1"
	rope_start.kv.ZiplineAutoDetachDistance = "150"
	rope_start.kv.ZiplineSagEnable = "0"
	rope_start.kv.ZiplineSagHeight = "50"
	rope_start.SetOrigin( startPos )

	entity rope_end = CreateEntity( "keyframe_rope" )
	SetTargetName( rope_end, endpointName )
	rope_end.kv.MoveSpeed = 64
	rope_end.kv.Slack = 25
	rope_end.kv.Subdiv = "2"
	rope_end.kv.Width = "2"
	rope_end.kv.Type = "0"
	rope_end.kv.TextureScale = "1"
	rope_end.kv.RopeMaterial = "cable/zipline.vmt"
	rope_end.kv.PositionInterpolator = 2
	rope_end.kv.Zipline = "1"
	rope_end.kv.ZiplineAutoDetachDistance = "150"
	rope_end.kv.ZiplineSagEnable = "0"
	rope_end.kv.ZiplineSagHeight = "50"
	rope_end.SetOrigin( endPos )

	DispatchSpawn( rope_start )
	DispatchSpawn( rope_end )
}

string function GetNPCTitanSettingFile( entity titan )
{
	Assert( titan.IsTitan(), titan + " is not a titan" )
	return titan.ai.titanSettings.titanSetFile
}

void function DecodeBitField( int bitField )
{
	for ( int bitIndex = 0; bitIndex < 32; bitIndex++ )
	{
		if ( bitField & (1 << bitIndex) )
		{
			printt( "Comparison: ", bitField, "& ( 1 <<", bitIndex, ") = ", bitField & (1 << bitIndex) )
			printt( "BIT SET: ", bitIndex, bitField, 1 << bitIndex )
		}
	}
}

void function DropWeapon( entity npc )
{
	entity weapon = npc.GetActiveWeapon()
	if ( !weapon )
		return

	string name = weapon.GetWeaponClassName()

	// giving the weapon you have drops a new one in its place
	npc.GiveWeapon( name )
	npc.TakeActiveWeapon()
}

void function TestGiveGunTo( int index, string weaponName )
{
	entity ent = GetEntByIndex( index )
	if ( !ent )
	{
		printt( "No entity for index:", index )
		return;
	}

	TakePrimaryWeapon( ent )
	ent.GiveWeapon( weaponName )
	ent.SetActiveWeaponByName( weaponName )
}

string function GetEditorClass( entity self )
{
	if ( self.HasKey( "editorclass" ) )
		return expect string( self.kv.editorclass )

	return ""
}

bool function TitanHasRegenningShield( entity soul )
{
	if ( !TitanShieldRegenEnabled() )
		return false

	if ( !TitanShieldDecayEnabled() )
		return true

	if ( SoulHasPassive( soul, ePassives.PAS_SHIELD_BOOST ) )
		return true

	return false
}

void function DelayShieldDecayTime( entity soul, float delay )
{
	soul.e.nextShieldDecayTime = Time() + delay
}

void function HighlightWeapon( entity weapon )
{
#if HAS_WEAPON_PICKUP_HIGHLIGHT
	if ( weapon.IsLoadoutPickup() )
	{
		Highlight_SetOwnedHighlight( weapon, "sp_loadout_pickup" )
		Highlight_SetNeutralHighlight( weapon, "sp_loadout_pickup" )
	}
	else
	{
		Highlight_SetOwnedHighlight( weapon, "weapon_drop_active" )
		Highlight_SetNeutralHighlight( weapon, "weapon_drop_normal" )
	}
#endif // #if HAS_WEAPON_PICKUP_HIGHLIGHT
}

void function WaitTillLookingAt( entity player, entity ent, bool doTrace, float degrees, float minDist = 0, float timeOut = 0, entity trigger = null, string failsafeFlag = "" )
{
	EndSignal( ent, "OnDestroy" )
	EndSignal( player, "OnDeath" )

	//trigger = the trigger ther player must be touching while doing the check
	//failsafeFlag = bypass everything if this flag gets set

	if ( failsafeFlag != "" )
		EndSignal( level, failsafeFlag )

	float minDistSqr = minDist * minDist
	Assert( minDistSqr >= 0 )
	float timeoutTime = Time() + timeOut

	while( true )
	{

		if ( timeOut > 0 && Time() > timeoutTime )
			break

		if ( failsafeFlag != "" && Flag( failsafeFlag ) )
			break

		// Within range?
		if ( minDistSqr > 0 && DistanceSqr( player.GetOrigin(), ent.GetOrigin() ) > minDistSqr )
		{
			WaitFrame()
			continue
		}

		// Touching trigger?
		if ( ( trigger != null ) && ( !trigger.IsTouching( player ) ) )
		{
			WaitFrame()
			continue
		}

		if ( PlayerCanSee( player, ent, doTrace, degrees ) )
			break

		WaitFrame()
	}
}

void function SetTargetName( entity ent, string name )
{
	ent.SetValueForKey( "targetname", name )
}

ZipLine function CreateZipLine( vector start, vector end, int autoDetachDistance = 150, float ziplineMoveSpeedScale = 1.0 )
{
	string midpointName = UniqueString( "rope_midpoint" )
	string endpointName = UniqueString( "rope_endpoint" )

	entity rope_start = CreateEntity( "move_rope" )
	rope_start.kv.NextKey = midpointName
	rope_start.kv.MoveSpeed = 0
	rope_start.kv.ZiplineMoveSpeedScale = ziplineMoveSpeedScale
	rope_start.kv.Slack = 0
	rope_start.kv.Subdiv = 0
	rope_start.kv.Width = "2"
	rope_start.kv.TextureScale = "1"
	rope_start.kv.RopeMaterial = "cable/zipline.vmt"
	rope_start.kv.PositionInterpolator = 2
	rope_start.kv.Zipline = "1"
	rope_start.kv.ZiplineAutoDetachDistance = string( autoDetachDistance )
	rope_start.kv.ZiplineSagEnable = "0"
	rope_start.kv.ZiplineSagHeight = "0"
	rope_start.SetOrigin( start )

	entity rope_mid = CreateEntity( "keyframe_rope" )
	SetTargetName( rope_mid, midpointName )
	rope_start.kv.NextKey = endpointName
	rope_mid.SetOrigin( ( start + end ) * 0.5 )
	//rope_mid.SetOrigin( start )

	entity rope_end = CreateEntity( "keyframe_rope" )
	SetTargetName( rope_end, endpointName )
	rope_end.SetOrigin( end )

	// Dispatch spawn entities
	DispatchSpawn( rope_start )
	DispatchSpawn( rope_mid )
	DispatchSpawn( rope_end )

	ZipLine zipLine
	zipLine.start = rope_start
	zipLine.mid = rope_mid
	zipLine.end = rope_end

	return zipLine
}

entity function GetPlayerFromEntity( entity ent )
{
	entity player = null

	if ( ent.IsPlayer() )
	{
		player = ent
	}
	else if ( ent.IsNPC() )
	{
		player = ent.GetBossPlayer()
	}
	else
	{
		player = ent.GetOwner()
		if ( !player || !player.IsPlayer() )
			return null
	}

	if ( IsValid_ThisFrame( player ) )
		return player

	return null
}

void function SetHumanRagdollImpactTable( entity ent )
{
	ent.SetRagdollImpactFX( HUMAN_RAGDOLL_IMPACT_TABLE_IDX )
}

bool function ScriptManagedEntArrayContains( int handle, entity ent )
{
	array< entity > ents = GetScriptManagedEntArray( handle )
	foreach ( ent in ents )
	{
		if ( ent == ent )
			return true
	}

	return false
}

void function HideCrit( entity ent )
{
	int bodyGroupIndex = ent.FindBodyGroup( "hitpoints" )

	if ( bodyGroupIndex == -1 )
	{
		return
	}

	ent.SetBodygroup( bodyGroupIndex, 1 )
}

void function ShowCrit( entity ent )
{
	int bodyGroupIndex = ent.FindBodyGroup( "hitpoints" )

	if ( bodyGroupIndex == -1 )
	{
		return
	}

	ent.SetBodygroup( bodyGroupIndex, 0 )
}


#if DEV
void function TeleportEnemyBotToView()
{
	entity player = gp()[0]

	TraceResults traceResults = PlayerViewTrace( player )

	if ( traceResults.fraction >= 1.0 )
		return

	array<entity> players = GetPlayerArrayOfEnemies_Alive( player.GetTeam() )
	foreach ( enemy in players )
	{
		if ( !enemy.IsBot() )
			continue

		enemy.SetOrigin( traceResults.endPos )
		return
	}
}

void function TeleportEntityToView( entity ent )
{
	entity player = gp()[0]

	TraceResults traceResults = PlayerViewTrace( player )

	if ( traceResults.fraction >= 1.0 )
		return

	ent.SetOrigin( traceResults.endPos )
	//traceResults.surfaceNormal
}

void function TeleportFriendlyBotToView()
{
	entity player = gp()[0]

	TraceResults traceResults = PlayerViewTrace( player )

	if ( traceResults.fraction >= 1.0 )
		return

	array<entity> players = GetPlayerArrayOfTeam_Alive( player.GetTeam() )
	foreach ( enemy in players )
	{
		if ( !enemy.IsBot() )
			continue

		enemy.SetOrigin( traceResults.endPos )
		return
	}
}

void function TeleportBotToAbove()
{
	entity player = gp()[0]

	array<entity> players = GetPlayerArray_AlivePilots()
	foreach ( enemy in players )
	{
		if ( !enemy.IsBot() )
			continue

		enemy.SetOrigin( player.GetOrigin() + < 0, 0, 512 > )
		return
	}
}

TraceResults function PlayerViewTrace( entity player, float distance = 10000 )
{
	vector eyePosition = player.EyePosition()
	vector viewVector = player.GetViewVector()

	TraceResults traceResults = TraceLine( eyePosition, eyePosition + viewVector * distance, player, TRACE_MASK_SHOT_BRUSHONLY, TRACE_COLLISION_GROUP_NONE )

	return traceResults
}
#endif

void function ClearPlayerAnimViewEntity( entity player, float time = 0.3 )
{
	entity viewEnt = player.GetFirstPersonProxy()
	viewEnt.HideFirstPersonProxy()
	viewEnt.Anim_Stop()

	player.AnimViewEntity_SetLerpOutTime( time )
	player.AnimViewEntity_Clear()
	player.p.currViewConeFunction = null
}


void function BrushMoves( entity brush )
{
	float moveTime = float( brush.kv.move_time )
	int movedir = int( brush.kv.movedirection )

	BrushMovesInDirection( brush, movedir, moveTime )
}


void function BrushMovesInDirection( entity ent, int dir, float moveTime = 0, float blendIn = 0, float blendOut = 0, float lip = 8 )
{
	entity mover = CreateOwnedScriptMover( ent )
	OnThreadEnd(
		function() : ( ent, mover )
		{
			if ( IsValid( ent ) )
				ent.ClearParent()
			if ( IsValid( mover ) )
				mover.Destroy()
		}
	)

	dir %= 360
	if ( dir > 180 )
		dir -= 360
	else if ( dir < -180 )
		dir += 360

	string moveAxis = GetMoveAxisFromDir( dir )

	ent.SetParent( mover )
	vector origin = ent.GetOrigin()
	float moveAmount
	if ( ent.HasKey( "move_amount" ) )
	{
		moveAmount = float( ent.kv.move_amount ) - lip
		switch ( moveAxis )
		{
			case "x":
			case "y":
				if ( dir < 0 )
					moveAmount *= -1
				break

			case "z":
				if ( dir == -1 )
					moveAmount *= -1
				break
		}
	}
	else
	{
		switch ( moveAxis )
		{
			case "x":
				moveAmount = GetEntWidth( ent ) - lip
				if ( dir < 0 )
					moveAmount *= -1
				break

			case "y":
				moveAmount = GetEntDepth( ent ) - lip
				if ( dir < 0 )
					moveAmount *= -1
				break

			case "z":
				moveAmount = GetEntHeight( ent ) - lip
				if ( dir == -1 )
					moveAmount *= -1
				break
		}
	}

	switch ( moveAxis )
	{
		case "x":
			origin.x += moveAmount
			break
		case "y":
			origin.y += moveAmount
			break
		case "z":
			origin.z += moveAmount
			break
	}

	if ( moveTime > 0 )
	{
		mover.NonPhysicsMoveTo( origin, moveTime, blendIn, blendOut )
		wait moveTime
	}
	else
	{
		mover.SetOrigin( origin )
	}
}

string function GetMoveAxisFromDir( int dir )
{
	if ( dir == 1 || dir == -1 )
		return "z"

	if ( dir % 180 == 0 )
		return "x"

	return "y"
}


float function GetEntHeight( entity ent )
{
	return ent.GetBoundingMaxs().z - ent.GetBoundingMins().z
}

float function GetEntWidth( entity ent )
{
	return ent.GetBoundingMaxs().x - ent.GetBoundingMins().x
}

float function GetEntDepth( entity ent )
{
	return ent.GetBoundingMaxs().y - ent.GetBoundingMins().y
}

void function PushEntWithVelocity( entity ent, vector velocity )
{
	if ( !ent.IsPlayer() && !ent.IsNPC() )
		return

	if ( !IsAlive( ent ) )
		return

	float scale = 1.0
	float pushbackScale = 1.0
	if ( ent.IsTitan() )
	{
		entity soul = ent.GetTitanSoul()
		if ( soul != null ) // defensive fix
		{
			string settings = GetSoulPlayerSettings( soul )
			var scale = Dev_GetPlayerSettingByKeyField_Global( settings, "pushbackScale" )
			if ( scale != null )
			{
				pushbackScale = expect float( scale )
			}
		}
	}

	scale = 1.0 - StatusEffect_Get( ent, eStatusEffect.pushback_dampen )
	scale = scale * pushbackScale

	velocity *= scale

	ent.SetVelocity( velocity )
}



bool function IsPlayerMalePilot( entity player )
{
	Assert( player.IsPlayer() )

	if ( !IsPilot( player ) )
		return false

	return !IsPlayerFemale( player )
}

bool function IsPlayerFemalePilot( entity player )
{
	Assert( player.IsPlayer() )

	if ( !IsPilot( player ) )
		return false

	return IsPlayerFemale( player )
}

bool function IsFacingEnemy( entity guy, entity enemy, int viewAngle = 75 )
{
	vector dir = enemy.GetOrigin() - guy.GetOrigin()
	dir = Normalize( dir )
	float dot = DotProduct( guy.GetPlayerOrNPCViewVector(), dir )
	float yaw = DotToAngle( dot )

	return ( yaw < viewAngle )
}

void function SetSquad( entity guy, string squadName )
{
	Assert( IsValid( guy ) )

	if ( guy.kv.squadname == squadName )
		return

	// we only want squads containing NPCs of the same class
	#if HAS_AI_SQUAD_LIMITS
	Assert( SquadValidForClass( squadName, guy.GetClassName() ), "Can't put AI " + guy + " in squad " + squadName + ", because it contains one or more AI with a different class." )
	Assert( SquadCanAcceptNewMembers( guy, squadName ), "Can't add AI " + guy + " to squad " + squadName + ", because that squad already has " + SQUAD_SIZE + " slots filled or reserved." )
	#endif

	guy.SetSquad( squadName )
}

void function PushPlayersApart( entity target, entity attacker, float speed )
{
	vector dif = Normalize( target.GetOrigin() - attacker.GetOrigin() )
	dif *= speed
	PushPlayerAway( target, dif )
	PushPlayerAway( attacker, -dif )
}

void function PushPlayerAway( entity target, vector velocity )
{
	#if MP
	if ( !target.IsPlayer() && !target.IsNPC() )
		return
	#endif

	vector result = velocity // + target.GetVelocity()
	result.z = max( 200, fabs( velocity.z ) )
	target.SetVelocity( result )
	//DebugDrawLine( target.GetOrigin(), target.GetOrigin() + result * 5, 255, 0, 0, true, 5.0 )
}


int function SortBySpawnTime( entity ent1, entity ent2 )
{
	if ( ent1.e.spawnTime > ent2.e.spawnTime )
		return 1

	if ( ent2.e.spawnTime > ent1.e.spawnTime )
		return -1

	return 0
}

void function HolsterAndDisableWeapons( entity player )
{
	player.HolsterWeapon()
	DisableOffhandWeapons( player )
}

void function HolsterViewModelAndDisableWeapons( entity player ) //Note that this skips the first person holster animation, and it appears to 3p observers you still have a gun out
{
	player.DisableWeaponViewModel()
	DisableOffhandWeapons( player )
}


void function DeployAndEnableWeapons( entity player )
{
	player.DeployWeapon()
	EnableOffhandWeapons( player )
}

void function DeployViewModelAndEnableWeapons( entity player )
{
	if ( IsAlive( player ) )
		player.EnableWeaponViewModel()
	EnableOffhandWeapons( player )
}

//Investigate: This might be getting called without enableoffhandweapons being called. If so,  Server_TurnOffhandWeaponsDisabledOn() should be used instead of this stack system.
void function DisableOffhandWeapons( entity player )
{
	player.Server_TurnOffhandWeaponsDisabledOn()
	player.p.disableOffhandWeaponsStackCount++
}

void function EnableOffhandWeapons( entity player )
{
	player.p.disableOffhandWeaponsStackCount--
	if ( player.p.disableOffhandWeaponsStackCount <= 0 )
		player.Server_TurnOffhandWeaponsDisabledOff()

	Assert( player.p.disableOffhandWeaponsStackCount >= 0, "Warning! Called EnableOffhandWeapons() but the weapons aren't disabled!" )
}

void function PushEntWithDamageInfoAndDistanceScale( entity ent, var damageInfo, float nearRange, float farRange, float nearScale, float farScale, float forceMultiplier_dotBase = 0.5 )
{
	float scale = GraphCapped( DamageInfo_GetDistFromAttackOrigin( damageInfo ), nearRange, farRange, nearScale, farScale )

	if ( scale > 0 )
		PushEntWithDamageInfo( ent, damageInfo, forceMultiplier_dotBase, scale )
}

void function PushEntWithDamageInfo( entity ent, var damageInfo, float forceMultiplier_dotBase = 0.5, float forceMultiplier_dotScale = 0.5 )
{
	int source = DamageInfo_GetDamageSourceIdentifier( damageInfo )
	switch ( source )
	{
 		case eDamageSourceId.mp_titanweapon_vortex_shield:
  		case eDamageSourceId.mp_titanweapon_vortex_shield_ion:
			return
	}

	entity projectile = DamageInfo_GetInflictor( damageInfo )
	if ( !IsValid( projectile ) )
		return

	vector attackDirection = Normalize( projectile.GetVelocity() )
	float damage = DamageInfo_GetDamage( damageInfo )

	PushEntWithDamageFromDirection( ent, damage, attackDirection, forceMultiplier_dotBase, forceMultiplier_dotScale )
}

void function PushEntWithDamageFromDirection( entity ent, float damage, vector attackDirection, float forceMultiplier_dotBase = 0.5, float forceMultiplier_dotScale = 0.5 )
{

	float speed
	if ( damage < 900 )
		speed = GraphCapped( damage, 0, 900, 0, 650 )
	else
		speed = GraphCapped( damage, 900, 1400, 650, 1400 )

	vector direction = attackDirection + <0,0,0>
	direction.z *= 0.25
	vector force = direction * speed

	force += < 0, 0, fabs( direction.z ) * 0.25 >

	vector velocity = ent.GetVelocity()
	vector baseVel = Normalize( velocity + <0,0,0> )

	float dot = DotProduct( baseVel, attackDirection ) * -1
	float dotMultiplier
	if ( dot > 0 )
	{
		dot *= forceMultiplier_dotScale
	}
	else
	{
		dot = 0
	}

	force *= ( forceMultiplier_dotBase + dot )
	//printt( "force " + Length( force ) )
	velocity += force
	PushEntWithVelocity( ent, velocity )
}


void function SetPlayerAnimViewEntity( entity player, entity model )
{
	// clear any attempts to hide the view anim entity
	player.Signal( "NewViewAnimEntity" )
	player.AnimViewEntity_SetEntity( model )
}


void function RandomizeHead( entity model ) //Randomize head across all available heads
{
	int headIndex = model.FindBodyGroup( "head" )
	if ( headIndex == -1 )
	{
		//printt( "HeadIndex == -1, returning" )
		return
	}
	int numOfHeads = model.GetBodyGroupModelCount( headIndex ) - 1 // last one is no head
	//printt( "Num of Heads: " + numOfHeads )

	if ( HasTeamSkin( model ) )
	{
		RandomizeHeadByTeam( model, headIndex, numOfHeads )
		return
	}
	else
	{
		int randomHeadIndex = RandomInt( numOfHeads )
		//printt( "Set head to: : " + randomHeadIndex )
		model.SetBodygroup( headIndex, randomHeadIndex )
	}
}

bool function HasTeamSkin( entity model )
{
	return  "teamSkin" in model.CreateTableFromModelKeyValues()
}

void function RandomizeHeadByTeam( entity model, int headIndex, int numOfHeads ) //Randomize head across heads available to a particular team. Assumes for a model all imc heads are first, then all militia heads are later.
{
	float midPoint = float( numOfHeads / 2 )

	int randomHeadIndex = 0
	if ( model.GetTeam() == TEAM_IMC )
	{
		randomHeadIndex = RandomInt( midPoint )
	}
	else if ( model.GetTeam() == TEAM_MILITIA )
	{
		randomHeadIndex = RandomIntRange( midPoint, numOfHeads )
	}
	//printt( "Model ", model.GetModelName(), " is using ", numOfHeads, " randomHeadIndex")

	//printt( "Set head to: : " + randomHeadIndex )
	model.SetBodygroup( headIndex, randomHeadIndex )
}

void function TakeWeaponsForArray( entity ent, array<entity> weapons )
{
	foreach ( weapon in weapons )
	{
		ent.TakeWeaponNow( weapon.GetWeaponClassName() )
	}
}

void function ScaleHealth( entity ent, float scale )
{
	Assert( IsAlive( ent ) )

	int maxHealth = ent.GetMaxHealth()
	float healthRatio = float( ent.GetHealth() ) / maxHealth
	maxHealth = int( maxHealth * scale )
	ent.SetHealth( maxHealth * healthRatio )
	ent.SetMaxHealth( maxHealth )
}

void function TeleportPlayerToEnt( entity player, entity org )
{
	if ( !IsValid( player ) )
		return
	Assert( player.IsPlayer() )
	player.SetOrigin( org.GetOrigin() )
	player.SetAngles( org.GetAngles() )
}

float function ShieldModifyDamage( entity ent, var damageInfo )
{
	entity victim
	if ( ent.IsTitan() )
		victim = ent.GetTitanSoul()
	else
		victim = ent

	int shieldHealth = victim.GetShieldHealth()

	float damage = DamageInfo_GetDamage( damageInfo )

	int damageSourceIdentifier = DamageInfo_GetDamageSourceIdentifier( damageInfo )
	ShieldDamageModifier damageModifier = GetShieldDamageModifier( damageInfo )
	damage *= damageModifier.damageScale

	float healthFrac = GetHealthFrac( victim )

	float permanentDamage = (damage * damageModifier.permanentDamageFrac * healthFrac)

	float shieldDamage

	if ( damageSourceIdentifier == eDamageSourceId.titanEmpField )
	{
		shieldDamage = min( 1000.0, float( shieldHealth ) )
	}
	else
	{
		if ( damageModifier.normalizeShieldDamage )
			shieldDamage = damage * 0.5
		else
			shieldDamage = damage - permanentDamage

		// if ( IsSoul( victim ) && SoulHasPassive( victim, ePassives.PAS_SHIELD_BOOST ) )
		// 	shieldDamage *= SHIELD_BOOST_DAMAGE_DAMPEN

		if ( IsSoul( victim ) && SoulHasPassive( victim, ePassives.PAS_BERSERKER ) )
			shieldDamage *= BERSERKER_INCOMING_DAMAGE_DAMPEN
	}

	float newShieldHealth = shieldHealth - shieldDamage

	victim.SetShieldHealth( max( 0, newShieldHealth ) )

	if ( shieldHealth > 0 && newShieldHealth <= 0 )
	{
		if ( ent.IsPlayer() )
		{
			EmitSoundOnEntityExceptToPlayer( ent, ent, "titan_energyshield_down_3P" )
			EmitSoundOnEntityOnlyToPlayer( ent, ent, "titan_energyshield_down_1P" )
		}
		else if ( ent.GetScriptName() == "fw_team_tower" )
		{
			EmitSoundOnEntity( ent, "TitanWar_Harvester_ShieldDown" )

			#if FACTION_DIALOGUE_ENABLED
				PlayFactionDialogueToTeam( "fortwar_baseShieldDownFriendly", ent.GetTeam() )
				PlayFactionDialogueToTeam( "fortwar_baseShieldDownEnemy", GetOtherTeam( ent.GetTeam() ) )
			#endif
		}
		else
		{
			EmitSoundOnEntity( ent, "titan_energyshield_down_3P" )
		}
	}

	DamageInfo_AddCustomDamageType( damageInfo, DF_SHIELD_DAMAGE )

	if ( newShieldHealth < 0 )
	{
		DamageInfo_SetDamage( damageInfo, fabs( newShieldHealth ) + permanentDamage )
	}
	else
	{
		if ( permanentDamage == 0 )
		{
			entity attacker = DamageInfo_GetAttacker( damageInfo )
			vector damageOrigin = GetDamageOrigin( damageInfo, ent )
			int damageType = DamageInfo_GetCustomDamageType( damageInfo )
			int attackerEHandle = attacker.GetEncodedEHandle()
			int damageSourceId = DamageInfo_GetDamageSourceIdentifier( damageInfo )

			if ( attacker.IsPlayer() )
				attacker.NotifyDidDamage( ent, DamageInfo_GetHitBox( damageInfo ), DamageInfo_GetDamagePosition( damageInfo ), damageType, shieldDamage, DamageInfo_GetDamageFlags( damageInfo ), DamageInfo_GetHitGroup( damageInfo ), DamageInfo_GetWeapon( damageInfo ), DamageInfo_GetDistFromAttackOrigin( damageInfo ) )
			if ( ent.IsPlayer() )
				Remote_CallFunction_Replay( ent, "ServerCallback_TitanTookDamage", shieldDamage, damageOrigin.x, damageOrigin.y, damageOrigin.z, damageType, damageSourceId, attackerEHandle, null, false, 0 )
		}
		DamageInfo_SetDamage( damageInfo, permanentDamage )
	}

	float actualShieldDamage = min( shieldHealth, shieldDamage )

	if ( actualShieldDamage > 0 )
	{
		foreach ( func in ent.e.entPostShieldDamageCallbacks )
		{
			func( ent, damageInfo, actualShieldDamage )
		}
	}

	return actualShieldDamage
}

ShieldDamageModifier function GetShieldDamageModifier( var damageInfo )
{
	ShieldDamageModifier damageModifier

	// Disabling Shield Damage Modifiers and rebalancing the weapons. The below mechanics seem cool in an R1 style system though so leaving them commented out.
	// NOTE: Changing Damage Scale has a buggy interaction with permanent damage that must be fixed if we re-enable this.
	/*
	int damageSourceIdentifier = DamageInfo_GetDamageSourceIdentifier( damageInfo )

	switch ( damageSourceIdentifier )
	{
		case eDamageSourceId.mp_weapon_thermite_grenade:
			damageModifier.permanentDamageFrac = 0.9
			break
	}

	if ( DamageInfo_GetCustomDamageType( damageInfo ) & DF_ELECTRICAL )
	{
		// amped version
		if ( damageSourceIdentifier == eDamageSourceId.mp_titanweapon_xo16 )
			damageModifier.damageScale *= 1.5

		// amped version
		if ( damageSourceIdentifier == eDamageSourceId.mp_titanweapon_triple_threat )
			damageModifier.damageScale *= 1.5

		if ( damageSourceIdentifier == eDamageSourceId.mp_titanweapon_arc_cannon )
			damageModifier.damageScale *= 1.5
	}
	*/

	if ( DamageInfo_GetCustomDamageType( damageInfo ) & DF_ELECTRICAL )
	{
		int damageSourceIdentifier = DamageInfo_GetDamageSourceIdentifier( damageInfo )
		// Vanguard Arc Rounds
		if ( damageSourceIdentifier == eDamageSourceId.mp_titanweapon_xo16_vanguard )
			damageModifier.damageScale *= 1.5
	}


	return damageModifier
}



void function AddCallback_NPCLeeched( void functionref( entity, entity ) callbackFunc )
{
	Assert( !( svGlobal.onLeechedCustomCallbackFunc.contains( callbackFunc ) ) )
	svGlobal.onLeechedCustomCallbackFunc.append( callbackFunc )
}

void function MessageToPlayer( entity player, int eventID, entity ent = null, var eventVal = null )
{
	var eHandle = null
	if ( ent )
		eHandle = ent.GetEncodedEHandle()

	Remote_CallFunction_NonReplay( player, "ServerCallback_EventNotification", eventID, eHandle, eventVal )
	//SendHudMessage( player, message, 0.33, 0.28, 255, 255, 255, 255, 0.15, 3.0, 0.5 )
}


void function MessageToTeam( int team, int eventID, entity excludePlayer = null, entity ent = null, var eventVal = null )
{
	array<entity> players = GetPlayerArray()

	foreach ( player in players )
	{
		if ( player.GetTeam() != team )
			continue

		if ( player == excludePlayer )
			continue

		MessageToPlayer( player, eventID, ent, eventVal )
	}
}

void function MessageToAll( int eventID, entity excludePlayer = null, entity ent = null, var eventVal = null )
{
	array<entity> players = GetPlayerArray()

	foreach ( player in players )
	{
		if ( player == excludePlayer )
			continue

		MessageToPlayer( player, eventID, ent, eventVal )
	}
}



string function ReloadScriptsInternal()
{
	reloadingScripts = true
	reloadedScripts = true
	ReloadingScriptsBegin()

	if ( IsMenuLevel() )
	{
		reloadingScripts = false
		ReloadingScriptsEnd()
		return ""
	}

	TitanEmbark_Init()

	ReloadScriptCallbacks()

	reloadingScripts = false
	ReloadingScriptsEnd()

	return ( "reloaded server scripts" )
}

string function ReloadScripts()
{
	ServerCommand( "fs_report_sync_opens 0" ) // makes reload scripts slow
	delaythread ( 0 ) ReloadScriptsInternal()

	return ( "reloaded server scripts" )
}

void function SetGameEndTime(float seconds)
{
	SetServerVar( "gameEndTime", Time() + seconds )
}

void function SetRoundEndTime(float seconds)
{
	SetServerVar( "roundEndTime", Time() + seconds )
}

void function SetScoreLimit(int newLimit)
{
	SetPlaylistVarOverride( "scorelimit", string(newLimit) )
}

int function GameTime_TimeLimitSeconds()
{
	if ( IsRoundBased() )
	{
		return ( GetRoundTimeLimit_ForGameMode() * 60.0 ).tointeger()
	}
	else
	{
		if ( IsSuddenDeathGameMode() && GetGameState() == eGameState.SuddenDeath )
			return ( GetTimeLimit_ForGameMode() * 60.0 ).tointeger() + ( GetSuddenDeathTimeLimit_ForGameMode() * 60.0 ).tointeger()
		else
			return ( GetTimeLimit_ForGameMode() * 60.0 ).tointeger()
	}
	unreachable
}

int function GetSuddenDeathTimeLimit_ForGameMode()
{
	string mode = GameRules_GetGameMode()
	string playlistString = "suddendeath_timelimit"

	return GetCurrentPlaylistVarInt( playlistString, 4 )
}

int function GameTime_TimeLimitMinutes()
{
	if ( IsRoundBased() )
		return floor( GetRoundTimeLimit_ForGameMode() ).tointeger()
	else
		return floor( GetTimeLimit_ForGameMode() ).tointeger()
	unreachable
}

int function GameTime_TimeLeftMinutes()
{
	if ( GetGameState() == eGameState.WaitingForPlayers )
		return 0
	if ( GetGameState() == eGameState.Prematch )
		return int( ( expect float( GetServerVar( "gameStartTime" ) ) - Time()) / 60.0 )

	return floor( GameTime_PlayingTime() / 60 ).tointeger()
}

int function GameTime_TimeLeftSeconds()
{
	if ( GetGameState() == eGameState.Prematch )
		return int( expect float( GetServerVar( "gameStartTime" ) ) - Time() )

	return GameTime_PlayingTime().tointeger()
}

// WARN: this function includes WaitingForPlayers and Prematch duration!
int function GameTime_Seconds()
{
	return floor( Time() ).tointeger()
}

// WARN: this function includes WaitingForPlayers Prematch duration!
int function GameTime_Minutes()
{
	return int( floor( GameTime_Seconds() / 60 ) )
}

// this function only counts the time limit during eGameState.Playing
float function GameTime_PlayingTime()
{
	int gameState = GetGameState()
	if ( gameState < eGameState.Playing )
		return 0

	if ( IsRoundBased() )
	{
		if ( gameState > eGameState.SuddenDeath )
			return (expect float( GetServerVar( "roundEndTime" ) ) - expect float( GetServerVar( "roundStartTime" ) ) )
		else
			return floor( expect float( GetServerVar( "roundEndTime" ) ) - Time() )
	}
	else
	{
		if ( gameState > eGameState.SuddenDeath )
			return (expect float( GetServerVar( "gameEndTime" ) ) - expect float( GetServerVar( "gameStartTime" ) ) )
		else
			return floor( expect float( GetServerVar( "gameEndTime" ) ) - Time() )
	}
	unreachable
}

float function GameTime_TimeSpentInCurrentState()
{
	return Time() - expect float( GetServerVar( "gameStateChangeTime" ) )
}

int function GameScore_GetFirstToScoreLimit()
{
	return expect int( level.firstToScoreLimit )
}

bool function GameScore_AllowPointsOverLimit()
{
	return svGlobal.allowPointsOverLimit
}

int function GameScore_GetWinningTeam()
{
	if ( GameScore_GetFirstToScoreLimit() )
		return GameScore_GetFirstToScoreLimit()

	if ( IsRoundBased() )
	{
		if ( GameRules_GetTeamScore2( TEAM_IMC ) > GameRules_GetTeamScore2( TEAM_MILITIA ) )
			return TEAM_IMC
		else if ( GameRules_GetTeamScore2( TEAM_MILITIA ) > GameRules_GetTeamScore2( TEAM_IMC ) )
			return TEAM_MILITIA
	}
	else
	{
		if ( GameRules_GetTeamScore( TEAM_IMC ) > GameRules_GetTeamScore( TEAM_MILITIA ) )
			return TEAM_IMC
		else if ( GameRules_GetTeamScore( TEAM_MILITIA ) > GameRules_GetTeamScore( TEAM_IMC ) )
			return TEAM_MILITIA
	}

	return TEAM_UNASSIGNED
}

int function GameScore_GetWinningTeam_ThisRound()
{
	if ( GameScore_GetFirstToScoreLimit() )
		return GameScore_GetFirstToScoreLimit()

	Assert ( IsRoundBased() )

	if ( GameRules_GetTeamScore( TEAM_IMC ) > GameRules_GetTeamScore( TEAM_MILITIA ) )
		return TEAM_IMC
	else if ( GameRules_GetTeamScore( TEAM_MILITIA ) > GameRules_GetTeamScore( TEAM_IMC ) )
		return TEAM_MILITIA

	return TEAM_UNASSIGNED
}

#if DEV
void function KillIMC()
{
	array<entity> enemies = GetNPCArrayOfTeam( TEAM_IMC )
	foreach ( enemy in enemies )
	{
		enemy.Die()
	}
}

void function killtitans()
{
	printt( "Script command: Kill all titans" )
	array<entity> titans = GetTitanArray()
	foreach ( titan in titans )
		titan.Die()
}

void function killminions()
{
	printt( "Script command: Kill all minions" )
	array<entity> minions = GetAllMinions()
	foreach ( minion in minions )
	{
		minion.Die()
	}
}
#endif


array<entity> function GetTeamMinions( int team )
{
	array<entity> ai = GetNPCArrayByClass( "npc_soldier" )
	ai.extend( GetNPCArrayByClass( "npc_spectre" ) )

	for ( int i = 0; i < ai.len(); i++ )
	{
		if ( ai[i].GetTeam() != team )
		{
			ai.remove(i)
			i--
		}
	}

	return ai
}

array<entity> function GetAllMinions()
{
	array<entity> ai = GetNPCArrayByClass( "npc_soldier" )
	ai.extend( GetNPCArrayByClass( "npc_spectre" ) )
	ai.extend( GetNPCArrayByClass( "npc_drone" ) )

	return ai
}


bool function GameScore_IsLowScoreDifference()
{
	int winningTeam = GameScore_GetWinningTeam()

	if ( !winningTeam )
		return true

	int losingTeam = GetOtherTeam( winningTeam )

	int winningTeamScore
	int losingTeamScore

	if ( IsRoundBased() )
	{
		winningTeamScore = GameRules_GetTeamScore2( winningTeam )
		losingTeamScore =  GameRules_GetTeamScore2( losingTeam )
	}
	else
	{
		winningTeamScore =  GameRules_GetTeamScore( winningTeam )
		losingTeamScore =   GameRules_GetTeamScore( losingTeam )
	}

	return ( winningTeamScore - losingTeamScore < 2 )
}

bool function IsFastPilot( entity player )
{
	Assert( IsPilot( player ), "Pilot only check" )

	if ( player.IsWallHanging() )
		return false

	if ( player.IsWallRunning() )
		return true

	if ( !player.IsOnGround() )
		return true

	if ( LengthSqr( player.GetSmoothedVelocity() ) > 180*180 || LengthSqr( player.GetVelocity() ) > 180*180 )
		return true

	return false
}

void function KillPlayer( entity player, int damageSource )
{
	#if DEV
	printt( "Played Killed from script: " )
	DumpStack()
	#endif

	Assert( IsAlive( player ) )
	Assert( player.IsPlayer() )
	player.Die( svGlobal.worldspawn, svGlobal.worldspawn, { damageSourceId = damageSource, scriptType=DF_SKIP_DAMAGE_PROT | DF_SKIPS_DOOMED_STATE } )
}


//////////////////////////////////////////////////////////
void function TurretChangeTeam( entity turret, int team )
{
	if ( team != TEAM_UNASSIGNED )
	{
		// If a turret is on some player's team it should never be invulnerable
		MakeTurretVulnerable( turret )
	}

	SetTeam( turret, team )

	// refresh the turret client side particle effects
	UpdateTurretClientSideParticleEffects( turret )
}

void function MakeTurretInvulnerable( entity turret )
{
	Assert( IsValid( turret ) )
	turret.SetInvulnerable()
	turret.SetNoTarget(true)
	turret.SetNoTargetSmartAmmo(true)
}

void function MakeTurretVulnerable( entity turret )
{
	Assert( IsValid( turret ) )
	turret.ClearInvulnerable()
	turret.SetNoTarget(false)
	turret.SetNoTargetSmartAmmo(false)
}


void function UpdateTurretClientSideParticleEffects( entity turret )
{
	if ( !IsValid( turret ) )
		return

	int turretEHandle = turret.GetEncodedEHandle()
	array<entity> players = GetPlayerArray()
	foreach( player in players )
	{
		Remote_CallFunction_Replay( player, "ServerCallback_TurretRefresh", turretEHandle )
	}
}



bool function TakePrimaryWeapon( entity player )
{
	array<entity> weapons = player.GetMainWeapons()
	foreach ( index, weaponEnt in weapons )
	{
		int weaponType = weaponEnt.GetWeaponType()
		if ( weaponType == WT_SIDEARM || weaponType == WT_ANTITITAN )
			continue;

		string weapon = weaponEnt.GetWeaponClassName()
		player.TakeWeaponNow( weapon )
		return true
	}
	return false
}

bool function TakeSecondaryWeapon( entity player )
{
	array<entity> weapons = player.GetMainWeapons()
	foreach ( index, weaponEnt in weapons )
	{
		if ( weaponEnt.GetWeaponType() != WT_ANTITITAN )
			continue

		string weapon = weaponEnt.GetWeaponClassName()
		player.TakeWeaponNow( weapon )
		return true
	}
	return false
}

bool function TakeSidearmWeapon( entity player )
{
	array<entity> weapons = player.GetMainWeapons()
	foreach ( index, weaponEnt in weapons )
	{
		if ( weaponEnt.GetWeaponType() != WT_SIDEARM )
			continue

		string weapon = weaponEnt.GetWeaponClassName()
		player.TakeWeaponNow( weapon )
		return true
	}
	return false
}

void function TakeAllWeapons( entity ent )
{
	if ( ent.IsPlayer() )
	{
		ent.RemoveAllItems()
		array<entity> weapons = ent.GetMainWeapons()
		foreach ( weapon in weapons )
		{
			Assert( 0, ent + " still has weapon " + weapon.GetWeaponClassName() + " after doing takeallweapons" )
		}
	}
	else
	{
		array<entity> weapons = ent.GetMainWeapons()
		TakeWeaponsForArray( ent, weapons )

		weapons = ent.GetOffhandWeapons()
		foreach ( index, weapon in clone weapons )
		{
			ent.TakeOffhandWeapon( index )
		}
		TakeWeaponsForArray( ent, weapons )
	}
}


void function SetSpawnflags( entity ent, int spawnFlags )
{
	ent.kv.spawnflags = spawnFlags
}


void function DestroyAfterDelay( entity ent, float delay )
{
	Assert( IsNewThread(), "Must be threaded off" )

	ent.EndSignal( "OnDestroy" )

	wait( delay )

	ent.Destroy()
}

void function UnlockAchievement( entity player, int achievementID )
{
	Assert( IsValid( player ), "Can't unlock achievement on invalid player entity" )
	Assert( player.IsPlayer(), "Can't unlock achivement on non-player entity" )
	Assert( achievementID > 0 && achievementID < achievements.MAX_ACHIVEMENTS, "Tried to unlock achievement with invalid enum value" )

	Remote_CallFunction_UI( player, "ScriptCallback_UnlockAchievement", achievementID )
}

void function UpdateHeroStatsForPlayer( entity player )
{
	if ( !IsValid( player ) )
		return
	Remote_CallFunction_NonReplay( player, "ServerCallback_UpdateHeroStats" )
}

void function TestDeathFall()
{
	entity trigger = GetEntByScriptName( "DeathFallTrigger" )
	table results = WaitSignal( trigger, "OnTrigger" )
	printt( "DEATH FALL TRIGGERED" )
	PrintTable( results )
}

bool function PlayerHasTitan( entity player )
{
	entity titan
	if ( player.IsTitan() )
		titan = player
	else
		titan = player.GetPetTitan()

	if ( IsAlive( titan ) )
		return true

	return false
}