Merge pull request #180 from Fate-JH/all-zones

All Zones

.codecov.yml

@@ -41,5 +41,7 @@ ignore:
   - "pslogin/src/main/scala/CryptoSessionActor.scala"
   - "pslogin/src/main/scala/DatabaseConnector.scala"
   - "pslogin/src/main/scala/LoginConfig.scala"
+  - "pslogin/src/main/scala/Maps.scala"
   - "pslogin/src/main/scala/MDCContextAware.scala"
   - "pslogin/src/main/scala/MDCPropagatingExecutionContext.scala"
+  - "pslogin/src/main/scala/Zones.scala"

common/src/main/scala/net/psforever/objects/serverobject/ServerObjectBuilder.scala

@@ -0,0 +1,62 @@
+// Copyright (c) 2017 PSForever
+package net.psforever.objects.serverobject
+
+import akka.actor.ActorContext
+import net.psforever.objects.guid.NumberPoolHub
+
+/**
+  * Customizable native entity instantiation logic at the `ZoneMap` level.
+  * Produces environmental constants such as `Terminal` objects and `Door` objects.<br>
+  * <br>
+  * `ZoneMap` is the expected position where this class is defined.
+  * Within `Zone.Init` is where this class is expected to be fully executed.
+  * The former is a blueprint which provides as many emitted entities based on how many `Zone` objects utilize it.
+  * `constructor` is required to have the form `(Int, ActorContext) => A` by the point where it executes
+  * due to invocation of the `Build` method.
+  * For that reason, it must exist in an `Actor` which has an `ActorContext` to lend, hence the `Zone`'s `Actor`.
+  * Furthermore, the requirement of a `NumberPoolHub` means the region is accessible to and defined by
+  * a closed number space, which is also the `Zone`.
+  * It utilizes those qualities of the enclosing region to construct the entity within that region.<br>
+  * <br>
+  * Example: `ServerObjectBuilder(n, function)`
+  * Example: `new ServerBuilderObject[A](n, function)`, where `function` is a `(Int,Context)=>A`
+  * @see `ZoneMap`
+  * @see `Zone.Init`
+  * @param id the unique id that will be assigned to this entity
+  * @param constructor the logic that initializes the emitted entity
+  * @tparam A any object that extends from PlanetSideServerObject that will be produced by this class;
+  *           can be inferred from the output of `constructor`
+  */
+class ServerObjectBuilder[A <: PlanetSideServerObject](private val id : Int,
+                                                       private val constructor : (Int, ActorContext) => A
+                                                      ) {
+  /**
+    * Instantiate and configure the given server object.
+    * Specific configuration should have been handled by curried parameters into `constructor`, i.e.,
+    * `constructor(foo : Bar) => constructor(Int, ActorContext) => A`.
+    * The main activity performed locally registers the created object to the provided number space.
+    * @param context a context to allow the object to properly set up `ActorSystem` functionality;
+    *                defaults to `null`
+    * @param guid the local globally unique identifier system to complete the process of object introduction;
+    *             defaults to `null`
+    * @return the object that was created and integrated into the `Zone`
+    */
+  def Build(implicit context : ActorContext = null, guid : NumberPoolHub = null) : A = {
+    val obj : A = constructor(id, context)
+    guid.register(obj, id)
+    obj
+  }
+}
+
+object ServerObjectBuilder {
+  /**
+    * Overloaded constructor.
+    * @param id the unqiue id that will be assigned to this entity
+    * @param constructor the logic that initializes the emitted entity
+    * @tparam A any object that extends from PlanetSideServerObject that will be produced by this class
+    * @return a `ServerObjectBuilder` object
+    */
+  def apply[A <: PlanetSideServerObject](id : Int, constructor : (Int, ActorContext) => A) : ServerObjectBuilder[A] = {
+    new ServerObjectBuilder[A](id, constructor)
+  }
+}

common/src/main/scala/net/psforever/objects/serverobject/builders/DoorObjectBuilder.scala

@@ -1,34 +0,0 @@
-// Copyright (c) 2017 PSForever
-package net.psforever.objects.serverobject.builders
-
-import akka.actor.Props
-import net.psforever.objects.serverobject.doors.{Door, DoorControl, DoorDefinition}
-
-/**
-  * Wrapper `Class` designed to instantiate a `Door` server object.
-  * @param ddef a `DoorDefinition` object, indicating the specific functionality of the resulting `Door`
-  * @param id the globally unique identifier to which this `Door` will be registered
-  */
-class DoorObjectBuilder(private val ddef : DoorDefinition, private val id : Int) extends ServerObjectBuilder[Door] {
-  import akka.actor.ActorContext
-  import net.psforever.objects.guid.NumberPoolHub
-
-  def Build(implicit context : ActorContext, guid : NumberPoolHub) : Door = {
-    val obj = Door(ddef)
-    guid.register(obj, id) //non-Actor GUID registration
-    obj.Actor = context.actorOf(Props(classOf[DoorControl], obj), s"${ddef.Name}_${obj.GUID.guid}")
-    obj
-  }
-}
-
-object DoorObjectBuilder {
-  /**
-    * Overloaded constructor for a `DoorObjectBuilder`.
-    * @param ddef a `DoorDefinition` object
-    * @param id a globally unique identifier
-    * @return a `DoorObjectBuilder` object
-    */
-  def apply(ddef : DoorDefinition, id : Int) : DoorObjectBuilder = {
-    new DoorObjectBuilder(ddef, id)
-  }
-}

common/src/main/scala/net/psforever/objects/serverobject/builders/IFFLockObjectBuilder.scala

@@ -1,34 +0,0 @@
-// Copyright (c) 2017 PSForever
-package net.psforever.objects.serverobject.builders
-
-import akka.actor.Props
-import net.psforever.objects.serverobject.locks.{IFFLock, IFFLockControl, IFFLockDefinition}
-
-/**
-  * Wrapper `Class` designed to instantiate a door lock server object that is sensitive to user faction affiliation.
-  * @param idef a `IFFLockDefinition` object, indicating the specific functionality
-  * @param id the globally unique identifier to which this `IFFLock` will be registered
-  */
-class IFFLockObjectBuilder(private val idef : IFFLockDefinition, private val id : Int) extends ServerObjectBuilder[IFFLock] {
-  import akka.actor.ActorContext
-  import net.psforever.objects.guid.NumberPoolHub
-
-  def Build(implicit context : ActorContext, guid : NumberPoolHub) : IFFLock = {
-    val obj = IFFLock(idef)
-    guid.register(obj, id) //non-Actor GUID registration
-    obj.Actor = context.actorOf(Props(classOf[IFFLockControl], obj), s"${idef.Name}_${obj.GUID.guid}")
-    obj
-  }
-}
-
-object IFFLockObjectBuilder {
-  /**
-    * Overloaded constructor for a `IFFLockObjectBuilder`.
-    * @param idef an `IFFLock` object
-    * @param id a globally unique identifier
-    * @return an `IFFLockObjectBuilder` object
-    */
-  def apply(idef : IFFLockDefinition, id : Int) : IFFLockObjectBuilder = {
-    new IFFLockObjectBuilder(idef, id)
-  }
-}

common/src/main/scala/net/psforever/objects/serverobject/builders/ImplantTerminalMechObjectBuilder.scala

@@ -1,34 +0,0 @@
-// Copyright (c) 2017 PSForever
-package net.psforever.objects.serverobject.builders
-
-import akka.actor.Props
-import net.psforever.objects.serverobject.implantmech.{ImplantTerminalMech, ImplantTerminalMechControl, ImplantTerminalMechDefinition}
-
-/**
-  * Wrapper `Class` designed to instantiate a `ImplantTerminalMech` server object.
-  * @param idef a `ImplantTerminalMechDefinition` object, indicating the specific functionality of the resulting `Door`
-  * @param id the globally unique identifier to which this "tube" will be registered
-  */
-class ImplantTerminalMechObjectBuilder(private val idef : ImplantTerminalMechDefinition, private val id : Int) extends ServerObjectBuilder[ImplantTerminalMech] {
-  import akka.actor.ActorContext
-  import net.psforever.objects.guid.NumberPoolHub
-
-  def Build(implicit context : ActorContext, guid : NumberPoolHub) : ImplantTerminalMech = {
-    val obj = ImplantTerminalMech(idef)
-    guid.register(obj, id) //non-Actor GUID registration
-    obj.Actor = context.actorOf(Props(classOf[ImplantTerminalMechControl], obj), s"${idef.Name}_${obj.GUID.guid}")
-    obj
-  }
-}
-
-object ImplantTerminalMechObjectBuilder {
-  /**
-    * Overloaded constructor for a `DoorObjectBuilder`.
-    * @param idef a `DoorDefinition` object
-    * @param id a globally unique identifier
-    * @return a `DoorObjectBuilder` object
-    */
-  def apply(idef : ImplantTerminalMechDefinition, id : Int) : ImplantTerminalMechObjectBuilder = {
-    new ImplantTerminalMechObjectBuilder(idef, id)
-  }
-}

common/src/main/scala/net/psforever/objects/serverobject/builders/ServerObjectBuilder.scala

@@ -1,29 +0,0 @@
-// Copyright (c) 2017 PSForever
-package net.psforever.objects.serverobject.builders
-
-import akka.actor.ActorContext
-import net.psforever.objects.PlanetSideGameObject
-import net.psforever.objects.guid.NumberPoolHub
-
-/**
-  * Wrapper `Trait` designed to be extended to implement custom object instantiation logic at the `ZoneMap` level.
-  * @tparam A any object that extends from PlanetSideGameObject
-  * @see `Zone.Init`
-  */
-//TODO can we changed PlanetSideGameObject -> PlanetSideServerObject?
-trait ServerObjectBuilder[A <: PlanetSideGameObject] {
-  /**
-    * Instantiate and configure the given server object
-    * (at a later time compared to the construction of the builder class).<br>
-    * <br>
-    * Externally, it expects a `context` to properly integrate within an `ActorSystem`
-    * and is provided with a source for globally unique identifiers to integrate into the `Zone`.
-    * Neither is required of the `return` type, however.
-    * @param context a context to allow the object to properly set up `ActorSystem` functionality;
-    *                defaults to `null`
-    * @param guid the local globally unique identifier system to complete the process of object introduction;
-    *             defaults to `null`
-    * @return the object that was created and integrated into the `Zone`
-    */
-  def Build(implicit context : ActorContext = null, guid : NumberPoolHub = null) : A
-}

common/src/main/scala/net/psforever/objects/serverobject/builders/TerminalObjectBuilder.scala

@@ -1,34 +0,0 @@
-// Copyright (c) 2017 PSForever
-package net.psforever.objects.serverobject.builders
-
-import akka.actor.Props
-import net.psforever.objects.serverobject.terminals.{Terminal, TerminalControl, TerminalDefinition}
-
-/**
-  * Wrapper `Class` designed to instantiate a `Terminal` server object.
-  * @param tdef a `TerminalDefinition` object, indicating the specific functionality of the resulting `Terminal`
-  * @param id the globally unique identifier to which this `Terminal` will be registered
-  */
-class TerminalObjectBuilder(private val tdef : TerminalDefinition, private val id : Int) extends ServerObjectBuilder[Terminal] {
-  import akka.actor.ActorContext
-  import net.psforever.objects.guid.NumberPoolHub
-
-  def Build(implicit context : ActorContext, guid : NumberPoolHub) : Terminal = {
-    val obj = Terminal(tdef)
-    guid.register(obj, id) //non-Actor GUID registration
-    obj.Actor = context.actorOf(Props(classOf[TerminalControl], obj), s"${tdef.Name}_${obj.GUID.guid}")
-    obj
-  }
-}
-
-object TerminalObjectBuilder {
-  /**
-    * Overloaded constructor for a `TerminalObjectBuilder`.
-    * @param tdef a `TerminalDefinition` object
-    * @param id a globally unique identifier
-    * @return a `TerminalObjectBuilder` object
-    */
-  def apply(tdef : TerminalDefinition, id : Int) : TerminalObjectBuilder = {
-    new TerminalObjectBuilder(tdef, id)
-  }
-}

common/src/main/scala/net/psforever/objects/serverobject/builders/VehicleSpawnPadObjectBuilder.scala

@@ -1,35 +0,0 @@
-// Copyright (c) 2017 PSForever
-package net.psforever.objects.serverobject.builders
-
-import akka.actor.Props
-import net.psforever.objects.definition.ObjectDefinition
-import net.psforever.objects.serverobject.pad.{VehicleSpawnControl, VehicleSpawnPad}
-
-/**
-  * Wrapper `Class` designed to instantiate a `VehicleSpawnPad` server object.
-  * @param spdef an `ObjectDefinition` object ...
-  * @param id the globally unique identifier to which this `VehicleSpawnPad` will be registered
-  */
-class VehicleSpawnPadObjectBuilder(private val spdef : ObjectDefinition, private val id : Int) extends ServerObjectBuilder[VehicleSpawnPad] {
-  import akka.actor.ActorContext
-  import net.psforever.objects.guid.NumberPoolHub
-
-  def Build(implicit context : ActorContext, guid : NumberPoolHub) : VehicleSpawnPad = {
-    val obj = VehicleSpawnPad(spdef)
-    guid.register(obj, id) //non-Actor GUID registration
-    obj.Actor = context.actorOf(Props(classOf[VehicleSpawnControl], obj), s"${spdef.Name}_${obj.GUID.guid}")
-    obj
-  }
-}
-
-object VehicleSpawnPadObjectBuilder {
-  /**
-    * Overloaded constructor for a `DoorObjectBuilder`.
-    * @param spdef an `ObjectDefinition` object
-    * @param id a globally unique identifier
-    * @return a `VehicleSpawnPadObjectBuilder` object
-    */
-  def apply(spdef : ObjectDefinition, id : Int) : VehicleSpawnPadObjectBuilder = {
-    new VehicleSpawnPadObjectBuilder(spdef, id)
-  }
-}

common/src/main/scala/net/psforever/objects/serverobject/doors/Door.scala

@@ -76,4 +76,20 @@ object Door {
   def apply(tdef : DoorDefinition) : Door = {
     new Door(tdef)
   }
+
+  import akka.actor.ActorContext
+  /**
+    * Instantiate an configure a `Door` object
+    * @param id the unique id that will be assigned to this entity
+    * @param context a context to allow the object to properly set up `ActorSystem` functionality
+    * @return the `Door` object
+    */
+  def Constructor(id : Int, context : ActorContext) : Door = {
+    import akka.actor.Props
+    import net.psforever.objects.GlobalDefinitions
+
+    val obj = Door(GlobalDefinitions.door)
+    obj.Actor = context.actorOf(Props(classOf[DoorControl], obj), s"${GlobalDefinitions.door.Name}_$id")
+    obj
+  }
 }

common/src/main/scala/net/psforever/objects/serverobject/implantmech/ImplantTerminalMech.scala

@@ -36,7 +36,27 @@ class ImplantTerminalMech(private val idef : ImplantTerminalMechDefinition) exte
 }
 
 object ImplantTerminalMech {
+  /**
+    * Overloaded constructor.
+    * @param idef the `ObjectDefinition` that constructs this object and maintains some of its immutable fields
+    */
   def apply(idef : ImplantTerminalMechDefinition) : ImplantTerminalMech = {
     new ImplantTerminalMech(idef)
   }
+
+  import akka.actor.ActorContext
+  /**
+    * Instantiate an configure a `ImplantTerminalMech` object
+    * @param id the unique id that will be assigned to this entity
+    * @param context a context to allow the object to properly set up `ActorSystem` functionality
+    * @return the `ImplantTerminalMech` object
+    */
+  def Constructor(id : Int, context : ActorContext) : ImplantTerminalMech = {
+    import akka.actor.Props
+    import net.psforever.objects.GlobalDefinitions
+
+    val obj = ImplantTerminalMech(GlobalDefinitions.implant_terminal_mech)
+    obj.Actor = context.actorOf(Props(classOf[ImplantTerminalMechControl], obj), s"${GlobalDefinitions.implant_terminal_mech.Name}_$id")
+    obj
+  }
 }

common/src/main/scala/net/psforever/objects/serverobject/locks/IFFLock.scala

@@ -63,4 +63,20 @@ object IFFLock {
   def apply(idef : IFFLockDefinition) : IFFLock = {
     new IFFLock(idef)
   }
+
+  import akka.actor.ActorContext
+  /**
+    * Instantiate an configure a `IFFLock` object
+    * @param id the unique id that will be assigned to this entity
+    * @param context a context to allow the object to properly set up `ActorSystem` functionality
+    * @return the `IFFLock` object
+    */
+  def Constructor(id : Int, context : ActorContext) : IFFLock = {
+    import akka.actor.Props
+    import net.psforever.objects.GlobalDefinitions
+
+    val obj = IFFLock(GlobalDefinitions.lock_external)
+    obj.Actor = context.actorOf(Props(classOf[IFFLockControl], obj), s"${GlobalDefinitions.lock_external.Name}_$id")
+    obj
+  }
 }

common/src/main/scala/net/psforever/objects/serverobject/pad/VehicleSpawnPad.scala

@@ -86,4 +86,26 @@ object VehicleSpawnPad {
   def apply(spDef : ObjectDefinition) : VehicleSpawnPad = {
     new VehicleSpawnPad(spDef)
   }
+
+  import akka.actor.ActorContext
+  import net.psforever.types.Vector3
+
+  /**
+    * Instantiate an configure a `VehicleSpawnPad` object
+    * @param pos the position (used to determine spawn point)
+    * @param orient the orientation (used to indicate spawn direction)
+    * @param id the unique id that will be assigned to this entity
+    * @param context a context to allow the object to properly set up `ActorSystem` functionality
+    * @return the `VehicleSpawnPad` object
+    */
+  def Constructor(pos : Vector3, orient : Vector3)(id : Int, context : ActorContext) : VehicleSpawnPad = {
+    import akka.actor.Props
+    import net.psforever.objects.GlobalDefinitions
+
+    val obj = VehicleSpawnPad(GlobalDefinitions.spawn_pad)
+    obj.Position = pos
+    obj.Orientation = orient
+    obj.Actor = context.actorOf(Props(classOf[VehicleSpawnControl], obj), s"${GlobalDefinitions.spawn_pad.Name}_$id")
+    obj
+  }
 }

common/src/main/scala/net/psforever/objects/serverobject/terminals/Terminal.scala

@@ -3,11 +3,9 @@ package net.psforever.objects.serverobject.terminals
 
 import net.psforever.objects.Player
 import net.psforever.objects.definition.ImplantDefinition
-import net.psforever.objects.equipment.Equipment
-import net.psforever.objects.inventory.InventoryItem
 import net.psforever.objects.serverobject.PlanetSideServerObject
 import net.psforever.packet.game.{ItemTransactionMessage, PlanetSideGUID}
-import net.psforever.types.{ExoSuitType, TransactionType, Vector3}
+import net.psforever.types.{TransactionType, Vector3}
 
 /**
   * A structure-owned server object that is a "terminal" that can be accessed for amenities and services.
@@ -113,6 +111,8 @@ object Terminal {
     * A result of a processed request.
     */
   final case class NoDeal() extends Exchange
+
+  import net.psforever.types.ExoSuitType
   /**
     * The `Player` exo-suit will be changed to the prescribed one.
     * The subtype will be important if the user is swapping to an `ExoSuitType.MAX` exo-suit.
@@ -121,6 +121,8 @@ object Terminal {
     * @param subtype the exo-suit subtype, if any
     */
   final case class BuyExosuit(exosuit : ExoSuitType.Value, subtype : Int = 0) extends Exchange
+
+  import net.psforever.objects.equipment.Equipment
   /**
     * A single piece of `Equipment` has been selected and will be given to the `Player`.
     * The `Player` must decide what to do with it once it is in their control.
@@ -128,16 +130,15 @@ object Terminal {
     * @param item the `Equipment` being given to the player
     */
   final case class BuyEquipment(item : Equipment) extends Exchange
+
   /**
     * A roundabout message oft-times.
     * Most `Terminals` should always allow `Player`s to dispose of some piece of `Equipment`.
     * A result of a processed request.
     */
-  //TODO if there are exceptions, find them
+  final case class SellEquipment() extends Exchange //TODO if there are exceptions, find them
-  final case class SellEquipment() extends Exchange
 
   import net.psforever.types.CertificationType
-
   /**
     * Provide the certification type unlocked by the player.
     * @param cert the certification unlocked
@@ -173,6 +174,7 @@ object Terminal {
     */
   final case class BuyVehicle(vehicle : Vehicle, weapons : List[InventoryItem], inventory : List[InventoryItem]) extends Exchange
 
+  import net.psforever.objects.inventory.InventoryItem
   /**
     * Recover a former exo-suit and `Equipment` configuration that the `Player` possessed.
     * A result of a processed request.
@@ -190,4 +192,20 @@ object Terminal {
   def apply(tdef : TerminalDefinition) : Terminal = {
     new Terminal(tdef)
   }
+
+  import akka.actor.ActorContext
+  /**
+    * Instantiate an configure a `Terminal` object
+    * @param tdef the `ObjectDefinition` that constructs this object and maintains some of its immutable fields
+    * @param id the unique id that will be assigned to this entity
+    * @param context a context to allow the object to properly set up `ActorSystem` functionality
+    * @return the `Terminal` object
+    */
+  def Constructor(tdef : TerminalDefinition)(id : Int, context : ActorContext) : Terminal = {
+    import akka.actor.Props
+
+    val obj = Terminal(tdef)
+    obj.Actor = context.actorOf(Props(classOf[TerminalControl], obj), s"${tdef.Name}_$id")
+    obj
+  }
 }

common/src/main/scala/net/psforever/objects/zones/ZoneMap.scala

@@ -1,7 +1,7 @@
 // Copyright (c) 2017 PSForever
 package net.psforever.objects.zones
 
-import net.psforever.objects.serverobject.builders.ServerObjectBuilder
+import net.psforever.objects.serverobject.ServerObjectBuilder
 
 /**
   * The fixed instantiation and relation of a series of server objects.<br>

common/src/test/scala/objects/ServerObjectBuilderTest.scala

@@ -2,23 +2,23 @@
 package objects
 
 import akka.actor.{Actor, Props}
-import net.psforever.objects.GlobalDefinitions
+import net.psforever.objects.GlobalDefinitions.order_terminal
 import net.psforever.objects.guid.NumberPoolHub
 import net.psforever.packet.game.PlanetSideGUID
-import net.psforever.objects.serverobject.builders.ServerObjectBuilder
+import net.psforever.objects.serverobject.ServerObjectBuilder
+import net.psforever.types.Vector3
 
 import scala.concurrent.duration.Duration
 
 class DoorObjectBuilderTest extends ActorTest {
   import net.psforever.objects.serverobject.doors.Door
-  import net.psforever.objects.serverobject.builders.DoorObjectBuilder
   "DoorObjectBuilder" should {
     "build" in {
       val hub = ServerObjectBuilderTest.NumberPoolHub
-      val actor = system.actorOf(Props(classOf[ServerObjectBuilderTest.BuilderTestActor], DoorObjectBuilder(GlobalDefinitions.door, 1), hub), "door")
+      val actor = system.actorOf(Props(classOf[ServerObjectBuilderTest.BuilderTestActor], ServerObjectBuilder(1, Door.Constructor), hub), "door")
       actor ! "!"
 
-      val reply = receiveOne(Duration.create(100, "ms"))
+      val reply = receiveOne(Duration.create(1000, "ms"))
       assert(reply.isInstanceOf[Door])
       assert(reply.asInstanceOf[Door].HasGUID)
       assert(reply.asInstanceOf[Door].GUID == PlanetSideGUID(1))
@@ -29,14 +29,13 @@ class DoorObjectBuilderTest extends ActorTest {
 
 class IFFLockObjectBuilderTest extends ActorTest {
   import net.psforever.objects.serverobject.locks.IFFLock
-  import net.psforever.objects.serverobject.builders.IFFLockObjectBuilder
   "IFFLockObjectBuilder" should {
     "build" in {
       val hub = ServerObjectBuilderTest.NumberPoolHub
-      val actor = system.actorOf(Props(classOf[ServerObjectBuilderTest.BuilderTestActor], IFFLockObjectBuilder(GlobalDefinitions.lock_external, 1), hub), "lock")
+      val actor = system.actorOf(Props(classOf[ServerObjectBuilderTest.BuilderTestActor], ServerObjectBuilder(1, IFFLock.Constructor), hub), "lock")
       actor ! "!"
 
-      val reply = receiveOne(Duration.create(100, "ms"))
+      val reply = receiveOne(Duration.create(1000, "ms"))
       assert(reply.isInstanceOf[IFFLock])
       assert(reply.asInstanceOf[IFFLock].HasGUID)
       assert(reply.asInstanceOf[IFFLock].GUID == PlanetSideGUID(1))
@@ -47,14 +46,13 @@ class IFFLockObjectBuilderTest extends ActorTest {
 
 class ImplantTerminalMechObjectBuilderTest extends ActorTest {
   import net.psforever.objects.serverobject.implantmech.ImplantTerminalMech
-  import net.psforever.objects.serverobject.builders.ImplantTerminalMechObjectBuilder
   "IFFLockObjectBuilder" should {
     "build" in {
       val hub = ServerObjectBuilderTest.NumberPoolHub
-      val actor = system.actorOf(Props(classOf[ServerObjectBuilderTest.BuilderTestActor], ImplantTerminalMechObjectBuilder(GlobalDefinitions.implant_terminal_mech, 1), hub), "mech")
+      val actor = system.actorOf(Props(classOf[ServerObjectBuilderTest.BuilderTestActor], ServerObjectBuilder(1, ImplantTerminalMech.Constructor), hub), "mech")
       actor ! "!"
 
-      val reply = receiveOne(Duration.create(100, "ms"))
+      val reply = receiveOne(Duration.create(1000, "ms"))
       assert(reply.isInstanceOf[ImplantTerminalMech])
       assert(reply.asInstanceOf[ImplantTerminalMech].HasGUID)
       assert(reply.asInstanceOf[ImplantTerminalMech].GUID == PlanetSideGUID(1))
@@ -65,14 +63,13 @@ class ImplantTerminalMechObjectBuilderTest extends ActorTest {
 
 class TerminalObjectBuilderTest extends ActorTest {
   import net.psforever.objects.serverobject.terminals.Terminal
-  import net.psforever.objects.serverobject.builders.TerminalObjectBuilder
   "TerminalObjectBuilder" should {
     "build" in {
       val hub = ServerObjectBuilderTest.NumberPoolHub
-      val actor = system.actorOf(Props(classOf[ServerObjectBuilderTest.BuilderTestActor], TerminalObjectBuilder(GlobalDefinitions.order_terminal, 1), hub), "term")
+      val actor = system.actorOf(Props(classOf[ServerObjectBuilderTest.BuilderTestActor], ServerObjectBuilder(1, Terminal.Constructor(order_terminal)), hub), "term")
       actor ! "!"
 
-      val reply = receiveOne(Duration.create(100, "ms"))
+      val reply = receiveOne(Duration.create(1000, "ms"))
       assert(reply.isInstanceOf[Terminal])
       assert(reply.asInstanceOf[Terminal].HasGUID)
       assert(reply.asInstanceOf[Terminal].GUID == PlanetSideGUID(1))
@@ -83,17 +80,20 @@ class TerminalObjectBuilderTest extends ActorTest {
 
 class VehicleSpawnPadObjectBuilderTest extends ActorTest {
   import net.psforever.objects.serverobject.pad.VehicleSpawnPad
-  import net.psforever.objects.serverobject.builders.VehicleSpawnPadObjectBuilder
   "TerminalObjectBuilder" should {
     "build" in {
       val hub = ServerObjectBuilderTest.NumberPoolHub
-      val actor = system.actorOf(Props(classOf[ServerObjectBuilderTest.BuilderTestActor], VehicleSpawnPadObjectBuilder(GlobalDefinitions.spawn_pad, 1), hub), "pad")
+      val actor = system.actorOf(Props(classOf[ServerObjectBuilderTest.BuilderTestActor], ServerObjectBuilder(1,
+        VehicleSpawnPad.Constructor(Vector3(1.1f, 2.2f, 3.3f), Vector3(4.4f, 5.5f, 6.6f))
+      ), hub), "pad")
       actor ! "!"
 
-      val reply = receiveOne(Duration.create(100, "ms"))
+      val reply = receiveOne(Duration.create(1000, "ms"))
       assert(reply.isInstanceOf[VehicleSpawnPad])
       assert(reply.asInstanceOf[VehicleSpawnPad].HasGUID)
       assert(reply.asInstanceOf[VehicleSpawnPad].GUID == PlanetSideGUID(1))
+      assert(reply.asInstanceOf[VehicleSpawnPad].Position == Vector3(1.1f, 2.2f, 3.3f))
+      assert(reply.asInstanceOf[VehicleSpawnPad].Orientation == Vector3(4.4f, 5.5f, 6.6f))
       assert(reply == hub(1).get)
     }
   }

pslogin/src/main/scala/Maps.scala

@@ -0,0 +1,150 @@
+// Copyright (c) 2017 PSForever
+import net.psforever.objects.zones.ZoneMap
+import net.psforever.objects.GlobalDefinitions._
+import net.psforever.objects.serverobject.ServerObjectBuilder
+import net.psforever.objects.serverobject.doors.Door
+import net.psforever.objects.serverobject.implantmech.ImplantTerminalMech
+import net.psforever.objects.serverobject.locks.IFFLock
+import net.psforever.objects.serverobject.pad.VehicleSpawnPad
+import net.psforever.objects.serverobject.terminals.Terminal
+import net.psforever.types.Vector3
+
+object Maps {
+  val map1 = new ZoneMap("map01")
+
+  val map2 = new ZoneMap("map02")
+
+  val map3 = new ZoneMap("map03")
+
+  val map4 = new ZoneMap("map04")
+
+  val map5 = new ZoneMap("map05")
+
+  val map6 = new ZoneMap("map06")
+
+  val map7 = new ZoneMap("map07")
+
+  val map8 = new ZoneMap("map08")
+
+  val map9 = new ZoneMap("map09")
+
+  val map10 = new ZoneMap("map10")
+
+  val map11 = new ZoneMap("map11")
+
+  val map12 = new ZoneMap("map12")
+
+  val map13 = new ZoneMap("map13") {
+    LocalObject(ServerObjectBuilder(330, Door.Constructor))
+    LocalObject(ServerObjectBuilder(332, Door.Constructor))
+    LocalObject(ServerObjectBuilder(362, Door.Constructor))
+    LocalObject(ServerObjectBuilder(370, Door.Constructor))
+    LocalObject(ServerObjectBuilder(371, Door.Constructor))
+    LocalObject(ServerObjectBuilder(372, Door.Constructor))
+    LocalObject(ServerObjectBuilder(373, Door.Constructor))
+    LocalObject(ServerObjectBuilder(374, Door.Constructor))
+    LocalObject(ServerObjectBuilder(375, Door.Constructor))
+    LocalObject(ServerObjectBuilder(394, Door.Constructor))
+    LocalObject(ServerObjectBuilder(395, Door.Constructor))
+    LocalObject(ServerObjectBuilder(396, Door.Constructor))
+    LocalObject(ServerObjectBuilder(397, Door.Constructor))
+    LocalObject(ServerObjectBuilder(398, Door.Constructor))
+    LocalObject(ServerObjectBuilder(462, Door.Constructor))
+    LocalObject(ServerObjectBuilder(463, Door.Constructor))
+    LocalObject(ServerObjectBuilder(520, ImplantTerminalMech.Constructor)) //Hart B
+    LocalObject(ServerObjectBuilder(522, ImplantTerminalMech.Constructor)) //Hart C
+    LocalObject(ServerObjectBuilder(523, ImplantTerminalMech.Constructor)) //Hart C
+    LocalObject(ServerObjectBuilder(524, ImplantTerminalMech.Constructor)) //Hart C
+    LocalObject(ServerObjectBuilder(525, ImplantTerminalMech.Constructor)) //Hart C
+    LocalObject(ServerObjectBuilder(526, ImplantTerminalMech.Constructor)) //Hart C
+    LocalObject(ServerObjectBuilder(527, ImplantTerminalMech.Constructor)) //Hart C
+    LocalObject(ServerObjectBuilder(528, ImplantTerminalMech.Constructor)) //Hart C
+    LocalObject(ServerObjectBuilder(529, ImplantTerminalMech.Constructor)) //Hart C
+    LocalObject(ServerObjectBuilder(556, IFFLock.Constructor))
+    LocalObject(ServerObjectBuilder(558, IFFLock.Constructor))
+    LocalObject(ServerObjectBuilder(186, Terminal.Constructor(cert_terminal)))
+    LocalObject(ServerObjectBuilder(187, Terminal.Constructor(cert_terminal)))
+    LocalObject(ServerObjectBuilder(188, Terminal.Constructor(cert_terminal)))
+    LocalObject(ServerObjectBuilder(853, Terminal.Constructor(order_terminal)))
+    LocalObject(ServerObjectBuilder(855, Terminal.Constructor(order_terminal)))
+    LocalObject(ServerObjectBuilder(860, Terminal.Constructor(order_terminal)))
+    LocalObject(ServerObjectBuilder(1081, Terminal.Constructor(implant_terminal_interface))) //tube 520
+    LocalObject(ServerObjectBuilder(1082, Terminal.Constructor(implant_terminal_interface))) //TODO guid not correct
+    LocalObject(ServerObjectBuilder(1083, Terminal.Constructor(implant_terminal_interface))) //TODO guid not correct
+    LocalObject(ServerObjectBuilder(1084, Terminal.Constructor(implant_terminal_interface))) //TODO guid not correct
+    LocalObject(ServerObjectBuilder(1085, Terminal.Constructor(implant_terminal_interface))) //TODO guid not correct
+    LocalObject(ServerObjectBuilder(1086, Terminal.Constructor(implant_terminal_interface))) //TODO guid not correct
+    LocalObject(ServerObjectBuilder(1087, Terminal.Constructor(implant_terminal_interface))) //TODO guid not correct
+    LocalObject(ServerObjectBuilder(1088, Terminal.Constructor(implant_terminal_interface))) //TODO guid not correct
+    LocalObject(ServerObjectBuilder(1089, Terminal.Constructor(implant_terminal_interface))) //TODO guid not correct
+    LocalObject(ServerObjectBuilder(1063, Terminal.Constructor(ground_vehicle_terminal)))
+    LocalObject(ServerObjectBuilder(500,
+      VehicleSpawnPad.Constructor(Vector3(3506.0f, 2820.0f, 92.0f), Vector3(0f, 0f, 270.0f))
+    )) //TODO guid not correct
+    LocalObject(ServerObjectBuilder(304, Terminal.Constructor(dropship_vehicle_terminal)))
+    LocalObject(ServerObjectBuilder(501,
+      VehicleSpawnPad.Constructor(Vector3(3508.9844f, 2895.961f, 92.296875f), Vector3(0f, 0f, 270.0f))
+    )) //TODO guid not correct
+
+    LocalBases = 30
+
+    ObjectToBase(330, 29)
+    ObjectToBase(332, 29)
+    //ObjectToBase(520, 29)
+    ObjectToBase(522, 29)
+    ObjectToBase(523, 29)
+    ObjectToBase(524, 29)
+    ObjectToBase(525, 29)
+    ObjectToBase(526, 29)
+    ObjectToBase(527, 29)
+    ObjectToBase(528, 29)
+    ObjectToBase(529, 29)
+    ObjectToBase(556, 29)
+    ObjectToBase(558, 29)
+    ObjectToBase(1081, 29)
+    ObjectToBase(1063, 2) //TODO unowned courtyard terminal?
+    ObjectToBase(500, 2) //TODO unowned courtyard spawnpad?
+    ObjectToBase(304, 2) //TODO unowned courtyard terminal?
+    ObjectToBase(501, 2) //TODO unowned courtyard spawnpad?
+
+    DoorToLock(330, 558)
+    DoorToLock(332, 556)
+    TerminalToSpawnPad(1063, 500)
+    TerminalToSpawnPad(304, 501)
+    TerminalToInterface(520, 1081)
+    TerminalToInterface(522, 1082)
+    TerminalToInterface(523, 1083)
+    TerminalToInterface(524, 1084)
+    TerminalToInterface(525, 1085)
+    TerminalToInterface(526, 1086)
+    TerminalToInterface(527, 1087)
+    TerminalToInterface(528, 1088)
+    TerminalToInterface(529, 1089)
+  }
+
+  val map14 = new ZoneMap("map13")
+
+  val map15 = new ZoneMap("map13")
+
+  val map16 = new ZoneMap("map13")
+
+  val ugd01 = new ZoneMap("ugd01")
+
+  val ugd02 = new ZoneMap("ugd02")
+
+  val ugd03 = new ZoneMap("ugd03")
+
+  val ugd04 = new ZoneMap("ugd04")
+
+  val ugd05 = new ZoneMap("ugd05")
+
+  val ugd06 = new ZoneMap("ugd06")
+
+  val map96 = new ZoneMap("ugd06")
+
+  val map97 = new ZoneMap("map97")
+
+  val map98 = new ZoneMap("map98")
+
+  val map99 = new ZoneMap("map99")
+}

pslogin/src/main/scala/PsLogin.scala

@@ -3,7 +3,7 @@ import java.net.InetAddress
 import java.io.File
 import java.util.Locale
 
-import akka.actor.{ActorContext, ActorRef, ActorSystem, Props}
+import akka.actor.{ActorRef, ActorSystem, Props}
 import akka.routing.RandomPool
 import ch.qos.logback.classic.LoggerContext
 import ch.qos.logback.classic.joran.JoranConfigurator
@@ -14,8 +14,6 @@ import com.typesafe.config.ConfigFactory
 import net.psforever.crypto.CryptoInterface
 import net.psforever.objects.zones._
 import net.psforever.objects.guid.TaskResolver
-import net.psforever.objects.serverobject.builders._
-import net.psforever.types.Vector3
 import org.slf4j
 import org.fusesource.jansi.Ansi._
 import org.fusesource.jansi.Ansi.Color._
@@ -228,116 +226,15 @@ object PsLogin {
   }
 
   def createContinents() : List[Zone] = {
-    val map13 = new ZoneMap("map13") {
+    import Zones._
-      import net.psforever.objects.GlobalDefinitions._
+    List(
-
+      z1, z2, z3, z4, z5, z6, z7, z8, z9, z10,
-      LocalObject(DoorObjectBuilder(door, 330))
+      home1, tzshtr, tzdrtr, tzcotr,
-      LocalObject(DoorObjectBuilder(door, 332))
+      home2, tzshnc, tzdrnc, tzconc,
-      LocalObject(DoorObjectBuilder(door, 362))
+      home3, tzshvs, tzdrvs, tzcovs,
-      LocalObject(DoorObjectBuilder(door, 370))
+      c1, c2, c3, c4, c5, c6,
-      LocalObject(DoorObjectBuilder(door, 371))
+      i1, i2, i3, i4
-      LocalObject(DoorObjectBuilder(door, 372))
+    )
-      LocalObject(DoorObjectBuilder(door, 373))
-      LocalObject(DoorObjectBuilder(door, 374))
-      LocalObject(DoorObjectBuilder(door, 375))
-      LocalObject(DoorObjectBuilder(door, 394))
-      LocalObject(DoorObjectBuilder(door, 395))
-      LocalObject(DoorObjectBuilder(door, 396))
-      LocalObject(DoorObjectBuilder(door, 397))
-      LocalObject(DoorObjectBuilder(door, 398))
-      LocalObject(DoorObjectBuilder(door, 462))
-      LocalObject(DoorObjectBuilder(door, 463))
-      LocalObject(ImplantTerminalMechObjectBuilder(implant_terminal_mech, 520)) //Hart B
-      LocalObject(ImplantTerminalMechObjectBuilder(implant_terminal_mech, 522)) //Hart C
-      LocalObject(ImplantTerminalMechObjectBuilder(implant_terminal_mech, 523)) //Hart C
-      LocalObject(ImplantTerminalMechObjectBuilder(implant_terminal_mech, 524)) //Hart C
-      LocalObject(ImplantTerminalMechObjectBuilder(implant_terminal_mech, 525)) //Hart C
-      LocalObject(ImplantTerminalMechObjectBuilder(implant_terminal_mech, 526)) //Hart C
-      LocalObject(ImplantTerminalMechObjectBuilder(implant_terminal_mech, 527)) //Hart C
-      LocalObject(ImplantTerminalMechObjectBuilder(implant_terminal_mech, 528)) //Hart C
-      LocalObject(ImplantTerminalMechObjectBuilder(implant_terminal_mech, 529)) //Hart C
-      LocalObject(IFFLockObjectBuilder(lock_external, 556))
-      LocalObject(IFFLockObjectBuilder(lock_external, 558))
-      LocalObject(TerminalObjectBuilder(cert_terminal, 186))
-      LocalObject(TerminalObjectBuilder(cert_terminal, 187))
-      LocalObject(TerminalObjectBuilder(cert_terminal, 188))
-      LocalObject(TerminalObjectBuilder(order_terminal, 853))
-      LocalObject(TerminalObjectBuilder(order_terminal, 855))
-      LocalObject(TerminalObjectBuilder(order_terminal, 860))
-      LocalObject(TerminalObjectBuilder(implant_terminal_interface, 1081)) //tube 520
-      LocalObject(TerminalObjectBuilder(implant_terminal_interface, 1082)) //TODO guid not correct
-      LocalObject(TerminalObjectBuilder(implant_terminal_interface, 1083)) //TODO guid not correct
-      LocalObject(TerminalObjectBuilder(implant_terminal_interface, 1084)) //TODO guid not correct
-      LocalObject(TerminalObjectBuilder(implant_terminal_interface, 1085)) //TODO guid not correct
-      LocalObject(TerminalObjectBuilder(implant_terminal_interface, 1086)) //TODO guid not correct
-      LocalObject(TerminalObjectBuilder(implant_terminal_interface, 1087)) //TODO guid not correct
-      LocalObject(TerminalObjectBuilder(implant_terminal_interface, 1088)) //TODO guid not correct
-      LocalObject(TerminalObjectBuilder(implant_terminal_interface, 1089)) //TODO guid not correct
-      LocalObject(TerminalObjectBuilder(ground_vehicle_terminal, 1063))
-      LocalObject(VehicleSpawnPadObjectBuilder(spawn_pad, 500)) //TODO guid not correct
-      LocalObject(TerminalObjectBuilder(dropship_vehicle_terminal, 304))
-      LocalObject(VehicleSpawnPadObjectBuilder(spawn_pad, 501)) //TODO guid not correct
-
-      LocalBases = 30
-
-      ObjectToBase(330, 29)
-      ObjectToBase(332, 29)
-      //ObjectToBase(520, 29)
-      ObjectToBase(522, 29)
-      ObjectToBase(523, 29)
-      ObjectToBase(524, 29)
-      ObjectToBase(525, 29)
-      ObjectToBase(526, 29)
-      ObjectToBase(527, 29)
-      ObjectToBase(528, 29)
-      ObjectToBase(529, 29)
-      ObjectToBase(556, 29)
-      ObjectToBase(558, 29)
-      ObjectToBase(1081, 29)
-      ObjectToBase(1063, 2) //TODO unowned courtyard terminal?
-      ObjectToBase(500, 2) //TODO unowned courtyard spawnpad?
-      ObjectToBase(304, 2) //TODO unowned courtyard terminal?
-      ObjectToBase(501, 2) //TODO unowned courtyard spawnpad?
-
-      DoorToLock(330, 558)
-      DoorToLock(332, 556)
-      TerminalToSpawnPad(1063, 500)
-      TerminalToSpawnPad(304, 501)
-      TerminalToInterface(520, 1081)
-      TerminalToInterface(522, 1082)
-      TerminalToInterface(523, 1083)
-      TerminalToInterface(524, 1084)
-      TerminalToInterface(525, 1085)
-      TerminalToInterface(526, 1086)
-      TerminalToInterface(527, 1087)
-      TerminalToInterface(528, 1088)
-      TerminalToInterface(529, 1089)
-    }
-    val home3 = new Zone("home3", map13, 13) {
-      override def Init(implicit context : ActorContext) : Unit = {
-        super.Init(context)
-
-        import net.psforever.types.PlanetSideEmpire
-        Base(2).get.Faction = PlanetSideEmpire.VS //HART building C
-        Base(29).get.Faction = PlanetSideEmpire.NC //South Villa Gun Tower
-
-        GUID(500) match {
-          case Some(pad) =>
-            pad.Position = Vector3(3506.0f, 2820.0f, 92.0f)
-            pad.Orientation = Vector3(0f, 0f, 270.0f)
-          case None => ;
-        }
-        GUID(501) match {
-          case Some(pad) =>
-            pad.Position = Vector3(3508.9844f, 2895.961f, 92.296875f)
-            pad.Orientation = Vector3(0f, 0f, 270.0f)
-          case None => ;
-        }
-      }
-    }
-
-    home3 ::
-      Nil
   }
 
   def main(args : Array[String]) : Unit = {

pslogin/src/main/scala/Zones.scala

@@ -0,0 +1,77 @@
+// Copyright (c) 2017 PSForever
+import akka.actor.ActorContext
+import net.psforever.objects.zones.Zone
+
+object Zones {
+  val z1 = new Zone("z1", Maps.map1, 1)
+
+  val z2 = new Zone("z2", Maps.map2, 2)
+
+  val z3 = new Zone("z3", Maps.map3, 3)
+
+  val z4 = new Zone("z4", Maps.map4, 4)
+
+  val z5 = new Zone("z5", Maps.map5, 5)
+
+  val z6 = new Zone("z6", Maps.map6, 6)
+
+  val z7 = new Zone("z7", Maps.map7, 7)
+
+  val z8 = new Zone("z8", Maps.map8, 8)
+
+  val z9 = new Zone("z9", Maps.map9, 9)
+
+  val z10 = new Zone("z10", Maps.map10, 10)
+
+  val home1 = new Zone("home1", Maps.map11, 11)
+
+  val home2 = new Zone("home2", Maps.map12, 12)
+
+  val home3 = new Zone("home3", Maps.map13, 13) {
+    override def Init(implicit context : ActorContext) : Unit = {
+      super.Init(context)
+
+      import net.psforever.types.PlanetSideEmpire
+      Base(2).get.Faction = PlanetSideEmpire.VS //HART building C
+      Base(29).get.Faction = PlanetSideEmpire.NC //South Villa Gun Tower
+    }
+  }
+
+  val tzshtr = new Zone("tzshtr", Maps.map14, 14)
+
+  val tzdrtr = new Zone("tzsdrtr", Maps.map15, 15)
+
+  val tzcotr = new Zone("tzcotr", Maps.map16, 16)
+
+  val tzshnc = new Zone("tzshnc", Maps.map14, 17)
+
+  val tzdrnc = new Zone("tzdrnc", Maps.map15, 18)
+
+  val tzconc = new Zone("tzconc", Maps.map16, 19)
+
+  val tzshvs = new Zone("tzshvs", Maps.map14, 20)
+
+  val tzdrvs = new Zone("tzdrvs", Maps.map15, 21)
+
+  val tzcovs = new Zone("tzcovs", Maps.map16, 22)
+
+  val c1 = new Zone("c1", Maps.ugd01, 23)
+
+  val c2 = new Zone("c2", Maps.ugd02, 24)
+
+  val c3 = new Zone("c3", Maps.ugd03, 25)
+
+  val c4 = new Zone("c4", Maps.ugd04, 26)
+
+  val c5 = new Zone("c5", Maps.ugd05, 27)
+
+  val c6 = new Zone("c6", Maps.ugd06, 28)
+
+  val i1 = new Zone("i1", Maps.map96, 29)
+
+  val i2 = new Zone("i2", Maps.map97, 30)
+
+  val i3 = new Zone("i3", Maps.map98, 31)
+
+  val i4 = new Zone("i4", Maps.map99, 32)
+}