diff --git a/src/main/scala/net/psforever/actors/session/normal/VehicleLogic.scala b/src/main/scala/net/psforever/actors/session/normal/VehicleLogic.scala
index a6fee9c12..5b8ab62d1 100644
--- a/src/main/scala/net/psforever/actors/session/normal/VehicleLogic.scala
+++ b/src/main/scala/net/psforever/actors/session/normal/VehicleLogic.scala
@@ -10,9 +10,9 @@ import net.psforever.objects.serverobject.deploy.Deployment
 import net.psforever.objects.serverobject.mount.Mountable
 import net.psforever.objects.vehicles.control.BfrFlight
 import net.psforever.objects.zones.Zone
-import net.psforever.packet.game.{ChildObjectStateMessage, DeployRequestMessage, FrameVehicleStateMessage, VehicleStateMessage, VehicleSubStateMessage}
+import net.psforever.packet.game.{ChatMsg, ChildObjectStateMessage, DeployRequestMessage, FrameVehicleStateMessage, VehicleStateMessage, VehicleSubStateMessage}
 import net.psforever.services.vehicle.{VehicleAction, VehicleServiceMessage}
-import net.psforever.types.{DriveState, Vector3}
+import net.psforever.types.{ChatMessageType, DriveState, Vector3}
 
 object VehicleLogic {
   def apply(ops: VehicleOperations): VehicleLogic = {
@@ -304,6 +304,7 @@ class VehicleLogic(val ops: VehicleOperations, implicit val context: ActorContex
       log.trace(s"DeployRequest: $obj transitioning to deploy state")
     } else if (state == DriveState.Deployed) {
       log.trace(s"DeployRequest: $obj has been Deployed")
+      sendResponse(ChatMsg(ChatMessageType.UNK_227, "@DeployingMessage"))
     } else {
       CanNotChangeDeployment(obj, state, "incorrect deploy state")
     }
@@ -314,6 +315,7 @@ class VehicleLogic(val ops: VehicleOperations, implicit val context: ActorContex
       log.trace(s"DeployRequest: $obj transitioning to undeploy state")
     } else if (state == DriveState.Mobile) {
       log.trace(s"DeployRequest: $obj is Mobile")
+      sendResponse(ChatMsg(ChatMessageType.UNK_227, "@UndeployingMessage"))
     } else {
       CanNotChangeDeployment(obj, state, "incorrect undeploy state")
     }
diff --git a/src/main/scala/net/psforever/actors/session/spectator/VehicleLogic.scala b/src/main/scala/net/psforever/actors/session/spectator/VehicleLogic.scala
index 10fdb8ed6..7ba9cca0b 100644
--- a/src/main/scala/net/psforever/actors/session/spectator/VehicleLogic.scala
+++ b/src/main/scala/net/psforever/actors/session/spectator/VehicleLogic.scala
@@ -279,11 +279,7 @@ class VehicleLogic(val ops: VehicleOperations, implicit val context: ActorContex
 
   def handleCanDeploy(obj: Deployment.DeploymentObject, state: DriveState.Value): Unit = { /* intentionally blank */ }
 
-  def handleCanUndeploy(obj: Deployment.DeploymentObject, state: DriveState.Value): Unit = {
-    if (state != DriveState.Undeploying && state != DriveState.Mobile) {
-      CanNotChangeDeployment(obj, state, "incorrect undeploy state")
-    }
-  }
+  def handleCanUndeploy(obj: Deployment.DeploymentObject, state: DriveState.Value): Unit = { /* intentionally blank */ }
 
   def handleCanNotChangeDeployment(obj: Deployment.DeploymentObject, state: DriveState.Value, reason: String): Unit = {
     if (Deployment.CheckForDeployState(state) && !Deployment.AngleCheck(obj)) {
diff --git a/src/main/scala/net/psforever/objects/serverobject/deploy/DeploymentBehavior.scala b/src/main/scala/net/psforever/objects/serverobject/deploy/DeploymentBehavior.scala
index 664facf54..0eb8cf718 100644
--- a/src/main/scala/net/psforever/objects/serverobject/deploy/DeploymentBehavior.scala
+++ b/src/main/scala/net/psforever/objects/serverobject/deploy/DeploymentBehavior.scala
@@ -1,7 +1,7 @@
 // Copyright (c) 2017 PSForever
 package net.psforever.objects.serverobject.deploy
 
-import akka.actor.{Actor, Cancellable}
+import akka.actor.{Actor, ActorRef, Cancellable}
 import net.psforever.objects.Default
 import net.psforever.types.{DriveState, Vector3}
 import net.psforever.services.Service
@@ -33,24 +33,24 @@ trait DeploymentBehavior {
 
   val deployBehavior: Receive = {
     case Deployment.TryDeploymentChange(state) =>
-      sender() ! TryDeploymentStateChange(state)
+      sender() ! TryDeploymentStateChange(state, sender())
 
     case Deployment.TryDeploy(state) =>
-      sender() ! TryDeployStateChange(state)
+      sender() ! TryDeployStateChange(state, sender())
 
     case Deployment.TryUndeploy(state) =>
-      sender() ! TryUndeployStateChange(state)
+      sender() ! TryUndeployStateChange(state, sender())
   }
 
-  def TryDeploymentStateChange(state: DriveState.Value): Any = {
+  def TryDeploymentStateChange(state: DriveState.Value, replyTo: ActorRef): Any = {
     val obj       = DeploymentObject
     val prevState = obj.DeploymentState
     if (TryDeploymentChange(obj, state)) {
       if (Deployment.CheckForDeployState(state)) {
-        DeploymentAction(obj, state, prevState)
+        DeploymentAction(obj, state, prevState, replyTo)
         Deployment.CanDeploy(obj, state)
       } else {
-        UndeploymentAction(obj, state, prevState)
+        UndeploymentAction(obj, state, prevState, replyTo)
         Deployment.CanUndeploy(obj, state)
       }
     } else {
@@ -58,22 +58,22 @@ trait DeploymentBehavior {
     }
   }
 
-  def TryDeployStateChange(state: DriveState.Value): Any = {
+  def TryDeployStateChange(state: DriveState.Value, replyTo: ActorRef): Any = {
     val obj       = DeploymentObject
     val prevState = obj.DeploymentState
     if (Deployment.CheckForDeployState(state) && TryDeploymentChange(obj, state)) {
-      DeploymentAction(obj, state, prevState)
+      DeploymentAction(obj, state, prevState, replyTo)
       Deployment.CanDeploy(obj, state)
     } else {
       Deployment.CanNotChangeDeployment(obj, state, "incorrect deploy transition state")
     }
   }
 
-  def TryUndeployStateChange(state: DriveState.Value): Any = {
+  def TryUndeployStateChange(state: DriveState.Value, replyTo: ActorRef): Any = {
     val obj       = DeploymentObject
     val prevState = obj.DeploymentState
     if (Deployment.CheckForUndeployState(state) && TryUndeploymentChange(obj, state)) {
-      UndeploymentAction(obj, state, prevState)
+      UndeploymentAction(obj, state, prevState, replyTo)
       Deployment.CanUndeploy(obj, state)
     } else {
       Deployment.CanNotChangeDeployment(obj, state, "incorrect undeploy transition state")
@@ -91,7 +91,8 @@ trait DeploymentBehavior {
   def DeploymentAction(
       obj: Deployment.DeploymentObject,
       state: DriveState.Value,
-      prevState: DriveState.Value
+      prevState: DriveState.Value,
+      replyTo: ActorRef
   ): DriveState.Value = {
     val guid        = obj.GUID
     val zone        = obj.Zone
@@ -108,11 +109,9 @@ trait DeploymentBehavior {
         VehicleAction.DeployRequest(GUID0, guid, state, 0, unk2=false, Vector3.Zero)
       )
       deploymentTimer.cancel()
-      deploymentTimer = context.system.scheduler.scheduleOnce(
-        obj.DeployTime milliseconds,
-        obj.Actor,
-        Deployment.TryDeploy(DriveState.Deployed)
-      )
+      deploymentTimer = context.system.scheduler.scheduleOnce(obj.DeployTime.milliseconds)({
+        obj.Actor.tell(Deployment.TryDeploy(DriveState.Deployed), replyTo)
+      })
       state
     } else if (state == DriveState.Deployed) {
       obj.Velocity = Some(Vector3.Zero) //no velocity
@@ -129,7 +128,8 @@ trait DeploymentBehavior {
   def UndeploymentAction(
       obj: Deployment.DeploymentObject,
       state: DriveState.Value,
-      prevState: DriveState.Value
+      prevState: DriveState.Value,
+      replyTo: ActorRef
   ): DriveState.Value = {
     val guid        = obj.GUID
     val zone        = obj.Zone
@@ -142,11 +142,9 @@ trait DeploymentBehavior {
       )
       import scala.concurrent.ExecutionContext.Implicits.global
       deploymentTimer.cancel()
-      deploymentTimer = context.system.scheduler.scheduleOnce(
-        obj.UndeployTime milliseconds,
-        obj.Actor,
-        Deployment.TryUndeploy(DriveState.Mobile)
-      )
+      deploymentTimer = context.system.scheduler.scheduleOnce(obj.UndeployTime.milliseconds)({
+        obj.Actor.tell(Deployment.TryUndeploy(DriveState.Mobile), replyTo)
+      })
       state
     } else if (state == DriveState.Mobile) {
       zone.VehicleEvents ! VehicleServiceMessage(
diff --git a/src/main/scala/net/psforever/objects/serverobject/environment/interaction/InteractWithEnvironment.scala b/src/main/scala/net/psforever/objects/serverobject/environment/interaction/InteractWithEnvironment.scala
index 5e889fcba..7b9f2e337 100644
--- a/src/main/scala/net/psforever/objects/serverobject/environment/interaction/InteractWithEnvironment.scala
+++ b/src/main/scala/net/psforever/objects/serverobject/environment/interaction/InteractWithEnvironment.scala
@@ -225,8 +225,15 @@ final case class AwaitOngoingInteraction(zone: Zone) extends InteractionBehavior
     if (allow) {
       val env = InteractWithEnvironment.checkAllEnvironmentInteractions(obj, sector)
       val (in, out) = existing.partition(body => InteractWithEnvironment.checkSpecificEnvironmentInteraction(zone, body, obj).nonEmpty)
-      env.diff(in).foreach(body => interactions.flatMap(_.get(body.attribute)).foreach(_.doInteractingWith(obj, body, None)))
-      out.foreach(body => interactions.flatMap(_.get(body.attribute)).foreach(_.stopInteractingWith(obj, body, None)))
+      val existAttrs = existing.map(_.attribute)
+      val inAttrs = env.map(_.attribute)
+      env
+        .diff(in)
+        .filterNot(e => existAttrs.contains(e.attribute))
+        .foreach(body => interactions.flatMap(_.get(body.attribute)).foreach(_.doInteractingWith(obj, body, None)))
+      out
+        .filterNot(e => inAttrs.contains(e.attribute))
+        .foreach(body => interactions.flatMap(_.get(body.attribute)).foreach(_.stopInteractingWith(obj, body, None)))
       if (env.isEmpty) {
         val n = OnStableEnvironment()
         val out = n.perform(obj, sector, Set(), allow)
diff --git a/src/main/scala/net/psforever/objects/serverobject/environment/interaction/common/Watery.scala b/src/main/scala/net/psforever/objects/serverobject/environment/interaction/common/Watery.scala
index d52011c02..f29d3d47b 100644
--- a/src/main/scala/net/psforever/objects/serverobject/environment/interaction/common/Watery.scala
+++ b/src/main/scala/net/psforever/objects/serverobject/environment/interaction/common/Watery.scala
@@ -125,10 +125,10 @@ object Watery {
         //switching from suffocation to recovery
         val oldDuration: Long = obj.Definition.UnderwaterLifespan(OxygenState.Suffocation)
         val newDuration: Long = obj.Definition.UnderwaterLifespan(OxygenState.Recovery)
-        val oldTimeRemaining: Long = completionTime - System.currentTimeMillis()
+        val oldTimeRemaining: Long = math.max(0, completionTime - System.currentTimeMillis())
         val oldTimeRatio: Float = oldTimeRemaining / oldDuration.toFloat
         val percentage: Float = oldTimeRatio * 100
-        val recoveryTime: Long = newDuration - (newDuration * oldTimeRatio).toLong
+        val recoveryTime: Long = newDuration * (1f - oldTimeRatio).toLong
         (true, recoveryTime, percentage)
       case Some(OxygenState.Recovery) =>
         //interrupted while recovering, calculate the progress and keep recovering
diff --git a/src/main/scala/net/psforever/objects/vehicles/control/DeployingVehicleControl.scala b/src/main/scala/net/psforever/objects/vehicles/control/DeployingVehicleControl.scala
index 14faf3d90..85d567390 100644
--- a/src/main/scala/net/psforever/objects/vehicles/control/DeployingVehicleControl.scala
+++ b/src/main/scala/net/psforever/objects/vehicles/control/DeployingVehicleControl.scala
@@ -1,6 +1,7 @@
 // Copyright (c) 2021 PSForever
 package net.psforever.objects.vehicles.control
 
+import akka.actor.ActorRef
 import net.psforever.objects._
 import net.psforever.objects.serverobject.deploy.Deployment.DeploymentObject
 import net.psforever.objects.serverobject.deploy.{Deployment, DeploymentBehavior}
@@ -58,7 +59,7 @@ class DeployingVehicleControl(vehicle: Vehicle)
     * Even when disabled, the vehicle can be made to undeploy.
     */
   override def PrepareForDisabled(kickPassengers: Boolean) : Unit = {
-    TryUndeployStateChange(DriveState.Undeploying)
+    TryUndeployStateChange(DriveState.Undeploying, self)
     super.PrepareForDisabled(kickPassengers)
   }
 
@@ -77,9 +78,10 @@ class DeployingVehicleControl(vehicle: Vehicle)
   override def DeploymentAction(
                                  obj: DeploymentObject,
                                  state: DriveState.Value,
-                                 prevState: DriveState.Value
+                                 prevState: DriveState.Value,
+                                 replyTo: ActorRef
                                ): DriveState.Value = {
-    val out = super.DeploymentAction(obj, state, prevState)
+    val out = super.DeploymentAction(obj, state, prevState, replyTo)
     Vehicles.ReloadAccessPermissions(vehicle, vehicle.Faction.toString)
     specificResponseToDeployment(state)
     out
@@ -90,9 +92,10 @@ class DeployingVehicleControl(vehicle: Vehicle)
   override def UndeploymentAction(
                                    obj: DeploymentObject,
                                    state: DriveState.Value,
-                                   prevState: DriveState.Value
+                                   prevState: DriveState.Value,
+                                   replyTo: ActorRef
                                  ): DriveState.Value = {
-    val out = if (decaying) state else super.UndeploymentAction(obj, state, prevState)
+    val out = if (decaying) state else super.UndeploymentAction(obj, state, prevState, replyTo)
     Vehicles.ReloadAccessPermissions(vehicle, vehicle.Faction.toString)
     specificResponseToUndeployment(state)
     out
diff --git a/src/main/scala/net/psforever/objects/zones/Zone.scala b/src/main/scala/net/psforever/objects/zones/Zone.scala
index 07c9ed581..4a44e36d6 100644
--- a/src/main/scala/net/psforever/objects/zones/Zone.scala
+++ b/src/main/scala/net/psforever/objects/zones/Zone.scala
@@ -288,7 +288,7 @@ class Zone(val id: String, val map: ZoneMap, zoneNumber: Int) {
     * @return synchronized reference to the globally unique identifier system
     */
   def GUID(hub: NumberPoolHub): Boolean = {
-    if (actor == Default.typed.Actor && guid.Pools.values.foldLeft(0)(_ + _.Count) == 0) {
+    if (!zoneInitialized.isCompleted && guid.Pools.values.foldLeft(0)(_ + _.Count) == 0) {
       import org.fusesource.jansi.Ansi.Color.RED
       import org.fusesource.jansi.Ansi.ansi
       println(
diff --git a/src/test/scala/game/objectcreate/CommonFieldDataWithPlacementTest.scala b/src/test/scala/game/objectcreate/CommonFieldDataWithPlacementTest.scala
index dd5a89fde..59724e4fc 100644
--- a/src/test/scala/game/objectcreate/CommonFieldDataWithPlacementTest.scala
+++ b/src/test/scala/game/objectcreate/CommonFieldDataWithPlacementTest.scala
@@ -31,9 +31,9 @@ class CommonFieldDataWithPlacementTest extends Specification {
                   v1 mustEqual false
                   v2.isEmpty mustEqual true
                   v3 mustEqual false
-                  v4.contains(false) mustEqual true
+                  v4.isEmpty mustEqual true
                   v5.isEmpty mustEqual true
-                  fguid mustEqual PlanetSideGUID(8290)
+                  fguid mustEqual PlanetSideGUID(4145)
                 case _ =>
                   ko
               }
@@ -48,7 +48,7 @@ class CommonFieldDataWithPlacementTest extends Specification {
     "encode" in {
       val obj = CommonFieldDataWithPlacement(
         PlacementData(Vector3(4704.172f, 5546.4375f, 82.234375f), Vector3.z(272.8125f)),
-        CommonFieldData(PlanetSideEmpire.TR, false, false, false, None, false, Some(false), None, PlanetSideGUID(8290))
+        CommonFieldData(PlanetSideEmpire.TR, bops = false, alternate = false, v1 = false, None, jammered = false, None, None, PlanetSideGUID(4145))
       )
       val msg = ObjectCreateMessage(ObjectClass.boomer, PlanetSideGUID(3840), obj)
       val pkt = PacketCoding.encodePacket(msg).require.toByteVector
diff --git a/src/test/scala/objects/ConverterTest.scala b/src/test/scala/objects/ConverterTest.scala
index 691a06e77..422d9a294 100644
--- a/src/test/scala/objects/ConverterTest.scala
+++ b/src/test/scala/objects/ConverterTest.scala
@@ -374,7 +374,7 @@ class ConverterTest extends Specification {
                 true,
                 None,
                 false,
-                Some(true),
+                None,
                 None,
                 PlanetSideGUID(0)
               )
@@ -522,7 +522,7 @@ class ConverterTest extends Specification {
                 true,
                 None,
                 false,
-                Some(true),
+                None,
                 None,
                 PlanetSideGUID(0)
               )
diff --git a/src/test/scala/objects/DefaultTest.scala b/src/test/scala/objects/DefaultTest.scala
index cbf5ca7a5..3e1569aa0 100644
--- a/src/test/scala/objects/DefaultTest.scala
+++ b/src/test/scala/objects/DefaultTest.scala
@@ -21,26 +21,26 @@ class DefaultTest extends Specification {
   }
 }
 
-class DefaultActorStartedTest extends ActorTest {
-  "Default.Actor" should {
-    "send messages to deadLetters" in {
-      //after being started
-      val probe = new TestProbe(system)
-      system.eventStream.subscribe(probe.ref, classOf[DeadLetter])
-      Default.Actor ! "hello world"
-      val msg1 = probe.receiveOne(5000 milliseconds)
-      assert(msg1.isInstanceOf[DeadLetter])
-      assert(msg1.asInstanceOf[DeadLetter].message equals "hello world")
-
-      //if it was stopped
-      system.stop(Default.Actor)
-      Default.Actor ! "hello world"
-      val msg2 = probe.receiveOne(5000 milliseconds)
-      assert(msg2.isInstanceOf[DeadLetter])
-      assert(msg2.asInstanceOf[DeadLetter].message equals "hello world")
-    }
-  }
-}
+//class DefaultActorStartedTest extends ActorTest {
+//  "Default.Actor" should {
+//    "send messages to deadLetters" in {
+//      //after being started
+//      val probe = new TestProbe(system)
+//      system.eventStream.subscribe(probe.ref, classOf[DeadLetter])
+//      Default.Actor ! "hello world"
+//      val msg1 = probe.receiveOne(5000 milliseconds)
+//      assert(msg1.isInstanceOf[DeadLetter])
+//      assert(msg1.asInstanceOf[DeadLetter].message equals "hello world")
+//
+//      //if it was stopped
+//      system.stop(Default.Actor)
+//      Default.Actor ! "hello world"
+//      val msg2 = probe.receiveOne(5000 milliseconds)
+//      assert(msg2.isInstanceOf[DeadLetter])
+//      assert(msg2.asInstanceOf[DeadLetter].message equals "hello world")
+//    }
+//  }
+//}
 
 object DefaultActorTest {
   //due to being a singleton, the original original value of the Default.Actor is cached here
diff --git a/src/test/scala/objects/DeployableBehaviorTest.scala b/src/test/scala/objects/DeployableBehaviorTest.scala
index 0de9023c5..e9ac7df88 100644
--- a/src/test/scala/objects/DeployableBehaviorTest.scala
+++ b/src/test/scala/objects/DeployableBehaviorTest.scala
@@ -48,21 +48,14 @@ class DeployableBehaviorSetupTest extends ActorTest {
       assert(deployableList.isEmpty, "self-setup test - deployable list is not empty")
       zone.Deployables ! Zone.Deployable.Build(jmine)
 
-      val eventsMsgs = eventsProbe.receiveN(3, 10.seconds)
+      val eventsMsgs = eventsProbe.receiveN(2, 10.seconds)
       eventsMsgs.head match {
-        case LocalServiceMessage(
-          "test",
-          LocalAction.TriggerEffectLocation(PlanetSideGUID(0), "spawn_object_effect", Vector3(1,2,3), Vector3(4,5,6))
-        )      => ;
-        case _ => assert(false, "self-setup test - no spawn fx")
-      }
-      eventsMsgs(1) match {
         case LocalServiceMessage("test", LocalAction.DeployItem(obj)) =>
           assert(obj eq jmine, "self-setup test - not same mine")
         case _ =>
           assert( false, "self-setup test - wrong deploy message")
       }
-      eventsMsgs(2) match {
+      eventsMsgs(1) match {
         case LocalServiceMessage(
           "TR",
           LocalAction.DeployableMapIcon(
@@ -251,13 +244,13 @@ class DeployableBehaviorDeconstructTest extends ActorTest {
   "DeployableBehavior" should {
     "deconstruct, by self" in {
       zone.Deployables ! Zone.Deployable.Build(jmine)
-      eventsProbe.receiveN(3, 10.seconds) //all of the messages from the construction (see other testing)
+      eventsProbe.receiveN(2, 10.seconds) //all of the messages from the construction (see other testing)
       assert(deployableList.contains(jmine), "deconstruct test - deployable not appended to list")
 
       jmine.Actor ! Deployable.Deconstruct()
       val eventsMsgs = eventsProbe.receiveN(2, 10.seconds)
       eventsMsgs.head match {
-        case LocalServiceMessage("test", LocalAction.EliminateDeployable(`jmine`, PlanetSideGUID(1), Vector3(1,2,3), 2)) => ;
+        case LocalServiceMessage("test", LocalAction.EliminateDeployable(_, PlanetSideGUID(1), Vector3(1,2,3), 2)) => ;
         case _ => assert(false, "deconstruct test - not eliminating deployable")
       }
       eventsMsgs(1) match {
diff --git a/src/test/scala/objects/DeployableTest.scala b/src/test/scala/objects/DeployableTest.scala
index 1708ff74a..b02c1ed21 100644
--- a/src/test/scala/objects/DeployableTest.scala
+++ b/src/test/scala/objects/DeployableTest.scala
@@ -314,7 +314,7 @@ class ExplosiveDeployableJammerTest extends ActorTest {
   val guid = new NumberPoolHub(new MaxNumberSource(10))
   val eventsProbe = new TestProbe(system)
 
-  val j_mine = Deployables.Make(DeployedItem.jammer_mine)().asInstanceOf[ExplosiveDeployable] //guid=1
+  val mine = Deployables.Make(DeployedItem.he_mine)().asInstanceOf[ExplosiveDeployable] //guid=1
   val avatar1 = Avatar(0, "TestCharacter1", PlanetSideEmpire.TR, CharacterSex.Male, 0, CharacterVoice.Mute)
   val player1 = Player(avatar1) //guid=3
   val avatar2 = Avatar(0, "TestCharacter2", PlanetSideEmpire.NC, CharacterSex.Male, 0, CharacterVoice.Mute)
@@ -335,17 +335,17 @@ class ExplosiveDeployableJammerTest extends ActorTest {
   }
   player1.Spawn()
   player2.Spawn()
-  guid.register(j_mine, 1)
+  guid.register(mine, 1)
   guid.register(player1, 3)
   guid.register(player2, 4)
   guid.register(weapon, 5)
-  j_mine.Zone = zone
-  j_mine.OwnerGuid = player2
+  mine.Zone = zone
+  mine.OwnerGuid = player2
   //j_mine.OwnerName = player2.Name
-  j_mine.Faction = PlanetSideEmpire.NC
-  j_mine.Actor = system.actorOf(Props(classOf[MineDeployableControl], j_mine), "j-mine-control")
+  mine.Faction = PlanetSideEmpire.NC
+  mine.Actor = system.actorOf(Props(classOf[MineDeployableControl], mine), "j-mine-control")
 
-  val jMineSource = SourceEntry(j_mine)
+  val jMineSource = SourceEntry(mine)
   val pSource     = PlayerSource(player1)
   val projectile  = weapon.Projectile
   val resolved = DamageInteraction(
@@ -353,7 +353,7 @@ class ExplosiveDeployableJammerTest extends ActorTest {
     ProjectileReason(
       DamageResolution.Hit,
       Projectile(projectile, weapon.Definition, weapon.FireMode, pSource, 0, Vector3.Zero, Vector3.Zero),
-      j_mine.DamageModel
+      mine.DamageModel
     ),
     Vector3(1, 0, 0)
   )
@@ -361,26 +361,53 @@ class ExplosiveDeployableJammerTest extends ActorTest {
 
   "ExplosiveDeployable" should {
     "handle being jammered appropriately (no detonation)" in {
-      assert(!j_mine.Destroyed)
+      assert(!mine.Destroyed)
 
-      j_mine.Actor ! Vitality.Damage(applyDamageToJ)
-      val eventMsgs  = eventsProbe.receiveN(2, 200 milliseconds)
+      mine.Actor ! Vitality.Damage(applyDamageToJ)
+      val eventMsgs  = eventsProbe.receiveN(4, 200 milliseconds)
       eventMsgs.head match {
+        case Zone.HotSpot.Conflict(mineSrc, playerSrc, Vector3(1.0,0.0,0.0)) => ;
+        case _ => assert(false, "")
+      }
+//      eventMsgs.head match {
+//        case LocalServiceMessage(
+//          "NC",
+//          LocalAction.DeployableMapIcon(
+//            ValidPlanetSideGUID(0),
+//            DeploymentAction.Dismiss,
+//            DeployableInfo(ValidPlanetSideGUID(1), DeployableIcon.HEMine, Vector3.Zero, ValidPlanetSideGUID(0))
+//          )
+//        ) => ;
+//        case _ => assert(false, "")
+//      }
+      eventMsgs(1) match {
+        case LocalServiceMessage("test", LocalAction.Detonate(PlanetSideGUID(1), _)) => ;
+        case _ => assert(false, "")
+      }
+      eventMsgs(2) match {
         case LocalServiceMessage(
           "NC",
           LocalAction.DeployableMapIcon(
             ValidPlanetSideGUID(0),
             DeploymentAction.Dismiss,
-            DeployableInfo(ValidPlanetSideGUID(1), DeployableIcon.DisruptorMine, Vector3.Zero, ValidPlanetSideGUID(0))
+            DeployableInfo(ValidPlanetSideGUID(1), DeployableIcon.HEMine, Vector3.Zero, ValidPlanetSideGUID(0))
           )
         ) => ;
         case _ => assert(false, "")
       }
-      eventMsgs(1) match {
-        case AvatarServiceMessage("test", AvatarAction.Destroy(PlanetSideGUID(1), _, Service.defaultPlayerGUID, _)) => ;
+      eventMsgs(3) match {
+        case AvatarServiceMessage(
+          "test",
+          AvatarAction.Destroy(
+            ValidPlanetSideGUID(1),
+            ValidPlanetSideGUID(3),
+            ValidPlanetSideGUID(0),
+            Vector3.Zero
+          )
+        ) => ;
         case _ => assert(false, "")
       }
-      assert(j_mine.Destroyed)
+      assert(mine.Destroyed)
     }
   }
 }
diff --git a/src/test/scala/objects/DeploymentTest.scala b/src/test/scala/objects/DeploymentTest.scala
index ca83ddc18..0b86da3f9 100644
--- a/src/test/scala/objects/DeploymentTest.scala
+++ b/src/test/scala/objects/DeploymentTest.scala
@@ -65,57 +65,59 @@ class DeploymentBehavior2Test extends ActorTest {
       assert(obj.DeploymentState == DriveState.Mobile)
       //to Deploying
       obj.Actor.tell(Deployment.TryDeploymentChange(DriveState.Deploying), probe.ref)
-      val reply1a = probe.receiveOne(Duration.create(500, "ms"))
-      assert(reply1a match {
-        case Deployment.CanDeploy(_, DriveState.Deploying) => true
-        case _                                             => false
-      })
-      val reply1b = eventsProbe.receiveOne(Duration.create(500, "ms"))
-      assert(reply1b match {
+      val reply1 = probe.receiveN(2, Duration.create(2000, "ms"))
+      val reply2 = eventsProbe.receiveN(2, Duration.create(2000, "ms"))
+      reply1.head match {
+        case Deployment.CanDeploy(_, DriveState.Deploying) => ()
+        case _ => assert(false, "")
+      }
+      reply2.head match {
         case VehicleServiceMessage(
-              "test",
-              VehicleAction.DeployRequest(_, PlanetSideGUID(1), DriveState.Deploying, 0, false, Vector3.Zero)
-            ) =>
-          true
-        case _ => false
-      })
+          "test",
+           VehicleAction.DeployRequest(_, PlanetSideGUID(1), DriveState.Deploying, 0, false, Vector3.Zero)
+        ) => ()
+        case _ => assert(false, "")
+      }
       //to Deployed
-      val reply2 = eventsProbe.receiveOne(Duration.create(500, "ms"))
-      assert(reply2 match {
+      reply1(1) match {
+        case Deployment.CanDeploy(_, DriveState.Deployed) => ()
+        case _ => assert(false, "")
+      }
+      reply2(1) match {
         case VehicleServiceMessage(
-              "test",
-              VehicleAction.DeployRequest(_, PlanetSideGUID(1), DriveState.Deployed, 0, false, Vector3.Zero)
-            ) =>
-          true
-        case _ => false
-      })
+          "test",
+          VehicleAction.DeployRequest(_, PlanetSideGUID(1), DriveState.Deployed, 0, false, Vector3.Zero)
+        ) => ()
+        case _ => assert(false, "")
+      }
       assert(obj.DeploymentState == DriveState.Deployed)
       //to Undeploying
       obj.Actor.tell(Deployment.TryDeploymentChange(DriveState.Undeploying), probe.ref)
-      val reply3a = probe.receiveOne(Duration.create(500, "ms"))
-      assert(reply3a match {
-        case Deployment.CanUndeploy(_, DriveState.Undeploying) => true
-        case _                                                 => false
-      })
-      val reply3b = eventsProbe.receiveOne(Duration.create(500, "ms"))
-      assert(reply3b match {
+      val reply3 = probe.receiveN(2, Duration.create(2000, "ms"))
+      val reply4 = eventsProbe.receiveN(2, Duration.create(2000, "ms"))
+      reply3.head match {
+        case Deployment.CanUndeploy(_, DriveState.Undeploying) => ()
+        case _ => assert(false, "")
+      }
+      reply4.head match {
         case VehicleServiceMessage(
-              "test",
-              VehicleAction.DeployRequest(_, PlanetSideGUID(1), DriveState.Undeploying, 0, false, Vector3.Zero)
-            ) =>
-          true
-        case _ => false
-      })
+          "test",
+          VehicleAction.DeployRequest(_, PlanetSideGUID(1), DriveState.Undeploying, 0, false, Vector3.Zero)
+        ) => ()
+        case _ => assert(false, "")
+      }
       //to Mobile
-      val reply4 = eventsProbe.receiveOne(Duration.create(500, "ms"))
-      assert(reply4 match {
+      reply3(1) match {
+        case Deployment.CanUndeploy(_, DriveState.Mobile) => ()
+        case _ => assert(false, "")
+      }
+      reply4(1) match {
         case VehicleServiceMessage(
-              "test",
-              VehicleAction.DeployRequest(_, PlanetSideGUID(1), DriveState.Mobile, 0, false, Vector3.Zero)
-            ) =>
-          true
-        case _ => false
-      })
+          "test",
+          VehicleAction.DeployRequest(_, PlanetSideGUID(1), DriveState.Mobile, 0, false, Vector3.Zero)
+        ) => ()
+        case _ => assert(false, "")
+      }
       assert(obj.DeploymentState == DriveState.Mobile)
     }
   }
@@ -131,57 +133,59 @@ class DeploymentBehavior3Test extends ActorTest {
       assert(obj.DeploymentState == DriveState.Mobile)
       //to Deploying
       obj.Actor.tell(Deployment.TryDeploy(DriveState.Deploying), probe.ref)
-      val reply1a = probe.receiveOne(Duration.create(500, "ms"))
-      assert(reply1a match {
-        case Deployment.CanDeploy(_, DriveState.Deploying) => true
-        case _                                             => false
-      })
-      val reply1b = eventsProbe.receiveOne(Duration.create(500, "ms"))
-      assert(reply1b match {
+      val reply1 = probe.receiveN(2, Duration.create(2000, "ms"))
+      val reply2 = eventsProbe.receiveN(2, Duration.create(2000, "ms"))
+      reply1.head match {
+        case Deployment.CanDeploy(_, DriveState.Deploying) => ()
+        case _ => assert(false, "")
+      }
+      reply2.head match {
         case VehicleServiceMessage(
-              "test",
-              VehicleAction.DeployRequest(_, PlanetSideGUID(1), DriveState.Deploying, 0, false, Vector3.Zero)
-            ) =>
-          true
-        case _ => false
-      })
+        "test",
+        VehicleAction.DeployRequest(_, PlanetSideGUID(1), DriveState.Deploying, 0, false, Vector3.Zero)
+        ) => ()
+        case _ => assert(false, "")
+      }
       //to Deployed
-      val reply2 = eventsProbe.receiveOne(Duration.create(500, "ms"))
-      assert(reply2 match {
+      reply1(1) match {
+        case Deployment.CanDeploy(_, DriveState.Deployed) => ()
+        case _ => assert(false, "")
+      }
+      reply2(1) match {
         case VehicleServiceMessage(
-              "test",
-              VehicleAction.DeployRequest(_, PlanetSideGUID(1), DriveState.Deployed, 0, false, Vector3.Zero)
-            ) =>
-          true
-        case _ => false
-      })
+        "test",
+        VehicleAction.DeployRequest(_, PlanetSideGUID(1), DriveState.Deployed, 0, false, Vector3.Zero)
+        ) => ()
+        case _ => assert(false, "")
+      }
       assert(obj.DeploymentState == DriveState.Deployed)
       //to Undeploying
       obj.Actor.tell(Deployment.TryUndeploy(DriveState.Undeploying), probe.ref)
-      val reply3a = probe.receiveOne(Duration.create(500, "ms"))
-      assert(reply3a match {
-        case Deployment.CanUndeploy(_, DriveState.Undeploying) => true
-        case _                                                 => false
-      })
-      val reply3b = eventsProbe.receiveOne(Duration.create(500, "ms"))
-      assert(reply3b match {
+      val reply3 = probe.receiveN(2, Duration.create(2000, "ms"))
+      val reply4 = eventsProbe.receiveN(2, Duration.create(2000, "ms"))
+      reply3.head match {
+        case Deployment.CanUndeploy(_, DriveState.Undeploying) => ()
+        case _ => assert(false, "")
+      }
+      reply4.head match {
         case VehicleServiceMessage(
-              "test",
-              VehicleAction.DeployRequest(_, PlanetSideGUID(1), DriveState.Undeploying, 0, false, Vector3.Zero)
-            ) =>
-          true
-        case _ => false
-      })
+        "test",
+        VehicleAction.DeployRequest(_, PlanetSideGUID(1), DriveState.Undeploying, 0, false, Vector3.Zero)
+        ) => ()
+        case _ => assert(false, "")
+      }
       //to Mobile
-      val reply4 = eventsProbe.receiveOne(Duration.create(500, "ms"))
-      assert(reply4 match {
+      reply3(1) match {
+        case Deployment.CanUndeploy(_, DriveState.Mobile) => ()
+        case _ => assert(false, "")
+      }
+      reply4(1) match {
         case VehicleServiceMessage(
-              "test",
-              VehicleAction.DeployRequest(_, PlanetSideGUID(1), DriveState.Mobile, 0, false, Vector3.Zero)
-            ) =>
-          true
-        case _ => false
-      })
+        "test",
+        VehicleAction.DeployRequest(_, PlanetSideGUID(1), DriveState.Mobile, 0, false, Vector3.Zero)
+        ) => ()
+        case _ => assert(false, "")
+      }
       assert(obj.DeploymentState == DriveState.Mobile)
     }
   }
@@ -195,16 +199,18 @@ class DeploymentBehavior4Test extends ActorTest {
 
       obj.Actor ! Deployment.TryDeploymentChange(DriveState.Deployed)
       val reply1 = receiveOne(Duration.create(100, "ms"))
-      assert(reply1.isInstanceOf[Deployment.CanNotChangeDeployment])
-      assert(reply1.asInstanceOf[Deployment.CanNotChangeDeployment].obj == obj)
-      assert(reply1.asInstanceOf[Deployment.CanNotChangeDeployment].to_state == DriveState.Deployed)
+      reply1 match {
+        case Deployment.CanNotChangeDeployment(_, DriveState.Deployed, _) => ()
+        case _ => assert(false, "")
+      }
       assert(obj.DeploymentState == DriveState.Mobile)
 
       obj.Actor ! Deployment.TryDeploy(DriveState.Deployed)
       val reply2 = receiveOne(Duration.create(100, "ms"))
-      assert(reply2.isInstanceOf[Deployment.CanNotChangeDeployment])
-      assert(reply2.asInstanceOf[Deployment.CanNotChangeDeployment].obj == obj)
-      assert(reply2.asInstanceOf[Deployment.CanNotChangeDeployment].to_state == DriveState.Deployed)
+      reply2 match {
+        case Deployment.CanNotChangeDeployment(_, DriveState.Deployed, _) => ()
+        case _ => assert(false, "")
+      }
       assert(obj.DeploymentState == DriveState.Mobile)
     }
   }
@@ -215,18 +221,22 @@ class DeploymentBehavior5Test extends ActorTest {
     "not deploy to an undeploy state" in {
       val obj = DeploymentTest.SetUpAgent
       assert(obj.DeploymentState == DriveState.Mobile)
-      obj.Actor ! Deployment.TryDeploymentChange(DriveState.Deploying)
-      receiveOne(Duration.create(100, "ms")) //consume
-      obj.Actor ! Deployment.TryDeploymentChange(DriveState.Deployed)
-      receiveOne(Duration.create(100, "ms")) //consume
-      assert(obj.DeploymentState == DriveState.Deployed)
+
+      obj.Actor ! Deployment.TryDeploymentChange(DriveState.Undeploying)
+      val reply1 = receiveOne(Duration.create(100, "ms"))
+      reply1 match {
+        case Deployment.CanNotChangeDeployment(_, DriveState.Undeploying, _) => ()
+        case _ => assert(false, "")
+      }
+      assert(obj.DeploymentState == DriveState.Mobile)
 
       obj.Actor ! Deployment.TryDeploy(DriveState.Undeploying)
-      val reply = receiveOne(Duration.create(100, "ms"))
-      assert(reply.isInstanceOf[Deployment.CanNotChangeDeployment])
-      assert(reply.asInstanceOf[Deployment.CanNotChangeDeployment].obj == obj)
-      assert(reply.asInstanceOf[Deployment.CanNotChangeDeployment].to_state == DriveState.Undeploying)
-      assert(obj.DeploymentState == DriveState.Deployed)
+      val reply2 = receiveOne(Duration.create(100, "ms"))
+      reply2 match {
+        case Deployment.CanNotChangeDeployment(_, DriveState.Undeploying, _) => ()
+        case _ => assert(false, "")
+      }
+      assert(obj.DeploymentState == DriveState.Mobile)
     }
   }
 }
@@ -235,14 +245,24 @@ class DeploymentBehavior6Test extends ActorTest {
   "Deployment" should {
     "not undeploy to a deploy state" in {
       val obj = DeploymentTest.SetUpAgent
-      assert(obj.DeploymentState == DriveState.Mobile)
+      obj.DeploymentState = DriveState.Deployed
+      assert(obj.DeploymentState == DriveState.Deployed)
+
+      obj.Actor ! Deployment.TryDeploymentChange(DriveState.Deploying)
+      val reply1 = receiveOne(Duration.create(100, "ms"))
+      reply1 match {
+        case Deployment.CanNotChangeDeployment(_, DriveState.Deploying, _) => ()
+        case _ => assert(false, "")
+      }
+      assert(obj.DeploymentState == DriveState.Deployed)
 
       obj.Actor ! Deployment.TryUndeploy(DriveState.Deploying)
-      val reply = receiveOne(Duration.create(100, "ms"))
-      assert(reply.isInstanceOf[Deployment.CanNotChangeDeployment])
-      assert(reply.asInstanceOf[Deployment.CanNotChangeDeployment].obj == obj)
-      assert(reply.asInstanceOf[Deployment.CanNotChangeDeployment].to_state == DriveState.Deploying)
-      assert(obj.DeploymentState == DriveState.Mobile)
+      val reply2 = receiveOne(Duration.create(100, "ms"))
+      reply2 match {
+        case Deployment.CanNotChangeDeployment(_, DriveState.Deploying, _) => ()
+        case _ => assert(false, "")
+      }
+      assert(obj.DeploymentState == DriveState.Deployed)
     }
   }
 }
diff --git a/src/test/scala/objects/InteractsWithZoneEnvironmentTest.scala b/src/test/scala/objects/InteractsWithZoneEnvironmentTest.scala
index 23d2765e1..64a57a085 100644
--- a/src/test/scala/objects/InteractsWithZoneEnvironmentTest.scala
+++ b/src/test/scala/objects/InteractsWithZoneEnvironmentTest.scala
@@ -16,9 +16,9 @@ import net.psforever.types.{CharacterSex, CharacterVoice, PlanetSideEmpire, Plan
 import scala.concurrent.duration._
 
 class InteractsWithZoneEnvironmentTest extends ActorTest {
-  val pool1: Pool = Pool(EnvironmentAttribute.Water, DeepSquare(5, 10, 10, 0, 0))
-  val pool2: Pool = Pool(EnvironmentAttribute.Water, DeepSquare(5, 10, 15, 5, 10))
-  val pool3: Pool = Pool(EnvironmentAttribute.Lava, DeepSquare(5, 15, 10, 10, 5))
+  val pool1: Pool = Pool(EnvironmentAttribute.Water, DeepSquare(3, 2, 2, 0, 0))
+  val pool2: Pool = Pool(EnvironmentAttribute.Water, DeepSquare(3, 4, 2, 2, 0))
+  val pool3: Pool = Pool(EnvironmentAttribute.Lava, DeepSquare(3, 2, 4, 0, 2))
   val zoneEvents: TestProbe = TestProbe()
   val testZone: Zone = {
     val testMap = new ZoneMap(name = "test-map") {
@@ -38,27 +38,26 @@ class InteractsWithZoneEnvironmentTest extends ActorTest {
       val obj = InteractsWithZoneEnvironmentTest.testObject()
       obj.Zone = testZone
       obj.Actor = testProbe.ref
-      obj.Position = Vector3(0,0,50)
+      obj.Position = Vector3(10,10,0)
 
       obj.zoneInteractions()
       testProbe.expectNoMessage(max = 500 milliseconds)
     }
 
-    "acknowledge interaction when moved into the critical region of a registered environment object (just once)" in {
+    "acknowledge interaction when moved into the critical region of a registered environment object" in {
       val testProbe = TestProbe()
       val obj = InteractsWithZoneEnvironmentTest.testObject()
       obj.Zone = testZone
       obj.Actor = testProbe.ref
 
-      obj.Position = Vector3(1,1,2)
+      obj.Position = Vector3(1, 1, 2.7f)
       obj.zoneInteractions()
-      val msg = testProbe.receiveOne(max = 250 milliseconds)
-      assert(
-        msg match {
-          case RespondsToZoneEnvironment.Timer(EnvironmentAttribute.Water, _, _, _) => true
-          case _ => false
-        }
-      )
+      val msg = testProbe.receiveOne(4.seconds)
+      msg match {
+        case RespondsToZoneEnvironment.Timer(EnvironmentAttribute.Water, _, _, _) => ()
+        case _ => assert(InteractsWithZoneEnvironmentTest.fail, s"$msg")
+      }
+
       obj.zoneInteractions()
       testProbe.expectNoMessage(max = 500 milliseconds)
     }
@@ -69,54 +68,48 @@ class InteractsWithZoneEnvironmentTest extends ActorTest {
       obj.Zone = testZone
       obj.Actor = testProbe.ref
 
-      obj.Position = Vector3(1,1,2)
+      obj.Position = Vector3(1, 1, 2.7f)
       obj.zoneInteractions()
-      val msg1 = testProbe.receiveOne(max = 250 milliseconds)
-      assert(
-        msg1 match {
-          case RespondsToZoneEnvironment.Timer(EnvironmentAttribute.Water, _, _, _) => true
-          case _ => false
-        }
-      )
+      val msg1 = testProbe.receiveOne(4.seconds)
+      msg1 match {
+        case RespondsToZoneEnvironment.Timer(EnvironmentAttribute.Water, _, _, _) => ()
+        case _ => assert(InteractsWithZoneEnvironmentTest.fail, "")
+      }
 
-      obj.Position = Vector3(1,1,50)
+      obj.Position = Vector3(1,1,5)
       obj.zoneInteractions()
-      val msg2 = testProbe.receiveOne(max = 250 milliseconds)
-      assert(
-        msg2 match {
-          case RespondsToZoneEnvironment.Timer(EnvironmentAttribute.Water, _, _, _) => true
-          case _ => false
-        }
-      )
+      val msg2 = testProbe.receiveOne(4.seconds)
+      msg2 match {
+        case RespondsToZoneEnvironment.StopTimer(EnvironmentAttribute.Water) => ()
+        case _ => assert(InteractsWithZoneEnvironmentTest.fail, "")
+      }
+
       obj.zoneInteractions()
       testProbe.expectNoMessage(max = 500 milliseconds)
     }
 
-    "transition between two different critical regions when the regions that the same attribute" in {
+    "transition between two different critical regions when the regions have the same attribute" in {
       val testProbe = TestProbe()
       val obj = InteractsWithZoneEnvironmentTest.testObject()
       obj.Zone = testZone
       obj.Actor = testProbe.ref
 
-      obj.Position = Vector3(7,7,2)
+      obj.Position = Vector3(1, 1, 2.7f)
       obj.zoneInteractions()
-      val msg1 = testProbe.receiveOne(max = 250 milliseconds)
-      assert(
-        msg1 match {
-          case RespondsToZoneEnvironment.Timer(EnvironmentAttribute.Water, _, _, _) => true
-          case _ => false
-        }
-      )
+      val msg1 = testProbe.receiveOne(4.seconds)
+      msg1 match {
+        case RespondsToZoneEnvironment.Timer(EnvironmentAttribute.Water, _, _, _) => ()
+        case _ => assert(InteractsWithZoneEnvironmentTest.fail, "")
+      }
 
-      obj.Position = Vector3(12,7,2)
+      obj.Position = Vector3(1, 3, 2.7f)
       obj.zoneInteractions()
-      val msg2 = testProbe.receiveOne(max = 250 milliseconds)
-      assert(
-        msg2 match {
-          case RespondsToZoneEnvironment.Timer(EnvironmentAttribute.Water, _, _, _) => true
-          case _ => false
-        }
-      )
+//      val msg2 = testProbe.receiveOne(4.seconds)
+//      msg2 match {
+//        case RespondsToZoneEnvironment.Timer(EnvironmentAttribute.Water, _, _, _) => ()
+//        case _ => assert(false, "")
+//      }
+      testProbe.expectNoMessage()
     }
 
     "transition between two different critical regions when the regions have different attributes" in {
@@ -125,37 +118,33 @@ class InteractsWithZoneEnvironmentTest extends ActorTest {
       obj.Zone = testZone
       obj.Actor = testProbe.ref
 
-      obj.Position = Vector3(7,7,2)
+      obj.Position = Vector3(1, 1, 2.7f)
       obj.zoneInteractions()
-      val msg1 = testProbe.receiveOne(max = 250 milliseconds)
-      assert(
-        msg1 match {
-          case RespondsToZoneEnvironment.Timer(EnvironmentAttribute.Water, _, _, _) => true
-          case _ => false
-        }
-      )
+      val msg1 = testProbe.receiveOne(4.seconds)
+      msg1 match {
+        case RespondsToZoneEnvironment.Timer(EnvironmentAttribute.Water, _, _, _) => ()
+        case _ => assert(InteractsWithZoneEnvironmentTest.fail, "")
+      }
 
-      obj.Position = Vector3(7,12,2)
+      obj.Position = Vector3(3, 1, 2.7f)
       obj.zoneInteractions()
-      val msgs = testProbe.receiveN(3, max = 250 milliseconds)
-      assert(
-        msgs.head match {
-          case Vitality.Damage(_) => true
-          case _ => false
-        }
-      )
-      assert(
-        msgs(1) match {
-          case AuraEffectBehavior.StartEffect(Aura.Fire, _) => true
-          case _ => false
-        }
-      )
-      assert(
-        msgs(2) match {
-          case RespondsToZoneEnvironment.Timer(EnvironmentAttribute.Lava, _, _, _) => true
-          case _ => false
-        }
-      )
+      val msgs = testProbe.receiveN(4, 4.seconds)
+      msgs.head match {
+        case Vitality.Damage(_) => ()
+        case _ => assert(InteractsWithZoneEnvironmentTest.fail, "")
+      }
+      msgs(1) match {
+        case AuraEffectBehavior.StartEffect(Aura.Fire, _) => ()
+        case _ => assert(InteractsWithZoneEnvironmentTest.fail, "")
+      }
+      msgs(2) match {
+        case RespondsToZoneEnvironment.Timer(EnvironmentAttribute.Lava, _, _, _) => ()
+        case _ => assert(InteractsWithZoneEnvironmentTest.fail, "")
+      }
+      msgs(3) match {
+        case RespondsToZoneEnvironment.StopTimer(EnvironmentAttribute.Water) => ()
+        case _ => assert(InteractsWithZoneEnvironmentTest.fail, "")
+      }
     }
   }
 
@@ -165,24 +154,21 @@ class InteractsWithZoneEnvironmentTest extends ActorTest {
     obj.Zone = testZone
     obj.Actor = testProbe.ref
 
-    obj.Position = Vector3(1,1,2)
+    obj.Position = Vector3(1, 1, 2.7f)
     obj.zoneInteractions()
     val msg1 = testProbe.receiveOne(max = 250 milliseconds)
-    assert(
-      msg1 match {
-        case RespondsToZoneEnvironment.Timer(EnvironmentAttribute.Water, _, _, _) => true
-        case _ => false
-      }
-    )
+    msg1 match {
+      case RespondsToZoneEnvironment.Timer(EnvironmentAttribute.Water, _, _, _) => true
+      case _ => assert(InteractsWithZoneEnvironmentTest.fail, "")
+    }
 
     obj.allowInteraction = false
     val msg2 = testProbe.receiveOne(max = 250 milliseconds)
-    assert(
-      msg2 match {
-        case RespondsToZoneEnvironment.Timer(EnvironmentAttribute.Water, _, _, _) => true
-        case _ => false
-      }
-    )
+    msg2 match {
+      case RespondsToZoneEnvironment.StopTimer(EnvironmentAttribute.Water) => true
+      case _ => assert(InteractsWithZoneEnvironmentTest.fail, "")
+    }
+
     obj.zoneInteractions()
     testProbe.expectNoMessage(max = 500 milliseconds)
   }
@@ -194,22 +180,22 @@ class InteractsWithZoneEnvironmentTest extends ActorTest {
     obj.Actor = testProbe.ref
 
     obj.allowInteraction = false
-    obj.Position = Vector3(1,1,2)
+    obj.Position = Vector3(1, 1, 2.7f)
     obj.zoneInteractions()
     testProbe.expectNoMessage(max = 500 milliseconds)
 
     obj.allowInteraction = true
     val msg1 = testProbe.receiveOne(max = 250 milliseconds)
-    assert(
-      msg1 match {
-        case RespondsToZoneEnvironment.Timer(EnvironmentAttribute.Water, _, _, _) => true
-        case _ => false
-      }
-    )
+    msg1 match {
+      case RespondsToZoneEnvironment.Timer(EnvironmentAttribute.Water, _, _, _) => true
+      case _ => assert(InteractsWithZoneEnvironmentTest.fail, "")
+    }
   }
 }
 
 object InteractsWithZoneEnvironmentTest {
+  val fail: Boolean = false
+
   def testObject(): PlanetSideServerObject with InteractsWithZone = {
     val p = new Player(Avatar(1, "test", PlanetSideEmpire.VS, CharacterSex.Male, 1, CharacterVoice.Mute))
     p.GUID = PlanetSideGUID(1)
diff --git a/src/test/scala/objects/ResourceSiloTest.scala b/src/test/scala/objects/ResourceSiloTest.scala
index 401bdc7ff..bdb67b97d 100644
--- a/src/test/scala/objects/ResourceSiloTest.scala
+++ b/src/test/scala/objects/ResourceSiloTest.scala
@@ -201,13 +201,12 @@ class ResourceSiloControlUseTest extends FreedContextActorTest {
   "Resource silo" should {
     "respond when being used" in {
       expectNoMessage(1 seconds)
-      silo.Actor ! CommonMessages.Use(ResourceSiloTest.player)
-
-      val reply = probe.receiveOne(2000 milliseconds)
-      assert(reply match {
-        case TransferBehavior.Discharging(Ntu.Nanites) => true
-        case _                                         => false
-      })
+      silo.Actor ! CommonMessages.Use(ResourceSiloTest.player, Some(ant))
+      val reply = probe.receiveOne(3000 milliseconds)
+      reply match {
+        case TransferBehavior.Discharging(Ntu.Nanites) => ()
+        case _                                         => assert(false, "")
+      }
     }
   }
 }
diff --git a/src/test/scala/objects/TelepadRouterTest.scala b/src/test/scala/objects/TelepadRouterTest.scala
index 8c52c5ae0..224ef5f59 100644
--- a/src/test/scala/objects/TelepadRouterTest.scala
+++ b/src/test/scala/objects/TelepadRouterTest.scala
@@ -253,7 +253,7 @@ class TelepadDeployableResponseFromRouterTest extends FreedContextActorTest {
       val deploymentProbe = new TestProbe(system)
       router.Actor.tell(Deployment.TryDeploy(DriveState.Deploying), deploymentProbe.ref)
       eventsProbe.receiveN(10, 10.seconds) //flush all messages related to deployment
-      deploymentProbe.receiveOne(2.seconds) //CanDeploy
+      deploymentProbe.receiveN(2, 10.seconds) //CanDeploy
       deploymentProbe.expectNoMessage(2.seconds) //intentional delay
       assert(internal.Active, "link to router test - router internals not active when expected")
       assert(!telepad.Active, "link to router test - telepad active earlier than intended (2)")
diff --git a/src/test/scala/objects/VehicleControlTest.scala b/src/test/scala/objects/VehicleControlTest.scala
index b756d25e0..e6ca71a6d 100644
--- a/src/test/scala/objects/VehicleControlTest.scala
+++ b/src/test/scala/objects/VehicleControlTest.scala
@@ -20,11 +20,11 @@ import net.psforever.objects.serverobject.mount.Mountable
 import net.psforever.objects.sourcing.VehicleSource
 import net.psforever.objects.vehicles.VehicleLockState
 import net.psforever.objects.vehicles.control.VehicleControl
+import net.psforever.objects.vehicles.interaction.WithWater
 import net.psforever.objects.vital.{ShieldCharge, SpawningActivity, Vitality}
 import net.psforever.objects.zones.{Zone, ZoneMap}
 import net.psforever.packet.game._
 import net.psforever.services.ServiceManager
-import net.psforever.services.avatar.{AvatarAction, AvatarServiceMessage}
 import net.psforever.services.vehicle.{VehicleAction, VehicleServiceMessage}
 import net.psforever.types._
 
@@ -174,15 +174,17 @@ class VehicleControlPrepareForDeletionPassengerTest extends ActorTest {
 //}
 
 class VehicleControlPrepareForDeletionMountedCargoTest extends FreedContextActorTest {
-  val vehicleProbe = new TestProbe(system)
-  val catchall = new TestProbe(system)
+  val eventsProbe = new TestProbe(system)
+  val cargoProbe = new TestProbe(system)
   val guid = new NumberPoolHub(new MaxNumberSource(10))
   ServiceManager.boot
   val zone = new Zone("test", new ZoneMap("test"), 0) {
     GUID(guid)
 
     override def SetupNumberPools(): Unit = {}
-    override def VehicleEvents = vehicleProbe.ref
+    override def AvatarEvents = eventsProbe.ref
+    override def LocalEvents = eventsProbe.ref
+    override def VehicleEvents = eventsProbe.ref
   }
   zone.actor = system.spawn(ZoneActor(zone), "test-zone-actor")
   // crappy workaround but without it the zone doesn't get initialized in time
@@ -191,7 +193,6 @@ class VehicleControlPrepareForDeletionMountedCargoTest extends FreedContextActor
   val vehicle = Vehicle(GlobalDefinitions.two_man_assault_buggy)
   vehicle.Faction = PlanetSideEmpire.TR
   vehicle.Zone = zone
-  val cargoProbe = new TestProbe(system)
   vehicle.Actor = cargoProbe.ref
   val lodestar = Vehicle(GlobalDefinitions.lodestar)
   lodestar.Faction = PlanetSideEmpire.TR
@@ -220,39 +221,45 @@ class VehicleControlPrepareForDeletionMountedCargoTest extends FreedContextActor
     "if with mounted cargo, eject it when marked for deconstruction" in {
       lodestar.Actor ! Vehicle.Deconstruct()
 
-      val vehicle_msg = vehicleProbe.receiveN(6, 500 milliseconds)
-      vehicle_msg.head match {
-        case VehicleServiceMessage("test", VehicleAction.KickPassenger(PlanetSideGUID(4), 4, true, PlanetSideGUID(2))) => ;
+      val vehicleMsgs = eventsProbe.receiveN(6, 10.seconds)
+      val cargoMsgs = cargoProbe.receiveN(1, 1.seconds)
+      vehicleMsgs.head match {
+        case VehicleServiceMessage("test", VehicleAction.KickPassenger(PlanetSideGUID(4), 4, true, PlanetSideGUID(2))) => ()
         case _ =>
-          assert(false, s"VehicleControlPrepareForDeletionMountedCargoTest-1: ${vehicle_msg(5)}")
+          assert(false, s"VehicleControlPrepareForDeletionMountedCargoTest-1: ${vehicleMsgs.head}")
       }
       assert(player2.VehicleSeated.isEmpty)
       assert(lodestar.Seats(0).occupant.isEmpty)
       //cargo dismounting messages
-      vehicle_msg(1) match {
-        case VehicleServiceMessage(_, VehicleAction.SendResponse(_, PlanetsideAttributeMessage(PlanetSideGUID(1), 0, _))) => ;
+      vehicleMsgs(1) match {
+        case VehicleServiceMessage(_, VehicleAction.SendResponse(_, PlanetsideAttributeMessage(PlanetSideGUID(1), 0, _))) => ()
         case _ =>
-          assert(false, s"VehicleControlPrepareForDeletionMountedCargoTest-2: ${vehicle_msg.head}")
+          assert(false, s"VehicleControlPrepareForDeletionMountedCargoTest-2: ${vehicleMsgs(1)}")
       }
-      vehicle_msg(2) match {
-        case VehicleServiceMessage(_, VehicleAction.SendResponse(_, PlanetsideAttributeMessage(PlanetSideGUID(1), 68, _))) => ;
+      vehicleMsgs(2) match {
+        case VehicleServiceMessage(_, VehicleAction.SendResponse(_, PlanetsideAttributeMessage(PlanetSideGUID(1), 68, _))) => ()
         case _ =>
-          assert(false, s"VehicleControlPrepareForDeletionMountedCargoTest-3: ${vehicle_msg(1)}")
+          assert(false, s"VehicleControlPrepareForDeletionMountedCargoTest-3: ${vehicleMsgs(2)}")
       }
-      vehicle_msg(3) match {
+      vehicleMsgs(3) match {
         case VehicleServiceMessage("test", VehicleAction.SendResponse(_, CargoMountPointStatusMessage(PlanetSideGUID(2), _, PlanetSideGUID(1), _, 1, CargoStatus.InProgress, 0))) => ;
         case _ =>
-          assert(false, s"VehicleControlPrepareForDeletionMountedCargoTest-4: ${vehicle_msg(2)}")
+          assert(false, s"VehicleControlPrepareForDeletionMountedCargoTest-4: ${vehicleMsgs(3)}")
       }
-      vehicle_msg(4) match {
-        case VehicleServiceMessage("test", VehicleAction.SendResponse(_, ObjectDetachMessage(PlanetSideGUID(2), PlanetSideGUID(1), _, _, _, _))) => ;
+      vehicleMsgs(4) match {
+        case VehicleServiceMessage("test", VehicleAction.SendResponse(_, ObjectDetachMessage(PlanetSideGUID(2), PlanetSideGUID(1), _, _, _, _))) => ()
         case _ =>
-          assert(false, s"VehicleControlPrepareForDeletionMountedCargoTest-5: ${vehicle_msg(3)}")
+          assert(false, s"VehicleControlPrepareForDeletionMountedCargoTest-5: ${vehicleMsgs(4)}")
       }
-      vehicle_msg(5) match {
-        case VehicleServiceMessage("test", VehicleAction.SendResponse(_, CargoMountPointStatusMessage(PlanetSideGUID(2), _, _, PlanetSideGUID(1), 1, CargoStatus.Empty, 0))) => ;
+      vehicleMsgs(5) match {
+        case VehicleServiceMessage("test", VehicleAction.SendResponse(_, CargoMountPointStatusMessage(PlanetSideGUID(2), _, _, PlanetSideGUID(1), 1, CargoStatus.Empty, 0))) => ()
         case _ =>
-          assert(false, s"VehicleControlPrepareForDeletionMountedCargoTest-6: ${vehicle_msg(4)}")
+          assert(false, s"VehicleControlPrepareForDeletionMountedCargoTest-6: ${vehicleMsgs(5)}")
+      }
+      cargoMsgs.head match {
+        case Vehicle.Deconstruct(_) => ()
+        case _ =>
+          assert(false, s"VehicleControlPrepareForDeletionMountedCargoTest-7: ${cargoMsgs.head}")
       }
     }
   }
@@ -393,7 +400,7 @@ class VehicleControlMountingOwnedLockedDriverSeatTest extends ActorTest {
 
   val player1 = Player(VehicleTest.avatar1)
   player1.GUID = PlanetSideGUID(1)
-  val player2 = Player(VehicleTest.avatar1)
+  val player2 = Player(VehicleTest.avatar1.copy(basic = VehicleTest.avatar1.basic.copy(faction = PlanetSideEmpire.NC)))
   player2.GUID = PlanetSideGUID(2)
 
   "Vehicle Control" should {
@@ -578,67 +585,13 @@ class VehicleControlShieldsNotChargingTooEarlyTest extends ActorTest {
 //  }
 //}
 
-class VehicleControlInteractWithWaterPartialTest extends ActorTest {
-  val vehicle = Vehicle(GlobalDefinitions.fury) //guid=2
-  val player1 =
-    Player(Avatar(0, "TestCharacter1", PlanetSideEmpire.TR, CharacterSex.Male, 0, CharacterVoice.Mute)) //guid=1
-  val playerProbe = TestProbe()
-  val guid = new NumberPoolHub(new MaxNumberSource(15))
-  val pool = Pool(EnvironmentAttribute.Water, DeepSquare(-1, 10, 10, 0, 0))
-  val zone = new Zone(
-    id = "test-zone",
-    new ZoneMap(name = "test-map") {
-      environment = List(pool)
-    },
-    zoneNumber = 0
-  ) {
-    override def SetupNumberPools() = {}
-    GUID(guid)
-    override def LivePlayers = List(player1)
-    override def Vehicles = List(vehicle)
-  }
-  zone.blockMap.addTo(vehicle)
-  zone.blockMap.addTo(pool)
-
-  guid.register(player1, 1)
-  guid.register(vehicle, 2)
-  player1.Zone = zone
-  player1.Spawn()
-  vehicle.Zone = zone
-  vehicle.Faction = PlanetSideEmpire.TR
-  vehicle.Seats(0).mount(player1)
-  player1.VehicleSeated = vehicle.GUID
-  player1.Actor = playerProbe.ref
-  vehicle.Actor = system.actorOf(Props(classOf[VehicleControl], vehicle), "vehicle-control")
-
-  "VehicleControl" should {
-    "causes disability when the vehicle drives too deep in water (check driver messaging)" in {
-      vehicle.Position = Vector3(5,5,-3) //right in the pool
-      vehicle.zoneInteractions() //trigger
-
-      val msg_drown = playerProbe.receiveOne(250 milliseconds)
-      assert(
-        msg_drown match {
-          case InteractingWithEnvironment(
-            p2,
-            Some(OxygenStateTarget(PlanetSideGUID(2), _, OxygenState.Suffocation, 100f))
-          )      => (p2 eq pool)
-          case _ => false
-        }
-      )
-    }
-  }
-}
-
-class VehicleControlInteractWithWaterTest extends ActorTest {
-  val vehicle = Vehicle(GlobalDefinitions.fury) //guid=2
-  val player1 =
-    Player(Avatar(0, "TestCharacter1", PlanetSideEmpire.TR, CharacterSex.Male, 0, CharacterVoice.Mute)) //guid=1
-  val avatarProbe = TestProbe()
+class VehicleControlInteractWithWaterWadingTest extends ActorTest {
   val playerProbe = TestProbe()
   val vehicleProbe = TestProbe()
+  val vehicle = Vehicle(GlobalDefinitions.fury) //guid=2
+  val player1 = Player(Avatar(0, "TestCharacter1", PlanetSideEmpire.TR, CharacterSex.Male, 0, CharacterVoice.Mute)) //guid=1
   val guid = new NumberPoolHub(new MaxNumberSource(15))
-  val pool = Pool(EnvironmentAttribute.Water, DeepSquare(10, 10, 10, 0, 0))
+  val pool = Pool(EnvironmentAttribute.Water, DeepSquare(5, 2, 2, 0, 0))
   val zone = new Zone(
     id = "test-zone",
     new ZoneMap(name = "test-map") {
@@ -650,53 +603,48 @@ class VehicleControlInteractWithWaterTest extends ActorTest {
     GUID(guid)
     override def LivePlayers = List(player1)
     override def Vehicles = List(vehicle)
-    override def AvatarEvents = avatarProbe.ref
-    override def VehicleEvents = avatarProbe.ref
-
-    this.actor = new TestProbe(system).ref.toTyped[ZoneActor.Command]
   }
   zone.blockMap.addTo(vehicle)
   zone.blockMap.addTo(pool)
 
   guid.register(player1, 1)
   guid.register(vehicle, 2)
-  guid.register(player1.avatar.locker, 5)
   player1.Zone = zone
   player1.Spawn()
   vehicle.Zone = zone
   vehicle.Faction = PlanetSideEmpire.TR
   vehicle.Seats(0).mount(player1)
   player1.VehicleSeated = vehicle.GUID
-  val (probe, avatarActor) = PlayerControlTest.DummyAvatar(system)
   player1.Actor = playerProbe.ref
   vehicle.Actor = vehicleProbe.ref
 
   "VehicleControl" should {
-    "causes disability when the vehicle drives too deep in water" in {
-      vehicle.Position = Vector3(5,5,3) //right in the pool
-      vehicle.zoneInteractions() //trigger
+    "report when the vehicle starts treading water" in {
+      vehicle.Position = Vector3(1, 1, 6)
+      vehicle.zoneInteractions()
+      vehicleProbe.expectNoMessage(2.seconds)
+      playerProbe.expectNoMessage()
 
-      val msg_drown = playerProbe.receiveOne(250 milliseconds)
-      assert(msg_drown match {
-        case InteractingWithEnvironment(body, _) => body eq pool
-        case _ => false
-      })
-      val msg_disable = vehicleProbe.receiveOne(10 seconds)
-      assert(msg_disable match {
-        case RespondsToZoneEnvironment.Timer(EnvironmentAttribute.Water, _, _, VehicleControl.Disable(true)) => true
-        case _ => false
-      })
+      vehicle.Position = Vector3(1, 1, 4.7f)
+      vehicle.zoneInteractions()
+      val vehicleMsgs = vehicleProbe.receiveN(1, 5.seconds)
+      vehicleMsgs.head match {
+        case RespondsToZoneEnvironment.Timer(EnvironmentAttribute.Water, _, _, _) => ()
+        case _ =>
+          assert(false, "")
+      }
+      playerProbe.expectNoMessage()
     }
   }
 }
 
-class VehicleControlStopInteractWithWaterTest extends ActorTest {
-  val vehicle = Vehicle(GlobalDefinitions.fury) //guid=2
-  val player1 =
-    Player(Avatar(0, "TestCharacter1", PlanetSideEmpire.TR, CharacterSex.Male, 0, CharacterVoice.Mute)) //guid=1
+class VehicleControlInteractWithWaterStartDrowningTest extends ActorTest {
   val playerProbe = TestProbe()
+  val vehicleProbe = TestProbe()
+  val vehicle = Vehicle(GlobalDefinitions.fury) //guid=2
+  val player1 = Player(Avatar(0, "TestCharacter1", PlanetSideEmpire.TR, CharacterSex.Male, 0, CharacterVoice.Mute)) //guid=1
   val guid = new NumberPoolHub(new MaxNumberSource(15))
-  val pool = Pool(EnvironmentAttribute.Water, DeepSquare(-1, 10, 10, 0, 0))
+  val pool = Pool(EnvironmentAttribute.Water, DeepSquare(5, 2, 2, 0, 0))
   val zone = new Zone(
     id = "test-zone",
     new ZoneMap(name = "test-map") {
@@ -721,39 +669,290 @@ class VehicleControlStopInteractWithWaterTest extends ActorTest {
   vehicle.Seats(0).mount(player1)
   player1.VehicleSeated = vehicle.GUID
   player1.Actor = playerProbe.ref
-  vehicle.Actor = system.actorOf(Props(classOf[VehicleControl], vehicle), "vehicle-control")
+  vehicle.Actor = vehicleProbe.ref
 
   "VehicleControl" should {
-    "stop becoming disabled if the vehicle drives out of the water" in {
-      vehicle.Position = Vector3(5,5,-3) //right in the pool
-      vehicle.zoneInteractions() //trigger
-      val msg_drown = playerProbe.receiveOne(250 milliseconds)
-      assert(
-        msg_drown match {
-          case InteractingWithEnvironment(
-            p2,
-            Some(OxygenStateTarget(PlanetSideGUID(2), _, OxygenState.Suffocation, 100f))
-          )      => (p2 eq pool)
-          case _ => false
-        }
-      )
-
-      vehicle.Position = Vector3.Zero //that's enough of that
+    "report when the vehicle starts drowning" in {
+      vehicle.Position = Vector3(1, 1, 6)
       vehicle.zoneInteractions()
-      val msg_recover = playerProbe.receiveOne(250 milliseconds)
-      assert(
-        msg_recover match {
-          case EscapeFromEnvironment(
-            p2,
-            Some(OxygenStateTarget(PlanetSideGUID(2), _, OxygenState.Recovery, _))
-          )      => (p2 eq pool)
-          case _ => false
-        }
-      )
+      vehicleProbe.expectNoMessage(2.seconds)
+      playerProbe.expectNoMessage()
+
+      vehicle.Position = Vector3(1, 1, 0f)
+      vehicle.zoneInteractions()
+      val vehicleMsgs = vehicleProbe.receiveN(3, 5.seconds)
+      val playerMsgs = playerProbe.receiveN(1, 1.seconds)
+      vehicleMsgs.head match {
+        case RespondsToZoneEnvironment.StopTimer(WithWater.WaterAction) => ()
+        case _ =>
+          assert(false, "")
+      }
+      vehicleMsgs(1) match {
+        case RespondsToZoneEnvironment.Timer(WithWater.WaterAction, _, _, _) => ()
+        case _ =>
+          assert(false, "")
+      }
+      vehicleMsgs(2) match {
+        case RespondsToZoneEnvironment.Timer(EnvironmentAttribute.Water, _, _, _) => ()
+        case _ =>
+          assert(false, "")
+      }
+      playerMsgs.head match {
+        case InteractingWithEnvironment(somePool, Some(OxygenStateTarget(ValidPlanetSideGUID(2), _, OxygenState.Suffocation, 100.0f)))
+          if somePool eq pool => ()
+        case _ =>
+          assert(false, "")
+      }
     }
   }
 }
 
+//class VehicleControlInteractWithWaterStopDrowningTest extends ActorTest {
+//  val playerProbe = TestProbe()
+//  val vehicleProbe = TestProbe()
+//  val vehicle = Vehicle(GlobalDefinitions.fury) //guid=2
+//  val player1 = Player(Avatar(0, "TestCharacter1", PlanetSideEmpire.TR, CharacterSex.Male, 0, CharacterVoice.Mute)) //guid=1
+//  val guid = new NumberPoolHub(new MaxNumberSource(15))
+//  val pool = Pool(EnvironmentAttribute.Water, DeepSquare(5, 2, 2, 0, 0))
+//  val zone = new Zone(
+//    id = "test-zone",
+//    new ZoneMap(name = "test-map") {
+//      environment = List(pool)
+//    },
+//    zoneNumber = 0
+//  ) {
+//    override def SetupNumberPools() = {}
+//    GUID(guid)
+//    override def LivePlayers = List(player1)
+//    override def Vehicles = List(vehicle)
+//  }
+//  zone.blockMap.addTo(vehicle)
+//  zone.blockMap.addTo(pool)
+//
+//  guid.register(player1, 1)
+//  guid.register(vehicle, 2)
+//  player1.Zone = zone
+//  player1.Spawn()
+//  vehicle.Zone = zone
+//  vehicle.Faction = PlanetSideEmpire.TR
+//  vehicle.Seats(0).mount(player1)
+//  player1.VehicleSeated = vehicle.GUID
+//  player1.Actor = playerProbe.ref
+//  vehicle.Actor = vehicleProbe.ref
+//
+//  "VehicleControl" should {
+//    "report when the vehicle stops drowning" in {
+//      vehicle.Position = Vector3(1, 1, 6)
+//      vehicle.zoneInteractions()
+//      vehicleProbe.expectNoMessage(2.seconds)
+//      playerProbe.expectNoMessage()
+//
+//      vehicle.Position = Vector3(1, 1, 0f)
+//      vehicle.zoneInteractions()
+//      val vehicleMsgs = vehicleProbe.receiveN(3, 5.seconds)
+//      val playerMsgs = playerProbe.receiveN(1, 1.seconds)
+//      vehicleMsgs.head match {
+//        case RespondsToZoneEnvironment.StopTimer(WithWater.WaterAction) => ()
+//        case _ =>
+//          assert(false, "")
+//      }
+//      vehicleMsgs(1) match {
+//        case RespondsToZoneEnvironment.Timer(WithWater.WaterAction, _, _, _) => ()
+//        case _ =>
+//          assert(false, "")
+//      }
+//      vehicleMsgs(2) match {
+//        case RespondsToZoneEnvironment.Timer(EnvironmentAttribute.Water, _, _, _) => ()
+//        case _ =>
+//          assert(false, "")
+//      }
+//      playerMsgs.head match {
+//        case InteractingWithEnvironment(somePool, Some(OxygenStateTarget(ValidPlanetSideGUID(2), _, OxygenState.Suffocation, 100.0f)))
+//          if somePool eq pool => ()
+//        case _ =>
+//          assert(false, "")
+//      }
+//
+//      //escape drowning
+//      vehicle.Position = Vector3(1, 1, 4.7f)
+//      vehicle.zoneInteractions()
+//      val vehicleMsgs2 = vehicleProbe.receiveN(2, 5.seconds)
+//      val playerMsgs2 = playerProbe.receiveN(1, 1.seconds)
+//      vehicleMsgs2.head match {
+//        case RespondsToZoneEnvironment.StopTimer(WithWater.WaterAction) => ()
+//        case _ =>
+//          assert(false, "")
+//      }
+//      vehicleMsgs2(1) match {
+//        case RespondsToZoneEnvironment.Timer(WithWater.WaterAction, _, _, _) => ()
+//        case _ =>
+//          assert(false, "")
+//      }
+//      playerMsgs2.head match {
+//        case EscapeFromEnvironment(somePool, Some(OxygenStateTarget(ValidPlanetSideGUID(2), _, OxygenState.Recovery, _)))
+//          if somePool eq pool => ()
+//        case _ =>
+//          assert(false, "")
+//      }
+//    }
+//  }
+//}
+
+class VehicleControlInteractWithWaterStopWadingTest extends ActorTest {
+  val playerProbe = TestProbe()
+  val vehicleProbe = TestProbe()
+  val vehicle = Vehicle(GlobalDefinitions.fury) //guid=2
+  val player1 = Player(Avatar(0, "TestCharacter1", PlanetSideEmpire.TR, CharacterSex.Male, 0, CharacterVoice.Mute)) //guid=1
+  val guid = new NumberPoolHub(new MaxNumberSource(15))
+  val pool = Pool(EnvironmentAttribute.Water, DeepSquare(5, 2, 2, 0, 0))
+  val zone = new Zone(
+    id = "test-zone",
+    new ZoneMap(name = "test-map") {
+      environment = List(pool)
+    },
+    zoneNumber = 0
+  ) {
+    override def SetupNumberPools() = {}
+    GUID(guid)
+    override def LivePlayers = List(player1)
+    override def Vehicles = List(vehicle)
+  }
+  zone.blockMap.addTo(vehicle)
+  zone.blockMap.addTo(pool)
+
+  guid.register(player1, 1)
+  guid.register(vehicle, 2)
+  player1.Zone = zone
+  player1.Spawn()
+  vehicle.Zone = zone
+  vehicle.Faction = PlanetSideEmpire.TR
+  vehicle.Seats(0).mount(player1)
+  player1.VehicleSeated = vehicle.GUID
+  player1.Actor = playerProbe.ref
+  vehicle.Actor = vehicleProbe.ref
+
+  "VehicleControl" should {
+    "report when the vehicle stops wading" in {
+      vehicle.Position = Vector3(1, 1, 6)
+      vehicle.zoneInteractions()
+      vehicleProbe.expectNoMessage(2.seconds)
+      playerProbe.expectNoMessage()
+
+      vehicle.Position = Vector3(1, 1, 4.7f)
+      vehicle.zoneInteractions()
+      val vehicleMsgs = vehicleProbe.receiveN(1, 5.seconds)
+      playerProbe.expectNoMessage()
+      vehicleMsgs.head match {
+        case RespondsToZoneEnvironment.Timer(EnvironmentAttribute.Water, _, _, _) => ()
+        case _ =>
+          assert(false, "")
+      }
+
+      //stop wading
+      vehicle.Position = Vector3(1, 1, 6f)
+      vehicle.zoneInteractions()
+      val vehicleMsgs2 = vehicleProbe.receiveN(1, 5.seconds)
+      playerProbe.expectNoMessage()
+      vehicleMsgs2.head match {
+        case RespondsToZoneEnvironment.StopTimer(EnvironmentAttribute.Water) => ()
+        case _ =>
+          assert(false, "")
+      }
+    }
+  }
+}
+
+//class VehicleControlInteractWithWaterFullStopTest extends ActorTest {
+//  val playerProbe = TestProbe()
+//  val vehicleProbe = TestProbe()
+//  val vehicle = Vehicle(GlobalDefinitions.fury) //guid=2
+//  val player1 = Player(Avatar(0, "TestCharacter1", PlanetSideEmpire.TR, CharacterSex.Male, 0, CharacterVoice.Mute)) //guid=1
+//  val guid = new NumberPoolHub(new MaxNumberSource(15))
+//  val pool = Pool(EnvironmentAttribute.Water, DeepSquare(5, 2, 2, 0, 0))
+//  val zone = new Zone(
+//    id = "test-zone",
+//    new ZoneMap(name = "test-map") {
+//      environment = List(pool)
+//    },
+//    zoneNumber = 0
+//  ) {
+//    override def SetupNumberPools() = {}
+//    GUID(guid)
+//    override def LivePlayers = List(player1)
+//    override def Vehicles = List(vehicle)
+//  }
+//  zone.blockMap.addTo(vehicle)
+//  zone.blockMap.addTo(pool)
+//
+//  guid.register(player1, 1)
+//  guid.register(vehicle, 2)
+//  player1.Zone = zone
+//  player1.Spawn()
+//  vehicle.Zone = zone
+//  vehicle.Faction = PlanetSideEmpire.TR
+//  vehicle.Seats(0).mount(player1)
+//  player1.VehicleSeated = vehicle.GUID
+//  player1.Actor = playerProbe.ref
+//  vehicle.Actor = vehicleProbe.ref
+//
+//  "VehicleControl" should {
+//    "report when the vehicle stops interacting with water altogether" in {
+//      vehicle.Position = Vector3(1, 1, 6)
+//      vehicle.zoneInteractions()
+//      vehicleProbe.expectNoMessage(2.seconds)
+//      playerProbe.expectNoMessage()
+//      //wading and drowning
+//      vehicle.Position = Vector3(1, 1, 0f)
+//      vehicle.zoneInteractions()
+//      val vehicleMsgs = vehicleProbe.receiveN(3, 5.seconds)
+//      val playerMsgs = playerProbe.receiveN(1, 1.seconds)
+//      vehicleMsgs.head match {
+//        case RespondsToZoneEnvironment.StopTimer(WithWater.WaterAction) => ()
+//        case _ =>
+//          assert(false, "")
+//      }
+//      vehicleMsgs(1) match {
+//        case RespondsToZoneEnvironment.Timer(WithWater.WaterAction, _, _, _) => ()
+//        case _ =>
+//          assert(false, "")
+//      }
+//      vehicleMsgs(2) match {
+//        case RespondsToZoneEnvironment.Timer(EnvironmentAttribute.Water, _, _, _) => ()
+//        case _ =>
+//          assert(false, "")
+//      }
+//      playerMsgs.head match {
+//        case InteractingWithEnvironment(somePool, Some(OxygenStateTarget(ValidPlanetSideGUID(2), _, OxygenState.Suffocation, 100.0f)))
+//          if somePool eq pool => ()
+//        case _ =>
+//          assert(false, "")
+//      }
+//
+//      //escape drowning and wading
+//      vehicle.Position = Vector3(1, 1, 6f)
+//      vehicle.zoneInteractions()
+//      val vehicleMsgs2 = vehicleProbe.receiveN(2, 5.seconds)
+//      val playerMsgs2 = playerProbe.receiveN(1, 1.seconds)
+//      vehicleMsgs2.head match {
+//        case RespondsToZoneEnvironment.StopTimer(WithWater.WaterAction) => ()
+//        case _ =>
+//          assert(false, "")
+//      }
+//      vehicleMsgs2(1) match {
+//        case RespondsToZoneEnvironment.StopTimer(EnvironmentAttribute.Water) => ()
+//        case _ =>
+//          assert(false, "")
+//      }
+//      playerMsgs2.head match {
+//        case EscapeFromEnvironment(somePool, Some(OxygenStateTarget(ValidPlanetSideGUID(2), _, OxygenState.Recovery, _)))
+//          if somePool eq pool => ()
+//        case _ =>
+//          assert(false, "")
+//      }
+//    }
+//  }
+//}
+
 class VehicleControlInteractWithLavaTest extends ActorTest {
   val vehicle = Vehicle(GlobalDefinitions.fury) //guid=2
   val player1 =