Stupid Thing_Factory

Discussions about Coding and Scripting

Stupid Thing_Factory

Postby Red_Fist » 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.

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." );
}

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



Including the reset if empty, I see Barbie has something but this factory thing just tees me off.
Binary Space Partitioning
Red_Fist
Godlike
 
Posts: 1450
Joined: Sun Oct 05, 2008 3:31 am

Re: Stupid Thing_Factory

Postby Leo(T.C.K.) » Sat Apr 13, 2019 6:50 pm

What happens if you use thing factory with triggercontrol state trigger?

I never tried but you could do that and have that triggercontrol trigger attached to a mover.
Leo(T.C.K.)
Adept
 
Posts: 389
Joined: Sat Aug 13, 2011 10:26 pm

Re: Stupid Thing_Factory

Postby Red_Fist » Sat Apr 13, 2019 7:39 pm

Because I want a floor plate to set off traps as you stand on the floor with a mover embedded into the floor.

But I can use geometric shapes as opposed to radius of triggers.
Binary Space Partitioning
Red_Fist
Godlike
 
Posts: 1450
Joined: Sun Oct 05, 2008 3:31 am

Re: Stupid Thing_Factory

Postby Leo(T.C.K.) » Sat Apr 13, 2019 9:03 pm

True, well it could even be solved by a triggercontrol state mover (a mylevel subclass) for example.
That's more direct approach rather than having a modified thing factory.
Leo(T.C.K.)
Adept
 
Posts: 389
Joined: Sat Aug 13, 2011 10:26 pm

Re: Stupid Thing_Factory

Postby Red_Fist » Sat Apr 13, 2019 9:49 pm

No, the mover is just a trigger, but you have to "touch" the thingfactory to shut it off.

Then I go back to the mover and trigger another one, using -1 as capacity.
So it does work now but the mover "event" can't stop the spawning.

So I step off the mover and it will stop, if can work like that.
Binary Space Partitioning
Red_Fist
Godlike
 
Posts: 1450
Joined: Sun Oct 05, 2008 3:31 am

Re: Stupid Thing_Factory

Postby Leo(T.C.K.) » Sun Apr 14, 2019 8:13 am

I will try to test this myself, what are you trying to spawn exactly?
Leo(T.C.K.)
Adept
 
Posts: 389
Joined: Sat Aug 13, 2011 10:26 pm

Re: Stupid Thing_Factory

Postby Red_Fist » Sun Apr 14, 2019 5:53 pm

Projectiles for traps in hallways.

This is the way Quake 1 did it, they had trigger brushes, as soon as you stand in area things happen, not rows and rows of triggeres.
Binary Space Partitioning
Red_Fist
Godlike
 
Posts: 1450
Joined: Sun Oct 05, 2008 3:31 am

Re: Stupid Thing_Factory

Postby Leo(T.C.K.) » Sun Apr 14, 2019 8:46 pm

I see.
Leo(T.C.K.)
Adept
 
Posts: 389
Joined: Sat Aug 13, 2011 10:26 pm


Return to Coding, Scripting

Who is online

Users browsing this forum: No registered users and 3 guests