Stupid Thing_Factory
Posted: Sat Apr 13, 2019 2:05 am
Man that thing really tees me off I wish someone could do a final fix-version once and for all.
OK, stand on mover using trigger control.
Thing factory spawns stuff
Get off of mover ThingFactory stops spawning.
Get on mover, thing factory starts again.
I want a mover event-bump event to be able to do the same function as touch-untouch.
Here is the code for Unreal2 if it helps.
Including the reset if empty, I see Barbie has something but this factory thing just tees me off.
OK, stand on mover using trigger control.
Thing factory spawns stuff
Get off of mover ThingFactory stops spawning.
Get on mover, thing factory starts again.
I want a mover event-bump event to be able to do the same function as touch-untouch.
Here is the code for Unreal2 if it helps.
Code: Select all
/=============================================================================
// 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." );
}
//-----------------------------------------------------------------------------