U2XMP.ForceWall

//=============================================================================
// $Author: Mfox $
// $Date: 1/29/03 4:25p $
// $Revision: 46 $
// Description: This is the barrier summoned between FieldGenerators to create
// the wall effect.
//=============================================================================

class ForceWall extends StationaryPawn;

#exec OBJ LOAD File=..\Sounds\U2XMPA.uax

struct WallState
{
	var() color Color;
};

struct WallTransition
{
	var() WallState Start;
	var() WallState End;
	var() Name		EndFunction;
	var() float		Time;
};

var	  WallState					CurrentState;
var() WallState					DefaultState;
var	  WallTransition			CurrentTransition;
var() WallTransition			BeamHitTransition;
var() WallTransition			BeamKillTransition;
var() WallState					DisabledState;
var() sound						HitSound;
var() sound						ForceWallAmbientSound;
var() int						ColliderAmbientSoundOffset;	// Every X colliders will have an ambient sound.
var() float						DamageTransferPct;
var	  bool						bEnabled;

var class<PulseLineGenerator>	BeamClass;		// The class of the beams used to create the wall's visual effect
var int							BeamCount;
var float						ForceWallWidth;
var Actor						StartActor;
var Actor						EndActor;
var	PulseLineGenerator			Beams;
var float						ElapsedTime;
var int							DamageAccumulator;
var int							HitCount;

var ForceWallCollider			FWCStart;

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

const FUDGEVERT				= 50.0;
const FUDGEHORZ				= 50.0;

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

simulated event PostBeginPlay()
{
	Super.PostBeginPlay();
	BeamHitTransition.End = DefaultState;
	CurrentTransition = BeamHitTransition;
}

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

function bool IsEnabled() { return bEnabled; }

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

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

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

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

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

// Iterate through and Destroy all Beams
simulated function ShutDownForceWall()
{
	local int i;
	local ForceWallCollider Walker;
	local ForceWallCollider WalkerNext;

	Beams.Destroy();
	
	if( FWCStart != None )
	{
		ModifyPaths( false );

		Walker = FWCStart;
		while( Walker.Next != None )
		{
			WalkerNext = Walker.Next;
			Walker.Destroy();
			Walker = WalkerNext;
		}
		Walker.Destroy();
		FWCStart = None;
	}

	Destroy();
}

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

simulated function CreateVisualEffect( float FieldHeight, float BottomOffset )
{
	local float BeamSpacing;
	local float BeamVertIncrement;
	local int	i;

	BeamSpacing = (FieldHeight*2)/(BeamCount-1);
	Beams = Spawn( BeamClass );
	for( i=0; i<BeamCount; i++ )
	{
		BeamVertIncrement = ((-1*(FieldHeight))+BottomOffset)+(BeamSpacing*i);
		Beams.AddConnection(	StartActor.Location + vect(0,0,1)*BeamVertIncrement,
								EndActor.Location + vect(0,0,1)*BeamVertIncrement );
	}
	SetState( DefaultState );
}

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

simulated function CreateColliders( float FieldHeight, float BottomOffset, float CollisionOffset )
{
	local ForceWallCollider CurrentFWC;
	local ForceWallCollider NextFWC;
	local float				WallLength;
	local int				ColliderAmbientCount;
	local float				ColliderIncrementRadius;
	local vector			StartLocation, EndLocation, WallVector;
	local vector			CurrentLocation;
	local int				i, NumColliders;
	
	ColliderAmbientCount = 1;

	WallVector = Normal( EndActor.Location - StartActor.Location );

	// build wall partially overlapping with endpoints
	StartLocation = StartActor.Location + vect(0,0,1)*BottomOffset;
	EndLocation = EndActor.Location + vect(0,0,1)*BottomOffset;
	
	WallLength = VSize( StartLocation - EndLocation );

	// allow for some overlap (or traces go through the "cracks")
	// unfortunately this will mean even more colliders...
	ColliderIncrementRadius = ForceWallWidth*0.80;
	
	// number of colliders in wall
	NumColliders = int(WallLength / ColliderIncrementRadius) + 1;

	// recompute collision radius based on actual number of colliders
	ColliderIncrementRadius = WallLength / NumColliders;

	CurrentLocation = StartLocation + (StartActor.CollisionRadius - (ForceWallWidth - ColliderIncrementRadius) / 2)*WallVector;
	for( i=0; i<NumColliders; i++ )
	{
		NextFWC = Spawn( class'ForceWallCollider',,, CurrentLocation );
		
		if( NextFWC != None )
		{			
			// Depending upon whether we've already created a FWC or not, set up the appropriate pointer
			if( CurrentFWC == None )
				FWCStart = NextFWC;
			else
				CurrentFWC.Next = NextFWC;
				
			// Move this new FWC to the Current slot
			CurrentFWC = NextFWC;
			CurrentFWC.SetCollisionSize( ForceWallWidth/2, FieldHeight );
			CurrentFWC.FW = Self;
			CurrentFWC.CheckEncroachers();
		}
		
		// Handle ambient sounds
		if( (++ColliderAmbientCount) % ColliderAmbientSoundOffset == 0 )
			CurrentFWC.AmbientSound = ForceWallAmbientSound;			
			
		// Increment
		CurrentLocation += ColliderIncrementRadius*WallVector;
		
		if( i==0 || i==(NumColliders-1) )
		{
			// disable use traces hitting first and last so field generator hit instead
			NextFWC.bHiddenUsable = false;
		}
	}
	// The last FWC's Next should be None by default
}

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

simulated function InitiateWall( float FieldHeight, 
								 float BottomOffset, 
								 float CollisionOffset, 
								 int inBeamCount, 
								 float inForceWallWidth, 
								 class<PulseLineGenerator> inBeamClass )
{	
	BeamCount = inBeamCount;
	ForceWallWidth = inForceWallWidth;
	BeamClass = inBeamClass;
	SetCollisionSize( ForceWallWidth/2, FieldHeight );
	CreateVisualEffect( FieldHeight, BottomOffset );
	CreateColliders( FieldHeight, BottomOffset, CollisionOffset );	
	default.Health = ((FieldGenerator(StartActor).default.Health+FieldGenerator(EndActor).default.Health)/2) * 3;
	Health = ((FieldGenerator(StartActor).Health+FieldGenerator(EndActor).Health)/2) * 3;
	//DM( "*** " $ Self $ " ((" $ FieldGenerator(StartActor).Health $ "+" $ FieldGenerator(EndActor).Health $ ")/2) * 3 = " $ Health );
	ModifyPaths( true );
	SetEnabled( true );
}

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

simulated function ForceWallKilled()
{
//DM( "*** ForceWallKilled - StartActor = " $ StartActor $ " EndActor = " $ EndActor );
	// Destroy the FieldGenerators that own this ForceWall
	FieldGenerator(StartActor).ShutdownDeployedUnit( true );
	FieldGenerator(EndActor).ShutdownDeployedUnit( true );
	FieldGenerator(StartActor).Explode();
	FieldGenerator(EndActor).Explode();
	FieldGenerator(StartActor).Destroy();
	FieldGenerator(EndActor).Destroy();
}

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

simulated function TakeDamage( int Damage, Pawn instigatedBy, vector hitlocation, vector momentum, class<DamageType> damageType)
{
	DamageAccumulator += Damage;
	HitCount++;
	Enable( 'Tick' );
//DM( "*** TakeDamage - " $ Self $ " Health = " $ Health );
//	if( Health <= 0 )
//		StartTransition( BeamKillTransition );
//	else
//		StartTransition( BeamHitTransition );
}

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

simulated function EnableCollision()
{
	local ForceWallCollider CurrentFWC;

	for( CurrentFWC = FWCStart; CurrentFWC != None; CurrentFWC = CurrentFWC.Next )
	{		
		CurrentFWC.SetCollision( true, true, true );
		CurrentFWC.CheckForEncroachingPawns();
	}
	
	// now handled when FG itself gets bumped?
	//FieldGenerator(StartActor).SetCollision( true, true, true );
	//FieldGenerator(StartActor).CheckForEncroachingPawns();
	//FieldGenerator(EndActor).SetCollision( true, true, true );
	//FieldGenerator(EndActor).CheckForEncroachingPawns();
}

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

simulated function DisableCollision()
{
	local ForceWallCollider CurrentFWC;

	for( CurrentFWC = FWCStart; CurrentFWC != None; CurrentFWC = CurrentFWC.Next )
		CurrentFWC.SetCollision( false, false, false );
	
	// now handled when FG itself gets bumped?
	//FieldGenerator(StartActor).SetCollision( false, false, false );
	//FieldGenerator(EndActor).SetCollision( false, false, false );
}

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

simulated function ReEnableUnit()
{
	// ReEnable collision on FWCs
	EnableCollision();
	// ReEnable
	SetEnabled( true );
	// Set visual change
	BeamHitTransition.End = DefaultState;
	Enable( 'Tick' );
	StartTransition( BeamHitTransition );
	// Play ReEnabled sound
	if( DeployedUnit(StartActor).ReEnabledSound != None )
		PlaySound( DeployedUnit(StartActor).ReEnabledSound, SLOT_None );
}

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

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

	//DM( "@@@ DisableUnit " $ Self );
	
	// Disable collision on FWCs
	DisableCollision();
	// Disable
	SetEnabled( false );
	// Set visual change
	BeamHitTransition.End = DisabledState;
	Enable( 'Tick' );
	StartTransition( BeamHitTransition );
	// Play Disabled sound
	if( DeployedUnit(StartActor).DisabledSound != None )
		PlaySound( DeployedUnit(StartActor).DisabledSound, SLOT_None );
	// Run timer
	AddTimer( 'ReEnableUnit', DeployedUnit(StartActor).DisableTime, false );
}

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

simulated function SetState( WallState State )
{
	CurrentState = State;
	Beams.BeamColor = State.Color;
	Beams.SpriteJointColor = State.Color;
}

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

simulated function StartTransition( WallTransition Transition )
{
	CurrentTransition = Transition;
	ElapsedTime = 0;
	SetState( CurrentTransition.Start );
	//Enable('Tick');
}

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

simulated function EndTransition()
{
//DM( "*** EndTransition - " $ Self $ " EndFunction = " $ CurrentTransition.EndFunction );
	if( CurrentTransition.EndFunction != '' )
	{
//DM( "*** EndTransition - " $ Self );
		CallFunction( CurrentTransition.EndFunction );
	}
	SetState( CurrentTransition.End );
	Disable('Tick');
}

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

simulated function WallState BlendStates( WallState A, WallState B, float Percentage )
{
	local WallState NewState;

	NewState.Color.R = Blend( A.Color.R, B.Color.R, Percentage );
	NewState.Color.G = Blend( A.Color.G, B.Color.G, Percentage );
	NewState.Color.B = Blend( A.Color.B, B.Color.B, Percentage );
	NewState.Color.A = Blend( A.Color.A, B.Color.A, Percentage );

	return NewState;
}

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

simulated function ProgressTransition( float DeltaTime )
{
	local float Percentage;

	ElapsedTime += DeltaTime;
	Percentage = ElapsedTime / CurrentTransition.Time;
	if( Percentage >= 1.0 )
	{
		EndTransition();
		return;
	}
	SetState( BlendStates( CurrentTransition.Start, CurrentTransition.End, Percentage ) );
}

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

simulated event Tick( float DeltaTime )
{
	local int   Damage;
	local float FGDamage;

	Super.Tick( DeltaTime );

	if( HitCount > 0 )
	{
		//DM( "$$$ Health before = " $ Health $ ", Then subtract " $ DamageAccumulator $ "/" $ Min(20, HitCount) );
		Damage = DamageAccumulator/Min(20, HitCount);
		//DM( "*** Tick - " $ Self $ " Damage = " $ Damage );		
		Health -= Damage;
		//DM( "*** Tick - " $ Self $ " Health after = " $ Health );
		if( Health > 0 )
		{
			FGDamage = Damage*DamageTransferPct;
			if( FGDamage > 0 && FGDamage < 1 )
				FGDamage = 1;
			// Deal a fraction of the damage to the connecting FieldGenerators
			//DM( "  $$$ Dealing " $ int(FGDamage) $ " Damage to each FieldGenerator" );
			StartActor.TakeDamage( FGDamage, self, vect(0,0,0), vect(0,0,0), class'DamageTypePhysical' );
			EndActor.TakeDamage( FGDamage, self, vect(0,0,0), vect(0,0,0), class'DamageTypePhysical' );
			StartTransition( BeamHitTransition );
		}
		else
			ForceWallKilled();
		//StartTransition( BeamKillTransition );
			
		//DM( "$$$ After " $ DamageAccumulator/Min(20, HitCount) $ " damage, Health = " $ Health );
		DamageAccumulator = 0;
		HitCount = 0;
	}
	//DM( "Tick" );
	ProgressTransition( DeltaTime );
}

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

function HandleForceWallBump( Actor Other )
{
	if( class'DeployedUnit'.static.DisableForBump( Self, Other ) )
		DisableUnit();
}

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

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

//-----------------------------------------------------------------------------
//!!mdf-tbd: parameterize as much of this as makes sense and move into util?. 
// We increment/decrement bEnabled and/or Cost for reachspecs because these 
// could be affected by multiple walls.

function ModifyPaths( bool bEnabled )
{
	local vector WallVectorHorz1, WallVectorHorz2;
	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 = 4;
	EndPoints[ 0 ] = StartActor.Location	+ vect(0,0,1) * StartActor.CollisionHeight;
	EndPoints[ 1 ] = EndActor.Location		+ vect(0,0,1) * EndActor.CollisionHeight;
	EndPoints[ 2 ] = EndActor.Location		- vect(0,0,1) * EndActor.CollisionHeight;
	EndPoints[ 3 ] = StartActor.Location	- vect(0,0,1) * StartActor.CollisionHeight;

	// now increase the size of the blocking poly to allow for collision sizes etc.?
	WallVectorHorz1 = Normal( EndPoints[ 0 ] - EndPoints[ 1 ] );

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

	WallVectorHorz2 = Normal( (EndPoints[ 0 ] - EndPoints[ 1 ]) cross (EndPoints[ 0 ] - EndPoints[ 3 ]) );

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

	Faces[ 1 ].Points.Length = 4;
	Faces[ 1 ].Points[ 0 ] = ExpandedEndPoints[ 0 ] - WallVectorHorz2 * (StartActor.CollisionRadius + FUDGEHORZ);
	Faces[ 1 ].Points[ 1 ] = ExpandedEndPoints[ 1 ] - WallVectorHorz2 * (StartActor.CollisionRadius + FUDGEHORZ);
	Faces[ 1 ].Points[ 2 ] = ExpandedEndPoints[ 2 ] - WallVectorHorz2 * (StartActor.CollisionRadius + FUDGEHORZ);
	Faces[ 1 ].Points[ 3 ] = ExpandedEndPoints[ 3 ] - WallVectorHorz2 * (StartActor.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 ];
	
	if( bEnabled )
		BlockedExtraCost = 3*LevelInfo.PathsMaxDist;
	else
		BlockedExtraCost = -3*LevelInfo.PathsMaxDist;

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

	/* mdf-tbd: insert paths around wall?
	if( bAffecteedPaths )
	{	
		if( bEnabled  )
		{
			WallVectorHorz1 = Normal( EndActor.Location - StartActor.Location );
			AddPathOffset = class'PathNode'.default.CollisionRadius + StartActor.CollisionRadius;
			class'LevelInfo'.static.AddPathNode( StartActor.Location - WallVectorHorz1*AddPathOffset, false );
			class'LevelInfo'.static.AddPathNode( EndActor.Location + WallVectorHorz1*AddPathOffset, false );

			AddCylinder( StartActor.Location - WallVectorHorz1*AddPathOffset, 50, 50, ColorCyan() );
			AddCylinder( EndActor.Location + WallVectorHorz1*AddPathOffset, 50, 50, ColorCyan() );
		}		
		//!!mdf-tbd: remove paths that were added if wall removed?
		//else
	   	//{
		//}
	}
	*/
}

//-----------------------------------------------------------------------------
// Subclasses can override this if they consist of multiple actors.

function bool HitSelf( Actor HitActor )
{
	local ForceWallCollider Walker;
	
	if( HitActor == Self )
		return true;
		
	for( Walker = FWCStart; Walker != None; Walker = Walker.Next )
		if( HitActor == Walker )
			return true;

	return false;
}

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

defaultproperties
{
	DefaultState=(Color=(B=100,R=255))
	BeamHitTransition=(Start=(Color=(B=255,G=150,R=150)),Time=0.500000)
	BeamKillTransition=(Start=(Color=(B=255,G=255,R=255)),EndFunction=ForceWallKilled,Time=0.500000)
	DisabledState=(Color=(B=100,G=255))
	ForceWallAmbientSound=Sound'U2XMPA.FieldGenerator.ForceWallAmbient'
	ColliderAmbientSoundOffset=8
	DamageTransferPct=0.100000
	bSpecialCollider=true
	bSpecialEnemy=true
	AnimationControllerClass=None
	ControllerClass=Class'U2XMP.StationaryPawnControllerDefensive'
	Physics=PHYS_None
	DrawType=DT_None
	bActorShadows=false
	bCollideActors=false
	bCollideWorld=false
	bBlockActors=false
	bBlockPlayers=false
     UseReticleOnEvents(0)="UseReticleText"
     UseReticleOnEvents(1)="UseReticleCorners"
     UseReticleOnEvents(2)="UseReticleSideBars"
     ProximityReticleOnEvents(0)="ProximityReticleCorners"
     ProximityReticleOnEvents(1)="ProximityReticleSideBars"
}