diff --git a/src/main/scala/net/psforever/actors/session/SessionActor.scala b/src/main/scala/net/psforever/actors/session/SessionActor.scala
index 9b83a7789..7150759f1 100644
--- a/src/main/scala/net/psforever/actors/session/SessionActor.scala
+++ b/src/main/scala/net/psforever/actors/session/SessionActor.scala
@@ -107,21 +107,9 @@ class SessionActor(middlewareActor: typed.ActorRef[MiddlewareActor.Command], con
   private[this] val data = new SessionData(middlewareActor, context)
   private[this] var mode: PlayerMode = NormalMode
   private[this] var logic: ModeLogic = _
+  private[this] var listOfHandlers: Seq[CommonHandlerFunctions] = List.empty
 
   private val commonHandlerLogic: CommonHandlerLogic = new CommonHandlerLogic(data, context)
-  private def listOfHandlers: Seq[CommonHandlerFunctions] = {
-    if (logic == null) {
-      List.empty
-    } else {
-      List(
-        logic.avatarResponse,
-        logic.local,
-        logic.vehicleResponse,
-        logic.galaxy,
-        commonHandlerLogic
-      )
-    }
-  }
 
   override def postStop(): Unit = {
     clientKeepAlive.cancel()
@@ -177,6 +165,13 @@ class SessionActor(middlewareActor: typed.ActorRef[MiddlewareActor.Command], con
       logic.switchFrom(data.session)
       mode = newMode
       logic = newMode.setup(data)
+      listOfHandlers = List(
+        logic.avatarResponse,
+        logic.local,
+        logic.vehicleResponse,
+        logic.galaxy,
+        commonHandlerLogic
+      )
     }
     logic.switchTo(data.session)
   }
@@ -396,15 +391,16 @@ class SessionActor(middlewareActor: typed.ActorRef[MiddlewareActor.Command], con
         CommonHandlerFunctions.HandleNothing
     }
     //try the handler on the input message
+    val filter = HandlerFilter(guid, data.player)
     lazy val alwaysAllowFilter = HandlerFilter.Allow(guid)
-    if (primaryHandler.handleWith(guid).isDefinedAt(reply)) {
+    if (primaryHandler.handleWith(filter).isDefinedAt(reply)) {
       primaryHandler.receive.apply(reply)
     } else if (!primaryHandler.handleWith(alwaysAllowFilter).isDefinedAt(reply)) {
       //check a list of all handlers for any potentially valid case
       val potentiallyValidHandlers = listOfHandlers.filter(_.handleWith(alwaysAllowFilter).isDefinedAt(reply))
       if (potentiallyValidHandlers.nonEmpty) {
         potentiallyValidHandlers
-          .find(_.handleWith(guid).isDefinedAt(reply))
+          .find(_.handleWith(filter).isDefinedAt(reply))
           .foreach(_.receive.apply(reply))
         //arrive here without processing input, the guard for a handler blocked a case; not gonna fault
       } else {
diff --git a/src/main/scala/net/psforever/actors/session/csr/AvatarHandlerLogic.scala b/src/main/scala/net/psforever/actors/session/csr/AvatarHandlerLogic.scala
index 0b8cbc2fd..4ad3e6dc7 100644
--- a/src/main/scala/net/psforever/actors/session/csr/AvatarHandlerLogic.scala
+++ b/src/main/scala/net/psforever/actors/session/csr/AvatarHandlerLogic.scala
@@ -80,9 +80,9 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
     isCloaking,
     isNotRendered,
     canSeeReallyFar
-    ) if filter.isNotSameTarget =>
+    ) if isNotSameTarget =>
       val pstateToSave = pstate.copy(timestamp = 0)
-      val (lastMsg, lastTime, lastPosition, wasVisible, wasShooting) = ops.lastSeenStreamMessage.get(filter.resolvedPlayerGuid.guid) match {
+      val (lastMsg, lastTime, lastPosition, wasVisible, wasShooting) = ops.lastSeenStreamMessage.get(resolvedGuid.guid) match {
         case Some(SessionAvatarHandlers.LastUpstream(Some(msg), visible, shooting, time)) => (Some(msg), time, msg.pos, visible, shooting)
         case _ => (None, 0L, Vector3.Zero, false, None)
       }
@@ -125,7 +125,7 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
           //must draw
           sendResponse(
             PlayerStateMessage(
-              filter.resolvedPlayerGuid,
+              resolvedGuid,
               pos,
               vel,
               yaw,
@@ -138,10 +138,10 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
               isCloaking
             )
           )
-          ops.lastSeenStreamMessage.put(filter.resolvedPlayerGuid.guid, SessionAvatarHandlers.LastUpstream(Some(pstateToSave), visible=true, wasShooting, now))
+          ops.lastSeenStreamMessage.put(resolvedGuid.guid, SessionAvatarHandlers.LastUpstream(Some(pstateToSave), visible=true, wasShooting, now))
         } else {
           //is visible, but skip reinforcement
-          ops.lastSeenStreamMessage.put(filter.resolvedPlayerGuid.guid, SessionAvatarHandlers.LastUpstream(Some(pstateToSave), visible=true, wasShooting, lastTime))
+          ops.lastSeenStreamMessage.put(resolvedGuid.guid, SessionAvatarHandlers.LastUpstream(Some(pstateToSave), visible=true, wasShooting, lastTime))
         }
       } else {
         //conditions where the target is not currently visible
@@ -150,7 +150,7 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
           val lat = (1 + ops.hidingPlayerRandomizer.nextInt(continent.map.scale.height.toInt)).toFloat
           sendResponse(
             PlayerStateMessage(
-              filter.resolvedPlayerGuid,
+              resolvedGuid,
               Vector3(1f, lat, 1f),
               vel=None,
               facingYaw=0f,
@@ -160,28 +160,28 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
               is_cloaked = isCloaking
             )
           )
-          ops.lastSeenStreamMessage.put(filter.resolvedPlayerGuid.guid, SessionAvatarHandlers.LastUpstream(Some(pstateToSave), visible=false, wasShooting, now))
+          ops.lastSeenStreamMessage.put(resolvedGuid.guid, SessionAvatarHandlers.LastUpstream(Some(pstateToSave), visible=false, wasShooting, now))
         } else {
           //skip drawing altogether
-          ops.lastSeenStreamMessage.put(filter.resolvedPlayerGuid.guid, SessionAvatarHandlers.LastUpstream(Some(pstateToSave), visible=false, wasShooting, lastTime))
+          ops.lastSeenStreamMessage.put(resolvedGuid.guid, SessionAvatarHandlers.LastUpstream(Some(pstateToSave), visible=false, wasShooting, lastTime))
         }
       }
 
     case AvatarAction.AvatarImplant(ImplantAction.Add, implant_slot, value)
       if value == ImplantType.SecondWind.value =>
-      sendResponse(AvatarImplantMessage(filter.resolvedPlayerGuid, ImplantAction.Add, implant_slot, 7))
+      sendResponse(AvatarImplantMessage(resolvedGuid, ImplantAction.Add, implant_slot, 7))
       //second wind does not normally load its icon into the shortcut hotbar
       avatar
         .shortcuts
         .zipWithIndex
         .find { case (s, _) => s.isEmpty}
         .foreach { case (_, index) =>
-          sendResponse(CreateShortcutMessage(filter.resolvedPlayerGuid, index + 1, Some(ImplantType.SecondWind.shortcut)))
+          sendResponse(CreateShortcutMessage(resolvedGuid, index + 1, Some(ImplantType.SecondWind.shortcut)))
         }
 
     case AvatarAction.AvatarImplant(ImplantAction.Remove, implant_slot, value)
       if value == ImplantType.SecondWind.value =>
-      sendResponse(AvatarImplantMessage(filter.resolvedPlayerGuid, ImplantAction.Remove, implant_slot, value))
+      sendResponse(AvatarImplantMessage(resolvedGuid, ImplantAction.Remove, implant_slot, value))
       //second wind does not normally unload its icon from the shortcut hotbar
       val shortcut = {
         val imp = ImplantType.SecondWind.shortcut
@@ -192,15 +192,15 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
         .zipWithIndex
         .find { case (s, _) => s.contains(shortcut) }
         .foreach { case (_, index) =>
-          sendResponse(CreateShortcutMessage(filter.resolvedPlayerGuid, index + 1, None))
+          sendResponse(CreateShortcutMessage(resolvedGuid, index + 1, None))
         }
 
     case AvatarAction.AvatarImplant(action, implant_slot, value) =>
-      sendResponse(AvatarImplantMessage(filter.resolvedPlayerGuid, action, implant_slot, value))
+      sendResponse(AvatarImplantMessage(resolvedGuid, action, implant_slot, value))
 
     case AvatarAction.ObjectHeld(slot, _)
-      if filter.isSameTarget && player.VisibleSlots.contains(slot) =>
-      sendResponse(ObjectHeldMessage(filter.resolvedPlayerGuid, slot, unk1=true))
+      if isSameTarget && player.VisibleSlots.contains(slot) =>
+      sendResponse(ObjectHeldMessage(resolvedGuid, slot, unk1=true))
       //Stop using proximity terminals if player unholsters a weapon
       continent.GUID(sessionLogic.terminals.usingMedicalTerminal).collect {
         case term: Terminal with ProximityUnit => sessionLogic.terminals.StopUsingProximityUnit(term)
@@ -210,31 +210,31 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
       }
 
     case AvatarAction.ObjectHeld(slot, _)
-      if filter.isSameTarget && slot > -1 =>
-      sendResponse(ObjectHeldMessage(filter.resolvedPlayerGuid, slot, unk1=true))
+      if isSameTarget && slot > -1 =>
+      sendResponse(ObjectHeldMessage(resolvedGuid, slot, unk1=true))
 
     case AvatarAction.ObjectHeld(_, _)
-      if filter.isSameTarget => ()
+      if isSameTarget => ()
 
     case AvatarAction.ObjectHeld(_, previousSlot) =>
-      sendResponse(ObjectHeldMessage(filter.resolvedPlayerGuid, previousSlot, unk1=false))
+      sendResponse(ObjectHeldMessage(resolvedGuid, previousSlot, unk1=false))
 
     case ChangeFireState_Start(weaponGuid)
-      if filter.isNotSameTarget && ops.lastSeenStreamMessage.get(filter.resolvedPlayerGuid.guid).exists { _.visible } =>
+      if isNotSameTarget && ops.lastSeenStreamMessage.get(resolvedGuid.guid).exists { _.visible } =>
       sendResponse(ChangeFireStateMessage_Start(weaponGuid))
-      val entry = ops.lastSeenStreamMessage(filter.resolvedPlayerGuid.guid)
-      ops.lastSeenStreamMessage.put(filter.resolvedPlayerGuid.guid, entry.copy(shooting = Some(weaponGuid)))
+      val entry = ops.lastSeenStreamMessage(resolvedGuid.guid)
+      ops.lastSeenStreamMessage.put(resolvedGuid.guid, entry.copy(shooting = Some(weaponGuid)))
 
     case ChangeFireState_Stop(weaponGuid)
-      if filter.isNotSameTarget && ops.lastSeenStreamMessage.get(filter.resolvedPlayerGuid.guid).exists { msg => msg.visible || msg.shooting.nonEmpty } =>
+      if isNotSameTarget && ops.lastSeenStreamMessage.get(resolvedGuid.guid).exists { msg => msg.visible || msg.shooting.nonEmpty } =>
       sendResponse(ChangeFireStateMessage_Stop(weaponGuid))
-      val entry = ops.lastSeenStreamMessage(filter.resolvedPlayerGuid.guid)
-      ops.lastSeenStreamMessage.put(filter.resolvedPlayerGuid.guid, entry.copy(shooting = None))
+      val entry = ops.lastSeenStreamMessage(resolvedGuid.guid)
+      ops.lastSeenStreamMessage.put(resolvedGuid.guid, entry.copy(shooting = None))
 
-    case AvatarAction.LoadCreatedPlayer(pkt) if filter.isNotSameTarget =>
+    case AvatarAction.LoadCreatedPlayer(pkt) if isNotSameTarget =>
       sendResponse(pkt)
 
-    case AvatarAction.EquipmentCreatedInHand(pkt) if filter.isNotSameTarget =>
+    case AvatarAction.EquipmentCreatedInHand(pkt) if isNotSameTarget =>
       sendResponse(pkt)
 
     case AvatarAction.Destroy(victim, killer, weapon, pos) =>
@@ -267,7 +267,7 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
     inventory,
     drop,
     delete
-    ) if filter.resolvedPlayerGuid == target =>
+    ) if resolvedGuid == target =>
       sendResponse(ArmorChangedMessage(target, exosuit, subtype))
       sendResponse(PlanetsideAttributeMessage(target, attribute_type=4, armor))
       //happening to this player
@@ -349,7 +349,7 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
     oldInventory,
     inventory,
     drops
-    ) if filter.resolvedPlayerGuid == target =>
+    ) if resolvedGuid == target =>
       sendResponse(ArmorChangedMessage(target, exosuit, subtype))
       sendResponse(PlanetsideAttributeMessage(target, attribute_type=4, armor))
       //happening to this player
@@ -386,9 +386,9 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
     case AvatarAction.UseKit(kguid, kObjId) =>
       sendResponse(
         UseItemMessage(
-          filter.resolvedPlayerGuid,
+          resolvedGuid,
           kguid,
-          filter.resolvedPlayerGuid,
+          resolvedGuid,
           unk2 = 4294967295L,
           unk3 = false,
           unk4 = Vector3.Zero,
@@ -411,7 +411,7 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
 
     /* common messages (maybe once every respawn) */
     case ReloadTool(itemGuid)
-      if filter.isNotSameTarget && ops.lastSeenStreamMessage.get(filter.resolvedPlayerGuid.guid).exists { _.visible } =>
+      if isNotSameTarget && ops.lastSeenStreamMessage.get(resolvedGuid.guid).exists { _.visible } =>
       sendResponse(ReloadMessage(itemGuid, ammo_clip=1, unk1=0))
 
     case AvatarAction.Killed(_, mount) =>
@@ -422,23 +422,23 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
       sessionLogic.zoning.zoningStatus = Zoning.Status.None
       continent.GUID(mount).collect {
         case obj: Vehicle if obj.Destroyed =>
-          ops.killedWhileMounted(obj, filter.resolvedPlayerGuid)
+          ops.killedWhileMounted(obj, resolvedGuid)
           sessionLogic.vehicles.ConditionalDriverVehicleControl(obj)
           sessionLogic.general.unaccessContainer(obj)
 
         case obj: Vehicle =>
-          ops.killedWhileMounted(obj, filter.resolvedPlayerGuid)
+          ops.killedWhileMounted(obj, resolvedGuid)
           sessionLogic.vehicles.ConditionalDriverVehicleControl(obj)
 
         case obj: PlanetSideGameObject with Mountable with Container if obj.Destroyed =>
-          ops.killedWhileMounted(obj, filter.resolvedPlayerGuid)
+          ops.killedWhileMounted(obj, resolvedGuid)
           sessionLogic.general.unaccessContainer(obj)
 
         case obj: PlanetSideGameObject with Mountable with Container =>
-          ops.killedWhileMounted(obj, filter.resolvedPlayerGuid)
+          ops.killedWhileMounted(obj, resolvedGuid)
 
         case obj: PlanetSideGameObject with Mountable =>
-          ops.killedWhileMounted(obj, filter.resolvedPlayerGuid)
+          ops.killedWhileMounted(obj, resolvedGuid)
       }
       //player state changes
       sessionLogic.general.dropSpecialSlotItem()
@@ -451,11 +451,11 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
       //render
       CustomerServiceRepresentativeMode.renderPlayer(sessionLogic, continent, player)
 
-    case AvatarAction.ReleasePlayer(tplayer) if filter.isNotSameTarget =>
+    case AvatarAction.ReleasePlayer(tplayer) if isNotSameTarget =>
       sessionLogic.zoning.spawn.DepictPlayerAsCorpse(tplayer)
 
     case AvatarAction.Revive(revivalTargetGuid)
-      if filter.resolvedPlayerGuid == revivalTargetGuid =>
+      if resolvedGuid == revivalTargetGuid =>
       ops.revive()
       player.Actor ! Player.Revive
       player.History
@@ -470,18 +470,18 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
 
     /* uncommon messages (utility, or once in a while) */
     case ChangeAmmo(weapon_guid, weapon_slot, previous_guid, ammo_id, ammo_guid, ammo_data)
-      if filter.isNotSameTarget && ops.lastSeenStreamMessage.get(filter.resolvedPlayerGuid.guid).exists { _.visible } =>
+      if isNotSameTarget && ops.lastSeenStreamMessage.get(resolvedGuid.guid).exists { _.visible } =>
       ops.changeAmmoProcedure(weapon_guid, previous_guid, ammo_id, ammo_guid, weapon_slot, ammo_data)
       sendResponse(ChangeAmmoMessage(weapon_guid, 1))
 
-    case AvatarAction.ChangeFireMode(itemGuid, mode) if filter.isNotSameTarget =>
+    case AvatarAction.ChangeFireMode(itemGuid, mode) if isNotSameTarget =>
       sendResponse(ChangeFireModeMessage(itemGuid, mode))
 
     case AvatarAction.EnvironmentalDamage(_, _, _) =>
       //TODO damage marker?
       sessionLogic.zoning.CancelZoningProcess()
 
-    case AvatarAction.DropCreatedItem(pkt) if filter.isNotSameTarget =>
+    case AvatarAction.DropCreatedItem(pkt) if isNotSameTarget =>
       sendResponse(pkt)
 
     /* rare messages */
@@ -494,10 +494,10 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
         vehicle.flatMap { vinfo => Some(DrowningTarget(vinfo.guid, vinfo.progress, vinfo.state)) }
       ))
 
-    case AvatarAction.LoadCreatedProjectile(pkt) if filter.isNotSameTarget =>
+    case AvatarAction.LoadCreatedProjectile(pkt) if isNotSameTarget =>
       sendResponse(pkt)
 
-    case AvatarAction.ProjectileState(projectileGuid, shotPos, shotVel, shotOrient, seq, end, targetGuid) if filter.isNotSameTarget =>
+    case AvatarAction.ProjectileState(projectileGuid, shotPos, shotVel, shotOrient, seq, end, targetGuid) if isNotSameTarget =>
       sendResponse(ProjectileStateMessage(projectileGuid, shotPos, shotVel, shotOrient, seq, end, targetGuid))
 
     case AvatarAction.ProjectileExplodes(projectileGuid, projectile) =>
@@ -517,10 +517,10 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
     case AvatarAction.ProjectileAutoLockAwareness(mode) =>
       sendResponse(GenericActionMessage(mode))
 
-    case AvatarAction.PutDownFDU(target) if filter.isNotSameTarget =>
+    case AvatarAction.PutDownFDU(target) if isNotSameTarget =>
       sendResponse(GenericObjectActionMessage(target, code=53))
 
-    case AvatarAction.StowEquipment(target, slot, item) if filter.isNotSameTarget =>
+    case AvatarAction.StowEquipment(target, slot, item) if isNotSameTarget =>
       val definition = item.Definition
       sendResponse(
         ObjectCreateDetailedMessage(
@@ -532,7 +532,7 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
       )
 
     case WeaponDryFire(weaponGuid)
-      if filter.isNotSameTarget && ops.lastSeenStreamMessage.get(filter.resolvedPlayerGuid.guid).exists { _.visible } =>
+      if isNotSameTarget && ops.lastSeenStreamMessage.get(resolvedGuid.guid).exists { _.visible } =>
       continent.GUID(weaponGuid).collect {
         case tool: Tool if tool.Magazine == 0 =>
           // check that the magazine is still empty before sending WeaponDryFireMessage
diff --git a/src/main/scala/net/psforever/actors/session/normal/AvatarHandlerLogic.scala b/src/main/scala/net/psforever/actors/session/normal/AvatarHandlerLogic.scala
index 25c318c3d..66ebd97fe 100644
--- a/src/main/scala/net/psforever/actors/session/normal/AvatarHandlerLogic.scala
+++ b/src/main/scala/net/psforever/actors/session/normal/AvatarHandlerLogic.scala
@@ -66,9 +66,9 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
     isCloaking,
     isNotRendered,
     canSeeReallyFar
-    ) if filter.isNotSameTarget =>
+    ) if isNotSameTarget =>
       val pstateToSave = pstate.copy(timestamp = 0)
-      val (lastMsg, lastTime, lastPosition, wasVisible, wasShooting) = ops.lastSeenStreamMessage.get(filter.resolvedPlayerGuid.guid) match {
+      val (lastMsg, lastTime, lastPosition, wasVisible, wasShooting) = ops.lastSeenStreamMessage.get(resolvedGuid.guid) match {
         case Some(SessionAvatarHandlers.LastUpstream(Some(msg), visible, shooting, time)) => (Some(msg), time, msg.pos, visible, shooting)
         case _ => (None, 0L, Vector3.Zero, false, None)
       }
@@ -111,7 +111,7 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
           //must draw
           sendResponse(
             PlayerStateMessage(
-              filter.resolvedPlayerGuid,
+              resolvedGuid,
               pos,
               vel,
               yaw,
@@ -124,10 +124,10 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
               isCloaking
             )
           )
-          ops.lastSeenStreamMessage.put(filter.resolvedPlayerGuid.guid, SessionAvatarHandlers.LastUpstream(Some(pstateToSave), visible=true, wasShooting, now))
+          ops.lastSeenStreamMessage.put(resolvedGuid.guid, SessionAvatarHandlers.LastUpstream(Some(pstateToSave), visible=true, wasShooting, now))
         } else {
           //is visible, but skip reinforcement
-          ops.lastSeenStreamMessage.put(filter.resolvedPlayerGuid.guid, SessionAvatarHandlers.LastUpstream(Some(pstateToSave), visible=true, wasShooting, lastTime))
+          ops.lastSeenStreamMessage.put(resolvedGuid.guid, SessionAvatarHandlers.LastUpstream(Some(pstateToSave), visible=true, wasShooting, lastTime))
         }
       } else {
         //conditions where the target is not currently visible
@@ -136,7 +136,7 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
           val lat = (1 + ops.hidingPlayerRandomizer.nextInt(continent.map.scale.height.toInt)).toFloat
           sendResponse(
             PlayerStateMessage(
-              filter.resolvedPlayerGuid,
+              resolvedGuid,
               Vector3(1f, lat, 1f),
               vel=None,
               facingYaw=0f,
@@ -146,28 +146,28 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
               is_cloaked = isCloaking
             )
           )
-          ops.lastSeenStreamMessage.put(filter.resolvedPlayerGuid.guid, SessionAvatarHandlers.LastUpstream(Some(pstateToSave), visible=false, wasShooting, now))
+          ops.lastSeenStreamMessage.put(resolvedGuid.guid, SessionAvatarHandlers.LastUpstream(Some(pstateToSave), visible=false, wasShooting, now))
         } else {
           //skip drawing altogether
-          ops.lastSeenStreamMessage.put(filter.resolvedPlayerGuid.guid, SessionAvatarHandlers.LastUpstream(Some(pstateToSave), visible=false, wasShooting, lastTime))
+          ops.lastSeenStreamMessage.put(resolvedGuid.guid, SessionAvatarHandlers.LastUpstream(Some(pstateToSave), visible=false, wasShooting, lastTime))
         }
       }
 
     case AvatarAction.AvatarImplant(ImplantAction.Add, implant_slot, value)
       if value == ImplantType.SecondWind.value =>
-      sendResponse(AvatarImplantMessage(filter.resolvedPlayerGuid, ImplantAction.Add, implant_slot, 7))
+      sendResponse(AvatarImplantMessage(resolvedGuid, ImplantAction.Add, implant_slot, 7))
       //second wind does not normally load its icon into the shortcut hotbar
       avatar
         .shortcuts
         .zipWithIndex
         .find { case (s, _) => s.isEmpty}
         .foreach { case (_, index) =>
-          sendResponse(CreateShortcutMessage(filter.resolvedPlayerGuid, index + 1, Some(ImplantType.SecondWind.shortcut)))
+          sendResponse(CreateShortcutMessage(resolvedGuid, index + 1, Some(ImplantType.SecondWind.shortcut)))
         }
 
     case AvatarAction.AvatarImplant(ImplantAction.Remove, implant_slot, value)
       if value == ImplantType.SecondWind.value =>
-      sendResponse(AvatarImplantMessage(filter.resolvedPlayerGuid, ImplantAction.Remove, implant_slot, value))
+      sendResponse(AvatarImplantMessage(resolvedGuid, ImplantAction.Remove, implant_slot, value))
       //second wind does not normally unload its icon from the shortcut hotbar
       val shortcut = {
         val imp = ImplantType.SecondWind.shortcut
@@ -178,15 +178,15 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
         .zipWithIndex
         .find { case (s, _) => s.contains(shortcut) }
         .foreach { case (_, index) =>
-          sendResponse(CreateShortcutMessage(filter.resolvedPlayerGuid, index + 1, None))
+          sendResponse(CreateShortcutMessage(resolvedGuid, index + 1, None))
         }
 
     case AvatarAction.AvatarImplant(action, implant_slot, value) =>
-      sendResponse(AvatarImplantMessage(filter.resolvedPlayerGuid, action, implant_slot, value))
+      sendResponse(AvatarImplantMessage(resolvedGuid, action, implant_slot, value))
 
     case AvatarAction.ObjectHeld(slot, _)
-      if filter.isSameTarget && player.VisibleSlots.contains(slot) =>
-      sendResponse(ObjectHeldMessage(filter.resolvedPlayerGuid, slot, unk1=true))
+      if isSameTarget && player.VisibleSlots.contains(slot) =>
+      sendResponse(ObjectHeldMessage(resolvedGuid, slot, unk1=true))
       //Stop using proximity terminals if player unholsters a weapon
       continent.GUID(sessionLogic.terminals.usingMedicalTerminal).collect {
         case term: Terminal with ProximityUnit => sessionLogic.terminals.StopUsingProximityUnit(term)
@@ -196,35 +196,35 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
       }
 
     case AvatarAction.ObjectHeld(slot, _)
-      if filter.isSameTarget && slot > -1 =>
-      sendResponse(ObjectHeldMessage(filter.resolvedPlayerGuid, slot, unk1=true))
+      if isSameTarget && slot > -1 =>
+      sendResponse(ObjectHeldMessage(resolvedGuid, slot, unk1=true))
 
     case AvatarAction.ObjectHeld(_, _)
-      if filter.isSameTarget => ()
+      if isSameTarget => ()
 
     case AvatarAction.ObjectHeld(_, previousSlot) =>
-      sendResponse(ObjectHeldMessage(filter.resolvedPlayerGuid, previousSlot, unk1=false))
+      sendResponse(ObjectHeldMessage(resolvedGuid, previousSlot, unk1=false))
 
     case ChangeFireState_Start(weaponGuid)
-      if filter.isNotSameTarget && ops.lastSeenStreamMessage.get(filter.resolvedPlayerGuid.guid).exists { _.visible } =>
+      if isNotSameTarget && ops.lastSeenStreamMessage.get(resolvedGuid.guid).exists { _.visible } =>
       sendResponse(ChangeFireStateMessage_Start(weaponGuid))
-      val entry = ops.lastSeenStreamMessage(filter.resolvedPlayerGuid.guid)
-      ops.lastSeenStreamMessage.put(filter.resolvedPlayerGuid.guid, entry.copy(shooting = Some(weaponGuid)))
+      val entry = ops.lastSeenStreamMessage(resolvedGuid.guid)
+      ops.lastSeenStreamMessage.put(resolvedGuid.guid, entry.copy(shooting = Some(weaponGuid)))
 
     case ChangeFireState_Stop(weaponGuid)
-      if filter.isNotSameTarget && ops.lastSeenStreamMessage.get(filter.resolvedPlayerGuid.guid).exists { msg => msg.visible || msg.shooting.nonEmpty } =>
+      if isNotSameTarget && ops.lastSeenStreamMessage.get(resolvedGuid.guid).exists { msg => msg.visible || msg.shooting.nonEmpty } =>
       sendResponse(ChangeFireStateMessage_Stop(weaponGuid))
-      val entry = ops.lastSeenStreamMessage(filter.resolvedPlayerGuid.guid)
-      ops.lastSeenStreamMessage.put(filter.resolvedPlayerGuid.guid, entry.copy(shooting = None))
+      val entry = ops.lastSeenStreamMessage(resolvedGuid.guid)
+      ops.lastSeenStreamMessage.put(resolvedGuid.guid, entry.copy(shooting = None))
 
-    case AvatarAction.LoadCreatedPlayer(pkt) if filter.isNotSameTarget =>
+    case AvatarAction.LoadCreatedPlayer(pkt) if isNotSameTarget =>
       sendResponse(pkt)
 
-    case AvatarAction.EquipmentCreatedInHand(pkt) if filter.isNotSameTarget =>
+    case AvatarAction.EquipmentCreatedInHand(pkt) if isNotSameTarget =>
       sendResponse(pkt)
 
     case AvatarAction.PlanetsideStringAttribute(attributeType, attributeValue) =>
-      sendResponse(PlanetsideStringAttributeMessage(filter.resolvedPlayerGuid, attributeType, attributeValue))
+      sendResponse(PlanetsideStringAttributeMessage(resolvedGuid, attributeType, attributeValue))
 
     case AvatarAction.Destroy(victim, killer, weapon, pos) =>
       // guid = victim // killer = killer
@@ -260,7 +260,7 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
     inventory,
     drop,
     delete
-    ) if filter.resolvedPlayerGuid == target =>
+    ) if resolvedGuid == target =>
       sendResponse(ArmorChangedMessage(target, exosuit, subtype))
       sendResponse(PlanetsideAttributeMessage(target, attribute_type=4, armor))
       //happening to this player
@@ -360,7 +360,7 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
     oldInventory,
     inventory,
     drops
-    ) if filter.resolvedPlayerGuid == target =>
+    ) if resolvedGuid == target =>
       sendResponse(ArmorChangedMessage(target, exosuit, subtype))
       sendResponse(PlanetsideAttributeMessage(target, attribute_type=4, armor))
       //happening to this player
@@ -400,9 +400,9 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
     case AvatarAction.UseKit(kguid, kObjId) =>
       sendResponse(
         UseItemMessage(
-          filter.resolvedPlayerGuid,
+          resolvedGuid,
           kguid,
-          filter.resolvedPlayerGuid,
+          resolvedGuid,
           unk2 = 4294967295L,
           unk3 = false,
           unk4 = Vector3.Zero,
@@ -451,7 +451,7 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
 
     /* common messages (maybe once every respawn) */
     case ReloadTool(itemGuid)
-      if filter.isNotSameTarget && ops.lastSeenStreamMessage.get(filter.resolvedPlayerGuid.guid).exists { _.visible } =>
+      if isNotSameTarget && ops.lastSeenStreamMessage.get(resolvedGuid.guid).exists { _.visible } =>
       sendResponse(ReloadMessage(itemGuid, ammo_clip=1, unk1=0))
 
     case AvatarAction.Killed(cause, mount) =>
@@ -517,16 +517,16 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
       sessionLogic.zoning.spawn.deadState = DeadState.Dead
       continent.GUID(mount).collect {
         case obj: Vehicle =>
-          killedWhileMounted(obj, filter.resolvedPlayerGuid)
+          killedWhileMounted(obj, resolvedGuid)
           sessionLogic.vehicles.ConditionalDriverVehicleControl(obj)
           sessionLogic.general.unaccessContainer(obj)
 
         case obj: PlanetSideGameObject with Mountable with Container =>
-          killedWhileMounted(obj, filter.resolvedPlayerGuid)
+          killedWhileMounted(obj, resolvedGuid)
           sessionLogic.general.unaccessContainer(obj)
 
         case obj: PlanetSideGameObject with Mountable =>
-          killedWhileMounted(obj, filter.resolvedPlayerGuid)
+          killedWhileMounted(obj, resolvedGuid)
       }
       sessionLogic.actionsToCancel()
       sessionLogic.terminals.CancelAllProximityUnits()
@@ -544,11 +544,11 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
         sessionLogic.zoning.spawn.HandleReleaseAvatar(player, continent)
       }
 
-    case AvatarAction.ReleasePlayer(tplayer) if filter.isNotSameTarget =>
+    case AvatarAction.ReleasePlayer(tplayer) if isNotSameTarget =>
       sessionLogic.zoning.spawn.DepictPlayerAsCorpse(tplayer)
 
     case AvatarAction.Revive(revivalTargetGuid)
-      if filter.resolvedPlayerGuid == revivalTargetGuid =>
+      if resolvedGuid == revivalTargetGuid =>
       log.info(s"No time for rest, ${player.Name}.  Back on your feet!")
       ops.revive()
       player.Actor ! Player.Revive
@@ -564,18 +564,18 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
 
     /* uncommon messages (utility, or once in a while) */
     case ChangeAmmo(weapon_guid, weapon_slot, previous_guid, ammo_id, ammo_guid, ammo_data)
-      if filter.isNotSameTarget && ops.lastSeenStreamMessage.get(filter.resolvedPlayerGuid.guid).exists { _.visible } =>
+      if isNotSameTarget && ops.lastSeenStreamMessage.get(resolvedGuid.guid).exists { _.visible } =>
       ops.changeAmmoProcedure(weapon_guid, previous_guid, ammo_id, ammo_guid, weapon_slot, ammo_data)
       sendResponse(ChangeAmmoMessage(weapon_guid, 1))
 
-    case AvatarAction.ChangeFireMode(itemGuid, mode) if filter.isNotSameTarget =>
+    case AvatarAction.ChangeFireMode(itemGuid, mode) if isNotSameTarget =>
       sendResponse(ChangeFireModeMessage(itemGuid, mode))
 
     case AvatarAction.EnvironmentalDamage(_, _, _) =>
       //TODO damage marker?
       sessionLogic.zoning.CancelZoningProcessWithDescriptiveReason("cancel_dmg")
 
-    case AvatarAction.DropCreatedItem(pkt) if filter.isNotSameTarget =>
+    case AvatarAction.DropCreatedItem(pkt) if isNotSameTarget =>
       sendResponse(pkt)
 
     /* rare messages */
@@ -588,10 +588,10 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
         vehicle.flatMap { vinfo => Some(DrowningTarget(vinfo.guid, vinfo.progress, vinfo.state)) }
       ))
 
-    case AvatarAction.LoadCreatedProjectile(pkt) if filter.isNotSameTarget =>
+    case AvatarAction.LoadCreatedProjectile(pkt) if isNotSameTarget =>
       sendResponse(pkt)
 
-    case AvatarAction.ProjectileState(projectileGuid, shotPos, shotVel, shotOrient, seq, end, targetGuid) if filter.isNotSameTarget =>
+    case AvatarAction.ProjectileState(projectileGuid, shotPos, shotVel, shotOrient, seq, end, targetGuid) if isNotSameTarget =>
       sendResponse(ProjectileStateMessage(projectileGuid, shotPos, shotVel, shotOrient, seq, end, targetGuid))
 
     case AvatarAction.ProjectileExplodes(projectileGuid, projectile) =>
@@ -611,10 +611,10 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
     case AvatarAction.ProjectileAutoLockAwareness(mode) =>
       sendResponse(GenericActionMessage(mode))
 
-    case AvatarAction.PutDownFDU(target) if filter.isNotSameTarget =>
+    case AvatarAction.PutDownFDU(target) if isNotSameTarget =>
       sendResponse(GenericObjectActionMessage(target, code=53))
 
-    case AvatarAction.StowEquipment(target, slot, item) if filter.isNotSameTarget =>
+    case AvatarAction.StowEquipment(target, slot, item) if isNotSameTarget =>
       val definition = item.Definition
       sendResponse(
         ObjectCreateDetailedMessage(
@@ -626,7 +626,7 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
       )
 
     case WeaponDryFire(weaponGuid)
-      if filter.isNotSameTarget && ops.lastSeenStreamMessage.get(filter.resolvedPlayerGuid.guid).exists { _.visible } =>
+      if isNotSameTarget && ops.lastSeenStreamMessage.get(resolvedGuid.guid).exists { _.visible } =>
       continent.GUID(weaponGuid).collect {
         case tool: Tool if tool.Magazine == 0 =>
           // check that the magazine is still empty before sending WeaponDryFireMessage
diff --git a/src/main/scala/net/psforever/actors/session/normal/LocalHandlerLogic.scala b/src/main/scala/net/psforever/actors/session/normal/LocalHandlerLogic.scala
index f8bb508ee..1c108d951 100644
--- a/src/main/scala/net/psforever/actors/session/normal/LocalHandlerLogic.scala
+++ b/src/main/scala/net/psforever/actors/session/normal/LocalHandlerLogic.scala
@@ -49,7 +49,7 @@ class LocalHandlerLogic(val ops: SessionLocalHandlers, implicit val context: Act
           sendResponse(msg)
       }
 
-    case LocalAction.DeployableMapIcon(behavior, deployInfo) if filter.isNotSameTarget =>
+    case LocalAction.DeployableMapIcon(behavior, deployInfo) if isNotSameTarget =>
       sendResponse(DeployableObjectsInfoMessage(behavior, deployInfo))
 
     case LocalAction.DeployableUIFor(item) =>
@@ -68,7 +68,7 @@ class LocalHandlerLogic(val ops: SessionLocalHandlers, implicit val context: Act
     case LocalAction.Detonate(_, obj) =>
       log.warn(s"LocalAction.Detonate: ${obj.Definition.Name} not configured to explode correctly")
 
-    case LocalAction.DoorOpens(_, door) if filter.isNotSameTarget =>
+    case LocalAction.DoorOpens(_, door) if isNotSameTarget =>
       val doorGuid = door.GUID
       val pos = player.Position.xy
       val range = ops.doorLoadRange()
@@ -139,7 +139,7 @@ class LocalHandlerLogic(val ops: SessionLocalHandlers, implicit val context: Act
       ops.DeconstructDeployable(obj, dguid, pos, obj.Orientation, effect)
 
     case LocalAction.HackClear(targetGuid, unk1, unk2) =>
-      sendResponse(HackMessage(HackState1.Unk0, targetGuid, filter.resolvedPlayerGuid, progress=0, unk1.toFloat, HackState.HackCleared, unk2))
+      sendResponse(HackMessage(HackState1.Unk0, targetGuid, resolvedGuid, progress=0, unk1.toFloat, HackState.HackCleared, unk2))
 
     case LocalAction.HackObject(targetGuid, unk1, unk2) =>
       sessionLogic.general.hackObject(targetGuid, unk1, unk2)
@@ -216,7 +216,7 @@ class LocalHandlerLogic(val ops: SessionLocalHandlers, implicit val context: Act
     case LocalAction.UpdateForceDomeStatus(buildingGuid, false) =>
       sendResponse(GenericObjectActionMessage(buildingGuid, 12))
 
-    case LocalAction.RechargeVehicleWeapon(vehicleGuid, weaponGuid) if filter.isSameTarget /*resolvedPlayerGuid == guid*/ =>
+    case LocalAction.RechargeVehicleWeapon(vehicleGuid, weaponGuid) if isSameTarget /*resolvedPlayerGuid == guid*/ =>
       continent.GUID(vehicleGuid)
         .collect { case vehicle: MountableWeapons => (vehicle, vehicle.PassengerInSeat(player)) }
         .collect { case (vehicle, Some(seat_num)) => vehicle.WeaponControlledFromSeat(seat_num) }
diff --git a/src/main/scala/net/psforever/actors/session/normal/VehicleHandlerLogic.scala b/src/main/scala/net/psforever/actors/session/normal/VehicleHandlerLogic.scala
index 9758c53d3..c392bda74 100644
--- a/src/main/scala/net/psforever/actors/session/normal/VehicleHandlerLogic.scala
+++ b/src/main/scala/net/psforever/actors/session/normal/VehicleHandlerLogic.scala
@@ -47,7 +47,7 @@ class VehicleHandlerLogic(val ops: SessionVehicleHandlers, implicit val context:
     wheelDirection,
     unk5,
     unk6
-    ) if filter.isNotSameTarget && player.VehicleSeated.contains(vehicleGuid) =>
+    ) if isNotSameTarget && player.VehicleSeated.contains(vehicleGuid) =>
       //player who is also in the vehicle (not driver)
       sendResponse(VehicleStateMessage(vehicleGuid, unk1, pos, orient, vel, unk2, unk3, unk4, wheelDirection, unk5, unk6))
       player.Position = pos
@@ -75,30 +75,30 @@ class VehicleHandlerLogic(val ops: SessionVehicleHandlers, implicit val context:
     wheelDirection,
     unk5,
     unk6
-    ) if filter.isNotSameTarget =>
+    ) if isNotSameTarget =>
       //player who is watching the vehicle from the outside
       sendResponse(VehicleStateMessage(vehicleGuid, unk1, pos, ang, vel, unk2, unk3, unk4, wheelDirection, unk5, unk6))
 
-    case VehicleAction.ChildObjectState(objectGuid, pitch, yaw) if filter.isNotSameTarget =>
+    case VehicleAction.ChildObjectState(objectGuid, pitch, yaw) if isNotSameTarget =>
       sendResponse(ChildObjectStateMessage(objectGuid, pitch, yaw))
 
     case VehicleAction.FrameVehicleState(vguid, u1, pos, oient, vel, u2, u3, u4, is_crouched, u6, u7, u8, u9, uA)
-      if filter.isNotSameTarget =>
+      if isNotSameTarget =>
       sendResponse(FrameVehicleStateMessage(vguid, u1, pos, oient, vel, u2, u3, u4, is_crouched, u6, u7, u8, u9, uA))
 
-    case VehicleAction.DismountVehicle(bailType, wasKickedByDriver) if filter.isNotSameTarget =>
-      sendResponse(DismountVehicleMsg(filter.resolvedPlayerGuid, bailType, wasKickedByDriver))
+    case VehicleAction.DismountVehicle(bailType, wasKickedByDriver) if isNotSameTarget =>
+      sendResponse(DismountVehicleMsg(resolvedGuid, bailType, wasKickedByDriver))
 
-    case VehicleAction.MountVehicle(vehicleGuid, seat) if filter.isNotSameTarget =>
-      sendResponse(ObjectAttachMessage(vehicleGuid, filter.resolvedPlayerGuid, seat))
+    case VehicleAction.MountVehicle(vehicleGuid, seat) if isNotSameTarget =>
+      sendResponse(ObjectAttachMessage(vehicleGuid, resolvedGuid, seat))
 
-    case VehicleAction.DeployRequest(objectGuid, state, unk1, unk2, pos) if filter.isNotSameTarget =>
-      sendResponse(DeployRequestMessage(filter.resolvedPlayerGuid, objectGuid, state, unk1, unk2, pos))
+    case VehicleAction.DeployRequest(objectGuid, state, unk1, unk2, pos) if isNotSameTarget =>
+      sendResponse(DeployRequestMessage(resolvedGuid, objectGuid, state, unk1, unk2, pos))
 
-    case VehicleAction.EquipmentCreatedInSlot(pkt) if filter.isNotSameTarget =>
+    case VehicleAction.EquipmentCreatedInSlot(pkt) if isNotSameTarget =>
       sendResponse(pkt)
 
-    case VehicleAction.InventoryState(obj, parentGuid, start, conData) if filter.isNotSameTarget =>
+    case VehicleAction.InventoryState(obj, parentGuid, start, conData) if isNotSameTarget =>
       //TODO prefer ObjectDetachMessage, but how to force ammo pools to update properly?
       val objGuid = obj.GUID
       sendResponse(ObjectDeleteMessage(objGuid, unk1=0))
@@ -109,10 +109,10 @@ class VehicleHandlerLogic(val ops: SessionVehicleHandlers, implicit val context:
         conData
       ))
 
-    case VehicleAction.KickPassenger(_, wasKickedByDriver, vehicleGuid) if filter.isSameTarget /*resolvedPlayerGuid == guid*/ =>
+    case VehicleAction.KickPassenger(_, wasKickedByDriver, vehicleGuid) if isSameTarget /*resolvedPlayerGuid == guid*/ =>
       //seat number (first field) seems to be correct if passenger is kicked manually by driver
       //but always seems to return 4 if user is kicked by mount permissions changing
-      sendResponse(DismountVehicleMsg(filter.resolvedPlayerGuid, BailType.Kicked, wasKickedByDriver))
+      sendResponse(DismountVehicleMsg(resolvedGuid, BailType.Kicked, wasKickedByDriver))
       val typeOfRide = continent.GUID(vehicleGuid) match {
         case Some(obj: Vehicle) =>
           sessionLogic.general.unaccessContainer(obj)
@@ -126,28 +126,28 @@ class VehicleHandlerLogic(val ops: SessionVehicleHandlers, implicit val context:
     case VehicleAction.KickPassenger(_, wasKickedByDriver, _) =>
       //seat number (first field) seems to be correct if passenger is kicked manually by driver
       //but always seems to return 4 if user is kicked by mount permissions changing
-      sendResponse(DismountVehicleMsg(filter.resolvedPlayerGuid, BailType.Kicked, wasKickedByDriver))
+      sendResponse(DismountVehicleMsg(resolvedGuid, BailType.Kicked, wasKickedByDriver))
 
-    case VehicleAction.InventoryState2(objGuid, parentGuid, value) if filter.isNotSameTarget =>
+    case VehicleAction.InventoryState2(objGuid, parentGuid, value) if isNotSameTarget =>
       sendResponse(InventoryStateMessage(objGuid, unk=0, parentGuid, value))
 
-    case VehicleAction.LoadVehicle(vehicle, vtype, vguid, vdata) if filter.isNotSameTarget =>
+    case VehicleAction.LoadVehicle(vehicle, vtype, vguid, vdata) if isNotSameTarget =>
       //this is not be suitable for vehicles with people who are seated in it before it spawns (if that is possible)
       sendResponse(ObjectCreateMessage(vtype, vguid, vdata))
       Vehicles.ReloadAccessPermissions(vehicle, player.Name)
 
-    case VehicleAction.Ownership(vehicleGuid) if filter.isSameTarget /*resolvedPlayerGuid == guid*/ =>
+    case VehicleAction.Ownership(vehicleGuid) if isSameTarget /*resolvedPlayerGuid == guid*/ =>
       //Only the player that owns this vehicle needs the ownership packet
       avatarActor ! AvatarActor.SetVehicle(Some(vehicleGuid))
-      sendResponse(PlanetsideAttributeMessage(filter.resolvedPlayerGuid, attribute_type=21, vehicleGuid))
+      sendResponse(PlanetsideAttributeMessage(resolvedGuid, attribute_type=21, vehicleGuid))
 
     case VehicleAction.LoseOwnership(_, vehicleGuid) =>
       ops.announceAmsDecay(vehicleGuid,msg = "@ams_decaystarted")
 
-    case VehicleAction.SeatPermissions(vehicleGuid, seatGroup, permission) if filter.isNotSameTarget =>
+    case VehicleAction.SeatPermissions(vehicleGuid, seatGroup, permission) if isNotSameTarget =>
       sendResponse(PlanetsideAttributeMessage(vehicleGuid, seatGroup, permission))
 
-    case VehicleAction.StowCreatedEquipment(vehicleGuid, slot, itemType, itemGuid, itemData) if filter.isNotSameTarget =>
+    case VehicleAction.StowCreatedEquipment(vehicleGuid, slot, itemType, itemGuid, itemData) if isNotSameTarget =>
       //TODO prefer ObjectAttachMessage, but how to force ammo pools to update properly?
       sendResponse(ObjectCreateDetailedMessage(itemType, itemGuid, ObjectCreateMessageParent(vehicleGuid, slot), itemData))
 
@@ -164,7 +164,7 @@ class VehicleHandlerLogic(val ops: SessionVehicleHandlers, implicit val context:
         sendResponse(ChatMsg(ChatMessageType.UNK_229, "@ams_decayed"))
       }
 
-    case VehicleAction.UnstowEquipment(itemGuid) if filter.isNotSameTarget =>
+    case VehicleAction.UnstowEquipment(itemGuid) if isNotSameTarget =>
       //TODO prefer ObjectDetachMessage, but how to force ammo pools to update properly?
       sendResponse(ObjectDeleteMessage(itemGuid, unk1=0))
 
@@ -172,7 +172,7 @@ class VehicleHandlerLogic(val ops: SessionVehicleHandlers, implicit val context:
       sessionLogic.zoning.spawn.amsSpawnPoints = list.filter(tube => tube.Faction == player.Faction)
       sessionLogic.zoning.spawn.DrawCurrentAmsSpawnPoint()
 
-    case VehicleAction.TransferPassengerChannel(oldChannel, tempChannel, vehicle, vehicleToDelete) if filter.isNotSameTarget =>
+    case VehicleAction.TransferPassengerChannel(oldChannel, tempChannel, vehicle, vehicleToDelete) if isNotSameTarget =>
       sessionLogic.zoning.interstellarFerry = Some(vehicle)
       sessionLogic.zoning.interstellarFerryTopLevelGUID = Some(vehicleToDelete)
       continent.VehicleEvents ! Service.Leave(oldChannel) //old vehicle-specific channel (was s"${vehicle.Actor}")
diff --git a/src/main/scala/net/psforever/actors/session/spectator/AvatarHandlerLogic.scala b/src/main/scala/net/psforever/actors/session/spectator/AvatarHandlerLogic.scala
index d072f0069..1e4f0b3f6 100644
--- a/src/main/scala/net/psforever/actors/session/spectator/AvatarHandlerLogic.scala
+++ b/src/main/scala/net/psforever/actors/session/spectator/AvatarHandlerLogic.scala
@@ -61,9 +61,9 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
     isCloaking,
     isNotRendered,
     canSeeReallyFar
-    ) if filter.isNotSameTarget =>
+    ) if isNotSameTarget =>
       val pstateToSave = pstate.copy(timestamp = 0)
-      val (lastMsg, lastTime, lastPosition, wasVisible, wasShooting) = ops.lastSeenStreamMessage.get(filter.resolvedPlayerGuid.guid) match {
+      val (lastMsg, lastTime, lastPosition, wasVisible, wasShooting) = ops.lastSeenStreamMessage.get(resolvedGuid.guid) match {
         case Some(SessionAvatarHandlers.LastUpstream(Some(msg), visible, shooting, time)) => (Some(msg), time, msg.pos, visible, shooting)
         case _ => (None, 0L, Vector3.Zero, false, None)
       }
@@ -106,7 +106,7 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
           //must draw
           sendResponse(
             PlayerStateMessage(
-              filter.resolvedPlayerGuid,
+              resolvedGuid,
               pos,
               vel,
               yaw,
@@ -119,10 +119,10 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
               isCloaking
             )
           )
-          ops.lastSeenStreamMessage.put(filter.resolvedPlayerGuid.guid, SessionAvatarHandlers.LastUpstream(Some(pstateToSave), visible=true, wasShooting, now))
+          ops.lastSeenStreamMessage.put(resolvedGuid.guid, SessionAvatarHandlers.LastUpstream(Some(pstateToSave), visible=true, wasShooting, now))
         } else {
           //is visible, but skip reinforcement
-          ops.lastSeenStreamMessage.put(filter.resolvedPlayerGuid.guid, SessionAvatarHandlers.LastUpstream(Some(pstateToSave), visible=true, wasShooting, lastTime))
+          ops.lastSeenStreamMessage.put(resolvedGuid.guid, SessionAvatarHandlers.LastUpstream(Some(pstateToSave), visible=true, wasShooting, lastTime))
         }
       } else {
         //conditions where the target is not currently visible
@@ -131,7 +131,7 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
           val lat = (1 + ops.hidingPlayerRandomizer.nextInt(continent.map.scale.height.toInt)).toFloat
           sendResponse(
             PlayerStateMessage(
-              filter.resolvedPlayerGuid,
+              resolvedGuid,
               Vector3(1f, lat, 1f),
               vel=None,
               facingYaw=0f,
@@ -141,16 +141,16 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
               is_cloaked = isCloaking
             )
           )
-          ops.lastSeenStreamMessage.put(filter.resolvedPlayerGuid.guid, SessionAvatarHandlers.LastUpstream(Some(pstateToSave), visible=false, wasShooting, now))
+          ops.lastSeenStreamMessage.put(resolvedGuid.guid, SessionAvatarHandlers.LastUpstream(Some(pstateToSave), visible=false, wasShooting, now))
         } else {
           //skip drawing altogether
-          ops.lastSeenStreamMessage.put(filter.resolvedPlayerGuid.guid, SessionAvatarHandlers.LastUpstream(Some(pstateToSave), visible=false, wasShooting, lastTime))
+          ops.lastSeenStreamMessage.put(resolvedGuid.guid, SessionAvatarHandlers.LastUpstream(Some(pstateToSave), visible=false, wasShooting, lastTime))
         }
       }
 
     case AvatarAction.ObjectHeld(slot, _)
-      if filter.isSameTarget && player.VisibleSlots.contains(slot) =>
-      sendResponse(ObjectHeldMessage(filter.resolvedPlayerGuid, slot, unk1=true))
+      if isSameTarget && player.VisibleSlots.contains(slot) =>
+      sendResponse(ObjectHeldMessage(resolvedGuid, slot, unk1=true))
       //Stop using proximity terminals if player unholsters a weapon
       continent.GUID(sessionLogic.terminals.usingMedicalTerminal).collect {
         case term: Terminal with ProximityUnit => sessionLogic.terminals.StopUsingProximityUnit(term)
@@ -160,31 +160,31 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
       }
 
     case AvatarAction.ObjectHeld(slot, _)
-      if filter.isSameTarget && slot > -1 =>
-      sendResponse(ObjectHeldMessage(filter.resolvedPlayerGuid, slot, unk1=true))
+      if isSameTarget && slot > -1 =>
+      sendResponse(ObjectHeldMessage(resolvedGuid, slot, unk1=true))
 
     case AvatarAction.ObjectHeld(_, _)
-      if filter.isSameTarget => ()
+      if isSameTarget => ()
 
     case AvatarAction.ObjectHeld(_, previousSlot) =>
-      sendResponse(ObjectHeldMessage(filter.resolvedPlayerGuid, previousSlot, unk1=false))
+      sendResponse(ObjectHeldMessage(resolvedGuid, previousSlot, unk1=false))
 
     case ChangeFireState_Start(weaponGuid)
-      if filter.isNotSameTarget && ops.lastSeenStreamMessage.get(filter.resolvedPlayerGuid.guid).exists { _.visible } =>
+      if isNotSameTarget && ops.lastSeenStreamMessage.get(resolvedGuid.guid).exists { _.visible } =>
       sendResponse(ChangeFireStateMessage_Start(weaponGuid))
-      val entry = ops.lastSeenStreamMessage(filter.resolvedPlayerGuid.guid)
-      ops.lastSeenStreamMessage.put(filter.resolvedPlayerGuid.guid, entry.copy(shooting = Some(weaponGuid)))
+      val entry = ops.lastSeenStreamMessage(resolvedGuid.guid)
+      ops.lastSeenStreamMessage.put(resolvedGuid.guid, entry.copy(shooting = Some(weaponGuid)))
 
     case ChangeFireState_Stop(weaponGuid)
-      if filter.isNotSameTarget && ops.lastSeenStreamMessage.get(filter.resolvedPlayerGuid.guid).exists { msg => msg.visible || msg.shooting.nonEmpty } =>
+      if isNotSameTarget && ops.lastSeenStreamMessage.get(resolvedGuid.guid).exists { msg => msg.visible || msg.shooting.nonEmpty } =>
       sendResponse(ChangeFireStateMessage_Stop(weaponGuid))
-      val entry = ops.lastSeenStreamMessage(filter.resolvedPlayerGuid.guid)
-      ops.lastSeenStreamMessage.put(filter.resolvedPlayerGuid.guid, entry.copy(shooting = None))
+      val entry = ops.lastSeenStreamMessage(resolvedGuid.guid)
+      ops.lastSeenStreamMessage.put(resolvedGuid.guid, entry.copy(shooting = None))
 
-    case AvatarAction.LoadCreatedPlayer(pkt) if filter.isNotSameTarget =>
+    case AvatarAction.LoadCreatedPlayer(pkt) if isNotSameTarget =>
       sendResponse(pkt)
 
-    case AvatarAction.EquipmentCreatedInHand(pkt) if filter.isNotSameTarget =>
+    case AvatarAction.EquipmentCreatedInHand(pkt) if isNotSameTarget =>
       sendResponse(pkt)
 
     case AvatarAction.Destroy(victim, killer, weapon, pos) =>
@@ -217,7 +217,7 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
     inventory,
     drop,
     delete
-    ) if filter.resolvedPlayerGuid == target =>
+    ) if resolvedGuid == target =>
       sendResponse(ArmorChangedMessage(target, exosuit, subtype))
       sendResponse(PlanetsideAttributeMessage(target, attribute_type=4, armor))
       //happening to this player
@@ -295,7 +295,7 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
     oldInventory,
     inventory,
     drops
-    ) if filter.resolvedPlayerGuid == target =>
+    ) if resolvedGuid == target =>
       sendResponse(ArmorChangedMessage(target, exosuit, subtype))
       sendResponse(PlanetsideAttributeMessage(target, attribute_type = 4, armor))
       //happening to this player
@@ -329,9 +329,9 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
     case AvatarAction.UseKit(kguid, kObjId) =>
       sendResponse(
         UseItemMessage(
-          filter.resolvedPlayerGuid,
+          resolvedGuid,
           kguid,
-          filter.resolvedPlayerGuid,
+          resolvedGuid,
           unk2 = 4294967295L,
           unk3 = false,
           unk4 = Vector3.Zero,
@@ -386,7 +386,7 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
 
     /* common messages (maybe once every respawn) */
     case ReloadTool(itemGuid)
-      if filter.isNotSameTarget && ops.lastSeenStreamMessage.get(filter.resolvedPlayerGuid.guid).exists { _.visible } =>
+      if isNotSameTarget && ops.lastSeenStreamMessage.get(resolvedGuid.guid).exists { _.visible } =>
       sendResponse(ReloadMessage(itemGuid, ammo_clip=1, unk1=0))
 
     case AvatarAction.Killed(_, mount) =>
@@ -440,10 +440,10 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
         sessionLogic.zoning.spawn.HandleReleaseAvatar(player, continent)
       }
 
-    case AvatarAction.ReleasePlayer(tplayer) if filter.isNotSameTarget =>
+    case AvatarAction.ReleasePlayer(tplayer) if isNotSameTarget =>
       sessionLogic.zoning.spawn.DepictPlayerAsCorpse(tplayer)
 
-    case AvatarAction.Revive(revivalTargetGuid) if filter.resolvedPlayerGuid == revivalTargetGuid =>
+    case AvatarAction.Revive(revivalTargetGuid) if resolvedGuid == revivalTargetGuid =>
       log.info(s"No time for rest, ${player.Name}.  Back on your feet!")
       sessionLogic.zoning.spawn.reviveTimer.cancel()
       sessionLogic.zoning.spawn.deadState = DeadState.Alive
@@ -458,18 +458,18 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
 
     /* uncommon messages (utility, or once in a while) */
     case ChangeAmmo(weapon_guid, weapon_slot, previous_guid, ammo_id, ammo_guid, ammo_data)
-      if filter.isNotSameTarget && ops.lastSeenStreamMessage.get(filter.resolvedPlayerGuid.guid).exists { _.visible } =>
+      if isNotSameTarget && ops.lastSeenStreamMessage.get(resolvedGuid.guid).exists { _.visible } =>
       ops.changeAmmoProcedure(weapon_guid, previous_guid, ammo_id, ammo_guid, weapon_slot, ammo_data)
       sendResponse(ChangeAmmoMessage(weapon_guid, 1))
 
-    case AvatarAction.ChangeFireMode(itemGuid, mode) if filter.isNotSameTarget =>
+    case AvatarAction.ChangeFireMode(itemGuid, mode) if isNotSameTarget =>
       sendResponse(ChangeFireModeMessage(itemGuid, mode))
 
     case AvatarAction.EnvironmentalDamage(_, _, _) =>
       //TODO damage marker?
       sessionLogic.zoning.CancelZoningProcess()
 
-    case AvatarAction.DropCreatedItem(pkt) if filter.isNotSameTarget =>
+    case AvatarAction.DropCreatedItem(pkt) if isNotSameTarget =>
       sendResponse(pkt)
 
     /* rare messages */
@@ -482,10 +482,10 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
         vehicle.flatMap { vinfo => Some(DrowningTarget(vinfo.guid, vinfo.progress, vinfo.state)) }
       ))
 
-    case AvatarAction.LoadCreatedProjectile(pkt) if filter.isNotSameTarget =>
+    case AvatarAction.LoadCreatedProjectile(pkt) if isNotSameTarget =>
       sendResponse(pkt)
 
-    case AvatarAction.ProjectileState(projectileGuid, shotPos, shotVel, shotOrient, seq, end, targetGuid) if filter.isNotSameTarget =>
+    case AvatarAction.ProjectileState(projectileGuid, shotPos, shotVel, shotOrient, seq, end, targetGuid) if isNotSameTarget =>
       sendResponse(ProjectileStateMessage(projectileGuid, shotPos, shotVel, shotOrient, seq, end, targetGuid))
 
     case AvatarAction.ProjectileExplodes(projectileGuid, projectile) =>
@@ -505,10 +505,10 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
     case AvatarAction.ProjectileAutoLockAwareness(mode) =>
       sendResponse(GenericActionMessage(mode))
 
-    case AvatarAction.PutDownFDU(target) if filter.isNotSameTarget =>
+    case AvatarAction.PutDownFDU(target) if isNotSameTarget =>
       sendResponse(GenericObjectActionMessage(target, code=53))
 
-    case AvatarAction.StowEquipment(target, slot, item) if filter.isNotSameTarget =>
+    case AvatarAction.StowEquipment(target, slot, item) if isNotSameTarget =>
       val definition = item.Definition
       sendResponse(
         ObjectCreateDetailedMessage(
@@ -520,7 +520,7 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
       )
 
     case WeaponDryFire(weaponGuid)
-      if filter.isNotSameTarget && ops.lastSeenStreamMessage.get(filter.resolvedPlayerGuid.guid).exists { _.visible } =>
+      if isNotSameTarget && ops.lastSeenStreamMessage.get(resolvedGuid.guid).exists { _.visible } =>
       continent.GUID(weaponGuid).collect {
         case tool: Tool if tool.Magazine == 0 =>
           // check that the magazine is still empty before sending WeaponDryFireMessage
diff --git a/src/main/scala/net/psforever/actors/session/spectator/VehicleHandlerLogic.scala b/src/main/scala/net/psforever/actors/session/spectator/VehicleHandlerLogic.scala
index 3b6a1b96e..b1c1e4fbb 100644
--- a/src/main/scala/net/psforever/actors/session/spectator/VehicleHandlerLogic.scala
+++ b/src/main/scala/net/psforever/actors/session/spectator/VehicleHandlerLogic.scala
@@ -40,7 +40,7 @@ class VehicleHandlerLogic(val ops: SessionVehicleHandlers, implicit val context:
     wheelDirection,
     unk5,
     unk6
-    ) if filter.isNotSameTarget && player.VehicleSeated.contains(vehicleGuid) =>
+    ) if isNotSameTarget && player.VehicleSeated.contains(vehicleGuid) =>
       //player who is also in the vehicle (not driver)
       sendResponse(VehicleStateMessage(vehicleGuid, unk1, pos, orient, vel, unk2, unk3, unk4, wheelDirection, unk5, unk6))
       player.Position = pos
@@ -60,30 +60,30 @@ class VehicleHandlerLogic(val ops: SessionVehicleHandlers, implicit val context:
     wheelDirection,
     unk5,
     unk6
-    ) if filter.isNotSameTarget =>
+    ) if isNotSameTarget =>
       //player who is watching the vehicle from the outside
       sendResponse(VehicleStateMessage(vehicleGuid, unk1, pos, ang, vel, unk2, unk3, unk4, wheelDirection, unk5, unk6))
 
-    case VehicleAction.ChildObjectState(objectGuid, pitch, yaw) if filter.isNotSameTarget =>
+    case VehicleAction.ChildObjectState(objectGuid, pitch, yaw) if isNotSameTarget =>
       sendResponse(ChildObjectStateMessage(objectGuid, pitch, yaw))
 
     case VehicleAction.FrameVehicleState(vguid, u1, pos, oient, vel, u2, u3, u4, is_crouched, u6, u7, u8, u9, uA)
-      if filter.isNotSameTarget =>
+      if isNotSameTarget =>
       sendResponse(FrameVehicleStateMessage(vguid, u1, pos, oient, vel, u2, u3, u4, is_crouched, u6, u7, u8, u9, uA))
 
-    case VehicleAction.DismountVehicle(bailType, wasKickedByDriver) if filter.isNotSameTarget =>
-      sendResponse(DismountVehicleMsg(filter.resolvedPlayerGuid, bailType, wasKickedByDriver))
+    case VehicleAction.DismountVehicle(bailType, wasKickedByDriver) if isNotSameTarget =>
+      sendResponse(DismountVehicleMsg(resolvedGuid, bailType, wasKickedByDriver))
 
-    case VehicleAction.MountVehicle(vehicleGuid, seat) if filter.isNotSameTarget =>
-      sendResponse(ObjectAttachMessage(vehicleGuid, filter.resolvedPlayerGuid, seat))
+    case VehicleAction.MountVehicle(vehicleGuid, seat) if isNotSameTarget =>
+      sendResponse(ObjectAttachMessage(vehicleGuid, resolvedGuid, seat))
 
-    case VehicleAction.DeployRequest(objectGuid, state, unk1, unk2, pos) if filter.isNotSameTarget =>
-      sendResponse(DeployRequestMessage(filter.resolvedPlayerGuid, objectGuid, state, unk1, unk2, pos))
+    case VehicleAction.DeployRequest(objectGuid, state, unk1, unk2, pos) if isNotSameTarget =>
+      sendResponse(DeployRequestMessage(resolvedGuid, objectGuid, state, unk1, unk2, pos))
 
-    case VehicleAction.EquipmentCreatedInSlot(pkt) if filter.isNotSameTarget =>
+    case VehicleAction.EquipmentCreatedInSlot(pkt) if isNotSameTarget =>
       sendResponse(pkt)
 
-    case VehicleAction.InventoryState(obj, parentGuid, start, conData) if filter.isNotSameTarget =>
+    case VehicleAction.InventoryState(obj, parentGuid, start, conData) if isNotSameTarget =>
       //TODO prefer ObjectDetachMessage, but how to force ammo pools to update properly?
       val objGuid = obj.GUID
       sendResponse(ObjectDeleteMessage(objGuid, unk1=0))
@@ -94,10 +94,10 @@ class VehicleHandlerLogic(val ops: SessionVehicleHandlers, implicit val context:
         conData
       ))
 
-    case VehicleAction.KickPassenger(_, wasKickedByDriver, vehicleGuid) if filter.isSameTarget =>
+    case VehicleAction.KickPassenger(_, wasKickedByDriver, vehicleGuid) if isSameTarget =>
       //seat number (first field) seems to be correct if passenger is kicked manually by driver
       //but always seems to return 4 if user is kicked by mount permissions changing
-      sendResponse(DismountVehicleMsg(filter.resolvedPlayerGuid, BailType.Kicked, wasKickedByDriver))
+      sendResponse(DismountVehicleMsg(resolvedGuid, BailType.Kicked, wasKickedByDriver))
       continent.GUID(vehicleGuid) match {
         case Some(obj: Vehicle) =>
           sessionLogic.general.unaccessContainer(obj)
@@ -107,23 +107,23 @@ class VehicleHandlerLogic(val ops: SessionVehicleHandlers, implicit val context:
     case VehicleAction.KickPassenger(_, wasKickedByDriver, _) =>
       //seat number (first field) seems to be correct if passenger is kicked manually by driver
       //but always seems to return 4 if user is kicked by mount permissions changing
-      sendResponse(DismountVehicleMsg(filter.resolvedPlayerGuid, BailType.Kicked, wasKickedByDriver))
+      sendResponse(DismountVehicleMsg(resolvedGuid, BailType.Kicked, wasKickedByDriver))
 
-    case VehicleAction.InventoryState2(objGuid, parentGuid, value) if filter.isNotSameTarget =>
+    case VehicleAction.InventoryState2(objGuid, parentGuid, value) if isNotSameTarget =>
       sendResponse(InventoryStateMessage(objGuid, unk=0, parentGuid, value))
 
-    case VehicleAction.LoadVehicle(vehicle, vtype, vguid, vdata) if filter.isNotSameTarget =>
+    case VehicleAction.LoadVehicle(vehicle, vtype, vguid, vdata) if isNotSameTarget =>
       //this is not be suitable for vehicles with people who are seated in it before it spawns (if that is possible)
       sendResponse(ObjectCreateMessage(vtype, vguid, vdata))
       Vehicles.ReloadAccessPermissions(vehicle, player.Name)
 
-    case VehicleAction.SeatPermissions(vehicleGuid, seatGroup, permission) if filter.isNotSameTarget =>
+    case VehicleAction.SeatPermissions(vehicleGuid, seatGroup, permission) if isNotSameTarget =>
       sendResponse(PlanetsideAttributeMessage(vehicleGuid, seatGroup, permission))
 
     case VehicleAction.UnloadVehicle(_, vehicleGuid) =>
       sendResponse(ObjectDeleteMessage(vehicleGuid, unk1=1))
 
-    case VehicleAction.UnstowEquipment(itemGuid) if filter.isNotSameTarget =>
+    case VehicleAction.UnstowEquipment(itemGuid) if isNotSameTarget =>
       //TODO prefer ObjectDetachMessage, but how to force ammo pools to update properly?
       sendResponse(ObjectDeleteMessage(itemGuid, unk1=0))
 
diff --git a/src/main/scala/net/psforever/actors/session/support/CommonHandlerFunctions.scala b/src/main/scala/net/psforever/actors/session/support/CommonHandlerFunctions.scala
index 4dc165152..5e2020e31 100644
--- a/src/main/scala/net/psforever/actors/session/support/CommonHandlerFunctions.scala
+++ b/src/main/scala/net/psforever/actors/session/support/CommonHandlerFunctions.scala
@@ -10,17 +10,24 @@ import net.psforever.types.PlanetSideGUID
 trait HandlerFilter {
   def resolvedPlayerGuid: PlanetSideGUID
   def isNotSameTarget: Boolean
-  def isSameTarget: Boolean = !isNotSameTarget
+  def isSameTarget: Boolean
 }
 
-class HandlerFilterClass(guid1: PlanetSideGUID, guid2: PlanetSideGUID) extends HandlerFilter {
-  val resolvedPlayerGuid: PlanetSideGUID = guid2
-  val isNotSameTarget: Boolean = resolvedPlayerGuid != guid1
-}
+case class HandlerFilterRules(
+                               resolvedPlayerGuid: PlanetSideGUID,
+                               isNotSameTarget: Boolean,
+                               isSameTarget: Boolean
+                             ) extends HandlerFilter
 
 object HandlerFilter {
+  def apply(guid: PlanetSideGUID, isNotSameTarget: Boolean): HandlerFilter = {
+    HandlerFilterRules(guid, isNotSameTarget, !isNotSameTarget)
+  }
+
   def apply(guid1: PlanetSideGUID, guid2: PlanetSideGUID): HandlerFilter = {
-    new HandlerFilterClass(guid1, guid2)
+    val resolvedPlayerGuid: PlanetSideGUID = guid2
+    val isNotSameTarget: Boolean = resolvedPlayerGuid != guid1
+    this(guid2, isNotSameTarget)
   }
 
   def apply(guid: PlanetSideGUID, player: Player): HandlerFilter = {
@@ -31,17 +38,9 @@ object HandlerFilter {
     })
   }
 
-  final val NeverAllow: HandlerFilter = new HandlerFilter {
-    def resolvedPlayerGuid: PlanetSideGUID = PlanetSideGUID(-1)
-    def isNotSameTarget: Boolean = false
-    override def isSameTarget: Boolean = false
-  }
+  final val NeverAllow: HandlerFilter = HandlerFilterRules(PlanetSideGUID(-1), isNotSameTarget = false, isSameTarget = false)
 
-  final def Allow(guid: PlanetSideGUID): HandlerFilter = new HandlerFilter {
-    def resolvedPlayerGuid: PlanetSideGUID = guid
-    def isNotSameTarget: Boolean = true
-    override def isSameTarget: Boolean = true
-  }
+  final def Allow(guid: PlanetSideGUID): HandlerFilter = HandlerFilterRules(guid, isNotSameTarget = true, isSameTarget = true)
 }
 
 trait CommonHandlerFunctionsBase {
@@ -62,7 +61,13 @@ trait CommonHandlerFunctionsBase {
 
 trait CommonHandlerFunctions extends CommonHandlerFunctionsBase {
   _: CommonSessionInterfacingFunctionality =>
-  protected var filter: HandlerFilter = HandlerFilter.NeverAllow
+  private var filter: HandlerFilter = HandlerFilter.NeverAllow
+
+  def resolvedGuid: PlanetSideGUID = filter.resolvedPlayerGuid
+
+  def isNotSameTarget: Boolean = filter.isNotSameTarget
+
+  def isSameTarget: Boolean = filter.isSameTarget
 
   /**
    * na
diff --git a/src/main/scala/net/psforever/actors/session/support/CommonHandlerLogic.scala b/src/main/scala/net/psforever/actors/session/support/CommonHandlerLogic.scala
index e66a4e84c..c0e5772b9 100644
--- a/src/main/scala/net/psforever/actors/session/support/CommonHandlerLogic.scala
+++ b/src/main/scala/net/psforever/actors/session/support/CommonHandlerLogic.scala
@@ -12,36 +12,36 @@ class CommonHandlerLogic(val sessionLogic: SessionData, implicit val context: Ac
 
   def receive: Receive = {
     case PlanetsideAttribute(target_guid, attributeType, attributeValue)
-      if filter.isNotSameTarget =>
+      if isNotSameTarget =>
       sendResponse(PlanetsideAttributeMessage(target_guid, attributeType, attributeValue))
 
     case GenericObjectAction(objectGuid, actionCode)
-      if filter.isNotSameTarget =>
+      if isNotSameTarget =>
       sendResponse(GenericObjectActionMessage(objectGuid, actionCode))
 
     case ObjectDelete(itemGuid, unk)
-      if filter.isNotSameTarget =>
+      if isNotSameTarget =>
       sendResponse(ObjectDeleteMessage(itemGuid, unk))
 
     case ChangeFireState_Start(weaponGuid)
-      if filter.isNotSameTarget =>
+      if isNotSameTarget =>
       sendResponse(ChangeFireStateMessage_Start(weaponGuid))
 
     case ChangeFireState_Stop(weaponGuid)
-      if filter.isNotSameTarget =>
+      if isNotSameTarget =>
       sendResponse(ChangeFireStateMessage_Stop(weaponGuid))
 
     case ReloadTool(itemGuid)
-      if filter.isNotSameTarget =>
+      if isNotSameTarget =>
       sendResponse(ReloadMessage(itemGuid, ammo_clip=1, unk1=0))
 
     case ChangeAmmo(weapon_guid, weapon_slot, previous_guid, ammo_id, ammo_guid, ammo_data)
-      if filter.isNotSameTarget =>
+      if isNotSameTarget =>
       sessionLogic.avatarResponse.changeAmmoProcedure(weapon_guid, previous_guid, ammo_id, ammo_guid, weapon_slot, ammo_data)
       sendResponse(ChangeAmmoMessage(weapon_guid, 1))
 
     case WeaponDryFire(weaponGuid)
-      if filter.isNotSameTarget =>
+      if isNotSameTarget =>
       continent.GUID(weaponGuid).collect {
         case tool: Tool if tool.Magazine == 0 =>
           // check that the magazine is still empty before sending WeaponDryFireMessage
@@ -51,15 +51,15 @@ class CommonHandlerLogic(val sessionLogic: SessionData, implicit val context: Ac
 
     case HintsAtAttacker(sourceGuid)
       if player.isAlive =>
-      sendResponse(HitHint(sourceGuid, filter.resolvedPlayerGuid))
+      sendResponse(HitHint(sourceGuid, resolvedGuid))
       sessionLogic.zoning.CancelZoningProcessWithDescriptiveReason("cancel_dmg")
 
     case SetEmpire(objectGuid, faction)
-      if filter.isNotSameTarget =>
+      if isNotSameTarget =>
       sendResponse(SetEmpireMessage(objectGuid, faction))
 
     case ConcealPlayer(_) =>
-      sendResponse(GenericObjectActionMessage(filter.resolvedPlayerGuid, code=9))
+      sendResponse(GenericObjectActionMessage(resolvedGuid, code=9))
 
     case SendResponse(msgs) =>
       msgs.foreach(sendResponse)