U2XMP.DeployedUnit

//=============================================================================
// $Workfile: DeployedUnit.uc $
// Created By: Mark Poesch
// Created On: 7/2/2001
// $Author: Mfox $
// $Date: 1/29/03 4:25p $
// $Revision: 68 $
//=============================================================================
class DeployedUnit extends StationaryPawn
	abstract;

#exec OBJ LOAD File=..\System\ParticleRes\Impact_Metal_AR.u
#exec OBJ LOAD File=..\Textures\XMPT.utx
#exec OBJ LOAD File=..\StaticMeshes\XMPM.usx
#exec OBJ LOAD File=..\Sounds\U2XMPA.uax

const NotifyDeployedTimerName = 'NotifyDeployedTimer';
const DecayingState = 'Decaying';

var() class<Pickup>	PickupClass;
var() ParticleSalamander ExplosionEffect;
var() ParticleGenerator ParticleHitEffect;		// The effect to spawn when an impact happens
var() sound			ExplodeSound;
var() sound			ShutdownSound;
var() sound			DestroyedAlertSound;
var() sound			DisabledSound;
var() sound			ReEnabledSound;
var() sound			DeploySound;
var() sound			AmbientNoiseSound;
var() localized string	Description;
var() float			DisableTime;				// Number of seconds the unit remains disabled.
var() float			CheckIntersectingActorsInterval;	// How frequently the unit checks for any intersecting actors while disabled.
var() float			CheckIntersectingRadius;	// The radius the unit checks for intersecting actors while disabled.
var() protected bool	bEnabled;
var() Shader		DisabledSkin;				// Skin/Shader to use when unit is Disabled.
var() array<Mesh>	CarcassMesh;				// Mesh to spawn when unit is destroyed.
var protected bool	bActive;					// Unit becomes active when it has eventLanded() and is on.
var	protected bool	bDeployed;					// Unit is deployed through NotifyDeployed()
var private float	LandedNotifyDeployedDelay;
var float			StartTime;					// When the unit is first blocked from becoming re-enabled.
var bool bInitialized;
var array<Pawn> EncroachedPawns;
//var float			DestroyIntersectingUnitTime;// How long the unit can remain disabled due to an intersecting actor before being destroyed.

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

const FUDGEVERT				= 50.0;
const FUDGEHORZ				= 50.0;

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

function bool IsActive() { return bActive; }

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

function bool IsDeployed() { return bDeployed; }

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

function bool IsEnabled() { return bEnabled; }

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

function SetActive( bool bVal ) { bActive = bVal; }

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

function SetDeployed( bool bVal ) { bDeployed = bVal; }

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

function SetEnabled( bool bVal ) { bEnabled = bVal; }

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

function Trigger( Actor Other, Pawn EventInstigator, optional name EventName )
{
	if( bEnabled )
	{
		//DM( "XXX " $ Self $ " bEnabled set to FALSE" );
		SetEnabled( false );
	}
	else
	{
		//DM( "OOO " $ Self $ " bEnabled set to TRUE" );
		SetEnabled( true );
	}
}

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

function OnUse( Actor Other )
{
	// units are returned to the player's inventory when used if on the same team,
	// if not on the same team but bFriendlyToPlayerTeam, they are disabled.	
	//DM( "*** " $ Self $ " Team = " $ GetTeam() $ " " $ Other $ ".Team = " $ Controller(Other).Pawn.GetTeam() );
	if( SameTeam( Controller(Other).Pawn, , true ) )
		ShutDownDeployedUnit( false, Controller(Other).Pawn );
	else
		DisableUnit();
}

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

function OnUnuse( Actor Other )
{
	// Nothing, I don't think...
}

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

function bool IsUsable( Actor Other )
{
	// 2003.01.29 (mdf) fix for adding timers (etc.) to invalid (e.g. deleted) actors
	if( bDeleteMe )
		return false;

	// if a scripted NPC tries to use a unit, let him, even if the unit is disabled.
	if( bEnabled || U2NPCController(Other).UnderScriptControl() )
	{
		if( Controller(Other) != None && SameTeam( Controller(Other).Pawn ) )
			return true;
	}
	return false;
}

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

function string GetDescription()
{
	return Description;
}

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

function Initialize( bool AltActivate )
{
	PlaySound( DeploySound, SLOT_None );
	CheckEncroachers();
	bInitialized = true;
}

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

function SetSkin( bool bDisabledSkin );

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

function DisableUnit()
{
	// 2003.01.29 (mdf) fix for adding timers (etc.) to invalid (e.g. deleted) actors
	if( bDeleteMe )
		return;

	//DM( "@@@ DisableUnit Disabling " $ Self );
	// Turn off collision
	SetCollision( false, false, false );
	// Disable
	SetEnabled( false );
	// Disabled skin
	SetSkin( true );
	if( DisabledSound != None )
		PlaySound( DisabledSound, SLOT_None );
	AddTimer( 'ReEnableUnit', DisableTime, false );
}

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

function ReEnableUnit()
{
	local actor A;
	local bool  bNoIntersections;

	// 2003.01.29 (mdf) fix for adding timers (etc.) to invalid (e.g. deleted) actors
	if( bDeleteMe )
		return;
			
	A = CheckIntersecting();
	//DM( "  @@@ A = " $ A $ " DestroyIntersectingUnitTime = " $ DestroyIntersectingUnitTime );
	if( A != None )
	{
		if( StartTime == 0 )
			StartTime = Level.TimeSeconds;
		//DM( "  @@@ " $ Level.TimeSeconds - StartTime $ " > " $ DestroyIntersectingUnitTime );
		//if( Level.TimeSeconds - StartTime > DestroyIntersectingUnitTime )
		//	ShutDownDeployedUnit( true );
		//DM( "  @@@ " $ Self $ " is intersecting with " $ A $ ", going into limbo..." );
		AddTimer( 'ReEnableUnit', CheckIntersectingActorsInterval, false );
		bNoIntersections = false;
	}
	else
		bNoIntersections = true;

	if( bNoIntersections )
	{
		//DM( "@@@ ReEnabling " $ Self );
		StartTime = 0;
		SetCollision( true, true, true );
		CheckForEncroachingPawns();
		// ReEnable
		SetEnabled( true );
		// Standard skin
		SetSkin( false );
		if( ReEnabledSound != None )
			PlaySound( ReEnabledSound, SLOT_None );
	}
}

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

function actor CheckIntersecting()
{
	local actor A;

	foreach VisibleCollidingActors( class'Actor', A, CheckIntersectingRadius )
	{
		
		if( Pawn(A) != None || DeployedUnit(A) != None /*|| Mover(A) != None*/ )
		{
			//DM( "  @@@ CollisionRadiusDistance = " $ A.CollisionRadius+CollisionRadius $ " Actual distance = " $ VSize( A.Location - Location ) $ " Evaluates = " $ (A.CollisionRadius+CollisionRadius) > VSize( A.Location - Location ) );
			//DM( "  @@@ CollisionHeightDistance = " $ A.CollisionHeight+CollisionHeight $ " Actual distance = " $ VSize( A.Location - Location ) $ " Evaluates = " $ (A.CollisionHeight+CollisionHeight) > VSize( A.Location - Location ) );
			if( ( ((A.CollisionRadius+CollisionRadius) > VSize( A.Location - Location ))
				|| ((A.CollisionHeight+CollisionHeight) > VSize( A.Location - Location )) )
				&& A != Self )
					return A;
		}
	}

	return None;
}

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

function KillInventory()
{
	local Inventory Inv,Next;

	if( Inventory == None )
		return;
	Inv = Inventory;
	while ( Inv != None )
	{
		Next = Inv.Inventory;
		Inv.Destroy();
		Inv = Next;
	}	
	Weapon = None;
	Inventory = None;
}

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

function ShutDownDeployedUnit( bool bDestroyed, optional Pawn P )
{
	local Inventory Inv;

	ModifyPaths( false );

	// if being used and turned into a pickup
	if( !bDestroyed )
	{
		// Add one of these to the player's inventory
		if( Health > 0 )
			PlaySound( ShutdownSound, SLOT_None );
		//else
		//	DM( "*** WARNING *** Health of " $ Self $ " is <= 0!" );
		// Put the item in inventory
		class'UtilGame'.static.GiveInventoryClass( P, PickupClass.default.InventoryType );
		// Give player a pickup message
		if( P != None && P.IsRealPlayer() )
			class'UIConsole'.static.BroadcastStatusMessage( Self, PickupClass.default.PickupMessage );
		Inv = P.FindInventoryType( PickupClass.default.InventoryType );
		// Record health of item to be transferred to inventory
		if( Inv != None )
			DeployableInventory(Inv).UpdateInventoryHealth( Health );
		// Destroy myself
		if( !bDeleteMe )
			KillInventory();
		Controller.PawnDied();
		Destroy();
	}
	else	// else, being destroyed
	{		
		//DM( "!!! " $ Self $ " CarcassMesh.Length = " $ CarcassMesh.Length );
		if( CarcassMesh.Length > 0 && Health <= 0 )
		{
			Mesh = CarcassMesh[ Rand(CarcassMesh.Length) ];
			GotoState( DecayingState );
		}
		else
		{
			if( Health > 0 )
				PlaySound( ShutdownSound, SLOT_None );
			if( !bDeleteMe )
				KillInventory();
			Controller.PawnDied();
			Destroy();
		}
	}
}

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

state @ DecayingState
{
ignores Bump, HitWall, HeadVolumeChange, PhysicsVolumeChange, BeginFalling, BreathTimer;

	event Timer()
	{
		if ( !PlayerCanSeeMe() )
			Destroy();
		else
			SetTimer(2.0, false);	
	}

	event BeginState()
	{
		if ( bTearOff && (Level.NetMode == NM_DedicatedServer) )
			LifeSpan = 1.0;
		else
			SetTimer(18.0, false);
		bInvulnerableBody = true;
		if ( Controller != None )
		{
			//NEW (mdf) -- PawnDied should be called for non players too -- and let PawnDied decided whether to destroy the Controller
			// Not calling this also means that the Pawn isn't correctly unpossessed?
			Controller.PawnDied();
		}
		SetEnabled( false );
		//DM( "@@@ Decaying.BeginState Disabling " $ Self );
		SetCollision(false,false,false);
		KillInventory();
	}

Begin:
//	DM( "@@@-------------------------- Starting DecayingState" );
	Sleep(0.2);
	bInvulnerableBody = false;
}

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

function NotifyDeployed()
{
	ModifyPaths( true );
}

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

function TakeDamage( int Damage, Pawn instigatedBy, vector HitLocation, vector momentum, class<DamageType> DamageType)
{
	local ParticleGenerator Particles;

	if( Health > 0 )
	{
		if( DamageFilterClass? ) 
			DamageFilterClass.static.ApplyFilter( Damage, momentum, DamageType );

		if( Damage > 0 )
		{			
			Health -= Damage;
			if( ParticleHitEffect != None )
			{
				Particles = class'ParticleGenerator'.static.CreateNew( Self, ParticleHitEffect, HitLocation );
				Particles.Trigger( Self, Instigator );
				Particles.ParticleLifeSpan = Particles.GetMaxLifeSpan() + Particles.TimerDuration;
			}
		}
	}
	if( Health <= 0 )
	{
		AmbientSound = None;
		if( DestroyedAlertSound != None )
			PlaySound( DestroyedAlertSound, SLOT_None );	
		TriggerDeathEvent( Self, instigatedBy );
		ShutDownDeployedUnit( true );
		Explode();
	}
}

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

function Explode()
{
	local ParticleSalamander Explosion;

	if( Level.NetMode != NM_DedicatedServer )
	{
		Explosion = ParticleSalamander( class'ParticleGenerator'.static.CreateNew( self, ExplosionEffect, Location ) );
		Explosion.SetRotation( Rotation );
		Explosion.Trigger( Self, Instigator );
		Explosion.ParticleLifeSpan = 5.0;
	}

	PlaySound( ExplodeSound, SLOT_None );
}

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

function NotifyDeployedTimer()
{
	// sanity checks
	if( !bDeleteMe && bActive && bDeployed )
		NotifyDeployed();
}

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

event LandedEx( CheckResult Hit )
{
	// 2003.01.29 (mdf) fix for adding timers (etc.) to invalid (e.g. deleted) actors
	if( bDeleteMe )
		return;
	
	bActive = true;
	bDeployed = true;

	// wait until location "settles down" before sending out NotifyDeployed
	AddTimer( NotifyDeployedTimerName, LandedNotifyDeployedDelay, false );
}

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

event Destroyed()
{
	RemoveAllTimers(); // in case timer(s) somehow still active
	Super.Destroyed();
}

//-----------------------------------------------------------------------------
// AI
//-----------------------------------------------------------------------------

function CheckEncroacher( Pawn P )
{
	if( !P.bDeleteMe && P.Health > -9999 && !SameTeam( P ) && !P.IsRealPlayer() )
		P.TakeDamage( 10000, None, P.Location, vect(0,0,0), class'Crushed' );
}

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

function CheckForEncroachingPawns()
{
	local Pawn P;
	
	for( P=Level.PawnList; P!=None; P=P.NextPawn )
	{
		if( VSize( P.Location - Location ) < (class'FieldGenerator'.default.LinkRadius + 50.0) )
		{
			if( class'Util'.static.DoActorCylindersIntersect( Self, P ) )
				CheckEncroacher( P );
		}
	}
}

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

function CheckEncroachers()
{
	local int ii;
	
	for( ii=0; ii<EncroachedPawns.Length; ii++ )
		CheckEncroacher( EncroachedPawns[ ii ] );
	EncroachedPawns.Length = 0;
}

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

event bool EncroachingOn( Actor Other )
{
	if( Pawn(Other) != None )
	{
		if( bInitialized )
			CheckEncroacher( Pawn(Other) );
		else
			EncroachedPawns[ EncroachedPawns.Length ] = Pawn(Other);
	}
		
	return false;
}

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

static function bool DisableForBump( Pawn P, Actor Other )
{
	local bool bResult;
	
	bResult = ( Pawn(Other) != None && 
				!Other.IsRealPlayer() && 
				P.SameTeam( Pawn(Other) ) &&
				StationaryPawn(Other) == None &&
				Pawn(Other).Controller != None &&
				Pawn(Other).Controller.ControllerEnemy == None ); 
				/* 2002.12.12 remove because NPC might be using MoveToPoint e.g. to adjust 
				   from wall or while wandering and in these cases we want the wall to 
				   be disabled (wandering should avoid walls though)
				Pawn(Other).Controller.MoveTarget != None );
				*/
				
	//P.DMT( "DisableForBump returning " $ bResult $ " P: " $ P $ " Other: " $ Other $ " MoveTarget: " $ Pawn(Other).Controller.MoveTarget $ " Enemy: " $ Pawn(Other).Controller.ControllerEnemy );
	
	return bResult;

/*tbd:
{
	local int ii;
	local Actor HitActor;
	local vector HitLocation, HitNormal;

	if( !bSpecialEnemy )
		return true; // should always consider attacking

	if( AttackingController.Pawn == None )
		return false; // invalid attacker
		
	if( AttackingController.ControllerEnemy != None && StationaryPawn(AttackingController.ControllerEnemy) == None )
		return false; // has a non-stationary pawn enemy currently

	if( AttackingController.Pawn.Physics != PHYS_Walking )
		return false; // wait until attacker lands?
		
	if( VSize( AttackingController.Pawn.Location - Location ) > 2000 )
		return false; // too far away to worry about

	// if attacker has no goal (e.g. wandering), can attack XMP item
	if( AttackingController.MoveTarget == None )
		return true;

	// if NPC's current direction will send it through item (or part of it), attack it
	HitActor = AttackingController.Pawn.Trace( HitLocation, HitNormal, AttackingController.MoveTarget.Location, AttackingController.Pawn.Location, true );
	if( HitSelf( HitActor ) )
		return true;
		
	for( ii=0; ii<RouteCacheDepthCheck-1; ii++ )
		if( PathTraverses( NavigationPoint(AttackingController.RouteCache[ ii ]), NavigationPoint(AttackingController.RouteCache[ ii+1 ]) ) )
			return true;
					
	return false;
}
*/			
			/*mdf-tbd:			
			U2NPCController(Pawn(Other).Controller) != None &&
			U2NPCController(Pawn(Other).Controller).UnderScriptControl() );
			*/
}

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

function SpecialBumpHandling( Actor Other )
{
	if( DisableForBump( Self, Other ) )
		DisableUnit();
}

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

event Bump( Actor Other )
{
	Super.Bump( Other );
	SpecialBumpHandling( Other );
}

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

function ModifyPaths( bool bEnabled )
{
	local vector VectorHorz1, VectorHorz2;
	local int BlockedExtraCost;
	local array<vector> EndPoints;
	local array<vector> ExpandedEndPoints;
	local array<Face> Faces;
	local bool bAffectedPaths;
	
	// determine the endpoints to use as the blocking poly
	EndPoints.Length = 2;
	EndPoints[ 0 ] = Location	+ vect(0,0,1) * CollisionHeight;
	EndPoints[ 1 ] = Location	- vect(0,0,1) * CollisionHeight;

	// now increase the size of the blocking poly to allow for collision sizes etc.?
	VectorHorz1 = vector(Rotation);

	ExpandedEndPoints.Length = 4;
	ExpandedEndPoints[ 0 ] = EndPoints[ 0 ] + VectorHorz1 * (CollisionRadius + FUDGEHORZ) + vect(0,0,1)*FUDGEVERT;
	ExpandedEndPoints[ 1 ] = EndPoints[ 1 ] - VectorHorz1 * (CollisionRadius + FUDGEHORZ) - vect(0,0,1)*FUDGEVERT;
	ExpandedEndPoints[ 2 ] = EndPoints[ 1 ] + VectorHorz1 * (CollisionRadius + FUDGEHORZ) - vect(0,0,1)*FUDGEVERT;
	ExpandedEndPoints[ 3 ] = EndPoints[ 0 ] - VectorHorz1 * (CollisionRadius + FUDGEHORZ) + vect(0,0,1)*FUDGEVERT;

	VectorHorz2 = Normal( (ExpandedEndPoints[ 0 ] - ExpandedEndPoints[ 2 ]) cross (ExpandedEndPoints[ 0 ] - ExpandedEndPoints[ 3 ]) );

	Faces.Length = 6;
	Faces[ 0 ].Points.Length = 4;
	Faces[ 0 ].Points[ 0 ] = ExpandedEndPoints[ 0 ] + VectorHorz2 * (CollisionRadius + FUDGEHORZ);
	Faces[ 0 ].Points[ 1 ] = ExpandedEndPoints[ 2 ] + VectorHorz2 * (CollisionRadius + FUDGEHORZ);
	Faces[ 0 ].Points[ 2 ] = ExpandedEndPoints[ 1 ] + VectorHorz2 * (CollisionRadius + FUDGEHORZ);
	Faces[ 0 ].Points[ 3 ] = ExpandedEndPoints[ 3 ] + VectorHorz2 * (CollisionRadius + FUDGEHORZ);

	Faces[ 1 ].Points.Length = 4;
	Faces[ 1 ].Points[ 0 ] = ExpandedEndPoints[ 0 ] - VectorHorz2 * (CollisionRadius + FUDGEHORZ);
	Faces[ 1 ].Points[ 1 ] = ExpandedEndPoints[ 2 ] - VectorHorz2 * (CollisionRadius + FUDGEHORZ);
	Faces[ 1 ].Points[ 2 ] = ExpandedEndPoints[ 1 ] - VectorHorz2 * (CollisionRadius + FUDGEHORZ);
	Faces[ 1 ].Points[ 3 ] = ExpandedEndPoints[ 3 ] - VectorHorz2 * (CollisionRadius + FUDGEHORZ);

	Faces[ 2 ].Points.Length = 4;
	Faces[ 2 ].Points[ 0 ] = Faces[0].Points[ 0 ];
	Faces[ 2 ].Points[ 1 ] = Faces[1].Points[ 0 ];
	Faces[ 2 ].Points[ 2 ] = Faces[1].Points[ 1 ];
	Faces[ 2 ].Points[ 3 ] = Faces[0].Points[ 1 ];

	Faces[ 3 ].Points.Length = 4;
	Faces[ 3 ].Points[ 0 ] = Faces[0].Points[ 3 ];
	Faces[ 3 ].Points[ 1 ] = Faces[1].Points[ 3 ];
	Faces[ 3 ].Points[ 2 ] = Faces[1].Points[ 2 ];
	Faces[ 3 ].Points[ 3 ] = Faces[0].Points[ 2 ];

	Faces[ 4 ].Points.Length = 4;
	Faces[ 4 ].Points[ 0 ] = Faces[0].Points[ 1 ];
	Faces[ 4 ].Points[ 1 ] = Faces[1].Points[ 1 ];
	Faces[ 4 ].Points[ 2 ] = Faces[1].Points[ 2 ];
	Faces[ 4 ].Points[ 3 ] = Faces[0].Points[ 2 ];

	Faces[ 5 ].Points.Length = 4;
	Faces[ 5 ].Points[ 0 ] = Faces[0].Points[ 0 ];
	Faces[ 5 ].Points[ 1 ] = Faces[1].Points[ 0 ];
	Faces[ 5 ].Points[ 2 ] = Faces[1].Points[ 3 ];
	Faces[ 5 ].Points[ 3 ] = Faces[0].Points[ 3 ];

	/*
	AddLine( Faces[0].Points[0], Faces[0].Points[2], ColorOrange() );
	AddLine( Faces[0].Points[2], Faces[0].Points[1], ColorOrange() );
	AddLine( Faces[0].Points[1], Faces[0].Points[3], ColorOrange() );
	AddLine( Faces[0].Points[3], Faces[0].Points[0], ColorOrange() );

	AddLine( Faces[1].Points[0], Faces[1].Points[2], ColorOrange() );
	AddLine( Faces[1].Points[2], Faces[1].Points[1], ColorOrange() );
	AddLine( Faces[1].Points[1], Faces[1].Points[3], ColorOrange() );
	AddLine( Faces[1].Points[3], Faces[1].Points[0], ColorOrange() );

	AddLine( Faces[0].Points[0], Faces[1].Points[0], ColorOrange() );
	AddLine( Faces[0].Points[2], Faces[1].Points[2], ColorOrange() );
	AddLine( Faces[0].Points[1], Faces[1].Points[1], ColorOrange() );
	AddLine( Faces[0].Points[3], Faces[1].Points[3], ColorOrange() );
	*/
	
	if( bEnabled )
		BlockedExtraCost = 3*LevelInfo.PathsMaxDist;
	else
		BlockedExtraCost = -3*LevelInfo.PathsMaxDist;

	bAffectedPaths = class'UtilGame'.static.UpdatePathsForBlockingFaces( Self, Faces, BlockedExtraCost, GetTeam(), ModifiedReachSpecs );
}

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

defaultproperties
{
	ParticleHitEffect=ParticleSalamander'Impact_Metal_AR.ParticleSalamander0'
	DisableTime=3.000000
	CheckIntersectingActorsInterval=0.500000
	CheckIntersectingRadius=100.000000
	bActive=true
	LandedNotifyDeployedDelay=0.500000
	bSpecialCollider=true
	AnimationControllerClass=None
	DamageFilterClass=Class'U2XMP.DamageFilterDeployed'
	Health=1000
	TeamNumber=255
	bActorShadows=false
	bMustFace=false
	bCanMantle=false
     UseReticleOnEvents(0)="UseReticleText"
     UseReticleOnEvents(1)="UseReticleCorners"
     UseReticleOnEvents(2)="UseReticleTopBars"
     UseReticleOnEvents(3)="UseReticleHealthBar"
     ProximityReticleOnEvents(0)="ProximityReticleCorners"
     ProximityReticleOnEvents(1)="ProximityReticleSideBars"
}