U2XMP.FieldGenerator

//=============================================================================
// $Workfile: FieldGenerator.uc $
// Created By: Mark Poesch
// Created On: 7/2/2001
// $Author: Sbrown $
// $Date: 12/15/02 0:22 $
// $Revision: 46 $
//=============================================================================
class FieldGenerator extends DeployedUnit
	placeable;

struct FGStruct
{
	var FieldGenerator	FG;
	var ForceWall		FGEffect;
};
var() float				LinkRadius;
var() int				NumPrimaryLinks;
var() int				NumSecondaryLinks;
var() float				TraceTolerance;
var() sound				LinkSound;
var() sound				UnlinkSound;
var() class<PulseLineGenerator>	BeamClass;
// ForceWall Properties
var() int				BeamCount;		// The number of beams
var() float				ForceWallWidth;	// The defined width of the wall
var() float				FieldHeight;
var() float				BottomOffset;

var	  array<FGStruct>	FGLinks;
var   FieldGenerator	CurrentFGChoice;
var   float				CosMinAngle;

var bool bDidShutDownDestroy;	// recursion lockout

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

function Initialize( bool AltActivate )
{
	Super.Initialize( AltActivate );
	// Primary Activation
	if( !AltActivate )
	{
		//DM( "*** " $ Self $ " has been Activated" );
		FGLinks.Length = NumPrimaryLinks;
		Description = Description $ " (" $ NumPrimaryLinks $ ")";
	}
	else	// Secondary Activation
	{
		//DM( "*** " $ Self $ " has been AltActivated" );
		FGLinks.Length = NumSecondaryLinks;
		Description = Description $ " (" $ NumSecondaryLinks $ ")";
	}
}

//-----------------------------------------------------------------------------
// This tests to see if this FG is linked to the FG being passed in as F.

function int IsLinked( FieldGenerator F )
{
	local int i;
	local int Retval;

	Retval = -1;
	for( i=0; i<FGLinks.Length; i++ )
	{
		if( FGLinks[i].FG == F )
		{
			Retval = i;
			break;
		}
	}
	return Retval;
}

//-----------------------------------------------------------------------------
// How many links does this FG have

function int NumLinks()
{
	local int i;
	local int Retval;

	Retval = 0;
	for( i=0; i<FGLinks.Length; i++ )
	{
		if( FGLinks[i].FG != None )
			Retval++;
	}
	return Retval;
}

//-----------------------------------------------------------------------------
// How many free link slots does this FG have?

function int NumFreeSlots()
{
	local int i;
	local int Retval;

	Retval = 0;
	for( i=0; i<FGLinks.Length; i++ )
	{
		if( FGLinks[i].FG == None )
			Retval++;
	}
	return Retval;
}

//-----------------------------------------------------------------------------
// What's the first free link slot?

function int FirstFreeSlot()
{
	local int i;
	local int Retval;

	Retval = -1;
	for( i=0; i<FGLinks.Length; i++ )
	{
		if( FGLinks[i].FG == None )
		{
			Retval = i;
			break;
		}
	}
	return Retval;
}

//-----------------------------------------------------------------------------
// A debugging function to see what's happening on each slot

function OutputLinks()
{
	local int i;

	for( i=0; i<FGLinks.Length; i++ )
	{
		DM( "### " $ Self $ " slot[" $ i $ "].FG = " $ FGLinks[i].FG );
		DM( "### " $ Self $ " slot[" $ i $ "].FGEffect = " $ FGLinks[i].FGEffect );		
	}
}

//-----------------------------------------------------------------------------
// The FG is shutdown. All links are severed, the VerticalBeam is destroyed and,
// if given, a pickup version of the FG is spawned.

function ShutDownDeployedUnit( bool bDestroyed, optional Pawn P )
{
	local int i;

	// Disconnect all links
	for( i=0; i<FGLinks.Length; i++ )
	{
		if( FGLinks[i].FG != None )
		{
			FGLinks[i].FG.Unlink( FGLinks[i].FG.IsLinked( Self ), false );

			Unlink( i, true );
		}
	}

	bDidShutDownDestroy = true;
	Super.ShutDownDeployedUnit( bDestroyed, P );
}

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

event Destroyed()
{
	// make sure force field generator cleaned up if field generators destroyed (e.g. with killactor)
	if( !bDidShutDownDestroy )
		ShutDownDeployedUnit( true );
	
	Super.Destroyed();
}

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

function DisableUnit()
{
	local int i;

	// Disable all links
	for( i=0; i<FGLinks.Length; i++ )
	{
		if( FGLinks[i].FGEffect != None && FGLinks[i].FGEffect.IsEnabled() )
		{
			FGLinks[i].FGEffect.DisableUnit();
		}
	}

	Super.DisableUnit();
}

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

function Trigger( Actor Other, Pawn EventInstigator, optional name EventName )
{
	OnUse( Other );
}

//-----------------------------------------------------------------------------
// Handles the unlinking of the passed in slot and destroying the VerticalBeam
// if necessary.

function Unlink( int UnlinkSlot, bool bDestroyWall )
{
	// Unlinks the given slot
	FGLinks[UnlinkSlot].FG = None;
	if( bDestroyWall )
	{
		FGLinks[UnlinkSlot].FGEffect.ShutDownForceWall();
	}
	PlaySound( UnlinkSound, SLOT_None );
	FGLInks[UnlinkSlot].FGEffect = None;
}

//-----------------------------------------------------------------------------
// Set's the passed in link, sets up creation of the ForceWall, displays effects, 
// and plays sounds.

function MakeLinks( FieldGenerator F, int LinkSlot )
{
	// Set up links
	FGLinks[ LinkSlot ].FG = F;
	F.FGLinks[ F.FirstFreeSlot() ].FG = Self;
	// Create ForceWalls
	Linkup( LinkSlot );
	F.Linkup( F.IsLinked( Self ) );
}

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

function Linkup( int ActiveLink )
{
	CreateField( ActiveLink );
	PlaySound( LinkSound, SLOT_None );
}

//-----------------------------------------------------------------------------
// Spawn's a ForceWall

function CreateField( int ActiveLink )
{
	local int LinkedForceWallIndex;
	local vector ForceWallMidPoint;

	// Find out if the FG being linked to has already built a ForceWall to me
	LinkedForceWallIndex = FGLinks[ActiveLink].FG.ForceWallIndex( Self );
	// if the answer is -1, then no, it hasn't, so build it
	if( LinkedForceWallIndex == -1)
	{
		ForceWallMidPoint = (Location + FGLinks[ActiveLink].FG.Location)/2;
		FGLinks[ActiveLink].FGEffect = Spawn( class'ForceWall', , , ForceWallMidPoint );
		FGLinks[ActiveLink].FGEffect.SetTeam( GetTeam() );
		FGLinks[ActiveLink].FGEffect.bFriendlyToPlayerTeam = bFriendlyToPlayerTeam;
		FGLinks[ActiveLink].FGEffect.StartActor = Self;
		FGLinks[ActiveLink].FGEffect.EndActor = FGLinks[ActiveLink].FG;
		FGLinks[ActiveLink].FGEffect.InitiateWall( FieldHeight, BottomOffset, CollisionRadius, BeamCount, ForceWallWidth, BeamClass );
	}
	else	// else, the FG being linked to does have a wall built to this FG, so just get a reference to the ForceWall
	{
		FGLinks[ActiveLink].FGEffect = FGLinks[ActiveLink].FG.FGLinks[LinkedForceWallIndex].FGEffect;
	}
}

//-----------------------------------------------------------------------------
// This tests to see if the FG I am linked to has already created a ForceWall
// linking to me.

function int ForceWallIndex( FieldGenerator F )
{
	local int i;
	local int Retval;

	Retval = -1;
	for( i=0; i<FGLinks.Length; i++ )
	{
		if( FGLinks[i].FG == F )
		{
			if( FGLinks[i].FGEffect != None )
			{
				Retval = i;
				break;
			}
		}
	}
	return Retval;
}

//-----------------------------------------------------------------------------
// Location of the top of the field wall

function vector GetTopLink( FieldGenerator F )
{
	local vector TopLink;

	TopLink = F.Location;
	TopLink.Z += F.FieldHeight+BottomOffset;

	return TopLink;
}

//-----------------------------------------------------------------------------
// Location of the bottom of the field wall

function vector GetBottomLink( FieldGenerator F )
{
	local vector BottomLink;

	BottomLink = F.Location;
	BottomLink.Z -= FieldHeight-BottomOffset;

	return BottomLink;
}


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

function bool CanConnect( FieldGenerator TraceToFG )
{
	local vector HitLocation, HitNormal, Extent, StartLocation, EndLocation, EdgeVector;
	local vector SideVector;
	local actor HitActor;

	Extent.X = ForceWallWidth/2;
	Extent.Y = ForceWallWidth/2;
	Extent.Z = FieldHeight-TraceTolerance;

	EdgeVector = TraceToFG.Location - Location;
	EdgeVector.Z = 0;
	EdgeVector = Normal( EdgeVector );

	StartLocation = Location + CollisionRadius * EdgeVector;
	StartLocation.Z += BottomOffset;
	EndLocation = TraceToFG.Location - TraceToFG.CollisionRadius * EdgeVector;
	EndLocation.Z += BottomOffset;

/*
SideVector = Normal( (EndLocation - StartLocation) cross vect(0,0,1) );

AddCylinder( StartLocation, Extent.X, Extent.Z, ColorYellow() );

AddLine( StartLocation+vect(0,0,1)*Extent.Z+SideVector*Extent.X, EndLocation+vect(0,0,1)*Extent.Z+SideVector*Extent.X, ColorBlue() );
AddLine( StartLocation+vect(0,0,1)*Extent.Z-SideVector*Extent.X, EndLocation+vect(0,0,1)*Extent.Z-SideVector*Extent.X, ColorBlue() );
AddLine( StartLocation-vect(0,0,1)*Extent.Z+SideVector*Extent.X, EndLocation-vect(0,0,1)*Extent.Z+SideVector*Extent.X, ColorBlue() );
AddLine( StartLocation-vect(0,0,1)*Extent.Z-SideVector*Extent.X, EndLocation-vect(0,0,1)*Extent.Z-SideVector*Extent.X, ColorBlue() );

AddCylinder( EndLocation, Extent.X, Extent.Z, ColorYellow() );
*/

	HitActor = Trace( HitLocation, HitNormal, EndLocation, StartLocation, false, Extent, , TRACE_World | TRACE_Volumes | TRACE_StopAtFirstHit );
	
	//if( HitActor != None && FieldGenerator(HitActor) == None )
	//	DM( "%%% TestConnection between " $ Self $ " and " $ TraceToFG $ " failed. Reason: HitActor = " $ HitActor );
	//if( VSize( HitLocation - TraceToFG.Location ) < VSize( TraceToFG.Location - Location ) )
	//	DM( "%%% TestConnection between " $ Self $ " and " $ TraceToFG $ " failed. Reason: LevelGeometry in the way" );
	
//DM( "*** HitActor = " $ HitActor );
	return ( HitActor == None || HitActor == TraceToFG );
		     //( VSize( HitLocation - TraceToFG.Location ) >= VSize( TraceToFG.Location - Location ) ) || 
			 //( FieldGenerator(HitActor) != None) );
}

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

function bool FilterFG( FieldGenerator FG )
{
	local bool bValid;

	if( FG == Self )
	{
		//DM( "***Self" );
		return true;
	}
	
	if( !FG.bActive )
	{
		//DM( "***bActive" );
		return true;
	}

	if( !FG.bEnabled )
	{
		//DM( "***bEnabled" );
		return true;
	}

	if( FG.TeamNumber != TeamNumber )
	{
		//DM( "***TeamNumber" );
		return true;
	}

	// Check if FG has valid links before calling TestConnection
	if( FG.NumFreeSlots() <= 0 )
	{
		//DM( "*** Slots: " $ FG.NumFreeSlots() );
		return true;
	}

	// Am I already linked to this FG?
	if( IsLinked( FG ) != -1 )
	{
		//DM( "*** IsLinked" );
		return true;
	}

	//assert( FG.IsLinked( Self ) == -1 );

	return !CanConnect( FG );
}

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

function bool AnglesOK( FieldGenerator SourceFG, FieldGenerator TargetFG )
{
	local vector ExistingVector, PossibleVector;
	local bool bAngleOK;
	local int i;
			
	PossibleVector = TargetFG.Location - SourceFG.Location;
	PossibleVector.Z = 0;
	PossibleVector = Normal( PossibleVector );

	bAngleOK = true;
	for( i=0; i<SourceFG.FGLinks.Length; i++ )
	{
		if( SourceFG.FGLinks[ i ].FG != None )
		{
			ExistingVector = SourceFG.FGLinks[ i ].FG.Location - SourceFG.Location;
			ExistingVector.Z = 0;
			ExistingVector = Normal( ExistingVector );
			//DM( "CosAngle: " $ ExistingVector dot PossibleVector );
			//DM( "Angle:    " $ Acos(ExistingVector dot PossibleVector) );
			if( (ExistingVector dot PossibleVector) > CosMinAngle )
			{
				bAngleOK = false;
				break;
			}
		}
	}
	
	return bAngleOK;
}

/*-----------------------------------------------------------------------------
Uses the ActorTypes list to search for FGs in range. Performs a few tests on
the FGs found and calls FindValidLink() to determine validity of the FG. If it
is found to be valid, ScanArea returns an FG, otherwise it returns None.
*/

function ScanArea()
{
	local int i,j;
	local FieldGenerator FG;
	local array<FieldGenerator> SortedFGs;
	local int CurrentCandidate;
	local vector CandidateVector;
	local float FGDistance;

	foreach VisibleCollidingActors( class'FieldGenerator', FG, LinkRadius )
	{
		if( !FilterFG( FG ) )
		{
			//DM( "Adding " $ FG );
			// insert into array with closest first
			FGDistance = VSize(FG.Location - Location);

			i = 0;
			while( i < SortedFGs.Length && VSize( SortedFGs[ i ].Location - Location ) < FGDistance )
				i++;

			// insert at i after moving everything else down
			SortedFGs.Length = SortedFGs.Length + 1;
			for( j=SortedFGs.Length-2; j>=i; j-- )
				SortedFGs[ j+1 ] = SortedFGs[ j ];
			SortedFGs[ i ] = FG;			
		}
	}

/*
	for( i=0; i<SortedFGs.Length; i++ )
	{
		//DM( i $ ": " $ SortedFGs[ i ] );
		if( i<SortedFGs.Length-1 )
			assert( VSize(SortedFGs[ i ].Location - Location) <= VSize(SortedFGs[ i+1 ].Location - Location) );
	}
*/

	CurrentCandidate = 0;
	for( i=0; i<FGLinks.Length; i++ )
	{
		if( FGLinks[ i ].FG == None )
		{
			for( j=CurrentCandidate; j<SortedFGs.Length; j++ )
			{
				CurrentCandidate = j+1;
				
				// check this possible link against all existing links in this FG and the opposite FG
				if( AnglesOK( Self, SortedFGs[ j ] ) && AnglesOK( SortedFGs[ j ], Self ) )
				{
					// add it
					MakeLinks( SortedFGs[ j ], i );
					break;
				}
			}
		}
	}
}

//-----------------------------------------------------------------------------
/*
function TakeDamage( int Damage, Pawn instigatedBy, vector hitlocation, vector momentum, class<DamageType> damageType)
{
	Health -= Damage;
	// Can do some cool things here, varying color, size, vibration, add sparks...
	if( Health <= 0 )
	{
DM( "### TakeDamage - " $ Self $ " Calling ShutDownDeployedUnit()" );
		ShutDownDeployedUnit( true );
	}
}
*/
//-----------------------------------------------------------------------------
// Finds a valid link and sets up the connections

function SetUpLink()
{
	ScanArea();
}

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

function NotifyDeployed()
{	
	Super.NotifyDeployed();
	SetUpLink();
}

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

function ModifyPaths( bool bEnabled ); // done via the ForceWall

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

function SpecialBumpHandling( Actor Other )
{
	local int i;
	
	Super.SpecialBumpHandling( Other );
	
	for( i=0; i<FGLinks.Length; i++ )
	{
		if( FGLinks[i].FGEffect != None )
			FGLinks[i].FGEffect.HandleForceWallBump( Other );
	}
}

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

function bool ConsiderAttacking( Actor TargetActor, U2NPCController AttackingController )
{
	local int ii;
	local bool bFoundForceWall, bResult;
	
	// hand decision off to ForceWall(s)
	if( FGLinks.Length >= 1 )
	{
		for( ii=0; ii<FGLinks.Length && !bResult; ii++ )
			if( FGLinks[ ii ].FGEffect != None && FGLinks[ ii ].FGEffect.ConsiderAttacking( TargetActor, AttackingController ) )
			{
				bFoundForceWall = true;
				bResult = true;
			}
	}
	
	if( !bFoundForceWall )
		bResult = Super.ConsiderAttacking( TargetActor, AttackingController );
		
	//DMTNS( "FieldGenerator.ConsiderAttacking returning " $ bResult $ " for should " $ AttackingController.Pawn $ " (" $ AttackingController.GetStateName() $ ")" $ " consider attacking " $ Self );
	return bResult;
}

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

defaultproperties
{
	LinkRadius=1000.000000
	NumPrimaryLinks=2
	NumSecondaryLinks=1
	TraceTolerance=16.000000
	LinkSound=Sound'U2XMPA.FieldGenerator.FieldGeneratorLink'
	UnlinkSound=Sound'U2XMPA.FieldGenerator.FieldGeneratorUnlink'
	BeamClass=Class'U2XMP.ForceWallBeam'
	BeamCount=6
	ForceWallWidth=10.000000
	FieldHeight=60.000000
	BottomOffset=10.000000
	CosMinAngle=0.707000
	PickupClass=Class'U2XMP.FieldGeneratorPickup'
	ExplosionEffect=ParticleSalamander'RocketEffects.ParticleSalamander2'
	ExplodeSound=Sound'U2XMPA.FieldGenerator.FieldGeneratorDestroyed'
	ShutdownSound=Sound'U2XMPA.FieldGenerator.FieldGeneratorShutdown'
	DestroyedAlertSound=Sound'U2XMPA.FieldGenerator.FieldGeneratorDestroyedAlert'
	DisabledSound=Sound'U2XMPA.FieldGenerator.FieldGeneratorDisabled'
	ReEnabledSound=Sound'U2XMPA.FieldGenerator.FieldGeneratorEnabled'
	DeploySound=Sound'U2XMPA.FieldGenerator.FieldGeneratorActivate'
	Description="Field Generator"
	bEnabled=true
	bSpecialEnemy=true
	Health=300
	ControllerClass=Class'U2XMP.StationaryPawnControllerDefensive'
	DrawType=DT_StaticMesh
	StaticMesh=StaticMesh'343M.Assets.FieldGenerator'
	DrawScale=0.110000
	PrePivot=(X=-10.000000,Y=-5.000000,Z=-20.000000)
	CollisionRadius=5.000000
	CollisionHeight=55.000000
	bNoStaticMeshCollide=true
     UseReticleOnEvents(0)="UseReticleText"
     UseReticleOnEvents(1)="UseReticleCorners"
     UseReticleOnEvents(2)="UseReticleTopBars"
     UseReticleOnEvents(3)="UseReticleHealthBar"
     ProximityReticleOnEvents(0)="ProximityReticleCorners"
     ProximityReticleOnEvents(1)="ProximityReticleSideBars"
}