initial commit after moving to new repo

1 files changed, 1395 insertions, 0 deletions

diff --git a/Northstar.CustomServers/scripts/vscripts/_anim.gnut b/Northstar.CustomServers/scripts/vscripts/_anim.gnut
new file mode 100644
index 00000000..2ead1d30
--- /dev/null
+++ b/Northstar.CustomServers/scripts/vscripts/_anim.gnut
@@ -0,0 +1,1395 @@
+untyped
+
+global function Anim_Init
+
+global function FirstPersonSequence
+global function GetAnim
+global function HasAnim
+global function SetAnim
+global function PlayAnimTeleport
+global function GetAnimStartInfo
+
+global function PlayFPSAnim
+global function PlayFPSAnimShowProxy
+global function PlayFPSAnimTeleport
+global function PlayFPSAnimTeleportShowProxy
+
+global function PlayAnim
+global function PlayAnimGravity
+global function PlayAnimGravityClientSyncing
+global function PlayAnimRunGravity
+global function PlayAnimRun
+
+global function RunToAnimStart_Deprecated
+global function RunToAnimStartForced_Deprecated
+
+global function RunToAnimStartPos
+global function RunToAndPlayAnim
+global function RunToAndPlayAnimAndWait
+global function RunToAndPlayAnimGravity
+global function RunToAndPlayAnimGravityForced
+
+function Anim_Init()
+{
+	RegisterSignal( "NewViewAnim" )
+	RegisterSignal( "NewFirstPersonSequence" )
+	RegisterSignal( "ScriptAnimStop" )
+	RegisterSignal( "AnimEventKill" )
+
+	AddGlobalAnimEvent( "enable_weapon", GlobalAnimEvent_EnableWeapon )
+	AddGlobalAnimEvent( "disable_weapon", GlobalAnimEvent_DisableWeapon	)
+	AddGlobalAnimEvent( "clear_parent", GlobalAnimEvent_ClearParent )
+	AddGlobalAnimEvent( "hide", GlobalAnimEvent_Hide )
+	AddGlobalAnimEvent( "show", GlobalAnimEvent_Show )
+	AddGlobalAnimEvent( "RecordOrigin", GlobalAnimEvent_RecordOrigin )
+	AddGlobalAnimEvent( "ShowFPSProxy", GlobalAnimEvent_ShowFPSProxy )
+	AddGlobalAnimEvent( "clear_anim_view_ent",GlobalAnimEvent_ClearAnimViewEntity )
+	AddGlobalAnimEvent( "scripted_death_to_ragdoll", GlobalAnimEvent_ScriptedDeathToRagdoll )
+	AddGlobalAnimEvent( "SetVelocity", GlobalAnimEvent_SetVelocity )
+	AddGlobalAnimEvent( "stance_kneel", GlobalAnimEvent_StanceKneel )
+	AddGlobalAnimEvent( "stance_kneeling", GlobalAnimEvent_StanceKneeling )
+	AddGlobalAnimEvent( "stance_stand", GlobalAnimEvent_StanceStand )
+	AddGlobalAnimEvent( "stance_standing", GlobalAnimEvent_StanceStanding )
+	AddGlobalAnimEvent( "enable_planting", GlobalAnimEvent_EnablePlanting )
+	AddGlobalAnimEvent( "kill", GlobalAnimEvent_Kill )
+	AddGlobalAnimEvent( "gib", GlobalAnimEvent_Gib )
+	AddGlobalAnimEvent( "titan_gib", GlobalAnimEvent_TitanGib )
+	AddGlobalAnimEvent( "EnableAimAssist", GlobalAnimEvent_EnableAimAssist )
+	AddGlobalAnimEvent( "DisableAimAssist", GlobalAnimEvent_DisableAimAssist )
+	AddGlobalAnimEvent( "give_ammo", GlobalAnimEvent_GiveAmmo )
+
+	#if SP
+	PrecacheWeapon( "mp_titanweapon_salvo_rockets" ) // used by bt_pod_fire_left/bt_pod_fire_right anim events. Only BT has these anim events.
+	AddGlobalAnimEvent( "bt_pod_fire_left", GlobalAnimEvent_BT_Pod_Left )
+	AddGlobalAnimEvent( "bt_pod_fire_right", GlobalAnimEvent_BT_Pod_Right )
+	#endif
+}
+
+void function GlobalAnimEvent_BT_Pod_Left( entity guy )
+{
+	BT_Pod( guy, "POD_L" )
+}
+
+void function GlobalAnimEvent_BT_Pod_Right( entity guy )
+{
+	BT_Pod( guy, "POD_R" )
+}
+
+void function BT_Pod( entity guy, string tag )
+{
+	entity oldOffhandWeapon = guy.GetOffhandWeapon( 0 )
+	guy.TakeOffhandWeapon( 0 )
+	guy.GiveOffhandWeapon( "mp_titanweapon_salvo_rockets", 0, [ "scripted_no_damage" ] )
+
+	//printt( tag )
+	entity newOffhandWeapon = guy.GetOffhandWeapon( 0 )
+	int attachID = guy.LookupAttachment( tag )
+	vector angles = guy.GetAttachmentAngles( attachID )
+	WeaponPrimaryAttackParams params
+	params.pos = guy.GetAttachmentOrigin( attachID )
+	params.dir = AnglesToForward( angles )
+	StartParticleEffectOnEntity( guy, GetParticleSystemIndex( $"P_muzzleflash_predator" ), FX_PATTACH_POINT_FOLLOW, attachID )
+
+	thread OnWeaponPrimaryAttack_titanweapon_salvo_rockets( newOffhandWeapon, params )
+
+	guy.TakeOffhandWeapon( 0 )
+
+	if ( oldOffhandWeapon )
+ 		guy.GiveOffhandWeapon( oldOffhandWeapon.GetWeaponClassName(), 0, oldOffhandWeapon.GetMods() )
+}
+
+void function GlobalAnimEvent_EnableWeapon( entity guy )
+{
+	if ( guy.IsPlayer() )
+	{
+		guy.EnableWeapon()
+		guy.EnableWeaponViewModel()
+	}
+	else
+		printt( "Warning: Tried to enable weapon on non player: " + guy )
+}
+
+void function GlobalAnimEvent_DisableWeapon( entity guy )
+{
+	if ( guy.IsPlayer() )
+	{
+		guy.DisableWeapon()
+	}
+	else
+		printt( "Warning: Tried to disable weapon on non player: " + guy )
+}
+
+void function GlobalAnimEvent_ClearParent( entity guy )
+{
+	guy.ClearParent()
+}
+
+void function GlobalAnimEvent_Hide( entity guy )
+{
+	guy.Hide()
+}
+
+void function GlobalAnimEvent_Show( entity guy )
+{
+	guy.Show()
+}
+
+void function GlobalAnimEvent_RecordOrigin( entity actor )
+{
+	if ( !actor.IsPlayer() )
+		return
+	if ( !( "recordedOrigin" in actor.s ) )
+		actor.s.recordedOrigin <- []
+
+	table record = {}
+	record.origin <- actor.GetOrigin()
+	record.time <- Time()
+
+	actor.s.recordedOrigin.append( record )
+}
+
+void function GlobalAnimEvent_ShowFPSProxy( entity player )
+{
+	if ( !player.IsPlayer() )
+		return
+	local viewmodel = player.GetFirstPersonProxy()
+	viewmodel.ShowFirstPersonProxy()
+}
+
+void function GlobalAnimEvent_ClearAnimViewEntity( entity player )
+{
+	if ( !player.IsPlayer() )
+		return
+	ClearPlayerAnimViewEntity( player, 1.0 )
+}
+
+void function GlobalAnimEvent_ScriptedDeathToRagdoll( entity ent )
+{
+	ent.Die()
+	ent.SetContinueAnimatingAfterRagdoll( true )
+	ent.BecomeRagdoll( Vector(0,0,0), false )
+}
+
+void function GlobalAnimEvent_SetVelocity( entity actor )
+{
+	if ( !actor.IsPlayer() )
+		return
+	local record = null
+
+	if ( ( "recordedOrigin" in actor.s ) && actor.s.recordedOrigin.len() )
+		record = actor.s.recordedOrigin[ actor.s.recordedOrigin.len() - 1 ]
+
+	Assert( record, "anim had AE_SV_VSCRIPT_CALLBACK: SetVelocity, but no AE_SV_VSCRIPT_CALLBACK:RecordOrigin" )
+
+	local dir 		= Normalize( actor.GetOrigin() - record.origin )
+	local distance 		= Distance( actor.GetOrigin(), record.origin )
+	local time			= Time() - record.time
+	if ( time <= 0 )
+		time = 0.001 // timescale bug?
+	local speed 		= distance / time
+
+	actor.SetVelocity( dir * speed )
+}
+
+void function GlobalAnimEvent_StanceKneel( entity guy )
+{
+	Assert( guy.IsTitan() )
+	Assert( guy.IsNPC() )
+	SetStanceKneel( guy.GetTitanSoul() )
+}
+
+void function GlobalAnimEvent_StanceKneeling( entity guy )
+{
+	Assert( guy.IsTitan() )
+	Assert( guy.IsNPC() )
+	SetStanceKneeling( guy.GetTitanSoul() )
+}
+
+void function GlobalAnimEvent_StanceStand( entity guy )
+{
+	Assert( guy.IsTitan() )
+	Assert( guy.IsNPC() )
+	SetStanceStand( guy.GetTitanSoul() )
+}
+
+void function GlobalAnimEvent_StanceStanding( entity guy )
+{
+	Assert( guy.IsTitan() )
+	Assert( guy.IsNPC() )
+	SetStanceStanding( guy.GetTitanSoul() )
+}
+
+void function GlobalAnimEvent_EnablePlanting( entity guy )
+{
+	if ( guy.IsNPC() || guy.IsPlayer() )
+		guy.Anim_EnablePlanting()
+	else
+		printt( "Warning: Tried to enable planting on " + guy )
+}
+
+void function GlobalAnimEvent_Kill( entity guy )
+{
+	if ( IsAlive( guy ) )
+	{
+		Signal( guy, "AnimEventKill" )
+		guy.TakeDamage( guy.GetMaxHealth() + 1, null, null, { damageSourceId=damagedef_suicide } )
+		guy.BecomeRagdoll( Vector( 0, 0, 0 ), false )
+	}
+}
+
+void function GlobalAnimEvent_Gib( entity guy )
+{
+	if ( IsAlive( guy ) )
+	{
+		Signal( guy, "AnimEventKill" )
+		guy.Gib( <0,0,100> )
+	}
+}
+
+void function GlobalAnimEvent_TitanGib( entity guy )
+{
+	if ( IsAlive( guy ) )
+	{
+		PlayTitanDeathFxUp( guy )
+
+		local entKVs = guy.CreateTableFromModelKeyValues()
+		local hitData = entKVs["hit_data"]
+
+		foreach ( bodyGroupName, bodyGroupData in hitData )
+		{
+			if ( !("blank" in bodyGroupData) )
+				continue
+
+			local bodyGroupIndex = guy.FindBodyGroup( bodyGroupName )
+			local stateCount = guy.GetBodyGroupModelCount( bodyGroupIndex )
+			guy.SetBodygroup( bodyGroupIndex, stateCount - 1 )
+		}
+	}
+}
+
+
+void function GlobalAnimEvent_EnableAimAssist( entity guy )
+{
+	if ( IsAlive( guy ) )
+	{
+		guy.SetAimAssistAllowed( true )
+	}
+}
+
+void function GlobalAnimEvent_DisableAimAssist( entity guy )
+{
+	if ( IsAlive( guy ) )
+	{
+		guy.SetAimAssistAllowed( false )
+	}
+}
+
+void function GlobalAnimEvent_GiveAmmo( entity guy )
+{
+	if ( IsAlive( guy ) )
+	{
+		array<entity> weapons = guy.GetMainWeapons()
+		if ( weapons.len() > 0 )
+		{
+			entity weapon = weapons[0]
+			if ( IsValid( weapon ) )
+			{
+				weapon.SetWeaponPrimaryClipCount( weapon.GetWeaponPrimaryClipCountMax() )
+			}
+		}
+	}
+}
+
+
+function GetAnim( guy, animation )
+{
+	if ( !( "anims" in guy.s ) )
+		return animation
+
+	if ( !( animation in guy.s.anims ) )
+		return animation
+
+	return guy.s.anims[ animation ]
+}
+
+function HasAnim( guy, animation )
+{
+	if ( !( "anims" in guy.s ) )
+		return false
+
+	return animation in guy.s.anims
+}
+
+function SetAnim( guy, name, animation )
+{
+	if ( !( "anims" in guy.s ) )
+		guy.s.anims <- {}
+
+	Assert( !( name in guy.s.anims ), guy + " already has set anim " + name )
+
+	guy.s.anims[ name ] <- animation
+}
+
+AnimRefPoint function GetAnimStartInfo( entity ent, string animAlias, animref )
+{
+	string animData = expect string( GetAnim( ent, animAlias ) )
+	AnimRefPoint animStartInfo = ent.Anim_GetStartForRefPoint( animData, animref.GetOrigin(), animref.GetAngles() )
+
+	return animStartInfo
+}
+
+
+function GetRefPosition( reference )
+{
+	Assert( reference.HasKey( "model" ) && reference.GetValueForModelKey() != $"", "Tried to play an anim relative to " + reference + " but it has no model/ref attachment." )
+
+	local position = {}
+	local attach_id
+	attach_id = reference.LookupAttachment( "REF" )
+
+	if ( attach_id )
+	{
+		position.origin <- reference.GetAttachmentOrigin( attach_id )
+		position.angles <- reference.GetAttachmentAngles( attach_id )
+	}
+
+	return position
+}
+
+// play the anim
+function __PlayAnim( guy, animation_name, reference = null, optionalTag = null, blendTime = DEFAULT_SCRIPTED_ANIMATION_BLEND_TIME )
+{
+	expect entity( guy )
+
+	Assert( IsValid_ThisFrame( guy ), "Invalid ent sent to PlayAnim " + animation_name )
+	local animation = GetAnim( guy, animation_name )
+
+	guy.SetNextThinkNow()
+
+	#if !DEV
+	if ( guy.IsNPC() && !guy.IsInterruptable() )
+	{
+		// better than nothing failsafe
+		guy.Signal( "OnAnimationInterrupted" )
+		guy.Signal( "OnAnimationDone" )
+		return
+	}
+	#endif
+
+	if ( guy.IsNPC() )
+	{
+		guy.EndSignal( "OnDeath" )
+		Assert( IsAlive( guy ), "Guy " + guy + " tried to play an anim, but it is not alive." )
+	}
+
+	if ( reference )
+	{
+		if ( reference == guy )
+		{
+			local position = GetRefPosition( reference )
+			local origin = position.origin
+			local angles = position.angles
+
+			if ( guy.IsNPC() )
+				guy.Anim_ScriptedPlayWithRefPoint( animation, origin, angles, blendTime )
+			else
+				guy.Anim_PlayWithRefPoint( animation, origin, angles, blendTime )
+
+			return
+		}
+
+		if ( optionalTag )
+		{
+			if ( typeof( reference ) == "vector" )
+			{
+				Assert( typeof( optionalTag ) == "vector", "Expected angles but got " + optionalTag )
+				if ( guy.IsNPC() )
+					guy.Anim_ScriptedPlayWithRefPoint( animation, reference, optionalTag, blendTime )
+				else
+					guy.Anim_PlayWithRefPoint( animation, reference, optionalTag, blendTime )
+				return
+			}
+
+			Assert( typeof( optionalTag ) == "string", "Passed invalid optional tag " + optionalTag )
+
+			if ( guy.GetParent() == reference )
+			{
+				if ( guy.IsNPC() )
+					guy.Anim_ScriptedPlay( animation )
+				else
+					guy.Anim_Play( animation )
+			}
+			else
+			{
+				local attachIndex = reference.LookupAttachment( optionalTag )
+				local origin = reference.GetAttachmentOrigin( attachIndex )
+				local angles = reference.GetAttachmentAngles( attachIndex )
+				if ( guy.IsNPC() )
+				{
+					//local origin = reference.GetOrigin()
+					//local angles = reference.GetAngles()
+					guy.Anim_ScriptedPlayWithRefPoint( animation, origin, angles, blendTime )
+				}
+				else
+				{
+					//local animStartPos = guy.Anim_GetStartForRefEntity_Old( animation, reference, optionalTag )
+					//local origin = animStartPos.origin
+					//local angles = animStartPos.angles
+					guy.Anim_PlayWithRefPoint( animation, origin, angles, blendTime )
+				}
+			}
+			return
+		}
+	}
+	else
+	{
+		Assert( optionalTag == null, "Reference was null, but optionalTag was not. Did you mean to set the tag?" )
+	}
+
+	if ( reference != null && guy.GetParent() == reference )
+	{
+		if ( guy.IsNPC() )
+			guy.Anim_ScriptedPlay( animation )
+		else
+			guy.Anim_Play( animation )
+
+		return
+	}
+
+    if ( !reference )
+	    reference = guy
+
+    local origin = reference.GetOrigin()
+    local angles = reference.GetAngles()
+
+    if ( guy.IsNPC() )
+	    guy.Anim_ScriptedPlayWithRefPoint( animation, origin, angles, blendTime )
+    else
+	    guy.Anim_PlayWithRefPoint( animation, origin, angles, blendTime )
+
+}
+
+function TeleportToAnimStart( _guy, animation_name, reference, optionalTag = null, smooth = false )
+{
+	entity guy = expect entity( _guy )
+
+	Assert( reference, "NO reference" )
+	string animation = expect string( GetAnim( guy, animation_name ) )
+	AnimRefPoint animStartPos
+
+	if ( optionalTag )
+	{
+		if ( typeof( reference ) == "vector" )
+		{
+			Assert( typeof( optionalTag ) == "vector", "Expected angles but got " + optionalTag )
+			animStartPos = guy.Anim_GetStartForRefPoint( animation, reference, optionalTag )
+		}
+		else
+		{
+			animStartPos = guy.Anim_GetStartForRefEntity( animation, reference, optionalTag )
+		}
+	}
+	else
+	{
+		//printt( "Reference is " + reference )
+		//printt( "guy is " + guy )
+		//printt( "animation is " + animation )
+		local origin = reference.GetOrigin()
+		local angles = reference.GetAngles()
+		animStartPos = guy.Anim_GetStartForRefPoint( animation, origin, angles )
+	}
+	//Assert( animStartPos, "No animStartPos for " + animation + " on " + guy )
+
+	// hack! shouldn't need to do this
+	animStartPos.origin = ClampToWorldspace( animStartPos.origin )
+
+	if ( guy.GetParent() )
+	{
+		if ( smooth )
+		{
+			guy.SetAbsOriginSmooth( animStartPos.origin )
+			guy.SetAbsAnglesSmooth( animStartPos.angles )
+		}
+		else
+		{
+			guy.SetAbsOrigin( animStartPos.origin )
+			guy.SetAbsAngles( animStartPos.angles )
+		}
+	}
+	else
+	{
+		guy.SetOrigin( animStartPos.origin )
+		guy.SetAngles( animStartPos.angles )
+	}
+}
+
+// wait till arrive at goal and animation is done
+function RunToAndPlayAnimAndWait( entity guy, string animation_name, reference, bool doArrival = false, optionalTag = null )
+{
+	bool savedEnableFriendlyFollower = guy.ai.enableFriendlyFollower
+	guy.ai.enableFriendlyFollower = false
+
+	local allowFlee = guy.GetNPCFlag( NPC_ALLOW_FLEE )
+	local allowHandSignal = guy.GetNPCFlag( NPC_ALLOW_HAND_SIGNALS )
+	guy.DisableNPCFlag( NPC_ALLOW_FLEE | NPC_ALLOW_HAND_SIGNALS )
+
+	__RunToAndPlayAnim( guy, animation_name, reference, doArrival, optionalTag )
+
+	guy.WaitSignal( "OnFinishedAssault" )
+	WaittillAnimDone( guy )
+
+	guy.SetNPCFlag( NPC_ALLOW_FLEE, allowFlee )
+	guy.ai.enableFriendlyFollower = savedEnableFriendlyFollower
+}
+
+// wait till arrive at goal and start animation but don't wait until animation is done
+function RunToAndPlayAnim( entity guy, string animation_name, reference, bool doArrival = false, optionalTag = null )
+{
+	bool savedEnableFriendlyFollower = guy.ai.enableFriendlyFollower
+	guy.ai.enableFriendlyFollower = false
+
+	local allowFlee = guy.GetNPCFlag( NPC_ALLOW_FLEE )
+	local allowHandSignal = guy.GetNPCFlag( NPC_ALLOW_HAND_SIGNALS )
+	guy.DisableNPCFlag( NPC_ALLOW_FLEE | NPC_ALLOW_HAND_SIGNALS )
+
+	__RunToAndPlayAnim( guy, animation_name, reference, doArrival, optionalTag )
+
+	guy.WaitSignal( "OnFinishedAssault" )
+
+	guy.SetNPCFlag( NPC_ALLOW_FLEE, allowFlee )
+	guy.ai.enableFriendlyFollower = savedEnableFriendlyFollower
+}
+
+function RunToAndPlayAnimGravity( entity guy, string animation_name, reference, bool doArrival = false, optionalTag = null )
+{
+	local allowFlee = guy.GetNPCFlag( NPC_ALLOW_FLEE )
+	local allowHandSignal = guy.GetNPCFlag( NPC_ALLOW_HAND_SIGNALS )
+	guy.DisableNPCFlag( NPC_ALLOW_FLEE | NPC_ALLOW_HAND_SIGNALS )
+
+	float arrivalTolerance = guy.AssaultGetArrivalTolerance()
+	__RunToAndPlayAnim( guy, animation_name, reference, doArrival, optionalTag )
+
+	guy.WaitSignal( "OnFinishedAssault" )
+	guy.Anim_EnablePlanting()
+	WaittillAnimDone( guy )
+
+	guy.AssaultSetArrivalTolerance( arrivalTolerance )
+
+	guy.SetNPCFlag( NPC_ALLOW_HAND_SIGNALS, allowHandSignal )
+}
+
+
+function RunToAndPlayAnimGravityForced( entity guy, string animation_name, reference, bool doArrival = false, optionalTag = null )
+{
+	bool savedEnableFriendlyFollower = guy.ai.enableFriendlyFollower
+	guy.ai.enableFriendlyFollower = false
+
+	local allowFlee = guy.GetNPCFlag( NPC_ALLOW_FLEE )
+	local allowHandSignal = guy.GetNPCFlag( NPC_ALLOW_HAND_SIGNALS )
+	guy.DisableNPCFlag( NPC_ALLOW_FLEE | NPC_ALLOW_HAND_SIGNALS )
+
+	float arrivalTolerance = guy.AssaultGetArrivalTolerance()
+	__RunToAndPlayAnim( guy, animation_name, reference, doArrival, optionalTag )
+
+	guy.WaitSignal( "OnFinishedAssault" )
+	guy.Anim_EnablePlanting()
+	WaittillAnimDone( guy )
+
+	guy.AssaultSetArrivalTolerance( arrivalTolerance )
+
+	guy.SetNPCFlag( NPC_ALLOW_HAND_SIGNALS, allowHandSignal )
+	guy.ai.enableFriendlyFollower = savedEnableFriendlyFollower
+}
+
+function __RunToAndPlayAnim( entity guy, string animation_name, reference, bool doArrival, optionalTag )
+{
+	Assert( IsAlive( guy ) )
+	guy.Anim_Stop() // in case we were doing an anim already
+	guy.EndSignal( "OnDeath" )
+
+	string animation = expect string( GetAnim( guy, animation_name ) )
+	local origin, angles
+
+	if ( optionalTag )
+	{
+		if ( typeof( reference ) == "vector" )
+		{
+			Assert( typeof( optionalTag ) == "vector", "Expected angles but got " + optionalTag )
+			origin = reference
+			angles = optionalTag
+		}
+		else
+		{
+			local attach_id = reference.LookupAttachment( optionalTag )
+			origin = reference.GetAttachmentOrigin( attach_id )
+			angles = reference.GetAttachmentAngles( attach_id )
+		}
+	}
+	else
+	{
+		Assert( typeof( reference ) != "vector", "Expected an entity, but got an origin with no angles" )
+		origin = reference.GetOrigin()
+		angles = reference.GetAngles()
+	}
+
+	guy.AssaultPointToAnim( origin, angles, animation, doArrival, 4.0 )
+}
+
+// run to the place to start the anim, then play it
+function RunToAnimStart_Deprecated( guy, animation_name, reference = null, optionalTag = null )
+{
+	expect entity( guy )
+
+	Assert( IsAlive( guy ) )
+	guy.Anim_Stop() // in case we were doing an anim already
+	guy.EndSignal( "OnDeath" )
+
+	local allowFlee = guy.GetNPCFlag( NPC_ALLOW_FLEE )
+	local allowHandSignal = guy.GetNPCFlag( NPC_ALLOW_HAND_SIGNALS )
+
+	guy.DisableNPCFlag( NPC_ALLOW_FLEE | NPC_ALLOW_HAND_SIGNALS )
+
+	local animation = GetAnim( guy, animation_name )
+	local animStartPos
+
+	if ( optionalTag )
+	{
+		if ( typeof( reference ) == "vector" )
+		{
+			Assert( typeof( optionalTag ) == "vector", "Expected angles but got " + optionalTag )
+			animStartPos = guy.Anim_GetStartForRefPoint_Old( animation, reference, optionalTag )
+		}
+		else
+		{
+			animStartPos = guy.Anim_GetStartForRefEntity_Old( animation, reference, optionalTag )
+		}
+	}
+	else
+	{
+			local origin = reference.GetOrigin()
+			local angles = reference.GetAngles()
+			animStartPos = guy.Anim_GetStartForRefPoint_Old( animation, origin, angles )
+	}
+
+	guy.AssaultPoint( animStartPos.origin )
+	guy.WaitSignal( "OnFinishedAssault" )
+
+	guy.SetNPCFlag( NPC_ALLOW_FLEE, allowFlee )
+	guy.SetNPCFlag( NPC_ALLOW_HAND_SIGNALS, allowHandSignal )
+
+	local dist = Distance( animStartPos.origin, guy.GetOrigin() )
+	if ( dist > 8 )
+	{
+		//DebugDrawLine( animStartPos.origin, guy.GetOrigin(), 255, 150, 0, true, 60 )
+		printt( guy, " was ", dist, " units away from where he wanted to end his scripted sequence" )
+	}
+//	printt( guy + " finished assault at dist ", Distance( animStartPos.origin, guy.GetOrigin() ) )
+//	Assert( Distance( animStartPos.origin, guy.GetOrigin() ) < 32, guy + " finished assault but was " + ( Distance( animStartPos.origin, guy.GetOrigin() ) ) + " away from where he should have ended up." )
+}
+
+// only use this if you are OK with a frame pause before the start of the animation
+void function RunToAnimStartPos( entity guy, string animation_name, reference = null, bool doArrival = false, optionalTag = null )
+{
+	Assert( IsAlive( guy ) )
+	guy.Anim_Stop() // in case we were doing an anim already
+	guy.EndSignal( "OnDeath" )
+
+	local allowFlee = guy.GetNPCFlag( NPC_ALLOW_FLEE )
+	local allowHandSignal = guy.GetNPCFlag( NPC_ALLOW_HAND_SIGNALS )
+	local allowArrivals = guy.GetNPCMoveFlag( NPCMF_DISABLE_ARRIVALS )
+
+	if ( !doArrival )
+	{
+	//	guy.DisableArrivalOnce( true )
+		guy.EnableNPCMoveFlag( NPCMF_DISABLE_ARRIVALS )
+	}
+
+	guy.DisableNPCFlag( NPC_ALLOW_FLEE | NPC_ALLOW_HAND_SIGNALS )
+
+	local animation = GetAnim( guy, animation_name )
+	local animStartPos
+
+	if ( optionalTag )
+	{
+		if ( typeof( reference ) == "vector" )
+		{
+			Assert( typeof( optionalTag ) == "vector", "Expected angles but got " + optionalTag )
+			animStartPos = guy.Anim_GetStartForRefPoint_Old( animation, reference, optionalTag )
+		}
+		else
+		{
+			animStartPos = guy.Anim_GetStartForRefEntity_Old( animation, reference, optionalTag )
+			vector ornull clampedPos = NavMesh_ClampPointForAI( animStartPos.origin, guy )
+			if ( clampedPos != null )
+				animStartPos.origin = clampedPos
+		}
+	}
+	else
+	{
+		local origin = reference.GetOrigin()
+		local angles = reference.GetAngles()
+		animStartPos = guy.Anim_GetStartForRefPoint_Old( animation, origin, angles )
+	}
+
+	var fightRadius = guy.AssaultGetFightRadius()
+	var arrivalTolerance = guy.AssaultGetArrivalTolerance()
+	float runtoRadius = 61.16
+	guy.AssaultSetFightRadius( runtoRadius )
+	guy.AssaultSetArrivalTolerance( runtoRadius )
+
+	bool savedEnableFriendlyFollower = guy.ai.enableFriendlyFollower
+	guy.ai.enableFriendlyFollower = false
+
+	guy.AssaultPoint( animStartPos.origin )
+
+	//DebugDrawLine( guy.GetOrigin(), animStartPos.origin, 255, 0, 0, true, 20.0 )
+	//DebugDrawAngles( animStartPos.origin, animStartPos.angles )
+	//thread DebugAssaultEnt( guy, assaultEnt )
+	WaitSignal( guy, "OnFinishedAssault" )
+
+	//in case the scripter reset during run, we want to honor the intended change
+	if ( guy.AssaultGetFightRadius() == runtoRadius )
+		guy.AssaultSetFightRadius( fightRadius )
+
+	if ( guy.AssaultGetArrivalTolerance() == runtoRadius )
+		guy.AssaultSetArrivalTolerance( arrivalTolerance )
+
+	guy.SetNPCFlag( NPC_ALLOW_FLEE, allowFlee )
+	guy.SetNPCFlag( NPC_ALLOW_HAND_SIGNALS, allowHandSignal )
+	guy.SetNPCMoveFlag( NPCMF_DISABLE_ARRIVALS, allowArrivals )
+
+	guy.ai.enableFriendlyFollower = savedEnableFriendlyFollower
+}
+
+///////////////////////////////////////////////////////////////////
+// Deprecated, use RunToAndPlayAnim, otherwise there will be a gap between arriving at position and playing the animation
+function RunToAnimStartForced_Deprecated( entity guy, string animation_name, reference = null, optionalTag = null, bool disableArrival = true, disableAssaultAngles = false )
+{
+	Assert( IsAlive( guy ) )
+	guy.Anim_Stop() // in case we were doing an anim already
+	guy.EndSignal( "OnDeath" )
+
+	local allowFlee = guy.GetNPCFlag( NPC_ALLOW_FLEE )
+	local allowHandSignal = guy.GetNPCFlag( NPC_ALLOW_HAND_SIGNALS )
+	local allowArrivals = guy.GetNPCMoveFlag( NPCMF_DISABLE_ARRIVALS )
+
+	if ( disableArrival )
+	{
+	//	guy.DisableArrivalOnce( true )
+		guy.EnableNPCMoveFlag( NPCMF_DISABLE_ARRIVALS )
+	}
+
+	guy.DisableNPCFlag( NPC_ALLOW_FLEE | NPC_ALLOW_HAND_SIGNALS )
+
+	local animation = GetAnim( guy, animation_name )
+	local animStartPos
+
+	if ( optionalTag )
+	{
+		if ( typeof( reference ) == "vector" )
+		{
+			Assert( typeof( optionalTag ) == "vector", "Expected angles but got " + optionalTag )
+			animStartPos = guy.Anim_GetStartForRefPoint_Old( animation, reference, optionalTag )
+		}
+		else
+		{
+			animStartPos = guy.Anim_GetStartForRefEntity_Old( animation, reference, optionalTag )
+			vector ornull clampedPos = NavMesh_ClampPointForAI( animStartPos.origin, guy )
+			if ( clampedPos != null )
+				animStartPos.origin = clampedPos
+		}
+	}
+	else
+	{
+		local origin = reference.GetOrigin()
+		local angles = reference.GetAngles()
+		animStartPos = guy.Anim_GetStartForRefPoint_Old( animation, origin, angles )
+	}
+
+	var fightRadius = guy.AssaultGetFightRadius()
+	var arrivalTolerance = guy.AssaultGetArrivalTolerance()
+	float runtoRadius = 61.16
+	guy.AssaultSetFightRadius( runtoRadius )
+	guy.AssaultSetArrivalTolerance( runtoRadius )
+
+	bool savedEnableFriendlyFollower = guy.ai.enableFriendlyFollower
+	guy.ai.enableFriendlyFollower = false
+
+	guy.AssaultPoint( animStartPos.origin )
+	if ( !disableAssaultAngles )
+		guy.AssaultSetAngles( animStartPos.angles, true )
+
+	//DebugDrawLine( guy.GetOrigin(), animStartPos.origin, 255, 0, 0, true, 20.0 )
+	//DebugDrawAngles( animStartPos.origin, animStartPos.angles )
+	//thread DebugAssaultEnt( guy, assaultEnt )
+	WaitSignal( guy, "OnFinishedAssault" )
+
+/*
+	if ( !disableAssaultAngles )
+		guy.AssaultSetAngles( animStartPos.angles, true )
+
+	guy.AssaultPointToAnim( animStartPos.origin, animation, 4.0 )
+	WaittillAnimDone( guy )
+//	guy.WaitSignal( "OnFinishedAssault" )
+
+*/
+	//in case the scripter reset during run, we want to honor the intended change
+	if ( guy.AssaultGetFightRadius() == runtoRadius )
+		guy.AssaultSetFightRadius( fightRadius )
+
+	if ( guy.AssaultGetArrivalTolerance() == runtoRadius )
+		guy.AssaultSetArrivalTolerance( arrivalTolerance )
+
+	guy.SetNPCFlag( NPC_ALLOW_FLEE, allowFlee )
+	guy.SetNPCFlag( NPC_ALLOW_HAND_SIGNALS, allowHandSignal )
+	guy.SetNPCMoveFlag( NPCMF_DISABLE_ARRIVALS, allowArrivals )
+
+	guy.ai.enableFriendlyFollower = savedEnableFriendlyFollower
+}
+
+void function ShowEnt( entity viewmodel )
+{
+	if ( IsValid_ThisFrame( viewmodel ) )
+		viewmodel.ShowFirstPersonProxy()
+}
+
+// anim teleport
+function PlayAnimTeleport( guy, animation_name, reference = null, optionalTag = null, initialTime = -1.0, smooth = false )
+{
+	if ( type( guy ) == "array" || type( guy ) == "table" )
+	{
+		Assert( reference, "NO reference" )
+		local firstEnt = null
+		foreach ( ent in guy )
+		{
+			if ( !firstEnt )
+				firstEnt = ent
+
+			TeleportToAnimStart( ent, animation_name, reference, optionalTag, smooth )
+			__PlayAnim( ent, animation_name, reference, optionalTag, 0 )
+			if ( initialTime > 0.0 )
+				guy.Anim_SetInitialTime( initialTime )
+		}
+
+		WaittillAnimDone( expect entity( firstEnt ) )
+	}
+	else
+	{
+		if ( !reference )
+			reference = guy
+
+		TeleportToAnimStart( guy, animation_name, reference, optionalTag, smooth )
+		__PlayAnim( guy, animation_name, reference, optionalTag, 0 )
+		if ( initialTime > 0.0 )
+			guy.Anim_SetInitialTime( initialTime )
+		WaittillAnimDone( expect entity( guy ) )
+	}
+}
+
+// play the anim
+function PlayAnim( guy, animation_name, reference = null, optionalTag = null, blendTime = DEFAULT_SCRIPTED_ANIMATION_BLEND_TIME, initialTime = -1.0 )
+{
+	if ( type( guy ) == "array" )
+	{
+		foreach ( ent in guy )
+		{
+			__PlayAnim( ent, animation_name, reference, optionalTag, blendTime )
+			if ( initialTime > 0.0 )
+				guy.Anim_SetInitialTime( initialTime )
+		}
+
+		WaittillAnimDone( expect entity( guy[0] ) )
+	}
+	else
+	{
+		__PlayAnim( guy, animation_name, reference, optionalTag, blendTime )
+		if ( initialTime > 0.0 )
+			guy.Anim_SetInitialTime( initialTime )
+		WaittillAnimDone( expect entity( guy ) )
+	}
+}
+
+// play the anim
+function PlayAnimRun( entity guy, string animation_name, reference, bool doArrival, optionalTag = null, blendTime = DEFAULT_SCRIPTED_ANIMATION_BLEND_TIME  )
+{
+	RunToAndPlayAnim( guy, animation_name, reference, doArrival, optionalTag )
+	WaitSignal( guy, "OnFinishedAssault" )
+	WaittillAnimDone( guy )
+}
+
+function PlayAnimRunGravity( entity guy, string animation_name, reference, bool doArrival, optionalTag = null, blendTime = DEFAULT_SCRIPTED_ANIMATION_BLEND_TIME )
+{
+	RunToAndPlayAnim( guy, animation_name, reference, doArrival, optionalTag )
+	WaitSignal( guy, "OnFinishedAssault" )
+	guy.Anim_EnablePlanting()
+	WaittillAnimDone( guy )
+}
+
+function PlayAnimGravityClientSyncing( guy, animation_name, reference = null, optionalTag = null, blendTime = DEFAULT_SCRIPTED_ANIMATION_BLEND_TIME  )
+{
+	__PlayAnim( guy, animation_name, reference, optionalTag, blendTime )
+	guy.Anim_EnablePlanting()
+	WaittillAnimDone( expect entity( guy ) )
+}
+
+function PlayAnimGravity( guy, animation_name, reference = null, optionalTag = null, blendTime = DEFAULT_SCRIPTED_ANIMATION_BLEND_TIME  )
+{
+	__PlayAnim( guy, animation_name, reference, optionalTag, blendTime )
+	guy.Anim_EnablePlanting()
+	WaittillAnimDone( expect entity( guy ) )
+}
+
+
+function CalcSequenceBlendTime( FirstPersonSequenceStruct sequence, entity player, entity ent = null )
+{
+	if ( sequence.blendTime != CALCULATE_SEQUENCE_BLEND_TIME )
+		return
+
+	sequence.blendTime = 0
+	if ( ent && sequence.thirdPersonAnim != "" )
+	{
+		local start
+		if ( sequence.attachment != "" )
+		{
+			start = player.Anim_GetStartForRefEntity_Old( sequence.thirdPersonAnim, ent, sequence.attachment )
+		}
+		else
+		{
+			start = {}
+			start.origin <- ent.GetOrigin()
+			start.angles <- ent.GetAngles()
+		}
+
+		if ( sequence.teleport )
+		{
+			player.SetAbsOrigin( start.origin )
+			player.SetAbsAngles( start.angles )
+		}
+		else
+		{
+			local dist = Distance( player.GetOrigin(), start.origin )
+			sequence.blendTime = GraphCapped( dist, 0, 350, 0.25, 0.9 )
+		}
+	}
+}
+
+void function PlayFPSAnim( entity player, string anim3rd, string anim1st = "", entity ref = null, string optionalTag = "", void functionref(entity) animView = null, float blendTime = DEFAULT_SCRIPTED_ANIMATION_BLEND_TIME, float initialTime = 0.0 )
+{
+	bool teleport = false
+	bool hideProxy = true
+	__PlayFPSAnimInternal( player, anim3rd, anim1st, ref, optionalTag, animView, blendTime, initialTime, teleport, hideProxy )
+}
+
+void function PlayFPSAnimShowProxy( entity player, string anim3rd, string anim1st = "", entity ref = null, string optionalTag = "", void functionref(entity) animView = null, float blendTime = DEFAULT_SCRIPTED_ANIMATION_BLEND_TIME, float initialTime = 0.0 )
+{
+	bool teleport = false
+	bool hideProxy = false
+	__PlayFPSAnimInternal( player, anim3rd, anim1st, ref, optionalTag, animView, blendTime, initialTime, teleport, hideProxy )
+}
+
+void function PlayFPSAnimTeleport( entity player, string anim3rd, string anim1st = "", entity ref = null, string optionalTag = "", void functionref(entity) animView = null, float initialTime = 0.0 )
+{
+	bool teleport = true
+	bool hideProxy = true
+	float blendTime = 0.0
+	__PlayFPSAnimInternal( player, anim3rd, anim1st, ref, optionalTag, animView, blendTime, initialTime, teleport, hideProxy )
+}
+
+void function PlayFPSAnimTeleportShowProxy( entity player, string anim3rd, string anim1st = "", entity ref = null, string optionalTag = "", void functionref(entity) animView = null, float initialTime = 0.0 )
+{
+	bool teleport = true
+	bool hideProxy = false
+	float blendTime = 0.0
+	__PlayFPSAnimInternal( player, anim3rd, anim1st, ref, optionalTag, animView, blendTime, initialTime, teleport, hideProxy )
+}
+
+void function __PlayFPSAnimInternal( entity player, string anim3rd, string anim1st, entity ref, string optionalTag, void functionref(entity) animView, float blendTime, float initialTime, bool teleport, bool hideProxy )
+{
+	if ( animView == null )
+		animView = ViewConeRampFree
+
+	FirstPersonSequenceStruct sequence
+
+	sequence.firstPersonAnim	= anim1st
+	sequence.thirdPersonAnim 	= anim3rd
+	sequence.attachment 		= optionalTag
+	sequence.viewConeFunction	= animView
+	sequence.setInitialTime 	= initialTime
+	sequence.blendTime			= blendTime
+	sequence.teleport			= teleport
+	sequence.hideProxy			= hideProxy
+
+	//hard coded in this function
+	sequence.noParent			= true
+
+	FirstPersonSequence( sequence, player, ref )
+}
+
+void function FirstPersonSequence( FirstPersonSequenceStruct sequence, entity player, entity ent = null )
+{
+	player.Signal( "NewFirstPersonSequence" )
+	player.EndSignal( "NewFirstPersonSequence" )
+	player.EndSignal( "ScriptAnimStop" )
+
+	player.SetVelocity( <0,0,0> ) // fix this
+	if ( player.IsPlayer() && sequence.snapPlayerFeetToEyes )
+	{
+		player.SnapFeetToEyes()
+	}
+
+	//figure out if we have/should do a first person sequence and handle Spawn slots.
+	bool doFirstPersonAnim = sequence.firstPersonAnim != ""
+
+	entity firstPersonProxy
+	if ( doFirstPersonAnim )
+	{
+		Assert( player.IsPlayer(), player + " is not a player" )
+		firstPersonProxy = player.GetFirstPersonProxy()
+		if ( !IsValid( firstPersonProxy ) || !EntHasModelSet( firstPersonProxy ) )
+		{
+			doFirstPersonAnim = false;
+		}
+	}
+
+	if ( doFirstPersonAnim )
+	{
+		firstPersonProxy.ShowFirstPersonProxy()
+
+		if ( sequence.renderWithViewModels )
+			firstPersonProxy.RenderWithViewModels( true )
+		else
+			firstPersonProxy.RenderWithViewModels( false )
+
+		firstPersonProxy.ClearParent()
+		firstPersonProxy.SetAbsOrigin( player.GetOrigin() )
+		firstPersonProxy.SetAbsAngles( player.GetAngles() )
+
+		// Set anim view entity *after* setting the proxy's origin so that we calculate our initial view offset correctly (for lerping)
+		SetPlayerAnimViewEntity( player, firstPersonProxy )
+		firstPersonProxy.SetNextThinkNow()
+		SetForceDrawWhileParented( firstPersonProxy, true )
+	}
+	else if ( sequence.thirdPersonCameraAttachments.len() > 0 )
+	{
+		if ( player.IsPlayer() )
+		{
+			entity fpProxy = player.GetFirstPersonProxy() //Shouldn't ever need to show the first person proxy when doing thirdPersonCameraAttachments; hide it explicitly here to stop it from showing up when chaining animations
+			if ( IsValid( fpProxy )  )
+				fpProxy.HideFirstPersonProxy()
+
+			if ( sequence.thirdPersonCameraEntity )
+			{
+				SetPlayerAnimViewEntity( player, sequence.thirdPersonCameraEntity )
+			}
+			else
+			{
+				SetPlayerAnimViewEntity( player, player )
+			}
+
+			player.AnimViewEntity_SetThirdPersonCameraAttachments( sequence.thirdPersonCameraAttachments )
+			if ( sequence.thirdPersonCameraVisibilityChecks )
+			{
+				player.AnimViewEntity_EnableThirdPersonCameraVisibilityChecks()
+			}
+		}
+	}
+	else
+	{
+		if ( player.IsPlayer() )
+		{
+			ClearPlayerAnimViewEntity( player )
+		}
+	}
+
+	entity soul
+
+	if ( ent )
+	{
+		// the entity we are animating relative to may change during the animation
+		if ( IsSoul( ent ) )
+		{
+			soul = ent
+			ent = soul.GetTitan()
+			if ( !IsValid( ent ) )
+				return
+		}
+		else if ( HasSoul( ent ) )
+		{
+			soul = ent.GetTitanSoul()
+		}
+	}
+
+	CalcSequenceBlendTime( sequence, player, ent )
+
+	if ( player.IsPlayer() )
+	{
+		if ( sequence.teleport )
+		{
+			player.AnimViewEntity_SetLerpInTime( 0.0 )
+			player.PlayerCone_SetLerpTime( 0.0 )
+			player.SnapToAbsOrigin( player.GetOrigin() )
+		}
+		else
+		{
+			if ( sequence.noViewLerp || (sequence.blendTime <= 0.0) )
+			{
+				player.AnimViewEntity_SetLerpInTime( 0.0 )
+				player.PlayerCone_SetLerpTime( 0.0 )
+			}
+			else
+			{
+				player.AnimViewEntity_SetLerpInTime( sequence.blendTime )
+				player.PlayerCone_SetLerpTime( sequence.blendTime )
+			}
+		}
+
+		if ( sequence.thirdPersonCameraAttachments.len() == 0 )
+		{
+			if ( sequence.firstPersonBlendOutTime >= 0.0 )
+			{
+				player.AnimViewEntity_SetLerpOutTime( sequence.firstPersonBlendOutTime )
+			}
+			else
+			{
+				player.AnimViewEntity_SetLerpOutTime( 0.4 )
+			}
+		}
+
+		if ( !doFirstPersonAnim || !sequence.playerPushable )
+		{
+			player.SnapFeetToEyes()
+		}
+	}
+
+	if ( ent && !sequence.noParent )
+	{
+		local optionalTag
+		if ( sequence.attachment != "" )
+		{
+			optionalTag = sequence.attachment
+		}
+		else
+		{
+			optionalTag = ""
+		}
+
+		if ( player.GetParent() != ent )
+		{
+			// you could be parenting from one tag to another but we don't do
+			// that anywhere currently, and if we want to do it we can do some
+			// special stuff
+			player.SetParent( ent, optionalTag, false, sequence.blendTime )
+		}
+	}
+
+	if ( doFirstPersonAnim )
+	{
+		if ( sequence.teleport )
+		{
+			firstPersonProxy.SnapToAbsOrigin( player.GetOrigin() )
+		}
+
+		if ( sequence.playerPushable )
+		{
+			firstPersonProxy.SetParent( player, "", false )
+		}
+		else
+		{
+			firstPersonProxy.SetToSameParentAs( player )
+		}
+	}
+
+	if ( sequence.relativeAnim != "" )
+	{
+		if ( sequence.teleport )
+		{
+			thread PlayAnimGravityClientSyncing( ent, sequence.relativeAnim, null, null, 0.0 )
+		}
+		else
+		{
+			thread PlayAnimGravityClientSyncing( ent, sequence.relativeAnim )
+		}
+
+		if ( sequence.setInitialTime != 0.0 )
+			ent.Anim_SetInitialTime( sequence.setInitialTime )
+	}
+
+	if ( doFirstPersonAnim )
+	{
+		if ( ent )
+		{
+			thread PlayAnim( firstPersonProxy, sequence.firstPersonAnim, ent, sequence.attachment, sequence.blendTime )
+		}
+		else if ( sequence.playerPushable )
+		{
+			firstPersonProxy.Anim_Play( sequence.firstPersonAnim )
+			firstPersonProxy.Anim_DisableUpdatePosition()
+		}
+		else if ( sequence.gravity )
+		{
+			thread PlayAnimGravityClientSyncing( firstPersonProxy, sequence.firstPersonAnim, sequence.origin, sequence.angles, sequence.blendTime )
+		}
+		else
+		{
+			thread PlayAnim( firstPersonProxy, sequence.firstPersonAnim, sequence.origin, sequence.angles, sequence.blendTime )
+		}
+
+		// BROKEN - Anim_EnablePlanting() only works on players and NPCs
+		// if ( sequence.enablePlanting )
+		// {
+		// 	viewmodel.Anim_EnablePlanting()
+		// }
+
+		if ( sequence.setInitialTime != 0.0 )
+		{
+			firstPersonProxy.Anim_SetInitialTime( sequence.setInitialTime )
+		}
+
+		if ( sequence.useAnimatedRefAttachment )
+		{
+			firstPersonProxy.Anim_EnableUseAnimatedRefAttachmentInsteadOfRootMotion()
+		}
+
+		if ( sequence.hideProxy )
+		{
+			firstPersonProxy.HideFirstPersonProxy()
+		}
+	}
+
+	if ( sequence.thirdPersonAnim != "" )
+	{
+		if ( ent )
+		{
+			thread PlayAnim( player, sequence.thirdPersonAnim, ent, sequence.attachment, sequence.blendTime )
+		}
+		else if ( player.IsPlayer() && sequence.playerPushable )
+		{
+			player.Anim_Play( sequence.thirdPersonAnim )
+			player.Anim_DisableUpdatePosition()
+		}
+		else if ( sequence.gravity )
+		{
+			thread PlayAnimGravityClientSyncing( player, sequence.thirdPersonAnim, sequence.origin, sequence.angles, sequence.blendTime )
+		}
+		else
+		{
+			thread PlayAnim( player, sequence.thirdPersonAnim, sequence.origin, sequence.angles, sequence.blendTime )
+		}
+
+		if ( sequence.enablePlanting )
+			player.Anim_EnablePlanting()
+
+		if ( sequence.viewConeFunction != null )
+		{
+			if ( sequence.thirdPersonCameraAttachments.len() == 0 )
+			{
+				sequence.viewConeFunction( player )
+			}
+		}
+
+		if ( sequence.setInitialTime != 0.0 )
+			player.Anim_SetInitialTime( sequence.setInitialTime )
+
+		if ( sequence.useAnimatedRefAttachment )
+			player.Anim_EnableUseAnimatedRefAttachmentInsteadOfRootMotion()
+
+		WaittillAnimDone( player )
+	}
+
+	if ( doFirstPersonAnim && IsValid( firstPersonProxy ) && firstPersonProxy.Anim_IsActive() && !firstPersonProxy.IsSequenceFinished() )
+	{
+		WaittillAnimDone( firstPersonProxy )
+	}
+
+	if ( !IsValid( player ) )
+		return
+
+	if ( player.IsPlayer() )
+	{
+		if ( !IsAlive( player ) )
+			return
+
+ 		if ( IsDisconnected( player ) )
+ 			return
+	}
+	else
+	if ( player.IsNPC() )
+	{
+		if ( !IsAlive( player ) )
+			return
+	}
+
+	// time passed
+	if ( soul )
+	{
+		if ( !IsValid( soul ) )
+			return
+
+		ent = soul.GetTitan()
+		if ( !IsAlive( ent ) )
+			return
+	}
+
+	if ( sequence.thirdPersonAnimIdle != "" )
+	{
+		//thread PlayAnim( player, sequence.thirdPersonAnimIdle, ent, sequence.attachment, 0 )
+		if ( ent )
+		{
+			thread PlayAnim( player, sequence.thirdPersonAnimIdle, ent, sequence.attachment, sequence.blendTime )
+		}
+		else if ( player.IsPlayer() && sequence.playerPushable )
+		{
+			player.Anim_Play( sequence.thirdPersonAnimIdle )
+			player.Anim_DisableUpdatePosition()
+		}
+		else
+		{
+			thread PlayAnim( player, sequence.thirdPersonAnimIdle, sequence.origin, sequence.angles, sequence.blendTime )
+		}
+	}
+
+	if ( sequence.firstPersonAnimIdle != "" )
+	{
+		firstPersonProxy = player.GetFirstPersonProxy()
+		firstPersonProxy.ShowFirstPersonProxy()
+
+		if ( IsValid( firstPersonProxy ) && EntHasModelSet( firstPersonProxy ) ) //JFS: Defensive fix for player not having view models sometimes
+		{
+			if ( sequence.renderWithViewModels )
+				firstPersonProxy.RenderWithViewModels( true )
+			else
+				firstPersonProxy.RenderWithViewModels( false )
+
+			SetPlayerAnimViewEntity( player, firstPersonProxy )
+			firstPersonProxy.SetNextThinkNow()
+
+			firstPersonProxy.SetAbsOrigin( player.GetOrigin() )
+			firstPersonProxy.SetAbsAngles( player.GetAngles() )
+
+			firstPersonProxy.Anim_Play( sequence.firstPersonAnimIdle )
+
+			if ( sequence.playerPushable )
+			{
+				firstPersonProxy.SetParent( player, "", false )
+				firstPersonProxy.Anim_DisableUpdatePosition()
+			}
+			else
+			{
+				firstPersonProxy.SetToSameParentAs( player )
+			}
+		}
+	}
+
+	if ( sequence.thirdPersonAnimIdle != "" && sequence.firstPersonAnimIdle != "" )
+	{
+		if ( sequence.viewConeFunction != null )
+			sequence.viewConeFunction( player )
+	}
+}
+
+
+function ClampPlayerViewCone( player )
+{
+	player.EndSignal( "OnDeath" )
+	player.PlayerCone_SetLerpTime( 0.0 )
+}
\ No newline at end of file