U2.AnimationControllerBase

//=============================================================================
// AnimationControllerBase.uc
//=============================================================================

class AnimationControllerBase extends AnimationControllerInterf within U2Pawn;

//============================================================================
//    DEFINITIONS / ENUMERATIONS
//============================================================================

const LandingVelocityUseAnim	= -0.06;	// min landing velocity which will result in a soft landed animation

//============================================================================
//    VARIABLES
//============================================================================

var EAnimationGroup AnimationGroup;			// current animation catagory (replaces animation groups)

var int LockLevel;							// 0: not locked, 1: locked until animation ends 2: animations are under external control

var Actor.EPhysics OldPhysics;
var vector OldVelocity;
// mib-tbd only set by melee and ranged attack animations
var float SpecialAnimTimer;					// when special animation will be finished

var vector RagdollStartLocation;
var float RagdollTimer;
var float RagdollCollisionTimer;
var float MinRagdollDuration; // minimum time that ragdoll deaths will last before being checked for a stop
var float ChangeRagdollCollisionDelay; // time after which collision is changed for ragdoll deaths
var bool bDodging;
var bool bFallingDeath;
var bool bSpecialAnim;

//============================================================================
//    INTERFACE METHODS
//============================================================================

//-----------------------------------------------------------------------------

#debugbegin
function ACDM( coerce string Msg )
{
	//if( Outer.IsA( 'U2SkaarjMedium' ) )
	//if( !IsHumanControlled() )
	//	DMTNS( Msg );
}
#debugend

function Initialize()
{
	if (MeshAgentGetChannelCount() == 0)
		log("AnimationControllerBase.Initialize: Warning: Non-agentized character "$self$" attempting to use animation controller");
}

function CleanUp()
{
	RemoveAllTimers();
}

function ExternalTick( float DeltaTime )
{
	// NOTE: I did have a check for bHidden also, but this would bork any code
	// that is waiting for an AnimEnd (we're still using this currently).
	if( bStasis )
		return;

	//if (HasAnimationTable())
		AnimationTick( DeltaTime );
}


// attacks (non-weapon using NPCs?)

function SetWeaponState()
{
	//DMTNS( "SetWeaponState" );
	
	if (U2Weapon(Weapon) == None)
	{
		if (Controller.bFire != 0)
		{
			//DMTNS( "WeaponState: fire" );
			MeshAgentSetInputCurValue('WeaponState', 'Fire');
		}
		else if (Controller.bAltFire != 0)
		{
			//DMTNS( "WeaponState: altfire" );
			MeshAgentSetInputCurValue('WeaponState', 'AltFire');
		}
		else if( GetAlert() )
		{
			//DMTNS( "WeaponState: ambient" );
			MeshAgentSetInputCurValue('WeaponState', 'Ambient');
		}
		else
		{
			//DMTNS( "WeaponState: ambientlowered" );
			MeshAgentSetInputCurValue('WeaponState', 'AmbientLowered');
		}
	}
}


function SetAnimationGroup( EAnimationGroup NewAnimationGroup )
{
	//if( !bIsRealPlayer )
	//	DMTNS( "SetAnimationGroup " $ EnumStr( enum'EAnimationGroup', AnimationGroup ) $ " --> " $ EnumStr( enum'EAnimationGroup', NewAnimationGroup ) $ " at " $ ContextStr );

	AnimationGroup = NewAnimationGroup;
}


function float CallSpecialAnimAction( name AnimAction, EAnimationGroup AG, optional bool bNoWarn )
{
	local float ActionTime;

	//DMTNS( "CallSpecialAnimAction: " @ AnimAction @ "AG: " $ AG );
	
	ActionTime = MeshAgentCallAction( AnimAction );
	SpecialAnimTimer = Level.TimeSeconds + ActionTime;
	if( ActionTime <= 0.0 )
	{
#debugbegin	
		if (!bNoWarn) // only log certain warnings (others are deemed ok)
		{
			if( Controller != None )
				Controller.DMTNS( "Warning (CallSpecialAnimAction): agent unable to provide a special animation for" @ AnimAction @ "for" @ Outer );
			else
				DMTNS( "Warning (CallSpecialAnimAction): agent unable to provide a special animation for" @ AnimAction @ "for" @ Outer );
		}
#debugend		
	}
	else if (AG != AG_None)
	{
		//if( bIsRealPlayer )
		//	DMTNS( "  animation for " $ AnimAction $ " found -- will play for " $ ActionTime );
		SetAnimationGroup( AG );
	}
		
	return ActionTime;
}

function SetSpecialParamAnim( name NewValue )
{
	//if( !bIsRealPlayer )
	//DMTNS( "SetSpecialParam: " $ NewValue );
	MeshAgentSetInputCurValue( 'SpecialParam', NewValue );
	bSpecialAnim = (NewValue != '');
}

function float SpecialAnimationAcquisition()
{
	return CallSpecialAnimAction( 'U2_Acquire', AG_Special );
}

function float SpecialAnimationMeleeAttack()
{
	return CallSpecialAnimAction( 'U2_MeleeAttack', AG_AttackMelee );
}

function float SpecialAnimationRangedAttack(bool bIsStill)
{
	local float Duration;
	
	SetWeaponState();
	
	if (bIsStill)
		Duration = CallSpecialAnimAction( 'U2_RangedAttackStill', AG_AttackRanged, true ); // optional; if not present then will fall back to regular U2_RangedAttack
	if( Duration ~= 0.0 )
		Duration = CallSpecialAnimAction( 'U2_RangedAttack', AG_AttackRanged );

	/*
	Controller.DMTNS( "SpecialAnimationRangedAttack: " $ bIsStill );
	
	if( Duration > 0.0 )
		DMTNS( "  Duration: " $ Duration );
	else
		DMTNS( "  FAILED: " $ Duration );
	DumpAgentInfo();
	*/
	
	return Duration;
}

function float SpecialAnimationImpaleAttack()
{
	return CallSpecialAnimAction( 'U2_ImpaleAttack', AG_AttackMelee );
}

function SpecialAnimationMeleeAttackAbort()
{
	if (Health <= 0)
		return;
	MeshAgentCallAction( 'U2_MeleeAttackAbort' );
	SetAnimationGroup( AG_None );
}

function SpecialAnimationRangedAttackAbort()
{
	if (Health <= 0)
		return;
	MeshAgentCallAction( 'U2_RangedAttackAbort' );
	SetAnimationGroup( AG_None );
}

function SpecialAnimationImpaleAttackAbort()
{
	if (Health <= 0)
		return;
	MeshAgentCallAction( 'U2_ImpaleAttackAbort' );
	SetAnimationGroup( AG_None );
}

function SpecialAnimationVictoryDance()
{
	MeshAgentSetInputCurValue('SpecialParam', 'Victory'); // fullbody victories/thrusts specifically, or...
	//MeshAgentSetInputCurValue('SpecialParam', 'Taunt'); // upperbody taunts specifically, or...
	//MeshAgentSetInputCurValue('SpecialParam', 'None'); // let it choose
	
	CallSpecialAnimAction('U2_Taunt', AG_None);
}

function float SpecialAnimationTaunt()
{
	MeshAgentSetInputCurValue('SpecialParam', 'Taunt');
	return(CallSpecialAnimAction('U2_Taunt', AG_None));
}

function float SpecialAnimationWave()
{
	return(CallSpecialAnimAction('U2_Wave', AG_None));
}

function float SpecialAnimation( name AnimAction )
{
	switch( AnimAction )
	{
		case 'U2_Acquire':
			return SpecialAnimationAcquisition();
		case 'U2_Taunt':
			return SpecialAnimationTaunt();
		default:
			DMTNS( "Warning: invalid action requested in SpecialAnimation: " $ AnimAction );
	}
}

// specific animation requests (tbd)

function bool FallbackSpecialAnimation( name LookupName, optional float Rate, optional float TweenTime, optional bool bLooping )
{
	// fallback for the remaining animplay/animloop calls in the scripts until they're phased out.
	// yes this function is slow, but hey, more incentive for the LDs to clean up their scripts. ;)
	// all of the scripts I saw used either exact animation matches, or base names without weapon extensions.
	// I saw hardly ANY uses of just a slot name alone, so I'm not going out of my way to support those here.
	// Exact matches and weapon extension matches should be sufficient.
	
	local int i, count;
	local int AnimIndex;
	local float Duration;
	local string ScriptNameString;
	local string ExecuteString;

	if (Rate == 0.0) Rate = 1.0;
	if (TweenTime == 0.0) TweenTime = 0.2;

	// is there an exact matching animation for this name?
	AnimIndex = GetAnimIndex(LookupName);
	if (AnimIndex >= 0)
	{		
		// yes, we have an exact match.
		//DMN("Exact match");
		ScriptNameString = Chr(34)$string(LookupName)$Chr(34);
	}
	else
	{
		// no match; try using the weapon extension and hope for the best...
		ScriptNameString = "str("$Chr(34)$LookupName$"_"$Chr(34)$", WeaponType)";
	}
	ExecuteString = "force(50) "$MeshAgentGetChannelName(0)$" { script "$ScriptNameString$"; rate "$class'Util'.static.GetFloatString(Rate)$
		"; blend "$class'Util'.static.GetFloatString(TweenTime);
	if (bLooping)
	{
		ExecuteString = ExecuteString $ "; keepset 9999 9999; ";
		LockLevel = 2; // used so animrelease's UnlockAnimationController call will cause resets
	}
	else
	{
		ExecuteString = ExecuteString $ "; restart 1";
		if (LockLevel == 2)
			ExecuteString = ExecuteString $ "; looping 0; keepset 9999 9999; "; // animloop-without-release exploit (see JustDead.u2s and CourtDead.u2s in M08A)
		else
			ExecuteString = ExecuteString $ "; looping 0; keepset 1 1; ";
	}
	count = MeshAgentGetChannelCount();
	for (i=1;i<count;i++)
		ExecuteString = ExecuteString $ "force "$MeshAgentGetChannelName(i)$" {} ";
	ExecuteString = ExecuteString $ "}";

	//DMN("ExecuteString: "$ExecuteString);

	Duration = MeshAgentImmediateAction(ExecuteString);
	SpecialAnimTimer = Level.TimeSeconds + Duration;
	if (Duration == 0.0)
	{
		DMN("FallbackSpecialAnimation: No animation found for lookup name "$LookupName);
		return(false);
	}
	return(true);
}

function bool SpecialAnimationLoop( name LookupName, optional float Rate, optional float TweenTime, optional int _LockLevel )
{
	//DMN("SpecialAnimationLoop: The animloop command has been deprecated; please use agentbind/agentunbind, or animplay for non-looping animations");
	
	// CDH: There's no real fallback for this aside from continuing to do locks/unlocks, and I don't want to do that anymore.
	// We really do need to use agent inputs (bind/unbind) for this kind of thing to keep things clean.
	// Fortunately, not having a fallback isn't too big of a deal since animloop typically isn't set to wait in the scripts,
	// and if it doesn't wait then it generally can't break them.  If it does wait, then it's not much different from animplay.
	// So for the time being, we'll treat this the same way as we do animplay.
	return(FallbackSpecialAnimation(LookupName, Rate, TweenTime, true));
}

function bool SpecialAnimationPlay( name LookupName, optional float Rate, optional float TweenTime, optional int _LockLevel )
{
	//DMN("SpecialAnimationPlay: The animplay command has been deprecated; please use agentcall or agentexecute");	
	return(FallbackSpecialAnimation(LookupName, Rate, TweenTime, false));
}

function bool SpecialAnimationTween( name LookupName, optional float TweenTime, optional int _LockLevel )
{
	DMN("SpecialAnimationTween (warning): The animtween command has been deprecated");
	// CDH: nobody was using it anyway.  I'm serious; not a single instance in all the U2S files.
	return(false);
}

// special animation requests

function bool IsRagdollFriendlyDamageType( class<DamageType> DamageType )
{
	return ((DamageType!=None)
	 && !ClassIsChildOf(DamageType, class'DamageTypeThermalFlaming')
	 && !ClassIsChildOf(DamageType, class'DamageTypeBiological'));
}

function bool SetupForRagdollDeath()
{
	local int ActiveRagdollDeaths, MaxRagdollDeaths;

	if( !IsRealPlayer() && Level.bDropDetail )
		return false;
			
	ActiveRagdollDeaths = Level.Game.GetActiveRagdollDeaths();
	MaxRagdollDeaths = Level.Game.GetMaxRagdollDeaths();

	// 0 means no ragdoll deaths, ever
	if( MaxRagdollDeaths <= 0 )
		return false;
	
	// cap # ragdoll deaths unless its the player
	if( !IsRealPlayer() && ActiveRagdollDeaths >= MaxRagdollDeaths )
		return false;

	if( !(DrawScale ~= 1.0) )
		return false; // DrawScale must be 1 for ragdoll support

	MeshAgentSetInputCurValue('RagdollDetail', 'High');

	return true;
}

function bool SetupForRagdollHit()
{
	local int RagdollDetail;
	
	if( Level.bDropDetail )
		return false;
		
	RagdollDetail = Level.Game.GetRagdollDetailLevel();
	
	if( RagdollDetail <= 0 )
		return false;

	if( !(DrawScale ~= 1.0) )
		return false; // DrawScale must be 1 for ragdoll support

	if( RagdollDetail == 1 )
		MeshAgentSetInputCurValue('RagdollDetail', 'Low');
	else if( RagdollDetail == 2 )
		MeshAgentSetInputCurValue('RagdollDetail', 'Medium');
	else
		MeshAgentSetInputCurValue('RagdollDetail', 'High');

	return true;
}

function vector GetRagdollMomentum( class<DamageType> DamageType, vector HitLocation, Pawn InstigatedBy, vector Momentum, bool bRequireMomentum )
{
	local float MomentumSize;

	// The pawn's mass will have been factored into the momentum coming in, but we're baselining ragdoll on a pawn mass of 100,
	// so increase the momentum most of the way back (most of the way, not all; we do want mass to still have some effect).
	if (Mass > 100.0)
		Momentum *= (((Mass - 100.0) * 0.75) + 100.0) / 100.0;

	if ((VSize(Momentum) ~= 0.0) && !bRequireMomentum)
		return vect(0,0,0);
	
	if (!IsRagdollFriendlyDamageType(DamageType))
	{
		Momentum = VRand()*300.0; // these damage types tend to give us junk momentum values, so just use a small random amount
	}

	if (VSize(Momentum) > 1000.0)
		Momentum = 1000.0*Normal(Momentum);
	Momentum *= 0.1;
	MomentumSize = VSize(Momentum); // will now be between 0 and 100

	// if there's less than 25 at minimum, bump it up for ragdoll purposes
	if (MomentumSize < 25.0)
	{
		if (MomentumSize ~= 0.0)
		{
			// we have no momentum vector at all, so make one up based on the direction from whatever hit me
			if (!InstigatedBy)
				InstigatedBy = Outer;
			Momentum = HitLocation - InstigatedBy.Location;
			if (VSize(Momentum) ~= 0.0)
				Momentum = VRand(); // still no valid momentum vector?  then just make one up
		}
		Momentum = Normal(Momentum)*25.0;
	}

	return Momentum;
}

function SpecialAnimationDeath( class<DamageType> DamageType, vector HitLocation, Pawn InstigatedBy, vector Momentum )
{
	local int ChannelIndex;
	local vector RagdollMomentum;
	
	//DMTNS( "SpecialAnimationDeath -- DamageType:" @ DamageType @ "HitLocation:" @ HitLocation @ "Instigator:" @ InstigatedBy @ "Momentum:" @ Momentum );
	//DMTNS( "SpecialAnimationDeath: " $ Physics );
	
	// make sure not locked (e.g. in case NPC was flipping or doing some other special animation while killed)
	UnlockAnimationController();
	SpecialAnimationClear();
	
	if( Physics == PHYS_Falling || Physics == PHYS_Flying || Physics == PHYS_Swimming )
	{
		MeshAgentSetInputCurValue('SpecialState', 'Fall');
	}
	else
	{
		MeshAgentSetInputCurValue('SpecialState', 'None');
	}

	if ( ((HitLocation.Z - Location.Z) > (0.9 * CollisionHeight))   )
			//&& FDecision(/*default.OddsDecap*/0.67) /*&& !class'GameInfo'.default.bVeryLowGore*/ )
	{
		MeshAgentSetInputCurValue('SpecialParam', 'DeathDecap');
	}
	else if (Velocity.Z > 250.0 /*&& (FRand() < 0.75)*/ )
	{
		MeshAgentSetInputCurValue('SpecialParam', 'DeathBigHit');
	}
	else
	{
		MeshAgentSetInputCurValue('SpecialParam', 'None');
	}

	if (SetupForRagdollDeath() && (CallSpecialAnimAction('U2_DeathRagdoll', AG_None, true) > 0.0))
	{
		Level.Game.IncActiveRagDollDeaths();
		bRagdollDeath = true;
		RagdollTimer = Level.TimeSeconds + MinRagdollDuration;
		RagdollCollisionTimer = Level.TimeSeconds + ChangeRagdollCollisionDelay;
		RagdollStartLocation = Location;

		// no delayed cylinder reduction is required with ragdolls since physics and collision are automatically turned off
		bReducedCylinder = true;
		Velocity = vect(0,0,0);

		RagdollMomentum = GetRagdollMomentum(DamageType, HitLocation, InstigatedBy, Momentum, false);
		//RagdollMomentum *= 5; // Mega-Momentum test
	
		if (VSize(RagdollMomentum) > 0.0)
		{
			KAddImpulse(RagdollMomentum, HitLocation);
			if (VSize(RagdollMomentum) > 50.0)
				KAddImpulse(RagdollMomentum*0.5, Location); // big hit; throw a chunk of impulse on me at my center
		}

		bMeshAlwaysRefresh = true;
	}
	else if (CallSpecialAnimAction('U2_DeathFalling', AG_None, true) > 0.0)
	{
		bFallingDeath = true;
	}
	else 
	{
		if( CallSpecialAnimAction('U2_Death', AG_None) ~= 0.0 )
		{
			//DMTNS("Has no death animation -- freezing current animation");
			for( ChannelIndex=0; ChannelIndex < MeshAgentGetChannelCount(); ChannelIndex++ )
				MeshAgentEnableChannel( ChannelIndex, false );
			AnimRate = 0.0;
		}
	}

	MeshAgentSetInputLock('Posture', false);
	MeshAgentSetInputCurValue('Posture', 'Dead');
	MeshAgentSetInputLock('Posture', true); // lock the posture as dead from this point on

	/*
	//SetAnimationGroup( AG_Dying );
	LockAnimationController( 2 ); // death is a special case that should be handled the old way for the moment

	if( Physics == PHYS_Falling || Physics == PHYS_Flying || Physics == PHYS_Swimming )
	{
		// cdh-tbd: if NPC is given momentum after dying, PHYS_Falling isn't yet set
		if( AnimationHandler.PlayDyingFalling( Outer, DamageType, HitLocation ) )
			SetAnimationGroup( AG_DyingFalling );
	}
	else
	{
		AnimationHandler.PlayDying( Outer, DamageType, HitLocation );
	}
	*/
	// NOTE: if Outer doesn't have a dying animation call to PlayDying can
	// result in Outer being destroyed so there shouldn't be any code after
	// this point. Not sure if there is a better way to handle this.
}

function DodgeTimer()
{
	bDodging = false;
}

function float SpecialAnimationDodge( Actor.eDoubleClickDir DoubleClickMove )
{
	local float DodgeTime;

	// FIXME: The double-click dir itself is backwards; when I dodge left it says
	// right, and when I dodge right it says left.  This needs to be fixed at its
	// source, but for now switch the two manually.
	switch(DoubleClickMove)
	{
	case DCLICK_Forward: MeshAgentSetInputCurValue('Direction', 'Forward'); break;
	case DCLICK_Back: MeshAgentSetInputCurValue('Direction', 'Backward'); break;
	case /*DCLICK_Left*/ DCLICK_Right: MeshAgentSetInputCurValue('Direction', 'Left'); break;
	case /*DCLICK_Right*/ DCLICK_Left: MeshAgentSetInputCurValue('Direction', 'Right'); break;
	default: MeshAgentSetInputCurValue('Direction', 'Forward'); break;
	}

	DodgeTime = MeshAgentCallAction('U2_Dodge');
	if (DodgeTime > 0.0)
	{
		bDodging = true;
		AddTimer('DodgeTimer', DodgeTime, false);
	}
	else
	{
#debugbegin	
		if( Controller != None )
			Controller.DMTNS( "Warning (SpecialAnimationDodge): agent unable to provide a special animation for U2_Dodge for" @ Outer );
		else
			DMTNS( "Warning (SpecialAnimationDodge): agent unable to provide a special animation for U2_Dodge for" @ Outer );
#debugend
	}
	
	//SetAnimationGroup( AG_SpecialJump );
	return DodgeTime;
}

function SpecialAnimationMantle()
{
	if (MeshAgentCallAction('U2_Mantle') > 0.0)
		SetAnimationGroup( AG_Special );
}

function SpecialAnimationTakeHit( vector HitLocation, float Damage, class<DamageType> DamageType, Pawn InstigatedBy, vector Momentum )
{
	local vector RagdollMomentum;

	if( (IsRealPlayer() || Controller.AllowHitAnimations()) && !HandleKnockDown( InstigatedBy, HitLocation, Damage, DamageType, Momentum ) )
	{
		if (SetupForRagdollHit() && CanDoRagdollHit() && (IsRagdollFriendlyDamageType(DamageType)) && (CallSpecialAnimAction('U2_HitRagdoll', AG_None, true) > 0.0))
		{
			RagdollMomentum = GetRagdollMomentum(DamageType, HitLocation, InstigatedBy, Momentum, true);
			KAddImpulse(RagdollMomentum, HitLocation);

			LastPainAnimTime = Level.TimeSeconds;
		}
		else
		{
			if( Level.TimeSeconds - LastPainAnimTime > 0.1 )
			{
				LastPainAnimTime = Level.TimeSeconds;
				
				/* taken from old U2Pawn.HandleTakeHit code.  Copied and commented out for reference, but was not actually being
				   used since the last condition (making sure the animation controller was not of this type, i.e. it was the old controller)
				   meant it was never being called for agentized characters.  The U2_Hit action is the new agentized replacement

				//!!CDH (mdf) This is/was a temporary hack to get damage animations
				//!!CDH (mdf) afaict damaging NPC that is crouched causes sliding with the 
				// agentized NPCs. Checking for ST_Standing here seems to fix the 
				// problem just fine for now and this code will go away eventually anyway.
				//if( DefaultDamageAnim != '' && AnimationController != None )
				if( DefaultDamageAnim != '' && 
					Damage > 0 &&							// no damage done
					AnimationController != None && 			// no animation controller
					( VSize(Velocity) ~= 0.0 || 				// walking -- will cause sliding if repeatedly damaged
					Physics != PHYS_Walking ) &&
					!AnimationController.SpecialAnim() &&	// don't override a special anim
					//Stance == ST_Standing &&				// not standing (no longer matters since filtering out agents completely?)
					AnimationControllerBase(AnimationController) == None ) //!!CHD (mdf) still getting sliding even with stance check
				{
					AnimationController.SpecialAnimationPlay( DefaultDamageAnim );
				}
				*/

				CallSpecialAnimAction('U2_Hit', AG_None, true);
			}
		}
	}
}

function float SpecialAnimationLeap()
{
	//AnimationHandler.PlayLeap( Outer );
	return CallSpecialAnimAction( 'U2_Leap', AG_Leaping );
}

function float SpecialAnimationDamageKnockDown()
{
	return CallSpecialAnimAction( 'U2_DamageKnockdown', AG_Special);
}

function float SpecialAnimationDamageLaunch()
{
	return CallSpecialAnimAction( 'U2_DamageLaunch', AG_Special, true);
}

// special animation requests (tbd)

function LockAnimationController( int _LockLevel )
{
	assert(false); // don't use this anymore.
	/*
	local int i, count;

	DMTNS("LOCKANIMATIONCONTROLLER");

	if (LockLevel == 0)
	{
		// we weren't locked before but now we will be, so shut down agent channels
		count = MeshAgentGetChannelCount();
		for (i=0;i<count;i++)
			MeshAgentEnableChannel(i, false);
		for (i=1;i<count;i++) // close off upper channels
		{
			PlayAnim('', , , i);
			PlayAnim('', , , i); // double play none so any deprecated processes will be purged too
		}
	}
	
	LockLevel = Max( LockLevel, _LockLevel );
	*/
}

function UnlockAnimationController()
{
	local int i, count;

	/*
	//if (Health > 0)) //(mdf): otherwise death animation could be cleared (cdh: no longer relevant; death is now an agent action)
	//{
		if (LockLevel != 0)
		{
			// we were locked before and now we're unlocked, so reenable agent channels
			count = MeshAgentGetChannelCount();
			for (i=0;i<count;i++)
				MeshAgentEnableChannel(i, true);
		}

		SetAnimationGroup( AG_None ); //tbd: otherwise NPCs slide if looping special anim hasn't finished (at least once)
		LockLevel = 0;
	//}
	*/
	if (LockLevel != 0)
	{
		count = MeshAgentGetChannelCount();
		for (i=0;i<count;i++)
			MeshAgentResetChannel(i); // used by animrelease
		LockLevel = 0;
	}
	
	#debug ACDM( "clearing AnimationGroup in UnlockAnimationController" );
	SetAnimationGroup( AG_None );
}

function SpecialAnimationClear()
{
	if( Health > 0 )
	{
		#debug ACDM( "clearing AnimationGroup in SpecialAnimationClear" );
		SetAnimationGroup( AG_None );
		SpecialAnimTimer = 0;
	}
}

function bool CheckAnimationGroup( EAnimationGroup AG )
{
	return ( AnimationGroup == AG );
}

function bool IsSpecialAnimGroupPlaying( EAnimationGroup AG )
{
	return ( AnimationGroup == AG && 
			 Level.TimeSeconds < SpecialAnimTimer );
}

function bool SpecialAnim()
{
	return ( LockLevel != 0 || AnimationGroup == AG_Special || SpecialMovementAnim() );
}

// Used, e.g. to hold up tweening to falling animation when playing a special jump
// animation, such as a forward flip.

function bool SpecialJumpAnim()
{
	return ( bDodging || AnimationGroup == AG_Leaping );
	/*
	if( !IsAnimating() )
		return false;

	return( AnimationGroup == AG_SpecialJump );
	*/
}

//============================================================================
//    IMPLEMENTATION METHODS
//============================================================================
/*
	Helpers
*/
function bool Animating()
{
	return ( IsAnimating() && (!SimAnim.bAnimLoop || !bAnimLoopFinished) );
}

// Returns true if usual movement/idle animations don't currently apply, e.g. 
// because the current animation needs to finish or because the NPC is mantling etc.
function bool SpecialMovementAnim()
{
	return( AnimationGroup == AG_Landing || 
			AnimationGroup == AG_AttackMelee ||
			AnimationGroup == AG_AttackRanged ||
			bMantling );
}

function EWalkingAnimType GetWalkingAnimType()
{
	local int i;
	local float MovementSpeed;
	
	if( bIsWalking )				
		MovementSpeed = DesiredSpeed * WalkingPct; // reverse what engine does
	else
		MovementSpeed = DesiredSpeed;
	
	i = NumWalkingAnims-1;
	while ((i > 0) && (MovementSpeed < default.WalkingAnims[i].MinSpeed))
		i--;

	return(WalkingAnims[i].WalkingAnimType);
}

/*
	Ticking
*/
protected function AnimationTick(float DeltaTime)
{
	if( Health > 0 && Controller != None )
	{
		UpdateAnimation( DeltaTime );
	}
	else if (Health <= 0)
	{
		if ( bRagdollDeath )
		{
			if (RagdollCollisionTimer > 0.0 && Level.TimeSeconds > RagdollCollisionTimer )
			{
				NotifyRagdollCollisionChange();
				RagdollCollisionTimer = -1.0;
			}
			
			if (Level.TimeSeconds > RagdollTimer)
			{
				// we've past our ragdoll duration; terminate it if we haven't moved much since the last check
				if (VSize(Location - RagdollStartLocation) < CollisionRadius*0.5) // collision radius is a sufficient distance
				{
					// we haven't moved much, cut it off
					CallSpecialAnimAction('U2_DeathRagdollStop', AG_None);
					#debug ACDM( "clearing AnimationGroup in bRagdollDeath" );
					SetAnimationGroup( AG_None );
					bRagdollDeath = false;
					NotifyRagdollDeathEnded();
					bMeshAlwaysRefresh = false;
					Level.Game.DecActiveRagDollDeaths();
				}
				else
				{
					// we're still moving; renew timer to check again in another second
					RagdollTimer = Level.TimeSeconds + 1.0;
					RagdollStartLocation = Location;
				}
			}
		}
		else if( bFallingDeath && (Physics != PHYS_Falling/* || !IsAnimating()*/) )
		{
			CallSpecialAnimAction('U2_DeathLanded', AG_None);
			#debug ACDM( "clearing AnimationGroup in bFallingDeath" );
			SetAnimationGroup( AG_None );
			bFallingDeath = false;
		}
	}
}

function vector GetDefaultAimingLocation(float DeltaTime)
{
	local vector LocOrg;
	local rotator ClampRot;
	local vector AimingLocation;
	
	LocOrg = Location;
	LocOrg.Z += EyeHeight;
	//AimingLocation = LocOrg + (vector(Controller.Rotation) * 100.0);
	// TEMPORARY... workaround for Node Look At clamping problem in Golem
	ClampRot = Normalize(Controller.Rotation);
	if (GetStance() == ST_Prone)
		ClampRot.Pitch = Clamp(ClampRot.Pitch, 0, 14500);
	else
		ClampRot.Pitch = Clamp(ClampRot.Pitch, -14500, 14500);
	if ((Velocity dot vector(ClampRot)) > 0.0)
		LocOrg += Velocity*DeltaTime*4.0;
	AimingLocation = LocOrg + (vector(ClampRot) * 100.0);
	
	return AimingLocation;
}

function bool PlayerCanSeeHeadTracking()
{
	local PlayerController PC;
	local Actor ViewTarget;
	local bool bResult;
	
	PC = Level.PlayerControllerList;
	
	if( PC != None )
	{		
		if( PC.ViewTarget != None )
			ViewTarget = PC.ViewTarget;
		else
			ViewTarget = PC.Pawn;
		
		if( VSize( ViewTarget.Location - Location ) <= MaxHeadTrackPlayerDistance * 90.0/PC.FOVAngle ) 
			bResult = true;
	}
	
	//if( !IsRealPlayer() );
	//DMTNS( "PlayerCanSeeHeadTracking: " $ bResult );
	return bResult;
}

function bool CanHeadTrack(actor A)
{
	if (A == None)
		return(false);

	if (A.bHidden)
		return(false);
			
	if (StationaryPawn(A) != None)
		return(false);

	// track only within a limited cone of view
	//!!CDH (mdf) this should probably be done relative to some root bone / constrained in golem?
	return((vector(Rotation) dot Normal(A.Location - Location)) > 0.10);
}

function UpdateSatellites(float DeltaTime)
{
	local vector SatPos;
	local bool bHasAimingLocation, bGotHeadTrackLocation;
	local float Distance, NearDistance;
	local Pawn P, NearPawn;
	local bool bRealPlayer;
	local vector AimLocation;	

	if( !bWeaponAimingEnabled && !bHeadTrackingEnabled )
		return;
		
	//!!CDH (mdf) probably a temporary fix until we decide on a general solution
	if( HeadTrackActor != None && HeadTrackActor.bDeleteMe )
	{
		//Log( "WARNING (ASSERT) would have crashed" );
		HeadTrackActor = None;
	}

	bRealPlayer = IsRealPlayer();
	
	// Weapon Aiming
	if( bWeaponAimingEnabled )
	{		
		if( !bRealPlayer )
			bHasAimingLocation = Controller.GetAimingLocation( SatPos );
			
		if( bRealPlayer || !bHasAimingLocation || Normal( SatPos - Location ) dot vector( Rotation ) < 0.17 )
		{
			//if( !bRealPlayer )
			//DMTNS( "aiming at default location" );
			SatPos = GetDefaultAimingLocation( DeltaTime );
		}
		else
		{
			//if( !bRealPlayer )
			//DMTNS( "aiming at target location" );
		}
			
		MeshSetSatellite('Sat_WeaponAim', None, SatPos);
		//if( !bIsRealPlayer )
		//AddCylinder( SatPos, 4, 4, ColorGreen() );
		
		/*
		if( !bRealPlayer )
		{
		//AddCylinder( SatPos, 4, 4, ColorRed() );
		AddArrow( Location + vect(0,0,1)*EyeHeight, SatPos, ColorRed() );
		}
		*/
	}
		
	// Head Track
	if (bHeadTrackingEnabled && 
		!bRealPlayer && 
		!bHasAimingLocation &&
		PlayerCanSeeHeadTracking() )
	{
		//DMTNS( "looking for a head tracking target" );
		if ((HeadTrackActor != None) && (!CanHeadTrack(HeadTrackActor)))
		{
			HeadTrackActor = None;
			HeadTrackTimer = 0.0;
		}

		if ((HeadTrackActor == None) || (HeadTrackTimer <= 0.0))
		{
			HeadTrackActor = None;
			HeadTrackTimer = 0.0;

			NearPawn = None;
			NearDistance = 99999;

			for( P = Level.PawnList; P != None; P = P.nextPawn )
			{
				Distance = VSize( P.Location - Location );
				//DMTNS( "considering " $ P $ " at " $ Distance );
				if( Distance <= MaxHeadTrackDistance )
				{
					if ((P != Outer) && (CanHeadTrack(P)))
					{
						if (P.IsRealPlayer() )
						{
							// make player 3x as interesting to look at?
							Distance = 0.33*Distance;
						}
						
						if (Distance < NearDistance)
						{
							NearPawn = P;
							NearDistance = Distance;
						}
					}
				}
			}
			
			if (NearPawn != None)
			{
				HeadTrackActor = NearPawn;
				if (NearPawn.IsRealPlayer())
					HeadTrackTimer = 5.0 + FRand()*5.0;
				else
					HeadTrackTimer = 1.0;
			}
		}
		else if (HeadTrackTimer > 0.0)
			HeadTrackTimer -= DeltaTime;

		if (HeadTrackActor != None)
		{
			//if( !bRealPlayer )
			//DMTNS( "headtracking " $ HeadTrackActor );
			SatPos = HeadTrackActor.Location;
			if (Pawn(HeadTrackActor)!=None)
				SatPos.Z += Pawn(HeadTrackActor).EyeHeight;
			bGotHeadTrackLocation = true;
		}
	}
	
	if( !bGotHeadTrackLocation && !bWeaponAimingEnabled )
	{
		// didn't get a head tracking location and SatPos not currently set (not aiming)
		//if( !bRealPlayer )
		//DMTNS( "head tracking to default location" );
		SatPos = GetDefaultAimingLocation( DeltaTime );
	}
	
	//if (MeshAgentGetInputCurValue('InDialogMode') != 'True')  // CDH TBD
	if( bHeadtrackingEnabled )   //MW: Is this safe?
	{
		MeshSetSatellite('Sat_HeadTrack', None, SatPos);
		//if( !bIsRealPlayer )
		//AddCylinder( SatPos, 4, 4, ColorRed() );
	}
	
	/*
	if( !bRealPlayer )
	{
	//AddCylinder( SatPos, 8, 8, ColorBlue() );
	AddArrow( Location + vect(0,0,1)*EyeHeight, SatPos, ColorBlue() );
	}
	*/
	
/*!!CDH (mdf) is this still needed?	
	// Temporary... use weapon aiming in addition to head, if not in combat
	if (!bRealPlayer && !bHasAimingLocation)
		MeshSetSatellite('Sat_WeaponAim', None, SatPos);
*/
}

protected function UpdateAnimation(float DeltaTime)
{
	local bool bAnimating;
	local bool bResetFallTimer;
	
	local vector LocalAcceleration;
	local vector LocalVelocity;
	local Actor.EPhysics LocalPhysics;
	local bool LocalbIsTurning;
	local bool LocalbTurningLeft;
	local LicenseePawn.EMoveDir LocalMoveDir;
	local byte LocalPosture;
	local EWalkingAnimType LocalWalkingAnimType;
	local int LocalAnimationFlags;
	local LicenseePawn.EWeaponAnimationType LocalWeaponType;
	local byte LocalWeaponFiring;
	local int LocalTurnYaw;
	
	#debug ACDM( GetContext() $ " AnimationGroup: " $ EnumStr( enum'EAnimationGroup', AnimationGroup ) $ " LockLevel: " $ LockLevel $ " IsAnimating: " $ IsAnimating() $ " bAnimLoopFinished: " $ bAnimLoopFinished $ " SimAnim.bAnimLoop: " $ SimAnim.bAnimLoop );

	bAnimating = Animating();

	//!!CDH (mdf) temp hack to get victory dance to work
	/*
	if( AnimationGroup == AG_VictoryDance )
	{
		if( bAnimating )
			return;
		else
			UnlockAnimationController();
	}
	*/

	if( LockLevel == 1 && !bAnimating )
		UnlockAnimationController();
			
	//if( AnimationGroup == AG_Special && LockLevel )
	if (LockLevel != 0)
	{
		#debug ACDM( "returning: " $ GetContext() );
		return; // owner is handling animations
	}
	
	if( AnimationGroup == AG_Special )
	{
		if( bAnimating )
		{
			#debug ACDM( "returning: " $ GetContext() );
			return;
		}
		else
			UnlockAnimationController();
	}

	#debug ACDM( "Processing animation state" );

	SetWeaponState();

	// get current animation state properties
	LocalAcceleration = Acceleration;
	LocalVelocity = Velocity;
	LocalPhysics = Physics;
	LocalbIsTurning = bIsTurning;
	LocalbTurningLeft = bTurningLeft;
	LocalMoveDir = GetMoveDir();
	LocalPosture = GetStance();
	LocalWalkingAnimType = GetWalkingAnimType();
	LocalAnimationFlags = GetAnimationFlags();
	LocalWeaponType = GetWeaponAnimationTypeW(Weapon); //GetWeaponAnimationType();	
	LocalWeaponFiring = Controller.bFire | Controller.bAltFire;

	// Idles - Disable completely for now
	//if (GetAlert() || IsRealPlayer()) // also when in dialog state?
		MeshAgentSetInputCurValue('UseIdles', 'False');
	//else
	//	MeshAgentSetInputCurValue('UseIdles', 'True');

	// Posture
	if (Health <= 0)
	{
		MeshAgentSetInputCurValue('Posture', 'Dead');
	}
	else if (Physics == PHYS_Swimming)
	{
		MeshAgentSetInputCurValue('Posture', 'Swim');
	}
	else
	{
		switch(LocalPosture)
		{
		case ST_Standing: MeshAgentSetInputCurValue('Posture', 'Stand'); break;
		case ST_Crouching: MeshAgentSetInputCurValue('Posture', 'Duck'); break;
		case ST_Prone: MeshAgentSetInputCurValue('Posture', 'Prone'); break;
		default: MeshAgentSetInputCurValue('Posture', 'Stand'); break;
		}
	}

	// Health
	//FIXME: we don't want "random" idle anims if the Pawn is alert (has enemy etc.) or firing
	if (GetHurt())
	{
		MeshAgentSetInputCurValue('Health', 'Hurt');
	}
	else
	{
		MeshAgentSetInputCurValue('Health', 'Normal');
	}

	// Direction
	switch(LocalMoveDir)
	{
	case MD_None: MeshAgentSetInputCurValue('Direction', 'None'); break;
	case MD_Forward: MeshAgentSetInputCurValue('Direction', 'Forward'); break;
	case MD_Back: MeshAgentSetInputCurValue('Direction', 'Backward'); break;
	case MD_Left: MeshAgentSetInputCurValue('Direction', 'Left'); break;
	case MD_Right: MeshAgentSetInputCurValue('Direction', 'Right'); break;
	default: break;
	}

	// Turning
	if (LocalbIsTurning)
	{
		//DMT( "LocalTurnYaw: " $ LocalTurnYaw );

		//if( !bIsRealPlayer )
		//	DMTN( "LocalbIsTurning: " $ LocalbIsTurning $ "LocalbTurningLeft: " $ LocalbTurningLeft );

		if (LocalbTurningLeft)
			MeshAgentSetInputCurValue( 'Turning', 'LeftSmall' );
		else
			MeshAgentSetInputCurValue( 'Turning', 'RightSmall' );
			
		// determine how large the turn is likely to be
		LocalTurnYaw = Abs( DesiredRotation.Yaw - Rotation.Yaw ) & 65535;
		if( LocalTurnYaw >= 24576 )
			MeshAgentSetInputCurValue( 'TurnAngle', 'GE135' );
		else if( LocalTurnYaw >= 16384 )
			MeshAgentSetInputCurValue( 'TurnAngle', 'GE90' );
		else if( LocalTurnYaw >= 8192 )
			MeshAgentSetInputCurValue( 'TurnAngle', 'GE45' );
		else
			MeshAgentSetInputCurValue( 'TurnAngle', 'GE0' );
	}
	else
	{
		MeshAgentSetInputCurValue( 'Turning', 'None' );
		MeshAgentSetInputCurValue( 'TurnAngle', 'None' );
	}

	// Speed
	switch(LocalWalkingAnimType)
	{
	case WAT_None: MeshAgentSetInputCurValue('Speed', 'Walk'); break;
	case WAT_WalkSlow: MeshAgentSetInputCurValue('Speed', 'WalkHalf'); break;
	case WAT_WalkFast: MeshAgentSetInputCurValue('Speed', 'Walk'); break;
	case WAT_RunSlow: MeshAgentSetInputCurValue('Speed', 'RunHalf'); break;
	case WAT_RunFast: MeshAgentSetInputCurValue('Speed', 'Run'); break;
	}

	// WeaponType
	switch(LocalWeaponType)
	{
	case AT_Small: MeshAgentSetInputCurValue('WeaponType', 'Small'); break;
	case AT_SmallSwing: MeshAgentSetInputCurValue('WeaponType', 'SmallSwing'); break;
	case AT_Large: MeshAgentSetInputCurValue('WeaponType', 'Large'); break;
	case AT_Shoulder: MeshAgentSetInputCurValue('WeaponType', 'Shoulder'); break;
	case AT_Flamethrower: MeshAgentSetInputCurValue('WeaponType', 'FlameThrower'); break;
	default: break;
	}

	bResetFallTimer = true;

	// Landing
	#debug ACDM( "OldPhysics:       " $ EnumStr( enum'EPhysics', OldPhysics ) );
	#debug ACDM( "Physics:          " $ EnumStr( enum'EPhysics', Physics ) );
	#debug ACDM( "OldVelocity.Z:    " $ OldVelocity.Z );
	#debug ACDM( "Controller State: " $ Controller.GetStateName() );
	if ((OldPhysics == PHYS_Falling) && (Physics == PHYS_Walking) && (OldVelocity.Z <= MinLandAnimSpeed))
	{
		#debug ACDM( "HERE" );
		MeshAgentSetInputCurValue('Mood', 'Normal');
		if( Controller.IsInState( LController.LandedHardState ) )
			MeshAgentSetInputCurValue('SpecialParam', 'LandHard');
		else
		{
			if( !bSpecialAnim )
			{
				//if( !bIsRealPlayer )
				//DMTNS( "clearing SpecialParam #1" );
				MeshAgentSetInputCurValue('SpecialParam', 'None');
			}
		}
		MeshAgentCallAction('U2_Land');
	    SetAnimationGroup( AG_Landing );
	}
	else if (Physics == PHYS_Falling)
	{
		if ((Velocity.Z < 0) && (!SpecialJumpAnim())/* && (AnimationGroup != AG_Falling) */ )
		{
			bResetFallTimer = false;
			if( Velocity.Z <= GetLandCompressVelocity() )
			{
				if( MeshAgentGetInputCurValue('SpecialParam' ) != 'FallFar' )
					NotifyFallingFar( true );
				MeshAgentSetInputCurValue('SpecialParam', 'FallFar');
				if( GetStance() == ST_Standing ) //!!mdf-tbd: address in gal?
					MeshAgentSetInputCurValue('Mood', 'Panic');
			}
			else
			{
				MeshAgentSetInputCurValue('Mood', 'Normal');
				if( !bSpecialAnim )
				{
					//if( !bIsRealPlayer )
					//DMTNS( "clearing SpecialParam #2" );
					MeshAgentSetInputCurValue('SpecialParam', 'None');
				}
			}
			if( GetStance() == ST_Standing ) //!!mdf-tbd: address in gal?
				MeshAgentSetInputCurValue('SpecialState', 'Fall');
			//SetAnimationGroup( AG_Falling );
		}
		else if( Velocity.Z > MinJumpAnimSpeed && 
				 GetStance() == ST_Standing && //!!mdf-tbd: address in gal?
				 !SpecialJumpAnim() && 
				 OldPhysics == PHYS_Walking && 
				 AnimationGroup != AG_Jumping )
		{
			MeshAgentCallAction('U2_Jump');
			SetAnimationGroup( AG_Jumping );
		}
	}
	else if (bAnimating && SpecialMovementAnim())
	{
		// wait for current anim to finish
		// no: this spams special AnimationGroup so next call to SpecialMovementAnim returns false: AnimationGroup = AG_Finishing;
		MeshAgentSetInputCurValue('SpecialState', 'None');
		if( !bSpecialAnim )
		{
			//if( !bIsRealPlayer )
			//DMTNS( "clearing SpecialParam #3" );
			MeshAgentSetInputCurValue('SpecialParam', 'None');
		}
	}
	else if (Physics == PHYS_Ladder)
	{
		MeshAgentSetInputCurValue('SpecialState', 'Climb');
		//if( !bIsRealPlayer )
		//DMTNS( "clearing SpecialParam #4" );
		MeshAgentSetInputCurValue('SpecialParam', 'None');
		if( Velocity.X ~= 0.0 && Velocity.Y ~= 0.0 && Velocity.Z ~= 0.0 )
			AnimRate = 0.0; // freeze it?
		SetAnimationGroup( AG_Climbing );
	}
	else if (AnimationGroup != AG_Special &&
			 !bSpecialAnim &&
			 !bDodging &&
			 //!SpecialJumpAnim() &&
			 Level.TimeSeconds > SpecialAnimTimer)
	{
		MeshAgentSetInputCurValue('SpecialState', 'None');
		//if( !bIsRealPlayer )
		//DMTNS( "clearing SpecialParam #5" );
		MeshAgentSetInputCurValue('SpecialParam', 'None');
		#debug ACDM( "clearing AnimationGroup" );
		SetAnimationGroup( AG_None );
	}

	// FIXME: handle "typing" case somewhere:
	//if( IsRealPlayer() && PlayerController(Controller).bIsTyping )
	//	MeshAgentSetInputCurValue('SpecialState', 'Typing');
	
	OldPhysics = Physics;
	OldVelocity = Velocity;
	if (bResetFallTimer)
	{
		if( FallTimer > 0.0 && !bMantling )
			NotifyFallingFar( false );
		FallTimer = 0.0;
	}
	else
		FallTimer += DeltaTime;

	UpdateSatellites(DeltaTime);
}


//============================================================================
//    DEFAULT PROPERTIES
//============================================================================

defaultproperties
{
	MinRagdollDuration=5.000000
	ChangeRagdollCollisionDelay=1.000000
}