Engine.LicenseePawn

//NEW: licensee extensions support

//=============================================================================
// LicenseePawn.uc
//=============================================================================

class LicenseePawn extends Pawn
	config(User)
	abstract
	native;

/*=============================================================================
Licensee extensions support.

!!mdf-tbd: cleanup these comments:

This lets us add game-specific methods, properties, consts and enums etc.
here instead of either a) in Pawn.uc = messy for merging + game-specific stuff
shouldn't really go there or b) in a stand-alone class which has to do IsA
tests to interact with XXPlayerPawn/XXPawn specifically or c) having these exist
in both the XXPlayerPawn and XXPawn hierarchies which is difficult to maintain
and a violation of the Don't Repeat Yourself, i.e. duplicate code principle :).

See also LicenseeController.uc

Split into LicenseeController and LicenseePawn for UW. 
	What goes where?
		LicenseePawn?
			animation stuff
			stance stuff
			health stuff
		LicenseeController?
			pawn control stuff?
			debug stuff
	Do we need/want both of these?
=============================================================================*/

const AF_None		= 0x00;
const AF_Alert		= 0x01;
const AF_Hurt		= 0x02;

enum EWeaponAnimationType
{								
	AT_None, 		// not set
	AT_NoWeapon, 	// no weapon
	AT_Small,		// small weapon/object
	AT_SmallSwing,  // 1-handed swinging weapon/object
	AT_Large,		// large weapon/object
	AT_LargeSwing,  // 2-handed swinging weapon/object (!!cdh-tbr?)
	AT_Shoulder,  	// shoulder-held weapon/object
	AT_Flamethrower,// flamethrower type weapon/object
	AT_Gauntlet, 	// gauntlet (glove) type weapon/object (!!cdh-tbr?)
	AT_Last,		// last
};

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

enum EMoveDir
{								
	MD_None,
	MD_Back,
	MD_Forward,
	MD_Left,
	MD_Right,
};

/*
These specify various Z velocities (-ve) upon landing:

LandMakeNoiseVelocityXXX:	velocity above which Pawn plays landed grunt and calls MakeNoise
LandCompressVelocityXXX:	velocity above which Pawn will "stick" on landing (compress + play special landing sound)
LandDamageVelocityxXXX:		velocity above which damage occurs (play damage sound)
LandFatalVelocityXXX:		velocity above which landing is fatal (gib)

LandFatalVelocityXXX < LandDamageVelocityXXX < LandMakeNoiseVelocityXXX
LandFatalVelocityXXX < LandCompressVelocityXXX < LandMakeNoiseVelocityXXX 

LandDamageVelocityXXX can be <= LandCompressVelocityXXX but usually it will be > since Pawn would generally 
compress at velocities which would cause damage)
*/

var private float LandMakeNoiseVelocityStanding;
var private float LandDamageVelocityStanding;
var private float LandCompressVelocityStanding;
var private float LandFatalVelocityStanding;
var private float LandMakeNoiseVelocityCrouching;
var private float LandDamageVelocityCrouching;
var private float LandCompressVelocityCrouching;
var private float LandFatalVelocityCrouching;
var private float LandMakeNoiseVelocityProne;
var private float LandDamageVelocityProne;
var private float LandCompressVelocityProne;
var private float LandFatalVelocityProne;

var bool bSpecialHardLandings;	// NPC does special animations on hard landings

var float WalkingSlowPct;
var float CrouchingPct;
var float PronePct;
var float RunningSlowPct;

//-----------------------------------------------------------------------------
// crouch/prone stuff

var(Pawn) float ProneMeshAlignTraceLenFudgeFactor;
var(Pawn) vector ProneAlignMeshTraceOffset1;
var(Pawn) vector ProneAlignMeshTraceOffset2;
var(Pawn) vector ProneAlignMeshTraceOffset3;

var LicenseeController LController;

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

var(Pawn) float			AnimateHurtRatio;			// ratio of Health/default.Health where pawn should limp etc.

// !!cdh-tbd (mdf): generalize into a lookup AT_Small -> AT_Large, AT_Shoulder -> AT_Large, AT_SmallSwing -> AT_SmallSwing etc.?
var bool bLargeAnims;							// if true all weapons map to "large position" animations

//-----------------------------------------------------------------------------
// Mantling

// !!mjl (mdf) tbr: turn most of these into constants once good values found?
var(Pawn) globalconfig float MantleHandsUpwardReach;			// vertical reach of hands above CC
var(Pawn) globalconfig float MantleHandsForwardReachMin;		// min horizontal reach of hands in front of CC
var(Pawn) globalconfig float MantleHandsForwardReachMax;		// max horizontal reach of hands in front of CC
var(Pawn) globalconfig float MantleMinHitNormalDeltaZ;			// abort mantle if ledge normal Z component is less than this (.707 ~= 45 degrees)
var(Pawn) globalconfig float MantleSpeed;						// speed at which pawn mantles up (replaces AirSpeed during mantling)
var(Pawn) globalconfig float MantleMaxStandingMantleHeight;		// max height which can be mantled while standing
var(Pawn) globalconfig int   MantleDebugLevel;					// debugging control (set to 0: none, 1: show traces, 2: add begin/end 3: add other log info)

var(Pawn) float CosMinMoveForwardAngle;							// cos angle between X-axis of rotation and velocity below which forward animations used
var(Pawn) float CosMinMoveBackAngle;							// cos angle between X-axis of rotation and velocity below which back animations used

var vector MantleDestination;									// set when mantling begins to approx mantle destination for Pawn
var protected float NextCheckMantleTime;						// can be set to LevelTime + X to prevent re-mantling for a while
var float MantleHeight;											// set to height of ledge relative to player when mantling begins (for syncing animation)
var bool bMantling;												// true whenever pawn is mantling

//-----------------------------------------------------------------------------
// Replication
//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------
// MISC
//-----------------------------------------------------------------------------

// functions that subclasses will probably override
function bool LookupLoopAnim( name LookupName, optional float Rate, optional float TweenTime, optional int LockVal );
function bool LookupPlayAnim( name LookupName, optional float Rate, optional float TweenTime, optional int LockVal );
function bool LookupTweenAnim( name LookupName, optional float TweenTime, optional int LockVal );

//-----------------------------------------------------------------------------
// !!mdf-tbd: refactor various DMAI etc. to a single function which takes flags
// to compare against?

function final bool DebugAI()						{ return LController != None && LController.DebugAI(); }	
function final bool DebugAIAttacks()				{ return LController != None && LController.DebugAIAttacks(); }
function final bool DebugAIEvents()					{ return LController != None && LController.DebugAIEvents(); }
function final bool DebugAIMovement()				{ return LController != None && LController.DebugAIMovement(); }

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

function MantlingBegin();

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

function WentDormant( bool bVal );

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

event PreBeginPlay()
{
	Super.PreBeginPlay();

	// sanity checks
	assert( LandFatalVelocityStanding < LandDamageVelocityStanding );
	assert( LandDamageVelocityStanding < LandMakeNoiseVelocityStanding );
	assert( LandFatalVelocityStanding < LandCompressVelocityStanding );
	assert( LandCompressVelocityStanding < LandMakeNoiseVelocityStanding );

	assert( LandFatalVelocityCrouching < LandDamageVelocityCrouching );
	assert( LandDamageVelocityCrouching < LandMakeNoiseVelocityCrouching );
	assert( LandFatalVelocityCrouching < LandCompressVelocityCrouching );
	assert( LandCompressVelocityCrouching < LandMakeNoiseVelocityCrouching );

	assert( LandFatalVelocityProne < LandDamageVelocityProne );
	assert( LandDamageVelocityProne < LandMakeNoiseVelocityProne );
	assert( LandFatalVelocityStanding < LandCompressVelocityStanding );
	assert( LandCompressVelocityStanding < LandMakeNoiseVelocityStanding );
}

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

function PossessedBy( Controller C )
{
	//DMTNS( "PossessedBy start -- C: " $ C );
	InitLicenseeController( C );
	Super.PossessedBy( C );
	//DMTNS( "PossessedBy end -- C: " $ C );
}

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

function InitLicenseeController( Controller C )
{
	if( LicenseeController(C) != None )
	{
		LController = LicenseeController(C);
		LController.LPawn = Self;
	}
}

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

function PlayDyingSound();

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

function float GetLandMakeNoiseVelocity()
{
	switch( GetStance() )
	{
	case ST_Standing:
		return LandMakeNoiseVelocityStanding;
	case ST_Crouching:
		return LandMakeNoiseVelocityCrouching;
	case ST_Prone:
		return LandMakeNoiseVelocityProne;
	}
}

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

function float GetLandDamageVelocity()
{
	switch( GetStance() )
	{
	case ST_Standing:
		return LandDamageVelocityStanding;
	case ST_Crouching:
		return LandDamageVelocityCrouching;
	case ST_Prone:
		return LandDamageVelocityProne;
	}
}

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

function float GetLandCompressVelocity()
{
	switch( GetStance() )
	{
	case ST_Standing:
		return LandCompressVelocityStanding;
	case ST_Crouching:
		return LandCompressVelocityCrouching;
	case ST_Prone:
		return LandCompressVelocityProne;
	}
}

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

function float GetLandFatalVelocity()
{
	switch( GetStance() )
	{
	case ST_Standing:
		return LandFatalVelocityStanding;
	case ST_Crouching:
		return LandFatalVelocityCrouching;
	case ST_Prone:
		return LandFatalVelocityProne;
	}
}

//-----------------------------------------------------------------------------
// U2 version:

function TakeFallingDamage()
{
	local float Damage;
	local float Shake;

	//DMTNS( "TakeFallingDamage: " $ Velocity.Z );

	if( Velocity.Z <= GetLandMakeNoiseVelocity() )
	{
		if( Role == ROLE_Authority )
		{
			//DMTNS( "Role was ROLE_Authority" );
			
			if( Velocity.Z <= GetLandDamageVelocity() )
			{
				if( Velocity.Z <= GetLandFatalVelocity() )
					Damage = Health + 999; //make sure gibs (and spawns lotsa blood)
				else
					Damage = -0.12 * (Velocity.Z - GetLandDamageVelocity() );

				Damage = FMax( 1, Damage );
				TakeDamage( Damage,  Self, Location, vect(0,0,0), class'Fell' );
			}
		}
			
		if( Controller != None )
		{
			Shake = FMin( 1, -1 * Velocity.Z/MaxFallSpeed );
			//Controller.ShakeView( 0.175 + 0.1 * Shake, 850 * Shake, Shake * vect(0,0,1.5), 120000, vect(0,0,10), 1 );
			Controller.ShakeView( Shake );
		}
	}
}

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

function HandleLandedHard()		
{ 	
	LController.HandleLandedHard();
}

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

function bool IsHardLanding( CheckResult Hit, float ImpactSpeed )
{
	//DMTNS( "IsHardLanding Hit.Actor: " $ Hit.Actor $ " ImpactSpeed: " $ ImpactSpeed );
	return ( ImpactSpeed <= GetLandCompressVelocity() && Hit.Actor != None && !Hit.Actor.bLaunchPawns && !InGodMode() );
}

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

event LandedEx( CheckResult Hit )
{
	local float ImpactSpeed;

	// !!mdf-tbd: why do I care if physics still PHYS_Falling?
	// !!mdf-tbr? shouldn't engine physics take care of this (sets PHYS_None if dead, 
	// PHYS_Walking otherwise and this should only happen for creatures which can fall)?
	//if( Physics != PHYS_Walking && (Health > 0 || Physics != PHYS_None) )
	//{
	//	DM( "WARNING: Physics in Landed is: " $ class'Util'.static.GetPhysicsString(Self) );
	//	//assert( false );
	//}
	//???	SetMovementPhysics();

	//DMTNS( "Landed #1: " $ Velocity.Z );
	//DMTNS( "  Noise:     " $ GetLandMakeNoiseVelocity() );
	//DMTNS( "  Compress:  " $ GetLandCompressVelocity() );
	//DMTNS( "  Damage:    " $ GetLandDamageVelocity() );
	//DMTNS( "  Fatal:     " $ GetLandFatalVelocity() );
	TakeFallingDamage();

	//DMTNS( "Landed #2: " $ Velocity.Z );

	if( Health > 0 )
	{
		if( bSpecialHardLandings && IsHardLanding( Hit, Velocity.Z ) )
		{
			//DMTNS( "Calling HandleLandedHard Velocity.Z: " $ Velocity.Z );
			HandleLandedHard();
		}
		else
		{
			ImpactSpeed = Velocity.Z/JumpZ;
			ImpactSpeed = 0.1 * ImpactSpeed * ImpactSpeed;
		}
	}

	bJustLanded = true;
	
	Super.LandedEx( Hit );
}

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

simulated final function bool GetHurt()
{ 
	return ( float(Health)/float(default.Health) <= AnimateHurtRatio ); 
}

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

simulated final function bool GetAlert()
{ 
	return ( Controller != None && (Controller.ControllerEnemy != None || bAlert) ); 
}

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

simulated final function int GetAnimationFlags()
{ 
	local int AnimationFlags;

	if( GetAlert() )
		AnimationFlags = AnimationFlags | AF_Alert;
	if( GetHurt() )
		AnimationFlags = AnimationFlags | AF_Hurt;

	return AnimationFlags;
}

//-----------------------------------------------------------------------------
// Really just for forcing alert animations during testing.

simulated final function SetAlert( bool bNewVal )
{ 
	bAlert = bNewVal; 
}

//-----------------------------------------------------------------------------
// used by UI

simulated final function float GetHealth()
{
	return Health;
}

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

simulated function SetHealth( float NewVal )
{
	Health = NewVal;
}

//-----------------------------------------------------------------------------
// used by UI

simulated final function float GetHealthPct()
{
	return float(Health) / float(default.Health);
}

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

simulated final function string GetPlayerName()
{
	if( PlayerReplicationInfo!=None )
		return PlayerReplicationInfo.PlayerName;
	else
		return string(Name);
}

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

function final EMoveDir GetMoveDir() 
{
	local vector X, Y, Z, MovementVector;
	local float CosForwardAngle;
	local EMoveDir MoveDir;

	if( Velocity.X ~= 0.0 && Velocity.Y ~= 0.0 )
	{
		MoveDir = MD_None;
	}
	else if( GetStance() == ST_Prone )
	{
		//!!mdf: hack because when prone left/right get returned for forward/back
		// (should figure out why at some point) and we don't want/need left/right
		// for now (NPCs don't move and the roll animation isn't what we'd want
		// anyway since they could stop half way through it?)
		MoveDir = MD_Forward;
	}
	else 
	{
		GetAxes( Rotation, X, Y, Z );
		MovementVector = Velocity;
		MovementVector.Z = 0.0;
		MovementVector = Normal( MovementVector );

		CosForwardAngle = MovementVector dot X;
		//DMTNS( "CosForwardAngle: " $ CosForwardAngle );
		if( CosForwardAngle < CosMinMoveForwardAngle )
		{
			if( CosForwardAngle < -CosMinMoveBackAngle )
			{
				//DMTNS( "  back" );
				MoveDir = MD_Back;
			}
			else if( MovementVector dot Y > 0.0 )
			{
				//DMTNS( "  right" );
				MoveDir = MD_Right;
			}
			else
			{
				//DMTNS( "  left" );
				MoveDir = MD_Left;
			}
		}
		else
		{
			//DMTNS( "  forward" );
			MoveDir = MD_Forward;
		}
	}

	return MoveDir;
}

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

function final UpdateWalkingPct()
{
	switch( GetStance() )
	{
	case ST_Standing:
		WalkingPct = default.WalkingPct;
		break;
	case ST_Crouching:
		WalkingPct = default.CrouchingPct;
		break;
	case ST_Prone:
		WalkingPct = default.PronePct;
		break;
	}

	//DMTNS( "UpdateWalkingPct: " $ GetStance() );
	//DMTNS( "  #1: " $ WalkingPct );

	if( LController != None )
		WalkingPct *= LController.GetWalkingPctScale();

	//DMTNS( "  #2: " $ WalkingPct );
}

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

private function StandBegin()
{
	//DMTNS( "StandBegin #1 CollisionRadius: " $ CollisionRadius $ " CollisionHeight: " $ CollisionHeight $ " PrePivot.Z: " $ PrePivot.Z );
	AlignMeshTraceVector = vect(0,0,0);
	AlignMeshNormal = vect(0,0,0);

	bCrawler = default.bCrawler; //!!CDH - until golem supports AlignMeshNormal
	bIsWalking = false;
	//DMTNS( "StandBegin #2 CollisionRadius: " $ CollisionRadius $ " CollisionHeight: " $ CollisionHeight $ " PrePivot.Z: " $ PrePivot.Z );
}

//-----------------------------------------------------------------------------
// !!mdf-tbd: after move to 8xx clean up prone/crouch/stand code
// (generalize telling engine Pawn wants to be prone/crouched/standing
// let it do the collision changes and checks for new CC fitting then
// have engine call event StanceModified( NewStance --
// get rid of StartCrouch/EndCrouch? -- use stance to determine new
// stance and call Prone/Crouch/StandBegin accordingly).
// !!mdf-tbd: for players we could let updateeyeheight set the eyeheight (with smoothing)?

private function CrouchBegin()
{
	//DMTNS( "CrouchBegin #1 CollisionRadius: " $ CollisionRadius $ " CollisionHeight: " $ CollisionHeight $ " PrePivot.Z: " $ PrePivot.Z );
	AlignMeshTraceVector = vect(0,0,0);
	AlignMeshNormal = vect(0,0,0);

	//bWantsToCrouch = true;
	bCrawler = default.bCrawler; //!!CDH - until golem supports AlignMeshNormal
	bIsWalking = true;
	//DMTNS( "CrouchBegin #2 CollisionRadius: " $ CollisionRadius $ " CollisionHeight: " $ CollisionHeight $ " PrePivot.Z: " $ PrePivot.Z );
}

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

private function ProneBegin()
{
	//DMTNS( "ProneBegin #1 CollisionRadius: " $ CollisionRadius $ " CollisionHeight: " $ CollisionHeight $ " PrePivot.Z: " $ PrePivot.Z );
	// trace down from "patch" under upper body area (prefer to keep chest on ground) -- allow up to 2xCR to allow for 45 degree slope?
	AlignMeshTraceVector = vect(0,0,-1)*(2*ProneRadius+ProneMeshAlignTraceLenFudgeFactor);

	// if not used for anything else -- could actually just set once in PBP
	AlignMeshTraceOffset1 = ProneAlignMeshTraceOffset1;
	AlignMeshTraceOffset2 = ProneAlignMeshTraceOffset2;
	AlignMeshTraceOffset3 = ProneAlignMeshTraceOffset3;

	bCrawler = true; //!!CDH - until golem supports AlignMeshNormal
	bIsWalking = true;
	//DMTNS( "ProneBegin #2 CollisionRadius: " $ CollisionRadius $ " CollisionHeight: " $ CollisionHeight $ " PrePivot.Z: " $ PrePivot.Z );
}

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

event NotifyStanceChange( byte NewStance, float HeightAdjust )
{
	Super.NotifyStanceChange( NewStance, HeightAdjust );
	
	switch( NewStance )
	{
		case ST_Standing:
			StandBegin();
			break;
		case ST_Crouching:
			CrouchBegin();
			break;
		case ST_Prone:
			ProneBegin();
			break;
		UpdateWalkingPct();	
	}
}

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

function final bool IsPointing()
{
	// !!mdf-tbd: CarriedDecoration gone from UW
	//return ( (Weapon != None) && (Weapon.bPointing || CarriedDecoration != None) );
	return( Weapon != None && Weapon.bPointing );
}

//-----------------------------------------------------------------------------
// !!mdf-tbd: PlayerPawn code checked for SourcePawn.bFire || SourcePawn.bAltFire
//          but is this necessary?

function final bool IsRapidFiring()
{
	return ( (Weapon != None) && Weapon.bRapidFire && (Controller.bFire != 0 || Controller.bAltFire != 0) );
}

//-----------------------------------------------------------------------------
// Sub-Engine weapons handled in subclasses.

function EWeaponAnimationType GetWeaponAnimationTypeW( Weapon Weap )
{
	return AT_Large;
}

//-----------------------------------------------------------------------------
// Make sure we use the PendingWeapon if set or animation checks during a 
// weapon switch will be using the old weapon.

function final EWeaponAnimationType GetWeaponAnimationType()
{
	if( Health > 0 && PendingWeapon != None )
		return GetWeaponAnimationTypeW( PendingWeapon );
	else
		return GetWeaponAnimationTypeW( Weapon );
}

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

function bool IsUsable( optional Actor Other )
{
	if( LController != None )
		return LController.IsUsable( Other );
	else
		return Super.IsUsable( Other );
}

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

function OnUse( Actor Other )
{
	if ( LController != None )
		LController.OnUse( Other );
	else
		Super.OnUse( Other );
}

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

function OnUnuse( Actor Other )
{
	if ( LController != None )
		LController.OnUnuse( Other );
	else
		Super.OnUnuse( Other );
}

//-----------------------------------------------------------------------------
// We default to standard rendering/physics properties for players / bots and 
// human-like NPCs and subclasses can override these as necessary.


//OLD

defaultproperties
{
	LandMakeNoiseVelocityStanding=-700.000000
	LandDamageVelocityStanding=-1300.000000
	LandCompressVelocityStanding=-1200.000000
	LandFatalVelocityStanding=-3000.000000
	LandMakeNoiseVelocityCrouching=-700.000000
	LandDamageVelocityCrouching=-900.000000
	LandCompressVelocityCrouching=-800.000000
	LandFatalVelocityCrouching=-2000.000000
	LandMakeNoiseVelocityProne=-500.000000
	LandDamageVelocityProne=-700.000000
	LandCompressVelocityProne=-600.000000
	LandFatalVelocityProne=-1500.000000
	WalkingSlowPct=0.300000
	CrouchingPct=0.300000
	PronePct=0.200000
	RunningSlowPct=0.700000
	ProneMeshAlignTraceLenFudgeFactor=64.000000
	ProneAlignMeshTraceOffset1=(X=20.000000,Y=-20.000000,Z=-12.000000)
	ProneAlignMeshTraceOffset2=(X=20.000000,Y=20.000000,Z=-12.000000)
	ProneAlignMeshTraceOffset3=(X=-5.000000,Z=-12.000000)
	AnimateHurtRatio=0.350000
	MantleHandsUpwardReach=16.000000
	MantleHandsForwardReachMin=8.000000
	MantleHandsForwardReachMax=24.000000
	MantleMinHitNormalDeltaZ=0.707000
	MantleSpeed=300.000000
	MantleMaxStandingMantleHeight=125.000000
	CosMinMoveForwardAngle=0.800000
	CosMinMoveBackAngle=0.800000
	bCanStrafe=true
	GroundSpeed=263.000000
	WaterSpeed=140.000000
	AirSpeed=280.000000
	LadderSpeed=140.000000
	AccelRate=8192.000000
	JumpZ=470.000000
	WalkingPct=0.300000
	BaseEyeHeight=46.000000
	CrouchHeight=32.000000
	CrouchRadius=28.000000
	UnderWaterTime=20.000000
	bActorShadows=true
	CollisionRadius=28.000000
	CollisionHeight=54.000000
	Buoyancy=99.000000
	RotationRate=(Pitch=3072,Yaw=65000,Roll=2048)
     UseReticleOnEvents(0)="UseReticleText"
     UseReticleOnEvents(1)="UseReticleCorners"
     UseReticleOnEvents(2)="UseReticleSideBars"
     ProximityReticleOnEvents(0)="ProximityReticleCorners"
     ProximityReticleOnEvents(1)="ProximityReticleSideBars"
}