tests for a variety of objects and scripts (currently 810); minor changes to align with proper object behavior

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

@@ -1251,7 +1251,7 @@ object GlobalDefinitions {
   fury.Seats += 0 -> new SeatDefinition()
   fury.Seats(0).Bailable = true
   fury.Seats(0).ControlledWeapon = 1
-  fury.MountPoints += 0 -> 0
+  fury.MountPoints += 1 -> 0
   fury.MountPoints += 2 -> 0
   fury.Weapons += 1 -> fury_weapon_systema
   fury.TrunkSize = InventoryTile(11, 11)
@@ -1262,7 +1262,7 @@ object GlobalDefinitions {
   quadassault.Seats += 0 -> new SeatDefinition()
   quadassault.Seats(0).Bailable = true
   quadassault.Seats(0).ControlledWeapon = 1
-  quadassault.MountPoints += 0 -> 0
+  quadassault.MountPoints += 1 -> 0
   quadassault.MountPoints += 2 -> 0
   quadassault.Weapons += 1 -> quadassault_weapon_system
   quadassault.TrunkSize = InventoryTile(11, 11)
@@ -1273,7 +1273,7 @@ object GlobalDefinitions {
   quadstealth.CanCloak = true
   quadstealth.Seats += 0 -> new SeatDefinition()
   quadstealth.Seats(0).Bailable = true
-  quadstealth.MountPoints += 0 -> 0
+  quadstealth.MountPoints += 1 -> 0
   quadstealth.MountPoints += 2 -> 0
   quadstealth.CanCloak = true
   quadstealth.TrunkSize = InventoryTile(11, 11)

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

@@ -71,10 +71,14 @@ class Vehicle(private val vehicleDef : VehicleDefinition) extends PlanetSideServ
     this.owner
   }
 
+  def Owner_=(owner : PlanetSideGUID) : Option[PlanetSideGUID] = Owner_=(Some(owner))
+
+  def Owner_=(owner : Player) : Option[PlanetSideGUID] = Owner_=(Some(owner.GUID))
+
   def Owner_=(owner : Option[PlanetSideGUID]) : Option[PlanetSideGUID] = {
     owner match {
       case Some(_) =>
-        if(Definition.CanBeOwned) {
+        if(Definition.CanBeOwned) { //e.g., base turrets
           this.owner = owner
         }
       case None =>
@@ -102,7 +106,7 @@ class Vehicle(private val vehicleDef : VehicleDefinition) extends PlanetSideServ
 
   def Shields_=(strength : Int) : Int = {
     this.shields = strength
-    strength
+    Shields
   }
 
   def MaxShields : Int = {
@@ -252,12 +256,11 @@ class Vehicle(private val vehicleDef : VehicleDefinition) extends PlanetSideServ
     * @return a weapon, or `None`
     */
   def ControlledWeapon(wepNumber : Int) : Option[Equipment] = {
-    val slot = this.weapons.get(wepNumber)
+    weapons.get(wepNumber) match {
-    if(slot.isDefined) {
+      case Some(mount) =>
-      slot.get.Equipment
+        mount.Equipment
-    }
+      case None =>
-    else {
+        None
-      None
     }
   }
 
@@ -284,11 +287,11 @@ class Vehicle(private val vehicleDef : VehicleDefinition) extends PlanetSideServ
   }
 
   /**
-    * Given a valid seat number, retrieve an index where a weapon controlled from this seat is attached.
+    * Given a valid seat number, retrieve an index where the weapon controlled from this seat is mounted.
     * @param seatNumber the seat number
     * @return a mounted weapon by index, or `None` if either the seat doesn't exist or there is no controlled weapon
     */
-  def WeaponControlledFromSeat(seatNumber : Int) : Option[Tool] = {
+  def WeaponControlledFromSeat(seatNumber : Int) : Option[Equipment] = {
     Seat(seatNumber) match {
       case Some(seat) =>
         wepFromSeat(seat)
@@ -297,7 +300,7 @@ class Vehicle(private val vehicleDef : VehicleDefinition) extends PlanetSideServ
     }
   }
 
-  private def wepFromSeat(seat : Seat) : Option[Tool] = {
+  private def wepFromSeat(seat : Seat) : Option[Equipment] = {
     seat.ControlledWeapon match {
       case Some(index) =>
         wepFromSeat(index)
@@ -306,10 +309,10 @@ class Vehicle(private val vehicleDef : VehicleDefinition) extends PlanetSideServ
     }
   }
 
-  private def wepFromSeat(wepIndex : Int) : Option[Tool] = {
+  private def wepFromSeat(wepIndex : Int) : Option[Equipment] = {
     weapons.get(wepIndex) match {
       case Some(wep) =>
-        wep.Equipment.asInstanceOf[Option[Tool]]
+        wep.Equipment
       case None =>
         None
     }

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

@@ -1,5 +1,5 @@
 // Copyright (c) 2017 PSForever
-package scripts
+package net.psforever.objects.guid
 
 /**
   * The basic compiled tasks for assigning (registering) and revoking (unregistering) globally unique identifiers.<br>
@@ -20,7 +20,6 @@ object GUIDTask {
   import akka.actor.ActorRef
   import net.psforever.objects.entity.IdentifiableEntity
   import net.psforever.objects.equipment.Equipment
-  import net.psforever.objects.guid.{Task, TaskResolver}
   import net.psforever.objects.{EquipmentSlot, Player, Tool, Vehicle}
 
   import scala.annotation.tailrec

common/src/main/scala/net/psforever/objects/guid/pool/ExclusivePool.scala

@@ -5,7 +5,7 @@ import net.psforever.objects.guid.selector.NumberSelector
 
 import scala.util.{Failure, Success, Try}
 
-class ExclusivePool(numbers : List[Int]) extends SimplePool(numbers) {
+class ExclusivePool(override val numbers : List[Int]) extends SimplePool(numbers) {
   private val pool : Array[Int] = Array.ofDim[Int](numbers.length)
   numbers.indices.foreach(i => { pool(i) = i })
 

common/src/main/scala/net/psforever/objects/guid/pool/SimplePool.scala

@@ -5,7 +5,7 @@ import net.psforever.objects.guid.selector.{NumberSelector, StrictInOrderSelecto
 
 import scala.util.{Success, Try}
 
-class SimplePool(private val numbers : List[Int]) extends NumberPool {
+class SimplePool(val numbers : List[Int]) extends NumberPool {
   if(numbers.count(_ < 0) > 0) {
     throw new IllegalArgumentException("negative numbers not allowed in number pool")
   }

common/src/main/scala/net/psforever/objects/inventory/AccessibleInventory.scala

@@ -1,13 +0,0 @@
-// Copyright (c) 2017 PSForever
-package net.psforever.objects.inventory
-
-import net.psforever.objects.Player
-import net.psforever.packet.game.PlanetSideGUID
-
-trait AccessibleInventory {
-  def Inventory : GridInventory
-
-  def CanAccess(who : Player) : Boolean
-  def Access(who : PlanetSideGUID) : Boolean
-  def Unaccess : Boolean
-}

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

@@ -11,7 +11,6 @@ import net.psforever.packet.game.UseItemMessage
   */
 class Door(private val ddef : DoorDefinition) extends PlanetSideServerObject {
   private var openState : Boolean = false
-  private var lockState : Boolean = false
 
   def Open : Boolean = openState
 
@@ -20,25 +19,15 @@ class Door(private val ddef : DoorDefinition) extends PlanetSideServerObject {
     Open
   }
 
-  def Locked : Boolean = lockState
-
-  def Locked_=(lock : Boolean) : Boolean = {
-    lockState = lock
-    Locked
-  }
-
   def Use(player : Player, msg : UseItemMessage) : Door.Exchange = {
-    if(!lockState && !openState) {
+    if(!openState) {
       openState = true
       Door.OpenEvent()
     }
-    else if(openState) {
+    else {
       openState = false
       Door.CloseEvent()
     }
-    else {
-      Door.NoEvent()
-    }
   }
 
   def Definition : DoorDefinition = ddef

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

@@ -13,9 +13,7 @@ import net.psforever.types.{ExoSuitType, TransactionType, Vector3}
   * @param tdef the `ObjectDefinition` that constructs this object and maintains some of its immutable fields
   */
 class Terminal(tdef : TerminalDefinition) extends PlanetSideServerObject {
-  /**
+  /** An entry that maintains a reference to the `Player`, and the player's GUID and location when the message was received. */
-    * An entry that maintains a reference to the `Player`, and the player's GUID and location when the message was received.
-    */
   private var hackedBy : Option[(Player, PlanetSideGUID, Vector3)] = None
 
   def HackedBy : Option[(Player, PlanetSideGUID, Vector3)] = hackedBy

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

@@ -136,11 +136,14 @@ class Zone(private val zoneId : String, zoneMap : ZoneMap, zoneNumber : Int) {
     * The replacement will not occur if the current system is populated or if its synchronized reference has been created.
     * @return synchronized reference to the globally unique identifier system
     */
-  def GUID(hub : NumberPoolHub) : ActorRef = {
+  def GUID(hub : NumberPoolHub) : Boolean = {
     if(actor == ActorRef.noSender && guid.Pools.map({case ((_, pool)) => pool.Count}).sum == 0) {
       guid = hub
+      true
+    }
+    else {
+      false
     }
-    Actor
   }
 
   /**
@@ -215,7 +218,7 @@ class Zone(private val zoneId : String, zoneMap : ZoneMap, zoneNumber : Int) {
   def Transport : ActorRef = transport
 
   def MakeBases(num : Int) : List[Base] = {
-    bases = (0 to num).map(id => new Base(id)).toList
+    bases = (1 to num).map(id => new Base(id)).toList
     bases
   }
 

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

@@ -50,7 +50,9 @@ class ZoneMap(private val name : String) {
   def LocalBases : Int = numBases
 
   def LocalBases_=(num : Int) : Int = {
-    numBases = math.max(0, num)
+    if(num > 0) {
+      numBases = num
+    }
     LocalBases
   }
 

common/src/test/scala/objects/ActorTest.scala

@@ -6,7 +6,7 @@ import akka.testkit.{ImplicitSender, TestKit}
 import org.scalatest.{BeforeAndAfterAll, Matchers, WordSpecLike}
 import org.specs2.specification.Scope
 
-abstract class ActorTest(sys : ActorSystem) extends TestKit(sys) with Scope with ImplicitSender with WordSpecLike with Matchers with BeforeAndAfterAll {
+abstract class ActorTest(sys : ActorSystem = ActorSystem("system")) extends TestKit(sys) with Scope with ImplicitSender with WordSpecLike with Matchers with BeforeAndAfterAll {
   override def afterAll {
     TestKit.shutdownActorSystem(system)
   }

common/src/test/scala/objects/ConverterTest.scala

@@ -287,7 +287,7 @@ class ConverterTest extends Specification {
           fury.Position = Vector3(3674.8438f, 2732f, 91.15625f)
           fury.Orientation = Vector3(0.0f, 0.0f, 90.0f)
           fury.WeaponControlledFromSeat(0).get.GUID = PlanetSideGUID(400)
-          fury.WeaponControlledFromSeat(0).get.AmmoSlots.head.Box = hellfire_ammo_box
+          fury.WeaponControlledFromSeat(0).get.asInstanceOf[Tool].AmmoSlots.head.Box = hellfire_ammo_box
 
       fury.Definition.Packet.ConstructorData(fury).isSuccess mustEqual true
       ok //TODO write more of this test

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

@@ -0,0 +1,91 @@
+// Copyright (c) 2017 PSForever
+package objects
+
+import akka.actor.{ActorRef, Props}
+import net.psforever.objects.{GlobalDefinitions, Player}
+import net.psforever.objects.serverobject.doors.{Door, DoorControl}
+import net.psforever.packet.game.{PlanetSideGUID, UseItemMessage}
+import net.psforever.types.{CharacterGender, PlanetSideEmpire, Vector3}
+import org.specs2.mutable.Specification
+
+import scala.concurrent.duration.Duration
+
+class DoorTest extends Specification {
+  "Door" should {
+    "construct" in {
+      Door(GlobalDefinitions.door)
+      ok
+    }
+
+    "starts as closed (false)" in {
+      val door = Door(GlobalDefinitions.door)
+      door.Open mustEqual false
+    }
+
+    "can be opened and closed (1; manual)" in {
+      val door = Door(GlobalDefinitions.door)
+      door.Open mustEqual false
+      door.Open = true
+      door.Open mustEqual true
+      door.Open = false
+      door.Open mustEqual false
+    }
+
+    "can beopened and closed (2; toggle)" in {
+      val player = Player("test", PlanetSideEmpire.TR, CharacterGender.Male, 0, 0)
+      val msg = UseItemMessage(PlanetSideGUID(6585), 0, PlanetSideGUID(372), 4294967295L, false, Vector3(5.0f,0.0f,0.0f), Vector3(0.0f,0.0f,0.0f), 11, 25, 0, 364)
+      val door = Door(GlobalDefinitions.door)
+      door.Open mustEqual false
+      door.Use(player, msg)
+      door.Open mustEqual true
+      door.Use(player, msg)
+      door.Open mustEqual false
+    }
+  }
+}
+
+class DoorControl1Test extends ActorTest() {
+  "DoorControl" should {
+    "construct" in {
+      val door = Door(GlobalDefinitions.door)
+      door.Actor = system.actorOf(Props(classOf[DoorControl], door), "door")
+      assert(door.Actor != ActorRef.noSender)
+    }
+  }
+}
+
+class DoorControl2Test extends ActorTest() {
+  "DoorControl" should {
+    "open on use" in {
+      val door = Door(GlobalDefinitions.door)
+      door.Actor = system.actorOf(Props(classOf[DoorControl], door), "door")
+      val player = Player("test", PlanetSideEmpire.TR, CharacterGender.Male, 0, 0)
+      val msg = UseItemMessage(PlanetSideGUID(1), 0, PlanetSideGUID(2), 0L, false, Vector3(0f,0f,0f),Vector3(0f,0f,0f),0,0,0,0L) //faked
+      assert(!door.Open)
+
+      door.Actor ! Door.Use(player, msg)
+      val reply = receiveOne(Duration.create(500, "ms"))
+      assert(reply.isInstanceOf[Door.DoorMessage])
+      val reply2 = reply.asInstanceOf[Door.DoorMessage]
+      assert(reply2.player == player)
+      assert(reply2.msg == msg)
+      assert(reply2.response == Door.OpenEvent())
+      assert(door.Open)
+    }
+  }
+}
+
+class DoorControl3Test extends ActorTest() {
+  "DoorControl" should {
+    "do nothing if given garbage" in {
+      val door = Door(GlobalDefinitions.door)
+      door.Actor = system.actorOf(Props(classOf[DoorControl], door), "door")
+      assert(!door.Open)
+
+      door.Actor ! "trash"
+      val reply = receiveOne(Duration.create(500, "ms"))
+      assert(reply.isInstanceOf[Door.NoEvent])
+      assert(!door.Open)
+    }
+  }
+}

common/src/test/scala/objects/GUIDTaskTest.scala

@@ -0,0 +1,245 @@
+// Copyright (c) 2017 PSForever
+package objects
+
+import java.util.logging.LogManager
+
+import akka.actor.{ActorRef, ActorSystem, Props}
+import akka.testkit.TestProbe
+import net.psforever.objects._
+import net.psforever.objects.entity.IdentifiableEntity
+import net.psforever.objects.guid.actor.{NumberPoolActor, UniqueNumberSystem}
+import net.psforever.objects.guid.selector.RandomSelector
+import net.psforever.objects.guid.source.LimitedNumberSource
+import net.psforever.objects.guid.{GUIDTask, NumberPoolHub, Task, TaskResolver}
+import net.psforever.types.{CharacterGender, PlanetSideEmpire}
+
+class GUIDTaskRegister1Test extends ActorTest() {
+  "RegisterObjectTask" in {
+    val (_, uns, taskResolver, probe) = GUIDTaskTest.CommonTestSetup
+    val obj = new GUIDTaskTest.TestObject
+
+    assert(!obj.HasGUID)
+    taskResolver ! TaskResolver.GiveTask(new GUIDTaskTest.RegisterTestTask(probe.ref), List(GUIDTask.RegisterObjectTask(obj)(uns)))
+    probe.expectMsg(scala.util.Success)
+    assert(obj.HasGUID)
+  }
+}
+
+class GUIDTaskRegister2Test extends ActorTest() {
+  "RegisterEquipment -> RegisterObjectTask" in {
+    val (_, uns, taskResolver, probe) = GUIDTaskTest.CommonTestSetup
+    val obj = AmmoBox(GlobalDefinitions.energy_cell)
+
+    assert(!obj.HasGUID)
+    taskResolver ! TaskResolver.GiveTask(new GUIDTaskTest.RegisterTestTask(probe.ref), List(GUIDTask.RegisterEquipment(obj)(uns)))
+    probe.expectMsg(scala.util.Success)
+    assert(obj.HasGUID)
+  }
+}
+
+class GUIDTaskRegister3Test extends ActorTest() {
+  "RegisterEquipment -> RegisterTool" in {
+    val (_, uns, taskResolver, probe) = GUIDTaskTest.CommonTestSetup
+    val obj = Tool(GlobalDefinitions.beamer)
+    obj.AmmoSlots.head.Box = AmmoBox(GlobalDefinitions.energy_cell)
+
+    assert(!obj.HasGUID)
+    assert(!obj.AmmoSlots.head.Box.HasGUID)
+    taskResolver ! TaskResolver.GiveTask(new GUIDTaskTest.RegisterTestTask(probe.ref), List(GUIDTask.RegisterEquipment(obj)(uns)))
+    probe.expectMsg(scala.util.Success)
+    assert(obj.HasGUID)
+    assert(obj.AmmoSlots.head.Box.HasGUID)
+  }
+}
+
+class GUIDTaskRegister4Test extends ActorTest() {
+  "RegisterVehicle" in {
+    val (_, uns, taskResolver, probe) = GUIDTaskTest.CommonTestSetup
+    val obj = Vehicle(GlobalDefinitions.fury)
+    val obj_wep = obj.WeaponControlledFromSeat(0).get
+    val obj_wep_ammo = (obj.WeaponControlledFromSeat(0).get.asInstanceOf[Tool].AmmoSlots.head.Box = AmmoBox(GlobalDefinitions.hellfire_ammo)).get
+    obj.Trunk += 30 -> AmmoBox(GlobalDefinitions.hellfire_ammo)
+    val obj_trunk_ammo = obj.Trunk.Items(0).obj
+
+    assert(!obj.HasGUID)
+    assert(!obj_wep.HasGUID)
+    assert(!obj_wep_ammo.HasGUID)
+    assert(!obj_trunk_ammo.HasGUID)
+    taskResolver ! TaskResolver.GiveTask(new GUIDTaskTest.RegisterTestTask(probe.ref), List(GUIDTask.RegisterVehicle(obj)(uns)))
+    probe.expectMsg(scala.util.Success)
+    assert(obj.HasGUID)
+    assert(obj_wep.HasGUID)
+    assert(obj_wep_ammo.HasGUID)
+    assert(obj_trunk_ammo.HasGUID)
+  }
+}
+
+class GUIDTaskRegister5Test extends ActorTest() {
+  "RegisterAvatar" in {
+    val (_, uns, taskResolver, probe) = GUIDTaskTest.CommonTestSetup
+    val obj = Player("test", PlanetSideEmpire.TR, CharacterGender.Male, 0, 0)
+    val obj_wep = Tool(GlobalDefinitions.beamer)
+    obj.Slot(0).Equipment = obj_wep
+    val obj_wep_ammo = AmmoBox(GlobalDefinitions.energy_cell)
+    obj_wep.AmmoSlots.head.Box = obj_wep_ammo
+    val obj_inv_ammo = AmmoBox(GlobalDefinitions.energy_cell)
+    obj.Slot(6).Equipment = obj_inv_ammo
+    val obj_locker = obj.Slot(5).Equipment.get
+    val obj_locker_ammo = AmmoBox(GlobalDefinitions.energy_cell)
+    obj_locker.asInstanceOf[LockerContainer].Inventory += 0 -> obj_locker_ammo
+
+    assert(!obj.HasGUID)
+    assert(!obj_wep.HasGUID)
+    assert(!obj_wep_ammo.HasGUID)
+    assert(!obj_inv_ammo.HasGUID)
+    assert(!obj_locker.HasGUID)
+    assert(!obj_locker_ammo.HasGUID)
+    taskResolver ! TaskResolver.GiveTask(new GUIDTaskTest.RegisterTestTask(probe.ref), List(GUIDTask.RegisterAvatar(obj)(uns)))
+    probe.expectMsg(scala.util.Success)
+    assert(obj.HasGUID)
+    assert(obj_wep.HasGUID)
+    assert(obj_wep_ammo.HasGUID)
+    assert(obj_inv_ammo.HasGUID)
+    assert(obj_locker.HasGUID)
+    assert(obj_locker_ammo.HasGUID)
+  }
+}
+
+class GUIDTaskUnregister1Test extends ActorTest() {
+  "UnregisterObjectTask" in {
+    val (guid, uns, taskResolver, probe) = GUIDTaskTest.CommonTestSetup
+    val obj = new GUIDTaskTest.TestObject
+    guid.register(obj, "dynamic")
+
+    assert(obj.HasGUID)
+    taskResolver ! TaskResolver.GiveTask(new GUIDTaskTest.RegisterTestTask(probe.ref), List(GUIDTask.UnregisterObjectTask(obj)(uns)))
+    probe.expectMsg(scala.util.Success)
+    assert(!obj.HasGUID)
+  }
+}
+
+class GUIDTaskUnregister2Test extends ActorTest() {
+  "UnregisterEquipment -> UnregisterObjectTask" in {
+    val (guid, uns, taskResolver, probe) = GUIDTaskTest.CommonTestSetup
+    val obj = AmmoBox(GlobalDefinitions.energy_cell)
+    guid.register(obj, "dynamic")
+
+    assert(obj.HasGUID)
+    taskResolver ! TaskResolver.GiveTask(new GUIDTaskTest.RegisterTestTask(probe.ref), List(GUIDTask.UnregisterEquipment(obj)(uns)))
+    probe.expectMsg(scala.util.Success)
+    assert(!obj.HasGUID)
+  }
+}
+
+class GUIDTaskUnregister3Test extends ActorTest() {
+  "UnregisterEquipment -> UnregisterTool" in {
+    val (guid, uns, taskResolver, probe) = GUIDTaskTest.CommonTestSetup
+    val obj = Tool(GlobalDefinitions.beamer)
+    obj.AmmoSlots.head.Box = AmmoBox(GlobalDefinitions.energy_cell)
+    guid.register(obj, "dynamic")
+    guid.register(obj.AmmoSlots.head.Box, "dynamic")
+
+    assert(obj.HasGUID)
+    assert(obj.AmmoSlots.head.Box.HasGUID)
+    taskResolver ! TaskResolver.GiveTask(new GUIDTaskTest.RegisterTestTask(probe.ref), List(GUIDTask.UnregisterEquipment(obj)(uns)))
+    probe.expectMsg(scala.util.Success)
+    assert(!obj.HasGUID)
+    assert(!obj.AmmoSlots.head.Box.HasGUID)
+  }
+}
+
+class GUIDTaskUnregister4Test extends ActorTest() {
+  "RegisterVehicle" in {
+    val (guid, uns, taskResolver, probe) = GUIDTaskTest.CommonTestSetup
+    val obj = Vehicle(GlobalDefinitions.fury)
+    val obj_wep = obj.WeaponControlledFromSeat(0).get
+    val obj_wep_ammo = (obj.WeaponControlledFromSeat(0).get.asInstanceOf[Tool].AmmoSlots.head.Box = AmmoBox(GlobalDefinitions.hellfire_ammo)).get
+    obj.Trunk += 30 -> AmmoBox(GlobalDefinitions.hellfire_ammo)
+    val obj_trunk_ammo = obj.Trunk.Items(0).obj
+    guid.register(obj, "dynamic")
+    guid.register(obj_wep, "dynamic")
+    guid.register(obj_wep_ammo, "dynamic")
+    guid.register(obj_trunk_ammo, "dynamic")
+
+    assert(obj.HasGUID)
+    assert(obj_wep.HasGUID)
+    assert(obj_wep_ammo.HasGUID)
+    assert(obj_trunk_ammo.HasGUID)
+    taskResolver ! TaskResolver.GiveTask(new GUIDTaskTest.RegisterTestTask(probe.ref), List(GUIDTask.UnregisterVehicle(obj)(uns)))
+    probe.expectMsg(scala.util.Success)
+    assert(!obj.HasGUID)
+    assert(!obj_wep.HasGUID)
+    assert(!obj_wep_ammo.HasGUID)
+    assert(!obj_trunk_ammo.HasGUID)
+  }
+}
+
+class GUIDTaskUnregister5Test extends ActorTest() {
+  "UnregisterAvatar" in {
+    val (guid, uns, taskResolver, probe) = GUIDTaskTest.CommonTestSetup
+    val obj = Player("test", PlanetSideEmpire.TR, CharacterGender.Male, 0, 0)
+    val obj_wep = Tool(GlobalDefinitions.beamer)
+    obj.Slot(0).Equipment = obj_wep
+    val obj_wep_ammo = AmmoBox(GlobalDefinitions.energy_cell)
+    obj_wep.AmmoSlots.head.Box = obj_wep_ammo
+    val obj_inv_ammo = AmmoBox(GlobalDefinitions.energy_cell)
+    obj.Slot(6).Equipment = obj_inv_ammo
+    val obj_locker = obj.Slot(5).Equipment.get
+    val obj_locker_ammo = AmmoBox(GlobalDefinitions.energy_cell)
+    obj_locker.asInstanceOf[LockerContainer].Inventory += 0 -> obj_locker_ammo
+    guid.register(obj, "dynamic")
+    guid.register(obj_wep, "dynamic")
+    guid.register(obj_wep_ammo, "dynamic")
+    guid.register(obj_inv_ammo, "dynamic")
+    guid.register(obj_locker, "dynamic")
+    guid.register(obj_locker_ammo, "dynamic")
+
+    assert(obj.HasGUID)
+    assert(obj_wep.HasGUID)
+    assert(obj_wep_ammo.HasGUID)
+    assert(obj_inv_ammo.HasGUID)
+    assert(obj_locker.HasGUID)
+    assert(obj_locker_ammo.HasGUID)
+    taskResolver ! TaskResolver.GiveTask(new GUIDTaskTest.RegisterTestTask(probe.ref), List(GUIDTask.UnregisterAvatar(obj)(uns)))
+    probe.expectMsg(scala.util.Success)
+    assert(!obj.HasGUID)
+    assert(!obj_wep.HasGUID)
+    assert(!obj_wep_ammo.HasGUID)
+    assert(!obj_inv_ammo.HasGUID)
+    assert(!obj_locker.HasGUID)
+    assert(!obj_locker_ammo.HasGUID)
+  }
+}
+
+object GUIDTaskTest {
+  class TestObject extends IdentifiableEntity
+
+  class RegisterTestTask(probe : ActorRef) extends Task {
+    def Execute(resolver : ActorRef) : Unit = {
+      probe ! scala.util.Success
+      resolver ! scala.util.Success(this)
+    }
+  }
+
+  def CommonTestSetup(implicit system : ActorSystem) : (NumberPoolHub, ActorRef, ActorRef, TestProbe) = {
+    import akka.actor.Props
+    import akka.routing.RandomPool
+    import akka.testkit.TestProbe
+
+    val guid : NumberPoolHub = new NumberPoolHub(new LimitedNumberSource(110))
+    guid.AddPool("dynamic", (1 to 100).toList).Selector = new RandomSelector //TODO name is hardcoded for now
+    val uns = system.actorOf(RandomPool(25).props(Props(classOf[UniqueNumberSystem], guid, GUIDTaskTest.AllocateNumberPoolActors(guid))), "uns")
+    val taskResolver = system.actorOf(RandomPool(15).props(Props[TaskResolver]), "resolver")
+    LogManager.getLogManager.reset() //suppresses any internal loggers created by the above elements
+    (guid, uns, taskResolver, TestProbe())
+  }
+
+  /**
+    * @see `UniqueNumberSystem.AllocateNumberPoolActors(NumberPoolHub)(implicit ActorContext)`
+    */
+  def AllocateNumberPoolActors(poolSource : NumberPoolHub)(implicit system : ActorSystem) : Map[String, ActorRef] = {
+    poolSource.Pools.map({ case ((pname, pool)) =>
+      pname -> system.actorOf(Props(classOf[NumberPoolActor], pool), pname)
+    }).toMap
+  }
+}

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

@@ -0,0 +1,66 @@
+// Copyright (c) 2017 PSForever
+package objects
+
+import akka.actor.{ActorRef, Props}
+import net.psforever.objects.serverobject.CommonMessages
+import net.psforever.objects.{GlobalDefinitions, Player}
+import net.psforever.objects.serverobject.locks.{IFFLock, IFFLockControl}
+import net.psforever.packet.game.PlanetSideGUID
+import net.psforever.types.{CharacterGender, PlanetSideEmpire}
+import org.specs2.mutable.Specification
+
+class IFFLockTest extends Specification {
+  "IFFLock" should {
+    "construct" in {
+      IFFLock(GlobalDefinitions.lock_external)
+      ok
+    }
+
+    //TODO internal hacking logic will be re-written later
+  }
+}
+
+class IFFLockControl1Test extends ActorTest() {
+  "IFFLockControl" should {
+    "construct" in {
+      val lock = IFFLock(GlobalDefinitions.lock_external)
+      lock.Actor = system.actorOf(Props(classOf[IFFLockControl], lock), "lock-control")
+      assert(lock.Actor != ActorRef.noSender)
+    }
+  }
+}
+
+class IFFLockControl2Test extends ActorTest() {
+  "IFFLockControl" should {
+    "can hack" in {
+      val lock = IFFLock(GlobalDefinitions.lock_external)
+      lock.Actor = system.actorOf(Props(classOf[IFFLockControl], lock), "lock-control")
+      val player = Player("test", PlanetSideEmpire.TR, CharacterGender.Male, 0, 0)
+      player.GUID = PlanetSideGUID(1)
+      assert(lock.HackedBy.isEmpty)
+
+      lock.Actor ! CommonMessages.Hack(player)
+      Thread.sleep(500L) //blocking
+      assert(lock.HackedBy.nonEmpty) //TODO rewrite later
+    }
+  }
+}
+
+class IFFLockControl3Test extends ActorTest() {
+  "IFFLockControl" should {
+    "can hack" in {
+      val lock = IFFLock(GlobalDefinitions.lock_external)
+      lock.Actor = system.actorOf(Props(classOf[IFFLockControl], lock), "lock-control")
+      val player = Player("test", PlanetSideEmpire.TR, CharacterGender.Male, 0, 0)
+      player.GUID = PlanetSideGUID(1)
+      assert(lock.HackedBy.isEmpty)
+
+      lock.Actor ! CommonMessages.Hack(player)
+      Thread.sleep(500L) //blocking
+      assert(lock.HackedBy.nonEmpty) //TODO rewrite later
+      lock.Actor ! CommonMessages.ClearHack()
+      Thread.sleep(500L) //blocking
+      assert(lock.HackedBy.isEmpty) //TODO rewrite
+    }
+  }
+}

common/src/test/scala/objects/VehicleTest.scala

@@ -1,9 +1,11 @@
 // Copyright (c) 2017 PSForever
 package objects
 
-import net.psforever.objects.{GlobalDefinitions, Vehicle}
+import net.psforever.objects.{GlobalDefinitions, Player, Vehicle}
 import net.psforever.objects.definition.SeatDefinition
-import net.psforever.objects.vehicles.{Seat, SeatArmorRestriction, VehicleLockState}
+import net.psforever.objects.vehicles.{AccessPermissionGroup, Seat, SeatArmorRestriction, VehicleLockState}
+import net.psforever.packet.game.PlanetSideGUID
+import net.psforever.types.{CharacterGender, ExoSuitType, PlanetSideEmpire}
 import org.specs2.mutable._
 
 class VehicleTest extends Specification {
@@ -37,8 +39,7 @@ class VehicleTest extends Specification {
       fury.Seats(0).Bailable mustEqual true
       fury.Seats(0).ControlledWeapon mustEqual Some(1)
       fury.MountPoints.size mustEqual 2
-      fury.MountPoints.get(0) mustEqual Some(0)
+      fury.MountPoints.get(1) mustEqual Some(0)
-      fury.MountPoints.get(1) mustEqual None
       fury.MountPoints.get(2) mustEqual Some(0)
       fury.Weapons.size mustEqual 1
       fury.Weapons.get(0) mustEqual None
@@ -63,6 +64,58 @@ class VehicleTest extends Specification {
       seat.isOccupied mustEqual false
       seat.Occupant mustEqual None
     }
+
+    "player can sit" in {
+      val seat = new Seat(seat_def)
+      seat.Occupant.isDefined mustEqual false
+
+      val player1 = Player("test1", PlanetSideEmpire.TR, CharacterGender.Male, 0, 0)
+      player1.ExoSuit = ExoSuitType.MAX
+      seat.Occupant = player1
+      seat.Occupant.isDefined mustEqual true
+      seat.Occupant.contains(player1) mustEqual true
+    }
+
+    "one occupant at a time" in {
+      val seat = new Seat(seat_def)
+      seat.Occupant.isDefined mustEqual false
+
+      val player1 = Player("test1", PlanetSideEmpire.TR, CharacterGender.Male, 0, 0)
+      player1.ExoSuit = ExoSuitType.MAX
+      seat.Occupant = player1
+      seat.Occupant.isDefined mustEqual true
+      seat.Occupant.contains(player1) mustEqual true
+
+      val player2 = Player("test2", PlanetSideEmpire.TR, CharacterGender.Male, 0, 0)
+      player2.ExoSuit = ExoSuitType.MAX
+      seat.Occupant = player2
+      seat.Occupant.isDefined mustEqual true
+      seat.Occupant.contains(player1) mustEqual true
+    }
+
+    "one player must get out of seat before other can get in" in {
+      val seat = new Seat(seat_def)
+      seat.Occupant.isDefined mustEqual false
+
+      val player1 = Player("test1", PlanetSideEmpire.TR, CharacterGender.Male, 0, 0)
+      player1.ExoSuit = ExoSuitType.MAX
+      seat.Occupant = player1
+      seat.Occupant.isDefined mustEqual true
+      seat.Occupant.contains(player1) mustEqual true
+
+      val player2 = Player("test2", PlanetSideEmpire.TR, CharacterGender.Male, 0, 0)
+      player2.ExoSuit = ExoSuitType.MAX
+      seat.Occupant = player2
+      seat.Occupant.isDefined mustEqual true
+      seat.Occupant.contains(player2) mustEqual false
+      seat.Occupant.contains(player1) mustEqual true
+
+      seat.Occupant = None
+      seat.Occupant.isDefined mustEqual false
+      seat.Occupant = player2
+      seat.Occupant.isDefined mustEqual true
+      seat.Occupant.contains(player2) mustEqual true
+    }
   }
 
   "Vehicle" should {
@@ -93,11 +146,111 @@ class VehicleTest extends Specification {
       fury_vehicle.Trunk.Width mustEqual 11
       fury_vehicle.Trunk.Height mustEqual 11
       fury_vehicle.Trunk.Offset mustEqual 30
-      fury_vehicle.GetSeatFromMountPoint(0) mustEqual Some(0)
+      fury_vehicle.GetSeatFromMountPoint(1) mustEqual Some(0)
-      fury_vehicle.GetSeatFromMountPoint(1) mustEqual None
       fury_vehicle.GetSeatFromMountPoint(2) mustEqual Some(0)
       fury_vehicle.Decal mustEqual 0
       fury_vehicle.Health mustEqual fury_vehicle.Definition.MaxHealth
     }
+
+    "can be owned by a player" in {
+      val fury_vehicle = Vehicle(GlobalDefinitions.fury)
+      fury_vehicle.Owner.isDefined mustEqual false
+
+      val player1 = Player("test1", PlanetSideEmpire.TR, CharacterGender.Male, 0, 0)
+      player1.GUID = PlanetSideGUID(1)
+      fury_vehicle.Owner = player1
+      fury_vehicle.Owner.isDefined mustEqual true
+      fury_vehicle.Owner.contains(PlanetSideGUID(1)) mustEqual true
+    }
+
+    "ownership depends on who last was granted it" in {
+      val fury_vehicle = Vehicle(GlobalDefinitions.fury)
+      fury_vehicle.Owner.isDefined mustEqual false
+
+      val player1 = Player("test1", PlanetSideEmpire.TR, CharacterGender.Male, 0, 0)
+      player1.GUID = PlanetSideGUID(1)
+      fury_vehicle.Owner = player1
+      fury_vehicle.Owner.isDefined mustEqual true
+      fury_vehicle.Owner.contains(PlanetSideGUID(1)) mustEqual true
+
+      val player2 = Player("test2", PlanetSideEmpire.TR, CharacterGender.Male, 0, 0)
+      player2.GUID = PlanetSideGUID(2)
+      fury_vehicle.Owner = player2
+      fury_vehicle.Owner.isDefined mustEqual true
+      fury_vehicle.Owner.contains(PlanetSideGUID(2)) mustEqual true
+    }
+
+    "can use mount point to get seat number" in {
+      val fury_vehicle = Vehicle(GlobalDefinitions.fury)
+      fury_vehicle.GetSeatFromMountPoint(0) mustEqual None
+      fury_vehicle.GetSeatFromMountPoint(1) mustEqual Some(0)
+      fury_vehicle.GetSeatFromMountPoint(2) mustEqual Some(0)
+      fury_vehicle.GetSeatFromMountPoint(3) mustEqual None
+    }
+
+    "has four permission groups" in {
+      val fury_vehicle = Vehicle(GlobalDefinitions.fury)
+      fury_vehicle.PermissionGroup(AccessPermissionGroup.Driver.id) mustEqual Some(VehicleLockState.Locked)
+      fury_vehicle.PermissionGroup(AccessPermissionGroup.Gunner.id) mustEqual Some(VehicleLockState.Empire)
+      fury_vehicle.PermissionGroup(AccessPermissionGroup.Passenger.id) mustEqual Some(VehicleLockState.Empire)
+      fury_vehicle.PermissionGroup(AccessPermissionGroup.Trunk.id) mustEqual Some(VehicleLockState.Locked)
+    }
+
+    "set new permission level" in {
+      val fury_vehicle = Vehicle(GlobalDefinitions.fury)
+      fury_vehicle.PermissionGroup(AccessPermissionGroup.Driver.id) mustEqual Some(VehicleLockState.Locked)
+      fury_vehicle.PermissionGroup(AccessPermissionGroup.Driver.id, VehicleLockState.Group.id) mustEqual Some(VehicleLockState.Group)
+    }
+
+    "set the same permission level" in {
+      val fury_vehicle = Vehicle(GlobalDefinitions.fury)
+      fury_vehicle.PermissionGroup(AccessPermissionGroup.Driver.id) mustEqual Some(VehicleLockState.Locked)
+      fury_vehicle.PermissionGroup(AccessPermissionGroup.Driver.id, VehicleLockState.Locked.id) mustEqual None
+    }
+
+    "alternate permission level indices" in {
+      val fury_vehicle = Vehicle(GlobalDefinitions.fury)
+      fury_vehicle.PermissionGroup(AccessPermissionGroup.Driver.id) mustEqual fury_vehicle.PermissionGroup(10)
+      fury_vehicle.PermissionGroup(AccessPermissionGroup.Gunner.id) mustEqual fury_vehicle.PermissionGroup(11)
+      fury_vehicle.PermissionGroup(AccessPermissionGroup.Passenger.id) mustEqual fury_vehicle.PermissionGroup(12)
+      fury_vehicle.PermissionGroup(AccessPermissionGroup.Trunk.id) mustEqual fury_vehicle.PermissionGroup(13)
+
+      (AccessPermissionGroup.Driver.id + 10) mustEqual 10
+      fury_vehicle.PermissionGroup(AccessPermissionGroup.Driver.id, VehicleLockState.Group.id) mustEqual Some(VehicleLockState.Group)
+      fury_vehicle.PermissionGroup(AccessPermissionGroup.Driver.id) mustEqual fury_vehicle.PermissionGroup(10)
+    }
+
+    "can determine permission group from seat" in {
+      val harasser_vehicle = Vehicle(GlobalDefinitions.two_man_assault_buggy)
+      harasser_vehicle.SeatPermissionGroup(0) mustEqual Some(AccessPermissionGroup.Driver)
+      harasser_vehicle.SeatPermissionGroup(1) mustEqual Some(AccessPermissionGroup.Gunner)
+      harasser_vehicle.SeatPermissionGroup(2) mustEqual None
+      //TODO test for AccessPermissionGroup.Passenger later
+    }
+
+    "can find a passenger in a seat" in {
+      val harasser_vehicle = Vehicle(GlobalDefinitions.two_man_assault_buggy)
+      val player1 = Player("test1", PlanetSideEmpire.TR, CharacterGender.Male, 0, 0)
+      player1.GUID = PlanetSideGUID(1)
+      val player2 = Player("test2", PlanetSideEmpire.TR, CharacterGender.Male, 0, 0)
+      player2.GUID = PlanetSideGUID(2)
+      harasser_vehicle.Seat(0).get.Occupant = player1 //don't worry about ownership for now
+      harasser_vehicle.Seat(1).get.Occupant = player2
+
+      harasser_vehicle.PassengerInSeat(player1) mustEqual Some(0)
+      harasser_vehicle.PassengerInSeat(player2) mustEqual Some(1)
+      harasser_vehicle.Seat(0).get.Occupant = None
+      harasser_vehicle.PassengerInSeat(player1) mustEqual None
+      harasser_vehicle.PassengerInSeat(player2) mustEqual Some(1)
+    }
+
+    "can find a weapon controlled from seat" in {
+      val harasser_vehicle = Vehicle(GlobalDefinitions.two_man_assault_buggy)
+      val chaingun_p = harasser_vehicle.Weapons(2).Equipment
+      chaingun_p.isDefined mustEqual true
+
+      harasser_vehicle.WeaponControlledFromSeat(0) mustEqual None
+      harasser_vehicle.WeaponControlledFromSeat(1) mustEqual chaingun_p
+    }
   }
 }

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

@@ -0,0 +1,104 @@
+// Copyright (c) 2017 PSForever
+package objects
+
+import akka.actor.ActorRef
+import net.psforever.objects.entity.IdentifiableEntity
+import net.psforever.objects.equipment.Equipment
+import net.psforever.objects.guid.NumberPoolHub
+import net.psforever.objects.guid.source.LimitedNumberSource
+import net.psforever.objects.zones.{Zone, ZoneMap}
+import net.psforever.objects.{GlobalDefinitions, Vehicle}
+import org.specs2.mutable.Specification
+
+class ZoneTest extends Specification {
+  "ZoneMap" should {
+    //TODO these are temporary tests as the current ZoneMap is a kludge
+    "construct" in {
+      new ZoneMap("map13")
+      ok
+    }
+
+    "references bases by a positive building id (defaults to 0)" in {
+      val map = new ZoneMap("map13")
+      map.LocalBases mustEqual 0
+      map.LocalBases = 10
+      map.LocalBases mustEqual 10
+      map.LocalBases = -1
+      map.LocalBases mustEqual 10
+    }
+
+    "associates objects to bases (doesn't check numbers)" in {
+      val map = new ZoneMap("map13")
+      map.ObjectToBase mustEqual Nil
+      map.ObjectToBase(1, 2)
+      map.ObjectToBase mustEqual List((1, 2))
+      map.ObjectToBase(3, 4)
+      map.ObjectToBase mustEqual List((1, 2), (3, 4))
+    }
+
+    "associates doors to door locks (doesn't check numbers)" in {
+      val map = new ZoneMap("map13")
+      map.DoorToLock mustEqual Map.empty
+      map.DoorToLock(1, 2)
+      map.DoorToLock mustEqual Map(1 -> 2)
+      map.DoorToLock(3, 4)
+      map.DoorToLock mustEqual Map(1 -> 2, 3 -> 4)
+    }
+  }
+
+  val map13 = new ZoneMap("map13")
+  map13.LocalBases = 10
+  class TestObject extends IdentifiableEntity
+
+  "Zone" should {
+    //TODO these are temporary tests as the current Zone is a kludge
+    "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]
+    }
+
+    "can have its unique identifier system changed if no objects were added to it" in {
+      val zone = new Zone("home3", map13, 13)
+      val guid1 : NumberPoolHub = new NumberPoolHub(new LimitedNumberSource(100))
+      guid1.AddPool("pool1", (0 to 50).toList)
+      guid1.AddPool("pool2", (51 to 75).toList)
+      zone.GUID(guid1) mustEqual true
+
+      val obj = new TestObject()
+      guid1.register(obj, "pool2").isSuccess mustEqual true
+      guid1.WhichPool(obj) mustEqual Some("pool2")
+
+      val guid2 : NumberPoolHub = new NumberPoolHub(new LimitedNumberSource(150))
+      guid2.AddPool("pool3", (0 to 50).toList)
+      guid2.AddPool("pool4", (51 to 75).toList)
+      zone.GUID(guid2) mustEqual false
+    }
+
+    "can keep track of Vehicles" in {
+      val zone = new Zone("home3", map13, 13)
+      val fury = Vehicle(GlobalDefinitions.fury)
+      zone.Vehicles mustEqual List()
+      zone.AddVehicle(fury)
+      zone.Vehicles mustEqual List(fury)
+    }
+
+    "can forget specific vehicles" in {
+      val zone = new Zone("home3", map13, 13)
+      val fury = Vehicle(GlobalDefinitions.fury)
+      val wraith = Vehicle(GlobalDefinitions.quadstealth)
+      val basilisk = Vehicle(GlobalDefinitions.quadassault)
+      zone.AddVehicle(wraith)
+      zone.AddVehicle(fury)
+      zone.AddVehicle(basilisk)
+      zone.Vehicles mustEqual List(wraith, fury, basilisk)
+
+      zone.RemoveVehicle(fury)
+      zone.Vehicles mustEqual List(wraith, basilisk)
+    }
+  }
+}

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

@@ -1,10 +1,11 @@
 // Copyright (c) 2017 PSForever
-package objects
+package objects.number
 
 import akka.actor.{ActorSystem, Props}
 import net.psforever.objects.guid.actor.NumberPoolActor
 import net.psforever.objects.guid.pool.ExclusivePool
 import net.psforever.objects.guid.selector.RandomSelector
+import objects.ActorTest
 
 import scala.concurrent.duration.Duration
 
@@ -15,7 +16,7 @@ class NumberPoolActorTest extends ActorTest(ActorSystem("test")) {
       pool.Selector = new RandomSelector
       val poolActor = system.actorOf(Props(classOf[NumberPoolActor], pool), name = "poolActor1")
       poolActor ! NumberPoolActor.GetAnyNumber()
-      val msg = receiveOne(Duration.create(100, "ms"))
+      val msg = receiveOne(Duration.create(500, "ms"))
       assert(msg.isInstanceOf[NumberPoolActor.GiveNumber])
     }
   }
@@ -43,7 +44,7 @@ class NumberPoolActorTest2 extends ActorTest(ActorSystem("test")) {
       expectMsg(NumberPoolActor.GiveNumber(25, None))
 
       poolActor ! NumberPoolActor.GetAnyNumber()
-      val msg = receiveOne(Duration.create(100, "ms"))
+      val msg = receiveOne(Duration.create(500, "ms"))
       assert(msg.isInstanceOf[NumberPoolActor.NoNumber])
     }
   }

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

@@ -1,5 +1,5 @@
 // Copyright (c) 2017 PSForever
-package objects
+package objects.number
 
 import net.psforever.objects.entity.IdentifiableEntity
 import net.psforever.objects.guid.NumberPoolHub

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

@@ -1,5 +1,5 @@
 // Copyright (c) 2017 PSForever
-package objects
+package objects.number
 
 import net.psforever.objects.guid.pool.{ExclusivePool, GenericPool, SimplePool}
 import net.psforever.objects.guid.selector.SpecificSelector
@@ -191,4 +191,3 @@ class NumberPoolTest extends Specification {
     }
   }
 }
-

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

@@ -1,5 +1,5 @@
 // Copyright (c) 2017 PSForever
-package objects
+package objects.number
 
 import net.psforever.objects.guid.selector.{RandomSequenceSelector, _}
 import org.specs2.mutable.Specification
@@ -323,4 +323,3 @@ class NumberSelectorTest extends Specification {
     }
   }
 }
-

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

@@ -1,8 +1,8 @@
 // Copyright (c) 2017 PSForever
-package objects
+package objects.number
 
-import net.psforever.objects.guid.key.{LoanedKey, SecureKey}
 import net.psforever.objects.guid.AvailabilityPolicy
+import net.psforever.objects.guid.key.{LoanedKey, SecureKey}
 import org.specs2.mutable.Specification
 
 class NumberSourceTest extends Specification {

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

@@ -1,5 +1,5 @@
 // Copyright (c) 2017 PSForever
-package objects
+package objects.number
 
 import akka.actor.{ActorRef, ActorSystem, Props}
 import net.psforever.objects.entity.IdentifiableEntity
@@ -7,11 +7,12 @@ import net.psforever.objects.guid.NumberPoolHub
 import net.psforever.objects.guid.actor.{NumberPoolActor, Register, UniqueNumberSystem, Unregister}
 import net.psforever.objects.guid.selector.RandomSelector
 import net.psforever.objects.guid.source.LimitedNumberSource
+import objects.ActorTest
 
 import scala.concurrent.duration.Duration
 import scala.util.{Failure, Success}
 
-class AllocateNumberPoolActors extends ActorTest(ActorSystem("test")) {
+class AllocateNumberPoolActors extends ActorTest() {
   "AllocateNumberPoolActors" in {
     val src : LimitedNumberSource = LimitedNumberSource(6000)
     val guid : NumberPoolHub = new NumberPoolHub(src)
@@ -27,7 +28,7 @@ class AllocateNumberPoolActors extends ActorTest(ActorSystem("test")) {
   }
 }
 
-class UniqueNumberSystemTest extends ActorTest(ActorSystem("test")) {
+class UniqueNumberSystemTest extends ActorTest() {
   "UniqueNumberSystem" should {
     "constructor" in {
       val src : LimitedNumberSource = LimitedNumberSource(6000)
@@ -37,12 +38,11 @@ class UniqueNumberSystemTest extends ActorTest(ActorSystem("test")) {
       guid.AddPool("pool3", (5001 to 6000).toList)
       system.actorOf(Props(classOf[UniqueNumberSystem], guid, UniqueNumberSystemTest.AllocateNumberPoolActors(guid)), "uns")
       //as long as it constructs ...
-
     }
   }
 }
 
-class UniqueNumberSystemTest1 extends ActorTest(ActorSystem("test")) {
+class UniqueNumberSystemTest1 extends ActorTest() {
   class EntityTestClass extends IdentifiableEntity
 
   "UniqueNumberSystem" should {
@@ -61,7 +61,7 @@ class UniqueNumberSystemTest1 extends ActorTest(ActorSystem("test")) {
       for(_  <- 1 to 100) {
         val testObj = new EntityTestClass()
         uns ! Register(testObj, "pool1")
-        val msg = receiveOne(Duration.create(100, "ms"))
+        val msg = receiveOne(Duration.create(500, "ms"))
         assert(msg.isInstanceOf[Success[_]])
         assert(pool1.contains(testObj.GUID.guid))
       }
@@ -69,7 +69,7 @@ class UniqueNumberSystemTest1 extends ActorTest(ActorSystem("test")) {
       for(_  <- 1 to 100) {
         val testObj = new EntityTestClass()
         uns ! Register(testObj, "pool2")
-        val msg = receiveOne(Duration.create(100, "ms"))
+        val msg = receiveOne(Duration.create(500, "ms"))
         assert(msg.isInstanceOf[Success[_]])
         assert(pool2.contains(testObj.GUID.guid))
       }
@@ -77,7 +77,7 @@ class UniqueNumberSystemTest1 extends ActorTest(ActorSystem("test")) {
       for(_  <- 1 to 100) {
         val testObj = new EntityTestClass()
         uns ! Register(testObj, "pool3")
-        val msg = receiveOne(Duration.create(100, "ms"))
+        val msg = receiveOne(Duration.create(500, "ms"))
         assert(msg.isInstanceOf[Success[_]])
         assert(pool3.contains(testObj.GUID.guid))
       }
@@ -86,7 +86,7 @@ class UniqueNumberSystemTest1 extends ActorTest(ActorSystem("test")) {
   }
 }
 
-class UniqueNumberSystemTest2 extends ActorTest(ActorSystem("test")) {
+class UniqueNumberSystemTest2 extends ActorTest() {
   class EntityTestClass extends IdentifiableEntity
 
   "UniqueNumberSystem" should {
@@ -102,14 +102,14 @@ class UniqueNumberSystemTest2 extends ActorTest(ActorSystem("test")) {
       assert(src.CountUsed == 0)
 
       uns ! Register(testObj, "pool1")
-      val msg1 = receiveOne(Duration.create(100, "ms"))
+      val msg1 = receiveOne(Duration.create(500, "ms"))
       assert(msg1.isInstanceOf[Success[_]])
       assert(testObj.HasGUID)
       assert(src.CountUsed == 1)
 
       val id = testObj.GUID.guid
       uns ! Register(testObj, "pool2") //different pool; makes no difference
-      val msg2 = receiveOne(Duration.create(100, "ms"))
+      val msg2 = receiveOne(Duration.create(500, "ms"))
       assert(msg2.isInstanceOf[Success[_]])
       assert(testObj.HasGUID)
       assert(src.CountUsed == 1)
@@ -119,7 +119,7 @@ class UniqueNumberSystemTest2 extends ActorTest(ActorSystem("test")) {
   //a log.warn should have been generated during this test
 }
 
-class UniqueNumberSystemTest3 extends ActorTest(ActorSystem("test")) {
+class UniqueNumberSystemTest3 extends ActorTest() {
   class EntityTestClass extends IdentifiableEntity
 
   "UniqueNumberSystem" should {
@@ -135,7 +135,7 @@ class UniqueNumberSystemTest3 extends ActorTest(ActorSystem("test")) {
       assert(src.CountUsed == 0)
 
       uns ! Register(testObj, "pool4")
-      val msg1 = receiveOne(Duration.create(100, "ms"))
+      val msg1 = receiveOne(Duration.create(500, "ms"))
       assert(msg1.isInstanceOf[Failure[_]])
       assert(!testObj.HasGUID)
       assert(src.CountUsed == 0)
@@ -143,7 +143,7 @@ class UniqueNumberSystemTest3 extends ActorTest(ActorSystem("test")) {
   }
 }
 
-class UniqueNumberSystemTest4 extends ActorTest(ActorSystem("test")) {
+class UniqueNumberSystemTest4 extends ActorTest() {
   class EntityTestClass extends IdentifiableEntity
 
   "UniqueNumberSystem" should {
@@ -158,18 +158,18 @@ class UniqueNumberSystemTest4 extends ActorTest(ActorSystem("test")) {
 
       val testObj1 = new EntityTestClass()
       uns ! Register(testObj1, "pool4")
-      val msg1 = receiveOne(Duration.create(100, "ms"))
+      val msg1 = receiveOne(Duration.create(500, "ms"))
       assert(msg1.isInstanceOf[Success[_]]) //pool4 is now empty
 
       val testObj2 = new EntityTestClass()
       uns ! Register(testObj2, "pool4")
-      val msg2 = receiveOne(Duration.create(100, "ms"))
+      val msg2 = receiveOne(Duration.create(500, "ms"))
       assert(msg2.isInstanceOf[Failure[_]])
     }
   }
 }
 
-class UniqueNumberSystemTest5 extends ActorTest(ActorSystem("test")) {
+class UniqueNumberSystemTest5 extends ActorTest() {
   class EntityTestClass extends IdentifiableEntity
 
   "UniqueNumberSystem" should {
@@ -186,14 +186,14 @@ class UniqueNumberSystemTest5 extends ActorTest(ActorSystem("test")) {
       assert(src.CountUsed == 0)
 
       uns ! Register(testObj, "pool2")
-      val msg1 = receiveOne(Duration.create(100, "ms"))
+      val msg1 = receiveOne(Duration.create(500, "ms"))
       assert(msg1.isInstanceOf[Success[_]])
       assert(testObj.HasGUID)
       assert(pool2.contains(testObj.GUID.guid))
       assert(src.CountUsed == 1)
 
       uns ! Unregister(testObj)
-      val msg2 = receiveOne(Duration.create(100, "ms"))
+      val msg2 = receiveOne(Duration.create(500, "ms"))
       assert(msg2.isInstanceOf[Success[_]])
       assert(!testObj.HasGUID)
       assert(src.CountUsed == 0)
@@ -201,7 +201,7 @@ class UniqueNumberSystemTest5 extends ActorTest(ActorSystem("test")) {
   }
 }
 
-class UniqueNumberSystemTest6 extends ActorTest(ActorSystem("test")) {
+class UniqueNumberSystemTest6 extends ActorTest() {
   class EntityTestClass extends IdentifiableEntity
 
   "UniqueNumberSystem" should {
@@ -217,7 +217,7 @@ class UniqueNumberSystemTest6 extends ActorTest(ActorSystem("test")) {
       assert(src.CountUsed == 0)
 
       uns ! Unregister(testObj)
-      val msg1 = receiveOne(Duration.create(100, "ms"))
+      val msg1 = receiveOne(Duration.create(500, "ms"))
       assert(msg1.isInstanceOf[Success[_]])
       assert(!testObj.HasGUID)
       assert(src.CountUsed == 0)
@@ -225,7 +225,7 @@ class UniqueNumberSystemTest6 extends ActorTest(ActorSystem("test")) {
   }
 }
 
-class UniqueNumberSystemTest7 extends ActorTest(ActorSystem("test")) {
+class UniqueNumberSystemTest7 extends ActorTest() {
   class EntityTestClass extends IdentifiableEntity
 
   "UniqueNumberSystem" should {
@@ -242,7 +242,7 @@ class UniqueNumberSystemTest7 extends ActorTest(ActorSystem("test")) {
       assert(src.CountUsed == 0)
 
       uns ! Unregister(testObj)
-      val msg1 = receiveOne(Duration.create(100, "ms"))
+      val msg1 = receiveOne(Duration.create(500, "ms"))
       assert(msg1.isInstanceOf[Failure[_]])
       assert(testObj.HasGUID)
       assert(src.CountUsed == 0)
@@ -250,7 +250,7 @@ class UniqueNumberSystemTest7 extends ActorTest(ActorSystem("test")) {
   }
 }
 
-class UniqueNumberSystemTest8 extends ActorTest(ActorSystem("test")) {
+class UniqueNumberSystemTest8 extends ActorTest() {
   class EntityTestClass extends IdentifiableEntity
 
   "UniqueNumberSystem" should {
@@ -267,7 +267,7 @@ class UniqueNumberSystemTest8 extends ActorTest(ActorSystem("test")) {
       assert(src.CountUsed == 0)
 
       uns ! Unregister(testObj)
-      val msg1 = receiveOne(Duration.create(100, "ms"))
+      val msg1 = receiveOne(Duration.create(500, "ms"))
       assert(msg1.isInstanceOf[Failure[_]])
       assert(testObj.HasGUID)
       assert(src.CountUsed == 0)
@@ -285,4 +285,3 @@ object UniqueNumberSystemTest {
     }).toMap
   }
 }
-

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

@@ -0,0 +1,47 @@
+// Copyright (c) 2017 PSForever
+package objects.terminal
+
+import akka.actor.ActorRef
+import net.psforever.objects.serverobject.terminals.Terminal
+import net.psforever.objects.{GlobalDefinitions, Player}
+import net.psforever.packet.game.{ItemTransactionMessage, PlanetSideGUID}
+import net.psforever.types._
+import org.specs2.mutable.Specification
+
+class CertTerminalTest extends Specification {
+  "Cert_Terminal" should {
+    val player = Player("test", PlanetSideEmpire.TR, CharacterGender.Male, 0, 0)
+
+    "construct" in {
+      val terminal = Terminal(GlobalDefinitions.cert_terminal)
+      terminal.Actor mustEqual ActorRef.noSender
+    }
+
+    "player can learn a certification ('medium_assault')" in {
+      val terminal = Terminal(GlobalDefinitions.cert_terminal)
+      val msg = ItemTransactionMessage(PlanetSideGUID(1), TransactionType.Learn, 0, "medium_assault", 0, PlanetSideGUID(0))
+      terminal.Request(player, msg) mustEqual Terminal.LearnCertification(CertificationType.MediumAssault, 2)
+    }
+
+    "player can not learn a fake certification ('juggling')" in {
+      val terminal = Terminal(GlobalDefinitions.cert_terminal)
+      val msg = ItemTransactionMessage(PlanetSideGUID(1), TransactionType.Learn, 0, "juggling", 0, PlanetSideGUID(0))
+
+      terminal.Request(player, msg) mustEqual Terminal.NoDeal()
+    }
+
+    "player can forget a certification ('medium_assault')" in {
+      val terminal = Terminal(GlobalDefinitions.cert_terminal)
+      val msg = ItemTransactionMessage(PlanetSideGUID(1), TransactionType.Sell, 0, "medium_assault", 0, PlanetSideGUID(0))
+
+      terminal.Request(player, msg) mustEqual Terminal.SellCertification(CertificationType.MediumAssault, 2)
+    }
+
+    "player can not forget a fake certification ('juggling')" in {
+      val terminal = Terminal(GlobalDefinitions.cert_terminal)
+      val msg = ItemTransactionMessage(PlanetSideGUID(1), TransactionType.Sell, 0, "juggling", 0, PlanetSideGUID(0))
+
+      terminal.Request(player, msg) mustEqual Terminal.NoDeal()
+    }
+  }
+}

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

@@ -0,0 +1,85 @@
+// Copyright (c) 2017 PSForever
+package objects.terminal
+
+import akka.actor.ActorRef
+import net.psforever.objects.serverobject.terminals.Terminal
+import net.psforever.objects.{AmmoBox, GlobalDefinitions, Player, Tool}
+import net.psforever.packet.game.{ItemTransactionMessage, PlanetSideGUID}
+import net.psforever.types._
+import org.specs2.mutable.Specification
+
+class OrderTerminalTest extends Specification {
+  "Order_Terminal" should {
+    val player = Player("test", PlanetSideEmpire.TR, CharacterGender.Male, 0, 0)
+
+    "construct" in {
+      val terminal = Terminal(GlobalDefinitions.order_terminal)
+      terminal.Actor mustEqual ActorRef.noSender
+    }
+
+    "player can buy a box of ammunition ('9mmbullet_AP')" in {
+      val terminal = Terminal(GlobalDefinitions.order_terminal)
+      val msg = ItemTransactionMessage(PlanetSideGUID(1), TransactionType.Buy, 0, "9mmbullet_AP", 0, PlanetSideGUID(0))
+      val reply = terminal.Request(player, msg)
+      reply.isInstanceOf[Terminal.BuyEquipment] mustEqual true
+      val reply2 = reply.asInstanceOf[Terminal.BuyEquipment]
+      reply2.item.isInstanceOf[AmmoBox] mustEqual true
+      reply2.item.asInstanceOf[AmmoBox].Definition mustEqual GlobalDefinitions.bullet_9mm_AP
+      reply2.item.asInstanceOf[AmmoBox].Capacity mustEqual 50
+    }
+
+    "player can buy a weapon ('suppressor')" in {
+      val terminal = Terminal(GlobalDefinitions.order_terminal)
+      val msg = ItemTransactionMessage(PlanetSideGUID(1), TransactionType.Buy, 0, "suppressor", 0, PlanetSideGUID(0))
+      val reply = terminal.Request(player, msg)
+      reply.isInstanceOf[Terminal.BuyEquipment] mustEqual true
+      val reply2 = reply.asInstanceOf[Terminal.BuyEquipment]
+      reply2.item.isInstanceOf[Tool] mustEqual true
+      reply2.item.asInstanceOf[Tool].Definition mustEqual GlobalDefinitions.suppressor
+    }
+
+    "player can buy a box of vehicle ammunition ('105mmbullet')" in {
+      val terminal = Terminal(GlobalDefinitions.order_terminal)
+      val msg = ItemTransactionMessage(PlanetSideGUID(1), TransactionType.Buy, 3, "105mmbullet", 0, PlanetSideGUID(0))
+      val reply = terminal.Request(player, msg)
+      reply.isInstanceOf[Terminal.BuyEquipment] mustEqual true
+      val reply2 = reply.asInstanceOf[Terminal.BuyEquipment]
+      reply2.item.isInstanceOf[AmmoBox] mustEqual true
+      reply2.item.asInstanceOf[AmmoBox].Definition mustEqual GlobalDefinitions.bullet_105mm
+      reply2.item.asInstanceOf[AmmoBox].Capacity mustEqual 100
+    }
+
+    "player can buy a support tool ('bank')" in {
+      val terminal = Terminal(GlobalDefinitions.order_terminal)
+      val msg = ItemTransactionMessage(PlanetSideGUID(1), TransactionType.Buy, 2, "bank", 0, PlanetSideGUID(0))
+      val reply = terminal.Request(player, msg)
+      reply.isInstanceOf[Terminal.BuyEquipment] mustEqual true
+      val reply2 = reply.asInstanceOf[Terminal.BuyEquipment]
+      reply2.item.isInstanceOf[Tool] mustEqual true
+      reply2.item.asInstanceOf[Tool].Definition mustEqual GlobalDefinitions.bank
+    }
+
+    "player can buy different armor ('lite_armor')" in {
+      val terminal = Terminal(GlobalDefinitions.order_terminal)
+      val msg = ItemTransactionMessage(PlanetSideGUID(1), TransactionType.Buy, 1, "lite_armor", 0, PlanetSideGUID(0))
+
+      terminal.Request(player, msg) mustEqual Terminal.BuyExosuit(ExoSuitType.Agile)
+    }
+
+    "player can not buy fake equipment ('sabot')" in {
+      val terminal = Terminal(GlobalDefinitions.order_terminal)
+      val msg = ItemTransactionMessage(PlanetSideGUID(1), TransactionType.Buy, 0, "sabot", 0, PlanetSideGUID(0))
+
+      terminal.Request(player, msg) mustEqual Terminal.NoDeal()
+    }
+
+    //TODO loudout tests
+
+    "player can not buy equipment from the wrong page ('9mmbullet_AP', page 1)" in {
+      val terminal = Terminal(GlobalDefinitions.order_terminal)
+      val msg = ItemTransactionMessage(PlanetSideGUID(1), TransactionType.Buy, 1, "9mmbullet_AP", 0, PlanetSideGUID(0))
+
+      terminal.Request(player, msg) mustEqual Terminal.NoDeal()
+    }
+  }
+}

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

@@ -0,0 +1,73 @@
+// Copyright (c) 2017 PSForever
+package objects.terminal
+
+import akka.actor.Props
+import net.psforever.objects.serverobject.terminals.{Terminal, TerminalControl}
+import net.psforever.objects.{GlobalDefinitions, Player}
+import net.psforever.packet.game.{ItemTransactionMessage, PlanetSideGUID}
+import net.psforever.types._
+import objects.ActorTest
+
+import scala.concurrent.duration.Duration
+
+class TerminalControlTest extends ActorTest() {
+  "TerminalControl" should {
+    "construct (cert terminal)" in {
+      val terminal = Terminal(GlobalDefinitions.cert_terminal)
+      terminal.Actor = system.actorOf(Props(classOf[TerminalControl], terminal), "test-cert-term")
+    }
+  }
+}
+
+//terminal control is mostly a pass-through actor for Terminal.Exchange messages, wrapped in Terminal.TerminalMessage protocol
+//test for Cert_Terminal messages (see CertTerminalTest)
+class CertTerminalControl1Test extends ActorTest() {
+  "TerminalControl can be used to learn a certification ('medium_assault')" in {
+    val terminal = Terminal(GlobalDefinitions.cert_terminal)
+    terminal.Actor = system.actorOf(Props(classOf[TerminalControl], terminal), "test-cert-term")
+    val player = Player("test", PlanetSideEmpire.TR, CharacterGender.Male, 0, 0)
+    val msg = ItemTransactionMessage(PlanetSideGUID(1), TransactionType.Learn, 0, "medium_assault", 0, PlanetSideGUID(0))
+
+    terminal.Actor ! Terminal.Request(player, msg)
+    val reply = receiveOne(Duration.create(500, "ms"))
+    assert(reply.isInstanceOf[Terminal.TerminalMessage])
+    val reply2 = reply.asInstanceOf[Terminal.TerminalMessage]
+    assert(reply2.player == player)
+    assert(reply2.msg == msg)
+    assert(reply2.response == Terminal.LearnCertification(CertificationType.MediumAssault, 2))
+  }
+}
+
+class CertTerminalControl2Test extends ActorTest() {
+  "TerminalControl can be used to warn about not learning a fake certification ('juggling')" in {
+    val terminal = Terminal(GlobalDefinitions.cert_terminal)
+    terminal.Actor = system.actorOf(Props(classOf[TerminalControl], terminal), "test-cert-term")
+    val player = Player("test", PlanetSideEmpire.TR, CharacterGender.Male, 0, 0)
+    val msg = ItemTransactionMessage(PlanetSideGUID(1), TransactionType.Learn, 0, "juggling", 0, PlanetSideGUID(0))
+
+    terminal.Actor ! Terminal.Request(player, msg)
+    val reply = receiveOne(Duration.create(500, "ms"))
+    assert(reply.isInstanceOf[Terminal.TerminalMessage])
+    val reply2 = reply.asInstanceOf[Terminal.TerminalMessage]
+    assert(reply2.player == player)
+    assert(reply2.msg == msg)
+    assert(reply2.response == Terminal.NoDeal())
+  }
+}
+
+class CertTerminalControl3Test extends ActorTest() {
+  "TerminalControl can be used to forget a certification ('medium_assault')" in {
+    val terminal = Terminal(GlobalDefinitions.cert_terminal)
+    terminal.Actor = system.actorOf(Props(classOf[TerminalControl], terminal), "test-cert-term")
+    val player = Player("test", PlanetSideEmpire.TR, CharacterGender.Male, 0, 0)
+    val msg = ItemTransactionMessage(PlanetSideGUID(1), TransactionType.Sell, 0, "medium_assault", 0, PlanetSideGUID(0))
+
+    terminal.Actor ! Terminal.Request(player, msg)
+    val reply = receiveOne(Duration.create(500, "ms"))
+    assert(reply.isInstanceOf[Terminal.TerminalMessage])
+    val reply2 = reply.asInstanceOf[Terminal.TerminalMessage]
+    assert(reply2.player == player)
+    assert(reply2.msg == msg)
+    assert(reply2.response == Terminal.SellCertification(CertificationType.MediumAssault, 2))
+  }
+}

pslogin/src/main/scala/WorldSessionActor.scala

@@ -12,7 +12,7 @@ import MDCContextAware.Implicits._
 import services.ServiceManager.Lookup
 import net.psforever.objects._
 import net.psforever.objects.equipment._
-import net.psforever.objects.guid.{Task, TaskResolver}
+import net.psforever.objects.guid.{GUIDTask, Task, TaskResolver}
 import net.psforever.objects.inventory.{GridInventory, InventoryItem}
 import net.psforever.objects.serverobject.{CommonMessages, PlanetSideServerObject}
 import net.psforever.objects.serverobject.doors.Door
@@ -22,7 +22,6 @@ import net.psforever.objects.vehicles.{AccessPermissionGroup, Seat, VehicleLockS
 import net.psforever.objects.zones.{InterstellarCluster, Zone}
 import net.psforever.packet.game.objectcreate._
 import net.psforever.types._
-import scripts.GUIDTask
 import services._
 import services.avatar._
 import services.local._
@@ -552,7 +551,7 @@ class WorldSessionActor extends Actor with MDCContextAware {
                   val box = item.obj.asInstanceOf[AmmoBox]
                   sendResponse(PacketCoding.CreateGamePacket(0, InventoryStateMessage(box.GUID, 0, vehicle_guid, box.Capacity.toLong)))
                 })
-            case None => ; //no weapons to update
+            case _ => ; //no weapons to update
           }
           val player_guid : PlanetSideGUID = tplayer.GUID
           sendResponse(PacketCoding.CreateGamePacket(0, ObjectAttachMessage(vehicle_guid, player_guid, seat_num)))

pslogin/src/main/scala/services/vehicle/VehicleServiceResponse.scala

@@ -8,4 +8,3 @@ final case class VehicleServiceResponse(toChannel : String,
                                         avatar_guid : PlanetSideGUID,
                                         replyMessage : VehicleResponse.Response
                                        ) extends GenericEventBusMsg
-

pslogin/src/main/scala/services/vehicle/support/DeconstructionActor.scala

@@ -3,10 +3,10 @@ package services.vehicle.support
 
 import akka.actor.{Actor, ActorRef, Cancellable}
 import net.psforever.objects.Vehicle
+import net.psforever.objects.guid.GUIDTask
 import net.psforever.objects.vehicles.Seat
 import net.psforever.objects.zones.Zone
 import net.psforever.packet.game.PlanetSideGUID
-import scripts.GUIDTask
 import services.ServiceManager
 import services.ServiceManager.Lookup
 import services.vehicle.{VehicleAction, VehicleServiceMessage}