U2Pawns.U2KillerSproutController

//=============================================================================
// U2KillerSproutController
//=============================================================================

class U2KillerSproutController extends U2NPCControllerBase;

/*-----------------------------------------------------------------------------
Normally remains in the default state doing nothing other than playing idle
animations.

If an enemy (any class but itself?) touches its tentacles, grabs them and holds
and damages them. tbd: prevent enemy from moving but allow them to aim so they 
can attack the sprout. If the sprout is damaged enough or killed, enemy will be 
released.

Currently assumes sprout is on floor. Ideally would also work on ceiling and
walls? Not hard to do this -- we'd need to modify:
	the proxy collision cylinder size and location
	the CanGrab test
	the "reel in" vector
	initialization so sprouts wouldn't fall on startup (use PHYS_None)?

Note: 

Pawn uses a proxy cylinder to handle touch notifications. Pawn's usual 
collision cylinder has touch/untouch notifications disabled.

Design Goal: when inactive execute as little code as possible. The Controller's
Tick function is disabled by default and is only activated if the sprout is
damaged or if the sprout is touched by a valid enemy. The Tick function only
remains active until the sprout's health is restored and there is no longer any 
enemy being tracked.

Does not use an AnimationController (servo) as almost all animations need to be
custom controlled.
*/

const KSAlertState			= 'KSAlert';			// tracking enemy that touched tentacles
const KSGrabbingState		= 'KSGrabbing';			// reeling enemy in
const KSRecoveringState		= 'KSRecovering';		// hurt and healing
const KSWaitingState		= 'KSWaiting';			// idle

// properties
var float MaxGrabSpeed;
var float MinGrabHeight;
var float MinGrabRadius;
var float HealthydHealthLevel;
var float InjuredHealthLevel;
var float DamageEnemyRate;
var float ReeledInDamageMultiplier;
var float RecoverHealthRate;
var float ReelInSpeed;						// divided by enemy's mass to get final speed

// local
var float AddedHealth;
var float DamageAmount;

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

function float GetMinReachZ()
{
	if( U2KillerSprout(Pawn) != None )
		return U2KillerSprout(Pawn).GetMinReachZ();
	else
		return 999999.9;
}

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

function float GetMaxReachZ()
{
	if( U2KillerSprout(Pawn) != None )
		return U2KillerSprout(Pawn).GetMaxReachZ();
	else
		return -999999.9;
}

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

function bool CanGrab( Pawn P )
{
	return( P != None &&
    		!P.bDeleteMe && 
			!P.bHidden && 
			P.Location.Z >= GetMinReachZ() &&
			P.Location.Z <= GetMaxReachZ() &&
			VSize2D( P.Location - Pawn.Location ) <= Pawn.CollisionRadius );
}

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

event AnimEnd( int Channel )
{
	Disable( Event_AnimEnd );
}

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

function PlayHit()
{
	Pawn.MeshAgentCallAction( 'Event_Hit' );
}

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

function NotifyTakeHit( Pawn InstigatedBy, vector HitLocation, int Damage, class<DamageType> DamageType, vector Momentum )
{
	if( Level.TimeSeconds - Pawn.LastPainAnimTime > 1.5 )
	{
		Pawn.LastPainAnimTime = Level.TimeSeconds;
		PlayHit();
	}
}

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

function bool ShouldTransitionToRecovering()
{
	return ( Pawn.Health > 0 && Pawn.Health < InjuredHealthLevel*Pawn.default.Health );
}

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

event Tick( float DeltaTime )
{
	Super.Tick( DeltaTime );

	if( Pawn.Health > 0 )
	{
		if( Pawn.Health < Pawn.default.Health )
		{
			// gradually restore health
			AddedHealth += RecoverHealthRate*DeltaTime;
			if( AddedHealth >= 1.0 )
			{
				Pawn.Health += int(AddedHealth);
				Pawn.Health = FMin( Pawn.default.Health, Pawn.Health );
				AddedHealth -= int(AddedHealth);
			}	
			if( ShouldTransitionToRecovering() )
			{
				GotoState( KSRecoveringState );
			}
		}
		else if( ControllerEnemy == None )
		{
			Disable( Event_Tick );
		}
	}
}

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

function eventTookDamage( int Damage, Pawn Instigator, vector HitLocation, vector Momentum, class<DamageType> DamageType )
{
	if( Pawn != None && Pawn.Health > 0 )
		Enable( Event_Tick );
}

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

state @ KSAlertState
{
	//-------------------------------------------------------------------------

	event UnTouch( Actor Other )
	{
		if( Other == ControllerEnemy )
			GotoState( DefaultState );
	}

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

	event Tick( float DeltaTime )
	{
		Global.Tick( DeltaTime );

		if( !ValidPawn( ControllerEnemy ) )
		{
			GotoState( DefaultState );
		}
		else if( CanGrab( ControllerEnemy ) )
		{
			GotoState( KSGrabbingState );
		}
	}

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

	event BeginState()
	{
		Enable( Event_Tick );
	}
} //KSAlertState

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

state @ KSGrabbingState
{
	//-------------------------------------------------------------------------

	function PlayHit()
	{
		if( !ShouldTransitionToRecovering() )
			Global.PlayHit();
	}

	//-------------------------------------------------------------------------
		
	event UnTouch( Actor Other )
	{
		if( Other == ControllerEnemy )
		{
			GotoState(DefaultState);
		}
	}

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

	event Tick( float DeltaTime )
	{
		local bool bDigesting;

		Global.Tick( DeltaTime );

		if( ControllerEnemy != None && CanGrab( ControllerEnemy ) )
		{
			// damage enemy
			//2002.12.10 (mdf) quick fix for killer sprouts not dealing with walking NPCs very well -- kill 'em right away
			if( !ControllerEnemy.bIsRealPlayer && U2Pawn(ControllerEnemy).default.MovementPhysics == PHYS_Walking )
				DamageAmount = ControllerEnemy.Health - ControllerEnemy.GibMaybeHealth;
			else
				DamageAmount = DamageEnemyRate*DeltaTime;

			// more rapid damage once enemy reeled in
			bDigesting = ControllerEnemy.Location.Z - ControllerEnemy.CollisionHeight <= Pawn.Location.Z + CollisionHeight + 2.0; // NOTE: 2.0 = small fudge factor
			if( bDigesting )
				DamageAmount *= ReeledInDamageMultiplier;

			if( DamageAmount >= 1.0 )
			{
				if( bDigesting )
					ControllerEnemy.TakeDamage( int(DamageAmount), Pawn, ControllerEnemy.Location, vect(0,0,0), class'DamageTypeBiological' ); // tbd: switch to continuous pain yell (similar to when getting toasted by FT)? class'Chemical'?)
				else
					ControllerEnemy.TakeDamage( int(DamageAmount), Pawn, ControllerEnemy.Location, vect(0,0,0), class'DamageTypePhysical' );

				DamageAmount -= int(DamageAmount);

				if( ControllerEnemy == None || ControllerEnemy.bDeleteMe ) // note: call to TakeDamage may have resulted in enemy being cleared
				{
					GotoState(DefaultState);
				}
			}	

			// slowly draw towards center
			if( ControllerEnemy != None )
				ControllerEnemy.Velocity = Normal( Pawn.Location - ControllerEnemy.Location ) * (ReelInSpeed/FClamp( ControllerEnemy.Mass, 25.0, 100.0 ) );
		}
		else
		{
			GotoState(DefaultState);
		}
	}

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

	event BeginState()
	{
		// "grab" the enemy
		// mdf-tbd: this stuff may need work -- is there a simpler way to disable
		// movement for Pawns without needing to worry about physics etc.?
		LicenseeController(ControllerEnemy.Controller).Freeze();
		ControllerEnemy.SetPhysics( PHYS_Flying );
		Enable( Event_Tick );

		Pawn.MeshAgentSetInputCurValue('Mode', 'Melee');
	}

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

	event EndState()
	{
		// "ungrab" the enemy
		if( ControllerEnemy != None && LicenseeController(ControllerEnemy.Controller) != None )
		{
			// mdf-tbd: this stuff needs work...
			LicenseeController(ControllerEnemy.Controller).UnFreeze();
		}
		#debug   SetControllerEnemy( None, GetContext() );
		#release SetControllerEnemy( None );
		DamageAmount = 0.0;
	}

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

@ BeginLabel:
	Sleep( 0.1 );
	Stop;
} //KSGrabbingState

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

state @ KSRecoveringState
{
	//-------------------------------------------------------------------------

	function bool ShouldTransitionToRecovering()
	{
		return false;
	}

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

	event Tick( float DeltaTime )
	{
		Global.Tick( DeltaTime );

		if( Pawn.Health >= HealthydHealthLevel*Pawn.default.Health )
		{
			GotoState( DefaultState );
		}
	}

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

	event BeginState()
	{
		Pawn.MeshAgentSetInputCurValue( 'Mode', 'Recover' );
	}

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

@ BeginLabel:
	#debug   SetControllerEnemy( None, GetContext() );
	#release SetControllerEnemy( None );
	Stop;
} //KSRecoveringState

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

state @ KSWaitingState
{
	//-------------------------------------------------------------------------

	event Touch( Actor Other )
	{
		if( !ClassIsChildOf( Other.Class, Pawn.Class ) ) // don't react to same class
		{
			if( VSize(Other.Velocity) <= MaxGrabSpeed && Other.CollisionHeight >= MinGrabHeight && Other.CollisionRadius >= MinGrabRadius )
			{
				if( ValidPawn( Pawn(Other) ) && LicenseeController(Pawn(Other).Controller) != None )
				{
					#debug   SetControllerEnemy( Pawn(Other), GetContext() );
					#release SetControllerEnemy( Pawn(Other) );
					GotoState( KSAlertState );
				}
				else
				{
					// react to anything else (e.g. projectiles) without trying to grab it
					Pawn.MeshAgentCallAction('IdleToMelee');
				}
			}
		}
	}

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

	event BeginState()
	{
		#debug   SetControllerEnemy( None, GetContext() );
		#release SetControllerEnemy( None );
		Pawn.MeshAgentSetInputCurValue('Mode', 'Idle');
	}
} //KSWaitingState

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

defaultproperties
{
	MaxGrabSpeed=2000.000000
	HealthydHealthLevel=0.800000
	InjuredHealthLevel=0.600000
	DamageEnemyRate=10.000000
	ReeledInDamageMultiplier=3.000000
	RecoverHealthRate=25.000000
	ReelInSpeed=1000.000000
	DefaultState='KSWaiting'
     UseReticleOnEvents(0)="UseReticleText"
     UseReticleOnEvents(1)="UseReticleCorners"
     UseReticleOnEvents(2)="UseReticleTopBars"
     ProximityReticleOnEvents(0)="ProximityReticleCorners"
     ProximityReticleOnEvents(1)="ProximityReticleTopBars"
}