PSForever/PSF-LoginServer
1
0
Fork 0
mirror of https://github.com/psforever/PSF-LoginServer.git synced 2026-07-16 00:44:46 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

wrong filters used to retrieve other player data; re-use the same filter rather than create a new one

Browse source
This commit is contained in:
Fate-JH 2026-04-05 14:13:13 -04:00
parent d1cc964a4c
commit 1e34e8239c
11 changed files with 168 additions and 172 deletions
Download patch file Download diff file Expand all files Collapse all files

79
src/main/scala/net/psforever/actors/session/SessionActor.scala
View file

@ -3,7 +3,7 @@ package net.psforever.actors.session
import akka.actor.{Actor, ActorRef, Cancellable, MDCContextAware, typed} import akka.actor.{Actor, ActorRef, Cancellable, MDCContextAware, typed}
import net.psforever.actors.session.normal.NormalMode import net.psforever.actors.session.normal.NormalMode
import net.psforever.actors.session.support.{CommonHandlerFunctions, CommonHandlerLogic, HandlerFilter, ZoningOperations} import net.psforever.actors.session.support.{CommonHandlerFunctions, CommonHandlerFunctionsBase, CommonHandlerLogic, HandlerFilter, ZoningOperations}
import net.psforever.objects.TurretDeployable import net.psforever.objects.TurretDeployable
import net.psforever.objects.serverobject.CommonMessages import net.psforever.objects.serverobject.CommonMessages
import net.psforever.objects.serverobject.containable.Containable import net.psforever.objects.serverobject.containable.Containable
@ -123,7 +123,7 @@ class SessionActor(middlewareActor: typed.ActorRef[MiddlewareActor.Command], con
buffer.addOne(msg) buffer.addOne(msg)
case _ if data.whenAllEventBusesLoaded() => case _ if data.whenAllEventBusesLoaded() =>
context.become(inTheGame) context.become(inTheGame)
logic = mode.setup(data) changeModeSetup(mode)
buffer.foreach { self.tell(_, self) } //we forget the original sender, shouldn't be doing callbacks at this point buffer.foreach { self.tell(_, self) } //we forget the original sender, shouldn't be doing callbacks at this point
buffer.clear() buffer.clear()
case _ => () case _ => ()
@ -164,18 +164,22 @@ class SessionActor(middlewareActor: typed.ActorRef[MiddlewareActor.Command], con
if (mode != newMode) { if (mode != newMode) {
logic.switchFrom(data.session) logic.switchFrom(data.session)
mode = newMode mode = newMode
logic = newMode.setup(data) changeModeSetup(newMode)
listOfHandlers = List(
logic.avatarResponse,
logic.local,
logic.vehicleResponse,
logic.galaxy,
commonHandlerLogic
)
} }
logic.switchTo(data.session) logic.switchTo(data.session)
} }
private def changeModeSetup(newMode: PlayerMode): Unit = {
logic = newMode.setup(data)
listOfHandlers = List(
logic.avatarResponse,
logic.local,
logic.vehicleResponse,
logic.galaxy,
commonHandlerLogic
)
}
private def parse(sender: ActorRef): Receive = { private def parse(sender: ActorRef): Receive = {
/* really common messages (very frequently, every life) */ /* really common messages (very frequently, every life) */
case packet: PlanetSideGamePacket => case packet: PlanetSideGamePacket =>
@ -372,39 +376,46 @@ class SessionActor(middlewareActor: typed.ActorRef[MiddlewareActor.Command], con
} }
private def handleGenericResponseEnvelope(envelope: GenericResponseEnvelope): Unit = { private def handleGenericResponseEnvelope(envelope: GenericResponseEnvelope): Unit = {
val GenericResponseEnvelope(_, guid, reply) = envelope
//try use the stamp to match the specific handler //try use the stamp to match the specific handler
val primaryHandler = envelope.stamp match { envelope.stamp match {
case Undelivered => case Undelivered =>
val GenericResponseEnvelope(_, _, reply) = envelope
log.error(s"received a message's response that was not processed by an event system - $reply") log.error(s"received a message's response that was not processed by an event system - $reply")
CommonHandlerFunctions.HandleAnything
case AvatarStamp => case AvatarStamp =>
logic.avatarResponse handleEnvelopeWithResponseHandler(logic.avatarResponse, envelope)
case LocalStamp => case LocalStamp =>
logic.local handleEnvelopeWithResponseHandler(logic.local, envelope)
case VehicleStamp => case VehicleStamp =>
logic.vehicleResponse handleEnvelopeWithResponseHandler(logic.vehicleResponse, envelope)
case GalaxyStamp => case GalaxyStamp =>
logic.galaxy handleEnvelopeWithResponseHandler(logic.galaxy, envelope)
case unknownStamp => case unknownStamp =>
log.error(s"received a message's response from an unknown event system - stamp: $unknownStamp") log.error(s"received a message from an unknown event system - reply: $envelope, stamp: $unknownStamp")
CommonHandlerFunctions.HandleNothing
} }
//try the handler on the input message }
val filter = HandlerFilter(guid, data.player)
lazy val alwaysAllowFilter = HandlerFilter.Allow(guid) private def handleEnvelopeWithResponseHandler(
if (primaryHandler.handleWith(filter).isDefinedAt(reply)) { responseHandler: CommonHandlerFunctionsBase,
primaryHandler.receive.apply(reply) envelope: GenericResponseEnvelope
} else if (!primaryHandler.handleWith(alwaysAllowFilter).isDefinedAt(reply)) { ): Unit = {
//check a list of all handlers for any potentially valid case val GenericResponseEnvelope(_, guid, reply) = envelope
val potentiallyValidHandlers = listOfHandlers.filter(_.handleWith(alwaysAllowFilter).isDefinedAt(reply)) //try the expected handler with the input response
if (potentiallyValidHandlers.nonEmpty) { val filter = HandlerFilter.set(data.handlerFilter, guid, data.player)
potentiallyValidHandlers if (responseHandler.isDefinedAt(reply)) {
.find(_.handleWith(filter).isDefinedAt(reply)) responseHandler.receive.apply(reply)
.foreach(_.receive.apply(reply)) } else {
//arrive here without processing input, the guard for a handler blocked a case; not gonna fault //find any handler that might receive the response (ignore guard booleans during search)
} else { data.handlerFilter.set(guid, guid, notSame = true, same = true)
log.error(s"received completely unhandled response message - $envelope") if (!responseHandler.isDefinedAt(reply)) {
val potentiallyValidHandlers = listOfHandlers.filter(_.isDefinedAt(reply))
if (potentiallyValidHandlers.nonEmpty) {
data.handlerFilter.set(filter)
potentiallyValidHandlers
.find(_.isDefinedAt(reply))
.foreach(_.receive.apply(reply))
} else {
log.error(s"received completely unhandled response message - $envelope for ${envelope.stamp}")
}
} }
} }
} }

40
src/main/scala/net/psforever/actors/session/csr/AvatarHandlerLogic.scala
View file

@ -82,7 +82,7 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
canSeeReallyFar canSeeReallyFar
) if isNotSameTarget => ) if isNotSameTarget =>
val pstateToSave = pstate.copy(timestamp = 0) val pstateToSave = pstate.copy(timestamp = 0)
val (lastMsg, lastTime, lastPosition, wasVisible, wasShooting) = ops.lastSeenStreamMessage.get(resolvedGuid.guid) match { val (lastMsg, lastTime, lastPosition, wasVisible, wasShooting) = ops.lastSeenStreamMessage.get(filterGuid.guid) match {
case Some(SessionAvatarHandlers.LastUpstream(Some(msg), visible, shooting, time)) => (Some(msg), time, msg.pos, visible, shooting) case Some(SessionAvatarHandlers.LastUpstream(Some(msg), visible, shooting, time)) => (Some(msg), time, msg.pos, visible, shooting)
case _ => (None, 0L, Vector3.Zero, false, None) case _ => (None, 0L, Vector3.Zero, false, None)
} }
@ -125,7 +125,7 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
//must draw //must draw
sendResponse( sendResponse(
PlayerStateMessage( PlayerStateMessage(
resolvedGuid, filterGuid,
pos, pos,
vel, vel,
yaw, yaw,
@ -138,10 +138,10 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
isCloaking isCloaking
) )
) )
ops.lastSeenStreamMessage.put(resolvedGuid.guid, SessionAvatarHandlers.LastUpstream(Some(pstateToSave), visible=true, wasShooting, now)) ops.lastSeenStreamMessage.put(filterGuid.guid, SessionAvatarHandlers.LastUpstream(Some(pstateToSave), visible=true, wasShooting, now))
} else { } else {
//is visible, but skip reinforcement //is visible, but skip reinforcement
ops.lastSeenStreamMessage.put(resolvedGuid.guid, SessionAvatarHandlers.LastUpstream(Some(pstateToSave), visible=true, wasShooting, lastTime)) ops.lastSeenStreamMessage.put(filterGuid.guid, SessionAvatarHandlers.LastUpstream(Some(pstateToSave), visible=true, wasShooting, lastTime))
} }
} else { } else {
//conditions where the target is not currently visible //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 val lat = (1 + ops.hidingPlayerRandomizer.nextInt(continent.map.scale.height.toInt)).toFloat
sendResponse( sendResponse(
PlayerStateMessage( PlayerStateMessage(
resolvedGuid, filterGuid,
Vector3(1f, lat, 1f), Vector3(1f, lat, 1f),
vel=None, vel=None,
facingYaw=0f, facingYaw=0f,
@ -160,10 +160,10 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
is_cloaked = isCloaking is_cloaked = isCloaking
) )
) )
ops.lastSeenStreamMessage.put(resolvedGuid.guid, SessionAvatarHandlers.LastUpstream(Some(pstateToSave), visible=false, wasShooting, now)) ops.lastSeenStreamMessage.put(filterGuid.guid, SessionAvatarHandlers.LastUpstream(Some(pstateToSave), visible=false, wasShooting, now))
} else { } else {
//skip drawing altogether //skip drawing altogether
ops.lastSeenStreamMessage.put(resolvedGuid.guid, SessionAvatarHandlers.LastUpstream(Some(pstateToSave), visible=false, wasShooting, lastTime)) ops.lastSeenStreamMessage.put(filterGuid.guid, SessionAvatarHandlers.LastUpstream(Some(pstateToSave), visible=false, wasShooting, lastTime))
} }
} }
@ -200,7 +200,7 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
case AvatarAction.ObjectHeld(slot, _) case AvatarAction.ObjectHeld(slot, _)
if isSameTarget && player.VisibleSlots.contains(slot) => if isSameTarget && player.VisibleSlots.contains(slot) =>
sendResponse(ObjectHeldMessage(resolvedGuid, slot, unk1=true)) sendResponse(ObjectHeldMessage(filterGuid, slot, unk1=true))
//Stop using proximity terminals if player unholsters a weapon //Stop using proximity terminals if player unholsters a weapon
continent.GUID(sessionLogic.terminals.usingMedicalTerminal).collect { continent.GUID(sessionLogic.terminals.usingMedicalTerminal).collect {
case term: Terminal with ProximityUnit => sessionLogic.terminals.StopUsingProximityUnit(term) case term: Terminal with ProximityUnit => sessionLogic.terminals.StopUsingProximityUnit(term)
@ -211,25 +211,25 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
case AvatarAction.ObjectHeld(slot, _) case AvatarAction.ObjectHeld(slot, _)
if isSameTarget && slot > -1 => if isSameTarget && slot > -1 =>
sendResponse(ObjectHeldMessage(resolvedGuid, slot, unk1=true)) sendResponse(ObjectHeldMessage(filterGuid, slot, unk1=true))
case AvatarAction.ObjectHeld(_, _) case AvatarAction.ObjectHeld(_, _)
if isSameTarget => () if isSameTarget => ()
case AvatarAction.ObjectHeld(_, previousSlot) => case AvatarAction.ObjectHeld(_, previousSlot) =>
sendResponse(ObjectHeldMessage(resolvedGuid, previousSlot, unk1=false)) sendResponse(ObjectHeldMessage(filterGuid, previousSlot, unk1=false))
case ChangeFireState_Start(weaponGuid) case ChangeFireState_Start(weaponGuid)
if isNotSameTarget && ops.lastSeenStreamMessage.get(resolvedGuid.guid).exists { _.visible } => if isNotSameTarget && ops.lastSeenStreamMessage.get(filterGuid.guid).exists { _.visible } =>
sendResponse(ChangeFireStateMessage_Start(weaponGuid)) sendResponse(ChangeFireStateMessage_Start(weaponGuid))
val entry = ops.lastSeenStreamMessage(resolvedGuid.guid) val entry = ops.lastSeenStreamMessage(filterGuid.guid)
ops.lastSeenStreamMessage.put(resolvedGuid.guid, entry.copy(shooting = Some(weaponGuid))) ops.lastSeenStreamMessage.put(filterGuid.guid, entry.copy(shooting = Some(weaponGuid)))
case ChangeFireState_Stop(weaponGuid) case ChangeFireState_Stop(weaponGuid)
if isNotSameTarget && ops.lastSeenStreamMessage.get(resolvedGuid.guid).exists { msg => msg.visible || msg.shooting.nonEmpty } => if isNotSameTarget && ops.lastSeenStreamMessage.get(filterGuid.guid).exists { msg => msg.visible || msg.shooting.nonEmpty } =>
sendResponse(ChangeFireStateMessage_Stop(weaponGuid)) sendResponse(ChangeFireStateMessage_Stop(weaponGuid))
val entry = ops.lastSeenStreamMessage(resolvedGuid.guid) val entry = ops.lastSeenStreamMessage(filterGuid.guid)
ops.lastSeenStreamMessage.put(resolvedGuid.guid, entry.copy(shooting = None)) ops.lastSeenStreamMessage.put(filterGuid.guid, entry.copy(shooting = None))
case AvatarAction.LoadCreatedPlayer(pkt) if isNotSameTarget => case AvatarAction.LoadCreatedPlayer(pkt) if isNotSameTarget =>
sendResponse(pkt) sendResponse(pkt)
@ -411,7 +411,7 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
/* common messages (maybe once every respawn) */ /* common messages (maybe once every respawn) */
case ReloadTool(itemGuid) case ReloadTool(itemGuid)
if isNotSameTarget && ops.lastSeenStreamMessage.get(resolvedGuid.guid).exists { _.visible } => if isNotSameTarget && ops.lastSeenStreamMessage.get(filterGuid.guid).exists { _.visible } =>
sendResponse(ReloadMessage(itemGuid, ammo_clip=1, unk1=0)) sendResponse(ReloadMessage(itemGuid, ammo_clip=1, unk1=0))
case AvatarAction.Killed(_, mount) => case AvatarAction.Killed(_, mount) =>
@ -470,7 +470,7 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
/* uncommon messages (utility, or once in a while) */ /* uncommon messages (utility, or once in a while) */
case ChangeAmmo(weapon_guid, weapon_slot, previous_guid, ammo_id, ammo_guid, ammo_data) case ChangeAmmo(weapon_guid, weapon_slot, previous_guid, ammo_id, ammo_guid, ammo_data)
if isNotSameTarget && ops.lastSeenStreamMessage.get(resolvedGuid.guid).exists { _.visible } => if isNotSameTarget =>
ops.changeAmmoProcedure(weapon_guid, previous_guid, ammo_id, ammo_guid, weapon_slot, ammo_data) ops.changeAmmoProcedure(weapon_guid, previous_guid, ammo_id, ammo_guid, weapon_slot, ammo_data)
sendResponse(ChangeAmmoMessage(weapon_guid, 1)) sendResponse(ChangeAmmoMessage(weapon_guid, 1))
@ -532,11 +532,9 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
) )
case WeaponDryFire(weaponGuid) case WeaponDryFire(weaponGuid)
if isNotSameTarget && ops.lastSeenStreamMessage.get(resolvedGuid.guid).exists { _.visible } => if isNotSameTarget && ops.lastSeenStreamMessage.get(filterGuid.guid).exists { _.visible } =>
continent.GUID(weaponGuid).collect { continent.GUID(weaponGuid).collect {
case tool: Tool if tool.Magazine == 0 => case tool: Tool if tool.Magazine == 0 =>
// check that the magazine is still empty before sending WeaponDryFireMessage
// if it has been reloaded since then, other clients will not see it firing
sendResponse(WeaponDryFireMessage(weaponGuid)) sendResponse(WeaponDryFireMessage(weaponGuid))
} }
} }

43
src/main/scala/net/psforever/actors/session/normal/AvatarHandlerLogic.scala
View file

@ -68,7 +68,7 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
canSeeReallyFar canSeeReallyFar
) if isNotSameTarget => ) if isNotSameTarget =>
val pstateToSave = pstate.copy(timestamp = 0) val pstateToSave = pstate.copy(timestamp = 0)
val (lastMsg, lastTime, lastPosition, wasVisible, wasShooting) = ops.lastSeenStreamMessage.get(resolvedGuid.guid) match { val (lastMsg, lastTime, lastPosition, wasVisible, wasShooting) = ops.lastSeenStreamMessage.get(filterGuid.guid) match {
case Some(SessionAvatarHandlers.LastUpstream(Some(msg), visible, shooting, time)) => (Some(msg), time, msg.pos, visible, shooting) case Some(SessionAvatarHandlers.LastUpstream(Some(msg), visible, shooting, time)) => (Some(msg), time, msg.pos, visible, shooting)
case _ => (None, 0L, Vector3.Zero, false, None) case _ => (None, 0L, Vector3.Zero, false, None)
} }
@ -111,7 +111,7 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
//must draw //must draw
sendResponse( sendResponse(
PlayerStateMessage( PlayerStateMessage(
resolvedGuid, filterGuid,
pos, pos,
vel, vel,
yaw, yaw,
@ -124,10 +124,10 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
isCloaking isCloaking
) )
) )
ops.lastSeenStreamMessage.put(resolvedGuid.guid, SessionAvatarHandlers.LastUpstream(Some(pstateToSave), visible=true, wasShooting, now)) ops.lastSeenStreamMessage.put(filterGuid.guid, SessionAvatarHandlers.LastUpstream(Some(pstateToSave), visible=true, wasShooting, now))
} else { } else {
//is visible, but skip reinforcement //is visible, but skip reinforcement
ops.lastSeenStreamMessage.put(resolvedGuid.guid, SessionAvatarHandlers.LastUpstream(Some(pstateToSave), visible=true, wasShooting, lastTime)) ops.lastSeenStreamMessage.put(filterGuid.guid, SessionAvatarHandlers.LastUpstream(Some(pstateToSave), visible=true, wasShooting, lastTime))
} }
} else { } else {
//conditions where the target is not currently visible //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 val lat = (1 + ops.hidingPlayerRandomizer.nextInt(continent.map.scale.height.toInt)).toFloat
sendResponse( sendResponse(
PlayerStateMessage( PlayerStateMessage(
resolvedGuid, filterGuid,
Vector3(1f, lat, 1f), Vector3(1f, lat, 1f),
vel=None, vel=None,
facingYaw=0f, facingYaw=0f,
@ -146,10 +146,10 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
is_cloaked = isCloaking is_cloaked = isCloaking
) )
) )
ops.lastSeenStreamMessage.put(resolvedGuid.guid, SessionAvatarHandlers.LastUpstream(Some(pstateToSave), visible=false, wasShooting, now)) ops.lastSeenStreamMessage.put(filterGuid.guid, SessionAvatarHandlers.LastUpstream(Some(pstateToSave), visible=false, wasShooting, now))
} else { } else {
//skip drawing altogether //skip drawing altogether
ops.lastSeenStreamMessage.put(resolvedGuid.guid, SessionAvatarHandlers.LastUpstream(Some(pstateToSave), visible=false, wasShooting, lastTime)) ops.lastSeenStreamMessage.put(filterGuid.guid, SessionAvatarHandlers.LastUpstream(Some(pstateToSave), visible=false, wasShooting, lastTime))
} }
} }
@ -186,7 +186,7 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
case AvatarAction.ObjectHeld(slot, _) case AvatarAction.ObjectHeld(slot, _)
if isSameTarget && player.VisibleSlots.contains(slot) => if isSameTarget && player.VisibleSlots.contains(slot) =>
sendResponse(ObjectHeldMessage(resolvedGuid, slot, unk1=true)) sendResponse(ObjectHeldMessage(filterGuid, slot, unk1=true))
//Stop using proximity terminals if player unholsters a weapon //Stop using proximity terminals if player unholsters a weapon
continent.GUID(sessionLogic.terminals.usingMedicalTerminal).collect { continent.GUID(sessionLogic.terminals.usingMedicalTerminal).collect {
case term: Terminal with ProximityUnit => sessionLogic.terminals.StopUsingProximityUnit(term) case term: Terminal with ProximityUnit => sessionLogic.terminals.StopUsingProximityUnit(term)
@ -197,25 +197,25 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
case AvatarAction.ObjectHeld(slot, _) case AvatarAction.ObjectHeld(slot, _)
if isSameTarget && slot > -1 => if isSameTarget && slot > -1 =>
sendResponse(ObjectHeldMessage(resolvedGuid, slot, unk1=true)) sendResponse(ObjectHeldMessage(filterGuid, slot, unk1=true))
case AvatarAction.ObjectHeld(_, _) case AvatarAction.ObjectHeld(_, _)
if isSameTarget => () if isSameTarget => ()
case AvatarAction.ObjectHeld(_, previousSlot) => case AvatarAction.ObjectHeld(_, previousSlot) =>
sendResponse(ObjectHeldMessage(resolvedGuid, previousSlot, unk1=false)) sendResponse(ObjectHeldMessage(filterGuid, previousSlot, unk1=false))
case ChangeFireState_Start(weaponGuid) case ChangeFireState_Start(weaponGuid)
if isNotSameTarget && ops.lastSeenStreamMessage.get(resolvedGuid.guid).exists { _.visible } => if isNotSameTarget && ops.lastSeenStreamMessage.get(filterGuid.guid).exists { _.visible } =>
sendResponse(ChangeFireStateMessage_Start(weaponGuid)) sendResponse(ChangeFireStateMessage_Start(weaponGuid))
val entry = ops.lastSeenStreamMessage(resolvedGuid.guid) val entry = ops.lastSeenStreamMessage(filterGuid.guid)
ops.lastSeenStreamMessage.put(resolvedGuid.guid, entry.copy(shooting = Some(weaponGuid))) ops.lastSeenStreamMessage.put(filterGuid.guid, entry.copy(shooting = Some(weaponGuid)))
case ChangeFireState_Stop(weaponGuid) case ChangeFireState_Stop(weaponGuid)
if isNotSameTarget && ops.lastSeenStreamMessage.get(resolvedGuid.guid).exists { msg => msg.visible || msg.shooting.nonEmpty } => if isNotSameTarget && ops.lastSeenStreamMessage.get(filterGuid.guid).exists { msg => msg.visible || msg.shooting.nonEmpty } =>
sendResponse(ChangeFireStateMessage_Stop(weaponGuid)) sendResponse(ChangeFireStateMessage_Stop(weaponGuid))
val entry = ops.lastSeenStreamMessage(resolvedGuid.guid) val entry = ops.lastSeenStreamMessage(filterGuid.guid)
ops.lastSeenStreamMessage.put(resolvedGuid.guid, entry.copy(shooting = None)) ops.lastSeenStreamMessage.put(filterGuid.guid, entry.copy(shooting = None))
case AvatarAction.LoadCreatedPlayer(pkt) if isNotSameTarget => case AvatarAction.LoadCreatedPlayer(pkt) if isNotSameTarget =>
sendResponse(pkt) sendResponse(pkt)
@ -224,7 +224,7 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
sendResponse(pkt) sendResponse(pkt)
case AvatarAction.PlanetsideStringAttribute(attributeType, attributeValue) => case AvatarAction.PlanetsideStringAttribute(attributeType, attributeValue) =>
sendResponse(PlanetsideStringAttributeMessage(resolvedGuid, attributeType, attributeValue)) sendResponse(PlanetsideStringAttributeMessage(filterGuid, attributeType, attributeValue))
case AvatarAction.Destroy(victim, killer, weapon, pos) => case AvatarAction.Destroy(victim, killer, weapon, pos) =>
// guid = victim // killer = killer // guid = victim // killer = killer
@ -564,11 +564,12 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
/* uncommon messages (utility, or once in a while) */ /* uncommon messages (utility, or once in a while) */
case ChangeAmmo(weapon_guid, weapon_slot, previous_guid, ammo_id, ammo_guid, ammo_data) case ChangeAmmo(weapon_guid, weapon_slot, previous_guid, ammo_id, ammo_guid, ammo_data)
if isNotSameTarget && ops.lastSeenStreamMessage.get(resolvedGuid.guid).exists { _.visible } => if isNotSameTarget =>
ops.changeAmmoProcedure(weapon_guid, previous_guid, ammo_id, ammo_guid, weapon_slot, ammo_data) ops.changeAmmoProcedure(weapon_guid, previous_guid, ammo_id, ammo_guid, weapon_slot, ammo_data)
sendResponse(ChangeAmmoMessage(weapon_guid, 1)) sendResponse(ChangeAmmoMessage(weapon_guid, 1))
case AvatarAction.ChangeFireMode(itemGuid, mode) if isNotSameTarget => case AvatarAction.ChangeFireMode(itemGuid, mode)
if isNotSameTarget =>
sendResponse(ChangeFireModeMessage(itemGuid, mode)) sendResponse(ChangeFireModeMessage(itemGuid, mode))
case AvatarAction.EnvironmentalDamage(_, _, _) => case AvatarAction.EnvironmentalDamage(_, _, _) =>
@ -626,11 +627,9 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
) )
case WeaponDryFire(weaponGuid) case WeaponDryFire(weaponGuid)
if isNotSameTarget && ops.lastSeenStreamMessage.get(resolvedGuid.guid).exists { _.visible } => if isNotSameTarget && ops.lastSeenStreamMessage.get(filterGuid.guid).exists { _.visible } =>
continent.GUID(weaponGuid).collect { continent.GUID(weaponGuid).collect {
case tool: Tool if tool.Magazine == 0 => case tool: Tool if tool.Magazine == 0 =>
// check that the magazine is still empty before sending WeaponDryFireMessage
// if it has been reloaded since then, other clients will not see it firing
sendResponse(WeaponDryFireMessage(weaponGuid)) sendResponse(WeaponDryFireMessage(weaponGuid))
} }
} }

6
src/main/scala/net/psforever/actors/session/normal/LocalHandlerLogic.scala
View file

@ -10,7 +10,7 @@ import net.psforever.objects.serverobject.doors.Door
import net.psforever.objects.vehicles.MountableWeapons import net.psforever.objects.vehicles.MountableWeapons
import net.psforever.objects.{BoomerDeployable, ExplosiveDeployable, TelepadDeployable, Tool, TurretDeployable} import net.psforever.objects.{BoomerDeployable, ExplosiveDeployable, TelepadDeployable, Tool, TurretDeployable}
import net.psforever.packet.game.{ChatMsg, DeployableObjectsInfoMessage, GenericActionMessage, GenericObjectActionMessage, GenericObjectStateMsg, HackMessage, HackState, HackState1, InventoryStateMessage, ObjectAttachMessage, ObjectCreateMessage, ObjectDeleteMessage, ObjectDetachMessage, OrbitalShuttleTimeMsg, PadAndShuttlePair, PlanetsideAttributeMessage, ProximityTerminalUseMessage, TriggerEffectMessage, TriggerSoundMessage, TriggeredSound, VehicleStateMessage} import net.psforever.packet.game.{ChatMsg, DeployableObjectsInfoMessage, GenericActionMessage, GenericObjectActionMessage, GenericObjectStateMsg, HackMessage, HackState, HackState1, InventoryStateMessage, ObjectAttachMessage, ObjectCreateMessage, ObjectDeleteMessage, ObjectDetachMessage, OrbitalShuttleTimeMsg, PadAndShuttlePair, PlanetsideAttributeMessage, ProximityTerminalUseMessage, TriggerEffectMessage, TriggerSoundMessage, TriggeredSound, VehicleStateMessage}
import net.psforever.services.base.message.{GenericObjectAction, PlanetsideAttribute, SendResponse} import net.psforever.services.base.message.{PlanetsideAttribute, SendResponse}
import net.psforever.services.{InterstellarClusterService, Service} import net.psforever.services.{InterstellarClusterService, Service}
import net.psforever.services.local.LocalAction import net.psforever.services.local.LocalAction
import net.psforever.types.{ChatMessageType, SpawnGroup} import net.psforever.types.{ChatMessageType, SpawnGroup}
@ -139,7 +139,7 @@ class LocalHandlerLogic(val ops: SessionLocalHandlers, implicit val context: Act
ops.DeconstructDeployable(obj, dguid, pos, obj.Orientation, effect) ops.DeconstructDeployable(obj, dguid, pos, obj.Orientation, effect)
case LocalAction.HackClear(targetGuid, unk1, unk2) => case LocalAction.HackClear(targetGuid, unk1, unk2) =>
sendResponse(HackMessage(HackState1.Unk0, targetGuid, resolvedGuid, progress=0, unk1.toFloat, HackState.HackCleared, unk2)) sendResponse(HackMessage(HackState1.Unk0, targetGuid, filterGuid, progress=0, unk1.toFloat, HackState.HackCleared, unk2))
case LocalAction.HackObject(targetGuid, unk1, unk2) => case LocalAction.HackObject(targetGuid, unk1, unk2) =>
sessionLogic.general.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) => case LocalAction.UpdateForceDomeStatus(buildingGuid, false) =>
sendResponse(GenericObjectActionMessage(buildingGuid, 12)) sendResponse(GenericObjectActionMessage(buildingGuid, 12))
case LocalAction.RechargeVehicleWeapon(vehicleGuid, weaponGuid) if isSameTarget /*resolvedPlayerGuid == guid*/ => case LocalAction.RechargeVehicleWeapon(vehicleGuid, weaponGuid) if isSameTarget =>
continent.GUID(vehicleGuid) continent.GUID(vehicleGuid)
.collect { case vehicle: MountableWeapons => (vehicle, vehicle.PassengerInSeat(player)) } .collect { case vehicle: MountableWeapons => (vehicle, vehicle.PassengerInSeat(player)) }
.collect { case (vehicle, Some(seat_num)) => vehicle.WeaponControlledFromSeat(seat_num) } .collect { case (vehicle, Some(seat_num)) => vehicle.WeaponControlledFromSeat(seat_num) }

19
src/main/scala/net/psforever/actors/session/normal/VehicleHandlerLogic.scala
View file

@ -6,17 +6,16 @@ import akka.actor.{ActorContext, ActorRef, typed}
import net.psforever.actors.session.AvatarActor import net.psforever.actors.session.AvatarActor
import net.psforever.actors.session.support.{SessionData, SessionVehicleHandlers, VehicleHandlerFunctions} import net.psforever.actors.session.support.{SessionData, SessionVehicleHandlers, VehicleHandlerFunctions}
import net.psforever.objects.avatar.SpecialCarry import net.psforever.objects.avatar.SpecialCarry
import net.psforever.objects.{GlobalDefinitions, Player, Tool, Vehicle, Vehicles} import net.psforever.objects.{GlobalDefinitions, Player, Vehicle, Vehicles}
import net.psforever.objects.equipment.{Equipment, JammableMountedWeapons, JammableUnit} import net.psforever.objects.equipment.{Equipment, JammableMountedWeapons, JammableUnit}
import net.psforever.objects.guid.{GUIDTask, TaskWorkflow} import net.psforever.objects.guid.{GUIDTask, TaskWorkflow}
import net.psforever.objects.serverobject.interior.Sidedness.OutsideOf import net.psforever.objects.serverobject.interior.Sidedness.OutsideOf
import net.psforever.objects.serverobject.mount.Mountable import net.psforever.objects.serverobject.mount.Mountable
import net.psforever.objects.serverobject.pad.VehicleSpawnPad import net.psforever.objects.serverobject.pad.VehicleSpawnPad
import net.psforever.packet.game.objectcreate.ObjectCreateMessageParent import net.psforever.packet.game.objectcreate.ObjectCreateMessageParent
import net.psforever.packet.game.{ChangeAmmoMessage, ChangeFireStateMessage_Start, ChangeFireStateMessage_Stop, ChatMsg, ChildObjectStateMessage, DeadState, DeployRequestMessage, DismountVehicleMsg, FrameVehicleStateMessage, GenericObjectActionMessage, HitHint, InventoryStateMessage, ObjectAttachMessage, ObjectCreateDetailedMessage, ObjectCreateMessage, ObjectDeleteMessage, ObjectDetachMessage, PlanetsideAttributeMessage, ReloadMessage, ServerVehicleOverrideMsg, VehicleStateMessage, WeaponDryFireMessage} import net.psforever.packet.game.{ChatMsg, ChildObjectStateMessage, DeadState, DeployRequestMessage, DismountVehicleMsg, FrameVehicleStateMessage, GenericObjectActionMessage, InventoryStateMessage, ObjectAttachMessage, ObjectCreateDetailedMessage, ObjectCreateMessage, ObjectDeleteMessage, ObjectDetachMessage, PlanetsideAttributeMessage, ServerVehicleOverrideMsg, VehicleStateMessage}
import net.psforever.services.Service import net.psforever.services.Service
import net.psforever.services.base.envelope.GenericResponseEnvelope import net.psforever.services.base.envelope.GenericResponseEnvelope
import net.psforever.services.base.message.{ChangeAmmo, ChangeFireState_Start, ChangeFireState_Stop, GenericObjectAction, HintsAtAttacker, ObjectDelete, PlanetsideAttribute, ReloadTool, SendResponse, WeaponDryFire}
import net.psforever.services.local.support.CaptureFlagManager import net.psforever.services.local.support.CaptureFlagManager
import net.psforever.services.vehicle.{VehicleAction, VehicleStamp} import net.psforever.services.vehicle.{VehicleAction, VehicleStamp}
import net.psforever.types.{BailType, ChatMessageType, PlanetSideGUID, Vector3} import net.psforever.types.{BailType, ChatMessageType, PlanetSideGUID, Vector3}
@ -87,13 +86,13 @@ class VehicleHandlerLogic(val ops: SessionVehicleHandlers, implicit val context:
sendResponse(FrameVehicleStateMessage(vguid, u1, pos, oient, vel, u2, u3, u4, is_crouched, u6, u7, u8, u9, uA)) sendResponse(FrameVehicleStateMessage(vguid, u1, pos, oient, vel, u2, u3, u4, is_crouched, u6, u7, u8, u9, uA))
case VehicleAction.DismountVehicle(bailType, wasKickedByDriver) if isNotSameTarget => case VehicleAction.DismountVehicle(bailType, wasKickedByDriver) if isNotSameTarget =>
sendResponse(DismountVehicleMsg(resolvedGuid, bailType, wasKickedByDriver)) sendResponse(DismountVehicleMsg(filterGuid, bailType, wasKickedByDriver))
case VehicleAction.MountVehicle(vehicleGuid, seat) if isNotSameTarget => case VehicleAction.MountVehicle(vehicleGuid, seat) if isNotSameTarget =>
sendResponse(ObjectAttachMessage(vehicleGuid, resolvedGuid, seat)) sendResponse(ObjectAttachMessage(vehicleGuid, filterGuid, seat))
case VehicleAction.DeployRequest(objectGuid, state, unk1, unk2, pos) if isNotSameTarget => case VehicleAction.DeployRequest(objectGuid, state, unk1, unk2, pos) if isNotSameTarget =>
sendResponse(DeployRequestMessage(resolvedGuid, objectGuid, state, unk1, unk2, pos)) sendResponse(DeployRequestMessage(filterGuid, objectGuid, state, unk1, unk2, pos))
case VehicleAction.EquipmentCreatedInSlot(pkt) if isNotSameTarget => case VehicleAction.EquipmentCreatedInSlot(pkt) if isNotSameTarget =>
sendResponse(pkt) sendResponse(pkt)
@ -109,10 +108,10 @@ class VehicleHandlerLogic(val ops: SessionVehicleHandlers, implicit val context:
conData conData
)) ))
case VehicleAction.KickPassenger(_, wasKickedByDriver, vehicleGuid) if isSameTarget /*resolvedPlayerGuid == guid*/ => case VehicleAction.KickPassenger(_, wasKickedByDriver, vehicleGuid) if isSameTarget =>
//seat number (first field) seems to be correct if passenger is kicked manually by driver //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 //but always seems to return 4 if user is kicked by mount permissions changing
sendResponse(DismountVehicleMsg(resolvedGuid, BailType.Kicked, wasKickedByDriver)) sendResponse(DismountVehicleMsg(filterGuid, BailType.Kicked, wasKickedByDriver))
val typeOfRide = continent.GUID(vehicleGuid) match { val typeOfRide = continent.GUID(vehicleGuid) match {
case Some(obj: Vehicle) => case Some(obj: Vehicle) =>
sessionLogic.general.unaccessContainer(obj) sessionLogic.general.unaccessContainer(obj)
@ -126,7 +125,7 @@ class VehicleHandlerLogic(val ops: SessionVehicleHandlers, implicit val context:
case VehicleAction.KickPassenger(_, wasKickedByDriver, _) => case VehicleAction.KickPassenger(_, wasKickedByDriver, _) =>
//seat number (first field) seems to be correct if passenger is kicked manually by driver //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 //but always seems to return 4 if user is kicked by mount permissions changing
sendResponse(DismountVehicleMsg(resolvedGuid, BailType.Kicked, wasKickedByDriver)) sendResponse(DismountVehicleMsg(filterGuid, BailType.Kicked, wasKickedByDriver))
case VehicleAction.InventoryState2(objGuid, parentGuid, value) if isNotSameTarget => case VehicleAction.InventoryState2(objGuid, parentGuid, value) if isNotSameTarget =>
sendResponse(InventoryStateMessage(objGuid, unk=0, parentGuid, value)) sendResponse(InventoryStateMessage(objGuid, unk=0, parentGuid, value))
@ -136,7 +135,7 @@ class VehicleHandlerLogic(val ops: SessionVehicleHandlers, implicit val context:
sendResponse(ObjectCreateMessage(vtype, vguid, vdata)) sendResponse(ObjectCreateMessage(vtype, vguid, vdata))
Vehicles.ReloadAccessPermissions(vehicle, player.Name) Vehicles.ReloadAccessPermissions(vehicle, player.Name)
case VehicleAction.Ownership(vehicleGuid) if isSameTarget /*resolvedPlayerGuid == guid*/ => case VehicleAction.Ownership(vehicleGuid) if isSameTarget =>
//Only the player that owns this vehicle needs the ownership packet //Only the player that owns this vehicle needs the ownership packet
avatarActor ! AvatarActor.SetVehicle(Some(vehicleGuid)) avatarActor ! AvatarActor.SetVehicle(Some(vehicleGuid))
sendResponse(PlanetsideAttributeMessage(resolvedGuid, attribute_type=21, vehicleGuid)) sendResponse(PlanetsideAttributeMessage(resolvedGuid, attribute_type=21, vehicleGuid))

40
src/main/scala/net/psforever/actors/session/spectator/AvatarHandlerLogic.scala
View file

@ -63,7 +63,7 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
canSeeReallyFar canSeeReallyFar
) if isNotSameTarget => ) if isNotSameTarget =>
val pstateToSave = pstate.copy(timestamp = 0) val pstateToSave = pstate.copy(timestamp = 0)
val (lastMsg, lastTime, lastPosition, wasVisible, wasShooting) = ops.lastSeenStreamMessage.get(resolvedGuid.guid) match { val (lastMsg, lastTime, lastPosition, wasVisible, wasShooting) = ops.lastSeenStreamMessage.get(filterGuid.guid) match {
case Some(SessionAvatarHandlers.LastUpstream(Some(msg), visible, shooting, time)) => (Some(msg), time, msg.pos, visible, shooting) case Some(SessionAvatarHandlers.LastUpstream(Some(msg), visible, shooting, time)) => (Some(msg), time, msg.pos, visible, shooting)
case _ => (None, 0L, Vector3.Zero, false, None) case _ => (None, 0L, Vector3.Zero, false, None)
} }
@ -106,7 +106,7 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
//must draw //must draw
sendResponse( sendResponse(
PlayerStateMessage( PlayerStateMessage(
resolvedGuid, filterGuid,
pos, pos,
vel, vel,
yaw, yaw,
@ -119,10 +119,10 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
isCloaking isCloaking
) )
) )
ops.lastSeenStreamMessage.put(resolvedGuid.guid, SessionAvatarHandlers.LastUpstream(Some(pstateToSave), visible=true, wasShooting, now)) ops.lastSeenStreamMessage.put(filterGuid.guid, SessionAvatarHandlers.LastUpstream(Some(pstateToSave), visible=true, wasShooting, now))
} else { } else {
//is visible, but skip reinforcement //is visible, but skip reinforcement
ops.lastSeenStreamMessage.put(resolvedGuid.guid, SessionAvatarHandlers.LastUpstream(Some(pstateToSave), visible=true, wasShooting, lastTime)) ops.lastSeenStreamMessage.put(filterGuid.guid, SessionAvatarHandlers.LastUpstream(Some(pstateToSave), visible=true, wasShooting, lastTime))
} }
} else { } else {
//conditions where the target is not currently visible //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 val lat = (1 + ops.hidingPlayerRandomizer.nextInt(continent.map.scale.height.toInt)).toFloat
sendResponse( sendResponse(
PlayerStateMessage( PlayerStateMessage(
resolvedGuid, filterGuid,
Vector3(1f, lat, 1f), Vector3(1f, lat, 1f),
vel=None, vel=None,
facingYaw=0f, facingYaw=0f,
@ -141,16 +141,16 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
is_cloaked = isCloaking is_cloaked = isCloaking
) )
) )
ops.lastSeenStreamMessage.put(resolvedGuid.guid, SessionAvatarHandlers.LastUpstream(Some(pstateToSave), visible=false, wasShooting, now)) ops.lastSeenStreamMessage.put(filterGuid.guid, SessionAvatarHandlers.LastUpstream(Some(pstateToSave), visible=false, wasShooting, now))
} else { } else {
//skip drawing altogether //skip drawing altogether
ops.lastSeenStreamMessage.put(resolvedGuid.guid, SessionAvatarHandlers.LastUpstream(Some(pstateToSave), visible=false, wasShooting, lastTime)) ops.lastSeenStreamMessage.put(filterGuid.guid, SessionAvatarHandlers.LastUpstream(Some(pstateToSave), visible=false, wasShooting, lastTime))
} }
} }
case AvatarAction.ObjectHeld(slot, _) case AvatarAction.ObjectHeld(slot, _)
if isSameTarget && player.VisibleSlots.contains(slot) => if isSameTarget && player.VisibleSlots.contains(slot) =>
sendResponse(ObjectHeldMessage(resolvedGuid, slot, unk1=true)) sendResponse(ObjectHeldMessage(filterGuid, slot, unk1=true))
//Stop using proximity terminals if player unholsters a weapon //Stop using proximity terminals if player unholsters a weapon
continent.GUID(sessionLogic.terminals.usingMedicalTerminal).collect { continent.GUID(sessionLogic.terminals.usingMedicalTerminal).collect {
case term: Terminal with ProximityUnit => sessionLogic.terminals.StopUsingProximityUnit(term) case term: Terminal with ProximityUnit => sessionLogic.terminals.StopUsingProximityUnit(term)
@ -161,25 +161,25 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
case AvatarAction.ObjectHeld(slot, _) case AvatarAction.ObjectHeld(slot, _)
if isSameTarget && slot > -1 => if isSameTarget && slot > -1 =>
sendResponse(ObjectHeldMessage(resolvedGuid, slot, unk1=true)) sendResponse(ObjectHeldMessage(filterGuid, slot, unk1=true))
case AvatarAction.ObjectHeld(_, _) case AvatarAction.ObjectHeld(_, _)
if isSameTarget => () if isSameTarget => ()
case AvatarAction.ObjectHeld(_, previousSlot) => case AvatarAction.ObjectHeld(_, previousSlot) =>
sendResponse(ObjectHeldMessage(resolvedGuid, previousSlot, unk1=false)) sendResponse(ObjectHeldMessage(filterGuid, previousSlot, unk1=false))
case ChangeFireState_Start(weaponGuid) case ChangeFireState_Start(weaponGuid)
if isNotSameTarget && ops.lastSeenStreamMessage.get(resolvedGuid.guid).exists { _.visible } => if isNotSameTarget && ops.lastSeenStreamMessage.get(filterGuid.guid).exists { _.visible } =>
sendResponse(ChangeFireStateMessage_Start(weaponGuid)) sendResponse(ChangeFireStateMessage_Start(weaponGuid))
val entry = ops.lastSeenStreamMessage(resolvedGuid.guid) val entry = ops.lastSeenStreamMessage(filterGuid.guid)
ops.lastSeenStreamMessage.put(resolvedGuid.guid, entry.copy(shooting = Some(weaponGuid))) ops.lastSeenStreamMessage.put(filterGuid.guid, entry.copy(shooting = Some(weaponGuid)))
case ChangeFireState_Stop(weaponGuid) case ChangeFireState_Stop(weaponGuid)
if isNotSameTarget && ops.lastSeenStreamMessage.get(resolvedGuid.guid).exists { msg => msg.visible || msg.shooting.nonEmpty } => if isNotSameTarget && ops.lastSeenStreamMessage.get(filterGuid.guid).exists { msg => msg.visible || msg.shooting.nonEmpty } =>
sendResponse(ChangeFireStateMessage_Stop(weaponGuid)) sendResponse(ChangeFireStateMessage_Stop(weaponGuid))
val entry = ops.lastSeenStreamMessage(resolvedGuid.guid) val entry = ops.lastSeenStreamMessage(filterGuid.guid)
ops.lastSeenStreamMessage.put(resolvedGuid.guid, entry.copy(shooting = None)) ops.lastSeenStreamMessage.put(filterGuid.guid, entry.copy(shooting = None))
case AvatarAction.LoadCreatedPlayer(pkt) if isNotSameTarget => case AvatarAction.LoadCreatedPlayer(pkt) if isNotSameTarget =>
sendResponse(pkt) sendResponse(pkt)
@ -386,7 +386,7 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
/* common messages (maybe once every respawn) */ /* common messages (maybe once every respawn) */
case ReloadTool(itemGuid) case ReloadTool(itemGuid)
if isNotSameTarget && ops.lastSeenStreamMessage.get(resolvedGuid.guid).exists { _.visible } => if isNotSameTarget && ops.lastSeenStreamMessage.get(filterGuid.guid).exists { _.visible } =>
sendResponse(ReloadMessage(itemGuid, ammo_clip=1, unk1=0)) sendResponse(ReloadMessage(itemGuid, ammo_clip=1, unk1=0))
case AvatarAction.Killed(_, mount) => case AvatarAction.Killed(_, mount) =>
@ -458,7 +458,7 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
/* uncommon messages (utility, or once in a while) */ /* uncommon messages (utility, or once in a while) */
case ChangeAmmo(weapon_guid, weapon_slot, previous_guid, ammo_id, ammo_guid, ammo_data) case ChangeAmmo(weapon_guid, weapon_slot, previous_guid, ammo_id, ammo_guid, ammo_data)
if isNotSameTarget && ops.lastSeenStreamMessage.get(resolvedGuid.guid).exists { _.visible } => if isNotSameTarget =>
ops.changeAmmoProcedure(weapon_guid, previous_guid, ammo_id, ammo_guid, weapon_slot, ammo_data) ops.changeAmmoProcedure(weapon_guid, previous_guid, ammo_id, ammo_guid, weapon_slot, ammo_data)
sendResponse(ChangeAmmoMessage(weapon_guid, 1)) sendResponse(ChangeAmmoMessage(weapon_guid, 1))
@ -520,11 +520,9 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
) )
case WeaponDryFire(weaponGuid) case WeaponDryFire(weaponGuid)
if isNotSameTarget && ops.lastSeenStreamMessage.get(resolvedGuid.guid).exists { _.visible } => if isNotSameTarget && ops.lastSeenStreamMessage.get(filterGuid.guid).exists { _.visible } =>
continent.GUID(weaponGuid).collect { continent.GUID(weaponGuid).collect {
case tool: Tool if tool.Magazine == 0 => case tool: Tool if tool.Magazine == 0 =>
// check that the magazine is still empty before sending WeaponDryFireMessage
// if it has been reloaded since then, other clients will not see it firing
sendResponse(WeaponDryFireMessage(weaponGuid)) sendResponse(WeaponDryFireMessage(weaponGuid))
} }
} }

15
src/main/scala/net/psforever/actors/session/spectator/VehicleHandlerLogic.scala
View file

@ -4,13 +4,12 @@ package net.psforever.actors.session.spectator
import akka.actor.Actor.Receive import akka.actor.Actor.Receive
import akka.actor.ActorContext import akka.actor.ActorContext
import net.psforever.actors.session.support.{SessionData, SessionVehicleHandlers, VehicleHandlerFunctions} import net.psforever.actors.session.support.{SessionData, SessionVehicleHandlers, VehicleHandlerFunctions}
import net.psforever.objects.{Tool, Vehicle, Vehicles} import net.psforever.objects.{Vehicle, Vehicles}
import net.psforever.objects.equipment.Equipment import net.psforever.objects.equipment.Equipment
import net.psforever.objects.serverobject.pad.VehicleSpawnPad import net.psforever.objects.serverobject.pad.VehicleSpawnPad
import net.psforever.packet.game.objectcreate.ObjectCreateMessageParent import net.psforever.packet.game.objectcreate.ObjectCreateMessageParent
import net.psforever.packet.game.{ChangeAmmoMessage, ChangeFireStateMessage_Start, ChangeFireStateMessage_Stop, ChildObjectStateMessage, DeadState, DeployRequestMessage, DismountVehicleMsg, FrameVehicleStateMessage, GenericObjectActionMessage, InventoryStateMessage, ObjectAttachMessage, ObjectCreateDetailedMessage, ObjectCreateMessage, ObjectDeleteMessage, ObjectDetachMessage, PlanetsideAttributeMessage, ReloadMessage, ServerVehicleOverrideMsg, VehicleStateMessage, WeaponDryFireMessage} import net.psforever.packet.game.{ChildObjectStateMessage, DeadState, DeployRequestMessage, DismountVehicleMsg, FrameVehicleStateMessage, GenericObjectActionMessage, InventoryStateMessage, ObjectAttachMessage, ObjectCreateDetailedMessage, ObjectCreateMessage, ObjectDeleteMessage, ObjectDetachMessage, PlanetsideAttributeMessage, ServerVehicleOverrideMsg, VehicleStateMessage}
import net.psforever.services.base.envelope.GenericResponseEnvelope import net.psforever.services.base.envelope.GenericResponseEnvelope
import net.psforever.services.base.message.{ChangeAmmo, ChangeFireState_Start, ChangeFireState_Stop, GenericObjectAction, ObjectDelete, PlanetsideAttribute, ReloadTool, SendResponse, WeaponDryFire}
import net.psforever.services.vehicle.{VehicleAction, VehicleStamp} import net.psforever.services.vehicle.{VehicleAction, VehicleStamp}
import net.psforever.types.{BailType, PlanetSideGUID, Vector3} import net.psforever.types.{BailType, PlanetSideGUID, Vector3}
@ -72,13 +71,13 @@ class VehicleHandlerLogic(val ops: SessionVehicleHandlers, implicit val context:
sendResponse(FrameVehicleStateMessage(vguid, u1, pos, oient, vel, u2, u3, u4, is_crouched, u6, u7, u8, u9, uA)) sendResponse(FrameVehicleStateMessage(vguid, u1, pos, oient, vel, u2, u3, u4, is_crouched, u6, u7, u8, u9, uA))
case VehicleAction.DismountVehicle(bailType, wasKickedByDriver) if isNotSameTarget => case VehicleAction.DismountVehicle(bailType, wasKickedByDriver) if isNotSameTarget =>
sendResponse(DismountVehicleMsg(resolvedGuid, bailType, wasKickedByDriver)) sendResponse(DismountVehicleMsg(filterGuid, bailType, wasKickedByDriver))
case VehicleAction.MountVehicle(vehicleGuid, seat) if isNotSameTarget => case VehicleAction.MountVehicle(vehicleGuid, seat) if isNotSameTarget =>
sendResponse(ObjectAttachMessage(vehicleGuid, resolvedGuid, seat)) sendResponse(ObjectAttachMessage(vehicleGuid, filterGuid, seat))
case VehicleAction.DeployRequest(objectGuid, state, unk1, unk2, pos) if isNotSameTarget => case VehicleAction.DeployRequest(objectGuid, state, unk1, unk2, pos) if isNotSameTarget =>
sendResponse(DeployRequestMessage(resolvedGuid, objectGuid, state, unk1, unk2, pos)) sendResponse(DeployRequestMessage(filterGuid, objectGuid, state, unk1, unk2, pos))
case VehicleAction.EquipmentCreatedInSlot(pkt) if isNotSameTarget => case VehicleAction.EquipmentCreatedInSlot(pkt) if isNotSameTarget =>
sendResponse(pkt) sendResponse(pkt)
@ -97,7 +96,7 @@ class VehicleHandlerLogic(val ops: SessionVehicleHandlers, implicit val context:
case VehicleAction.KickPassenger(_, wasKickedByDriver, vehicleGuid) if isSameTarget => case VehicleAction.KickPassenger(_, wasKickedByDriver, vehicleGuid) if isSameTarget =>
//seat number (first field) seems to be correct if passenger is kicked manually by driver //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 //but always seems to return 4 if user is kicked by mount permissions changing
sendResponse(DismountVehicleMsg(resolvedGuid, BailType.Kicked, wasKickedByDriver)) sendResponse(DismountVehicleMsg(filterGuid, BailType.Kicked, wasKickedByDriver))
continent.GUID(vehicleGuid) match { continent.GUID(vehicleGuid) match {
case Some(obj: Vehicle) => case Some(obj: Vehicle) =>
sessionLogic.general.unaccessContainer(obj) sessionLogic.general.unaccessContainer(obj)
@ -107,7 +106,7 @@ class VehicleHandlerLogic(val ops: SessionVehicleHandlers, implicit val context:
case VehicleAction.KickPassenger(_, wasKickedByDriver, _) => case VehicleAction.KickPassenger(_, wasKickedByDriver, _) =>
//seat number (first field) seems to be correct if passenger is kicked manually by driver //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 //but always seems to return 4 if user is kicked by mount permissions changing
sendResponse(DismountVehicleMsg(resolvedGuid, BailType.Kicked, wasKickedByDriver)) sendResponse(DismountVehicleMsg(filterGuid, BailType.Kicked, wasKickedByDriver))
case VehicleAction.InventoryState2(objGuid, parentGuid, value) if isNotSameTarget => case VehicleAction.InventoryState2(objGuid, parentGuid, value) if isNotSameTarget =>
sendResponse(InventoryStateMessage(objGuid, unk=0, parentGuid, value)) sendResponse(InventoryStateMessage(objGuid, unk=0, parentGuid, value))

85
src/main/scala/net/psforever/actors/session/support/CommonHandlerFunctions.scala
View file

@ -9,38 +9,45 @@ import net.psforever.types.PlanetSideGUID
trait HandlerFilter { trait HandlerFilter {
def resolvedPlayerGuid: PlanetSideGUID def resolvedPlayerGuid: PlanetSideGUID
def otherPlayerGuid: PlanetSideGUID
def isNotSameTarget: Boolean def isNotSameTarget: Boolean
def isSameTarget: Boolean def isSameTarget: Boolean
def set(resolved: PlanetSideGUID, other: PlanetSideGUID, notSame: Boolean, same: Boolean): HandlerFilter
def set(filter: HandlerFilter): HandlerFilter
} }
case class HandlerFilterRules( class HandlerFilterRules extends HandlerFilter {
resolvedPlayerGuid: PlanetSideGUID, var resolvedPlayerGuid: PlanetSideGUID = Service.defaultPlayerGUID
isNotSameTarget: Boolean, var otherPlayerGuid: PlanetSideGUID = Service.defaultPlayerGUID
isSameTarget: Boolean var isNotSameTarget: Boolean = false
) extends HandlerFilter var isSameTarget: Boolean = false
def set(resolved: PlanetSideGUID, other: PlanetSideGUID, notSame: Boolean, same: Boolean): HandlerFilter = {
resolvedPlayerGuid = resolved
otherPlayerGuid = other
isNotSameTarget = notSame
isSameTarget = same
this
}
def set(filter: HandlerFilter): HandlerFilter = {
set(filter.resolvedPlayerGuid, filter.otherPlayerGuid, filter.isNotSameTarget, filter.isSameTarget)
}
}
object HandlerFilter { object HandlerFilter {
def apply(guid: PlanetSideGUID, isNotSameTarget: Boolean): HandlerFilter = { def set(filter: HandlerFilter, guid: PlanetSideGUID, player: Player): HandlerFilter = {
HandlerFilterRules(guid, isNotSameTarget, !isNotSameTarget) if (player != null && player.HasGUID) {
} val pguid = player.GUID
filter.set(pguid, guid, pguid != guid, pguid == guid)
def apply(guid1: PlanetSideGUID, guid2: PlanetSideGUID): HandlerFilter = {
val resolvedPlayerGuid: PlanetSideGUID = guid2
val isNotSameTarget: Boolean = resolvedPlayerGuid != guid1
this(guid2, isNotSameTarget)
}
def apply(guid: PlanetSideGUID, player: Player): HandlerFilter = {
this(guid, if (player != null && player.HasGUID) {
player.GUID
} else { } else {
Service.defaultPlayerGUID filter.set(Service.defaultPlayerGUID, guid, notSame = true, same = false)
}) }
filter
} }
final val NeverAllow: HandlerFilter = HandlerFilterRules(PlanetSideGUID(-1), isNotSameTarget = false, isSameTarget = false) final val NeverAllow: HandlerFilter = new HandlerFilterRules().set(PlanetSideGUID(-1), PlanetSideGUID(-2), notSame = false, same = false)
final def Allow(guid: PlanetSideGUID): HandlerFilter = HandlerFilterRules(guid, isNotSameTarget = true, isSameTarget = true)
} }
trait CommonHandlerFunctionsBase { trait CommonHandlerFunctionsBase {
@ -57,17 +64,19 @@ trait CommonHandlerFunctionsBase {
def handleWith(filter: HandlerFilter): Receive def handleWith(filter: HandlerFilter): Receive
def receive: Receive def receive: Receive
def isDefinedAt(x: Any): Boolean = receive.isDefinedAt(x)
} }
trait CommonHandlerFunctions extends CommonHandlerFunctionsBase { trait CommonHandlerFunctions extends CommonHandlerFunctionsBase {
_: CommonSessionInterfacingFunctionality => _: CommonSessionInterfacingFunctionality =>
private var filter: HandlerFilter = HandlerFilter.NeverAllow def resolvedGuid: PlanetSideGUID = sessionLogic.handlerFilter.resolvedPlayerGuid
def resolvedGuid: PlanetSideGUID = filter.resolvedPlayerGuid def filterGuid: PlanetSideGUID = sessionLogic.handlerFilter.otherPlayerGuid
def isNotSameTarget: Boolean = filter.isNotSameTarget def isNotSameTarget: Boolean = sessionLogic.handlerFilter.isNotSameTarget
def isSameTarget: Boolean = filter.isSameTarget def isSameTarget: Boolean = sessionLogic.handlerFilter.isSameTarget
/** /**
* na * na
@ -76,35 +85,19 @@ trait CommonHandlerFunctions extends CommonHandlerFunctionsBase {
* @param reply na * @param reply na
*/ */
def handle(toChannel: String, guid: PlanetSideGUID, reply: EventResponse): Unit = { def handle(toChannel: String, guid: PlanetSideGUID, reply: EventResponse): Unit = {
filter = HandlerFilter(guid, player) HandlerFilter.set(sessionLogic.handlerFilter, guid, player)
receive.apply(reply) receive.apply(reply)
} }
def handleWith(guid: PlanetSideGUID): Receive = { def handleWith(guid: PlanetSideGUID): Receive = {
filter = HandlerFilter(guid, player) HandlerFilter.set(sessionLogic.handlerFilter, guid, player)
receive receive
} }
def handleWith(giveFilter: HandlerFilter): Receive = { def handleWith(giveFilter: HandlerFilter): Receive = {
filter = giveFilter sessionLogic.handlerFilter = giveFilter
receive receive
} }
def receive: Receive def receive: Receive
} }
object CommonHandlerFunctions {
val HandleNothing: CommonHandlerFunctionsBase = new CommonHandlerFunctionsBase {
def handle(toChannel: String, guid: PlanetSideGUID, reply: EventResponse): Unit = { }
def handleWith(guid: PlanetSideGUID): Receive = receive
def handleWith(filter: HandlerFilter): Receive = receive
def receive: Receive = { case _: CommonHandlerFunctions => () }
}
val HandleAnything: CommonHandlerFunctionsBase = new CommonHandlerFunctionsBase {
def handle(toChannel: String, guid: PlanetSideGUID, reply: EventResponse): Unit = receive.apply(reply)
def handleWith(guid: PlanetSideGUID): Receive = receive
def handleWith(filter: HandlerFilter): Receive = receive
def receive: Receive = { case _ => () }
}
}

6
src/main/scala/net/psforever/actors/session/support/CommonHandlerLogic.scala
View file

@ -44,14 +44,12 @@ class CommonHandlerLogic(val sessionLogic: SessionData, implicit val context: Ac
if isNotSameTarget => if isNotSameTarget =>
continent.GUID(weaponGuid).collect { continent.GUID(weaponGuid).collect {
case tool: Tool if tool.Magazine == 0 => case tool: Tool if tool.Magazine == 0 =>
// check that the magazine is still empty before sending WeaponDryFireMessage
// if it has been reloaded since then, other clients will not see it firing
sendResponse(WeaponDryFireMessage(weaponGuid)) sendResponse(WeaponDryFireMessage(weaponGuid))
} }
case HintsAtAttacker(sourceGuid) case HintsAtAttacker(sourceGuid)
if player.isAlive => if player.isAlive =>
sendResponse(HitHint(sourceGuid, resolvedGuid)) sendResponse(HitHint(sourceGuid, filterGuid))
sessionLogic.zoning.CancelZoningProcessWithDescriptiveReason("cancel_dmg") sessionLogic.zoning.CancelZoningProcessWithDescriptiveReason("cancel_dmg")
case SetEmpire(objectGuid, faction) case SetEmpire(objectGuid, faction)
@ -59,7 +57,7 @@ class CommonHandlerLogic(val sessionLogic: SessionData, implicit val context: Ac
sendResponse(SetEmpireMessage(objectGuid, faction)) sendResponse(SetEmpireMessage(objectGuid, faction))
case ConcealPlayer(_) => case ConcealPlayer(_) =>
sendResponse(GenericObjectActionMessage(resolvedGuid, code=9)) sendResponse(GenericObjectActionMessage(filterGuid, code=9))
case SendResponse(msgs) => case SendResponse(msgs) =>
msgs.foreach(sendResponse) msgs.foreach(sendResponse)

1
src/main/scala/net/psforever/actors/session/support/SessionData.scala
View file

@ -119,6 +119,7 @@ class SessionData(
def squad: SessionSquadHandlers = squadResponseOpt.orNull def squad: SessionSquadHandlers = squadResponseOpt.orNull
def zoning: ZoningOperations = zoningOpt.orNull def zoning: ZoningOperations = zoningOpt.orNull
def chat: ChatOperations = chatOpt.orNull def chat: ChatOperations = chatOpt.orNull
var handlerFilter: HandlerFilter = HandlerFilter.NeverAllow
ServiceManager.serviceManager ! Lookup("accountIntermediary") ServiceManager.serviceManager ! Lookup("accountIntermediary")
ServiceManager.serviceManager ! Lookup("accountPersistence") ServiceManager.serviceManager ! Lookup("accountPersistence")

6
src/main/scala/net/psforever/services/base/GenericEventServiceWithCacheAndSupport.scala
View file

@ -145,11 +145,11 @@ class GenericEventServiceWithCacheAndSupport
* flush the cache messages to the normal event system bus. * flush the cache messages to the normal event system bus.
*/ */
private def tryFlushCache(): Boolean = { private def tryFlushCache(): Boolean = {
val willFLush = hasCachedMessages && nextTimeToFlushCache < System.currentTimeMillis() val willFlush = hasCachedMessages && nextTimeToFlushCache < System.currentTimeMillis()
if (willFLush) { if (willFlush) {
flushCache() flushCache()
} }
willFLush willFlush
} }
/** /**