diff --git a/src/main/scala/net/psforever/actors/session/SessionActor.scala b/src/main/scala/net/psforever/actors/session/SessionActor.scala
index 33e814221..d24b0cee3 100644
--- a/src/main/scala/net/psforever/actors/session/SessionActor.scala
+++ b/src/main/scala/net/psforever/actors/session/SessionActor.scala
@@ -131,15 +131,10 @@ class SessionActor(middlewareActor: typed.ActorRef[MiddlewareActor.Command], con
       startHeartbeat()
 
     case SessionActor.PokeClient =>
-      middlewareActor ! MiddlewareActor.Send(KeepAliveMessage())
+      pokeClient()
 
     case SessionActor.SetMode(newMode) =>
-      if (mode != newMode) {
-        logic.switchFrom(data.session)
-        mode = newMode
-        logic = mode.setup(data)
-      }
-      logic.switchTo(data.session)
+      changeMode(newMode)
 
     case packet =>
       parse(sender())(packet)
@@ -157,6 +152,19 @@ class SessionActor(middlewareActor: typed.ActorRef[MiddlewareActor.Command], con
     )
   }
 
+  private def pokeClient(): Unit = {
+    middlewareActor ! MiddlewareActor.Send(KeepAliveMessage())
+  }
+
+  private def changeMode(newMode: PlayerMode): Unit = {
+    if (mode != newMode) {
+      logic.switchFrom(data.session)
+      mode = newMode
+      logic = mode.setup(data)
+    }
+    logic.switchTo(data.session)
+  }
+
   private def parse(sender: ActorRef): Receive = {
     /* really common messages (very frequently, every life) */
     case packet: PlanetSideGamePacket =>
diff --git a/src/test/scala/objects/DamageableTest.scala b/src/test/scala/objects/DamageableTest.scala
index 42c0fffa7..ce9364c6f 100644
--- a/src/test/scala/objects/DamageableTest.scala
+++ b/src/test/scala/objects/DamageableTest.scala
@@ -31,17 +31,19 @@ import org.specs2.mutable.Specification
 
 import scala.concurrent.duration._
 import net.psforever.objects.avatar.Avatar
+import net.psforever.objects.definition.ProjectileDefinition
 import net.psforever.objects.serverobject.terminals.implant.{ImplantTerminalMech, ImplantTerminalMechControl}
 import net.psforever.objects.sourcing.{PlayerSource, SourceEntry}
 import net.psforever.objects.vital.interaction.DamageInteraction
 import net.psforever.objects.vital.base.DamageResolution
 import net.psforever.objects.vital.projectile.ProjectileReason
+import net.psforever.objects.vital.resolution.ResolutionCalculations.Output
 
 class DamageableTest extends Specification {
-  val player1     = Player(Avatar(0, "TestCharacter1", PlanetSideEmpire.TR, CharacterSex.Male, 0, CharacterVoice.Mute))
-  val pSource     = PlayerSource(player1)
-  val weaponA     = Tool(GlobalDefinitions.phoenix) //decimator
-  val projectileA = weaponA.Projectile
+  val player1: Player = Player(Avatar(0, "TestCharacter1", PlanetSideEmpire.TR, CharacterSex.Male, 0, CharacterVoice.Mute))
+  val pSource: PlayerSource = PlayerSource(player1)
+  val weaponA: Tool = Tool(GlobalDefinitions.phoenix) //decimator
+  val projectileA: ProjectileDefinition = weaponA.Projectile
 
   "Damageable" should {
     "permit damage" in {
@@ -282,16 +284,20 @@ essentially, treat them more as generic entities whose object types are damageab
 see specific object type tests in relation to what those object types does above and beyond that during damage
  */
 class DamageableEntityDamageTest extends ActorTest {
+  val activityProbe: TestProbe = TestProbe()
+  val avatarProbe: TestProbe = TestProbe()
+  val buildingProbe: TestProbe = TestProbe()
   val guid = new NumberPoolHub(new MaxNumberSource(5))
-  val zone = new Zone("test", new ZoneMap("test"), 0) {
-    override def SetupNumberPools() = {}
+  val zone: Zone = new Zone("test", new ZoneMap("test"), 0) {
+    override def SetupNumberPools(): Unit = {}
 
     GUID(guid)
+    override def Activity: ActorRef = activityProbe.ref
+    override def AvatarEvents: ActorRef = avatarProbe.ref
   }
-  val building = Building("test-building", 1, 1, zone, StructureType.Facility) //guid=1
-  val gen      = Generator(GlobalDefinitions.generator)                        //guid=2
-  val player1 =
-    Player(Avatar(0, "TestCharacter1", PlanetSideEmpire.TR, CharacterSex.Male, 0, CharacterVoice.Mute)) //guid=3
+  val building: Building = Building("test-building", 1, 1, zone, StructureType.Facility) //guid=1
+  val gen: Generator = Generator(GlobalDefinitions.generator) //guid=2
+  val player1: Player = Player(Avatar(0, "TestCharacter1", PlanetSideEmpire.TR, CharacterSex.Male, 0, CharacterVoice.Mute)) //guid=3
   guid.register(building, 1)
   guid.register(gen, 2)
   guid.register(player1, 3)
@@ -300,17 +306,11 @@ class DamageableEntityDamageTest extends ActorTest {
   building.Amenities = gen
   gen.Position = Vector3(1, 0, 0)
   gen.Actor = system.actorOf(Props(classOf[GeneratorControl], gen), "generator-control")
-
-  val activityProbe = TestProbe()
-  val avatarProbe   = TestProbe()
-  val buildingProbe = TestProbe()
-  zone.Activity = activityProbe.ref
-  zone.AvatarEvents = avatarProbe.ref
   building.Actor = buildingProbe.ref
 
-  val weapon     = Tool(GlobalDefinitions.phoenix) //decimator
-  val projectile = weapon.Projectile
-  val resolved = DamageInteraction(
+  val weapon: Tool = Tool(GlobalDefinitions.phoenix) //decimator
+  val projectile: ProjectileDefinition = weapon.Projectile
+  val resolved: DamageInteraction = DamageInteraction(
     SourceEntry(gen),
     ProjectileReason(
       DamageResolution.Hit,
@@ -319,14 +319,14 @@ class DamageableEntityDamageTest extends ActorTest {
     ),
     Vector3(1,0,0)
   )
-  val applyDamageTo = resolved.calculate()
+  val applyDamageTo: Output = resolved.calculate()
   expectNoMessage(200 milliseconds)
 
   "DamageableEntity" should {
     "handle taking damage" in {
       gen.Actor ! Vitality.Damage(applyDamageTo)
-      val msg1 = avatarProbe.receiveOne(500 milliseconds)
-      val msg2 = activityProbe.receiveOne(500 milliseconds)
+      val msg1 = avatarProbe.receiveOne(5000 milliseconds)
+      val msg2 = activityProbe.receiveOne(5000 milliseconds)
       msg1 match {
         case AvatarServiceMessage("test", AvatarAction.PlanetsideAttributeToAll(ValidPlanetSideGUID(2), 0, 3600)) => ()
         case _ => assert(false, "DamageableEntity:handle taking damage - player not messaged")
@@ -344,34 +344,34 @@ class DamageableEntityDamageTest extends ActorTest {
 
 class DamageableEntityDestroyedTest extends ActorTest {
   val guid = new NumberPoolHub(new MaxNumberSource(5))
-  val zone = new Zone("test", new ZoneMap("test"), 0) {
-    override def SetupNumberPools() = {}
+  val zone: Zone = new Zone("test", new ZoneMap("test"), 0) {
+    override def SetupNumberPools(): Unit = {}
 
     GUID(guid)
   }
-  val avatarProbe = TestProbe()
+  val avatarProbe: TestProbe = TestProbe()
   zone.AvatarEvents = avatarProbe.ref
-  val activityProbe = TestProbe()
+  val activityProbe: TestProbe = TestProbe()
   zone.Activity = activityProbe.ref
-  val mech = ImplantTerminalMech(GlobalDefinitions.implant_terminal_mech) //guid=2
+  val mech: ImplantTerminalMech = ImplantTerminalMech(GlobalDefinitions.implant_terminal_mech) //guid=2
   mech.Position = Vector3(1, 0, 0)
   mech.Actor = system.actorOf(Props(classOf[ImplantTerminalMechControl], mech), "mech-control")
-  val player1 =
+  val player1: Player =
     Player(Avatar(0, "TestCharacter1", PlanetSideEmpire.TR, CharacterSex.Male, 0, CharacterVoice.Mute)) //guid=3
   player1.Position = Vector3(14, 0, 0)                                                                     //<14m from generator; dies
   player1.Spawn()
-  val building = Building("test-building", 1, 1, zone, StructureType.Facility) //guid=1
+  val building: Building = Building("test-building", 1, 1, zone, StructureType.Facility) //guid=1
   building.Position = Vector3(1, 0, 0)
   building.Zone = zone
   building.Amenities = mech
-  val buildingProbe = TestProbe()
+  val buildingProbe: TestProbe = TestProbe()
   building.Actor = buildingProbe.ref
   guid.register(building, 1)
   guid.register(mech, 2)
   guid.register(player1, 3)
-  val weapon     = Tool(GlobalDefinitions.phoenix) //decimator
-  val projectile = weapon.Projectile
-  val resolved = DamageInteraction(
+  val weapon: Tool = Tool(GlobalDefinitions.phoenix) //decimator
+  val projectile: ProjectileDefinition = weapon.Projectile
+  val resolved: DamageInteraction = DamageInteraction(
     SourceEntry(mech),
     ProjectileReason(
       DamageResolution.Hit,
@@ -388,7 +388,7 @@ class DamageableEntityDestroyedTest extends ActorTest {
     ),
     Vector3(1, 0, 0)
   )
-  val applyDamageTo = resolved.calculate()
+  val applyDamageTo: Output = resolved.calculate()
   expectNoMessage(200 milliseconds)
   //we're not testing that the math is correct
 
@@ -420,14 +420,14 @@ class DamageableEntityDestroyedTest extends ActorTest {
 
 class DamageableEntityNotDestroyTwice extends ActorTest {
   val guid = new NumberPoolHub(new MaxNumberSource(10))
-  val zone = new Zone("test", new ZoneMap("test"), 0) {
-    override def SetupNumberPools() = {}
+  val zone: Zone = new Zone("test", new ZoneMap("test"), 0) {
+    override def SetupNumberPools(): Unit = {}
 
     GUID(guid)
   }
-  val building = Building("test-building", 1, 1, zone, StructureType.Facility) //guid=1
-  val gen      = Generator(GlobalDefinitions.generator)                        //guid=2
-  val player1 =
+  val building: Building = Building("test-building", 1, 1, zone, StructureType.Facility) //guid=1
+  val gen: Generator = Generator(GlobalDefinitions.generator)                        //guid=2
+  val player1: Player =
     Player(Avatar(0, "TestCharacter1", PlanetSideEmpire.TR, CharacterSex.Male, 0, CharacterVoice.Mute)) //guid=3
   player1.Spawn()
   guid.register(building, 1)
@@ -438,16 +438,16 @@ class DamageableEntityNotDestroyTwice extends ActorTest {
   building.Amenities = gen
   gen.Position = Vector3(1, 0, 0)
   gen.Actor = system.actorOf(Props(classOf[GeneratorControl], gen), "generator-control")
-  val activityProbe = TestProbe()
-  val avatarProbe   = TestProbe()
-  val buildingProbe = TestProbe()
+  val activityProbe: TestProbe = TestProbe()
+  val avatarProbe: TestProbe = TestProbe()
+  val buildingProbe: TestProbe = TestProbe()
   zone.Activity = activityProbe.ref
   zone.AvatarEvents = avatarProbe.ref
   building.Actor = buildingProbe.ref
 
-  val weapon     = Tool(GlobalDefinitions.phoenix) //decimator
-  val projectile = weapon.Projectile
-  val resolved = DamageInteraction(
+  val weapon: Tool = Tool(GlobalDefinitions.phoenix) //decimator
+  val projectile: ProjectileDefinition = weapon.Projectile
+  val resolved: DamageInteraction = DamageInteraction(
     SourceEntry(gen),
     ProjectileReason(
       DamageResolution.Hit,
@@ -464,7 +464,7 @@ class DamageableEntityNotDestroyTwice extends ActorTest {
     ),
     Vector3(1, 0, 0)
   )
-  val applyDamageTo = resolved.calculate()
+  val applyDamageTo: Output = resolved.calculate()
   expectNoMessage(200 milliseconds)
   //we're not testing that the math is correct
 
@@ -493,20 +493,20 @@ class DamageableEntityNotDestroyTwice extends ActorTest {
 
 class DamageableAmenityTest extends ActorTest {
   val guid = new NumberPoolHub(new MaxNumberSource(10))
-  val activityProbe = TestProbe()
-  val avatarProbe   = TestProbe()
-  val buildingProbe = TestProbe()
-  val zone = new Zone("test", new ZoneMap("test"), 0) {
-    override def SetupNumberPools() = {}
+  val activityProbe: TestProbe = TestProbe()
+  val avatarProbe: TestProbe = TestProbe()
+  val buildingProbe: TestProbe = TestProbe()
+  val zone: Zone = new Zone("test", new ZoneMap("test"), 0) {
+    override def SetupNumberPools(): Unit = {}
 
     override def AvatarEvents: ActorRef = avatarProbe.ref
     override def Activity: ActorRef = activityProbe.ref
 
     GUID(guid)
   }
-  val building = Building("test-building", 1, 1, zone, StructureType.Facility) //guid=1
-  val term     = Terminal(GlobalDefinitions.order_terminal)                    //guid=2
-  val player1 =
+  val building: Building = Building("test-building", 1, 1, zone, StructureType.Facility) //guid=1
+  val term: Terminal = Terminal(GlobalDefinitions.order_terminal)                    //guid=2
+  val player1: Player =
     Player(Avatar(0, "TestCharacter1", PlanetSideEmpire.TR, CharacterSex.Male, 0, CharacterVoice.Mute)) //guid=3
   player1.Spawn()
   guid.register(building, 1)
@@ -520,9 +520,9 @@ class DamageableAmenityTest extends ActorTest {
   term.Actor = system.actorOf(Props(classOf[TerminalControl], term), "terminal-control")
   building.Actor = buildingProbe.ref
 
-  val weapon     = Tool(GlobalDefinitions.phoenix) //decimator
-  val projectile = weapon.Projectile
-  val resolved = DamageInteraction(
+  val weapon: Tool = Tool(GlobalDefinitions.phoenix) //decimator
+  val projectile: ProjectileDefinition = weapon.Projectile
+  val resolved: DamageInteraction = DamageInteraction(
     SourceEntry(term),
     ProjectileReason(
       DamageResolution.Hit,
@@ -539,7 +539,7 @@ class DamageableAmenityTest extends ActorTest {
     ),
     Vector3(1, 0, 0)
   )
-  val applyDamageTo = resolved.calculate()
+  val applyDamageTo: Output = resolved.calculate()
   expectNoMessage(200 milliseconds)
   //we're not testing that the math is correct
 
@@ -577,19 +577,19 @@ class DamageableAmenityTest extends ActorTest {
 class DamageableMountableDamageTest extends ActorTest {
   //TODO this test with not send HitHint packets because LivePlayers is not being allocated for the players in the zone
   val guid = new NumberPoolHub(new MaxNumberSource(10))
-  val zone = new Zone("test", new ZoneMap("test"), 0) {
-    override def SetupNumberPools() = {}
+  val zone: Zone = new Zone("test", new ZoneMap("test"), 0) {
+    override def SetupNumberPools(): Unit = {}
 
     GUID(guid)
   }
-  val building = Building("test-building", 1, 1, zone, StructureType.Facility) //guid=1
-  val mech     = ImplantTerminalMech(GlobalDefinitions.implant_terminal_mech)  //guid=2
-  val player1 =
-    Player(Avatar(0, "TestCharacter1", PlanetSideEmpire.TR, CharacterSex.Male, 0, CharacterVoice.Mute)) //guid=3
+  val building: Building = Building("test-building", 1, 1, zone, StructureType.Facility) //guid=1
+  val mech: ImplantTerminalMech = ImplantTerminalMech(GlobalDefinitions.implant_terminal_mech)  //guid=2
+  val player1: Player = Player(Avatar(0, "TestCharacter1", PlanetSideEmpire.TR, CharacterSex.Male, 0, CharacterVoice.Mute)) //guid=3
+  player1.Zone = zone
   player1.Spawn()
   player1.Position = Vector3(2, 2, 2)
-  val player2 =
-    Player(Avatar(0, "TestCharacter2", PlanetSideEmpire.NC, CharacterSex.Male, 0, CharacterVoice.Mute)) //guid=4
+  val player2: Player = Player(Avatar(0, "TestCharacter2", PlanetSideEmpire.NC, CharacterSex.Male, 0, CharacterVoice.Mute)) //guid=4
+  player2.Zone = zone
   player2.Spawn()
   guid.register(building, 1)
   guid.register(mech, 2)
@@ -600,16 +600,16 @@ class DamageableMountableDamageTest extends ActorTest {
   building.Amenities = mech
   mech.Position = Vector3(1, 0, 0)
   mech.Actor = system.actorOf(Props(classOf[ImplantTerminalMechControl], mech), "mech-control")
-  val activityProbe = TestProbe()
-  val avatarProbe   = TestProbe()
-  val buildingProbe = TestProbe()
+  val activityProbe: TestProbe = TestProbe()
+  val avatarProbe: TestProbe = TestProbe()
+  val buildingProbe: TestProbe = TestProbe()
   zone.Activity = activityProbe.ref
   zone.AvatarEvents = avatarProbe.ref
   building.Actor = buildingProbe.ref
 
-  val weapon     = Tool(GlobalDefinitions.phoenix) //decimator
-  val projectile = weapon.Projectile
-  val resolved = DamageInteraction(
+  val weapon: Tool = Tool(GlobalDefinitions.phoenix) //decimator
+  val projectile: ProjectileDefinition = weapon.Projectile
+  val resolved: DamageInteraction = DamageInteraction(
     SourceEntry(mech),
     ProjectileReason(
       DamageResolution.Hit,
@@ -626,7 +626,7 @@ class DamageableMountableDamageTest extends ActorTest {
     ),
     Vector3(1, 0, 0)
   )
-  val applyDamageTo = resolved.calculate()
+  val applyDamageTo: Output = resolved.calculate()
   mech.Seats(0).mount(player2)        //mount the player
   player2.VehicleSeated = Some(mech.GUID) //mount the player
   expectNoMessage(200 milliseconds)
@@ -637,8 +637,8 @@ class DamageableMountableDamageTest extends ActorTest {
       assert(mech.Health == mech.Definition.DefaultHealth)
 
       mech.Actor ! Vitality.Damage(applyDamageTo)
-      val msg1_3 = avatarProbe.receiveN(2, 500 milliseconds)
-      val msg2   = activityProbe.receiveOne(500 milliseconds)
+      val msg1_3 = avatarProbe.receiveN(2, 5000 milliseconds)
+      val msg2   = activityProbe.receiveOne(5000 milliseconds)
       assert(
         msg1_3.head match {
           case AvatarServiceMessage("test", AvatarAction.PlanetsideAttributeToAll(PlanetSideGUID(2), 0, _)) => true
@@ -671,25 +671,25 @@ class DamageableMountableDamageTest extends ActorTest {
 class DamageableMountableDestroyTest extends ActorTest {
   //TODO this test with not send HitHint packets because LivePlayers is not being allocated for the players in the zone
   val guid = new NumberPoolHub(new MaxNumberSource(10))
-  val zone = new Zone("test", new ZoneMap("test"), 0) {
-    override def SetupNumberPools() = {}
+  val zone: Zone = new Zone("test", new ZoneMap("test"), 0) {
+    override def SetupNumberPools(): Unit = {}
 
     GUID(guid)
   }
-  val building = Building("test-building", 1, 1, zone, StructureType.Facility) //guid=1
-  val mech     = ImplantTerminalMech(GlobalDefinitions.implant_terminal_mech)  //guid=2
-  val player1 = Player(Avatar(0, "TestCharacter1", PlanetSideEmpire.TR, CharacterSex.Male, 0, CharacterVoice.Mute)) //guid=3
+  val building: Building = Building("test-building", 1, 1, zone, StructureType.Facility) //guid=1
+  val mech: ImplantTerminalMech = ImplantTerminalMech(GlobalDefinitions.implant_terminal_mech)  //guid=2
+  val player1: Player = Player(Avatar(0, "TestCharacter1", PlanetSideEmpire.TR, CharacterSex.Male, 0, CharacterVoice.Mute)) //guid=3
   mech.Zone = zone
   player1.Spawn()
   player1.Zone = zone
   player1.Position = Vector3(2, 2, 2)
-  val player1Probe = TestProbe()
+  val player1Probe: TestProbe = TestProbe()
   player1.Actor = player1Probe.ref
-  val player2 =
+  val player2: Player =
     Player(Avatar(0, "TestCharacter2", PlanetSideEmpire.NC, CharacterSex.Male, 0, CharacterVoice.Mute)) //guid=4
   player2.Spawn()
   player2.Zone = zone
-  val player2Probe = TestProbe()
+  val player2Probe: TestProbe = TestProbe()
   player2.Actor = player2Probe.ref
   guid.register(building, 1)
   guid.register(mech, 2)
@@ -700,16 +700,16 @@ class DamageableMountableDestroyTest extends ActorTest {
   building.Amenities = mech
   mech.Position = Vector3(1, 0, 0)
   mech.Actor = system.actorOf(Props(classOf[ImplantTerminalMechControl], mech), "mech-control")
-  val activityProbe = TestProbe()
-  val avatarProbe   = TestProbe()
-  val buildingProbe = TestProbe()
+  val activityProbe: TestProbe = TestProbe()
+  val avatarProbe: TestProbe = TestProbe()
+  val buildingProbe: TestProbe = TestProbe()
   zone.actor = ActorTestKit().createTestProbe[ZoneActor.Command]().ref
   zone.Activity = activityProbe.ref
   zone.AvatarEvents = avatarProbe.ref
   building.Actor = buildingProbe.ref
-  val weapon     = Tool(GlobalDefinitions.phoenix) //decimator
-  val projectile = weapon.Projectile
-  val resolved = DamageInteraction(
+  val weapon: Tool = Tool(GlobalDefinitions.phoenix) //decimator
+  val projectile: ProjectileDefinition = weapon.Projectile
+  val resolved: DamageInteraction = DamageInteraction(
     SourceEntry(mech),
     ProjectileReason(
       DamageResolution.Hit,
@@ -726,7 +726,7 @@ class DamageableMountableDestroyTest extends ActorTest {
     ),
     Vector3(1, 0, 0)
   )
-  val applyDamageTo = resolved.calculate()
+  val applyDamageTo: Output = resolved.calculate()
   mech.Seats(0).mount(player2)        //mount the player
   player2.VehicleSeated = Some(mech.GUID) //mount the player
   expectNoMessage(200 milliseconds)
@@ -752,8 +752,8 @@ class DamageableMountableDestroyTest extends ActorTest {
         case _                                                                                             => assert(false)
       }
       msg3 match {
-        case Player.Die(_) => true
-        case _            => assert(false)
+        case Player.Die(_) => ()
+        case _             => assert(false)
       }
       assert(mech.Health <= mech.Definition.DamageDestroysAt)
       assert(mech.Destroyed)
@@ -763,13 +763,13 @@ class DamageableMountableDestroyTest extends ActorTest {
 
 class DamageableWeaponTurretDamageTest extends ActorTest {
   val guid = new NumberPoolHub(new MaxNumberSource(10))
-  val zone = new Zone("test", new ZoneMap("test"), 0) {
-    override def SetupNumberPools() = {}
+  val zone: Zone = new Zone("test", new ZoneMap("test"), 0) {
+    override def SetupNumberPools(): Unit = {}
     GUID(guid)
   }
-  val activityProbe = TestProbe()
-  val avatarProbe   = TestProbe()
-  val vehicleProbe   = TestProbe()
+  val activityProbe: TestProbe = TestProbe()
+  val avatarProbe: TestProbe = TestProbe()
+  val vehicleProbe: TestProbe = TestProbe()
   zone.actor = ActorTestKit().createTestProbe[ZoneActor.Command]().ref
   zone.Activity = activityProbe.ref
   zone.AvatarEvents = avatarProbe.ref
@@ -779,17 +779,17 @@ class DamageableWeaponTurretDamageTest extends ActorTest {
   turret.Zone = zone
   turret.Position = Vector3(1, 0, 0)
   turret.LogActivity(SpawningActivity(SourceEntry(turret), zone.Number, None)) //seed a spawn event
-  val tSource = SourceEntry(turret)
-  val player1 =
+  val tSource: SourceEntry = SourceEntry(turret)
+  val player1: Player =
     Player(Avatar(0, "TestCharacter1", PlanetSideEmpire.TR, CharacterSex.Male, 0, CharacterVoice.Mute)) //guid=3
   player1.Spawn()
   player1.Position = Vector3(2, 2, 2)
-  val player1Probe = TestProbe()
+  val player1Probe: TestProbe = TestProbe()
   player1.Actor = player1Probe.ref
-  val player2 =
+  val player2: Player =
     Player(Avatar(0, "TestCharacter2", PlanetSideEmpire.NC, CharacterSex.Male, 0, CharacterVoice.Mute)) //guid=4
   player2.Spawn()
-  val player2Probe = TestProbe()
+  val player2Probe: TestProbe = TestProbe()
   player2.Actor = player2Probe.ref
   guid.register(turret, 2)
   guid.register(player1, 3)
@@ -797,10 +797,10 @@ class DamageableWeaponTurretDamageTest extends ActorTest {
   turret.Seats(0).mount(player2)
   player2.VehicleSeated = turret.GUID
 
-  val weapon       = Tool(GlobalDefinitions.suppressor)
-  val projectile   = weapon.Projectile
-  val pSource = PlayerSource(player1)
-  val resolved = DamageInteraction(
+  val weapon: Tool = Tool(GlobalDefinitions.suppressor)
+  val projectile: ProjectileDefinition = weapon.Projectile
+  val pSource: PlayerSource = PlayerSource(player1)
+  val resolved: DamageInteraction = DamageInteraction(
     tSource,
     ProjectileReason(
       DamageResolution.Hit,
@@ -817,7 +817,7 @@ class DamageableWeaponTurretDamageTest extends ActorTest {
     ),
     Vector3(1, 0, 0)
   )
-  val applyDamageTo = resolved.calculate()
+  val applyDamageTo: Output = resolved.calculate()
   expectNoMessage(200 milliseconds)
   //we're not testing that the math is correct
 
@@ -861,13 +861,13 @@ class DamageableWeaponTurretDamageTest extends ActorTest {
 
 class DamageableWeaponTurretJammerTest extends ActorTest {
   val guid = new NumberPoolHub(new MaxNumberSource(10))
-  val zone = new Zone("test", new ZoneMap("test"), 0) {
-    override def SetupNumberPools() = {}
+  val zone: Zone = new Zone("test", new ZoneMap("test"), 0) {
+    override def SetupNumberPools(): Unit = {}
     GUID(guid)
   }
-  val activityProbe = TestProbe()
-  val avatarProbe   = TestProbe()
-  val vehicleProbe  = TestProbe()
+  val activityProbe: TestProbe = TestProbe()
+  val avatarProbe: TestProbe = TestProbe()
+  val vehicleProbe: TestProbe = TestProbe()
   zone.Activity = activityProbe.ref
   zone.AvatarEvents = avatarProbe.ref
   zone.VehicleEvents = vehicleProbe.ref
@@ -876,18 +876,18 @@ class DamageableWeaponTurretJammerTest extends ActorTest {
   turret.Actor = system.actorOf(Props(classOf[TurretControl], turret), "turret-control")
   turret.Zone = zone
   turret.Position = Vector3(1, 0, 0)
-  val turretWeapon = turret.Weapons.values.head.Equipment.get.asInstanceOf[Tool]
+  val turretWeapon: Tool = turret.Weapons.values.head.Equipment.get.asInstanceOf[Tool]
 
-  val player1 =
+  val player1: Player =
     Player(Avatar(0, "TestCharacter1", PlanetSideEmpire.TR, CharacterSex.Male, 0, CharacterVoice.Mute)) //guid=3
   player1.Spawn()
   player1.Position = Vector3(2, 2, 2)
-  val player1Probe = TestProbe()
+  val player1Probe: TestProbe = TestProbe()
   player1.Actor = player1Probe.ref
-  val player2 =
+  val player2: Player =
     Player(Avatar(0, "TestCharacter2", PlanetSideEmpire.NC, CharacterSex.Male, 0, CharacterVoice.Mute)) //guid=4
   player2.Spawn()
-  val player2Probe = TestProbe()
+  val player2Probe: TestProbe = TestProbe()
   player2.Actor = player2Probe.ref
 
   guid.register(turret, 2)
@@ -898,10 +898,10 @@ class DamageableWeaponTurretJammerTest extends ActorTest {
   turret.Seats(0).mount(player2)
   player2.VehicleSeated = turret.GUID
 
-  val weapon       = Tool(GlobalDefinitions.jammer_grenade)
-  val projectile   = weapon.Projectile
-  val turretSource = SourceEntry(turret)
-  val resolved = DamageInteraction(
+  val weapon: Tool = Tool(GlobalDefinitions.jammer_grenade)
+  val projectile: ProjectileDefinition = weapon.Projectile
+  val turretSource: SourceEntry = SourceEntry(turret)
+  val resolved: DamageInteraction = DamageInteraction(
     turretSource,
     ProjectileReason(
       DamageResolution.Hit,
@@ -918,7 +918,7 @@ class DamageableWeaponTurretJammerTest extends ActorTest {
     ),
     Vector3(1, 0, 0)
   )
-  val applyDamageTo = resolved.calculate()
+  val applyDamageTo: Output = resolved.calculate()
   expectNoMessage(200 milliseconds)
   //we're not testing that the math is correct
 
@@ -958,15 +958,15 @@ class DamageableWeaponTurretJammerTest extends ActorTest {
 
 class DamageableWeaponTurretDestructionTest extends ActorTest {
   val guid = new NumberPoolHub(new MaxNumberSource(10))
-  val zone = new Zone("test", new ZoneMap("test"), 0) {
-    override def SetupNumberPools() = {}
+  val zone: Zone = new Zone("test", new ZoneMap("test"), 0) {
+    override def SetupNumberPools(): Unit = {}
     GUID(guid)
   }
-  val building      = Building("test-building", 1, 1, zone, StructureType.Facility) //guid=1
-  val activityProbe = TestProbe()
-  val avatarProbe   = TestProbe()
-  val vehicleProbe  = TestProbe()
-  val buildingProbe = TestProbe()
+  val building: Building = Building("test-building", 1, 1, zone, StructureType.Facility) //guid=1
+  val activityProbe: TestProbe = TestProbe()
+  val avatarProbe: TestProbe = TestProbe()
+  val vehicleProbe: TestProbe = TestProbe()
+  val buildingProbe: TestProbe = TestProbe()
   zone.actor = ActorTestKit().createTestProbe[ZoneActor.Command]().ref
   zone.Activity = activityProbe.ref
   zone.AvatarEvents = avatarProbe.ref
@@ -977,18 +977,18 @@ class DamageableWeaponTurretDestructionTest extends ActorTest {
   turret.Actor = system.actorOf(Props(classOf[FacilityTurretControl], turret), "turret-control")
   turret.Zone = zone
   turret.Position = Vector3(1, 0, 0)
-  val turretWeapon = turret.Weapons.values.head.Equipment.get.asInstanceOf[Tool]
+  val turretWeapon: Tool = turret.Weapons.values.head.Equipment.get.asInstanceOf[Tool]
 
-  val player1 =
+  val player1: Player =
     Player(Avatar(0, "TestCharacter1", PlanetSideEmpire.TR, CharacterSex.Male, 0, CharacterVoice.Mute)) //guid=3
   player1.Spawn()
   player1.Position = Vector3(2, 2, 2)
-  val player1Probe = TestProbe()
+  val player1Probe: TestProbe = TestProbe()
   player1.Actor = player1Probe.ref
-  val player2 =
+  val player2: Player =
     Player(Avatar(1, "TestCharacter2", PlanetSideEmpire.NC, CharacterSex.Male, 0, CharacterVoice.Mute)) //guid=4
   player2.Spawn()
-  val player2Probe = TestProbe()
+  val player2Probe: TestProbe = TestProbe()
   player2.Actor = player2Probe.ref
 
   guid.register(building, 1)
@@ -1003,11 +1003,11 @@ class DamageableWeaponTurretDestructionTest extends ActorTest {
   building.Zone = zone
   building.Amenities = turret
 
-  val turretSource = SourceEntry(turret)
+  val turretSource: SourceEntry = SourceEntry(turret)
   //turret.History(EntitySpawn(turretSource, zone)) //seed a spawn event
-  val weaponA      = Tool(GlobalDefinitions.jammer_grenade)
-  val projectileA  = weaponA.Projectile
-  val resolvedA = DamageInteraction(
+  val weaponA: Tool = Tool(GlobalDefinitions.jammer_grenade)
+  val projectileA: ProjectileDefinition = weaponA.Projectile
+  val resolvedA: DamageInteraction = DamageInteraction(
     turretSource,
     ProjectileReason(
       DamageResolution.Hit,
@@ -1024,11 +1024,11 @@ class DamageableWeaponTurretDestructionTest extends ActorTest {
     ),
     Vector3(1, 0, 0)
   )
-  val applyDamageToA = resolvedA.calculate()
+  val applyDamageToA: Output = resolvedA.calculate()
 
-  val weaponB     = Tool(GlobalDefinitions.phoenix) //decimator
-  val projectileB = weaponB.Projectile
-  val resolvedB = DamageInteraction(
+  val weaponB: Tool = Tool(GlobalDefinitions.phoenix) //decimator
+  val projectileB: ProjectileDefinition = weaponB.Projectile
+  val resolvedB: DamageInteraction = DamageInteraction(
 
     turretSource,
     ProjectileReason(
@@ -1046,7 +1046,7 @@ class DamageableWeaponTurretDestructionTest extends ActorTest {
     ),
     Vector3(1, 0, 0)
   )
-  val applyDamageToB = resolvedB.calculate()
+  val applyDamageToB: Output = resolvedB.calculate()
   expectNoMessage(200 milliseconds)
   //we're not testing that the math is correct
 
@@ -1080,7 +1080,7 @@ class DamageableWeaponTurretDestructionTest extends ActorTest {
           assert(false, s"DamageableWeaponTurretDestructionTest-2: ${msg12_4(1)}")
       }
       msg3 match {
-        case Player.Die(_) => true
+        case Player.Die(_) => ()
         case _ =>
           assert(false, s"DamageableWeaponTurretDestructionTest-3: player not dead - $msg3")
       }
@@ -1095,10 +1095,8 @@ class DamageableWeaponTurretDestructionTest extends ActorTest {
           assert(false, s"DamageableWeaponTurretDestructionTest-5: ${msg56.head}")
       }
       msg56(1) match {
-        case VehicleServiceMessage.TurretUpgrade(TurretUpgrader.AddTask(t, _, TurretUpgrade.None, _)) if t eq turret => ;
-          true
-        case _ =>
-          assert(false, s"DamageableWeaponTurretDestructionTest-6: ${msg56(1)}")
+        case VehicleServiceMessage.TurretUpgrade(TurretUpgrader.AddTask(t, _, TurretUpgrade.None, _)) if t eq turret => ()
+        case _ => assert(false, s"DamageableWeaponTurretDestructionTest-6: ${msg56(1)}")
       }
       assert(turret.Health <= turret.Definition.DamageDestroysAt)
       assert(!turret.Jammed)
@@ -1109,33 +1107,33 @@ class DamageableWeaponTurretDestructionTest extends ActorTest {
 
 class DamageableVehicleDamageTest extends ActorTest {
   val guid = new NumberPoolHub(new MaxNumberSource(10))
-  val zone = new Zone("test", new ZoneMap("test"), 0) {
-    override def SetupNumberPools() = {}
+  val zone: Zone = new Zone("test", new ZoneMap("test"), 0) {
+    override def SetupNumberPools(): Unit = {}
     GUID(guid)
   }
-  val activityProbe = TestProbe()
-  val avatarProbe   = TestProbe()
-  val vehicleProbe  = TestProbe()
+  val activityProbe: TestProbe = TestProbe()
+  val avatarProbe: TestProbe = TestProbe()
+  val vehicleProbe: TestProbe = TestProbe()
   zone.actor = ActorTestKit().createTestProbe[ZoneActor.Command]().ref
   zone.Activity = activityProbe.ref
   zone.AvatarEvents = avatarProbe.ref
   zone.VehicleEvents = vehicleProbe.ref
 
-  val atv = Vehicle(GlobalDefinitions.quadstealth) //guid=1
+  val atv: Vehicle = Vehicle(GlobalDefinitions.quadstealth) //guid=1
   atv.Actor = system.actorOf(Props(classOf[VehicleControl], atv), "vehicle-control")
   atv.Position = Vector3(1, 0, 0)
   //atv.History(EntitySpawn(turretSource, zone)) //seed a spawn event
 
-  val player1 =
+  val player1: Player =
     Player(Avatar(0, "TestCharacter1", PlanetSideEmpire.TR, CharacterSex.Male, 0, CharacterVoice.Mute)) //guid=2
   player1.Spawn()
   player1.Position = Vector3(2, 0, 0)
-  val player1Probe = TestProbe()
+  val player1Probe: TestProbe = TestProbe()
   player1.Actor = player1Probe.ref
-  val player2 =
+  val player2: Player =
     Player(Avatar(0, "TestCharacter2", PlanetSideEmpire.NC, CharacterSex.Male, 0, CharacterVoice.Mute)) //guid=3
   player2.Spawn()
-  val player2Probe = TestProbe()
+  val player2Probe: TestProbe = TestProbe()
   player2.Actor = player2Probe.ref
 
   guid.register(atv, 1)
@@ -1145,11 +1143,11 @@ class DamageableVehicleDamageTest extends ActorTest {
   atv.Seats(0).mount(player2)
   player2.VehicleSeated = atv.GUID
 
-  val weapon        = Tool(GlobalDefinitions.suppressor)
-  val projectile    = weapon.Projectile
-  val pSource = PlayerSource(player1)
-  val vehicleSource = SourceEntry(atv)
-  val resolved = DamageInteraction(
+  val weapon: Tool = Tool(GlobalDefinitions.suppressor)
+  val projectile: ProjectileDefinition = weapon.Projectile
+  val pSource: PlayerSource = PlayerSource(player1)
+  val vehicleSource: SourceEntry = SourceEntry(atv)
+  val resolved: DamageInteraction = DamageInteraction(
     vehicleSource,
     ProjectileReason(
       DamageResolution.Hit,
@@ -1166,7 +1164,7 @@ class DamageableVehicleDamageTest extends ActorTest {
     ),
     Vector3(1, 0, 0)
   )
-  val applyDamageTo = resolved.calculate()
+  val applyDamageTo: Output = resolved.calculate()
   expectNoMessage(200 milliseconds)
   //we're not testing that the math is correct
 
@@ -1219,13 +1217,13 @@ class DamageableVehicleDamageTest extends ActorTest {
 
 class DamageableVehicleDamageMountedTest extends FreedContextActorTest {
   val guid = new NumberPoolHub(new MaxNumberSource(15))
-  val zone = new Zone("test", new ZoneMap("test"), 0) {
-    override def SetupNumberPools() = {}
+  val zone: Zone = new Zone("test", new ZoneMap("test"), 0) {
+    override def SetupNumberPools(): Unit = {}
     GUID(guid)
   }
-  val activityProbe = TestProbe()
-  val avatarProbe   = TestProbe()
-  val vehicleProbe  = TestProbe()
+  val activityProbe: TestProbe = TestProbe()
+  val avatarProbe: TestProbe = TestProbe()
+  val vehicleProbe: TestProbe = TestProbe()
   zone.actor = ActorTestKit().createTestProbe[ZoneActor.Command]().ref
   zone.Activity = activityProbe.ref
   zone.AvatarEvents = avatarProbe.ref
@@ -1233,28 +1231,28 @@ class DamageableVehicleDamageMountedTest extends FreedContextActorTest {
   import akka.actor.typed.scaladsl.adapter._
   zone.actor = new TestProbe(system).ref.toTyped[ZoneActor.Command]
 
-  val lodestar = Vehicle(GlobalDefinitions.lodestar) //guid=1 & 4,5,6,7,8,9
+  val lodestar: Vehicle = Vehicle(GlobalDefinitions.lodestar) //guid=1 & 4,5,6,7,8,9
   lodestar.Position = Vector3(1, 0, 0)
   //lodestar.History(EntitySpawn(VehicleSource(lodestar), zone)) //seed a spawn event
-  val atv = Vehicle(GlobalDefinitions.quadstealth) //guid=11
+  val atv: Vehicle = Vehicle(GlobalDefinitions.quadstealth) //guid=11
   atv.Position = Vector3(1, 0, 0)
   atv.Actor = system.actorOf(Props(classOf[VehicleControl], atv), "atv-control")
 
-  val player1 =
+  val player1: Player =
     Player(Avatar(0, "TestCharacter1", PlanetSideEmpire.TR, CharacterSex.Male, 0, CharacterVoice.Mute)) //guid=2
   player1.Spawn()
   player1.Position = Vector3(2, 0, 0)
-  val player1Probe = TestProbe()
+  val player1Probe: TestProbe = TestProbe()
   player1.Actor = player1Probe.ref
-  val player2 =
+  val player2: Player =
     Player(Avatar(0, "TestCharacter2", PlanetSideEmpire.NC, CharacterSex.Male, 0, CharacterVoice.Mute)) //guid=3
   player2.Spawn()
-  val player2Probe = TestProbe()
+  val player2Probe: TestProbe = TestProbe()
   player2.Actor = player2Probe.ref
-  val player3 =
+  val player3: Player =
     Player(Avatar(0, "TestCharacter3", PlanetSideEmpire.NC, CharacterSex.Male, 0, CharacterVoice.Mute)) //guid=10
   player3.Spawn()
-  val player3Probe = TestProbe()
+  val player3Probe: TestProbe = TestProbe()
   player3.Actor = player3Probe.ref
 
   guid.register(lodestar, 1)
@@ -1280,11 +1278,11 @@ class DamageableVehicleDamageMountedTest extends FreedContextActorTest {
   lodestar.CargoHolds(1).mount(atv)
   atv.MountedIn = lodestar.GUID
 
-  val weapon        = Tool(GlobalDefinitions.phoenix) //decimator
-  val projectile    = weapon.Projectile
-  val pSource = PlayerSource(player1)
-  val vSource = SourceEntry(lodestar)
-  val resolved = DamageInteraction(
+  val weapon: Tool = Tool(GlobalDefinitions.phoenix) //decimator
+  val projectile: ProjectileDefinition = weapon.Projectile
+  val pSource: PlayerSource = PlayerSource(player1)
+  val vSource: SourceEntry = SourceEntry(lodestar)
+  val resolved: DamageInteraction = DamageInteraction(
     vSource,
     ProjectileReason(
       DamageResolution.Hit,
@@ -1301,7 +1299,7 @@ class DamageableVehicleDamageMountedTest extends FreedContextActorTest {
     ),
     Vector3(1, 0, 0)
   )
-  val applyDamageTo = resolved.calculate()
+  val applyDamageTo: Output = resolved.calculate()
   expectNoMessage(200 milliseconds)
   //we're not testing that the math is correct
 
@@ -1355,40 +1353,40 @@ class DamageableVehicleDamageMountedTest extends FreedContextActorTest {
 
 class DamageableVehicleJammeringMountedTest extends FreedContextActorTest {
   val guid = new NumberPoolHub(new MaxNumberSource(15))
-  val zone = new Zone("test", new ZoneMap("test"), 0) {
-    override def SetupNumberPools() = {}
+  val zone: Zone = new Zone("test", new ZoneMap("test"), 0) {
+    override def SetupNumberPools(): Unit = {}
     GUID(guid)
   }
-  val activityProbe = TestProbe()
-  val avatarProbe   = TestProbe()
-  val vehicleProbe  = TestProbe()
+  val activityProbe: TestProbe = TestProbe()
+  val avatarProbe: TestProbe = TestProbe()
+  val vehicleProbe: TestProbe = TestProbe()
   zone.Activity = activityProbe.ref
   zone.AvatarEvents = avatarProbe.ref
   zone.VehicleEvents = vehicleProbe.ref
 
-  val atv = Vehicle(GlobalDefinitions.quadassault) //guid=1
+  val atv: Vehicle = Vehicle(GlobalDefinitions.quadassault) //guid=1
   atv.Actor = system.actorOf(Props(classOf[VehicleControl], atv), "atv-control")
   atv.Position = Vector3(1, 0, 0)
-  val atvWeapon = atv.Weapons(1).Equipment.get.asInstanceOf[Tool] //guid=4 & 5
+  val atvWeapon: Tool = atv.Weapons(1).Equipment.get.asInstanceOf[Tool] //guid=4 & 5
 
-  val lodestar = Vehicle(GlobalDefinitions.lodestar) //guid=6
+  val lodestar: Vehicle = Vehicle(GlobalDefinitions.lodestar) //guid=6
   lodestar.Position = Vector3(1, 0, 0)
 
-  val player1 =
+  val player1: Player =
     Player(Avatar(0, "TestCharacter1", PlanetSideEmpire.TR, CharacterSex.Male, 0, CharacterVoice.Mute)) //guid=7
   player1.Spawn()
   player1.Position = Vector3(2, 0, 0)
-  val player1Probe = TestProbe()
+  val player1Probe: TestProbe = TestProbe()
   player1.Actor = player1Probe.ref
-  val player2 =
+  val player2: Player =
     Player(Avatar(0, "TestCharacter2", PlanetSideEmpire.NC, CharacterSex.Male, 0, CharacterVoice.Mute)) //guid=8
   player2.Spawn()
-  val player2Probe = TestProbe()
+  val player2Probe: TestProbe = TestProbe()
   player2.Actor = player2Probe.ref
-  val player3 =
+  val player3: Player =
     Player(Avatar(0, "TestCharacter3", PlanetSideEmpire.NC, CharacterSex.Male, 0, CharacterVoice.Mute)) //guid=9
   player3.Spawn()
-  val player3Probe = TestProbe()
+  val player3Probe: TestProbe = TestProbe()
   player3.Actor = player3Probe.ref
 
   guid.register(atv, 1)
@@ -1415,10 +1413,10 @@ class DamageableVehicleJammeringMountedTest extends FreedContextActorTest {
   lodestar.CargoHolds(1).mount(atv)
   atv.MountedIn = lodestar.GUID
 
-  val vehicleSource = SourceEntry(lodestar)
-  val weapon        = Tool(GlobalDefinitions.jammer_grenade)
-  val projectile    = weapon.Projectile
-  val resolved = DamageInteraction(
+  val vehicleSource: SourceEntry = SourceEntry(lodestar)
+  val weapon: Tool = Tool(GlobalDefinitions.jammer_grenade)
+  val projectile: ProjectileDefinition = weapon.Projectile
+  val resolved: DamageInteraction = DamageInteraction(
     vehicleSource,
     ProjectileReason(
       DamageResolution.Hit,
@@ -1435,7 +1433,7 @@ class DamageableVehicleJammeringMountedTest extends FreedContextActorTest {
     ),
     Vector3(1, 0, 0)
   )
-  val applyDamageTo = resolved.calculate()
+  val applyDamageTo: Output = resolved.calculate()
   expectNoMessage(200 milliseconds)
   //we're not testing that the math is correct
 
@@ -1469,37 +1467,37 @@ class DamageableVehicleJammeringMountedTest extends FreedContextActorTest {
 }
 
 class DamageableVehicleDestroyTest extends ActorTest {
-  val activityProbe = TestProbe()
-  val avatarProbe   = TestProbe()
-  val vehicleProbe  = TestProbe()
+  val activityProbe: TestProbe = TestProbe()
+  val avatarProbe: TestProbe = TestProbe()
+  val vehicleProbe: TestProbe = TestProbe()
   val guid = new NumberPoolHub(new MaxNumberSource(10))
-  val zone = new Zone("test", new ZoneMap("test"), 0) {
-    override def SetupNumberPools() = {}
-    override def Activity = activityProbe.ref
-    override def AvatarEvents = avatarProbe.ref
-    override def VehicleEvents = vehicleProbe.ref
+  val zone: Zone = new Zone("test", new ZoneMap("test"), 0) {
+    override def SetupNumberPools(): Unit = {}
+    override def Activity: ActorRef = activityProbe.ref
+    override def AvatarEvents: ActorRef = avatarProbe.ref
+    override def VehicleEvents: ActorRef = vehicleProbe.ref
 
     GUID(guid)
   }
   zone.actor = ActorTestKit().createTestProbe[ZoneActor.Command]().ref
 
-  val atv = Vehicle(GlobalDefinitions.quadassault) //guid=1
+  val atv: Vehicle = Vehicle(GlobalDefinitions.quadassault) //guid=1
   atv.Actor = system.actorOf(Props(classOf[VehicleControl], atv), "vehicle-control")
   atv.Zone = zone
   atv.Position = Vector3(1, 0, 0)
-  val atvWeapon = atv.Weapons(1).Equipment.get.asInstanceOf[Tool] //guid=4 & 5
+  val atvWeapon: Tool = atv.Weapons(1).Equipment.get.asInstanceOf[Tool] //guid=4 & 5
 
-  val player1 =
+  val player1: Player =
     Player(Avatar(0, "TestCharacter1", PlanetSideEmpire.TR, CharacterSex.Male, 0, CharacterVoice.Mute)) //guid=2
   player1.Spawn()
   player1.Zone = zone
   player1.Position = Vector3(2, 0, 0)
-  val player1Probe = TestProbe()
+  val player1Probe: TestProbe = TestProbe()
   player1.Actor = player1Probe.ref
-  val player2 =
+  val player2: Player =
     Player(Avatar(0, "TestCharacter2", PlanetSideEmpire.NC, CharacterSex.Male, 0, CharacterVoice.Mute)) //guid=3
   player2.Spawn()
-  val player2Probe = TestProbe()
+  val player2Probe: TestProbe = TestProbe()
   player2.Zone = zone
   player2.Actor = player2Probe.ref
 
@@ -1511,10 +1509,10 @@ class DamageableVehicleDestroyTest extends ActorTest {
   atv.Seats(0).mount(player2)
   player2.VehicleSeated = atv.GUID
 
-  val weapon        = Tool(GlobalDefinitions.suppressor)
-  val projectile    = weapon.Projectile
-  val vehicleSource = SourceEntry(atv)
-  val resolved = DamageInteraction(
+  val weapon: Tool = Tool(GlobalDefinitions.suppressor)
+  val projectile: ProjectileDefinition = weapon.Projectile
+  val vehicleSource: SourceEntry = SourceEntry(atv)
+  val resolved: DamageInteraction = DamageInteraction(
     vehicleSource,
     ProjectileReason(
       DamageResolution.Hit,
@@ -1531,7 +1529,7 @@ class DamageableVehicleDestroyTest extends ActorTest {
     ),
     Vector3(1, 0, 0)
   )
-  val applyDamageTo = resolved.calculate()
+  val applyDamageTo: Output = resolved.calculate()
   expectNoMessage(200 milliseconds)
   //we're not testing that the math is correct
 
@@ -1558,10 +1556,6 @@ class DamageableVehicleDestroyTest extends ActorTest {
         case Player.Die(_) => ()
         case _             => assert(false)
       }
-//      msg124(2) match {
-//        case AvatarServiceMessage("test", AvatarAction.ObjectDelete(PlanetSideGUID(0), PlanetSideGUID(4), _)) => ()
-//        case _                                                                                                => assert(false)
-//      }
       assert(atv.Health <= atv.Definition.DamageDestroysAt)
       assert(atv.Destroyed)
       //
diff --git a/src/test/scala/objects/DeployableTest.scala b/src/test/scala/objects/DeployableTest.scala
index 27f8ff976..7a3992cfc 100644
--- a/src/test/scala/objects/DeployableTest.scala
+++ b/src/test/scala/objects/DeployableTest.scala
@@ -449,8 +449,8 @@ class ExplosiveDeployableJammerExplodeTest extends ActorTest {
       assert(!h_mine.Destroyed)
 
       h_mine.Actor ! Vitality.Damage(applyDamageToH)
-      val eventMsgs = eventsProbe.receiveN(4, 200 milliseconds)
-      val p1Msgs = player1Probe.receiveN(1, 200 milliseconds)
+      val p1Msgs = player1Probe.receiveN(1, 5000 milliseconds)
+      val eventMsgs = eventsProbe.receiveN(3, 5000 milliseconds)
       eventMsgs.head match {
         case Zone.HotSpot.Conflict(target, attacker, _)
           if (target.Definition eq h_mine.Definition) && (attacker eq pSource) => ()
@@ -472,13 +472,6 @@ class ExplosiveDeployableJammerExplodeTest extends ActorTest {
         )  => ;
         case _ => assert(false, "")
       }
-      eventMsgs(3) match {
-        case AvatarServiceMessage(
-          "test",
-          AvatarAction.Destroy(PlanetSideGUID(2), PlanetSideGUID(3), Service.defaultPlayerGUID, Vector3.Zero)
-        ) => ()
-        case _ => assert(false, "")
-      }
       p1Msgs.head match {
         case Vitality.Damage(_) => ()
         case _                  => assert(false, "")
diff --git a/src/test/scala/objects/PlayerControlTest.scala b/src/test/scala/objects/PlayerControlTest.scala
index 7d2e9f733..7add65cc4 100644
--- a/src/test/scala/objects/PlayerControlTest.scala
+++ b/src/test/scala/objects/PlayerControlTest.scala
@@ -1,13 +1,12 @@
 // Copyright (c) 2020 PSForever
 package objects
 
+import akka.actor.{ActorRef => ClassicActorRef}
 import akka.actor.typed.ActorRef
 import akka.actor.{ActorSystem, Props}
-import akka.actor.typed.scaladsl.adapter._
 import akka.testkit.TestProbe
 import base.ActorTest
 import net.psforever.actors.session.AvatarActor
-import net.psforever.actors.zone.ZoneActor
 import net.psforever.objects.avatar.{Avatar, Certification, PlayerControl}
 import net.psforever.objects.ballistics._
 import net.psforever.objects.guid.NumberPoolHub
@@ -15,6 +14,7 @@ import net.psforever.objects.guid.source.MaxNumberSource
 import net.psforever.objects.vital.{SpawningActivity, Vitality}
 import net.psforever.objects.zones.{Zone, ZoneMap}
 import net.psforever.objects._
+import net.psforever.objects.definition.ProjectileDefinition
 import net.psforever.objects.serverobject.CommonMessages
 import net.psforever.objects.serverobject.environment.interaction.common.Watery.OxygenStateTarget
 import net.psforever.objects.serverobject.environment.{DeepSquare, EnvironmentAttribute, Pool}
@@ -22,6 +22,7 @@ import net.psforever.objects.sourcing.{PlayerSource, SourceEntry}
 import net.psforever.objects.vital.base.DamageResolution
 import net.psforever.objects.vital.interaction.DamageInteraction
 import net.psforever.objects.vital.projectile.ProjectileReason
+import net.psforever.objects.vital.resolution.ResolutionCalculations.Output
 import net.psforever.packet.game._
 import net.psforever.types._
 import net.psforever.services.avatar.{AvatarAction, AvatarServiceMessage}
@@ -29,17 +30,17 @@ import net.psforever.services.avatar.{AvatarAction, AvatarServiceMessage}
 import scala.concurrent.duration._
 
 class PlayerControlHealTest extends ActorTest {
-  val player1 =
+  val player1: Player =
     Player(Avatar(0, "TestCharacter1", PlanetSideEmpire.TR, CharacterSex.Male, 0, CharacterVoice.Mute)) //guid=1
-  val player2 =
+  val player2: Player =
     Player(Avatar(1, "TestCharacter2", PlanetSideEmpire.TR, CharacterSex.Male, 0, CharacterVoice.Mute)) //guid=2
-  val avatarProbe = TestProbe()
+  val avatarProbe: TestProbe = TestProbe()
   val guid = new NumberPoolHub(new MaxNumberSource(15))
-  val zone = new Zone("test", new ZoneMap("test"), 0) {
-    override def SetupNumberPools() = {}
+  val zone: Zone = new Zone("test", new ZoneMap("test"), 0) {
+    override def SetupNumberPools(): Unit = {}
     GUID(guid)
-    override def LivePlayers = List(player1, player2)
-    override def AvatarEvents = avatarProbe.ref
+    override def LivePlayers: List[Player] = List(player1, player2)
+    override def AvatarEvents: ClassicActorRef = avatarProbe.ref
   }
 
   player1.Zone = zone
@@ -52,7 +53,7 @@ class PlayerControlHealTest extends ActorTest {
   guid.register(player2.avatar.locker, 6)
   player2.Actor = system.actorOf(Props(classOf[PlayerControl], player2, null), "player2-control")
 
-  val tool = Tool(GlobalDefinitions.medicalapplicator) //guid=3 & 4
+  val tool: Tool = Tool(GlobalDefinitions.medicalapplicator) //guid=3 & 4
   guid.register(player1, 1)
   guid.register(player2, 2)
   guid.register(tool, 3)
@@ -114,15 +115,15 @@ class PlayerControlHealTest extends ActorTest {
   }
 }
 class PlayerControlHealSelfTest extends ActorTest {
-  val player1 =
+  val player1: Player =
     Player(Avatar(0, "TestCharacter1", PlanetSideEmpire.TR, CharacterSex.Male, 0, CharacterVoice.Mute)) //guid=1
-  val avatarProbe = TestProbe()
+  val avatarProbe: TestProbe = TestProbe()
   val guid = new NumberPoolHub(new MaxNumberSource(15))
-  val zone = new Zone("test", new ZoneMap("test"), 0) {
-    override def SetupNumberPools() = {}
+  val zone: Zone = new Zone("test", new ZoneMap("test"), 0) {
+    override def SetupNumberPools(): Unit = {}
     GUID(guid)
-    override def LivePlayers = List(player1)
-    override def AvatarEvents = avatarProbe.ref
+    override def LivePlayers: List[Player] = List(player1)
+    override def AvatarEvents: ClassicActorRef = avatarProbe.ref
   }
 
   player1.Zone = zone
@@ -131,7 +132,7 @@ class PlayerControlHealSelfTest extends ActorTest {
   guid.register(player1.avatar.locker, 5)
   player1.Actor = system.actorOf(Props(classOf[PlayerControl], player1, null), "player1-control")
 
-  val tool = Tool(GlobalDefinitions.medicalapplicator) //guid=3 & 4
+  val tool: Tool = Tool(GlobalDefinitions.medicalapplicator) //guid=3 & 4
   guid.register(player1, 1)
   guid.register(tool, 3)
   guid.register(tool.AmmoSlot.Box, 4)
@@ -189,18 +190,18 @@ class PlayerControlHealSelfTest extends ActorTest {
 }
 
 class PlayerControlRepairTest extends ActorTest {
-  val avatar = Avatar(0, "TestCharacter1", PlanetSideEmpire.TR, CharacterSex.Male, 0, CharacterVoice.Mute)
+  val avatar: Avatar = Avatar(0, "TestCharacter1", PlanetSideEmpire.TR, CharacterSex.Male, 0, CharacterVoice.Mute)
     .copy(certifications = Set(Certification.Engineering))
-  val player1 = Player(avatar) //guid=1
-  val player2 =
+  val player1: Player = Player(avatar) //guid=1
+  val player2: Player =
     Player(Avatar(1, "TestCharacter2", PlanetSideEmpire.TR, CharacterSex.Male, 0, CharacterVoice.Mute)) //guid=2
-  val avatarProbe = TestProbe()
+  val avatarProbe: TestProbe = TestProbe()
   val guid = new NumberPoolHub(new MaxNumberSource(15))
-  val zone = new Zone("test", new ZoneMap("test"), 0) {
-    override def SetupNumberPools() = {}
+  val zone: Zone = new Zone("test", new ZoneMap("test"), 0) {
+    override def SetupNumberPools(): Unit = {}
     GUID(guid)
-    override def LivePlayers = List(player1, player2)
-    override def AvatarEvents = avatarProbe.ref
+    override def LivePlayers: List[Player] = List(player1, player2)
+    override def AvatarEvents: ClassicActorRef = avatarProbe.ref
   }
 
   player1.Zone = zone
@@ -213,7 +214,7 @@ class PlayerControlRepairTest extends ActorTest {
   guid.register(player2.avatar.locker, 6)
   player2.Actor = system.actorOf(Props(classOf[PlayerControl], player2, null), "player2-control")
 
-  val tool = Tool(GlobalDefinitions.bank) //guid=3 & 4
+  val tool: Tool = Tool(GlobalDefinitions.bank) //guid=3 & 4
   guid.register(player1, 1)
   guid.register(player2, 2)
   guid.register(tool, 3)
@@ -286,16 +287,16 @@ class PlayerControlRepairTest extends ActorTest {
 }
 
 class PlayerControlRepairSelfTest extends ActorTest {
-  val avatar = Avatar(0, "TestCharacter1", PlanetSideEmpire.TR, CharacterSex.Male, 0, CharacterVoice.Mute)
+  val avatar: Avatar = Avatar(0, "TestCharacter1", PlanetSideEmpire.TR, CharacterSex.Male, 0, CharacterVoice.Mute)
     .copy(certifications = Set(Certification.Engineering))
-  val player1 = Player(avatar) //guid=1
-  val avatarProbe = TestProbe()
+  val player1: Player = Player(avatar) //guid=1
+  val avatarProbe: TestProbe = TestProbe()
   val guid = new NumberPoolHub(new MaxNumberSource(15))
-  val zone = new Zone("test", new ZoneMap("test"), 0) {
-    override def SetupNumberPools() = {}
+  val zone: Zone = new Zone("test", new ZoneMap("test"), 0) {
+    override def SetupNumberPools(): Unit = {}
     GUID(guid)
-    override def LivePlayers = List(player1)
-    override def AvatarEvents = avatarProbe.ref
+    override def LivePlayers: List[Player] = List(player1)
+    override def AvatarEvents: ClassicActorRef = avatarProbe.ref
   }
 
   player1.Zone = zone
@@ -304,7 +305,7 @@ class PlayerControlRepairSelfTest extends ActorTest {
   guid.register(player1.avatar.locker, 5)
   player1.Actor = system.actorOf(Props(classOf[PlayerControl], player1, null), "player1-control")
 
-  val tool = Tool(GlobalDefinitions.bank) //guid=3 & 4
+  val tool: Tool = Tool(GlobalDefinitions.bank) //guid=3 & 4
   guid.register(player1, 1)
   guid.register(tool, 3)
   guid.register(tool.AmmoSlot.Box, 4)
@@ -362,19 +363,19 @@ class PlayerControlRepairSelfTest extends ActorTest {
 }
 
 class PlayerControlDamageTest extends ActorTest {
-  val player1 =
+  val player1: Player =
     Player(Avatar(0, "TestCharacter1", PlanetSideEmpire.TR, CharacterSex.Male, 0, CharacterVoice.Mute)) //guid=1
-  val player2 =
+  val player2: Player =
     Player(Avatar(1, "TestCharacter2", PlanetSideEmpire.TR, CharacterSex.Male, 0, CharacterVoice.Mute)) //guid=2
-  val avatarProbe = TestProbe()
-  val activityProbe = TestProbe()
+  val avatarProbe: TestProbe = TestProbe()
+  val activityProbe: TestProbe = TestProbe()
   val guid = new NumberPoolHub(new MaxNumberSource(15))
-  val zone = new Zone("test", new ZoneMap("test"), 0) {
-    override def SetupNumberPools() = {}
+  val zone: Zone = new Zone("test", new ZoneMap("test"), 0) {
+    override def SetupNumberPools(): Unit = {}
     GUID(guid)
-    override def LivePlayers = List(player1, player2)
-    override def AvatarEvents = avatarProbe.ref
-    override def Activity = activityProbe.ref
+    override def LivePlayers: List[Player] = List(player1, player2)
+    override def AvatarEvents: ClassicActorRef = avatarProbe.ref
+    override def Activity: ClassicActorRef = activityProbe.ref
   }
 
   player1.Zone = zone
@@ -388,10 +389,10 @@ class PlayerControlDamageTest extends ActorTest {
   val (probe, avatarActor) = PlayerControlTest.DummyAvatar(system)
   player2.Actor = system.actorOf(Props(classOf[PlayerControl], player2, avatarActor), name = "player2-control")
 
-  val tool         = Tool(GlobalDefinitions.suppressor) //guid 3 & 4
-  val projectile   = tool.Projectile
-  val player1Source = PlayerSource(player1)
-  val resolved = DamageInteraction(
+  val tool: Tool = Tool(GlobalDefinitions.suppressor) //guid 3 & 4
+  val projectile: ProjectileDefinition = tool.Projectile
+  val player1Source: PlayerSource = PlayerSource(player1)
+  val resolved: DamageInteraction = DamageInteraction(
     SourceEntry(player2),
     ProjectileReason(
       DamageResolution.Hit,
@@ -408,7 +409,7 @@ class PlayerControlDamageTest extends ActorTest {
     ),
     Vector3(1, 0, 0)
   )
-  val applyDamageTo = resolved.calculate()
+  val applyDamageTo: Output = resolved.calculate()
   guid.register(player1, 1)
   guid.register(player2, 2)
   guid.register(tool, 3)
@@ -467,19 +468,19 @@ class PlayerControlDamageTest extends ActorTest {
 }
 
 class PlayerControlDeathStandingTest extends ActorTest {
-  val player1 =
+  val player1: Player =
     Player(Avatar(0, "TestCharacter1", PlanetSideEmpire.TR, CharacterSex.Male, 0, CharacterVoice.Mute)) //guid=1
-  val player2 =
+  val player2: Player =
     Player(Avatar(1, "TestCharacter2", PlanetSideEmpire.NC, CharacterSex.Male, 0, CharacterVoice.Mute)) //guid=2
-  val avatarProbe = TestProbe()
-  val activityProbe = TestProbe()
+  val avatarProbe: TestProbe = TestProbe()
+  val activityProbe: TestProbe = TestProbe()
   val guid = new NumberPoolHub(new MaxNumberSource(15))
-  val zone = new Zone("test", new ZoneMap("test"), 0) {
-    override def SetupNumberPools() = {}
+  val zone: Zone = new Zone("test", new ZoneMap("test"), 0) {
+    override def SetupNumberPools(): Unit = {}
     GUID(guid)
-    override def LivePlayers = List(player1, player2)
-    override def AvatarEvents = avatarProbe.ref
-    override def Activity = activityProbe.ref
+    override def LivePlayers: List[Player] = List(player1, player2)
+    override def AvatarEvents: ClassicActorRef = avatarProbe.ref
+    override def Activity: ClassicActorRef = activityProbe.ref
   }
 
   player1.Zone = zone
@@ -493,10 +494,10 @@ class PlayerControlDeathStandingTest extends ActorTest {
   val (probe, avatarActor) = PlayerControlTest.DummyAvatar(system)
   player2.Actor = system.actorOf(Props(classOf[PlayerControl], player2, avatarActor), name = "player2-control")
 
-  val tool         = Tool(GlobalDefinitions.suppressor) //guid 3 & 4
-  val projectile   = tool.Projectile
-  val player1Source = PlayerSource(player1)
-  val resolved = DamageInteraction(
+  val tool: Tool = Tool(GlobalDefinitions.suppressor) //guid 3 & 4
+  val projectile: ProjectileDefinition = tool.Projectile
+  val player1Source: PlayerSource = PlayerSource(player1)
+  val resolved: DamageInteraction = DamageInteraction(
     SourceEntry(player2),
     ProjectileReason(
       DamageResolution.Hit,
@@ -513,7 +514,7 @@ class PlayerControlDeathStandingTest extends ActorTest {
     ),
     Vector3(1, 0, 0)
   )
-  val applyDamageTo = resolved.calculate()
+  val applyDamageTo: Output = resolved.calculate()
   guid.register(player1, 1)
   guid.register(player2, 2)
   guid.register(tool, 3)
@@ -774,22 +775,22 @@ class PlayerControlDeathStandingTest extends ActorTest {
 //}
 
 class PlayerControlInteractWithWaterTest extends ActorTest {
-  val player1 =
+  val player1: Player =
     Player(Avatar(0, "TestCharacter1", PlanetSideEmpire.TR, CharacterSex.Male, 0, CharacterVoice.Mute)) //guid=1
-  val avatarProbe = TestProbe()
+  val avatarProbe: TestProbe = TestProbe()
   val guid = new NumberPoolHub(new MaxNumberSource(15))
-  val pool = Pool(EnvironmentAttribute.Water, DeepSquare(-1, 10, 10, 0, 0))
-  val zone = new Zone(
+  val pool: Pool = Pool(EnvironmentAttribute.Water, DeepSquare(-1, 10, 10, 0, 0))
+  val zone: Zone = new Zone(
     id = "test",
     new ZoneMap(name = "test-map") {
       environment = List(pool)
     },
     zoneNumber = 0
   ) {
-    override def SetupNumberPools() = {}
+    override def SetupNumberPools(): Unit = {}
     GUID(guid)
-    override def LivePlayers = List(player1)
-    override def AvatarEvents = avatarProbe.ref
+    override def LivePlayers: List[Player] = List(player1)
+    override def AvatarEvents: ClassicActorRef = avatarProbe.ref
   }
   zone.blockMap.addTo(player1)
   zone.blockMap.addTo(pool)
@@ -828,22 +829,22 @@ class PlayerControlInteractWithWaterTest extends ActorTest {
 }
 
 class PlayerControlStopInteractWithWaterTest extends ActorTest {
-  val player1 =
+  val player1: Player =
     Player(Avatar(0, "TestCharacter1", PlanetSideEmpire.TR, CharacterSex.Male, 0, CharacterVoice.Mute)) //guid=1
-  val avatarProbe = TestProbe()
+  val avatarProbe: TestProbe = TestProbe()
   val guid = new NumberPoolHub(new MaxNumberSource(15))
-  val pool = Pool(EnvironmentAttribute.Water, DeepSquare(-1, 10, 10, 0, 0))
-  val zone = new Zone(
+  val pool: Pool = Pool(EnvironmentAttribute.Water, DeepSquare(-1, 10, 10, 0, 0))
+  val zone: Zone = new Zone(
     id = "test",
     new ZoneMap(name = "test-map") {
       environment = List(pool)
     },
     zoneNumber = 0
   ) {
-    override def SetupNumberPools() = {}
+    override def SetupNumberPools(): Unit = {}
     GUID(guid)
-    override def LivePlayers = List(player1)
-    override def AvatarEvents = avatarProbe.ref
+    override def LivePlayers: List[Player] = List(player1)
+    override def AvatarEvents: ClassicActorRef = avatarProbe.ref
   }
   zone.blockMap.addTo(player1)
   zone.blockMap.addTo(pool)
@@ -893,23 +894,23 @@ class PlayerControlStopInteractWithWaterTest extends ActorTest {
 }
 
 class PlayerControlInteractWithLavaTest extends ActorTest {
-  val player1 =
+  val player1: Player =
     Player(Avatar(0, "TestCharacter1", PlanetSideEmpire.TR, CharacterSex.Male, 0, CharacterVoice.Mute)) //guid=1
-  val avatarProbe = TestProbe()
+  val avatarProbe: TestProbe = TestProbe()
   val guid = new NumberPoolHub(new MaxNumberSource(15))
-  val pool = Pool(EnvironmentAttribute.Lava, DeepSquare(-1, 10, 10, 0, 0))
-  val zone = new Zone(
+  val pool: Pool = Pool(EnvironmentAttribute.Lava, DeepSquare(-1, 10, 10, 0, 0))
+  val zone: Zone = new Zone(
     id = "test-map",
     new ZoneMap(name = "test-map") {
       environment = List(pool)
     },
     zoneNumber = 0
   ) {
-    override def SetupNumberPools() = {}
+    override def SetupNumberPools(): Unit = {}
     GUID(guid)
-    override def LivePlayers = List(player1)
-    override def AvatarEvents = avatarProbe.ref
-    override def Activity = TestProbe().ref
+    override def LivePlayers: List[Player] = List(player1)
+    override def AvatarEvents: ClassicActorRef = avatarProbe.ref
+    override def Activity: ClassicActorRef = TestProbe().ref
   }
   zone.blockMap.addTo(player1)
   zone.blockMap.addTo(pool)
@@ -955,23 +956,23 @@ class PlayerControlInteractWithLavaTest extends ActorTest {
 }
 
 class PlayerControlInteractWithDeathTest extends ActorTest {
-  val player1 =
+  val player1: Player =
     Player(Avatar(0, "TestCharacter1", PlanetSideEmpire.TR, CharacterSex.Male, 0, CharacterVoice.Mute)) //guid=1
-  val avatarProbe = TestProbe()
+  val avatarProbe: TestProbe = TestProbe()
   val guid = new NumberPoolHub(new MaxNumberSource(15))
-  val pool = Pool(EnvironmentAttribute.Death, DeepSquare(10, 10, 10, 0, 0))
-  val zone = new Zone(
+  val pool: Pool = Pool(EnvironmentAttribute.Death, DeepSquare(10, 10, 10, 0, 0))
+  val zone: Zone = new Zone(
     id = "test-map",
     new ZoneMap(name = "test-map") {
       environment = List(pool)
     },
     zoneNumber = 0
   ) {
-    override def SetupNumberPools() = {}
+    override def SetupNumberPools(): Unit = {}
     GUID(guid)
-    override def LivePlayers = List(player1)
-    override def AvatarEvents = avatarProbe.ref
-    override def Activity = TestProbe().ref
+    override def LivePlayers: List[Player] = List(player1)
+    override def Activity: ClassicActorRef = TestProbe().ref
+    override def AvatarEvents: ClassicActorRef = avatarProbe.ref
   }
   guid.register(player1, 1)
   guid.register(player1.avatar.locker, 5)
@@ -988,8 +989,9 @@ class PlayerControlInteractWithDeathTest extends ActorTest {
   "PlayerControl" should {
     "kill the player if that player steps into a pool of death" in {
       assert(player1.Health == 100) //alive
-      probe.expectNoMessage(6.seconds)
+      probe.expectNoMessage(5.seconds)
       player1.zoneInteractions() //trigger
+      probe.receiveOne(3.seconds)
       assert(player1.Health == 0) //ded
     }
   }