Interim 2 (#477)

* changed DefaultCancellable.obj with Default.Cancellable and deleted the former (as unnecessary)

* changed ActorRef.noSender with Default.Actor for PlanetSideServerObject entities

* Actor.noSender -> ActorRef.noSender, for consistency

* player name in log messages; zoneLoaded and zoneReload flags; upstream message count

* Default object tests; expanded the set current avatar loop

* fallback cases for unsuccessful zone/avatar load process

* completing the trials of the god Travis

* forgot to reactivate kamon

common/src/main/scala/net/psforever/objects/Default.scala

@@ -0,0 +1,47 @@
+// Copyright (c) 2017 PSForever
+package net.psforever.objects
+
+object Default {
+  //cancellable
+  import akka.actor.Cancellable
+  protected class InternalCancellable extends Cancellable {
+    override def cancel : Boolean = true
+    override def isCancelled : Boolean = true
+  }
+  private val cancellable : Cancellable = new InternalCancellable
+
+  /**
+    * Used to initialize the value of a re-usable `Cancellable` object.
+    * By convention, it always acts like it has been cancelled before and can be cancelled.
+    * Should be replaced with pertinent `Cancellable` logic through the initialization of an executor.
+    */
+  final def Cancellable : Cancellable = cancellable
+
+  //actor
+  import akka.actor.{Actor => AkkaActor, ActorRef, ActorSystem, DeadLetter, Props}
+  /**
+    * An actor designed to wrap around `deadLetters` and redirect all normal messages to it.
+    * This measure is more to "protect" `deadLetters` than anything else.
+    * Even if it is stopped, it still fulfills exactly the same purpose!
+    * The original target to which the actor is assigned will not be implicitly accredited.
+    */
+  private class DefaultActor extends AkkaActor {
+    def receive : Receive = {
+      case msg => context.system.deadLetters ! DeadLetter(msg, sender, self)
+    }
+  }
+  private var defaultRef : ActorRef = ActorRef.noSender
+  /**
+    * Instigate the default actor.
+    * @param sys the actor universe under which this default actor will exist
+    * @return the new default actor
+    */
+  def apply(sys : ActorSystem) : ActorRef = {
+    if(defaultRef == ActorRef.noSender) {
+      defaultRef = sys.actorOf(Props[DefaultActor], name = s"system-default-actor")
+    }
+    defaultRef
+  }
+
+  final def Actor : ActorRef = defaultRef
+}

common/src/main/scala/net/psforever/objects/DefaultCancellable.scala

@@ -1,18 +0,0 @@
-// Copyright (c) 2017 PSForever
-package net.psforever.objects
-
-/**
-  * Used to initialize the value of a re-usable `Cancellable` object.
-  * By convention, it always acts like it has been cancelled before and can be cancelled.
-  * Should be replaced with pertinent `Cancellable` logic through the initialization of an executor.
-  */
-object DefaultCancellable {
-  import akka.actor.Cancellable
-
-  protected class InternalCancellable extends Cancellable {
-    override def cancel : Boolean = true
-    override def isCancelled : Boolean = true
-  }
-
-  final val obj : Cancellable = new InternalCancellable
-}

common/src/main/scala/net/psforever/objects/ImplantSlot.scala

@@ -20,7 +20,7 @@ class ImplantSlot {
   /** whether this implant is ready for use */
   private var initialized : Boolean = false
   /** a cancellable timer that can be used to set an implant as initialized once complete */
-  private var initializeTimer: Cancellable = DefaultCancellable.obj
+  private var initializeTimer: Cancellable = Default.Cancellable
 
   /** is this implant active */
   private var active : Boolean = false

common/src/main/scala/net/psforever/objects/Player.scala

@@ -125,7 +125,7 @@ class Player(private val core : Avatar) extends PlanetSideServerObject
   def Stamina_=(assignStamina : Int) : Int = {
     stamina = if(isAlive) { math.min(math.max(0, assignStamina), MaxStamina) } else { 0 }
 
-    if(Actor != ActorRef.noSender) {
+    if(Actor != Default.Actor) {
       Actor ! Player.StaminaChanged(Stamina)
     }
 

common/src/main/scala/net/psforever/objects/Vehicle.scala

@@ -1,7 +1,6 @@
 // Copyright (c) 2017 PSForever
 package net.psforever.objects
 
-import akka.actor.ActorRef
 import net.psforever.objects.definition.VehicleDefinition
 import net.psforever.objects.equipment.{Equipment, EquipmentSize, EquipmentSlot, JammableUnit}
 import net.psforever.objects.inventory.{Container, GridInventory, InventoryTile}
@@ -546,14 +545,7 @@ class Vehicle(private val vehicleDef : VehicleDefinition) extends AmenityOwner
       false
   }
 
-  override def hashCode() : Int = {
-    Actor match {
-      case ActorRef.noSender =>
-        super.hashCode()
-      case actor =>
-        actor.hashCode()
-    }
-  }
+  override def hashCode() : Int = Actor.hashCode()
 
   /**
     * Override the string representation to provide additional information.

common/src/main/scala/net/psforever/objects/avatar/PlayerControl.scala

@@ -2,7 +2,7 @@
 package net.psforever.objects.avatar
 
 import akka.actor.Actor
-import net.psforever.objects.{DefaultCancellable, GlobalDefinitions, ImplantSlot, Player, Players, Tool}
+import net.psforever.objects.{Default, GlobalDefinitions, ImplantSlot, Player, Players, Tool}
 import net.psforever.objects.ballistics.{PlayerSource, ResolvedProjectile, SourceEntry}
 import net.psforever.objects.definition.ImplantDefinition
 import net.psforever.objects.equipment.{Ammo, JammableBehavior, JammableUnit}
@@ -33,7 +33,7 @@ class PlayerControl(player : Player) extends Actor
   private [this] val damageLog = org.log4s.getLogger(Damageable.LogChannel)
 
   // A collection of timers for each slot to trigger stamina drain on an interval
-  val implantSlotStaminaDrainTimers = mutable.HashMap(0 -> DefaultCancellable.obj, 1 -> DefaultCancellable.obj, 2 -> DefaultCancellable.obj)
+  val implantSlotStaminaDrainTimers = mutable.HashMap(0 -> Default.Cancellable, 1 -> Default.Cancellable, 2 -> Default.Cancellable)
 
   def receive : Receive = jammableBehavior
     .orElse(takesDamage)
@@ -46,7 +46,7 @@ class PlayerControl(player : Player) extends Actor
       if(status == 0 && (implantSlot.Active || !implantSlot.Initialized)) {
         // Cancel stamina drain timer
         implantSlotStaminaDrainTimers(slot).cancel()
-        implantSlotStaminaDrainTimers(slot) = DefaultCancellable.obj
+        implantSlotStaminaDrainTimers(slot) = Default.Cancellable
 
         implantSlot.Active = false
         player.Zone.AvatarEvents ! AvatarServiceMessage(player.Zone.Id, AvatarAction.PlanetsideAttribute(player.GUID, 28, player.Implant(slot).id * 2)) // Deactivation sound / effect
@@ -60,7 +60,7 @@ class PlayerControl(player : Player) extends Actor
               // todo: Deactivate implants server side when actions like zoning happen. (Other actions?)
               log.warn(s"Implant ${slot} is already active, but activating again")
               implantSlotStaminaDrainTimers(slot).cancel()
-              implantSlotStaminaDrainTimers(slot) = DefaultCancellable.obj
+              implantSlotStaminaDrainTimers(slot) = Default.Cancellable
             }
             implantSlot.Active = true
 
@@ -104,9 +104,9 @@ class PlayerControl(player : Player) extends Actor
       if(implantSlot.Installed.isDefined) {
         player.Zone.AvatarEvents ! AvatarServiceMessage(player.Name, AvatarAction.SendResponse(player.GUID, AvatarImplantMessage(player.GUID, ImplantAction.Initialization, slot, 1)))
         implantSlot.Initialized = true
-        if(implantSlot.InitializeTimer != DefaultCancellable.obj) {
+        if(implantSlot.InitializeTimer != Default.Cancellable) {
           implantSlot.InitializeTimer.cancel()
-          implantSlot.InitializeTimer = DefaultCancellable.obj
+          implantSlot.InitializeTimer = Default.Cancellable
         }
       }
 
@@ -463,9 +463,9 @@ object PlayerControl {
     val implantSlot = player.ImplantSlot(slot)
 
     implantSlot.Initialized = false
-    if(implantSlot.InitializeTimer != DefaultCancellable.obj) {
+    if(implantSlot.InitializeTimer != Default.Cancellable) {
       implantSlot.InitializeTimer.cancel()
-      implantSlot.InitializeTimer = DefaultCancellable.obj
+      implantSlot.InitializeTimer = Default.Cancellable
     }
     player.Zone.AvatarEvents ! AvatarServiceMessage(player.Zone.Id, AvatarAction.SendResponse(player.GUID, AvatarImplantMessage(player.GUID, ImplantAction.Initialization, slot, 0)))
   }

common/src/main/scala/net/psforever/objects/ce/TelepadLike.scala

@@ -2,8 +2,8 @@
 package net.psforever.objects.ce
 
 import akka.actor.ActorContext
+import net.psforever.objects.{Default, PlanetSideGameObject, TelepadDeployable, Vehicle}
 import net.psforever.objects.serverobject.PlanetSideServerObject
-import net.psforever.objects.{PlanetSideGameObject, TelepadDeployable, Vehicle}
 import net.psforever.objects.serverobject.structures.Amenity
 import net.psforever.objects.vehicles.Utility
 import net.psforever.objects.zones.Zone
@@ -50,8 +50,8 @@ object TelepadLike {
     */
   def Setup(obj : Amenity, context : ActorContext) : Unit = {
     obj.asInstanceOf[TelepadLike].Router = obj.Owner.GUID
-    import akka.actor.{ActorRef, Props}
-    if(obj.Actor == ActorRef.noSender) {
+    import akka.actor.Props
+    if(obj.Actor == Default.Actor) {
       obj.Actor = context.actorOf(Props(classOf[TelepadControl], obj), PlanetSideServerObject.UniqueActorName(obj))
     }
   }

common/src/main/scala/net/psforever/objects/definition/SimpleDeployableDefinition.scala

@@ -1,8 +1,8 @@
 // Copyright (c) 2017 PSForever
 package net.psforever.objects.definition
 
-import akka.actor.{ActorContext, ActorRef}
-import net.psforever.objects.PlanetSideGameObject
+import akka.actor.ActorContext
+import net.psforever.objects.{Default, PlanetSideGameObject}
 import net.psforever.objects.ce.{Deployable, DeployableCategory, DeployedItem}
 import net.psforever.objects.definition.converter.SmallDeployableConverter
 import net.psforever.objects.serverobject.PlanetSideServerObject
@@ -68,6 +68,6 @@ object SimpleDeployableDefinition {
 
   def SimpleUninitialize(obj : PlanetSideServerObject, context : ActorContext) : Unit = {
     context.stop(obj.Actor)
-    obj.Actor = ActorRef.noSender
+    obj.Actor = Default.Actor
   }
 }

common/src/main/scala/net/psforever/objects/equipment/JammingUnit.scala

@@ -2,7 +2,7 @@
 package net.psforever.objects.equipment
 
 import akka.actor.{Actor, Cancellable}
-import net.psforever.objects.{DefaultCancellable, PlanetSideGameObject, Tool}
+import net.psforever.objects.{Default, PlanetSideGameObject, Tool}
 import net.psforever.objects.ballistics.ResolvedProjectile
 import net.psforever.objects.serverobject.PlanetSideServerObject
 import net.psforever.objects.vehicles.MountedWeapons
@@ -111,9 +111,9 @@ trait JammableBehavior {
   /** flag for jammed sound */
   protected var jammedSound : Boolean = false
   /** the sound timer */
-  protected var jammeredSoundTimer : Cancellable = DefaultCancellable.obj
+  protected var jammeredSoundTimer : Cancellable = Default.Cancellable
   /** the effect timer */
-  protected var jammeredStatusTimer : Cancellable = DefaultCancellable.obj
+  protected var jammeredStatusTimer : Cancellable = Default.Cancellable
 
   /** `ZoneAware` is used for callback to the event systems */
   def JammableObject : PlanetSideServerObject with JammableUnit with ZoneAware

common/src/main/scala/net/psforever/objects/guid/TaskResolver.scala

@@ -5,6 +5,7 @@ import java.util.concurrent.TimeoutException
 
 import akka.actor.{Actor, ActorRef, Cancellable}
 import akka.routing.Broadcast
+import net.psforever.objects.Default
 
 import scala.annotation.tailrec
 import scala.collection.mutable.ListBuffer
@@ -16,7 +17,7 @@ class TaskResolver() extends Actor {
   /** list of all work currently managed by this resolver */
   private val tasks : ListBuffer[TaskResolver.TaskEntry] = new ListBuffer[TaskResolver.TaskEntry]
   /** scheduled termination of tardy managed work */
-  private var timeoutCleanup : Cancellable = TaskResolver.DefaultCancellable
+  private var timeoutCleanup : Cancellable = Default.Cancellable
   /** logging utilities; default to tracing */
   private[this] val log = org.log4s.getLogger
   private def trace(msg : String) = log.trace(msg)
@@ -109,7 +110,7 @@ class TaskResolver() extends Actor {
     * @param resolver the `TaskResolver` that distributed this work, thus determining that this work is a sub-task;
     *                 by default, no one, as the work is identified as a main task
     */
-  private def QueueSubtasks(task : Task, subtasks : List[TaskResolver.GiveTask], resolver : ActorRef = Actor.noSender) : Unit = {
+  private def QueueSubtasks(task : Task, subtasks : List[TaskResolver.GiveTask], resolver : ActorRef = ActorRef.noSender) : Unit = {
     val entry : TaskResolver.TaskEntry = TaskResolver.TaskEntry(task, subtasks.map(task => task.task), resolver)
     tasks += entry
     trace(s"enqueue task $task")
@@ -347,7 +348,7 @@ object TaskResolver {
     * //@param isASubtask whether this work is intermediary or the last in a dependency chain
     * @param supertaskRef the `TaskResolver` that will handle work that depends on the outcome of this work
     */
-  private final case class TaskEntry(task : Task, subtasks : List[Task] = Nil, supertaskRef : ActorRef = Actor.noSender) {
+  private final case class TaskEntry(task : Task, subtasks : List[Task] = Nil, supertaskRef : ActorRef = ActorRef.noSender) {
     private var start : Long = 0L
     private var isExecuting : Boolean = false
 
@@ -368,14 +369,6 @@ object TaskResolver {
     }
   }
 
-  /**
-    * A placeholder `Cancellable` object for the time-out checking functionality.
-    */
-  private final val DefaultCancellable = new Cancellable() {
-    def cancel : Boolean = true
-    def isCancelled() : Boolean = true
-  }
-
   /**
     * Scan across a group of tasks to determine which ones match the target completion status.
     * @param iter an `Iterator` of enqueued `TaskEntry` indices

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

@@ -2,41 +2,67 @@
 package net.psforever.objects.serverobject
 
 import akka.actor.ActorRef
-import net.psforever.objects.PlanetSideGameObject
+import net.psforever.objects.{Default, PlanetSideGameObject}
 import net.psforever.objects.entity.NoGUIDException
 import net.psforever.objects.serverobject.affinity.FactionAffinity
 import net.psforever.objects.zones.ZoneAware
 
 /**
   * An object layered on top of the standard game object class that maintains an internal `ActorRef`.
-  * A measure of synchronization can be managed using this `Actor`.
+  * A measure of synchronization can be managed using this `Actor` as a "controlling agent."
   */
 abstract class PlanetSideServerObject extends PlanetSideGameObject
   with FactionAffinity
   with ZoneAware {
-  private var actor = ActorRef.noSender
+  private var actor : ActorRef = ActorRef.noSender
+  private var getActorFunc : ()=>ActorRef = PlanetSideServerObject.getDefaultActor
 
   /**
     * Retrieve a reference to the internal `Actor`.
     * @return the internal `ActorRef`
     */
-  def Actor : ActorRef = actor
+  def Actor : ActorRef = getActorFunc()
 
   /**
     * Assign an `Actor` to act for this server object.
-    * This reference is only set once, that is, as long as the internal `ActorRef` directs to `Actor.noSender` (`null`).
+    * This reference is only set once, that is, as long as the internal `ActorRef` directs to `ActorRef.noSender` (`null`).
     * @param control the `Actor` whose functionality will govern this server object
     * @return the current internal `ActorRef`
     */
   def Actor_=(control : ActorRef) : ActorRef =  {
-    if(actor == ActorRef.noSender || control == ActorRef.noSender) {
-      actor = control
+    if(control == Default.Actor) {
+      ResetControl()
     }
-    actor
+    else {
+      actor = control
+      getActorFunc = PlanetSideServerObject.doGetLocalActor(this)
+      actor
+    }
+  }
+
+  def ResetControl() : ActorRef = {
+    getActorFunc = PlanetSideServerObject.getDefaultActor
+    val out = actor
+    actor = ActorRef.noSender
+    out
   }
 }
 
 object PlanetSideServerObject {
+  /**
+    * Before the internal control agency of a respective server object is ever set,
+    * a default control agency will be produced.
+    * @return the value pointed to by `Default.Actor`
+    */
+  private def getDefaultActor() : ActorRef = { Default.Actor }
+
+  /**
+    * Allow retrieving a reference to the internal `Actor`.
+    * @see o the server object
+    * @return the internal `ActorRef`
+    */
+  private def doGetLocalActor(o : PlanetSideServerObject)() : ActorRef = o.actor
+
   /**
     * `Actor` entities require unique names over the course of the lifetime of the `ActorSystem` object.
     * To produce this name, a composition of three strings separated by underscores is assembled.<br>

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

@@ -5,7 +5,7 @@ import akka.actor.{ActorContext, Cancellable, Props}
 import net.psforever.objects.serverobject.affinity.{FactionAffinity, FactionAffinityBehavior}
 import net.psforever.objects.serverobject.pad.process.{VehicleSpawnControlBase, VehicleSpawnControlConcealPlayer}
 import net.psforever.objects.zones.Zone
-import net.psforever.objects.{DefaultCancellable, Player, Vehicle}
+import net.psforever.objects.{Default, Player, Vehicle}
 import services.RemoverActor
 import services.vehicle.VehicleServiceMessage
 
@@ -32,7 +32,7 @@ import scala.concurrent.duration._
   */
 class VehicleSpawnControl(pad : VehicleSpawnPad) extends VehicleSpawnControlBase(pad) with FactionAffinityBehavior.Check {
   /** a reminder sent to future customers */
-  var periodicReminder : Cancellable = DefaultCancellable.obj
+  var periodicReminder : Cancellable = Default.Cancellable
   /** a list of vehicle orders that have been submitted for this spawn pad */
   var orders : List[VehicleSpawnControl.Order] = List.empty[VehicleSpawnControl.Order]
   /** the current vehicle order being acted upon;

common/src/main/scala/net/psforever/objects/serverobject/pad/process/VehicleSpawnControlSeatDriver.scala

@@ -1,8 +1,8 @@
 // Copyright (c) 2017 PSForever
 package net.psforever.objects.serverobject.pad.process
 
-import akka.actor.{ActorRef, Props}
-import net.psforever.objects.Vehicle
+import akka.actor.Props
+import net.psforever.objects.{Default, Vehicle}
 import net.psforever.objects.serverobject.pad.{VehicleSpawnControl, VehicleSpawnPad}
 
 import scala.concurrent.ExecutionContext.Implicits.global
@@ -29,7 +29,7 @@ class VehicleSpawnControlSeatDriver(pad : VehicleSpawnPad) extends VehicleSpawnC
 
   def receive : Receive = {
     case order @ VehicleSpawnControl.Order(_, vehicle) =>
-      if(vehicle.Actor == ActorRef.noSender) { //wait for a necessary vehicle component to be loaded
+      if(vehicle.Actor == Default.Actor) { //wait for a necessary vehicle component to be loaded
         context.system.scheduler.scheduleOnce(50 milliseconds, self, order)
       }
       else {

common/src/main/scala/net/psforever/objects/serverobject/painbox/PainboxControl.scala

@@ -3,7 +3,7 @@ package net.psforever.objects.serverobject.painbox
 import akka.actor.{Actor, Cancellable}
 import net.psforever.objects.serverobject.doors.Door
 import net.psforever.objects.serverobject.structures.Building
-import net.psforever.objects.{DefaultCancellable, GlobalDefinitions}
+import net.psforever.objects.{Default, GlobalDefinitions}
 import net.psforever.types.{PlanetSideEmpire, Vector3}
 import services.avatar.{AvatarAction, AvatarServiceMessage}
 
@@ -12,7 +12,7 @@ import scala.concurrent.duration._
 
 class PainboxControl(painbox: Painbox) extends Actor {
   private[this] val log = org.log4s.getLogger(s"Painbox")
-  var painboxTick: Cancellable = DefaultCancellable.obj
+  var painboxTick: Cancellable = Default.Cancellable
   var nearestDoor: Option[Door] = None
   var bBoxMinCorner = Vector3.Zero
   var bBoxMaxCorner = Vector3.Zero
@@ -97,7 +97,7 @@ class PainboxControl(painbox: Painbox) extends Actor {
     case Painbox.Stop() =>
       context.become(Stopped)
       painboxTick.cancel
-      painboxTick = DefaultCancellable.obj
+      painboxTick = Default.Cancellable
 
     case Painbox.Tick() =>
       //todo: Account for overlapping pain fields

common/src/main/scala/net/psforever/objects/serverobject/structures/Building.scala

@@ -3,8 +3,8 @@ package net.psforever.objects.serverobject.structures
 
 import java.util.concurrent.TimeUnit
 
-import akka.actor.{ActorContext, ActorRef}
-import net.psforever.objects.{GlobalDefinitions, Player}
+import akka.actor.ActorContext
+import net.psforever.objects.{Default, GlobalDefinitions, Player}
 import net.psforever.objects.definition.ObjectDefinition
 import net.psforever.objects.serverobject.generator.Generator
 import net.psforever.objects.serverobject.hackable.Hackable
@@ -118,7 +118,7 @@ class Building(private val name: String,
   }
 
   def TriggerZoneMapUpdate(): Unit = {
-    if(Actor != ActorRef.noSender) Actor ! Building.TriggerZoneMapUpdate(Zone.Number)
+    if(Actor != Default.Actor) Actor ! Building.TriggerZoneMapUpdate(Zone.Number)
   }
 
   def UpdateForceDomeStatus() : Unit = {
@@ -141,7 +141,7 @@ class Building(private val name: String,
       }
 
       if(originalStatus != ForceDomeActive) {
-        if(Actor != ActorRef.noSender) {
+        if(Actor != Default.Actor) {
           Zone.LocalEvents ! LocalServiceMessage(Zone.Id, LocalAction.UpdateForceDomeStatus(Service.defaultPlayerGUID, GUID, ForceDomeActive))
           Actor ! Building.SendMapUpdate(all_clients = true)
         }

common/src/main/scala/net/psforever/objects/serverobject/structures/BuildingControl.scala

@@ -13,8 +13,8 @@ import services.galaxy.{GalaxyAction, GalaxyResponse, GalaxyServiceMessage, Gala
 
 class BuildingControl(building : Building) extends Actor with FactionAffinityBehavior.Check {
   def FactionObject : FactionAffinity = building
-  var galaxyService : ActorRef = Actor.noSender
-  var interstellarCluster : ActorRef = Actor.noSender
+  var galaxyService : ActorRef = ActorRef.noSender
+  var interstellarCluster : ActorRef = ActorRef.noSender
   private[this] val log = org.log4s.getLogger
 
   override def preStart = {

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

@@ -2,7 +2,7 @@
 package net.psforever.objects.serverobject.terminals
 
 import akka.actor.ActorContext
-import net.psforever.objects.Player
+import net.psforever.objects.{Default, Player}
 import net.psforever.objects.serverobject.PlanetSideServerObject
 import net.psforever.objects.serverobject.structures.Amenity
 
@@ -28,8 +28,8 @@ object MatrixTerminalDefinition {
     * @param context hook to the local `Actor` system
     */
   def Setup(obj : Amenity, context : ActorContext) : Unit = {
-    import akka.actor.{ActorRef, Props}
-    if(obj.Actor == ActorRef.noSender) {
+    import akka.actor.Props
+    if(obj.Actor == Default.Actor) {
       obj.Actor = context.actorOf(Props(classOf[TerminalControl], obj), PlanetSideServerObject.UniqueActorName(obj))
     }
   }

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

@@ -3,7 +3,7 @@ package net.psforever.objects.serverobject.terminals
 
 import akka.actor.ActorContext
 import net.psforever.objects.definition.ImplantDefinition
-import net.psforever.objects.{Player, Vehicle}
+import net.psforever.objects.{Default, Player, Vehicle}
 import net.psforever.objects.equipment.Equipment
 import net.psforever.objects.loadouts.{InfantryLoadout, VehicleLoadout}
 import net.psforever.objects.inventory.InventoryItem
@@ -340,8 +340,8 @@ object OrderTerminalDefinition {
     * @param context hook to the local `Actor` system
     */
   def Setup(obj : Amenity, context : ActorContext) : Unit = {
-    import akka.actor.{ActorRef, Props}
-    if(obj.Actor == ActorRef.noSender) {
+    import akka.actor.Props
+    if(obj.Actor == Default.Actor) {
       obj.Actor = context.actorOf(Props(classOf[TerminalControl], obj), PlanetSideServerObject.UniqueActorName(obj))
     }
   }

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

@@ -1,7 +1,7 @@
 // Copyright (c) 2017 PSForever
 package net.psforever.objects.serverobject.terminals
 
-import net.psforever.objects.Player
+import net.psforever.objects.{Default, Player}
 import net.psforever.objects.serverobject.{CommonMessages, PlanetSideServerObject}
 import net.psforever.objects.serverobject.structures.Amenity
 import net.psforever.types.Vector3
@@ -74,8 +74,8 @@ object ProximityTerminal {
     * @param context hook to the local `Actor` system
     */
   def Setup(obj : Amenity, context : ActorContext) : Unit = {
-    import akka.actor.{ActorRef, Props}
-    if(obj.Actor == ActorRef.noSender) {
+    import akka.actor.Props
+    if(obj.Actor == Default.Actor) {
       obj.Actor = context.actorOf(Props(classOf[ProximityTerminalControl], obj), PlanetSideServerObject.UniqueActorName(obj))
       obj.Actor ! Service.Startup()
     }

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

@@ -30,7 +30,7 @@ class ProximityTerminalControl(term : Terminal with ProximityUnit) extends Actor
   def DamageableObject = term
   def RepairableObject = term
 
-  var terminalAction : Cancellable = DefaultCancellable.obj
+  var terminalAction : Cancellable = Default.Cancellable
   val callbacks : mutable.ListBuffer[ActorRef] = new mutable.ListBuffer[ActorRef]()
   val log = org.log4s.getLogger
 

common/src/main/scala/net/psforever/objects/serverobject/tube/SpawnTubeDefinition.scala

@@ -2,7 +2,7 @@
 package net.psforever.objects.serverobject.tube
 
 import akka.actor.ActorContext
-import net.psforever.objects.SpawnPointDefinition
+import net.psforever.objects.{Default, SpawnPointDefinition}
 import net.psforever.objects.definition.converter.SpawnTubeConverter
 import net.psforever.objects.serverobject.PlanetSideServerObject
 import net.psforever.objects.serverobject.structures.{Amenity, AmenityDefinition}
@@ -23,8 +23,8 @@ object SpawnTubeDefinition {
     * @param context hook to the local `Actor` system
     */
   def Setup(obj : Amenity, context : ActorContext) : Unit = {
-    import akka.actor.{ActorRef, Props}
-    if(obj.Actor == ActorRef.noSender) {
+    import akka.actor.Props
+    if(obj.Actor == Default.Actor) {
       obj.Actor = context.actorOf(Props(classOf[SpawnTubeControl], obj), PlanetSideServerObject.UniqueActorName(obj))
     }
   }

common/src/main/scala/net/psforever/objects/serverobject/turret/FacilityTurretControl.scala

@@ -3,7 +3,7 @@ package net.psforever.objects.serverobject.turret
 
 import akka.actor.Actor
 import net.psforever.objects.ballistics.ResolvedProjectile
-import net.psforever.objects.{DefaultCancellable, GlobalDefinitions, Player, Tool}
+import net.psforever.objects.{Default, GlobalDefinitions, Player, Tool}
 import net.psforever.objects.equipment.{Ammo, JammableMountedWeapons}
 import net.psforever.objects.serverobject.CommonMessages
 import net.psforever.objects.serverobject.mount.MountableBehavior
@@ -41,7 +41,7 @@ class FacilityTurretControl(turret : FacilityTurret) extends Actor
   def RepairableObject = turret
 
   // Used for timing ammo recharge for vanu turrets in caves
-  var weaponAmmoRechargeTimer = DefaultCancellable.obj
+  var weaponAmmoRechargeTimer = Default.Cancellable
 
   def receive : Receive = checkBehavior
     .orElse(jammableBehavior)
@@ -65,7 +65,7 @@ class FacilityTurretControl(turret : FacilityTurret) extends Actor
         }
 
       case FacilityTurret.WeaponDischarged() =>
-        if(weaponAmmoRechargeTimer != DefaultCancellable.obj) {
+        if(weaponAmmoRechargeTimer != Default.Cancellable) {
           weaponAmmoRechargeTimer.cancel()
         }
 
@@ -83,9 +83,9 @@ class FacilityTurretControl(turret : FacilityTurret) extends Actor
           }
         }
 
-        if(weapon.Magazine == weapon.MaxMagazine && weaponAmmoRechargeTimer != DefaultCancellable.obj) {
+        if(weapon.Magazine == weapon.MaxMagazine && weaponAmmoRechargeTimer != Default.Cancellable) {
           weaponAmmoRechargeTimer.cancel()
-          weaponAmmoRechargeTimer = DefaultCancellable.obj
+          weaponAmmoRechargeTimer = Default.Cancellable
         }
 
       case _ => ;

common/src/main/scala/net/psforever/objects/teamwork/SquadFeatures.scala

@@ -1,7 +1,7 @@
 // Copyright (c) 2019 PSForever
 package net.psforever.objects.teamwork
 
-import akka.actor.{Actor, ActorContext, ActorRef, Props}
+import akka.actor.{ActorContext, ActorRef, Props}
 import net.psforever.types.SquadWaypoints
 import services.teamwork.SquadService.WaypointData
 import services.teamwork.SquadSwitchboard
@@ -74,7 +74,7 @@ class SquadFeatures(val Squad : Squad) {
 
   def Stop : SquadFeatures = {
     switchboard ! akka.actor.PoisonPill
-    switchboard = Actor.noSender
+    switchboard = ActorRef.noSender
     waypoints = Array.empty
     this
   }

common/src/main/scala/net/psforever/objects/vehicles/CargoBehavior.scala

@@ -15,8 +15,8 @@ import scala.concurrent.duration._
 
 trait CargoBehavior {
   _ : Actor =>
-  private var cargoMountTimer : Cancellable = DefaultCancellable.obj
-  private var cargoDismountTimer : Cancellable = DefaultCancellable.obj
+  private var cargoMountTimer : Cancellable = Default.Cancellable
+  private var cargoDismountTimer : Cancellable = Default.Cancellable
 
   /* gate-keep mounting behavior so that unit does not try to dismount as cargo, or mount different vehicle */
   private var isMounting : Option[PlanetSideGUID] = None

common/src/main/scala/net/psforever/objects/vehicles/Utility.scala

@@ -269,6 +269,6 @@ object InternalTelepadDefinition {
 
   def SimpleUninitialize(obj : PlanetSideServerObject, context : ActorContext) : Unit = {
     context.stop(obj.Actor)
-    obj.Actor = ActorRef.noSender
+    obj.Actor = Default.Actor
   }
 }

common/src/main/scala/net/psforever/objects/vehicles/VehicleControl.scala

@@ -52,7 +52,7 @@ class VehicleControl(vehicle : Vehicle) extends Actor
   /** cheap flag for whether the vehicle is decaying */
   var decaying : Boolean = false
   /** primary vehicle decay timer */
-  var decayTimer : Cancellable = DefaultCancellable.obj
+  var decayTimer : Cancellable = Default.Cancellable
 
   def receive : Receive = Enabled
 
@@ -62,7 +62,7 @@ class VehicleControl(vehicle : Vehicle) extends Actor
     decayTimer.cancel
     vehicle.Utilities.values.foreach { util =>
       context.stop(util().Actor)
-      util().Actor = ActorRef.noSender
+      util().Actor = Default.Actor
     }
   }
 

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

@@ -1,7 +1,7 @@
 package net.psforever.objects.zones
 
 import akka.actor.{Actor, Cancellable}
-import net.psforever.objects.{DefaultCancellable, Player}
+import net.psforever.objects.{Default, Player}
 import net.psforever.objects.definition.ObjectDefinition
 import net.psforever.objects.serverobject.structures.{Building, SphereOfInfluence}
 import net.psforever.types.Vector3
@@ -12,7 +12,7 @@ import scala.concurrent.duration._
 
 class SphereOfInfluenceActor(zone: Zone) extends Actor {
   var sois : Iterable[(Building, Int)] = Nil
-  var populateTick : Cancellable = DefaultCancellable.obj
+  var populateTick : Cancellable = Default.Cancellable
   //private[this] val log = org.log4s.getLogger(s"${zone.Id.capitalize}-SphereOfInfluenceActor")
 
   def receive : Receive = Stopped

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

@@ -55,13 +55,13 @@ import scala.util.Try
   */
 class Zone(private val zoneId : String, zoneMap : ZoneMap, zoneNumber : Int) {
   /** Governs general synchronized external requests. */
-  private var actor = ActorRef.noSender
+  private var actor = Default.Actor
 
   /** Actor that handles SOI related functionality, for example if a player is in a SOI **/
-  private var soi = ActorRef.noSender
+  private var soi = Default.Actor
 
   /** Used by the globally unique identifier system to coordinate requests. */
-  private var accessor : ActorRef = ActorRef.noSender
+  private var accessor : ActorRef = Default.Actor
   /** The basic support structure for the globally unique number system used by this `Zone`. */
   private var guid : NumberPoolHub = new NumberPoolHub(new LimitedNumberSource(65536))
   /** A synchronized `List` of items (`Equipment`) dropped by players on the ground and can be collected again. */
@@ -69,19 +69,19 @@ class Zone(private val zoneId : String, zoneMap : ZoneMap, zoneNumber : Int) {
   /** */
   private val vehicles : ListBuffer[Vehicle] = ListBuffer[Vehicle]()
   /** Used by the `Zone` to coordinate `Equipment` dropping and collection requests. */
-  private var ground : ActorRef = ActorRef.noSender
+  private var ground : ActorRef = Default.Actor
   /** */
   private val constructions : ListBuffer[PlanetSideGameObject with Deployable] = ListBuffer[PlanetSideGameObject with Deployable]()
   /** */
-  private var deployables : ActorRef = ActorRef.noSender
+  private var deployables : ActorRef = Default.Actor
   /** */
-  private var transport : ActorRef = ActorRef.noSender
+  private var transport : ActorRef = Default.Actor
   /** */
   private val players : TrieMap[Avatar, Option[Player]] = TrieMap[Avatar, Option[Player]]()
   /** */
   private val corpses : ListBuffer[Player] = ListBuffer[Player]()
   /** */
-  private var population : ActorRef = ActorRef.noSender
+  private var population : ActorRef = Default.Actor
 
   private var buildings : PairMap[Int, Building] = PairMap.empty[Int, Building]
 
@@ -92,7 +92,7 @@ class Zone(private val zoneId : String, zoneMap : ZoneMap, zoneNumber : Int) {
   /** key - spawn zone id, value - buildings belonging to spawn zone */
   private var spawnGroups : Map[Building, List[SpawnPoint]] = PairMap[Building, List[SpawnPoint]]()
   /** */
-  private var projector : ActorRef = ActorRef.noSender
+  private var projector : ActorRef = Default.Actor
   /** */
   private var hotspots : ListBuffer[HotSpotInfo] = ListBuffer[HotSpotInfo]()
   /** */
@@ -102,11 +102,11 @@ class Zone(private val zoneId : String, zoneMap : ZoneMap, zoneNumber : Int) {
   /** calculate a duration from a given interaction's participants */
   private var hotspotTimeFunc : (SourceEntry, SourceEntry)=>FiniteDuration = Zone.HotSpot.Rules.NoTime
   /** */
-  private var avatarEvents : ActorRef = ActorRef.noSender
+  private var avatarEvents : ActorRef = Default.Actor
   /** */
-  private var localEvents : ActorRef = ActorRef.noSender
+  private var localEvents : ActorRef = Default.Actor
   /** */
-  private var vehicleEvents : ActorRef = ActorRef.noSender
+  private var vehicleEvents : ActorRef = Default.Actor
 
   /**
     * Establish the basic accessible conditions necessary for a functional `Zone`.<br>
@@ -126,7 +126,7 @@ class Zone(private val zoneId : String, zoneMap : ZoneMap, zoneNumber : Int) {
     * @param context a reference to an `ActorContext` necessary for `Props`
     */
   def Init(implicit context : ActorContext) : Unit = {
-    if(accessor == ActorRef.noSender) {
+    if(accessor == Default.Actor) {
       SetupNumberPools()
       accessor = context.actorOf(RandomPool(25).props(Props(classOf[UniqueNumberSystem], this.guid, UniqueNumberSystem.AllocateNumberPoolActors(this.guid))), s"$Id-uns")
       ground = context.actorOf(Props(classOf[ZoneGroundActor], this, equipmentOnGround), s"$Id-ground")
@@ -187,7 +187,7 @@ class Zone(private val zoneId : String, zoneMap : ZoneMap, zoneNumber : Int) {
     * @see `ZoneActor`
     */
   def Actor_=(zoneActor : ActorRef) : ActorRef = {
-    if(actor == ActorRef.noSender) {
+    if(actor == Default.Actor) {
       actor = zoneActor
     }
     Actor
@@ -226,7 +226,7 @@ class Zone(private val zoneId : String, zoneMap : ZoneMap, zoneNumber : Int) {
     * @return synchronized reference to the globally unique identifier system
     */
   def GUID(hub : NumberPoolHub) : Boolean = {
-    if(actor == ActorRef.noSender && guid.Pools.values.foldLeft(0)(_ + _.Count) == 0) {
+    if(actor == Default.Actor && guid.Pools.values.foldLeft(0)(_ + _.Count) == 0) {
       import org.fusesource.jansi.Ansi.Color.RED
       import org.fusesource.jansi.Ansi.ansi
       println(ansi().fgBright(RED).a(s"""Caution: replacement of the number pool system for zone $Id; function is for testing purposes only""").reset())
@@ -248,7 +248,7 @@ class Zone(private val zoneId : String, zoneMap : ZoneMap, zoneNumber : Int) {
     *        `false`, if the new pool can not be created because the system has already been started
     */
   def AddPool(name : String, pool : Seq[Int]) : Boolean = {
-    if(accessor == ActorRef.noSender) {
+    if(accessor == Default.Actor) {
       guid.AddPool(name, pool.toList)
       true
     }
@@ -266,7 +266,7 @@ class Zone(private val zoneId : String, zoneMap : ZoneMap, zoneNumber : Int) {
     *        `false`, if the new pool can not be removed because the system has already been started
     */
   def RemovePool(name : String) : Boolean = {
-    if(accessor == ActorRef.noSender) {
+    if(accessor == Default.Actor) {
       guid.RemovePool(name)
       true
     }

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

@@ -2,7 +2,7 @@
 package net.psforever.objects.zones
 
 import akka.actor.{Actor, ActorRef, Cancellable, Props}
-import net.psforever.objects.DefaultCancellable
+import net.psforever.objects.Default
 import net.psforever.types.{PlanetSideEmpire, Vector3}
 import services.ServiceManager
 
@@ -59,7 +59,7 @@ class ZoneHotSpotProjector(zone : Zone, hotspots : ListBuffer[HotSpotInfo], blan
   /** a hook for the `GalaxyService` used to broadcast messages */
   var galaxy : ActorRef = ActorRef.noSender
   /** the timer for the blanking process */
-  var blanking : Cancellable = DefaultCancellable.obj
+  var blanking : Cancellable = Default.Cancellable
   /** how long to wait in between blanking periods while hotspots decay */
   var blankingDelay : FiniteDuration = blankingTime
 

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

@@ -3,7 +3,7 @@ package net.psforever.objects.zones
 
 import akka.actor.{Actor, ActorRef, Props}
 import net.psforever.objects.avatar.PlayerControl
-import net.psforever.objects.{Avatar, Player}
+import net.psforever.objects.{Avatar, Default, Player}
 
 import scala.annotation.tailrec
 import scala.collection.concurrent.TrieMap
@@ -47,7 +47,7 @@ class ZonePopulationActor(zone : Zone, playerMap : TrieMap[Avatar, Option[Player
             sender ! Zone.Population.PlayerAlreadySpawned(zone, player)
           }
           else if(newToZone) {
-            player.Actor = context.actorOf(Props(classOf[PlayerControl], player),  s"${player.CharId}_${player.GUID.guid}_${System.currentTimeMillis}")
+            player.Actor = context.actorOf(Props(classOf[PlayerControl], player), name = GetPlayerControlName(player, None))
             player.Zone = zone
           }
         case None =>
@@ -63,10 +63,15 @@ class ZonePopulationActor(zone : Zone, playerMap : TrieMap[Avatar, Option[Player
       }
 
     case Zone.Corpse.Add(player) =>
-      CorpseAdd(player, corpseList)
+      if(CorpseAdd(player, corpseList)) {
+        player.Actor = context.actorOf(Props(classOf[PlayerControl], player), name = s"corpse_of_${GetPlayerControlName(player, None)}")
+        player.Zone = zone
+      }
 
     case Zone.Corpse.Remove(player) =>
-      CorpseRemove(player, corpseList)
+      if(CorpseRemove(player, corpseList)) {
+        PlayerLeave(player)
+      }
 
     case _ => ;
   }
@@ -168,17 +173,19 @@ object ZonePopulationActor {
     * @param player a `Player` object
     * @param corpseList a list of `Player` objects
     */
-  def CorpseRemove(player : Player, corpseList : ListBuffer[Player]) : Unit = {
+  def CorpseRemove(player : Player, corpseList : ListBuffer[Player]) : Boolean = {
     recursiveFindCorpse(corpseList.iterator, player) match {
-      case None => ;
+      case None =>
+        false
       case Some(index) =>
         corpseList.remove(index)
+        true
     }
   }
 
   def PlayerLeave(player : Player) : Unit = {
     player.Actor ! akka.actor.PoisonPill
-    player.Actor = ActorRef.noSender
+    player.Actor = Default.Actor
   }
 
   /**
@@ -202,4 +209,14 @@ object ZonePopulationActor {
       }
     }
   }
+
+  def GetPlayerControlName(player : Player, old : Option[ActorRef]) : String = {
+    old match {
+      case Some(control) =>
+        val nameNumber = control.toString.split("/").last //split on '/'
+        nameNumber.split("#").head //split on '#'
+      case None => ;
+        s"${player.CharId}_${player.GUID.guid}_${System.currentTimeMillis}" //new
+    }
+  }
 }

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

@@ -1,8 +1,8 @@
 // Copyright (c) 2017 PSForever
 package net.psforever.objects.zones
 
-import akka.actor.{Actor, ActorRef, Props}
-import net.psforever.objects.Vehicle
+import akka.actor.{Actor, Props}
+import net.psforever.objects.{Default, Vehicle}
 import net.psforever.objects.serverobject.PlanetSideServerObject
 import net.psforever.objects.vehicles.VehicleControl
 
@@ -38,7 +38,7 @@ class ZoneVehicleActor(zone : Zone, vehicleList : ListBuffer[Vehicle]) extends A
       else if(vehicleList.contains(vehicle)) {
         sender ! Zone.Vehicle.CanNotSpawn(zone, vehicle, "already in zone")
       }
-      else if(vehicle.Actor != ActorRef.noSender) {
+      else if(vehicle.Actor != Default.Actor) {
         sender ! Zone.Vehicle.CanNotSpawn(zone, vehicle, "already in another zone")
       }
       else {
@@ -52,7 +52,7 @@ class ZoneVehicleActor(zone : Zone, vehicleList : ListBuffer[Vehicle]) extends A
         case Some(index) =>
           vehicleList.remove(index)
           context.stop(vehicle.Actor)
-          vehicle.Actor = ActorRef.noSender
+          vehicle.Actor = Default.Actor
         case None => ;
           sender ! Zone.Vehicle.CanNotDespawn(zone, vehicle, "can not find")
       }

common/src/main/scala/services/RemoverActor.scala

@@ -1,10 +1,10 @@
 // Copyright (c) 2017 PSForever
 package services
 
-import akka.actor.{Actor, ActorRef, Cancellable}
+import akka.actor.{ActorRef, Cancellable}
 import net.psforever.objects.guid.TaskResolver
 import net.psforever.objects.zones.Zone
-import net.psforever.objects.{DefaultCancellable, PlanetSideGameObject}
+import net.psforever.objects.{Default, PlanetSideGameObject}
 import net.psforever.types.Vector3
 import services.support.{SimilarityComparator, SupportActor, SupportActorCaseConversions}
 
@@ -33,7 +33,7 @@ abstract class RemoverActor extends SupportActor[RemoverActor.Entry] {
   /**
     * The timer that checks whether entries in the first pool are still eligible for that pool.
     */
-  var firstTask : Cancellable = DefaultCancellable.obj
+  var firstTask : Cancellable = Default.Cancellable
   /**
     * The first pool of objects waiting to be processed for removal.
     */
@@ -42,13 +42,13 @@ abstract class RemoverActor extends SupportActor[RemoverActor.Entry] {
   /**
     * The timer that checks whether entries in the second pool are still eligible for that pool.
     */
-  var secondTask : Cancellable = DefaultCancellable.obj
+  var secondTask : Cancellable = Default.Cancellable
   /**
     * The second pool of objects waiting to be processed for removal.
     */
   var secondHeap : List[RemoverActor.Entry] = List()
 
-  protected var taskResolver : ActorRef = Actor.noSender
+  protected var taskResolver : ActorRef = ActorRef.noSender
 
   val sameEntryComparator = new SimilarityComparator[RemoverActor.Entry]() {
     def Test(entry1 : RemoverActor.Entry, entry2 : RemoverActor.Entry) : Boolean = {

common/src/main/scala/services/ServiceManager.scala

@@ -1,12 +1,12 @@
+// Copyright (c) 2017 PSForever
 package services
 
-// Copyright (c) 2017 PSForever
 import akka.actor.{Actor, ActorIdentity, ActorRef, ActorSystem, Identify, Props}
 
 import scala.collection.mutable
 
 object ServiceManager {
-  var serviceManager = Actor.noSender
+  var serviceManager = ActorRef.noSender
 
   def boot(implicit system : ActorSystem) = {
     serviceManager = system.actorOf(Props[ServiceManager], "service")

common/src/main/scala/services/account/AccountPersistenceService.scala

@@ -190,7 +190,7 @@ class PersistenceMonitor(name : String, squadService : ActorRef, taskResolver :
   /** the last-reported game coordinate position of this player */
   var lastPosition : Vector3 = Vector3.Zero
   /** the ongoing amount of permissible inactivity */
-  var timer : Cancellable = DefaultCancellable.obj
+  var timer : Cancellable = Default.Cancellable
   /** the sparingly-used log */
   val log = org.log4s.getLogger
 
@@ -309,7 +309,7 @@ class PersistenceMonitor(name : String, squadService : ActorRef, taskResolver :
     player.Position = Vector3.Zero
     player.Health = 0
     inZone.GUID(player.VehicleOwned) match {
-      case Some(vehicle : Vehicle) if vehicle.OwnerName.contains(player.Name) && vehicle.Actor != ActorRef.noSender =>
+      case Some(vehicle : Vehicle) if vehicle.OwnerName.contains(player.Name) && vehicle.Actor != Default.Actor =>
         vehicle.Actor ! Vehicle.Ownership(None)
       case _ => ;
     }

common/src/main/scala/services/local/support/DoorCloseActor.scala

@@ -2,7 +2,7 @@
 package services.local.support
 
 import akka.actor.{Actor, Cancellable}
-import net.psforever.objects.{DefaultCancellable, Player}
+import net.psforever.objects.{Default, Player}
 import net.psforever.objects.serverobject.doors.Door
 import net.psforever.objects.serverobject.structures.Building
 import net.psforever.objects.zones.Zone
@@ -18,7 +18,7 @@ import scala.concurrent.duration._
   */
 class DoorCloseActor() extends Actor {
   /** The periodic `Executor` that checks for doors to be closed */
-  private var doorCloserTrigger : Cancellable = DefaultCancellable.obj
+  private var doorCloserTrigger : Cancellable = Default.Cancellable
   /** A `List` of currently open doors */
   private var openDoors : List[DoorCloseActor.DoorEntry] = Nil
   //private[this] val log = org.log4s.getLogger

common/src/main/scala/services/local/support/HackCaptureActor.scala

@@ -1,7 +1,7 @@
 package services.local.support
 
 import akka.actor.{Actor, Cancellable}
-import net.psforever.objects.DefaultCancellable
+import net.psforever.objects.Default
 import net.psforever.objects.serverobject.hackable.Hackable
 import net.psforever.objects.serverobject.structures.Building
 import net.psforever.objects.serverobject.terminals.CaptureTerminal
@@ -14,7 +14,7 @@ import scala.concurrent.duration.{FiniteDuration, _}
 class HackCaptureActor extends Actor {
   private [this] val log = org.log4s.getLogger
 
-  private var clearTrigger : Cancellable = DefaultCancellable.obj
+  private var clearTrigger : Cancellable = Default.Cancellable
 
   /** A `List` of currently hacked server objects */
   private var hackedObjects : List[HackCaptureActor.HackEntry] = Nil

common/src/main/scala/services/local/support/HackClearActor.scala

@@ -4,7 +4,7 @@ package services.local.support
 import java.util.concurrent.TimeUnit
 
 import akka.actor.{Actor, Cancellable}
-import net.psforever.objects.DefaultCancellable
+import net.psforever.objects.Default
 import net.psforever.objects.serverobject.hackable.Hackable
 import net.psforever.objects.serverobject.{CommonMessages, PlanetSideServerObject}
 import net.psforever.objects.zones.Zone
@@ -20,7 +20,7 @@ import scala.concurrent.duration._
   */
 class HackClearActor() extends Actor {
   /** The periodic `Executor` that checks for server objects to be unhacked */
-  private var clearTrigger : Cancellable = DefaultCancellable.obj
+  private var clearTrigger : Cancellable = Default.Cancellable
   /** A `List` of currently hacked server objects */
   private var hackedObjects : List[HackClearActor.HackEntry] = Nil
   private[this] val log = org.log4s.getLogger

common/src/main/scala/services/local/support/RouterTelepadActivation.scala

@@ -9,7 +9,7 @@ import services.support.{SimilarityComparator, SupportActor}
 import scala.concurrent.duration._
 
 class RouterTelepadActivation extends SupportActor[RouterTelepadActivation.Entry] {
-  var activationTask : Cancellable = DefaultCancellable.obj
+  var activationTask : Cancellable = Default.Cancellable
   var telepadList : List[RouterTelepadActivation.Entry] = List()
   val sameEntryComparator = new SimilarityComparator[RouterTelepadActivation.Entry]() {
     def Test(entry1 : RouterTelepadActivation.Entry, entry2 : RouterTelepadActivation.Entry) : Boolean = {

common/src/main/scala/services/vehicle/support/TurretUpgrader.scala

@@ -1,8 +1,8 @@
 // Copyright (c) 2017 PSForever
 package services.vehicle.support
 
-import akka.actor.{Actor, ActorRef, Cancellable}
-import net.psforever.objects.{AmmoBox, DefaultCancellable, PlanetSideGameObject, Tool}
+import akka.actor.{ActorRef, Cancellable}
+import net.psforever.objects.{AmmoBox, Default, PlanetSideGameObject, Tool}
 import net.psforever.objects.guid.{GUIDTask, Task, TaskResolver}
 import net.psforever.objects.serverobject.PlanetSideServerObject
 import net.psforever.objects.serverobject.turret.{FacilityTurret, TurretUpgrade, WeaponTurret}
@@ -16,11 +16,11 @@ import services.{Service, ServiceManager}
 import scala.concurrent.duration._
 
 class TurretUpgrader extends SupportActor[TurretUpgrader.Entry] {
-  var task : Cancellable = DefaultCancellable.obj
+  var task : Cancellable = Default.Cancellable
 
   var list : List[TurretUpgrader.Entry] = List()
 
-  private var taskResolver : ActorRef = Actor.noSender
+  private var taskResolver : ActorRef = ActorRef.noSender
 
   val sameEntryComparator = new SimilarityComparator[TurretUpgrader.Entry]() {
     def Test(entry1 : TurretUpgrader.Entry, entry2 : TurretUpgrader.Entry) : Boolean = {

common/src/main/scala/services/vehicle/support/VehicleRemover.scala

@@ -7,7 +7,7 @@ import net.psforever.objects.guid.GUIDTask.UnregisterVehicle
 import services.{RemoverActor, ServiceManager}
 
 class VehicleRemover extends Actor {
-  var taskResolver : ActorRef = Actor.noSender
+  var taskResolver : ActorRef = ActorRef.noSender
 
   override def preStart() : Unit = {
     super.preStart()

common/src/test/scala/objects/BuildingTest.scala

@@ -1,9 +1,9 @@
 // Copyright (c) 2017 PSForever
 package objects
 
-import akka.actor.{ActorRef, Props}
+import akka.actor.Props
 import base.ActorTest
-import net.psforever.objects.GlobalDefinitions
+import net.psforever.objects.{Default, GlobalDefinitions}
 import net.psforever.objects.serverobject.affinity.FactionAffinity
 import net.psforever.objects.serverobject.doors.{Door, DoorControl}
 import net.psforever.objects.serverobject.structures._
@@ -72,7 +72,7 @@ class BuildingTest extends Specification {
     "construct" in {
       val bldg = Building("Building", 0, 10, Zone.Nowhere, StructureType.Building)
       bldg.MapId mustEqual 10
-      bldg.Actor mustEqual ActorRef.noSender
+      bldg.Actor mustEqual Default.Actor
       bldg.Amenities mustEqual Nil
       bldg.Zone mustEqual Zone.Nowhere
       bldg.Faction mustEqual PlanetSideEmpire.NEUTRAL
@@ -107,7 +107,7 @@ class WarpGateTest extends Specification {
     "construct" in {
       val bldg = WarpGate("WarpGate", 0, 10, Zone.Nowhere, GlobalDefinitions.warpgate)
       bldg.MapId mustEqual 10
-      bldg.Actor mustEqual ActorRef.noSender
+      bldg.Actor mustEqual Default.Actor
       bldg.Amenities mustEqual Nil
       bldg.Zone mustEqual Zone.Nowhere
       bldg.Faction mustEqual PlanetSideEmpire.NEUTRAL
@@ -120,7 +120,7 @@ class BuildingControl1Test extends ActorTest {
     "construct" in {
       val bldg = Building("Building", 0, 10, Zone.Nowhere, StructureType.Building)
       bldg.Actor = system.actorOf(Props(classOf[BuildingControl], bldg), "test")
-      assert(bldg.Actor != ActorRef.noSender)
+      assert(bldg.Actor != Default.Actor)
     }
   }
 }

common/src/test/scala/objects/DefaultTest.scala

@@ -0,0 +1,49 @@
+// Copyright (c) 2020 PSForever
+package objects
+
+import akka.actor.DeadLetter
+import akka.testkit.TestProbe
+import base.ActorTest
+import net.psforever.objects.Default
+import org.specs2.mutable.Specification
+
+import scala.concurrent.duration._
+
+class DefaultTest extends Specification {
+  "Default.Cancellable" should {
+    "always act like it can be cancelled successfully" in {
+      Default.Cancellable.cancel mustEqual true
+    }
+
+    "always act like it was cancelled successfully" in {
+      Default.Cancellable.isCancelled mustEqual true
+    }
+  }
+}
+
+class DefaultActorStartedTest extends ActorTest {
+  "Default.Actor" should {
+    "send messages to deadLetters" in {
+      //after being started
+      Default(system)
+      val probe = new TestProbe(system)
+      system.eventStream.subscribe(probe.ref, classOf[DeadLetter])
+      Default.Actor ! "hello world"
+      val msg1 = probe.receiveOne(250 milliseconds)
+      assert(msg1.isInstanceOf[DeadLetter])
+      assert(msg1.asInstanceOf[DeadLetter].message equals "hello world")
+
+      //if it was stopped
+      system.stop(Default.Actor)
+      Default.Actor ! "hello world"
+      val msg2 = probe.receiveOne(250 milliseconds)
+      assert(msg2.isInstanceOf[DeadLetter])
+      assert(msg2.asInstanceOf[DeadLetter].message equals "hello world")
+    }
+  }
+}
+
+object DefaultActorTest {
+  //due to being a singleton, the original original value of the Default.Actor is cached here
+  val Original = Default.Actor
+}

common/src/test/scala/objects/DeployableTest.scala

@@ -592,11 +592,11 @@ class TurretControlInitializeTest extends ActorTest {
     "initialize" in {
       val obj = new TurretDeployable(GlobalDefinitions.spitfire_turret)
       obj.GUID = PlanetSideGUID(1)
-      assert(obj.Actor == ActorRef.noSender)
+      assert(obj.Actor == Default.Actor)
       val init = system.actorOf(Props(classOf[DeployableTest.TurretInitializer], obj), "init_turret_test")
       init ! "initialize"
       expectNoMessage(200 milliseconds)
-      assert(obj.Actor != ActorRef.noSender)
+      assert(obj.Actor != Default.Actor)
     }
   }
 }
@@ -609,11 +609,11 @@ class TurretControlUninitializeTest extends ActorTest {
       obj.GUID = PlanetSideGUID(1)
       init ! "initialize"
       expectNoMessage(200 milliseconds)
-      assert(obj.Actor != ActorRef.noSender)
+      assert(obj.Actor != Default.Actor)
 
       init ! "uninitialize"
       expectNoMessage(200 milliseconds)
-      assert(obj.Actor == ActorRef.noSender)
+      assert(obj.Actor == Default.Actor)
     }
   }
 }

common/src/test/scala/objects/DeploymentTest.scala

@@ -1,7 +1,7 @@
 // Copyright (c) 2017 PSForever
 package objects
 
-import akka.actor.{Actor, ActorSystem, Props}
+import akka.actor.{Actor, ActorRef, ActorSystem, Props}
 import base.ActorTest
 import net.psforever.objects.serverobject.PlanetSideServerObject
 import net.psforever.objects.{GlobalDefinitions, Vehicle}
@@ -46,7 +46,7 @@ class DeploymentBehavior1Test extends ActorTest {
   "Deployment" should {
     "construct" in {
       val obj = DeploymentTest.SetUpAgent
-      assert(obj.Actor != Actor.noSender)
+      assert(obj.Actor != ActorRef.noSender)
       assert(obj.DeploymentState == DriveState.Mobile)
     }
   }

common/src/test/scala/objects/DoorTest.scala

@@ -1,9 +1,9 @@
 // Copyright (c) 2017 PSForever
 package objects
 
-import akka.actor.{ActorRef, ActorSystem, Props}
+import akka.actor.{ActorSystem, Props}
 import base.ActorTest
-import net.psforever.objects.{Avatar, GlobalDefinitions, Player}
+import net.psforever.objects.{Avatar, Default, GlobalDefinitions, Player}
 import net.psforever.objects.serverobject.doors.{Door, DoorControl}
 import net.psforever.objects.serverobject.structures.{Building, StructureType}
 import net.psforever.objects.zones.Zone
@@ -59,7 +59,7 @@ class DoorControl1Test extends ActorTest {
     "construct" in {
       val door = Door(GlobalDefinitions.door)
       door.Actor = system.actorOf(Props(classOf[DoorControl], door), "door")
-      assert(door.Actor != ActorRef.noSender)
+      assert(door.Actor != Default.Actor)
     }
   }
 }

common/src/test/scala/objects/FacilityTurretTest.scala

@@ -1,10 +1,10 @@
 // Copyright (c) 2017 PSForever
 package objects
 
-import akka.actor.{ActorRef, Props}
+import akka.actor.Props
 import akka.testkit.TestProbe
 import base.ActorTest
-import net.psforever.objects.{Avatar, GlobalDefinitions, Player, Tool}
+import net.psforever.objects.{Avatar, Default, GlobalDefinitions, Player, Tool}
 import net.psforever.objects.definition.ToolDefinition
 import net.psforever.objects.guid.NumberPoolHub
 import net.psforever.objects.guid.source.LimitedNumberSource
@@ -94,7 +94,7 @@ class FacilityTurretControl1Test extends ActorTest {
     "construct" in {
       val obj = FacilityTurret(GlobalDefinitions.manned_turret)
       obj.Actor = system.actorOf(Props(classOf[FacilityTurretControl], obj), "turret-control")
-      assert(obj.Actor != ActorRef.noSender)
+      assert(obj.Actor != Default.Actor)
     }
   }
 }

common/src/test/scala/objects/IFFLockTest.scala

@@ -1,10 +1,10 @@
 // Copyright (c) 2017 PSForever
 package objects
 
-import akka.actor.{ActorRef, ActorSystem, Props}
+import akka.actor.{ActorSystem, Props}
 import base.ActorTest
+import net.psforever.objects.{Avatar, Default, GlobalDefinitions, Player}
 import net.psforever.objects.serverobject.CommonMessages
-import net.psforever.objects.{Avatar, GlobalDefinitions, Player}
 import net.psforever.objects.serverobject.locks.{IFFLock, IFFLockControl}
 import net.psforever.objects.serverobject.structures.{Building, StructureType}
 import net.psforever.objects.zones.Zone
@@ -48,7 +48,7 @@ class IFFLockControl1Test extends ActorTest {
     "construct" in {
       val lock = IFFLock(GlobalDefinitions.lock_external)
       lock.Actor = system.actorOf(Props(classOf[IFFLockControl], lock), "lock-control")
-      assert(lock.Actor != ActorRef.noSender)
+      assert(lock.Actor != Default.Actor)
     }
   }
 }

common/src/test/scala/objects/LockerTest.scala

@@ -1,7 +1,7 @@
 // Copyright (c) 2017 PSForever
 package objects
 
-import akka.actor.{ActorRef, Props}
+import akka.actor.Props
 import base.ActorTest
 import net.psforever.objects.GlobalDefinitions
 import net.psforever.objects.serverobject.affinity.FactionAffinity
@@ -19,8 +19,8 @@ class LockerTest extends Specification {
 
   "Locker" should {
     "construct" in {
-      val locker = new Locker()
-      locker.Actor mustEqual ActorRef.noSender
+      new Locker()
+      ok
     }
   }
 }

common/src/test/scala/objects/PlayerControlTest.scala

@@ -187,7 +187,7 @@ class PlayerControlRepairTest extends ActorTest {
       assert(originalArmor < player2.MaxArmor)
 
       player2.Actor ! CommonMessages.Use(player1, Some(tool))
-      val msg_avatar = avatarProbe.receiveN(5, 500 milliseconds)
+      val msg_avatar = avatarProbe.receiveN(5, 1000 milliseconds)
       assert(
         msg_avatar.head match {
           case AvatarServiceMessage("TestCharacter1", AvatarAction.SendResponse(_, InventoryStateMessage(PlanetSideGUID(4), _, PlanetSideGUID(3), _))) => true

common/src/test/scala/objects/SpawnTubeTest.scala

@@ -1,9 +1,9 @@
 // Copyright (c) 2017 PSForever
 package objects
 
-import akka.actor.{ActorRef, Props}
+import akka.actor.Props
 import base.ActorTest
-import net.psforever.objects.GlobalDefinitions
+import net.psforever.objects.{Default, GlobalDefinitions}
 import net.psforever.objects.serverobject.tube.{SpawnTube, SpawnTubeControl, SpawnTubeDefinition}
 import org.specs2.mutable.Specification
 
@@ -18,7 +18,7 @@ class SpawnTubeTest extends Specification {
   "SpawnTube" should {
     "construct" in {
       val obj = SpawnTube(GlobalDefinitions.ams_respawn_tube)
-      obj.Actor mustEqual ActorRef.noSender
+      obj.Actor mustEqual Default.Actor
       obj.Definition mustEqual GlobalDefinitions.ams_respawn_tube
     }
   }
@@ -29,7 +29,7 @@ class SpawnTubeControlTest extends ActorTest {
     "construct" in {
       val obj = SpawnTube(GlobalDefinitions.ams_respawn_tube)
       obj.Actor = system.actorOf(Props(classOf[SpawnTubeControl], obj), "spawn-tube")
-      assert(obj.Actor != ActorRef.noSender)
+      assert(obj.Actor != Default.Actor)
     }
   }
 }

common/src/test/scala/objects/UtilityTest.scala

@@ -20,7 +20,7 @@ class UtilityTest extends Specification {
       obj.UtilType mustEqual UtilityType.order_terminala
       obj().isInstanceOf[Terminal] mustEqual true
       obj().asInstanceOf[Terminal].Definition.ObjectId mustEqual 613
-      obj().asInstanceOf[Terminal].Actor mustEqual ActorRef.noSender
+      obj().asInstanceOf[Terminal].Actor mustEqual Default.Actor
     }
 
     "create an order_terminalb object" in {
@@ -28,7 +28,7 @@ class UtilityTest extends Specification {
       obj.UtilType mustEqual UtilityType.order_terminalb
       obj().isInstanceOf[Terminal] mustEqual true
       obj().asInstanceOf[Terminal].Definition.ObjectId mustEqual 614
-      obj().asInstanceOf[Terminal].Actor mustEqual ActorRef.noSender
+      obj().asInstanceOf[Terminal].Actor mustEqual Default.Actor
     }
 
     "create a matrix_terminalc object" in {
@@ -36,7 +36,7 @@ class UtilityTest extends Specification {
       obj.UtilType mustEqual UtilityType.matrix_terminalc
       obj().isInstanceOf[Terminal] mustEqual true
       obj().asInstanceOf[Terminal].Definition.ObjectId mustEqual 519
-      obj().asInstanceOf[Terminal].Actor mustEqual ActorRef.noSender
+      obj().asInstanceOf[Terminal].Actor mustEqual Default.Actor
     }
 
     "create an ams_respawn_tube object" in {
@@ -44,7 +44,7 @@ class UtilityTest extends Specification {
       obj.UtilType mustEqual UtilityType.ams_respawn_tube
       obj().isInstanceOf[SpawnTube] mustEqual true
       obj().asInstanceOf[SpawnTube].Definition.ObjectId mustEqual 49
-      obj().asInstanceOf[SpawnTube].Actor mustEqual ActorRef.noSender
+      obj().asInstanceOf[SpawnTube].Actor mustEqual Default.Actor
     }
 
     "create a teleportpad_terminal object" in {
@@ -52,7 +52,7 @@ class UtilityTest extends Specification {
       obj.UtilType mustEqual UtilityType.teleportpad_terminal
       obj().isInstanceOf[Terminal] mustEqual true
       obj().asInstanceOf[Terminal].Definition.ObjectId mustEqual 853
-      obj().asInstanceOf[Terminal].Actor mustEqual ActorRef.noSender
+      obj().asInstanceOf[Terminal].Actor mustEqual Default.Actor
     }
 
     "produce a telepad object through the teleportpad_terminal" in {
@@ -78,7 +78,7 @@ class UtilityTest extends Specification {
       obj.UtilType mustEqual UtilityType.internal_router_telepad_deployable
       obj().isInstanceOf[Utility.InternalTelepad] mustEqual true
       obj().asInstanceOf[Utility.InternalTelepad].Definition.ObjectId mustEqual 744
-      obj().asInstanceOf[Utility.InternalTelepad].Actor mustEqual ActorRef.noSender
+      obj().asInstanceOf[Utility.InternalTelepad].Actor mustEqual Default.Actor
     }
 
     "internal_router_telepad_deployable can keep track of an object's GUID (presumedly, it's a Telepad)" in {
@@ -139,11 +139,11 @@ class UtilityTerminalATest extends ActorTest {
     "wire an order_terminala Actor" in {
       val obj = Utility(UtilityType.order_terminala, UtilityTest.vehicle)
       obj().GUID = PlanetSideGUID(1)
-      assert(obj().Actor == ActorRef.noSender)
+      assert(obj().Actor == Default.Actor)
 
       system.actorOf(Props(classOf[UtilityTest.SetupControl], obj), "test") ! ""
       receiveOne(Duration.create(500, "ms")) //consume and discard
-      assert(obj().Actor != ActorRef.noSender)
+      assert(obj().Actor != Default.Actor)
     }
   }
 }
@@ -153,11 +153,11 @@ class UtilityTerminalBTest extends ActorTest {
     "wire an order_terminalb Actor" in {
       val obj = Utility(UtilityType.order_terminalb, UtilityTest.vehicle)
       obj().GUID = PlanetSideGUID(1)
-      assert(obj().Actor == ActorRef.noSender)
+      assert(obj().Actor == Default.Actor)
 
       system.actorOf(Props(classOf[UtilityTest.SetupControl], obj), "test") ! ""
       receiveOne(Duration.create(500, "ms")) //consume and discard
-      assert(obj().Actor != ActorRef.noSender)
+      assert(obj().Actor != Default.Actor)
     }
   }
 }
@@ -167,11 +167,11 @@ class UtilityTerminalCTest extends ActorTest {
     "wire a matrix_terminalc Actor" in {
       val obj = Utility(UtilityType.matrix_terminalc, UtilityTest.vehicle)
       obj().GUID = PlanetSideGUID(1)
-      assert(obj().Actor == ActorRef.noSender)
+      assert(obj().Actor == Default.Actor)
 
       system.actorOf(Props(classOf[UtilityTest.SetupControl], obj), "test") ! ""
       receiveOne(Duration.create(500, "ms")) //consume and discard
-      assert(obj().Actor != ActorRef.noSender)
+      assert(obj().Actor != Default.Actor)
     }
   }
 }
@@ -181,11 +181,11 @@ class UtilityRespawnTubeTest extends ActorTest {
     "wire an ams_respawn_tube Actor" in {
       val obj = Utility(UtilityType.ams_respawn_tube, UtilityTest.vehicle)
       obj().GUID = PlanetSideGUID(1)
-      assert(obj().Actor == ActorRef.noSender)
+      assert(obj().Actor == Default.Actor)
 
       system.actorOf(Props(classOf[UtilityTest.SetupControl], obj), "test") ! ""
       receiveOne(Duration.create(500, "ms")) //consume and discard
-      assert(obj().Actor != ActorRef.noSender)
+      assert(obj().Actor != Default.Actor)
     }
   }
 }
@@ -195,11 +195,11 @@ class UtilityTelepadTerminalTest extends ActorTest {
     "wire a teleportpad_terminal Actor" in {
       val obj = Utility(UtilityType.teleportpad_terminal, UtilityTest.vehicle)
       obj().GUID = PlanetSideGUID(1)
-      assert(obj().Actor == ActorRef.noSender)
+      assert(obj().Actor == Default.Actor)
 
       system.actorOf(Props(classOf[UtilityTest.SetupControl], obj), "test") ! ""
       receiveOne(Duration.create(500, "ms")) //consume and discard
-      assert(obj().Actor != ActorRef.noSender)
+      assert(obj().Actor != Default.Actor)
     }
   }
 }
@@ -211,12 +211,12 @@ class UtilityInternalTelepadTest extends ActorTest {
       veh.GUID = PlanetSideGUID(101)
       val obj = Utility(UtilityType.internal_router_telepad_deployable, veh)
       obj().GUID = PlanetSideGUID(1)
-      assert(obj().Actor == ActorRef.noSender)
+      assert(obj().Actor == Default.Actor)
       assert(obj().asInstanceOf[Utility.InternalTelepad].Router.contains(veh.GUID))
 
       system.actorOf(Props(classOf[UtilityTest.SetupControl], obj), "test") ! ""
       receiveOne(Duration.create(500, "ms")) //consume and discard
-      assert(obj().Actor != ActorRef.noSender)
+      assert(obj().Actor != Default.Actor)
       assert(obj().asInstanceOf[Utility.InternalTelepad].Router.contains(veh.GUID))
     }
   }

common/src/test/scala/objects/VehicleSpawnPadTest.scala

@@ -1,9 +1,8 @@
 // Copyright (c) 2017 PSForever
 package objects
 
-import akka.actor.ActorRef
+import net.psforever.objects.{Default, GlobalDefinitions}
 import net.psforever.objects.serverobject.pad.VehicleSpawnPad
-import net.psforever.objects.GlobalDefinitions
 import org.specs2.mutable.Specification
 
 class VehicleSpawnPadTest extends Specification {
@@ -16,7 +15,7 @@ class VehicleSpawnPadTest extends Specification {
   "VehicleSpawnPad" should {
     "construct" in {
       val obj = VehicleSpawnPad(GlobalDefinitions.mb_pad_creation)
-      obj.Actor mustEqual ActorRef.noSender
+      obj.Actor mustEqual Default.Actor
       obj.Definition mustEqual GlobalDefinitions.mb_pad_creation
     }
   }

common/src/test/scala/objects/ZoneTest.scala

@@ -92,10 +92,6 @@ class ZoneTest extends Specification {
   "Zone" should {
     "construct" in {
       val zone = new Zone("home3", map13, 13)
-      zone.GUID mustEqual ActorRef.noSender
-      zone.Ground mustEqual ActorRef.noSender
-      zone.Transport mustEqual ActorRef.noSender
-      //zone also has a unique identifier system but it can't be accessed without its the Actor GUID being initialized
       zone.EquipmentOnGround mustEqual List.empty[Equipment]
       zone.Vehicles mustEqual List.empty[Vehicle]
       zone.Players mustEqual List.empty[Player]

common/src/test/scala/objects/number/RegisterTest.scala

@@ -1,7 +1,7 @@
 // Copyright (c) 2017 PSForever
 package objects.number
 
-import akka.actor.Actor
+import akka.actor.ActorRef
 import net.psforever.objects.guid.actor.Register
 import org.specs2.mutable.Specification
 
@@ -18,11 +18,11 @@ class RegisterTest extends Specification {
     }
 
     "construct (object, callback)" in {
-      val reg = Register(obj, Actor.noSender)
+      val reg = Register(obj, ActorRef.noSender)
       reg.obj mustEqual obj
       reg.number.isEmpty mustEqual true
       reg.name.isEmpty mustEqual true
-      reg.callback.contains(Actor.noSender) mustEqual true
+      reg.callback.contains(ActorRef.noSender) mustEqual true
     }
 
     "construct (object, suggested number)" in {
@@ -34,11 +34,11 @@ class RegisterTest extends Specification {
     }
 
     "construct (object, suggested number, callback)" in {
-      val reg = Register(obj, 5, Actor.noSender)
+      val reg = Register(obj, 5, ActorRef.noSender)
       reg.obj mustEqual obj
       reg.number.contains(5) mustEqual true
       reg.name.isEmpty mustEqual true
-      reg.callback.contains(Actor.noSender) mustEqual true
+      reg.callback.contains(ActorRef.noSender) mustEqual true
     }
 
     "construct (object, pool name)" in {
@@ -50,11 +50,11 @@ class RegisterTest extends Specification {
     }
 
     "construct (object, pool name, callback)" in {
-      val reg = Register(obj, "pool", Actor.noSender)
+      val reg = Register(obj, "pool", ActorRef.noSender)
       reg.obj mustEqual obj
       reg.number.isEmpty mustEqual true
       reg.name.contains("pool") mustEqual true
-      reg.callback.contains(Actor.noSender) mustEqual true
+      reg.callback.contains(ActorRef.noSender) mustEqual true
     }
   }
 }

common/src/test/scala/objects/terminal/ImplantTerminalMechTest.scala

@@ -1,8 +1,9 @@
 // Copyright (c) 2017 PSForever
 package objects.terminal
 
-import akka.actor.{ActorRef, ActorSystem, Props}
+import akka.actor.{ActorSystem, Props}
 import base.ActorTest
+import net.psforever.objects.{Avatar, Default, GlobalDefinitions, Player}
 import net.psforever.objects.definition.SeatDefinition
 import net.psforever.objects.guid.NumberPoolHub
 import net.psforever.objects.guid.source.LimitedNumberSource
@@ -12,7 +13,6 @@ import net.psforever.objects.serverobject.structures.{Building, StructureType}
 import net.psforever.objects.serverobject.terminals.Terminal
 import net.psforever.objects.vehicles.Seat
 import net.psforever.objects.zones.{Zone, ZoneMap}
-import net.psforever.objects.{Avatar, GlobalDefinitions, Player}
 import net.psforever.types.{CharacterGender, CharacterVoice, PlanetSideEmpire, Vector3}
 import org.specs2.mutable.Specification
 
@@ -35,7 +35,7 @@ class ImplantTerminalMechTest extends Specification {
   "Implant_Terminal_Mech" should {
     "construct" in {
       val obj = ImplantTerminalMech(GlobalDefinitions.implant_terminal_mech)
-      obj.Actor mustEqual ActorRef.noSender
+      obj.Actor mustEqual Default.Actor
       obj.Definition mustEqual GlobalDefinitions.implant_terminal_mech
       obj.Seats.keySet mustEqual Set(0)
       obj.Seats(0).isInstanceOf[Seat] mustEqual true
@@ -65,7 +65,7 @@ class ImplantTerminalMechControl1Test extends ActorTest {
     "construct" in {
       val obj = ImplantTerminalMech(GlobalDefinitions.implant_terminal_mech)
       obj.Actor = system.actorOf(Props(classOf[ImplantTerminalMechControl], obj), "mech")
-      assert(obj.Actor != ActorRef.noSender)
+      assert(obj.Actor != Default.Actor)
     }
   }
 }

common/src/test/scala/service/LocalServiceTest.scala

@@ -6,6 +6,7 @@ import base.ActorTest
 import net.psforever.objects.{GlobalDefinitions, SensorDeployable, Vehicle}
 import net.psforever.objects.serverobject.PlanetSideServerObject
 import net.psforever.objects.serverobject.terminals.{ProximityTerminal, Terminal}
+import net.psforever.objects.vehicles.VehicleControl
 import net.psforever.objects.zones.Zone
 import net.psforever.packet.game._
 import net.psforever.types.{PlanetSideEmpire, PlanetSideGUID, Vector3}
@@ -206,6 +207,7 @@ class ToggleTeleportSystemTest extends ActorTest {
   "LocalService" should {
     "pass ToggleTeleportSystem" in {
       val router = Vehicle(GlobalDefinitions.router)
+      router.Actor = system.actorOf(Props(classOf[VehicleControl], router), "test-router")
       val service = system.actorOf(Props(classOf[LocalService], Zone.Nowhere), "l_service")
       service ! Service.Join("test")
       service ! LocalServiceMessage("test", LocalAction.ToggleTeleportSystem(PlanetSideGUID(10), router, None))

common/src/test/scala/service/VehicleServiceTest.scala

@@ -4,6 +4,7 @@ package service
 import akka.actor.Props
 import base.ActorTest
 import net.psforever.objects._
+import net.psforever.objects.vehicles.VehicleControl
 import net.psforever.objects.zones.Zone
 import net.psforever.types.{PlanetSideGUID, _}
 import services.{Service, ServiceManager}
@@ -171,6 +172,7 @@ class KickPassengerTest extends ActorTest {
 class LoadVehicleTest extends ActorTest {
   ServiceManager.boot(system)
   val vehicle = Vehicle(GlobalDefinitions.quadstealth)
+  vehicle.Actor = system.actorOf(Props(classOf[VehicleControl], vehicle), "test-vehicle")
   val cdata = vehicle.Definition.Packet.ConstructorData(vehicle).get
 
   "VehicleService" should {
@@ -260,6 +262,7 @@ class TransferPassengerChannelTest extends ActorTest {
     "pass TransferPassengerChannel" in {
       val service = system.actorOf(Props(classOf[VehicleService], Zone.Nowhere), "v-service")
       val fury = Vehicle(GlobalDefinitions.fury)
+      fury.Actor = system.actorOf(Props(classOf[VehicleControl], fury), "test-fury")
       service ! Service.Join("test")
       service ! VehicleServiceMessage("test", VehicleAction.TransferPassengerChannel(PlanetSideGUID(10), "old_channel", "new_channel", fury, PlanetSideGUID(11)))
       expectMsg(VehicleServiceResponse("/test/Vehicle", PlanetSideGUID(10), VehicleResponse.TransferPassengerChannel("old_channel", "new_channel", fury, PlanetSideGUID(11))))