Facility Turrets (#223)

* object class, actor class, and definitions for base turrets; untested

* wired base turrets into existence, with hoop jumping; created interface for objects with mounted weapons (vehicles and turrets); working example phalanx_sgl_hevgatcan in Anguta, Ceryshen

* re-wiring manned turrets so that the turreted weapon itself never changes externally but merely identifies different and changes internally; workflow for upgrading wall turrets in place (30s); clarifications and documentation for HackMessage and UseItemMessage; getting rid of orphaned packages from previous location of services

* added a simple task that reverts upgraded manned turrets to their None state after a certain amount of time has passed; it works but need improvement

* turret weapon upgrades now last for a duration of 30 minutes before reverting; created a service support actor base actor that underlies all current support actors; nano-dispenser now properly loads 1 unit of upgrade canister, rather than 100 units; all canister types have appropriate 2x3 inventory size

* forgot to hurry; moved over the Services tests from main/test folder into the common/test folder and needed to change the location of ActorTest to accommodate it; test and documentation for MannedTurret; codecov ignore update

* wired facility turrets in Anguta, Ceryshen; Akna tower, Ceryshen; and S.Villa tower, home3 (Anguta tower is a watchtower); attempted workaround for Travis CI issues with receiveN; re-introduced RemoveActorTest, at least the first test; expanded how ZoneActor performs tests on MannedTurret setup

* getting rid of useless commented-out code; making common operations for mounting and dismounting

* removed outdated comment; added ResourceSilo tests; added extra test for Zone

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

@@ -1,25 +0,0 @@
-// Copyright (c) 2017 PSForever
-package objects
-
-import akka.actor.ActorSystem
-import akka.testkit.{ImplicitSender, TestKit}
-import com.typesafe.config.{ConfigFactory, ConfigValueFactory}
-import org.scalatest.{BeforeAndAfterAll, Matchers, WordSpecLike}
-import org.specs2.specification.Scope
-
-abstract class ActorTest(sys : ActorSystem = ActorSystem("system", ConfigFactory.parseMap(ActorTest.LoggingConfig)))
-  extends TestKit(sys) with Scope with ImplicitSender with WordSpecLike with Matchers with BeforeAndAfterAll {
-  override def afterAll {
-    TestKit.shutdownActorSystem(system)
-  }
-}
-
-object ActorTest {
-  import scala.collection.JavaConverters._
-  private val LoggingConfig = Map(
-    "akka.loggers" -> List("akka.testkit.TestEventListener").asJava,
-    "akka.loglevel" -> "OFF",
-    "akka.stdout-loglevel" -> "OFF",
-    "akka.log-dead-letters" -> "OFF"
-  ).asJava
-}

common/src/test/scala/objects/AutoDriveControlsTest.scala

@@ -3,6 +3,7 @@ package objects
 
 import akka.actor.Props
 import akka.testkit.TestProbe
+import base.ActorTest
 import net.psforever.objects.serverobject.pad.{VehicleSpawnControl, VehicleSpawnPad}
 import net.psforever.objects.{Avatar, GlobalDefinitions, Player, Vehicle}
 import net.psforever.objects.serverobject.pad.process.{AutoDriveControls, VehicleSpawnControlGuided}

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

@@ -2,6 +2,7 @@
 package objects
 
 import akka.actor.{ActorRef, Props}
+import base.ActorTest
 import net.psforever.objects.GlobalDefinitions
 import net.psforever.objects.definition.ObjectDefinition
 import net.psforever.objects.serverobject.affinity.FactionAffinity
@@ -128,12 +129,11 @@ class BuildingControl2Test extends ActorTest {
   val bldg = Building(10, Zone.Nowhere, StructureType.Building)
   bldg.Faction = PlanetSideEmpire.TR
   bldg.Actor = system.actorOf(Props(classOf[BuildingControl], bldg), "test")
+  bldg.Actor ! "startup"
 
   "Building Control" should {
     "convert and assert faction affinity on convert request" in {
-      expectNoMsg(250 milliseconds)
-      bldg.Actor ! "startup"
-      expectNoMsg(250 milliseconds)
+      expectNoMsg(500 milliseconds)
 
       assert(bldg.Faction == PlanetSideEmpire.TR)
       bldg.Actor ! FactionAffinity.ConvertFactionAffinity(PlanetSideEmpire.VS)
@@ -159,12 +159,11 @@ class BuildingControl3Test extends ActorTest {
   door2.Actor = system.actorOf(Props(classOf[DoorControl], door2), "door2-test")
   bldg.Amenities = door2
   bldg.Amenities = door1
+  bldg.Actor ! "startup"
 
   "Building Control" should {
     "convert and assert faction affinity on convert request, and for each of its amenities" in {
-      expectNoMsg(250 milliseconds)
-      bldg.Actor ! "startup"
-      expectNoMsg(250 milliseconds)
+      expectNoMsg(500 milliseconds)
 
       assert(bldg.Faction == PlanetSideEmpire.TR)
       assert(bldg.Amenities.length == 2)
@@ -172,7 +171,8 @@ class BuildingControl3Test extends ActorTest {
       assert(bldg.Amenities(1) == door1)
 
       bldg.Actor ! FactionAffinity.ConvertFactionAffinity(PlanetSideEmpire.VS)
-      val reply = receiveN(3, Duration.create(500, "ms"))
+      val reply = ActorTest.receiveMultiple(3, 500 milliseconds, this)
+      //val reply = receiveN(3, Duration.create(5000, "ms"))
       assert(reply.length == 3)
       var building_count = 0
       var door_count = 0

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

@@ -2,6 +2,7 @@
 package objects
 
 import akka.actor.{Actor, ActorSystem, Props}
+import base.ActorTest
 import net.psforever.objects.serverobject.PlanetSideServerObject
 import net.psforever.objects.{GlobalDefinitions, Vehicle}
 import net.psforever.objects.serverobject.deploy.{Deployment, DeploymentBehavior}

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

@@ -2,6 +2,7 @@
 package objects
 
 import akka.actor.{ActorRef, ActorSystem, Props}
+import base.ActorTest
 import net.psforever.objects.{Avatar, GlobalDefinitions, Player}
 import net.psforever.objects.serverobject.doors.{Door, DoorControl}
 import net.psforever.objects.serverobject.structures.{Building, StructureType}
@@ -42,7 +43,7 @@ class DoorTest extends Specification {
     }
 
     "be opened and closed (2; toggle)" in {
-      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 msg = UseItemMessage(PlanetSideGUID(6585), PlanetSideGUID(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 None
       door.Use(player, msg)
@@ -74,7 +75,7 @@ class DoorTest extends Specification {
   }
 }
 
-class DoorControl1Test extends ActorTest() {
+class DoorControl1Test extends ActorTest {
   "DoorControl" should {
     "construct" in {
       val door = Door(GlobalDefinitions.door)
@@ -84,11 +85,11 @@ class DoorControl1Test extends ActorTest() {
   }
 }
 
-class DoorControl2Test extends ActorTest() {
+class DoorControl2Test extends ActorTest {
   "DoorControl" should {
     "open on use" in {
       val (player, door) = DoorControlTest.SetUpAgents(PlanetSideEmpire.TR)
-      val msg = UseItemMessage(PlanetSideGUID(1), 0, PlanetSideGUID(2), 0L, false, Vector3(0f,0f,0f),Vector3(0f,0f,0f),0,0,0,0L) //faked
+      val msg = UseItemMessage(PlanetSideGUID(1), PlanetSideGUID(0), PlanetSideGUID(2), 0L, false, Vector3(0f,0f,0f),Vector3(0f,0f,0f),0,0,0,0L) //faked
       assert(door.Open.isEmpty)
 
       door.Actor ! Door.Use(player, msg)
@@ -103,7 +104,7 @@ class DoorControl2Test extends ActorTest() {
   }
 }
 
-class DoorControl3Test extends ActorTest() {
+class DoorControl3Test extends ActorTest {
   "DoorControl" should {
     "do nothing if given garbage" in {
       val (_, door) = DoorControlTest.SetUpAgents(PlanetSideEmpire.TR)

common/src/test/scala/objects/FactionAffinityTest.scala

@@ -2,6 +2,7 @@
 package objects
 
 import akka.actor.{Actor, ActorSystem, Props}
+import base.ActorTest
 import net.psforever.objects.{GlobalDefinitions, Vehicle}
 import net.psforever.objects.serverobject.affinity.FactionAffinity
 import net.psforever.objects.serverobject.doors.Door
@@ -55,7 +56,7 @@ class FactionAffinityTest extends Specification {
   }
 }
 
-class FactionAffinity1Test extends ActorTest() {
+class FactionAffinity1Test extends ActorTest {
   "FactionAffinity" should {
     "assert affinity on confirm request" in {
       val obj = FactionAffinityTest.SetUpAgent
@@ -71,7 +72,7 @@ class FactionAffinity1Test extends ActorTest() {
   }
 }
 
-class FactionAffinity2Test extends ActorTest() {
+class FactionAffinity2Test extends ActorTest {
   "FactionAffinity" should {
     "assert affinity on assert request" in {
       val obj = FactionAffinityTest.SetUpAgent
@@ -87,7 +88,7 @@ class FactionAffinity2Test extends ActorTest() {
   }
 }
 
-class FactionAffinity3Test extends ActorTest() {
+class FactionAffinity3Test extends ActorTest {
   "FactionAffinity" should {
     "convert and assert affinity on convert request" in {
       val obj = FactionAffinityTest.SetUpAgent

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

@@ -2,6 +2,7 @@
 package objects
 
 import akka.actor.{ActorRef, ActorSystem, Props}
+import base.ActorTest
 import net.psforever.objects.serverobject.CommonMessages
 import net.psforever.objects.{Avatar, GlobalDefinitions, Player}
 import net.psforever.objects.serverobject.locks.{IFFLock, IFFLockControl}
@@ -22,7 +23,7 @@ class IFFLockTest extends Specification {
   }
 }
 
-class IFFLockControl1Test extends ActorTest() {
+class IFFLockControl1Test extends ActorTest {
   "IFFLockControl" should {
     "construct" in {
       val lock = IFFLock(GlobalDefinitions.lock_external)
@@ -32,7 +33,7 @@ class IFFLockControl1Test extends ActorTest() {
   }
 }
 
-class IFFLockControl2Test extends ActorTest() {
+class IFFLockControl2Test extends ActorTest {
   "IFFLockControl" should {
     "can hack" in {
       val (player, lock) = IFFLockControlTest.SetUpAgents(PlanetSideEmpire.TR)
@@ -46,7 +47,7 @@ class IFFLockControl2Test extends ActorTest() {
   }
 }
 
-class IFFLockControl3Test extends ActorTest() {
+class IFFLockControl3Test extends ActorTest {
   "IFFLockControl" should {
     "can hack" in {
       val (player, lock) = IFFLockControlTest.SetUpAgents(PlanetSideEmpire.TR)

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

@@ -2,6 +2,7 @@
 package objects
 
 import akka.actor.{ActorRef, Props}
+import base.ActorTest
 import net.psforever.objects.GlobalDefinitions
 import net.psforever.objects.serverobject.affinity.FactionAffinity
 import net.psforever.objects.serverobject.mblocker.{Locker, LockerControl}

common/src/test/scala/objects/MannedTurretTest.scala

@@ -0,0 +1,179 @@
+// Copyright (c) 2017 PSForever
+package objects
+
+import akka.actor.{ActorRef, Props}
+import base.ActorTest
+import net.psforever.objects.{Avatar, GlobalDefinitions, Player, Tool}
+import net.psforever.objects.definition.ToolDefinition
+import net.psforever.objects.serverobject.mount.Mountable
+import net.psforever.objects.serverobject.structures.{Building, StructureType}
+import net.psforever.objects.serverobject.turret.{MannedTurret, MannedTurretControl, MannedTurretDefinition, TurretUpgrade}
+import net.psforever.objects.zones.Zone
+import net.psforever.packet.game.PlanetSideGUID
+import net.psforever.types.{CharacterGender, CharacterVoice, PlanetSideEmpire}
+import org.specs2.mutable.Specification
+
+import scala.collection.mutable
+import scala.concurrent.duration._
+
+class MannedTurretTest extends Specification {
+  "MannedTurretTest" should {
+    "define" in {
+      val obj = new MannedTurretDefinition(480)
+      obj.Weapons mustEqual mutable.HashMap.empty[TurretUpgrade.Value, ToolDefinition]
+      obj.ReserveAmmunition mustEqual false
+      obj.FactionLocked mustEqual true
+      obj.MaxHealth mustEqual 100
+      obj.MountPoints mustEqual mutable.HashMap.empty[Int,Int]
+    }
+
+    "construct" in {
+      val obj = MannedTurret(GlobalDefinitions.manned_turret)
+      obj.Weapons.size mustEqual 1
+      obj.Weapons(1).Equipment match {
+        case Some(tool : Tool) =>
+          tool.Definition mustEqual GlobalDefinitions.phalanx_sgl_hevgatcan
+        case _ =>
+          ko
+      }
+      obj.Seats.size mustEqual 1
+      obj.Seats(0).ControlledWeapon mustEqual Some(1)
+      obj.MountPoints.size mustEqual 1
+      obj.MountPoints(1) mustEqual 0
+      obj.Health mustEqual 3600
+      obj.Upgrade mustEqual TurretUpgrade.None
+      obj.Jammered mustEqual false
+
+      obj.Health = 360
+      obj.Health mustEqual 360
+      obj.Jammered = true
+      obj.Jammered mustEqual true
+    }
+
+    "upgrade to a different weapon" in {
+      val obj = MannedTurret(GlobalDefinitions.manned_turret)
+      obj.Upgrade = TurretUpgrade.None
+      obj.Weapons(1).Equipment match {
+        case Some(tool : Tool) =>
+          tool.Definition mustEqual GlobalDefinitions.phalanx_sgl_hevgatcan
+          tool.FireModeIndex mustEqual 0
+          tool.NextFireMode
+          tool.FireModeIndex mustEqual 0 //one fire mode
+        case _ =>
+          ko
+      }
+      //upgrade
+      obj.Upgrade = TurretUpgrade.AVCombo
+      obj.Weapons(1).Equipment match {
+        case Some(tool : Tool) =>
+          tool.Definition mustEqual GlobalDefinitions.phalanx_avcombo
+          tool.FireModeIndex mustEqual 0
+          tool.ProjectileType mustEqual GlobalDefinitions.phalanx_projectile.ProjectileType
+          tool.NextFireMode
+          tool.FireModeIndex mustEqual 1
+          tool.ProjectileType mustEqual GlobalDefinitions.phalanx_av_projectile.ProjectileType
+        case _ =>
+          ko
+      }
+      //revert
+      obj.Upgrade = TurretUpgrade.None
+      obj.Weapons(1).Equipment match {
+        case Some(tool : Tool) =>
+          tool.Definition mustEqual GlobalDefinitions.phalanx_sgl_hevgatcan
+        case _ =>
+          ko
+      }
+    }
+  }
+}
+
+class MannedTurretControl1Test extends ActorTest {
+  "MannedTurretControl" should {
+    "construct" in {
+      val obj = MannedTurret(GlobalDefinitions.manned_turret)
+      obj.Actor = system.actorOf(Props(classOf[MannedTurretControl], obj), "turret-control")
+      assert(obj.Actor != ActorRef.noSender)
+    }
+  }
+}
+
+class MannedTurretControl2Test extends ActorTest {
+  val player = Player(Avatar("", PlanetSideEmpire.TR, CharacterGender.Male, 0, CharacterVoice.Mute))
+  val obj = MannedTurret(GlobalDefinitions.manned_turret)
+  obj.GUID = PlanetSideGUID(1)
+  obj.Actor = system.actorOf(Props(classOf[MannedTurretControl], obj), "turret-control")
+  val bldg = Building(0, Zone.Nowhere, StructureType.Building)
+  bldg.Amenities = obj
+  bldg.Faction = PlanetSideEmpire.TR
+
+  "MannedTurretControl" should {
+    "seat on faction affiliation when FactionLock is true" in {
+      assert(player.Faction == PlanetSideEmpire.TR)
+      assert(obj.Faction == PlanetSideEmpire.TR)
+      assert(obj.Definition.FactionLocked)
+
+      obj.Actor ! Mountable.TryMount(player, 0)
+      val reply = receiveOne(300 milliseconds)
+      reply match {
+        case msg : Mountable.MountMessages =>
+          assert(msg.response.isInstanceOf[Mountable.CanMount])
+        case _ =>
+          assert(false)
+      }
+    }
+  }
+}
+
+class MannedTurretControl3Test extends ActorTest {
+  val player = Player(Avatar("", PlanetSideEmpire.TR, CharacterGender.Male, 0, CharacterVoice.Mute))
+  val obj = MannedTurret(GlobalDefinitions.manned_turret)
+  obj.GUID = PlanetSideGUID(1)
+  obj.Actor = system.actorOf(Props(classOf[MannedTurretControl], obj), "turret-control")
+  val bldg = Building(0, Zone.Nowhere, StructureType.Building)
+  bldg.Amenities = obj
+
+  "MannedTurretControl" should {
+    "block seating on mismatched faction affiliation when FactionLock is true" in {
+      assert(player.Faction == PlanetSideEmpire.TR)
+      assert(obj.Faction == PlanetSideEmpire.NEUTRAL)
+      assert(obj.Definition.FactionLocked)
+
+      obj.Actor ! Mountable.TryMount(player, 0)
+      val reply = receiveOne(300 milliseconds)
+      reply match {
+        case msg : Mountable.MountMessages =>
+          assert(msg.response.isInstanceOf[Mountable.CanNotMount])
+        case _ =>
+          assert(false)
+      }
+    }
+  }
+}
+
+class MannedTurretControl4Test extends ActorTest {
+  val player = Player(Avatar("", PlanetSideEmpire.TR, CharacterGender.Male, 0, CharacterVoice.Mute))
+  val objDef = new MannedTurretDefinition(480)
+  objDef.FactionLocked = false
+  val obj = MannedTurret(objDef)
+  obj.GUID = PlanetSideGUID(1)
+  obj.Actor = system.actorOf(Props(classOf[MannedTurretControl], obj), "turret-control")
+  val bldg = Building(0, Zone.Nowhere, StructureType.Building)
+  bldg.Amenities = obj
+
+  "MannedTurretControl" should {
+    "seating even with mismatched faction affiliation when FactionLock is false" in {
+      assert(player.Faction == PlanetSideEmpire.TR)
+      assert(obj.Faction == PlanetSideEmpire.NEUTRAL)
+      assert(!obj.Definition.FactionLocked)
+
+      obj.Actor ! Mountable.TryMount(player, 0)
+      val reply = receiveOne(300 milliseconds)
+      reply match {
+        case msg : Mountable.MountMessages =>
+          assert(msg.response.isInstanceOf[Mountable.CanMount])
+        case _ =>
+          assert(false)
+      }
+    }
+  }
+}

common/src/test/scala/objects/MountableTest.scala

@@ -2,6 +2,7 @@
 package objects
 
 import akka.actor.{Actor, ActorRef, Props}
+import base.ActorTest
 import net.psforever.objects.{Avatar, Player}
 import net.psforever.objects.definition.{ObjectDefinition, SeatDefinition}
 import net.psforever.objects.serverobject.mount.{Mountable, MountableBehavior}
@@ -12,7 +13,7 @@ import net.psforever.types.{CharacterGender, CharacterVoice, PlanetSideEmpire}
 
 import scala.concurrent.duration.Duration
 
-class MountableControl1Test extends ActorTest() {
+class MountableControl1Test extends ActorTest {
   "MountableControl" should {
     "construct" in {
       val obj = new MountableTest.MountableTestObject
@@ -22,7 +23,7 @@ class MountableControl1Test extends ActorTest() {
   }
 }
 
-class MountableControl2Test extends ActorTest() {
+class MountableControl2Test extends ActorTest {
   "MountableControl" should {
     "let a player mount" in {
       val player = Player(Avatar("test", PlanetSideEmpire.TR, CharacterGender.Male, 0, CharacterVoice.Mute))
@@ -43,7 +44,7 @@ class MountableControl2Test extends ActorTest() {
   }
 }
 
-class MountableControl3Test extends ActorTest() {
+class MountableControl3Test extends ActorTest {
   "MountableControl" should {
     "block a player from mounting" in {
       val player1 = Player(Avatar("test1", PlanetSideEmpire.TR, CharacterGender.Male, 0, CharacterVoice.Mute))

common/src/test/scala/objects/ResourceSiloTest.scala

@@ -0,0 +1,332 @@
+// Copyright (c) 2017 PSForever
+package objects
+
+import akka.actor.{Actor, Props}
+import akka.routing.RandomPool
+import akka.testkit.TestProbe
+import base.ActorTest
+import net.psforever.objects.guid.TaskResolver
+import net.psforever.objects.{Avatar, GlobalDefinitions, Player}
+import net.psforever.objects.serverobject.resourcesilo.{ResourceSilo, ResourceSiloControl, ResourceSiloDefinition}
+import net.psforever.objects.serverobject.structures.{Building, StructureType}
+import net.psforever.objects.zones.Zone
+import net.psforever.packet.game.{PlanetSideGUID, UseItemMessage}
+import net.psforever.types.{CharacterGender, CharacterVoice, PlanetSideEmpire, Vector3}
+import org.specs2.mutable.Specification
+import services.ServiceManager
+import services.avatar.{AvatarAction, AvatarService, AvatarServiceMessage}
+
+import scala.concurrent.duration._
+
+class ResourceSiloTest extends Specification {
+  "Resource Silo" should {
+    "define" in {
+      val obj = new ResourceSiloDefinition
+      obj.ObjectId mustEqual 731
+    }
+
+    "construct" in {
+      val obj = ResourceSilo()
+      obj.Definition mustEqual GlobalDefinitions.resource_silo
+      obj.MaximumCharge mustEqual 1000
+      obj.ChargeLevel mustEqual 0
+      obj.LowNtuWarningOn mustEqual 0
+      obj.CapacitorDisplay mustEqual 0
+      //
+      obj.ChargeLevel = 50
+      obj.LowNtuWarningOn = 25
+      obj.CapacitorDisplay = 75
+      obj.ChargeLevel mustEqual 50
+      obj.LowNtuWarningOn mustEqual 25
+      obj.CapacitorDisplay mustEqual 75
+    }
+
+    "charge level can not exceed limits(0 to maximum)" in {
+      val obj = ResourceSilo()
+      obj.ChargeLevel mustEqual 0
+      obj.ChargeLevel = -5
+      obj.ChargeLevel mustEqual 0
+
+      obj.ChargeLevel = 1250
+      obj.ChargeLevel mustEqual 1000
+      obj.ChargeLevel mustEqual obj.MaximumCharge
+    }
+
+    "using the silo generates a charge event" in {
+      val msg = UseItemMessage(PlanetSideGUID(1), PlanetSideGUID(0), PlanetSideGUID(2), 0L, false, Vector3(0f,0f,0f),Vector3(0f,0f,0f),0,0,0,0L) //faked
+      ResourceSilo().Use(ResourceSiloTest.player, msg) mustEqual ResourceSilo.ChargeEvent()
+    }
+  }
+}
+
+class ResourceSiloControlStartupTest extends ActorTest {
+  val serviceManager = ServiceManager.boot(system)
+  serviceManager ! ServiceManager.Register(RandomPool(1).props(Props[TaskResolver]), "taskResolver")
+  val obj = ResourceSilo()
+  obj.GUID = PlanetSideGUID(1)
+  val probe = TestProbe()
+  serviceManager ! ServiceManager.Register(Props(classOf[ResourceSiloTest.ProbedAvatarService], probe), "avatar")
+
+  "Resource silo" should {
+    "startup properly" in {
+      expectNoMsg(500 milliseconds)
+      system.actorOf(Props(classOf[ResourceSiloControl], obj), "test-silo")
+      expectNoMsg(1 seconds)
+      assert(true)
+    }
+  }
+}
+
+class ResourceSiloControlUseTest extends ActorTest {
+  val serviceManager = ServiceManager.boot(system)
+  serviceManager ! ServiceManager.Register(RandomPool(1).props(Props[TaskResolver]), "taskResolver")
+  val probe = TestProbe()
+  serviceManager ! ServiceManager.Register(Props(classOf[ResourceSiloTest.ProbedAvatarService], probe), "avatar")
+  val msg = UseItemMessage(PlanetSideGUID(1), PlanetSideGUID(0), PlanetSideGUID(2), 0L, false, Vector3(0f,0f,0f),Vector3(0f,0f,0f),0,0,0,0L) //faked
+  val obj = ResourceSilo()
+  obj.GUID = PlanetSideGUID(1)
+  obj.Actor = system.actorOf(Props(classOf[ResourceSiloControl], obj), "test-silo")
+  obj.Actor ! "startup"
+
+  "Resource silo" should {
+    "respond when being used" in {
+      expectNoMsg(1 seconds)
+      obj.Actor ! ResourceSilo.Use(ResourceSiloTest.player, msg)
+
+      val reply = receiveOne(500 milliseconds)
+      assert(reply.isInstanceOf[ResourceSilo.ResourceSiloMessage])
+      assert(reply.asInstanceOf[ResourceSilo.ResourceSiloMessage].player == ResourceSiloTest.player)
+      assert(reply.asInstanceOf[ResourceSilo.ResourceSiloMessage].msg == msg)
+      assert(reply.asInstanceOf[ResourceSilo.ResourceSiloMessage].response == ResourceSilo.ChargeEvent())
+    }
+  }
+}
+
+class ResourceSiloControlNtuWarningTest extends ActorTest {
+  val serviceManager = ServiceManager.boot(system)
+  serviceManager ! ServiceManager.Register(RandomPool(1).props(Props[TaskResolver]), "taskResolver")
+  val probe = TestProbe()
+  serviceManager ! ServiceManager.Register(Props(classOf[ResourceSiloTest.ProbedAvatarService], probe), "avatar")
+  val obj = ResourceSilo()
+  obj.GUID = PlanetSideGUID(1)
+  obj.Actor = system.actorOf(Props(classOf[ResourceSiloControl], obj), "test-silo")
+  obj.Actor ! "startup"
+  obj.Owner = new Building(0, Zone.Nowhere, StructureType.Building) {
+    ModelId = 6
+  }
+
+  "Resource silo" should {
+    "announce low ntu" in {
+      expectNoMsg(1 seconds)
+      assert(obj.LowNtuWarningOn == 0)
+      obj.Actor ! ResourceSilo.LowNtuWarning(10)
+
+      val reply = probe.receiveOne(500 milliseconds)
+      assert(obj.LowNtuWarningOn == 10)
+      assert(reply.isInstanceOf[AvatarServiceMessage])
+      assert(reply.asInstanceOf[AvatarServiceMessage].forChannel == "nowhere")
+      assert(reply.asInstanceOf[AvatarServiceMessage]
+        .actionMessage.isInstanceOf[AvatarAction.PlanetsideAttribute])
+      assert(reply.asInstanceOf[AvatarServiceMessage]
+        .actionMessage.asInstanceOf[AvatarAction.PlanetsideAttribute].player_guid == PlanetSideGUID(6))
+      assert(reply.asInstanceOf[AvatarServiceMessage]
+        .actionMessage.asInstanceOf[AvatarAction.PlanetsideAttribute].attribute_type == 47)
+      assert(reply.asInstanceOf[AvatarServiceMessage]
+        .actionMessage.asInstanceOf[AvatarAction.PlanetsideAttribute].attribute_value == 10)
+    }
+  }
+}
+
+class ResourceSiloControlUpdate1Test extends ActorTest {
+  val serviceManager = ServiceManager.boot(system)
+  serviceManager ! ServiceManager.Register(RandomPool(1).props(Props[TaskResolver]), "taskResolver")
+  val probe1 = TestProbe()
+  serviceManager ! ServiceManager.Register(Props(classOf[ResourceSiloTest.ProbedAvatarService], probe1), "avatar")
+  val obj = ResourceSilo()
+  obj.GUID = PlanetSideGUID(1)
+  obj.Actor = system.actorOf(Props(classOf[ResourceSiloControl], obj), "test-silo")
+  obj.Actor ! "startup"
+  val bldg = new Building(0, Zone.Nowhere, StructureType.Building) {
+    ModelId = 6
+  }
+  val probe2 = TestProbe()
+  bldg.Actor = system.actorOf(Props(classOf[ResourceSiloTest.ProbedBuildingControl], probe2), "test-bldg")
+  obj.Owner = bldg
+
+  "Resource silo" should {
+    "update the charge level and capacitor display (report low ntu, power restored)" in {
+      expectNoMsg(1 seconds)
+
+      assert(obj.ChargeLevel == 0)
+      assert(obj.CapacitorDisplay == 0)
+      obj.Actor ! ResourceSilo.UpdateChargeLevel(105)
+
+      val reply1 = probe1.receiveOne(500 milliseconds)
+      val reply2 = probe2.receiveOne(500 milliseconds)
+      assert(obj.ChargeLevel == 105)
+      assert(obj.CapacitorDisplay == 1)
+      assert(reply1.isInstanceOf[AvatarServiceMessage])
+      assert(reply1.asInstanceOf[AvatarServiceMessage].forChannel == "nowhere")
+      assert(reply1.asInstanceOf[AvatarServiceMessage]
+        .actionMessage.isInstanceOf[AvatarAction.PlanetsideAttribute])
+      assert(reply1.asInstanceOf[AvatarServiceMessage]
+        .actionMessage.asInstanceOf[AvatarAction.PlanetsideAttribute].player_guid == PlanetSideGUID(1))
+      assert(reply1.asInstanceOf[AvatarServiceMessage]
+        .actionMessage.asInstanceOf[AvatarAction.PlanetsideAttribute].attribute_type == 45)
+      assert(reply1.asInstanceOf[AvatarServiceMessage]
+        .actionMessage.asInstanceOf[AvatarAction.PlanetsideAttribute].attribute_value == 1)
+
+      assert(reply2.isInstanceOf[Building.SendMapUpdateToAllClients])
+
+      val reply3 = probe1.receiveOne(500 milliseconds)
+      assert(reply3.isInstanceOf[AvatarServiceMessage])
+      assert(reply3.asInstanceOf[AvatarServiceMessage].forChannel == "nowhere")
+      assert(reply3.asInstanceOf[AvatarServiceMessage]
+        .actionMessage.isInstanceOf[AvatarAction.PlanetsideAttribute])
+      assert(reply3.asInstanceOf[AvatarServiceMessage]
+        .actionMessage.asInstanceOf[AvatarAction.PlanetsideAttribute].player_guid == PlanetSideGUID(6))
+      assert(reply3.asInstanceOf[AvatarServiceMessage]
+        .actionMessage.asInstanceOf[AvatarAction.PlanetsideAttribute].attribute_type == 48)
+      assert(reply3.asInstanceOf[AvatarServiceMessage]
+        .actionMessage.asInstanceOf[AvatarAction.PlanetsideAttribute].attribute_value == 0)
+
+      val reply4 = probe1.receiveOne(500 milliseconds)
+      assert(obj.LowNtuWarningOn == 1)
+      assert(reply4.isInstanceOf[AvatarServiceMessage])
+      assert(reply4.asInstanceOf[AvatarServiceMessage].forChannel == "nowhere")
+      assert(reply4.asInstanceOf[AvatarServiceMessage]
+        .actionMessage.isInstanceOf[AvatarAction.PlanetsideAttribute])
+      assert(reply4.asInstanceOf[AvatarServiceMessage]
+        .actionMessage.asInstanceOf[AvatarAction.PlanetsideAttribute].player_guid == PlanetSideGUID(6))
+      assert(reply4.asInstanceOf[AvatarServiceMessage]
+        .actionMessage.asInstanceOf[AvatarAction.PlanetsideAttribute].attribute_type == 47)
+      assert(reply4.asInstanceOf[AvatarServiceMessage]
+        .actionMessage.asInstanceOf[AvatarAction.PlanetsideAttribute].attribute_value == 1)
+    }
+  }
+}
+
+class ResourceSiloControlUpdate2Test extends ActorTest {
+  val serviceManager = ServiceManager.boot(system)
+  serviceManager ! ServiceManager.Register(RandomPool(1).props(Props[TaskResolver]), "taskResolver")
+  val probe1 = TestProbe()
+  serviceManager ! ServiceManager.Register(Props(classOf[ResourceSiloTest.ProbedAvatarService], probe1), "avatar")
+  val obj = ResourceSilo()
+  obj.GUID = PlanetSideGUID(1)
+  obj.Actor = system.actorOf(Props(classOf[ResourceSiloControl], obj), "test-silo")
+  obj.Actor ! "startup"
+  val bldg = new Building(0, Zone.Nowhere, StructureType.Building) {
+    ModelId = 6
+  }
+  val probe2 = TestProbe()
+  bldg.Actor = system.actorOf(Props(classOf[ResourceSiloTest.ProbedBuildingControl], probe2), "test-bldg")
+  obj.Owner = bldg
+
+  "Resource silo" should {
+    "update the charge level and capacitor display (report good ntu)" in {
+      expectNoMsg(1 seconds)
+
+      obj.ChargeLevel = 100
+      obj.CapacitorDisplay = 1
+      obj.LowNtuWarningOn = 1
+      assert(obj.ChargeLevel == 100)
+      assert(obj.CapacitorDisplay == 1)
+      assert(obj.LowNtuWarningOn == 1)
+      obj.Actor ! ResourceSilo.UpdateChargeLevel(105)
+
+      val reply1 = probe1.receiveOne(500 milliseconds)
+      val reply2 = probe2.receiveOne(500 milliseconds)
+      assert(obj.ChargeLevel == 205)
+      assert(obj.CapacitorDisplay == 2)
+      assert(reply1.isInstanceOf[AvatarServiceMessage])
+      assert(reply1.asInstanceOf[AvatarServiceMessage].forChannel == "nowhere")
+      assert(reply1.asInstanceOf[AvatarServiceMessage]
+        .actionMessage.isInstanceOf[AvatarAction.PlanetsideAttribute])
+      assert(reply1.asInstanceOf[AvatarServiceMessage]
+        .actionMessage.asInstanceOf[AvatarAction.PlanetsideAttribute].player_guid == PlanetSideGUID(1))
+      assert(reply1.asInstanceOf[AvatarServiceMessage]
+        .actionMessage.asInstanceOf[AvatarAction.PlanetsideAttribute].attribute_type == 45)
+      assert(reply1.asInstanceOf[AvatarServiceMessage]
+        .actionMessage.asInstanceOf[AvatarAction.PlanetsideAttribute].attribute_value == 2)
+
+      assert(reply2.isInstanceOf[Building.SendMapUpdateToAllClients])
+
+      val reply3 = probe1.receiveOne(500 milliseconds)
+      assert(obj.LowNtuWarningOn == 0)
+      assert(reply3.isInstanceOf[AvatarServiceMessage])
+      assert(reply3.asInstanceOf[AvatarServiceMessage].forChannel == "nowhere")
+      assert(reply3.asInstanceOf[AvatarServiceMessage]
+        .actionMessage.isInstanceOf[AvatarAction.PlanetsideAttribute])
+      assert(reply3.asInstanceOf[AvatarServiceMessage]
+        .actionMessage.asInstanceOf[AvatarAction.PlanetsideAttribute].player_guid == PlanetSideGUID(6))
+      assert(reply3.asInstanceOf[AvatarServiceMessage]
+        .actionMessage.asInstanceOf[AvatarAction.PlanetsideAttribute].attribute_type == 47)
+      assert(reply3.asInstanceOf[AvatarServiceMessage]
+        .actionMessage.asInstanceOf[AvatarAction.PlanetsideAttribute].attribute_value == 0)
+    }
+  }
+}
+
+class ResourceSiloControlNoUpdateTest extends ActorTest {
+  val serviceManager = ServiceManager.boot(system)
+  serviceManager ! ServiceManager.Register(RandomPool(1).props(Props[TaskResolver]), "taskResolver")
+  val probe1 = TestProbe()
+  serviceManager ! ServiceManager.Register(Props(classOf[ResourceSiloTest.ProbedAvatarService], probe1), "avatar")
+  val obj = ResourceSilo()
+  obj.GUID = PlanetSideGUID(1)
+  obj.Actor = system.actorOf(Props(classOf[ResourceSiloControl], obj), "test-silo")
+  obj.Actor ! "startup"
+  val bldg = new Building(0, Zone.Nowhere, StructureType.Building) {
+    ModelId = 6
+  }
+  val probe2 = TestProbe()
+  bldg.Actor = system.actorOf(Props(classOf[ResourceSiloTest.ProbedBuildingControl], probe2), "test-bldg")
+  obj.Owner = bldg
+
+  "Resource silo" should {
+    "update, but not sufficiently to change the capacitor display" in {
+      expectNoMsg(1 seconds)
+
+      obj.ChargeLevel = 250
+      obj.CapacitorDisplay = 3
+      obj.LowNtuWarningOn = 0
+      assert(obj.ChargeLevel == 250)
+      assert(obj.CapacitorDisplay == 3)
+      assert(obj.LowNtuWarningOn == 0)
+      obj.Actor ! ResourceSilo.UpdateChargeLevel(50)
+
+      expectNoMsg(500 milliseconds)
+      probe1.expectNoMsg(500 milliseconds)
+      probe2.expectNoMsg(500 milliseconds)
+      assert(obj.ChargeLevel == 300)
+      assert(obj.CapacitorDisplay == 3)
+      assert(obj.LowNtuWarningOn == 0)
+    }
+  }
+}
+
+object ResourceSiloTest {
+  val player = Player(Avatar("TestCharacter", PlanetSideEmpire.TR, CharacterGender.Male, 0, CharacterVoice.Mute))
+
+  class ProbedAvatarService(probe : TestProbe) extends Actor {
+    override def receive : Receive = {
+      case msg =>
+        probe.ref ! msg
+    }
+  }
+
+  class ProbedBuildingControl(probe : TestProbe) extends Actor {
+    override def receive : Receive = {
+      case msg =>
+        probe.ref ! msg
+    }
+  }
+
+  class ProbedResourceSiloControl(silo : ResourceSilo, probe : TestProbe) extends ResourceSiloControl(silo) {
+    override def receive : Receive = {
+      case msg =>
+          super.receive.apply(msg)
+          probe.ref ! msg
+      }
+  }
+}

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

@@ -2,6 +2,7 @@
 package objects
 
 import akka.actor.{Actor, ActorContext, Props}
+import base.ActorTest
 import net.psforever.objects.guid.NumberPoolHub
 import net.psforever.packet.game.PlanetSideGUID
 import net.psforever.objects.serverobject.ServerObjectBuilder
@@ -137,7 +138,8 @@ class ProximityTerminalObjectBuilderTest extends ActorTest {
   "Terminal object" should {
     "build" in {
       val hub = ServerObjectBuilderTest.NumberPoolHub
-      val actor = system.actorOf(Props(classOf[ServerObjectBuilderTest.BuilderTestActor], ServerObjectBuilder(1, ProximityTerminal.Constructor(medical_terminal)), hub), "term")
+      val actor = system.actorOf(Props(classOf[ServerObjectBuilderTest.BuilderTestActor], ServerObjectBuilder(1,
+        ProximityTerminal.Constructor(medical_terminal)), hub), "term")
       actor ! "!"
 
       val reply = receiveOne(Duration.create(1000, "ms"))
@@ -172,7 +174,7 @@ class VehicleSpawnPadObjectBuilderTest extends ActorTest {
 
 class LocalProjectileBuilderTest extends ActorTest {
   import net.psforever.objects.LocalProjectile
-  "Local ProjectileBuilder" should {
+  "Local projectile object" should {
     "build" in {
       val hub = ServerObjectBuilderTest.NumberPoolHub
       val actor = system.actorOf(Props(classOf[ServerObjectBuilderTest.BuilderTestActor], ServerObjectBuilder(1,
@@ -190,7 +192,7 @@ class LocalProjectileBuilderTest extends ActorTest {
 
 class LockerObjectBuilderTest extends ActorTest {
   import net.psforever.objects.serverobject.mblocker.Locker
-  "LockerObjectBuilder" should {
+  "Locker object" should {
     "build" in {
       val hub = ServerObjectBuilderTest.NumberPoolHub
       val actor = system.actorOf(Props(classOf[ServerObjectBuilderTest.BuilderTestActor], ServerObjectBuilder(1,
@@ -206,9 +208,27 @@ class LockerObjectBuilderTest extends ActorTest {
   }
 }
 
+class ResourceSiloObjectBuilderTest extends ActorTest {
+  import net.psforever.objects.serverobject.resourcesilo.ResourceSilo
+  "Resource silo object" should {
+    "build" in {
+      val hub = ServerObjectBuilderTest.NumberPoolHub
+      val actor = system.actorOf(Props(classOf[ServerObjectBuilderTest.BuilderTestActor], ServerObjectBuilder(1,
+        ResourceSilo.Constructor), hub), "spawn-tube")
+      actor ! "startup"
+
+      val reply = receiveOne(Duration.create(1000, "ms"))
+      assert(reply.isInstanceOf[ResourceSilo])
+      assert(reply.asInstanceOf[ResourceSilo].HasGUID)
+      assert(reply.asInstanceOf[ResourceSilo].GUID == PlanetSideGUID(1))
+      assert(reply == hub(1).get)
+    }
+  }
+}
+
 class SpawnTubeObjectBuilderTest extends ActorTest {
   import net.psforever.objects.serverobject.tube.SpawnTube
-  "LockerObjectBuilder" should {
+  "Spawn tube object" should {
     "build" in {
       val hub = ServerObjectBuilderTest.NumberPoolHub
       val actor = system.actorOf(Props(classOf[ServerObjectBuilderTest.BuilderTestActor], ServerObjectBuilder(1,
@@ -226,6 +246,25 @@ class SpawnTubeObjectBuilderTest extends ActorTest {
   }
 }
 
+class MannedTurretObjectBuilderTest extends ActorTest {
+  import net.psforever.objects.GlobalDefinitions.manned_turret
+  import net.psforever.objects.serverobject.turret.MannedTurret
+  "MannedTurretObjectBuilder" should {
+    "build" in {
+      val hub = ServerObjectBuilderTest.NumberPoolHub
+      val actor = system.actorOf(Props(classOf[ServerObjectBuilderTest.BuilderTestActor], ServerObjectBuilder(1,
+        MannedTurret.Constructor(manned_turret)), hub), "spawn-tube")
+      actor ! "!"
+
+      val reply = receiveOne(Duration.create(1000, "ms"))
+      assert(reply.isInstanceOf[MannedTurret])
+      assert(reply.asInstanceOf[MannedTurret].HasGUID)
+      assert(reply.asInstanceOf[MannedTurret].GUID == PlanetSideGUID(1))
+      assert(reply == hub(1).get)
+    }
+  }
+}
+
 object ServerObjectBuilderTest {
   import net.psforever.objects.guid.source.LimitedNumberSource
   def NumberPoolHub : NumberPoolHub = {

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

@@ -2,6 +2,7 @@
 package objects
 
 import akka.actor.{ActorRef, Props}
+import base.ActorTest
 import net.psforever.objects.GlobalDefinitions
 import net.psforever.objects.serverobject.tube.{SpawnTube, SpawnTubeControl, SpawnTubeDefinition}
 import org.specs2.mutable.Specification
@@ -48,7 +49,7 @@ class SpawnTubeTest extends Specification {
   }
 }
 
-class SpawnTubeControlTest extends ActorTest() {
+class SpawnTubeControlTest extends ActorTest {
   "SpawnTubeControl" should {
     "construct" in {
       val obj = SpawnTube(GlobalDefinitions.ams_respawn_tube)

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

@@ -2,6 +2,7 @@
 package objects
 
 import akka.actor.{Actor, ActorRef, Props}
+import base.ActorTest
 import net.psforever.objects.{GlobalDefinitions, Vehicle}
 import net.psforever.objects.serverobject.terminals.Terminal
 import net.psforever.objects.vehicles._
@@ -73,7 +74,7 @@ class UtilityTest extends Specification {
   }
 }
 
-class Utility1Test extends ActorTest() {
+class Utility1Test extends ActorTest {
   "Utility" should {
     "wire an order_terminala Actor" in {
       val obj = Utility(UtilityType.order_terminala, UtilityTest.vehicle)
@@ -87,7 +88,7 @@ class Utility1Test extends ActorTest() {
   }
 }
 
-class Utility2Test extends ActorTest() {
+class Utility2Test extends ActorTest {
   "Utility" should {
     "wire an order_terminalb Actor" in {
       val obj = Utility(UtilityType.order_terminalb, UtilityTest.vehicle)
@@ -101,7 +102,7 @@ class Utility2Test extends ActorTest() {
   }
 }
 
-class Utility3Test extends ActorTest() {
+class Utility3Test extends ActorTest {
   "Utility" should {
     "wire a matrix_terminalc Actor" in {
       val obj = Utility(UtilityType.matrix_terminalc, UtilityTest.vehicle)
@@ -115,7 +116,7 @@ class Utility3Test extends ActorTest() {
   }
 }
 
-class Utility4Test extends ActorTest() {
+class Utility4Test extends ActorTest {
   "Utility" should {
     "wire an ams_respawn_tube Actor" in {
       val obj = Utility(UtilityType.ams_respawn_tube, UtilityTest.vehicle)

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

@@ -3,7 +3,7 @@ package objects
 
 import akka.actor.{ActorRef, ActorSystem, Props}
 import akka.testkit.TestProbe
-import net.psforever.objects.ballistics.Projectile
+import base.ActorTest
 import net.psforever.objects.serverobject.mount.Mountable
 import net.psforever.objects.serverobject.pad.{VehicleSpawnControl, VehicleSpawnPad}
 import net.psforever.objects.serverobject.structures.StructureType
@@ -39,7 +39,7 @@ class VehicleSpawnPadTest extends Specification {
   }
 }
 
-class VehicleSpawnControl1Test extends ActorTest() {
+class VehicleSpawnControl1Test extends ActorTest {
   "VehicleSpawnControl" should {
     "construct" in {
       val obj = VehicleSpawnPad(GlobalDefinitions.spawn_pad)
@@ -49,7 +49,7 @@ class VehicleSpawnControl1Test extends ActorTest() {
   }
 }
 
-class VehicleSpawnControl2aTest extends ActorTest() {
+class VehicleSpawnControl2aTest extends ActorTest {
   // This runs for a long time.
   "VehicleSpawnControl" should {
     "complete on a vehicle order (block a second one until the first is done and the spawn pad is cleared)" in {
@@ -113,7 +113,7 @@ class VehicleSpawnControl2aTest extends ActorTest() {
   }
 }
 
-class VehicleSpawnControl2bTest extends ActorTest() {
+class VehicleSpawnControl2bTest extends ActorTest {
   // This runs for a long time.
   "VehicleSpawnControl" should {
     "complete on a vehicle order (railless)" in {
@@ -170,7 +170,7 @@ class VehicleSpawnControl2bTest extends ActorTest() {
   }
 }
 
-class VehicleSpawnControl3Test extends ActorTest() {
+class VehicleSpawnControl3Test extends ActorTest {
   "VehicleSpawnControl" should {
     "player is on wrong continent before vehicle can partially load; vehicle is cleaned up" in {
       val (vehicle, player, pad, zone) = VehicleSpawnPadControlTest.SetUpAgents(PlanetSideEmpire.TR)
@@ -241,7 +241,7 @@ class VehicleSpawnControl4Test extends ActorTest() {
 //  }
 //}
 
-class VehicleSpawnControl5Test extends ActorTest() {
+class VehicleSpawnControl5Test extends ActorTest {
   "VehicleSpawnControl" should {
     "player dies right after vehicle partially loads; the vehicle spawns and blocks the pad" in {
       val (vehicle, player, pad, zone) = VehicleSpawnPadControlTest.SetUpAgents(PlanetSideEmpire.TR)
@@ -274,7 +274,7 @@ class VehicleSpawnControl5Test extends ActorTest() {
   }
 }
 
-class VehicleSpawnControl6Test extends ActorTest() {
+class VehicleSpawnControl6Test extends ActorTest {
   "VehicleSpawnControl" should {
     "the player can not sit in vehicle; vehicle spawns and blocks the pad" in {
       val (vehicle, player, pad, zone) = VehicleSpawnPadControlTest.SetUpAgents(PlanetSideEmpire.TR)

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

@@ -2,6 +2,7 @@
 package objects
 
 import akka.actor.Props
+import base.ActorTest
 import net.psforever.objects._
 import net.psforever.objects.definition.{SeatDefinition, VehicleDefinition}
 import net.psforever.objects.serverobject.mount.Mountable

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

@@ -4,6 +4,7 @@ package objects
 import java.util.concurrent.atomic.AtomicInteger
 
 import akka.actor.{ActorContext, ActorRef, Props}
+import base.ActorTest
 import net.psforever.objects.entity.IdentifiableEntity
 import net.psforever.objects.equipment.Equipment
 import net.psforever.objects.guid.NumberPoolHub
@@ -74,6 +75,15 @@ class ZoneTest extends Specification {
       map.TerminalToInterface(3, 4)
       map.TerminalToInterface mustEqual Map(1 -> 2, 3 -> 4)
     }
+
+    "associate turrets to weapons" in {
+      val map = new ZoneMap("map13")
+      map.TurretToWeapon mustEqual Map.empty
+      map.TurretToWeapon(1, 2)
+      map.TurretToWeapon mustEqual Map(1 -> 2)
+      map.TurretToWeapon(3, 4)
+      map.TurretToWeapon mustEqual Map(1 -> 2, 3 -> 4)
+    }
   }
 
   val map13 = new ZoneMap("map13")

common/src/test/scala/objects/guidtask/GUIDTaskRegister1Test.scala

@@ -1,8 +1,8 @@
 // Copyright (c) 2017 PSForever
 package objects.guidtask
 
+import base.ActorTest
 import net.psforever.objects.guid.{GUIDTask, TaskResolver}
-import objects.ActorTest
 
 class GUIDTaskRegister1Test extends ActorTest {
   "RegisterObjectTask" in {

common/src/test/scala/objects/guidtask/GUIDTaskRegister2Test.scala

@@ -1,11 +1,11 @@
 // Copyright (c) 2017 PSForever
 package objects.guidtask
 
+import base.ActorTest
 import net.psforever.objects._
 import net.psforever.objects.guid.{GUIDTask, TaskResolver}
-import objects.ActorTest
 
-class GUIDTaskRegister2Test extends ActorTest() {
+class GUIDTaskRegister2Test extends ActorTest {
   "RegisterEquipment -> RegisterObjectTask" in {
     val (_, uns, taskResolver, probe) = GUIDTaskTest.CommonTestSetup
     val obj = AmmoBox(GlobalDefinitions.energy_cell)

common/src/test/scala/objects/guidtask/GUIDTaskRegister3Test.scala

@@ -1,11 +1,11 @@
 // Copyright (c) 2017 PSForever
 package objects.guidtask
 
+import base.ActorTest
 import net.psforever.objects._
 import net.psforever.objects.guid.{GUIDTask, TaskResolver}
-import objects.ActorTest
 
-class GUIDTaskRegister3Test extends ActorTest() {
+class GUIDTaskRegister3Test extends ActorTest {
   "RegisterEquipment -> RegisterTool" in {
     val (_, uns, taskResolver, probe) = GUIDTaskTest.CommonTestSetup
     val obj = Tool(GlobalDefinitions.beamer)

common/src/test/scala/objects/guidtask/GUIDTaskRegister4Test.scala

@@ -1,11 +1,11 @@
 // Copyright (c) 2017 PSForever
 package objects.guidtask
 
+import base.ActorTest
 import net.psforever.objects._
 import net.psforever.objects.guid.{GUIDTask, TaskResolver}
-import objects.ActorTest
 
-class GUIDTaskRegister4Test extends ActorTest() {
+class GUIDTaskRegister4Test extends ActorTest {
   "RegisterVehicle" in {
     val (_, uns, taskResolver, probe) = GUIDTaskTest.CommonTestSetup
     val obj = Vehicle(GlobalDefinitions.fury)

common/src/test/scala/objects/guidtask/GUIDTaskRegister5Test.scala

@@ -1,12 +1,12 @@
 // Copyright (c) 2017 PSForever
 package objects.guidtask
 
+import base.ActorTest
 import net.psforever.objects._
 import net.psforever.objects.guid.{GUIDTask, TaskResolver}
 import net.psforever.types.{CharacterGender, CharacterVoice, PlanetSideEmpire}
-import objects.ActorTest
 
-class GUIDTaskRegister5Test extends ActorTest() {
+class GUIDTaskRegister5Test extends ActorTest {
   "RegisterAvatar" in {
     val (_, uns, taskResolver, probe) = GUIDTaskTest.CommonTestSetup
     val obj = Player(Avatar("test", PlanetSideEmpire.TR, CharacterGender.Male, 0, CharacterVoice.Mute))

common/src/test/scala/objects/guidtask/GUIDTaskRegister6Test.scala

@@ -1,12 +1,12 @@
 // Copyright (c) 2017 PSForever
 package objects.guidtask
 
+import base.ActorTest
 import net.psforever.objects._
 import net.psforever.objects.guid.{GUIDTask, TaskResolver}
 import net.psforever.types.{CharacterGender, CharacterVoice, PlanetSideEmpire}
-import objects.ActorTest
 
-class GUIDTaskRegister6Test extends ActorTest() {
+class GUIDTaskRegister6Test extends ActorTest {
   "RegisterPlayer" in {
     val (_, uns, taskResolver, probe) = GUIDTaskTest.CommonTestSetup
     val obj = Player(Avatar("test", PlanetSideEmpire.TR, CharacterGender.Male, 0, CharacterVoice.Mute))

common/src/test/scala/objects/guidtask/GUIDTaskUnregister1Test.scala

@@ -1,10 +1,10 @@
 // Copyright (c) 2017 PSForever
 package objects.guidtask
 
+import base.ActorTest
 import net.psforever.objects.guid.{GUIDTask, TaskResolver}
-import objects.ActorTest
 
-class GUIDTaskUnregister1Test extends ActorTest() {
+class GUIDTaskUnregister1Test extends ActorTest {
   "UnregisterObjectTask" in {
     val (guid, uns, taskResolver, probe) = GUIDTaskTest.CommonTestSetup
     val obj = new GUIDTaskTest.TestObject

common/src/test/scala/objects/guidtask/GUIDTaskUnregister2Test.scala

@@ -1,11 +1,11 @@
 // Copyright (c) 2017 PSForever
 package objects.guidtask
 
+import base.ActorTest
 import net.psforever.objects._
 import net.psforever.objects.guid.{GUIDTask, TaskResolver}
-import objects.ActorTest
 
-class GUIDTaskUnregister2Test extends ActorTest() {
+class GUIDTaskUnregister2Test extends ActorTest {
   "UnregisterEquipment -> UnregisterObjectTask" in {
     val (guid, uns, taskResolver, probe) = GUIDTaskTest.CommonTestSetup
     val obj = AmmoBox(GlobalDefinitions.energy_cell)

common/src/test/scala/objects/guidtask/GUIDTaskUnregister3Test.scala

@@ -1,11 +1,11 @@
 // Copyright (c) 2017 PSForever
 package objects.guidtask
 
+import base.ActorTest
 import net.psforever.objects._
 import net.psforever.objects.guid.{GUIDTask, TaskResolver}
-import objects.ActorTest
 
-class GUIDTaskUnregister3Test extends ActorTest() {
+class GUIDTaskUnregister3Test extends ActorTest {
   "UnregisterEquipment -> UnregisterTool" in {
     val (guid, uns, taskResolver, probe) = GUIDTaskTest.CommonTestSetup
     val obj = Tool(GlobalDefinitions.beamer)

common/src/test/scala/objects/guidtask/GUIDTaskUnregister4Test.scala

@@ -1,11 +1,11 @@
 // Copyright (c) 2017 PSForever
 package objects.guidtask
 
+import base.ActorTest
 import net.psforever.objects._
 import net.psforever.objects.guid.{GUIDTask, TaskResolver}
-import objects.ActorTest
 
-class GUIDTaskUnregister4Test extends ActorTest() {
+class GUIDTaskUnregister4Test extends ActorTest {
   "RegisterVehicle" in {
     val (guid, uns, taskResolver, probe) = GUIDTaskTest.CommonTestSetup
     val obj = Vehicle(GlobalDefinitions.fury)

common/src/test/scala/objects/guidtask/GUIDTaskUnregister5Test.scala

@@ -1,12 +1,12 @@
 // Copyright (c) 2017 PSForever
 package objects.guidtask
 
+import base.ActorTest
 import net.psforever.objects._
 import net.psforever.objects.guid.{GUIDTask, TaskResolver}
 import net.psforever.types.{CharacterGender, CharacterVoice, PlanetSideEmpire}
-import objects.ActorTest
 
-class GUIDTaskUnregister5Test extends ActorTest() {
+class GUIDTaskUnregister5Test extends ActorTest {
   "UnregisterAvatar" in {
     val (guid, uns, taskResolver, probe) = GUIDTaskTest.CommonTestSetup
     val obj = Player(Avatar("test", PlanetSideEmpire.TR, CharacterGender.Male, 0, CharacterVoice.Mute))

common/src/test/scala/objects/guidtask/GUIDTaskUnregister6Test.scala

@@ -1,12 +1,12 @@
 // Copyright (c) 2017 PSForever
 package objects.guidtask
 
+import base.ActorTest
 import net.psforever.objects._
 import net.psforever.objects.guid.{GUIDTask, TaskResolver}
 import net.psforever.types.{CharacterGender, CharacterVoice, PlanetSideEmpire}
-import objects.ActorTest
 
-class GUIDTaskUnregister6Test extends ActorTest() {
+class GUIDTaskUnregister6Test extends ActorTest {
   "UnregisterPlayer" in {
     val (guid, uns, taskResolver, probe) = GUIDTaskTest.CommonTestSetup
     val obj = Player(Avatar("test", PlanetSideEmpire.TR, CharacterGender.Male, 0, CharacterVoice.Mute))

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

@@ -2,14 +2,14 @@
 package objects.number
 
 import akka.actor.{ActorSystem, Props}
+import base.ActorTest
 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
 
-class NumberPoolActorTest extends ActorTest() {
+class NumberPoolActorTest extends ActorTest {
   "NumberPoolActor" should {
     "GetAnyNumber" in {
       val pool = new ExclusivePool((25 to 50).toList)
@@ -22,7 +22,7 @@ class NumberPoolActorTest extends ActorTest() {
   }
 }
 
-class NumberPoolActorTest1 extends ActorTest() {
+class NumberPoolActorTest1 extends ActorTest {
   "NumberPoolActor" should {
     "GetSpecificNumber" in {
       val pool = new ExclusivePool((25 to 50).toList)
@@ -34,7 +34,7 @@ class NumberPoolActorTest1 extends ActorTest() {
   }
 }
 
-class NumberPoolActorTest2 extends ActorTest() {
+class NumberPoolActorTest2 extends ActorTest {
   "NumberPoolActor" should {
     "NoNumber" in {
       val pool = new ExclusivePool((25 to 25).toList) //pool only has one number - 25

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

@@ -2,17 +2,17 @@
 package objects.number
 
 import akka.actor.{ActorRef, ActorSystem, Props}
+import base.ActorTest
 import net.psforever.objects.entity.IdentifiableEntity
 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() {
+class AllocateNumberPoolActors extends ActorTest {
   "AllocateNumberPoolActors" in {
     val src : LimitedNumberSource = LimitedNumberSource(6000)
     val guid : NumberPoolHub = new NumberPoolHub(src)

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

@@ -2,6 +2,7 @@
 package objects.terminal
 
 import akka.actor.{ActorRef, ActorSystem, Props}
+import base.ActorTest
 import net.psforever.objects.definition.SeatDefinition
 import net.psforever.objects.serverobject.mount.Mountable
 import net.psforever.objects.serverobject.implantmech.{ImplantTerminalMech, ImplantTerminalMechControl}
@@ -9,7 +10,6 @@ import net.psforever.objects.serverobject.structures.StructureType
 import net.psforever.objects.vehicles.Seat
 import net.psforever.objects.{Avatar, GlobalDefinitions, Player}
 import net.psforever.types.{CharacterGender, CharacterVoice, PlanetSideEmpire, Vector3}
-import objects.ActorTest
 import org.specs2.mutable.Specification
 
 import scala.concurrent.duration.Duration
@@ -56,7 +56,7 @@ class ImplantTerminalMechTest extends Specification {
   }
 }
 
-class ImplantTerminalMechControl1Test extends ActorTest() {
+class ImplantTerminalMechControl1Test extends ActorTest {
   "ImplantTerminalMechControl" should {
     "construct" in {
       val obj = ImplantTerminalMech(GlobalDefinitions.implant_terminal_mech)
@@ -66,7 +66,7 @@ class ImplantTerminalMechControl1Test extends ActorTest() {
   }
 }
 
-class ImplantTerminalMechControl2Test extends ActorTest() {
+class ImplantTerminalMechControl2Test extends ActorTest {
   "ImplantTerminalMechControl" should {
     "let a player mount" in {
       val (player, mech) = ImplantTerminalMechTest.SetUpAgents(PlanetSideEmpire.TR)
@@ -85,7 +85,7 @@ class ImplantTerminalMechControl2Test extends ActorTest() {
   }
 }
 
-class ImplantTerminalMechControl3Test extends ActorTest() {
+class ImplantTerminalMechControl3Test extends ActorTest {
   import net.psforever.types.CharacterGender
   "ImplantTerminalMechControl" should {
     "block a player from mounting" in {
@@ -108,7 +108,7 @@ class ImplantTerminalMechControl3Test extends ActorTest() {
   }
 }
 
-class ImplantTerminalMechControl4Test extends ActorTest() {
+class ImplantTerminalMechControl4Test extends ActorTest {
   "ImplantTerminalMechControl" should {
     "dismount player after mounting" in {
       val (player, mech) = ImplantTerminalMechTest.SetUpAgents(PlanetSideEmpire.TR)
@@ -130,7 +130,7 @@ class ImplantTerminalMechControl4Test extends ActorTest() {
   }
 }
 
-class ImplantTerminalMechControl5Test extends ActorTest() {
+class ImplantTerminalMechControl5Test extends ActorTest {
   "ImplantTerminalMechControl" should {
     "block a player from dismounting" in {
       val (player, mech) = ImplantTerminalMechTest.SetUpAgents(PlanetSideEmpire.TR)

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

@@ -2,16 +2,16 @@
 package objects.terminal
 
 import akka.actor.{ActorSystem, Props}
+import base.ActorTest
 import net.psforever.objects.serverobject.CommonMessages
 import net.psforever.objects.{Avatar, GlobalDefinitions, Player}
 import net.psforever.objects.serverobject.terminals._
 import net.psforever.packet.game.PlanetSideGUID
 import net.psforever.types.{CharacterGender, CharacterVoice, PlanetSideEmpire}
-import objects.ActorTest
 
 import scala.concurrent.duration.Duration
 
-class ProximityTerminalControl1Test extends ActorTest() {
+class ProximityTerminalControl1Test extends ActorTest {
   "ProximityTerminalControl" should {
     "construct (medical terminal)" in {
       val terminal = ProximityTerminal(GlobalDefinitions.medical_terminal)
@@ -20,7 +20,7 @@ class ProximityTerminalControl1Test extends ActorTest() {
   }
 }
 
-class ProximityTerminalControl2Test extends ActorTest() {
+class ProximityTerminalControl2Test extends ActorTest {
   "ProximityTerminalControl can not process wrong messages" in {
     val (_, terminal) = TerminalControlTest.SetUpAgents(GlobalDefinitions.medical_terminal, PlanetSideEmpire.TR)
 
@@ -30,7 +30,7 @@ class ProximityTerminalControl2Test extends ActorTest() {
 }
 
 //terminal control is mostly a pass-through actor for Terminal.Exchange messages, wrapped in Terminal.TerminalMessage protocol
-class MedicalTerminalControl1Test extends ActorTest() {
+class MedicalTerminalControl1Test extends ActorTest {
   "ProximityTerminalControl sends a message to the first new user only" in {
     val (player, terminal) = ProximityTerminalControlTest.SetUpAgents(GlobalDefinitions.medical_terminal, PlanetSideEmpire.TR)
     player.GUID = PlanetSideGUID(10)
@@ -53,7 +53,7 @@ class MedicalTerminalControl1Test extends ActorTest() {
   }
 }
 
-class MedicalTerminalControl2Test extends ActorTest() {
+class MedicalTerminalControl2Test extends ActorTest {
   "ProximityTerminalControl sends a message to the last user only" in {
     val (player, terminal) : (Player, ProximityTerminal) = ProximityTerminalControlTest.SetUpAgents(GlobalDefinitions.medical_terminal, PlanetSideEmpire.TR)
     player.GUID = PlanetSideGUID(10)
@@ -82,7 +82,7 @@ class MedicalTerminalControl2Test extends ActorTest() {
   }
 }
 
-class MedicalTerminalControl3Test extends ActorTest() {
+class MedicalTerminalControl3Test extends ActorTest {
   "ProximityTerminalControl sends a message to the last user only (confirmation of test #2)" in {
     val (player, terminal) : (Player, ProximityTerminal) = ProximityTerminalControlTest.SetUpAgents(GlobalDefinitions.medical_terminal, PlanetSideEmpire.TR)
     player.GUID = PlanetSideGUID(10)

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

@@ -2,13 +2,13 @@
 package objects.terminal
 
 import akka.actor.Props
+import base.ActorTest
 import net.psforever.objects.serverobject.CommonMessages
 import net.psforever.objects.serverobject.terminals.Terminal.TerminalMessage
 import net.psforever.objects.serverobject.terminals.{ProximityTerminal, ProximityTerminalControl, ProximityUnit, Terminal}
 import net.psforever.objects.{Avatar, GlobalDefinitions, Player}
 import net.psforever.packet.game.PlanetSideGUID
 import net.psforever.types.{CharacterGender, CharacterVoice, PlanetSideEmpire}
-import objects.ActorTest
 import org.specs2.mutable.Specification
 
 import scala.concurrent.duration._

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

@@ -2,17 +2,17 @@
 package objects.terminal
 
 import akka.actor.{ActorSystem, Props}
+import base.ActorTest
 import net.psforever.objects.serverobject.structures.{Building, StructureType}
 import net.psforever.objects.serverobject.terminals.{Terminal, TerminalControl, TerminalDefinition}
 import net.psforever.objects.zones.Zone
 import net.psforever.objects.{Avatar, GlobalDefinitions, Player}
 import net.psforever.packet.game.{ItemTransactionMessage, PlanetSideGUID}
 import net.psforever.types._
-import objects.ActorTest
 
 import scala.concurrent.duration.Duration
 
-class TerminalControl1Test extends ActorTest() {
+class TerminalControl1Test extends ActorTest {
   "TerminalControl" should {
     "construct (cert terminal)" in {
       val terminal = Terminal(GlobalDefinitions.cert_terminal)
@@ -21,7 +21,7 @@ class TerminalControl1Test extends ActorTest() {
   }
 }
 
-class TerminalControl2Test extends ActorTest() {
+class TerminalControl2Test extends ActorTest {
   "TerminalControl can not process wrong messages" in {
     val (_, terminal) = TerminalControlTest.SetUpAgents(GlobalDefinitions.cert_terminal, PlanetSideEmpire.TR)
 
@@ -32,7 +32,7 @@ class TerminalControl2Test extends ActorTest() {
 
 //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() {
+class CertTerminalControl1Test extends ActorTest {
   "TerminalControl can be used to learn a certification ('medium_assault')" in {
     val (player, terminal) = TerminalControlTest.SetUpAgents(GlobalDefinitions.cert_terminal, PlanetSideEmpire.TR)
     val msg = ItemTransactionMessage(PlanetSideGUID(1), TransactionType.Learn, 0, "medium_assault", 0, PlanetSideGUID(0))
@@ -47,7 +47,7 @@ class CertTerminalControl1Test extends ActorTest() {
   }
 }
 
-class CertTerminalControl2Test extends ActorTest() {
+class CertTerminalControl2Test extends ActorTest {
   "TerminalControl can be used to warn about not learning a fake certification ('juggling')" in {
     val (player, terminal) = TerminalControlTest.SetUpAgents(GlobalDefinitions.cert_terminal, PlanetSideEmpire.TR)
     val msg = ItemTransactionMessage(PlanetSideGUID(1), TransactionType.Learn, 0, "juggling", 0, PlanetSideGUID(0))
@@ -62,7 +62,7 @@ class CertTerminalControl2Test extends ActorTest() {
   }
 }
 
-class CertTerminalControl3Test extends ActorTest() {
+class CertTerminalControl3Test extends ActorTest {
   "TerminalControl can be used to forget a certification ('medium_assault')" in {
     val (player, terminal) = TerminalControlTest.SetUpAgents(GlobalDefinitions.cert_terminal, PlanetSideEmpire.TR)
     val msg = ItemTransactionMessage(PlanetSideGUID(1), TransactionType.Sell, 0, "medium_assault", 0, PlanetSideGUID(0))
@@ -77,7 +77,7 @@ class CertTerminalControl3Test extends ActorTest() {
   }
 }
 
-class VehicleTerminalControl1Test extends ActorTest() {
+class VehicleTerminalControl1Test extends ActorTest {
   "TerminalControl can be used to buy a vehicle ('two_man_assault_buggy')" in {
     val (player, terminal) = TerminalControlTest.SetUpAgents(GlobalDefinitions.ground_vehicle_terminal, PlanetSideEmpire.TR)
     val msg = ItemTransactionMessage(PlanetSideGUID(1), TransactionType.Buy, 0, "two_man_assault_buggy", 0, PlanetSideGUID(0))
@@ -102,7 +102,7 @@ class VehicleTerminalControl1Test extends ActorTest() {
   }
 }
 
-class VehicleTerminalControl2Test extends ActorTest() {
+class VehicleTerminalControl2Test extends ActorTest {
   "TerminalControl can be used to warn about not buy a vehicle ('harasser')" in {
     val (player, terminal) = TerminalControlTest.SetUpAgents(GlobalDefinitions.ground_vehicle_terminal, PlanetSideEmpire.TR)
     val msg = ItemTransactionMessage(PlanetSideGUID(1), TransactionType.Buy, 0, "harasser", 0, PlanetSideGUID(0))