U2.ActorFactory

//=============================================================================
// ActorFactory.uc
// $Author: Mfox $
// $Date: 12/04/02 4:25p $
// $Revision: 17 $
//=============================================================================
class ActorFactory extends Keypoint;

enum EDistribution
{
	DIST_Constant,
	DIST_Uniform,
	DIST_Gaussian
};

var() class<Actor> Prototype; 				// the template class
var() int MaxItems;							// max number of items from this factory at any time
var() int Capacity;							// max number of items ever buildable (-1 = no limit)
var() float Interval;						// average time interval between spawnings
var() name ItemTag;							// tag given to items produced at this factory
var() name DepletedEvent;					// event to trigger when factory has been depleted

var() bool bTouchEnabled;					// (true) if false, factory not triggered via touch
var() bool bTriggerManually;				// spawn maxitems when triggered and then go back to waiting
var() bool bNonPrototypeTriggerShutdown;	// trigger from anything but spawned type shuts down the factory
var() bool bNonPrototypeTriggerKillAll;		// trigger from anything but spawned type kills all the spawned objects
var() EDistribution TimeDistribution;		// randomisation of time interval

var() bool bOnlyPlayerTouched; 				// only player can trigger it
var() bool bCovert;							// only do hidden spawns
var() bool bStoppable;						// stops producing when untouched
var() bool bCanRestart;						// if true factory will restock itself when empty and can be triggered again
var() bool bCycleSpawnPoints;				// if true, tries to use each spawn point in order (instead of randomly)
var() int FlipCovertCount;					// after this many NPCs are spawned, flips the covertness of the factory (permanently)

var private int NumSpawnPoints;				// number of spawnspots
var private int NumSpawnedItems;			// current number of items from this factory
var private SpawnPoint SpawnSpots[16];	 	// possible start locations
var private int NextSpawnPoint;				// next spawn point to use if bCycleSpawnPoints
var int InitialCapacity;

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

event PostBeginPlay()
{
	local SpawnPoint NewSpot;
	local Actor A;
	
	Super.PostBeginPlay();
	
	// count and store spawn points
	NumSpawnPoints = 0;
	foreach AllActors( class'SpawnPoint', NewSpot, tag )
	{
		if( NumSpawnPoints < 16 )
		{
			SpawnSpots[NumSpawnPoints] = NewSpot;
			NewSpot.Factory = Self;
			NumSpawnPoints += 1;
		}
	}

	if( NumSpawnPoints == 0 )
	{
		warn( Self $ " has no spawn points!" );
	}
	
	// count pre-existing matching items (item event = factory tag)
	NumSpawnedItems = 0;
	foreach AllActors( Prototype, A, tag )
	{
		NumSpawnedItems++;
	}
	
	if( ItemTag == '' )
	{
		ItemTag = 'BallPiensRock';
	}

	if( Capacity > 0 )
		InitialCapacity = Capacity;   // save initial capacity so that we can reset the factory later
}	

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

function SpawnPoint GetSpawnSpot( int Index )
{
	if( Index >= 0 && Index<NumSpawnPoints )
		return SpawnSpots[ Index ];
	else
		return None;
}

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

function StartBuilding()
{
}

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

function KillAll()
{
	local int i;

	for( i=0; i < ArrayCount(SpawnSpots); i++ )
	{
		if( SpawnSpots[i] != None )
			SpawnSpots[i].DestroyAllSpawnees();
	}
	NumSpawnedItems = 0;
}


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

function bool HandleSpawneeDeath( Actor Other )
{
	local Pawn P;

	P = Pawn(Other);

	// Spawned pawn has died (actor deaths don't trigger events)
	if( P != None && P.class == Prototype && P.Health <= 0 )
	{
		NumSpawnedItems--;
		return true;
	}
	return false;
}

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

auto state Waiting
{
	function Trigger( Actor Other, Pawn EventInstigator, optional name EventName )
	{
		if( !HandleSpawneeDeath( Other ) )
		{
			// Factory has been triggered, start spawning
			TriggerEvent( Event, Other, EventInstigator );
			GotoState( 'Spawning' );
		}
	}
		
	event Touch( Actor Other )
	{
		local Pawn OtherPawn;

		if( bTouchEnabled )
		{	
			OtherPawn = Pawn(Other);
			if( OtherPawn != None && (!bOnlyPlayerTouched || OtherPawn.IsPlayer()) )
				Trigger( Other, otherPawn );
		}
	}
}

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

state Spawning
{
	// Disabled in BeginState if !bStoppable
	event UnTouch( Actor Other )
	{
		local Pawn P;

		if( bTouchEnabled )
		{
			// check if some other pawn still touching, ignore the untouching actor and dead stuff
			foreach TouchingActors( class'Pawn', P )
				if( P != Other && P.Health > 0 && (!bOnlyPlayerTouched || P.IsPlayer()) )
					return;

			GotoState( 'Waiting' );
		}
	}

	function Trigger( Actor Other, Pawn EventInstigator, optional name EventName )
	{
		local int i;

		if( bTriggerManually )
			return;
		else if( HandleSpawneeDeath( Other ) )
		{
			if( NumSpawnedItems < MaxItems )
				StartBuilding();
		}
		else
		{
			// trigger from anything but creatures belonging to 
			// this factory shuts down the factory
			if( bNonPrototypeTriggerKillAll )
			{
				KillAll();
			}

			if( bCanRestart )
			{
				Capacity = InitialCapacity;
				GotoState( 'Waiting' );
			}
			else if( bNonPrototypeTriggerShutdown )
			{
				GotoState( 'Finished' );
			}
			else
			{
				GotoState( 'Waiting' );
			}
		}
	}

	function bool TrySpawn( int Start, int End )
	{
		local int i;
		local bool bDone;

		bDone = false;
		i = Start;
		while( i < End )
		{
			if( SpawnSpots[i].Create() )
			{
				bDone = true;
				i = End;
				if( Capacity > 0 )
				{
					Capacity--;
				}
					
				NumSpawnedItems++;
				
				if( FlipCovertCount > 0 && NumSpawnedItems == FlipCovertCount )
				{
					bCovert = !bCovert;
					FlipCovertCount = 0;
				}
				
				if( Capacity == 0 )
					GotoState( 'Finished' );
			}
			i++;
		}
		
		return bDone;
	}
		
	event Timer()
	{
		local int Start;
		
		if( NumSpawnedItems < MaxItems )
		{
			//pick a spawn point
			if( bCycleSpawnPoints )
			{
				Start = NextSpawnPoint;
				NextSpawnPoint++;
				if( NextSpawnPoint >= NumSpawnPoints )
					NextSpawnPoint = 0;
			}
			else
				Start = Rand( NumSpawnPoints );
				
			if( !TrySpawn( Start, NumSpawnPoints ) )
				TrySpawn( 0, Start );
				
			StartBuilding();
		}
		else if( bTriggerManually )
		{
			// forget about the spawned items
			// wait to be manually triggered again
			NumSpawnedItems = 0;
			GotoState('Waiting');
		}
	}

	function StartBuilding()
	{
		local float NextTime;
		
		if( Capacity == -1 || Capacity > 0 )
		{
			if( TimeDistribution == DIST_Constant )
			{
				NextTime = Interval;
			}
			else if( TimeDistribution == DIST_Uniform )
			{
				NextTime = 2 * FRand() * Interval;
			}
			else //TimeDistribution is gaussian
			{
				NextTime = 0.5 * (FRand() + FRand() + FRand() + FRand()) * Interval;
			}
			
			SetTimer( NextTime, false );
		}
	}

	event BeginState()
	{
		if( !bStoppable )
		{
			Disable( 'UnTouch' );
		}
	}

Begin:
	Timer();
}

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

state Finished
{
	function Trigger( Actor Other, Pawn EventInstigator, optional name EventName )
	{
		if( !HandleSpawneeDeath( Other ) )
		{
			// trigger from anything but creatures belonging to 
			// this factory shuts down the factory
			if( bNonPrototypeTriggerKillAll )
			{
				KillAll();
			}
		}
		if( bCanRestart )
		{
			Capacity = InitialCapacity;
			GotoState( 'Waiting' );
		}
	}
}	

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

function DumpInfo( PlayerController P )
{
	local SpawnPoint SP;
	local Actor A;
	local int Count;

	P.log( "   " );

	P.log( "ActorFactory:    " $ Name );
	P.log( "  State:         " $ GetStateName() );
	P.log( "  Prototype:     " $ Prototype );
	P.log( "  Capacity:      " $ Capacity );
	P.log( "  MaxItems:      " $ MaxItems );
	P.log( "  Spawn spots:   " $ NumSpawnPoints );
	P.log( "  Spawned items: " $ NumSpawnedItems );
	P.log( "  Event:         " $ Event );
	P.log( "  Tag:           " $ Tag );
	P.log( "  ItemTag:       " $ ItemTag );
	P.log( "  bTouchEnabled: " $ bTouchEnabled );

	// dump SpawnPoint info
	Count=0;
	P.log( "   " );
	P.log( "  SpawnPoints:" );
	foreach AllActors( class'SpawnPoint', SP, Tag )
	{
		SP.DumpInfo( P.Pawn );
		Count++;
		P.log( "   " );
	}
	P.log( "    " $ Count $ " SpawnPoints found." );

	// dump Trigger info
	Count=0;
	P.log( "   " );
	P.log( "  Existing Triggers:" );
	foreach AllActors( class'Actor', A )
	{
		if( A.Event == Tag )
		{
			P.log( "    " $ A.Name );
			Count++;
		}
	}
	P.log( "    " $ Count $ " Triggers found." );
}

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

defaultproperties
{
	MaxItems=1
	Capacity=1000000
	Interval=1.000000
	bTouchEnabled=true
	bNonPrototypeTriggerShutdown=true
	bStatic=false
	bCollideActors=true
     UseReticleOnEvents(0)="UseReticleText"
     UseReticleOnEvents(1)="UseReticleCorners"
     UseReticleOnEvents(2)="UseReticleTopBars"
     ProximityReticleOnEvents(0)="ProximityReticleCorners"
     ProximityReticleOnEvents(1)="ProximityReticleTopBars"
}