Amenity Auto-Repair (#594)

* working proof of concept for ntu request/flow

* ntu is now measured in Float rather than Int; adjusted the type declarations in ChatActor, as it was complaining

* added auto repair information for amenities; modified terminal working example to include periodic repair timer

* crude power state acknowledgement exchange between ntu silo and building, following by building and amenities; better management and control over auto-repair

* separated auto-repair from terminal control; resource silo publishes an appropriate power state message upon formal start-up

* various Damageble objects have been granted auto-repair; doors no longer report no event for intercepting unhandled messages

* documentation and comments; unit tests and integration tests for AmneityAutoRepair, ResourceSilo, and BuildingActor

* merge plus some fixes

* addition checks for auto-repairing cavern equipment and for auto-repairing un-owned equipment

src/test/scala/objects/AutoRepairIntegrationTest.scala

@@ -0,0 +1,164 @@
+// Copyright (c) 2020 PSForever
+package objects
+
+import akka.actor.Props
+import akka.testkit.TestProbe
+import base.FreedContextActorTest
+import net.psforever.objects.avatar.Avatar
+import net.psforever.objects.ballistics.{Projectile, ProjectileResolution, ResolvedProjectile, SourceEntry}
+import net.psforever.objects.guid.NumberPoolHub
+import net.psforever.objects.guid.source.MaxNumberSource
+import net.psforever.objects.serverobject.resourcesilo.{ResourceSilo, ResourceSiloControl}
+import net.psforever.objects.serverobject.structures.{AutoRepairStats, Building, StructureType}
+import net.psforever.objects.serverobject.terminals.{OrderTerminalDefinition, Terminal, TerminalControl}
+import net.psforever.objects.vital.Vitality
+import net.psforever.objects.vital.damage.DamageProfile
+import net.psforever.objects.zones.{Zone, ZoneMap}
+import net.psforever.objects.{GlobalDefinitions, Player, Tool}
+import net.psforever.services.galaxy.GalaxyService
+import net.psforever.services.{InterstellarClusterService, ServiceManager}
+import net.psforever.types.{CharacterGender, CharacterVoice, PlanetSideEmpire, Vector3}
+
+import scala.concurrent.duration._
+
+class AutoRepairFacilityIntegrationTest extends FreedContextActorTest {
+  import akka.actor.typed.scaladsl.adapter._
+  system.spawn(InterstellarClusterService(Nil), InterstellarClusterService.InterstellarClusterServiceKey.id)
+  ServiceManager.boot(system) ! ServiceManager.Register(Props[GalaxyService](), "galaxy")
+  expectNoMessage(200 milliseconds)
+
+  val player = Player(Avatar(0, "TestCharacter", PlanetSideEmpire.TR, CharacterGender.Male, 0, CharacterVoice.Mute))
+  player.Spawn()
+  val weapon = new Tool(GlobalDefinitions.suppressor)
+  val terminal = new Terminal(AutoRepairIntegrationTest.terminal_definition)
+  val silo = new ResourceSilo()
+  val guid = new NumberPoolHub(new MaxNumberSource(max = 10))
+  val zone = new Zone("test", new ZoneMap("test"), 0) {
+    override def SetupNumberPools() = {}
+    GUID(guid)
+  }
+  val avatarProbe = new TestProbe(system)
+  zone.AvatarEvents = avatarProbe.ref
+
+  guid.register(player, number = 1)
+  guid.register(weapon, number = 2)
+  guid.register(weapon.AmmoSlot.Box, number = 3)
+  guid.register(terminal, number = 4)
+  guid.register(silo, number = 5)
+
+  val building = Building.Structure(StructureType.Facility)(name = "test-building", guid = 6, map_id = 0, zone, context)
+  building.Invalidate()
+  guid.register(building, number = 6)
+  building.Amenities = silo
+  building.Amenities = terminal
+
+  terminal.Actor = context.actorOf(Props(classOf[TerminalControl], terminal), name = "test-terminal")
+
+  silo.NtuCapacitor = 1000
+  silo.Actor = system.actorOf(Props(classOf[ResourceSiloControl], silo), "test-silo")
+  silo.Actor ! "startup"
+
+  val wep_fmode  = weapon.FireMode
+  val wep_prof   = wep_fmode.Add
+  val proj       = weapon.Projectile
+  val proj_prof  = proj.asInstanceOf[DamageProfile]
+  val projectile = Projectile(proj, weapon.Definition, wep_fmode, player, Vector3(2, 0, 0), Vector3.Zero)
+  val resolved = ResolvedProjectile(
+    ProjectileResolution.Hit,
+    projectile,
+    SourceEntry(terminal),
+    terminal.DamageModel,
+    Vector3(1, 0, 0)
+  )
+  val applyDamageTo = resolved.damage_model.Calculate(resolved)
+
+  "AutoRepair" should {
+    "should activate on damage and trade NTU from the facility's resource silo for repairs" in {
+      assert(silo.NtuCapacitor == silo.MaxNtuCapacitor)
+      assert(terminal.Health == terminal.MaxHealth)
+      terminal.Actor ! Vitality.Damage(applyDamageTo)
+
+      avatarProbe.receiveOne(max = 200 milliseconds) //health update event
+      assert(terminal.Health < terminal.MaxHealth)
+      var i = 0 //safety counter
+      while(terminal.Health < terminal.MaxHealth && i < 100) {
+        i += 1
+        avatarProbe.receiveOne(max = 1000 milliseconds) //health update event
+      }
+      assert(silo.NtuCapacitor < silo.MaxNtuCapacitor)
+      assert(terminal.Health == terminal.MaxHealth)
+    }
+  }
+}
+
+class AutoRepairTowerIntegrationTest extends FreedContextActorTest {
+  import akka.actor.typed.scaladsl.adapter._
+  system.spawn(InterstellarClusterService(Nil), InterstellarClusterService.InterstellarClusterServiceKey.id)
+  ServiceManager.boot(system) ! ServiceManager.Register(Props[GalaxyService](), "galaxy")
+  expectNoMessage(200 milliseconds)
+
+  val player = Player(Avatar(0, "TestCharacter", PlanetSideEmpire.TR, CharacterGender.Male, 0, CharacterVoice.Mute))
+  player.Spawn()
+  val weapon = new Tool(GlobalDefinitions.suppressor)
+  val terminal = new Terminal(AutoRepairIntegrationTest.terminal_definition)
+  val guid = new NumberPoolHub(new MaxNumberSource(max = 10))
+  val zone = new Zone("test", new ZoneMap("test"), 0) {
+    override def SetupNumberPools() = {}
+    GUID(guid)
+  }
+  val avatarProbe = new TestProbe(system)
+  zone.AvatarEvents = avatarProbe.ref
+
+  guid.register(player, number = 1)
+  guid.register(weapon, number = 2)
+  guid.register(weapon.AmmoSlot.Box, number = 3)
+  guid.register(terminal, number = 4)
+
+  val building = Building.Structure(StructureType.Tower)(name = "test-building", guid = 6, map_id = 0, zone, context)
+  building.Invalidate()
+  guid.register(building, number = 6)
+  building.Amenities = terminal
+
+  terminal.Actor = context.actorOf(Props(classOf[TerminalControl], terminal), name = "test-terminal")
+
+  val wep_fmode  = weapon.FireMode
+  val wep_prof   = wep_fmode.Add
+  val proj       = weapon.Projectile
+  val proj_prof  = proj.asInstanceOf[DamageProfile]
+  val projectile = Projectile(proj, weapon.Definition, wep_fmode, player, Vector3(2, 0, 0), Vector3.Zero)
+  val resolved = ResolvedProjectile(
+    ProjectileResolution.Hit,
+    projectile,
+    SourceEntry(terminal),
+    terminal.DamageModel,
+    Vector3(1, 0, 0)
+  )
+  val applyDamageTo = resolved.damage_model.Calculate(resolved)
+
+  "AutoRepair" should {
+    "should activate on damage and trade NTU from the tower for repairs" in {
+      assert(terminal.Health == terminal.MaxHealth)
+      terminal.Actor ! Vitality.Damage(applyDamageTo)
+
+      avatarProbe.receiveOne(max = 200 milliseconds) //health update event
+      assert(terminal.Health < terminal.MaxHealth)
+      var i = 0 //safety counter
+      while(terminal.Health < terminal.MaxHealth && i < 100) {
+        i += 1
+        avatarProbe.receiveOne(max = 1000 milliseconds) //health update event
+      }
+      assert(terminal.Health == terminal.MaxHealth)
+    }
+  }
+}
+
+object AutoRepairIntegrationTest {
+  val terminal_definition = new OrderTerminalDefinition(objId = 612) {
+    Name = "order_terminal"
+    MaxHealth = 500
+    Damageable = true
+    Repairable = true
+    autoRepair = AutoRepairStats(1, 500, 500, 1)
+    RepairIfDestroyed = true
+  }
+}

src/test/scala/objects/AutoRepairTest.scala

@@ -0,0 +1,390 @@
+// Copyright (c) 2020 PSForever
+package objects
+
+import akka.actor.Props
+import akka.testkit.TestProbe
+import base.FreedContextActorTest
+import net.psforever.actors.commands.NtuCommand
+import net.psforever.actors.zone.BuildingActor
+import net.psforever.objects.avatar.Avatar
+import net.psforever.objects.ballistics.{Projectile, ProjectileResolution, ResolvedProjectile, SourceEntry}
+import net.psforever.objects.guid.NumberPoolHub
+import net.psforever.objects.guid.source.MaxNumberSource
+import net.psforever.objects.serverobject.structures.{AutoRepairStats, Building, StructureType}
+import net.psforever.objects.serverobject.terminals.{OrderTerminalDefinition, Terminal, TerminalControl}
+import net.psforever.objects.vital.Vitality
+import net.psforever.objects.vital.damage.DamageProfile
+import net.psforever.objects.zones.{Zone, ZoneMap}
+import net.psforever.objects.{GlobalDefinitions, Player, Tool}
+import net.psforever.types.{CharacterGender, CharacterVoice, PlanetSideEmpire, Vector3}
+
+import scala.concurrent.duration._
+
+class AutoRepairRequestNtuTest extends FreedContextActorTest {
+  val player = Player(Avatar(0, "TestCharacter", PlanetSideEmpire.TR, CharacterGender.Male, 0, CharacterVoice.Mute))
+  player.Spawn()
+  val weapon = new Tool(GlobalDefinitions.suppressor)
+  val terminal = new Terminal(AutoRepairTest.terminal_definition)
+  val guid = new NumberPoolHub(new MaxNumberSource(max = 10))
+  val zone = new Zone("test", new ZoneMap("test"), 0) {
+    override def SetupNumberPools() = {}
+    GUID(guid)
+  }
+  val avatarProbe = new TestProbe(system)
+  zone.AvatarEvents = avatarProbe.ref
+
+  guid.register(player, number = 1)
+  guid.register(weapon, number = 2)
+  guid.register(weapon.AmmoSlot.Box, number = 3)
+  guid.register(terminal, number = 4)
+
+  val building = Building("test-building", 1, 1, zone, StructureType.Facility)
+  building.Invalidate()
+  guid.register(building, number = 6)
+  val buildingProbe = new TestProbe(system)
+  building.Actor = buildingProbe.ref
+  building.Zone = zone
+  terminal.Actor = context.actorOf(Props(classOf[TerminalControl], terminal), name = "test-terminal")
+  terminal.Owner = building
+
+  val wep_fmode  = weapon.FireMode
+  val wep_prof   = wep_fmode.Add
+  val proj       = weapon.Projectile
+  val proj_prof  = proj.asInstanceOf[DamageProfile]
+  val projectile = Projectile(proj, weapon.Definition, wep_fmode, player, Vector3(2, 0, 0), Vector3.Zero)
+  val resolved = ResolvedProjectile(
+    ProjectileResolution.Hit,
+    projectile,
+    SourceEntry(terminal),
+    terminal.DamageModel,
+    Vector3(1, 0, 0)
+  )
+  val applyDamageTo = resolved.damage_model.Calculate(resolved)
+
+  "AutoRepair" should {
+    "asks owning building for NTU after damage" in {
+      assert(terminal.Health == terminal.MaxHealth)
+      terminal.Actor ! Vitality.Damage(applyDamageTo)
+
+      avatarProbe.receiveOne(max = 200 milliseconds) //health update event
+      assert(terminal.Health < terminal.MaxHealth)
+      val buildingMsg = buildingProbe.receiveOne(max = 600 milliseconds)
+      assert(buildingMsg match {
+        case BuildingActor.Ntu(NtuCommand.Request(drain, _)) =>
+          drain == terminal.Definition.autoRepair.get.drain
+        case _ =>
+          false
+      })
+    }
+  }
+}
+
+class AutoRepairRequestNtuRepeatTest extends FreedContextActorTest {
+  val player = Player(Avatar(0, "TestCharacter", PlanetSideEmpire.TR, CharacterGender.Male, 0, CharacterVoice.Mute))
+  player.Spawn()
+  val weapon = new Tool(GlobalDefinitions.suppressor)
+  val terminal = new Terminal(AutoRepairTest.terminal_definition)
+  val guid = new NumberPoolHub(new MaxNumberSource(max = 10))
+  val zone = new Zone("test", new ZoneMap("test"), 0) {
+    override def SetupNumberPools() = {}
+    GUID(guid)
+  }
+  val avatarProbe = new TestProbe(system)
+  zone.AvatarEvents = avatarProbe.ref
+
+  guid.register(player, number = 1)
+  guid.register(weapon, number = 2)
+  guid.register(weapon.AmmoSlot.Box, number = 3)
+  guid.register(terminal, number = 4)
+
+  val building = Building("test-building", 1, 1, zone, StructureType.Facility)
+  building.Invalidate()
+  guid.register(building, number = 6)
+  val buildingProbe = new TestProbe(system)
+  building.Actor = buildingProbe.ref
+  building.Zone = zone
+  terminal.Actor = context.actorOf(Props(classOf[TerminalControl], terminal), name = "test-terminal")
+  terminal.Owner = building
+
+  val wep_fmode  = weapon.FireMode
+  val wep_prof   = wep_fmode.Add
+  val proj       = weapon.Projectile
+  val proj_prof  = proj.asInstanceOf[DamageProfile]
+  val projectile = Projectile(proj, weapon.Definition, wep_fmode, player, Vector3(2, 0, 0), Vector3.Zero)
+  val resolved = ResolvedProjectile(
+    ProjectileResolution.Hit,
+    projectile,
+    SourceEntry(terminal),
+    terminal.DamageModel,
+    Vector3(1, 0, 0)
+  )
+  val applyDamageTo = resolved.damage_model.Calculate(resolved)
+
+  "AutoRepair" should {
+    "repeatedly asks owning building for NTU after damage" in {
+      assert(terminal.Health == terminal.MaxHealth)
+      terminal.Actor ! Vitality.Damage(applyDamageTo)
+
+      avatarProbe.receiveOne(max = 200 milliseconds) //health update event
+      assert(terminal.Health < terminal.MaxHealth)
+      (0 to 3).foreach { _ =>
+        val buildingMsg = buildingProbe.receiveOne(max = 1000 milliseconds)
+        assert(buildingMsg match {
+          case BuildingActor.Ntu(NtuCommand.Request(drain, _)) =>
+            drain == terminal.Definition.autoRepair.get.drain
+          case _ =>
+            false
+        })
+      }
+    }
+  }
+}
+
+class AutoRepairNoRequestNtuTest extends FreedContextActorTest {
+  val player = Player(Avatar(0, "TestCharacter", PlanetSideEmpire.TR, CharacterGender.Male, 0, CharacterVoice.Mute))
+  player.Spawn()
+  val weapon = new Tool(GlobalDefinitions.suppressor)
+  val terminal = new Terminal(AutoRepairTest.terminal_definition)
+  val guid = new NumberPoolHub(new MaxNumberSource(max = 10))
+  val zone = new Zone("test", new ZoneMap("test"), 0) {
+    override def SetupNumberPools() = {}
+    GUID(guid)
+  }
+  val avatarProbe = new TestProbe(system)
+  zone.AvatarEvents = avatarProbe.ref
+
+  guid.register(player, number = 1)
+  guid.register(weapon, number = 2)
+  guid.register(weapon.AmmoSlot.Box, number = 3)
+  guid.register(terminal, number = 4)
+
+  val building = Building("test-building", 1, 1, zone, StructureType.Facility)
+  building.Invalidate()
+  guid.register(building, number = 6)
+  val buildingProbe = new TestProbe(system)
+  building.Actor = buildingProbe.ref
+  building.Zone = zone
+  terminal.Actor = context.actorOf(Props(classOf[TerminalControl], terminal), name = "test-terminal")
+  terminal.Owner = building
+
+  val wep_fmode  = weapon.FireMode
+  val wep_prof   = wep_fmode.Add
+  val proj       = weapon.Projectile
+  val proj_prof  = proj.asInstanceOf[DamageProfile]
+  val projectile = Projectile(proj, weapon.Definition, wep_fmode, player, Vector3(2, 0, 0), Vector3.Zero)
+  val resolved = ResolvedProjectile(
+    ProjectileResolution.Hit,
+    projectile,
+    SourceEntry(terminal),
+    terminal.DamageModel,
+    Vector3(1, 0, 0)
+  )
+  val applyDamageTo = resolved.damage_model.Calculate(resolved)
+
+  "AutoRepair" should {
+    "not ask for NTU after damage if it expects no NTU" in {
+      assert(terminal.Health == terminal.MaxHealth)
+      terminal.Actor ! BuildingActor.NtuDepleted()
+      terminal.Actor ! Vitality.Damage(applyDamageTo)
+
+      avatarProbe.receiveOne(max = 200 milliseconds) //health update event
+      assert(terminal.Health < terminal.MaxHealth)
+      buildingProbe.expectNoMessage(max = 2000 milliseconds)
+    }
+  }
+}
+
+class AutoRepairRestoreRequestNtuTest extends FreedContextActorTest {
+  val player = Player(Avatar(0, "TestCharacter", PlanetSideEmpire.TR, CharacterGender.Male, 0, CharacterVoice.Mute))
+  player.Spawn()
+  val weapon = new Tool(GlobalDefinitions.suppressor)
+  val terminal = new Terminal(AutoRepairTest.terminal_definition)
+  val guid = new NumberPoolHub(new MaxNumberSource(max = 10))
+  val zone = new Zone("test", new ZoneMap("test"), 0) {
+    override def SetupNumberPools() = {}
+    GUID(guid)
+  }
+  val avatarProbe = new TestProbe(system)
+  zone.AvatarEvents = avatarProbe.ref
+
+  guid.register(player, number = 1)
+  guid.register(weapon, number = 2)
+  guid.register(weapon.AmmoSlot.Box, number = 3)
+  guid.register(terminal, number = 4)
+
+  val building = Building("test-building", 1, 1, zone, StructureType.Facility)
+  building.Invalidate()
+  guid.register(building, number = 6)
+  val buildingProbe = new TestProbe(system)
+  building.Actor = buildingProbe.ref
+  building.Zone = zone
+  terminal.Actor = context.actorOf(Props(classOf[TerminalControl], terminal), name = "test-terminal")
+  terminal.Owner = building
+
+  val wep_fmode  = weapon.FireMode
+  val wep_prof   = wep_fmode.Add
+  val proj       = weapon.Projectile
+  val proj_prof  = proj.asInstanceOf[DamageProfile]
+  val projectile = Projectile(proj, weapon.Definition, wep_fmode, player, Vector3(2, 0, 0), Vector3.Zero)
+  val resolved = ResolvedProjectile(
+    ProjectileResolution.Hit,
+    projectile,
+    SourceEntry(terminal),
+    terminal.DamageModel,
+    Vector3(1, 0, 0)
+  )
+  val applyDamageTo = resolved.damage_model.Calculate(resolved)
+
+  "AutoRepair" should {
+    "ask for NTU after damage if its expectation of NTU is restored" in {
+      assert(terminal.Health == terminal.MaxHealth)
+      terminal.Actor ! BuildingActor.NtuDepleted()
+      terminal.Actor ! Vitality.Damage(applyDamageTo)
+
+      avatarProbe.receiveOne(max = 200 milliseconds) //health update event
+      assert(terminal.Health < terminal.MaxHealth)
+      buildingProbe.expectNoMessage(max = 2000 milliseconds)
+
+      terminal.Actor ! BuildingActor.SuppliedWithNtu()
+      val buildingMsg = buildingProbe.receiveOne(max = 600 milliseconds)
+      assert(buildingMsg match {
+        case BuildingActor.Ntu(NtuCommand.Request(drain, _)) =>
+          drain == terminal.Definition.autoRepair.get.drain
+        case _ =>
+          false
+      })
+    }
+  }
+}
+
+class AutoRepairRepairWithNtuTest extends FreedContextActorTest {
+  val player = Player(Avatar(0, "TestCharacter", PlanetSideEmpire.TR, CharacterGender.Male, 0, CharacterVoice.Mute))
+  player.Spawn()
+  val weapon = new Tool(GlobalDefinitions.suppressor)
+  val terminal = new Terminal(AutoRepairTest.terminal_definition)
+  val guid = new NumberPoolHub(new MaxNumberSource(max = 10))
+  val zone = new Zone("test", new ZoneMap("test"), 0) {
+    override def SetupNumberPools() = {}
+    GUID(guid)
+  }
+  val avatarProbe = new TestProbe(system)
+  zone.AvatarEvents = avatarProbe.ref
+
+  guid.register(player, number = 1)
+  guid.register(weapon, number = 2)
+  guid.register(weapon.AmmoSlot.Box, number = 3)
+  guid.register(terminal, number = 4)
+
+  val building = Building("test-building", 1, 1, zone, StructureType.Facility)
+  building.Invalidate()
+  guid.register(building, number = 6)
+  val buildingProbe = new TestProbe(system)
+  building.Actor = buildingProbe.ref
+  building.Zone = zone
+  terminal.Actor = context.actorOf(Props(classOf[TerminalControl], terminal), name = "test-terminal")
+  terminal.Owner = building
+
+  val wep_fmode  = weapon.FireMode
+  val wep_prof   = wep_fmode.Add
+  val proj       = weapon.Projectile
+  val proj_prof  = proj.asInstanceOf[DamageProfile]
+  val projectile = Projectile(proj, weapon.Definition, wep_fmode, player, Vector3(2, 0, 0), Vector3.Zero)
+  val resolved = ResolvedProjectile(
+    ProjectileResolution.Hit,
+    projectile,
+    SourceEntry(terminal),
+    terminal.DamageModel,
+    Vector3(1, 0, 0)
+  )
+  val applyDamageTo = resolved.damage_model.Calculate(resolved)
+
+  "AutoRepair" should {
+    "repair some of the damage when it receives NTU" in {
+      assert(terminal.Health == terminal.MaxHealth)
+      terminal.Actor ! BuildingActor.NtuDepleted() //don't worry about requests
+      terminal.Actor ! Vitality.Damage(applyDamageTo)
+
+      avatarProbe.receiveOne(max = 200 milliseconds) //health update event
+      assert(terminal.Health < terminal.MaxHealth)
+      val reducedHealth = terminal.Health
+      buildingProbe.expectNoMessage(max = 2000 milliseconds)
+      terminal.Actor ! NtuCommand.Grant(null, 1)
+      avatarProbe.receiveOne(max = 200 milliseconds) //health update event
+      assert(terminal.Health > reducedHealth)
+    }
+  }
+}
+
+class AutoRepairRepairWithNtuUntilDoneTest extends FreedContextActorTest {
+  val player = Player(Avatar(0, "TestCharacter", PlanetSideEmpire.TR, CharacterGender.Male, 0, CharacterVoice.Mute))
+  player.Spawn()
+  val weapon = new Tool(GlobalDefinitions.suppressor)
+  val terminal = new Terminal(AutoRepairTest.terminal_definition)
+  val guid = new NumberPoolHub(new MaxNumberSource(max = 10))
+  val zone = new Zone("test", new ZoneMap("test"), 0) {
+    override def SetupNumberPools() = {}
+    GUID(guid)
+  }
+  val avatarProbe = new TestProbe(system)
+  zone.AvatarEvents = avatarProbe.ref
+
+  guid.register(player, number = 1)
+  guid.register(weapon, number = 2)
+  guid.register(weapon.AmmoSlot.Box, number = 3)
+  guid.register(terminal, number = 4)
+
+  val building = Building("test-building", 1, 1, zone, StructureType.Facility)
+  building.Invalidate()
+  guid.register(building, number = 6)
+  val buildingProbe = new TestProbe(system)
+  building.Actor = buildingProbe.ref
+  building.Zone = zone
+  terminal.Actor = context.actorOf(Props(classOf[TerminalControl], terminal), name = "test-terminal")
+  terminal.Owner = building
+
+  val wep_fmode  = weapon.FireMode
+  val wep_prof   = wep_fmode.Add
+  val proj       = weapon.Projectile
+  val proj_prof  = proj.asInstanceOf[DamageProfile]
+  val projectile = Projectile(proj, weapon.Definition, wep_fmode, player, Vector3(2, 0, 0), Vector3.Zero)
+  val resolved = ResolvedProjectile(
+    ProjectileResolution.Hit,
+    projectile,
+    SourceEntry(terminal),
+    terminal.DamageModel,
+    Vector3(1, 0, 0)
+  )
+  val applyDamageTo = resolved.damage_model.Calculate(resolved)
+
+  "AutoRepair" should {
+    "ask for NTU after damage and repair some of the damage when it receives NTU, until fully-repaired" in {
+      assert(terminal.Health == terminal.MaxHealth)
+      terminal.Actor ! Vitality.Damage(applyDamageTo)
+
+      avatarProbe.receiveOne(max = 200 milliseconds) //health update event
+      assert(terminal.Health < terminal.MaxHealth)
+      var i = 0
+      while(terminal.Health < terminal.MaxHealth && i < 100) {
+        i += 1 //safety counter
+        val buildingMsg = buildingProbe.receiveOne(max = 1000 milliseconds)
+        buildingMsg match {
+          case BuildingActor.Ntu(NtuCommand.Request(_, _)) =>
+            terminal.Actor ! NtuCommand.Grant(null, 1)
+          case _ => ;
+        }
+      }
+      assert(terminal.Health == terminal.MaxHealth)
+    }
+  }
+}
+
+object AutoRepairTest {
+  val terminal_definition = new OrderTerminalDefinition(objId = 612) {
+    Name = "order_terminal"
+    MaxHealth = 500
+    Damageable = true
+    Repairable = true
+    autoRepair = AutoRepairStats(1, 500, 500, 1)
+    RepairIfDestroyed = true
+  }
+}

src/test/scala/objects/DoorTest.scala

@@ -25,22 +25,22 @@ class DoorTest extends Specification {
 
     "starts as closed (false)" in {
       val door = Door(GlobalDefinitions.door)
-      door.Open mustEqual None
+      door.Open.isEmpty mustEqual true
       door.isOpen mustEqual false
     }
 
     "be opened and closed (1; manual)" in {
       val door = Door(GlobalDefinitions.door)
       door.isOpen mustEqual false
-      door.Open mustEqual None
+      door.Open.isEmpty mustEqual true
 
       door.Open = Some(player)
       door.isOpen mustEqual true
-      door.Open mustEqual Some(player)
+      door.Open.contains(player) mustEqual true
 
       door.Open = None
       door.isOpen mustEqual false
-      door.Open mustEqual None
+      door.Open.isEmpty mustEqual true
     }
 
     "be opened and closed (2; toggle)" in {
@@ -58,11 +58,11 @@ class DoorTest extends Specification {
         364
       )
       val door = Door(GlobalDefinitions.door)
-      door.Open mustEqual None
+      door.Open.isEmpty mustEqual true
       door.Use(player, msg)
-      door.Open mustEqual Some(player)
+      door.Open.contains(player) mustEqual true
       door.Use(player, msg)
-      door.Open mustEqual None
+      door.Open.isEmpty mustEqual true
     }
   }
 }
@@ -115,8 +115,7 @@ class DoorControl3Test extends ActorTest {
       assert(door.Open.isEmpty)
 
       door.Actor ! "trash"
-      val reply = receiveOne(Duration.create(500, "ms"))
-      assert(reply.isInstanceOf[Door.NoEvent])
+      expectNoMessage(Duration.create(500, "ms"))
       assert(door.Open.isEmpty)
     }
   }

src/test/scala/objects/GeneratorTest.scala

@@ -4,6 +4,7 @@ package objects
 import akka.actor.{ActorRef, Props}
 import akka.testkit.TestProbe
 import base.ActorTest
+import net.psforever.actors.zone.BuildingActor
 import net.psforever.objects.avatar.Avatar
 import net.psforever.objects.ballistics._
 import net.psforever.objects.{GlobalDefinitions, Player, Tool}
@@ -206,7 +207,7 @@ class GeneratorControlCriticalTest extends ActorTest {
       )
       assert(
         msg_building match {
-          case Building.AmenityStateChange(o) => o eq gen
+          case BuildingActor.AmenityStateChange(o) => o eq gen
           case _                              => false
         }
       )
@@ -268,6 +269,7 @@ class GeneratorControlDestroyedTest extends ActorTest {
     Vector3(1, 0, 0)
   )
   val applyDamageTo = resolved.damage_model.Calculate(resolved)
+  gen.Actor ! BuildingActor.NtuDepleted() //no auto-repair
   expectNoMessage(200 milliseconds)
   //we're not testing that the math is correct
 
@@ -293,12 +295,11 @@ class GeneratorControlDestroyedTest extends ActorTest {
       assert(gen.Condition == PlanetSideGeneratorState.Normal)
 
       avatarProbe.expectNoMessage(9 seconds)
-      buildingProbe.expectNoMessage(50 milliseconds) //no prior messages
       val msg_avatar2  = avatarProbe.receiveN(3, 1000 milliseconds) //see DamageableEntity test file
       val msg_building = buildingProbe.receiveOne(200 milliseconds)
       assert(
         msg_building match {
-          case Building.AmenityStateChange(o) => o eq gen
+          case BuildingActor.AmenityStateChange(o) => o eq gen
           case _                              => false
         }
       )
@@ -399,6 +400,7 @@ class GeneratorControlKillsTest extends ActorTest {
     Vector3(1, 0, 0)
   )
   val applyDamageTo = resolved.damage_model.Calculate(resolved)
+  gen.Actor ! BuildingActor.NtuDepleted() //no auto-repair
   expectNoMessage(200 milliseconds)
   //we're not testing that the math is correct
 
@@ -438,7 +440,7 @@ class GeneratorControlKillsTest extends ActorTest {
       player2Probe.expectNoMessage(200 milliseconds)
       assert(
         msg_building match {
-          case Building.AmenityStateChange(o) => o eq gen
+          case BuildingActor.AmenityStateChange(o) => o eq gen
           case _                              => false
         }
       )
@@ -840,7 +842,7 @@ class GeneratorControlRepairPastRestorePoint extends ActorTest {
       )
       assert(
         msg_building match {
-          case Building.AmenityStateChange(o) => o eq gen
+          case BuildingActor.AmenityStateChange(o) => o eq gen
           case _                              => false
         }
       )

src/test/scala/objects/ResourceSiloTest.scala

@@ -87,12 +87,63 @@ class ResourceSiloControlStartupTest extends ActorTest {
   "Resource silo" should {
     "startup properly" in {
       expectNoMessage(500 milliseconds)
-      system.actorOf(Props(classOf[ResourceSiloControl], obj), "test-silo")
+      system.actorOf(Props(classOf[ResourceSiloControl], obj), "test-silo") ! "startup"
       expectNoMessage(1 seconds)
     }
   }
 }
 
+class ResourceSiloControlStartupMessageNoneTest extends ActorTest {
+  val obj = ResourceSilo()
+  obj.GUID = PlanetSideGUID(1)
+  obj.Actor = system.actorOf(Props(classOf[ResourceSiloControl], obj), "test-silo")
+  val zone = new Zone("nowhere", new ZoneMap("nowhere-map"), 0)
+  val buildingEvents = TestProbe("test-building-events")
+  obj.Owner =
+    new Building("Building", building_guid = 6, map_id = 0, zone, StructureType.Building, GlobalDefinitions.building) {
+      Actor = buildingEvents.ref
+    }
+  obj.Owner.GUID = PlanetSideGUID(6)
+
+  "Resource silo" should {
+    "report if it has no NTU on startup" in {
+      assert(obj.NtuCapacitor == 0)
+      obj.Actor ! "startup"
+      val ownerMsg = buildingEvents.receiveOne(200 milliseconds)
+      assert(ownerMsg match {
+        case BuildingActor.NtuDepleted() => true
+        case _ => false
+      })
+    }
+  }
+}
+
+class ResourceSiloControlStartupMessageSomeTest extends ActorTest {
+  val obj = ResourceSilo()
+  obj.GUID = PlanetSideGUID(1)
+  obj.Actor = system.actorOf(Props(classOf[ResourceSiloControl], obj), "test-silo")
+  val zone = new Zone("nowhere", new ZoneMap("nowhere-map"), 0)
+  val buildingEvents = TestProbe("test-building-events")
+  obj.Owner =
+    new Building("Building", building_guid = 6, map_id = 0, zone, StructureType.Building, GlobalDefinitions.building) {
+      Actor = buildingEvents.ref
+    }
+  obj.Owner.GUID = PlanetSideGUID(6)
+
+  "Resource silo" should {
+    "report if it has any NTU on startup" in {
+      obj.NtuCapacitor = 1
+      assert(obj.NtuCapacitor == 1)
+      obj.Actor ! "startup"
+      val ownerMsg = buildingEvents.receiveOne(200 milliseconds)
+      assert(ownerMsg match {
+        case BuildingActor.SuppliedWithNtu() => true
+        case _ => false
+      })
+    }
+  }
+}
+
 class ResourceSiloControlUseTest extends ActorTest {
   val guid = new NumberPoolHub(new MaxNumberSource(10))
   val map  = new ZoneMap("test")
@@ -109,6 +160,7 @@ class ResourceSiloControlUseTest extends ActorTest {
     StructureType.Building,
     GlobalDefinitions.building
   ) //guid=1
+  building.Actor = TestProbe("building-actor").ref
 
   val obj = ResourceSilo() //guid=2
   obj.Actor = system.actorOf(Props(classOf[ResourceSiloControl], obj), "test-silo")
@@ -151,21 +203,23 @@ class ResourceSiloControlNtuWarningTest extends ActorTest {
   val obj = ResourceSilo()
   obj.GUID = PlanetSideGUID(1)
   obj.Actor = system.actorOf(Props(classOf[ResourceSiloControl], obj), "test-silo")
-  obj.Actor ! "startup"
   val zone = new Zone("nowhere", new ZoneMap("nowhere-map"), 0)
   obj.Owner =
-    new Building("Building", building_guid = 6, map_id = 0, zone, StructureType.Building, GlobalDefinitions.building)
+    new Building("Building", building_guid = 6, map_id = 0, zone, StructureType.Building, GlobalDefinitions.building) {
+      Actor = TestProbe("building-events").ref
+    }
   obj.Owner.GUID = PlanetSideGUID(6)
+
   val zoneEvents = TestProbe("zone-events")
+  zone.AvatarEvents = zoneEvents.ref
+  obj.Actor ! "startup"
 
   "Resource silo" should {
     "announce high ntu" in {
-      zone.AvatarEvents = zoneEvents.ref
       assert(obj.LowNtuWarningOn)
       obj.Actor ! ResourceSilo.LowNtuWarning(false)
 
-      val reply = zoneEvents.receiveOne(500 milliseconds)
-      assert(!obj.LowNtuWarningOn)
+      val reply = zoneEvents.receiveOne(5000 milliseconds)
       assert(reply.isInstanceOf[AvatarServiceMessage])
       assert(reply.asInstanceOf[AvatarServiceMessage].forChannel == "nowhere")
       assert(reply.asInstanceOf[AvatarServiceMessage].actionMessage.isInstanceOf[AvatarAction.PlanetsideAttribute])
@@ -190,6 +244,7 @@ class ResourceSiloControlNtuWarningTest extends ActorTest {
           .asInstanceOf[AvatarAction.PlanetsideAttribute]
           .attribute_value == 0
       )
+      assert(!obj.LowNtuWarningOn)
     }
   }
 }
@@ -198,7 +253,6 @@ class ResourceSiloControlUpdate1Test extends ActorTest {
   val obj = ResourceSilo()
   obj.GUID = PlanetSideGUID(1)
   obj.Actor = system.actorOf(Props(classOf[ResourceSiloControl], obj), "test-silo")
-  obj.Actor ! "startup"
   val zone = new Zone("nowhere", new ZoneMap("nowhere-map"), 0)
   val bldg =
     new Building("Building", building_guid = 6, map_id = 0, zone, StructureType.Building, GlobalDefinitions.building)
@@ -206,12 +260,13 @@ class ResourceSiloControlUpdate1Test extends ActorTest {
   obj.Owner = bldg
   val zoneEvents     = TestProbe("zone-events")
   val buildingEvents = TestProbe("building-events")
+  zone.AvatarEvents = zoneEvents.ref
+  bldg.Actor = buildingEvents.ref
+  obj.Actor ! "startup"
 
   "Resource silo" should {
     "update the charge level and capacitor display (report high ntu, power restored)" in {
-      zone.AvatarEvents = zoneEvents.ref
-      bldg.Actor = buildingEvents.ref
-
+      buildingEvents.receiveOne(500 milliseconds) //message caused by "startup"
       assert(obj.NtuCapacitor == 0)
       assert(obj.CapacitorDisplay == 0)
       assert(obj.LowNtuWarningOn)
@@ -247,7 +302,6 @@ class ResourceSiloControlUpdate2Test extends ActorTest {
   val obj = ResourceSilo()
   obj.GUID = PlanetSideGUID(1)
   obj.Actor = system.actorOf(Props(classOf[ResourceSiloControl], obj), "test-silo")
-  obj.Actor ! "startup"
   val zone = new Zone("nowhere", new ZoneMap("nowhere-map"), 0)
   val bldg =
     new Building("Building", building_guid = 6, map_id = 0, zone, StructureType.Building, GlobalDefinitions.building)
@@ -255,12 +309,13 @@ class ResourceSiloControlUpdate2Test extends ActorTest {
   obj.Owner = bldg
   val zoneEvents     = TestProbe("zone-events")
   val buildingEvents = TestProbe("building-events")
+  zone.AvatarEvents = zoneEvents.ref
+  bldg.Actor = buildingEvents.ref
+  obj.Actor ! "startup"
 
   "Resource silo" should {
     "update the charge level and capacitor display (report good ntu)" in {
-      zone.AvatarEvents = zoneEvents.ref
-      bldg.Actor = buildingEvents.ref
-
+      buildingEvents.receiveOne(500 milliseconds) //message caused by "startup"
       obj.NtuCapacitor = 100
       obj.LowNtuWarningOn = true
       assert(obj.NtuCapacitor == 100)
@@ -333,7 +388,6 @@ class ResourceSiloControlNoUpdateTest extends ActorTest {
   val obj = ResourceSilo()
   obj.GUID = PlanetSideGUID(1)
   obj.Actor = system.actorOf(Props(classOf[ResourceSiloControl], obj), "test-silo")
-  obj.Actor ! "startup"
   val zone = new Zone("nowhere", new ZoneMap("nowhere-map"), 0)
   val bldg =
     new Building("Building", building_guid = 6, map_id = 0, zone, StructureType.Building, GlobalDefinitions.building)
@@ -341,12 +395,13 @@ class ResourceSiloControlNoUpdateTest extends ActorTest {
   obj.Owner = bldg
   val zoneEvents     = TestProbe("zone-events")
   val buildingEvents = TestProbe("building-events")
+  zone.AvatarEvents = zoneEvents.ref
+  bldg.Actor = buildingEvents.ref
+  obj.Actor ! "startup"
 
   "Resource silo" should {
     "update, but not sufficiently to change the capacitor display" in {
-      zone.AvatarEvents = zoneEvents.ref
-      bldg.Actor = buildingEvents.ref
-
+      buildingEvents.receiveOne(500 milliseconds) //message caused by "startup"
       obj.NtuCapacitor = 250
       obj.LowNtuWarningOn = false
       assert(obj.NtuCapacitor == 250)