An item factory

• A factory is a design pattern.
• It is responsible for creating instances of members of a heirarchy.
  • This removes the object creation code from places that use instances of the heirarchy.
• I want to build something that will produce pickups for me.
  • Rmember, my spawner had thi snasty code in it
  • 
  • It had to know how to place objecs.
  • But it also had to know how to construct objects.
    • If this is the only place that objecs are constructed that is fine.
    • But consider the case where I might want different things to spawn objects
      • A random spawner
      • A shop, with a unique inventory each time the players enters
      • A NPC has a random item it drops when killed.
  • A resonable solution is that each distributor gets their items from a "factory"
• In general
  • Things that disperse items
    • have a registerd "factory"
    • They ask this factory for an item.
    • They are then responsible for "placing" the item in the world.
  • The factory
    • Produces the item of the type and quality requested.
    • And returns this to the requestor.
• Enumerated types
  • Since Unreal is so closely tied to c++ it makes sense there is an enumerated type
  • Easy to declare
  • 
  • 
  • I produced two, one for the pickup type and one for the quality.
  • When ordering from a factory, I pass both of these.
  • We will explore enumeration methods in the next steps.
• A client, BP_Store
  • This is a stripped down version of the spawner from last time.
  • It has a bounding box where items will be spawned.
  • It has a visibility platform, but this need not exist.
  • It has a variable that holds it's factory.
  • It is triggered when the player wonders in.

    
    OnOverlap
       If (not IsValid(factory))
         IsEmptyError() 
       else
          item = Factory.NewItem(itemType,itemQuality)
          item.SetLocation(MakeRandomLocation());
                 

    • Not the use of the IsValid node to make sure that a factory is registered.

      
      IsEmptyError()
          Print "Add a factory to ", GetDisplayName(self);
      
      
      MakeRandomLocation
         return RandomPointInBoundingBox(box);
                   

• The factory is somewhat more complex
  • The new item script is a mix between two different methods.
    • A fixed factory
    • A specialized factory.
    • 

    • NewItem(typeToBuild, qualityToBuild)
      
          save type and quality as local variables. // to clean up the graph.
      
          newItemType = typeToBuild 
          if (typeToBuild == random) {
              newItemType = PickRandomType()
          }
      
          switch(typeToBuild) {
              case Health:
              case Damage:
              case Random: // should never occur
                  returnValue = SpawnActor(ClassList[typeToBuild])
                  break
              case Ammo:
                  returnValue = AmmoFactory.NewAmmo(qualityToBuild);
          }
      
      
          return returnValue;
                 

    • The EnTypeToActor cast needed to be written
      • Based on the "int" value of the enum
      • I looked the value up actor type up an array of actors.
      • I hate this soultion by the way.
      • 
    • The PickRandomType
      • Just a series of casts
      • And a call to the random number generator.
      • 
    • Notice the select node is used twice.
      • This just selectes between different types of input for a single output.
• For the abstract factory
  • The factory just calls a specialized factory.
  • So the factory needs to "construct" the specialized factories on construction
    • I have only implemented the ammo factory.
    • 
  • The BP_Ammo Factory
    • This is just a specialization that knows about building ammo
    • You really should build one for each of the types of pickups that have variation.
    • 
• You need to add an instance of the BP_Factory to the scene, but not the ammo factory.