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

modified cached guard tests; adjusted list mechanics for SendResponse contents

Browse source
This commit is contained in:
Fate-JH 2026-06-23 12:03:17 -04:00
parent 3937bb8455
commit 4afe8550c0
25 changed files with 333 additions and 279 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -96,6 +96,15 @@ object SessionActor {
final case class SetMode(mode: PlayerMode) extends Command final case class SetMode(mode: PlayerMode) extends Command
/**
* Determine if a response handler would process a given reply message, ignoring its guards.
* Treat handlers already ignoring their guards as "determined (will not pass)".
* @see `CommonHandlerFunctions.IgnoreFilter_=`
* @param reply message
* @param handler message handler
* @return `true`, if the response handler will process the response;
* `false`, if the handler is skipped or if it would not process
*/
private def HandlerAcceptingMessageTest(reply: Any)(handler: CommonHandlerFunctions): Boolean = { private def HandlerAcceptingMessageTest(reply: Any)(handler: CommonHandlerFunctions): Boolean = {
if (handler.IgnoreFilter) { if (handler.IgnoreFilter) {
false false
@ -417,14 +426,15 @@ class SessionActor(middlewareActor: typed.ActorRef[MiddlewareActor.Command], con
responseHandler.IgnoreFilter = true responseHandler.IgnoreFilter = true
if (!responseHandler.isDefinedAt(reply)) { if (!responseHandler.isDefinedAt(reply)) {
//find every handler that might accept the input response, ignoring guard booleans only for the search //find every handler that might accept the input response, ignoring guard booleans only for the search
//try each discovered handler with the input response //try each discovered handler against the input response until one works
listOfHandlers.filter(SessionActor.HandlerAcceptingMessageTest(reply)) match { val test: CommonHandlerFunctions => Boolean = SessionActor.HandlerAcceptingMessageTest(reply)
listOfHandlers.filter(test) match {
case Nil => case Nil =>
log.error(s"received completely unhandled response message - $envelope for ${envelope.stamp}") log.error(s"received completely unhandled response message - $reply for ${envelope.stamp}:$toChannel")
case first :: Nil => case first :: Nil =>
first.handle(toChannel, guid, reply) first.tryToHandle(reply)
case first :: others => case first :: others =>
first.handle(toChannel, guid, reply) || others.exists(_.handle(toChannel, guid, reply)) first.tryToHandle(reply) || others.exists(_.tryToHandle(reply))
} }
} }
responseHandler.IgnoreFilter = false responseHandler.IgnoreFilter = false

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

@ -46,13 +46,13 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
def receive: Receive = { def receive: Receive = {
/* special messages */ /* special messages */
case AvatarAction.TeardownConnection case AvatarAction.TeardownConnection
if TestFilter(_ => { player.spectator }) => if TestFilter(() => { player.spectator }) =>
context.self ! SessionActor.SetMode(CustomerServiceRepresentativeMode) context.self ! SessionActor.SetMode(CustomerServiceRepresentativeMode)
context.self.forward(GenericResponseEnvelope(AvatarStamp, "", filterGuid, AvatarAction.TeardownConnection)) context.self.forward(GenericResponseEnvelope(AvatarStamp, "", FilterGuid, AvatarAction.TeardownConnection))
case AvatarAction.TeardownConnection => case AvatarAction.TeardownConnection =>
context.self ! SessionActor.SetMode(NormalMode) context.self ! SessionActor.SetMode(NormalMode)
context.self.forward(GenericResponseEnvelope(AvatarStamp, "", filterGuid, AvatarAction.TeardownConnection)) context.self.forward(GenericResponseEnvelope(AvatarStamp, "", FilterGuid, AvatarAction.TeardownConnection))
/* really common messages (very frequently, every life) */ /* really common messages (very frequently, every life) */
case pstate @ AvatarAction.PlayerState( case pstate @ AvatarAction.PlayerState(
@ -68,9 +68,9 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
isCloaking, isCloaking,
isNotRendered, isNotRendered,
canSeeReallyFar canSeeReallyFar
) if TestFilter(_ => isNotSameTarget) => ) if TestFilter(NotSameTargetTest) =>
val pstateToSave = pstate.copy(timestamp = 0) val pstateToSave = pstate.copy(timestamp = 0)
val (lastMsg, lastTime, lastPosition, wasVisible, wasShooting) = ops.lastSeenStreamMessage.get(filterGuid.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)
} }
@ -113,7 +113,7 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
//must draw //must draw
sendResponse( sendResponse(
PlayerStateMessage( PlayerStateMessage(
filterGuid, FilterGuid,
pos, pos,
vel, vel,
yaw, yaw,
@ -126,10 +126,10 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
isCloaking isCloaking
) )
) )
ops.lastSeenStreamMessage.put(filterGuid.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(filterGuid.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
@ -138,7 +138,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(
filterGuid, FilterGuid,
Vector3(1f, lat, 1f), Vector3(1f, lat, 1f),
vel=None, vel=None,
facingYaw=0f, facingYaw=0f,
@ -148,28 +148,28 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
is_cloaked = isCloaking is_cloaked = isCloaking
) )
) )
ops.lastSeenStreamMessage.put(filterGuid.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(filterGuid.guid, SessionAvatarHandlers.LastUpstream(Some(pstateToSave), visible=false, wasShooting, lastTime)) ops.lastSeenStreamMessage.put(FilterGuid.guid, SessionAvatarHandlers.LastUpstream(Some(pstateToSave), visible=false, wasShooting, lastTime))
} }
} }
case AvatarAction.AvatarImplant(ImplantAction.Add, implant_slot, value) case AvatarAction.AvatarImplant(ImplantAction.Add, implant_slot, value)
if TestFilter(_ => { value == ImplantType.SecondWind.value }) => if TestFilter(() => { value == ImplantType.SecondWind.value }) =>
sendResponse(AvatarImplantMessage(resolvedGuid, 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 //second wind does not normally load its icon into the shortcut hotbar
avatar avatar
.shortcuts .shortcuts
.zipWithIndex .zipWithIndex
.find { case (s, _) => s.isEmpty} .find { case (s, _) => s.isEmpty}
.foreach { case (_, index) => .foreach { case (_, index) =>
sendResponse(CreateShortcutMessage(resolvedGuid, index + 1, Some(ImplantType.SecondWind.shortcut))) sendResponse(CreateShortcutMessage(ResolvedGuid, index + 1, Some(ImplantType.SecondWind.shortcut)))
} }
case AvatarAction.AvatarImplant(ImplantAction.Remove, implant_slot, value) case AvatarAction.AvatarImplant(ImplantAction.Remove, implant_slot, value)
if TestFilter(_ => { value == ImplantType.SecondWind.value }) => if TestFilter(() => { value == ImplantType.SecondWind.value }) =>
sendResponse(AvatarImplantMessage(resolvedGuid, 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 //second wind does not normally unload its icon from the shortcut hotbar
val shortcut = { val shortcut = {
val imp = ImplantType.SecondWind.shortcut val imp = ImplantType.SecondWind.shortcut
@ -180,15 +180,15 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
.zipWithIndex .zipWithIndex
.find { case (s, _) => s.contains(shortcut) } .find { case (s, _) => s.contains(shortcut) }
.foreach { case (_, index) => .foreach { case (_, index) =>
sendResponse(CreateShortcutMessage(resolvedGuid, index + 1, None)) sendResponse(CreateShortcutMessage(ResolvedGuid, index + 1, None))
} }
case AvatarAction.AvatarImplant(action, implant_slot, value) => case AvatarAction.AvatarImplant(action, implant_slot, value) =>
sendResponse(AvatarImplantMessage(resolvedGuid, action, implant_slot, value)) sendResponse(AvatarImplantMessage(ResolvedGuid, action, implant_slot, value))
case AvatarAction.ObjectHeld(slot, _) case AvatarAction.ObjectHeld(slot, _)
if TestFilter(_ => { isSameTarget && player.VisibleSlots.contains(slot) }) => if TestFilter(() => { SameTarget && player.VisibleSlots.contains(slot) }) =>
sendResponse(ObjectHeldMessage(filterGuid, 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)
@ -198,33 +198,33 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
} }
case AvatarAction.ObjectHeld(slot, _) case AvatarAction.ObjectHeld(slot, _)
if TestFilter(_ => {isSameTarget && slot > -1 }) => if TestFilter(() => {SameTarget && slot > -1 }) =>
sendResponse(ObjectHeldMessage(filterGuid, slot, unk1=true)) sendResponse(ObjectHeldMessage(FilterGuid, slot, unk1=true))
case AvatarAction.ObjectHeld(_, _) case AvatarAction.ObjectHeld(_, _)
if TestFilter(_ => isSameTarget) => () if TestFilter(SameTargetTest) => ()
case AvatarAction.ObjectHeld(_, previousSlot) => case AvatarAction.ObjectHeld(_, previousSlot) =>
sendResponse(ObjectHeldMessage(filterGuid, previousSlot, unk1=false)) sendResponse(ObjectHeldMessage(FilterGuid, previousSlot, unk1=false))
case ChangeFireState_Start(weaponGuid) case ChangeFireState_Start(weaponGuid)
if TestFilter(_ => { isNotSameTarget && ops.lastSeenStreamMessage.get(filterGuid.guid).exists { _.visible } }) => if TestFilter(() => { NotSameTarget && ops.lastSeenStreamMessage.get(FilterGuid.guid).exists { _.visible } }) =>
sendResponse(ChangeFireStateMessage_Start(weaponGuid)) sendResponse(ChangeFireStateMessage_Start(weaponGuid))
val entry = ops.lastSeenStreamMessage(filterGuid.guid) val entry = ops.lastSeenStreamMessage(FilterGuid.guid)
ops.lastSeenStreamMessage.put(filterGuid.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 TestFilter(_ => { isNotSameTarget && ops.lastSeenStreamMessage.get(filterGuid.guid).exists { msg => msg.visible || msg.shooting.nonEmpty } }) => if TestFilter(() => { NotSameTarget && ops.lastSeenStreamMessage.get(FilterGuid.guid).exists { msg => msg.visible || msg.shooting.nonEmpty } }) =>
sendResponse(ChangeFireStateMessage_Stop(weaponGuid)) sendResponse(ChangeFireStateMessage_Stop(weaponGuid))
val entry = ops.lastSeenStreamMessage(filterGuid.guid) val entry = ops.lastSeenStreamMessage(FilterGuid.guid)
ops.lastSeenStreamMessage.put(filterGuid.guid, entry.copy(shooting = None)) ops.lastSeenStreamMessage.put(FilterGuid.guid, entry.copy(shooting = None))
case AvatarAction.LoadCreatedPlayer(pkt) case AvatarAction.LoadCreatedPlayer(pkt)
if TestFilter(_ => isNotSameTarget) => if TestFilter(NotSameTargetTest) =>
sendResponse(pkt) sendResponse(pkt)
case AvatarAction.EquipmentCreatedInHand(pkt) case AvatarAction.EquipmentCreatedInHand(pkt)
if TestFilter(_ => isNotSameTarget) => if TestFilter(NotSameTargetTest) =>
sendResponse(pkt) sendResponse(pkt)
case AvatarAction.Destroy(victim, killer, weapon, pos) => case AvatarAction.Destroy(victim, killer, weapon, pos) =>
@ -235,7 +235,7 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
sendResponse(ops.destroyDisplayMessage(killer, victim, method, unk)) sendResponse(ops.destroyDisplayMessage(killer, victim, method, unk))
case AvatarAction.TerminalOrderResult(terminalGuid, action, result) case AvatarAction.TerminalOrderResult(terminalGuid, action, result)
if TestFilter(_ => { result && (action == TransactionType.Buy || action == TransactionType.Loadout) }) => if TestFilter(() => { result && (action == TransactionType.Buy || action == TransactionType.Loadout) }) =>
sendResponse(ItemTransactionResultMessage(terminalGuid, action, result)) sendResponse(ItemTransactionResultMessage(terminalGuid, action, result))
sessionLogic.terminals.lastTerminalOrderFulfillment = true sessionLogic.terminals.lastTerminalOrderFulfillment = true
AvatarActor.savePlayerData(player) AvatarActor.savePlayerData(player)
@ -257,7 +257,7 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
inventory, inventory,
drop, drop,
delete delete
) if TestFilter(_ => {resolvedGuid == target }) => ) if TestFilter(() => {ResolvedGuid == target }) =>
sendResponse(ArmorChangedMessage(target, exosuit, subtype)) sendResponse(ArmorChangedMessage(target, exosuit, subtype))
sendResponse(PlanetsideAttributeMessage(target, attribute_type=4, armor)) sendResponse(PlanetsideAttributeMessage(target, attribute_type=4, armor))
//happening to this player //happening to this player
@ -339,7 +339,7 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
oldInventory, oldInventory,
inventory, inventory,
drops drops
) if TestFilter(_ => { resolvedGuid == target }) => ) if TestFilter(() => { ResolvedGuid == target }) =>
sendResponse(ArmorChangedMessage(target, exosuit, subtype)) sendResponse(ArmorChangedMessage(target, exosuit, subtype))
sendResponse(PlanetsideAttributeMessage(target, attribute_type=4, armor)) sendResponse(PlanetsideAttributeMessage(target, attribute_type=4, armor))
//happening to this player //happening to this player
@ -376,9 +376,9 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
case AvatarAction.UseKit(kguid, kObjId) => case AvatarAction.UseKit(kguid, kObjId) =>
sendResponse( sendResponse(
UseItemMessage( UseItemMessage(
resolvedGuid, ResolvedGuid,
kguid, kguid,
resolvedGuid, ResolvedGuid,
unk2 = 4294967295L, unk2 = 4294967295L,
unk3 = false, unk3 = false,
unk4 = Vector3.Zero, unk4 = Vector3.Zero,
@ -401,7 +401,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 TestFilter(_ => { isNotSameTarget && ops.lastSeenStreamMessage.get(filterGuid.guid).exists { _.visible } }) => if TestFilter(() => { NotSameTarget && 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) =>
@ -412,23 +412,23 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
sessionLogic.zoning.zoningStatus = Zoning.Status.None sessionLogic.zoning.zoningStatus = Zoning.Status.None
continent.GUID(mount).collect { continent.GUID(mount).collect {
case obj: Vehicle if obj.Destroyed => case obj: Vehicle if obj.Destroyed =>
ops.killedWhileMounted(obj, resolvedGuid) ops.killedWhileMounted(obj, ResolvedGuid)
sessionLogic.vehicles.ConditionalDriverVehicleControl(obj) sessionLogic.vehicles.ConditionalDriverVehicleControl(obj)
sessionLogic.general.unaccessContainer(obj) sessionLogic.general.unaccessContainer(obj)
case obj: Vehicle => case obj: Vehicle =>
ops.killedWhileMounted(obj, resolvedGuid) ops.killedWhileMounted(obj, ResolvedGuid)
sessionLogic.vehicles.ConditionalDriverVehicleControl(obj) sessionLogic.vehicles.ConditionalDriverVehicleControl(obj)
case obj: PlanetSideGameObject with Mountable with Container if obj.Destroyed => case obj: PlanetSideGameObject with Mountable with Container if obj.Destroyed =>
ops.killedWhileMounted(obj, resolvedGuid) ops.killedWhileMounted(obj, ResolvedGuid)
sessionLogic.general.unaccessContainer(obj) sessionLogic.general.unaccessContainer(obj)
case obj: PlanetSideGameObject with Mountable with Container => case obj: PlanetSideGameObject with Mountable with Container =>
ops.killedWhileMounted(obj, resolvedGuid) ops.killedWhileMounted(obj, ResolvedGuid)
case obj: PlanetSideGameObject with Mountable => case obj: PlanetSideGameObject with Mountable =>
ops.killedWhileMounted(obj, resolvedGuid) ops.killedWhileMounted(obj, ResolvedGuid)
} }
//player state changes //player state changes
sessionLogic.general.dropSpecialSlotItem() sessionLogic.general.dropSpecialSlotItem()
@ -442,11 +442,11 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
CustomerServiceRepresentativeMode.renderPlayer(sessionLogic, continent, player) CustomerServiceRepresentativeMode.renderPlayer(sessionLogic, continent, player)
case AvatarAction.ReleasePlayer(tplayer) case AvatarAction.ReleasePlayer(tplayer)
if TestFilter(_ => isNotSameTarget) => if TestFilter(NotSameTargetTest) =>
sessionLogic.zoning.spawn.DepictPlayerAsCorpse(tplayer) sessionLogic.zoning.spawn.DepictPlayerAsCorpse(tplayer)
case AvatarAction.Revive(revivalTargetGuid) case AvatarAction.Revive(revivalTargetGuid)
if TestFilter(_ => { resolvedGuid == revivalTargetGuid }) => if TestFilter(() => { ResolvedGuid == revivalTargetGuid }) =>
ops.revive() ops.revive()
player.Actor ! Player.Revive player.Actor ! Player.Revive
player.History player.History
@ -461,12 +461,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 TestFilter(_ => isNotSameTarget) => if TestFilter(NotSameTargetTest) =>
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) case AvatarAction.ChangeFireMode(itemGuid, mode)
if TestFilter(_ => isNotSameTarget) => if TestFilter(NotSameTargetTest) =>
sendResponse(ChangeFireModeMessage(itemGuid, mode)) sendResponse(ChangeFireModeMessage(itemGuid, mode))
case AvatarAction.EnvironmentalDamage(_, _, _) => case AvatarAction.EnvironmentalDamage(_, _, _) =>
@ -474,7 +474,7 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
sessionLogic.zoning.CancelZoningProcess() sessionLogic.zoning.CancelZoningProcess()
case AvatarAction.DropCreatedItem(pkt) case AvatarAction.DropCreatedItem(pkt)
if TestFilter(_ => isNotSameTarget) => if TestFilter(NotSameTargetTest) =>
sendResponse(pkt) sendResponse(pkt)
/* rare messages */ /* rare messages */
@ -488,11 +488,11 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
)) ))
case AvatarAction.LoadCreatedProjectile(pkt) case AvatarAction.LoadCreatedProjectile(pkt)
if TestFilter(_ => isNotSameTarget) => if TestFilter(NotSameTargetTest) =>
sendResponse(pkt) sendResponse(pkt)
case AvatarAction.ProjectileState(projectileGuid, shotPos, shotVel, shotOrient, seq, end, targetGuid) case AvatarAction.ProjectileState(projectileGuid, shotPos, shotVel, shotOrient, seq, end, targetGuid)
if TestFilter(_ => isNotSameTarget) => if TestFilter(NotSameTargetTest) =>
sendResponse(ProjectileStateMessage(projectileGuid, shotPos, shotVel, shotOrient, seq, end, targetGuid)) sendResponse(ProjectileStateMessage(projectileGuid, shotPos, shotVel, shotOrient, seq, end, targetGuid))
case AvatarAction.ProjectileExplodes(projectileGuid, projectile) => case AvatarAction.ProjectileExplodes(projectileGuid, projectile) =>
@ -513,11 +513,11 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
sendResponse(GenericActionMessage(mode)) sendResponse(GenericActionMessage(mode))
case AvatarAction.PutDownFDU(target) case AvatarAction.PutDownFDU(target)
if TestFilter(_ => isNotSameTarget) => if TestFilter(NotSameTargetTest) =>
sendResponse(GenericObjectActionMessage(target, code=53)) sendResponse(GenericObjectActionMessage(target, code=53))
case AvatarAction.StowEquipment(target, slot, item) case AvatarAction.StowEquipment(target, slot, item)
if TestFilter(_ => isNotSameTarget) => if TestFilter(NotSameTargetTest) =>
val definition = item.Definition val definition = item.Definition
sendResponse( sendResponse(
ObjectCreateDetailedMessage( ObjectCreateDetailedMessage(
@ -529,7 +529,7 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
) )
case WeaponDryFire(weaponGuid) case WeaponDryFire(weaponGuid)
if TestFilter(_ => { isNotSameTarget && ops.lastSeenStreamMessage.get(filterGuid.guid).exists { _.visible } }) => if TestFilter(() => { NotSameTarget && 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 =>
sendResponse(WeaponDryFireMessage(weaponGuid)) sendResponse(WeaponDryFireMessage(weaponGuid))

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

@ -66,9 +66,9 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
isCloaking, isCloaking,
isNotRendered, isNotRendered,
canSeeReallyFar canSeeReallyFar
) if TestFilter(_ => isNotSameTarget) => ) if TestFilter(NotSameTargetTest) =>
val pstateToSave = pstate.copy(timestamp = 0) val pstateToSave = pstate.copy(timestamp = 0)
val (lastMsg, lastTime, lastPosition, wasVisible, wasShooting) = ops.lastSeenStreamMessage.get(filterGuid.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(
filterGuid, 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(filterGuid.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(filterGuid.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(
filterGuid, FilterGuid,
Vector3(1f, lat, 1f), Vector3(1f, lat, 1f),
vel=None, vel=None,
facingYaw=0f, facingYaw=0f,
@ -146,28 +146,28 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
is_cloaked = isCloaking is_cloaked = isCloaking
) )
) )
ops.lastSeenStreamMessage.put(filterGuid.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(filterGuid.guid, SessionAvatarHandlers.LastUpstream(Some(pstateToSave), visible=false, wasShooting, lastTime)) ops.lastSeenStreamMessage.put(FilterGuid.guid, SessionAvatarHandlers.LastUpstream(Some(pstateToSave), visible=false, wasShooting, lastTime))
} }
} }
case AvatarAction.AvatarImplant(ImplantAction.Add, implant_slot, value) case AvatarAction.AvatarImplant(ImplantAction.Add, implant_slot, value)
if TestFilter(_ => { value == ImplantType.SecondWind.value }) => if TestFilter(() => { value == ImplantType.SecondWind.value }) =>
sendResponse(AvatarImplantMessage(resolvedGuid, 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 //second wind does not normally load its icon into the shortcut hotbar
avatar avatar
.shortcuts .shortcuts
.zipWithIndex .zipWithIndex
.find { case (s, _) => s.isEmpty} .find { case (s, _) => s.isEmpty}
.foreach { case (_, index) => .foreach { case (_, index) =>
sendResponse(CreateShortcutMessage(resolvedGuid, index + 1, Some(ImplantType.SecondWind.shortcut))) sendResponse(CreateShortcutMessage(ResolvedGuid, index + 1, Some(ImplantType.SecondWind.shortcut)))
} }
case AvatarAction.AvatarImplant(ImplantAction.Remove, implant_slot, value) case AvatarAction.AvatarImplant(ImplantAction.Remove, implant_slot, value)
if TestFilter(_ => { value == ImplantType.SecondWind.value }) => if TestFilter(() => { value == ImplantType.SecondWind.value }) =>
sendResponse(AvatarImplantMessage(resolvedGuid, 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 //second wind does not normally unload its icon from the shortcut hotbar
val shortcut = { val shortcut = {
val imp = ImplantType.SecondWind.shortcut val imp = ImplantType.SecondWind.shortcut
@ -178,15 +178,15 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
.zipWithIndex .zipWithIndex
.find { case (s, _) => s.contains(shortcut) } .find { case (s, _) => s.contains(shortcut) }
.foreach { case (_, index) => .foreach { case (_, index) =>
sendResponse(CreateShortcutMessage(resolvedGuid, index + 1, None)) sendResponse(CreateShortcutMessage(ResolvedGuid, index + 1, None))
} }
case AvatarAction.AvatarImplant(action, implant_slot, value) => case AvatarAction.AvatarImplant(action, implant_slot, value) =>
sendResponse(AvatarImplantMessage(resolvedGuid, action, implant_slot, value)) sendResponse(AvatarImplantMessage(ResolvedGuid, action, implant_slot, value))
case AvatarAction.ObjectHeld(slot, _) case AvatarAction.ObjectHeld(slot, _)
if TestFilter(_ => { isSameTarget && player.VisibleSlots.contains(slot) }) => if TestFilter(() => { SameTarget && player.VisibleSlots.contains(slot) }) =>
sendResponse(ObjectHeldMessage(filterGuid, 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)
@ -196,37 +196,37 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
} }
case AvatarAction.ObjectHeld(slot, _) case AvatarAction.ObjectHeld(slot, _)
if TestFilter(_ => { isSameTarget && slot > -1 }) => if TestFilter(() => { SameTarget && slot > -1 }) =>
sendResponse(ObjectHeldMessage(filterGuid, slot, unk1=true)) sendResponse(ObjectHeldMessage(FilterGuid, slot, unk1=true))
case AvatarAction.ObjectHeld(_, _) case AvatarAction.ObjectHeld(_, _)
if TestFilter(_ => isSameTarget) => () if TestFilter(SameTargetTest) => ()
case AvatarAction.ObjectHeld(_, previousSlot) => case AvatarAction.ObjectHeld(_, previousSlot) =>
sendResponse(ObjectHeldMessage(filterGuid, previousSlot, unk1=false)) sendResponse(ObjectHeldMessage(FilterGuid, previousSlot, unk1=false))
case ChangeFireState_Start(weaponGuid) case ChangeFireState_Start(weaponGuid)
if TestFilter(_ => { isNotSameTarget && ops.lastSeenStreamMessage.get(filterGuid.guid).exists { _.visible } }) => if TestFilter(() => { NotSameTarget && ops.lastSeenStreamMessage.get(FilterGuid.guid).exists { _.visible } }) =>
sendResponse(ChangeFireStateMessage_Start(weaponGuid)) sendResponse(ChangeFireStateMessage_Start(weaponGuid))
val entry = ops.lastSeenStreamMessage(filterGuid.guid) val entry = ops.lastSeenStreamMessage(FilterGuid.guid)
ops.lastSeenStreamMessage.put(filterGuid.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 TestFilter(_ => { isNotSameTarget && ops.lastSeenStreamMessage.get(filterGuid.guid).exists { msg => msg.visible || msg.shooting.nonEmpty } }) => if TestFilter(() => { NotSameTarget && ops.lastSeenStreamMessage.get(FilterGuid.guid).exists { msg => msg.visible || msg.shooting.nonEmpty } }) =>
sendResponse(ChangeFireStateMessage_Stop(weaponGuid)) sendResponse(ChangeFireStateMessage_Stop(weaponGuid))
val entry = ops.lastSeenStreamMessage(filterGuid.guid) val entry = ops.lastSeenStreamMessage(FilterGuid.guid)
ops.lastSeenStreamMessage.put(filterGuid.guid, entry.copy(shooting = None)) ops.lastSeenStreamMessage.put(FilterGuid.guid, entry.copy(shooting = None))
case AvatarAction.LoadCreatedPlayer(pkt) case AvatarAction.LoadCreatedPlayer(pkt)
if TestFilter(_ => isNotSameTarget) => if TestFilter(NotSameTargetTest) =>
sendResponse(pkt) sendResponse(pkt)
case AvatarAction.EquipmentCreatedInHand(pkt) case AvatarAction.EquipmentCreatedInHand(pkt)
if TestFilter(_ => isNotSameTarget) => if TestFilter(NotSameTargetTest) =>
sendResponse(pkt) sendResponse(pkt)
case AvatarAction.PlanetsideStringAttribute(attributeType, attributeValue) => case AvatarAction.PlanetsideStringAttribute(attributeType, attributeValue) =>
sendResponse(PlanetsideStringAttributeMessage(filterGuid, 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
@ -262,7 +262,7 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
inventory, inventory,
drop, drop,
delete delete
) if TestFilter(_ => { resolvedGuid == target }) => ) if TestFilter(() => { ResolvedGuid == target }) =>
sendResponse(ArmorChangedMessage(target, exosuit, subtype)) sendResponse(ArmorChangedMessage(target, exosuit, subtype))
sendResponse(PlanetsideAttributeMessage(target, attribute_type=4, armor)) sendResponse(PlanetsideAttributeMessage(target, attribute_type=4, armor))
//happening to this player //happening to this player
@ -362,7 +362,7 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
oldInventory, oldInventory,
inventory, inventory,
drops drops
) if TestFilter(_ => { resolvedGuid == target }) => ) if TestFilter(() => { ResolvedGuid == target }) =>
sendResponse(ArmorChangedMessage(target, exosuit, subtype)) sendResponse(ArmorChangedMessage(target, exosuit, subtype))
sendResponse(PlanetsideAttributeMessage(target, attribute_type=4, armor)) sendResponse(PlanetsideAttributeMessage(target, attribute_type=4, armor))
//happening to this player //happening to this player
@ -402,9 +402,9 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
case AvatarAction.UseKit(kguid, kObjId) => case AvatarAction.UseKit(kguid, kObjId) =>
sendResponse( sendResponse(
UseItemMessage( UseItemMessage(
resolvedGuid, ResolvedGuid,
kguid, kguid,
resolvedGuid, ResolvedGuid,
unk2 = 4294967295L, unk2 = 4294967295L,
unk3 = false, unk3 = false,
unk4 = Vector3.Zero, unk4 = Vector3.Zero,
@ -453,7 +453,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 TestFilter(_ => { isNotSameTarget && ops.lastSeenStreamMessage.get(filterGuid.guid).exists { _.visible } }) => if TestFilter(() => { NotSameTarget && 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(cause, mount) => case AvatarAction.Killed(cause, mount) =>
@ -519,16 +519,16 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
sessionLogic.zoning.spawn.deadState = DeadState.Dead sessionLogic.zoning.spawn.deadState = DeadState.Dead
continent.GUID(mount).collect { continent.GUID(mount).collect {
case obj: Vehicle => case obj: Vehicle =>
killedWhileMounted(obj, resolvedGuid) killedWhileMounted(obj, ResolvedGuid)
sessionLogic.vehicles.ConditionalDriverVehicleControl(obj) sessionLogic.vehicles.ConditionalDriverVehicleControl(obj)
sessionLogic.general.unaccessContainer(obj) sessionLogic.general.unaccessContainer(obj)
case obj: PlanetSideGameObject with Mountable with Container => case obj: PlanetSideGameObject with Mountable with Container =>
killedWhileMounted(obj, resolvedGuid) killedWhileMounted(obj, ResolvedGuid)
sessionLogic.general.unaccessContainer(obj) sessionLogic.general.unaccessContainer(obj)
case obj: PlanetSideGameObject with Mountable => case obj: PlanetSideGameObject with Mountable =>
killedWhileMounted(obj, resolvedGuid) killedWhileMounted(obj, ResolvedGuid)
} }
sessionLogic.actionsToCancel() sessionLogic.actionsToCancel()
sessionLogic.terminals.CancelAllProximityUnits() sessionLogic.terminals.CancelAllProximityUnits()
@ -547,11 +547,11 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
} }
case AvatarAction.ReleasePlayer(tplayer) case AvatarAction.ReleasePlayer(tplayer)
if TestFilter(_ => isNotSameTarget) => if TestFilter(NotSameTargetTest) =>
sessionLogic.zoning.spawn.DepictPlayerAsCorpse(tplayer) sessionLogic.zoning.spawn.DepictPlayerAsCorpse(tplayer)
case AvatarAction.Revive(revivalTargetGuid) case AvatarAction.Revive(revivalTargetGuid)
if TestFilter(_ => { resolvedGuid == revivalTargetGuid }) => if TestFilter(() => { ResolvedGuid == revivalTargetGuid }) =>
log.info(s"No time for rest, ${player.Name}. Back on your feet!") log.info(s"No time for rest, ${player.Name}. Back on your feet!")
ops.revive() ops.revive()
player.Actor ! Player.Revive player.Actor ! Player.Revive
@ -567,12 +567,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 TestFilter(_ => isNotSameTarget) => if TestFilter(NotSameTargetTest) =>
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) case AvatarAction.ChangeFireMode(itemGuid, mode)
if TestFilter(_ => isNotSameTarget) => if TestFilter(NotSameTargetTest) =>
sendResponse(ChangeFireModeMessage(itemGuid, mode)) sendResponse(ChangeFireModeMessage(itemGuid, mode))
case AvatarAction.EnvironmentalDamage(_, _, _) => case AvatarAction.EnvironmentalDamage(_, _, _) =>
@ -580,7 +580,7 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
sessionLogic.zoning.CancelZoningProcessWithDescriptiveReason("cancel_dmg") sessionLogic.zoning.CancelZoningProcessWithDescriptiveReason("cancel_dmg")
case AvatarAction.DropCreatedItem(pkt) case AvatarAction.DropCreatedItem(pkt)
if TestFilter(_ => isNotSameTarget) => if TestFilter(NotSameTargetTest) =>
sendResponse(pkt) sendResponse(pkt)
/* rare messages */ /* rare messages */
@ -594,11 +594,11 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
)) ))
case AvatarAction.LoadCreatedProjectile(pkt) case AvatarAction.LoadCreatedProjectile(pkt)
if TestFilter(_ => isNotSameTarget) => if TestFilter(NotSameTargetTest) =>
sendResponse(pkt) sendResponse(pkt)
case AvatarAction.ProjectileState(projectileGuid, shotPos, shotVel, shotOrient, seq, end, targetGuid) case AvatarAction.ProjectileState(projectileGuid, shotPos, shotVel, shotOrient, seq, end, targetGuid)
if TestFilter(_ => isNotSameTarget) => if TestFilter(NotSameTargetTest) =>
sendResponse(ProjectileStateMessage(projectileGuid, shotPos, shotVel, shotOrient, seq, end, targetGuid)) sendResponse(ProjectileStateMessage(projectileGuid, shotPos, shotVel, shotOrient, seq, end, targetGuid))
case AvatarAction.ProjectileExplodes(projectileGuid, projectile) => case AvatarAction.ProjectileExplodes(projectileGuid, projectile) =>
@ -619,11 +619,11 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
sendResponse(GenericActionMessage(mode)) sendResponse(GenericActionMessage(mode))
case AvatarAction.PutDownFDU(target) case AvatarAction.PutDownFDU(target)
if TestFilter(_ => isNotSameTarget) => if TestFilter(NotSameTargetTest) =>
sendResponse(GenericObjectActionMessage(target, code=53)) sendResponse(GenericObjectActionMessage(target, code=53))
case AvatarAction.StowEquipment(target, slot, item) case AvatarAction.StowEquipment(target, slot, item)
if TestFilter(_ => isNotSameTarget) => if TestFilter(NotSameTargetTest) =>
val definition = item.Definition val definition = item.Definition
sendResponse( sendResponse(
ObjectCreateDetailedMessage( ObjectCreateDetailedMessage(
@ -635,7 +635,7 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
) )
case WeaponDryFire(weaponGuid) case WeaponDryFire(weaponGuid)
if TestFilter(_ => { isNotSameTarget && ops.lastSeenStreamMessage.get(filterGuid.guid).exists { _.visible } }) => if TestFilter(() => { NotSameTarget && 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 =>
sendResponse(WeaponDryFireMessage(weaponGuid)) sendResponse(WeaponDryFireMessage(weaponGuid))

2
src/main/scala/net/psforever/actors/session/normal/GalaxyHandlerLogic.scala
View file

@ -83,7 +83,7 @@ class GalaxyHandlerLogic(val ops: SessionGalaxyHandlers, implicit val context: A
sendResponse(ZonePopulationUpdateMessage(zone.Number, 414, 138, popTR, 138, popNC, 138, popVS, 138, popBO)) sendResponse(ZonePopulationUpdateMessage(zone.Number, 414, 138, popTR, 138, popNC, 138, popVS, 138, popBO))
case GalaxyAction.LogStatusChange(name) case GalaxyAction.LogStatusChange(name)
if TestFilter(_ => avatar.people.friend.exists(_.name.equals(name))) => if TestFilter(() => avatar.people.friend.exists(_.name.equals(name))) =>
avatarActor ! AvatarActor.MemberListRequest(MemberAction.UpdateFriend, name) avatarActor ! AvatarActor.MemberListRequest(MemberAction.UpdateFriend, name)
} }
} }

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

@ -50,7 +50,7 @@ class LocalHandlerLogic(val ops: SessionLocalHandlers, implicit val context: Act
} }
case LocalAction.DeployableMapIcon(behavior, deployInfo) case LocalAction.DeployableMapIcon(behavior, deployInfo)
if TestFilter(_ => isNotSameTarget) => if TestFilter(NotSameTargetTest) =>
sendResponse(DeployableObjectsInfoMessage(behavior, deployInfo)) sendResponse(DeployableObjectsInfoMessage(behavior, deployInfo))
case LocalAction.DeployableUIFor(item) => case LocalAction.DeployableUIFor(item) =>
@ -70,7 +70,7 @@ class LocalHandlerLogic(val ops: SessionLocalHandlers, implicit val context: Act
log.warn(s"LocalAction.Detonate: ${obj.Definition.Name} not configured to explode correctly") log.warn(s"LocalAction.Detonate: ${obj.Definition.Name} not configured to explode correctly")
case LocalAction.DoorOpens(_, door) case LocalAction.DoorOpens(_, door)
if TestFilter(_ => isNotSameTarget) => if TestFilter(NotSameTargetTest) =>
val doorGuid = door.GUID val doorGuid = door.GUID
val pos = player.Position.xy val pos = player.Position.xy
val range = ops.doorLoadRange() val range = ops.doorLoadRange()
@ -89,7 +89,7 @@ class LocalHandlerLogic(val ops: SessionLocalHandlers, implicit val context: Act
sendResponse(GenericObjectStateMsg(doorGuid, state=17)) sendResponse(GenericObjectStateMsg(doorGuid, state=17))
case LocalAction.EliminateDeployable(obj: TurretDeployable, dguid, _, _) case LocalAction.EliminateDeployable(obj: TurretDeployable, dguid, _, _)
if TestFilter(_ => obj.Destroyed) => if TestFilter(() => obj.Destroyed) =>
sendResponse(ObjectDeleteMessage(dguid, unk1=0)) sendResponse(ObjectDeleteMessage(dguid, unk1=0))
case LocalAction.EliminateDeployable(obj: TurretDeployable, dguid, pos, _) => case LocalAction.EliminateDeployable(obj: TurretDeployable, dguid, pos, _) =>
@ -103,7 +103,7 @@ class LocalHandlerLogic(val ops: SessionLocalHandlers, implicit val context: Act
) )
case LocalAction.EliminateDeployable(obj: ExplosiveDeployable, dguid, _, _) case LocalAction.EliminateDeployable(obj: ExplosiveDeployable, dguid, _, _)
if TestFilter(_ => { obj.Destroyed || obj.Jammed || obj.Health == 0 }) => if TestFilter(() => { obj.Destroyed || obj.Jammed || obj.Health == 0 }) =>
sendResponse(ObjectDeleteMessage(dguid, unk1=0)) sendResponse(ObjectDeleteMessage(dguid, unk1=0))
case LocalAction.EliminateDeployable(obj: ExplosiveDeployable, dguid, pos, effect) => case LocalAction.EliminateDeployable(obj: ExplosiveDeployable, dguid, pos, effect) =>
@ -111,7 +111,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.EliminateDeployable(obj: TelepadDeployable, dguid, _, _) case LocalAction.EliminateDeployable(obj: TelepadDeployable, dguid, _, _)
if TestFilter(_ => { obj.Active && obj.Destroyed }) => if TestFilter(() => { obj.Active && obj.Destroyed }) =>
//if active, deactivate //if active, deactivate
obj.Active = false obj.Active = false
ops.deactivateTelpadDeployableMessages(dguid) ops.deactivateTelpadDeployableMessages(dguid)
@ -119,7 +119,7 @@ class LocalHandlerLogic(val ops: SessionLocalHandlers, implicit val context: Act
sendResponse(ObjectDeleteMessage(dguid, unk1=0)) sendResponse(ObjectDeleteMessage(dguid, unk1=0))
case LocalAction.EliminateDeployable(obj: TelepadDeployable, dguid, pos, _) case LocalAction.EliminateDeployable(obj: TelepadDeployable, dguid, pos, _)
if TestFilter(_ => obj.Active) => if TestFilter(() => obj.Active) =>
//if active, deactivate //if active, deactivate
obj.Active = false obj.Active = false
ops.deactivateTelpadDeployableMessages(dguid) ops.deactivateTelpadDeployableMessages(dguid)
@ -128,7 +128,7 @@ class LocalHandlerLogic(val ops: SessionLocalHandlers, implicit val context: Act
ops.DeconstructDeployable(obj, dguid, pos, obj.Orientation, deletionType=2) ops.DeconstructDeployable(obj, dguid, pos, obj.Orientation, deletionType=2)
case LocalAction.EliminateDeployable(obj: TelepadDeployable, dguid, _, _) case LocalAction.EliminateDeployable(obj: TelepadDeployable, dguid, _, _)
if TestFilter(_ => obj.Destroyed) => if TestFilter(() => obj.Destroyed) =>
//standard deployable elimination behavior //standard deployable elimination behavior
sendResponse(ObjectDeleteMessage(dguid, unk1=0)) sendResponse(ObjectDeleteMessage(dguid, unk1=0))
@ -138,7 +138,7 @@ class LocalHandlerLogic(val ops: SessionLocalHandlers, implicit val context: Act
ops.DeconstructDeployable(obj, dguid, pos, obj.Orientation, deletionType=2) ops.DeconstructDeployable(obj, dguid, pos, obj.Orientation, deletionType=2)
case LocalAction.EliminateDeployable(obj, dguid, _, _) case LocalAction.EliminateDeployable(obj, dguid, _, _)
if TestFilter(_ => obj.Destroyed) => if TestFilter(() => obj.Destroyed) =>
sendResponse(ObjectDeleteMessage(dguid, unk1=0)) sendResponse(ObjectDeleteMessage(dguid, unk1=0))
case LocalAction.EliminateDeployable(obj, dguid, pos, effect) => case LocalAction.EliminateDeployable(obj, dguid, pos, effect) =>
@ -146,14 +146,11 @@ 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, filterGuid, 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)
case PlanetsideAttribute(targetGuid, attributeType, attributeValue) =>
sessionLogic.general.sendPlanetsideAttributeMessage(targetGuid, attributeType, attributeValue)
case LocalAction.GenericActionMessage(actionNumber) => case LocalAction.GenericActionMessage(actionNumber) =>
sendResponse(GenericActionMessage(actionNumber)) sendResponse(GenericActionMessage(actionNumber))
@ -224,7 +221,7 @@ class LocalHandlerLogic(val ops: SessionLocalHandlers, implicit val context: Act
sendResponse(GenericObjectActionMessage(buildingGuid, 12)) sendResponse(GenericObjectActionMessage(buildingGuid, 12))
case LocalAction.RechargeVehicleWeapon(vehicleGuid, weaponGuid) case LocalAction.RechargeVehicleWeapon(vehicleGuid, weaponGuid)
if TestFilter(_ => isSameTarget) => if TestFilter(SameTargetTest) =>
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) }

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

@ -46,7 +46,7 @@ class VehicleHandlerLogic(val ops: SessionVehicleHandlers, implicit val context:
wheelDirection, wheelDirection,
unk5, unk5,
unk6 unk6
) if TestFilter(_ => { isNotSameTarget && player.VehicleSeated.contains(vehicleGuid) }) => ) if TestFilter(() => { NotSameTarget && player.VehicleSeated.contains(vehicleGuid) }) =>
//player who is also in the vehicle (not driver) //player who is also in the vehicle (not driver)
sendResponse(VehicleStateMessage(vehicleGuid, unk1, pos, orient, vel, unk2, unk3, unk4, wheelDirection, unk5, unk6)) sendResponse(VehicleStateMessage(vehicleGuid, unk1, pos, orient, vel, unk2, unk3, unk4, wheelDirection, unk5, unk6))
player.Position = pos player.Position = pos
@ -74,36 +74,36 @@ class VehicleHandlerLogic(val ops: SessionVehicleHandlers, implicit val context:
wheelDirection, wheelDirection,
unk5, unk5,
unk6 unk6
) if TestFilter(_ => isNotSameTarget) => ) if TestFilter(NotSameTargetTest) =>
//player who is watching the vehicle from the outside //player who is watching the vehicle from the outside
sendResponse(VehicleStateMessage(vehicleGuid, unk1, pos, ang, vel, unk2, unk3, unk4, wheelDirection, unk5, unk6)) sendResponse(VehicleStateMessage(vehicleGuid, unk1, pos, ang, vel, unk2, unk3, unk4, wheelDirection, unk5, unk6))
case VehicleAction.ChildObjectState(objectGuid, pitch, yaw) case VehicleAction.ChildObjectState(objectGuid, pitch, yaw)
if TestFilter(_ => isNotSameTarget) => if TestFilter(NotSameTargetTest) =>
sendResponse(ChildObjectStateMessage(objectGuid, pitch, yaw)) sendResponse(ChildObjectStateMessage(objectGuid, pitch, yaw))
case VehicleAction.FrameVehicleState(vguid, u1, pos, oient, vel, u2, u3, u4, is_crouched, u6, u7, u8, u9, uA) case VehicleAction.FrameVehicleState(vguid, u1, pos, oient, vel, u2, u3, u4, is_crouched, u6, u7, u8, u9, uA)
if TestFilter(_ => isNotSameTarget) => if TestFilter(NotSameTargetTest) =>
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) case VehicleAction.DismountVehicle(bailType, wasKickedByDriver)
if TestFilter(_ => isNotSameTarget) => if TestFilter(NotSameTargetTest) =>
sendResponse(DismountVehicleMsg(filterGuid, bailType, wasKickedByDriver)) sendResponse(DismountVehicleMsg(FilterGuid, bailType, wasKickedByDriver))
case VehicleAction.MountVehicle(vehicleGuid, seat) case VehicleAction.MountVehicle(vehicleGuid, seat)
if TestFilter(_ => isNotSameTarget) => if TestFilter(NotSameTargetTest) =>
sendResponse(ObjectAttachMessage(vehicleGuid, filterGuid, seat)) sendResponse(ObjectAttachMessage(vehicleGuid, FilterGuid, seat))
case VehicleAction.DeployRequest(objectGuid, state, unk1, unk2, pos) case VehicleAction.DeployRequest(objectGuid, state, unk1, unk2, pos)
if TestFilter(_ => isNotSameTarget) => if TestFilter(NotSameTargetTest) =>
sendResponse(DeployRequestMessage(filterGuid, objectGuid, state, unk1, unk2, pos)) sendResponse(DeployRequestMessage(FilterGuid, objectGuid, state, unk1, unk2, pos))
case VehicleAction.EquipmentCreatedInSlot(pkt) case VehicleAction.EquipmentCreatedInSlot(pkt)
if TestFilter(_ => isNotSameTarget) => if TestFilter(NotSameTargetTest) =>
sendResponse(pkt) sendResponse(pkt)
case VehicleAction.InventoryState(obj, parentGuid, start, conData) case VehicleAction.InventoryState(obj, parentGuid, start, conData)
if TestFilter(_ => isNotSameTarget) => if TestFilter(NotSameTargetTest) =>
//TODO prefer ObjectDetachMessage, but how to force ammo pools to update properly? //TODO prefer ObjectDetachMessage, but how to force ammo pools to update properly?
val objGuid = obj.GUID val objGuid = obj.GUID
sendResponse(ObjectDeleteMessage(objGuid, unk1=0)) sendResponse(ObjectDeleteMessage(objGuid, unk1=0))
@ -115,10 +115,10 @@ class VehicleHandlerLogic(val ops: SessionVehicleHandlers, implicit val context:
)) ))
case VehicleAction.KickPassenger(_, wasKickedByDriver, vehicleGuid) case VehicleAction.KickPassenger(_, wasKickedByDriver, vehicleGuid)
if TestFilter(_ => isSameTarget) => if TestFilter(SameTargetTest) =>
//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(filterGuid, 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)
@ -132,33 +132,33 @@ 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(filterGuid, BailType.Kicked, wasKickedByDriver)) sendResponse(DismountVehicleMsg(FilterGuid, BailType.Kicked, wasKickedByDriver))
case VehicleAction.InventoryState2(objGuid, parentGuid, value) case VehicleAction.InventoryState2(objGuid, parentGuid, value)
if TestFilter(_ => isNotSameTarget) => if TestFilter(NotSameTargetTest) =>
sendResponse(InventoryStateMessage(objGuid, unk=0, parentGuid, value)) sendResponse(InventoryStateMessage(objGuid, unk=0, parentGuid, value))
case VehicleAction.LoadVehicle(vehicle, vtype, vguid, vdata) case VehicleAction.LoadVehicle(vehicle, vtype, vguid, vdata)
if TestFilter(_ => isNotSameTarget) => if TestFilter(NotSameTargetTest) =>
//this is not be suitable for vehicles with people who are seated in it before it spawns (if that is possible) //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)) sendResponse(ObjectCreateMessage(vtype, vguid, vdata))
Vehicles.ReloadAccessPermissions(vehicle, player.Name) Vehicles.ReloadAccessPermissions(vehicle, player.Name)
case VehicleAction.Ownership(vehicleGuid) case VehicleAction.Ownership(vehicleGuid)
if TestFilter(_ => isSameTarget) => if TestFilter(SameTargetTest) =>
//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))
case VehicleAction.LoseOwnership(_, vehicleGuid) => case VehicleAction.LoseOwnership(_, vehicleGuid) =>
ops.announceAmsDecay(vehicleGuid,msg = "@ams_decaystarted") ops.announceAmsDecay(vehicleGuid,msg = "@ams_decaystarted")
case VehicleAction.SeatPermissions(vehicleGuid, seatGroup, permission) case VehicleAction.SeatPermissions(vehicleGuid, seatGroup, permission)
if TestFilter(_ => isNotSameTarget) => if TestFilter(NotSameTargetTest) =>
sendResponse(PlanetsideAttributeMessage(vehicleGuid, seatGroup, permission)) sendResponse(PlanetsideAttributeMessage(vehicleGuid, seatGroup, permission))
case VehicleAction.StowCreatedEquipment(vehicleGuid, slot, itemType, itemGuid, itemData) case VehicleAction.StowCreatedEquipment(vehicleGuid, slot, itemType, itemGuid, itemData)
if TestFilter(_ => isNotSameTarget) => if TestFilter(NotSameTargetTest) =>
//TODO prefer ObjectAttachMessage, but how to force ammo pools to update properly? //TODO prefer ObjectAttachMessage, but how to force ammo pools to update properly?
sendResponse(ObjectCreateDetailedMessage(itemType, itemGuid, ObjectCreateMessageParent(vehicleGuid, slot), itemData)) sendResponse(ObjectCreateDetailedMessage(itemType, itemGuid, ObjectCreateMessageParent(vehicleGuid, slot), itemData))
@ -176,7 +176,7 @@ class VehicleHandlerLogic(val ops: SessionVehicleHandlers, implicit val context:
} }
case VehicleAction.UnstowEquipment(itemGuid) case VehicleAction.UnstowEquipment(itemGuid)
if TestFilter(_ => isNotSameTarget) => if TestFilter(NotSameTargetTest) =>
//TODO prefer ObjectDetachMessage, but how to force ammo pools to update properly? //TODO prefer ObjectDetachMessage, but how to force ammo pools to update properly?
sendResponse(ObjectDeleteMessage(itemGuid, unk1=0)) sendResponse(ObjectDeleteMessage(itemGuid, unk1=0))
@ -185,7 +185,7 @@ class VehicleHandlerLogic(val ops: SessionVehicleHandlers, implicit val context:
sessionLogic.zoning.spawn.DrawCurrentAmsSpawnPoint() sessionLogic.zoning.spawn.DrawCurrentAmsSpawnPoint()
case VehicleAction.TransferPassengerChannel(oldChannel, tempChannel, vehicle, vehicleToDelete) case VehicleAction.TransferPassengerChannel(oldChannel, tempChannel, vehicle, vehicleToDelete)
if TestFilter(_ => isNotSameTarget) => if TestFilter(NotSameTargetTest) =>
sessionLogic.zoning.interstellarFerry = Some(vehicle) sessionLogic.zoning.interstellarFerry = Some(vehicle)
sessionLogic.zoning.interstellarFerryTopLevelGUID = Some(vehicleToDelete) sessionLogic.zoning.interstellarFerryTopLevelGUID = Some(vehicleToDelete)
continent.VehicleEvents ! Service.Leave(oldChannel) //old vehicle-specific channel (was s"${vehicle.Actor}") continent.VehicleEvents ! Service.Leave(oldChannel) //old vehicle-specific channel (was s"${vehicle.Actor}")
@ -193,7 +193,7 @@ class VehicleHandlerLogic(val ops: SessionVehicleHandlers, implicit val context:
log.debug(s"TransferPassengerChannel: ${player.Name} now subscribed to $tempChannel for vehicle gating") log.debug(s"TransferPassengerChannel: ${player.Name} now subscribed to $tempChannel for vehicle gating")
case VehicleAction.KickCargo(vehicle, speed, delay) case VehicleAction.KickCargo(vehicle, speed, delay)
if TestFilter(_ => { player.VehicleSeated.nonEmpty && sessionLogic.zoning.spawn.deadState == DeadState.Alive && speed > 0 }) => if TestFilter(() => { player.VehicleSeated.nonEmpty && sessionLogic.zoning.spawn.deadState == DeadState.Alive && speed > 0 }) =>
val strafe = 1 + Vehicles.CargoOrientation(vehicle) val strafe = 1 + Vehicles.CargoOrientation(vehicle)
val reverseSpeed = if (strafe > 1) { 0 } else { speed } val reverseSpeed = if (strafe > 1) { 0 } else { speed }
//strafe or reverse, not both //strafe or reverse, not both
@ -221,11 +221,11 @@ class VehicleHandlerLogic(val ops: SessionVehicleHandlers, implicit val context:
context.system.scheduler.scheduleOnce(delay milliseconds, context.self, resp) context.system.scheduler.scheduleOnce(delay milliseconds, context.self, resp)
case VehicleAction.KickCargo(cargo, _, _) case VehicleAction.KickCargo(cargo, _, _)
if TestFilter(_ => { player.VehicleSeated.nonEmpty && sessionLogic.zoning.spawn.deadState == DeadState.Alive }) => if TestFilter(() => { player.VehicleSeated.nonEmpty && sessionLogic.zoning.spawn.deadState == DeadState.Alive }) =>
sessionLogic.vehicles.TotalDriverVehicleControl(cargo) sessionLogic.vehicles.TotalDriverVehicleControl(cargo)
case VehicleAction.ChangeLoadout(target, oldWeapons, addedWeapons, oldInventory, newInventory) case VehicleAction.ChangeLoadout(target, oldWeapons, addedWeapons, oldInventory, newInventory)
if TestFilter(_ => { player.avatar.vehicle.contains(target) }) => if TestFilter(() => { player.avatar.vehicle.contains(target) }) =>
//TODO when vehicle weapons can be changed without visual glitches, rewrite this //TODO when vehicle weapons can be changed without visual glitches, rewrite this
continent.GUID(target).collect { case vehicle: Vehicle => continent.GUID(target).collect { case vehicle: Vehicle =>
import net.psforever.login.WorldSession.boolToInt import net.psforever.login.WorldSession.boolToInt
@ -249,7 +249,7 @@ class VehicleHandlerLogic(val ops: SessionVehicleHandlers, implicit val context:
} }
case VehicleAction.ChangeLoadout(target, oldWeapons, _, oldInventory, _) case VehicleAction.ChangeLoadout(target, oldWeapons, _, oldInventory, _)
if TestFilter(_ => { sessionLogic.general.accessedContainer.map(_.GUID).contains(target) }) => if TestFilter(() => { sessionLogic.general.accessedContainer.map(_.GUID).contains(target) }) =>
//TODO when vehicle weapons can be changed without visual glitches, rewrite this //TODO when vehicle weapons can be changed without visual glitches, rewrite this
continent.GUID(target).collect { case vehicle: Vehicle => continent.GUID(target).collect { case vehicle: Vehicle =>
//external participant: observe changes to equipment //external participant: observe changes to equipment
@ -287,7 +287,7 @@ class VehicleHandlerLogic(val ops: SessionVehicleHandlers, implicit val context:
sendResponse(GenericObjectActionMessage(playerGuid, code=10)) sendResponse(GenericObjectActionMessage(playerGuid, code=10))
case VehicleSpawnPad.StartPlayerSeatedInVehicle(vehicle, _) case VehicleSpawnPad.StartPlayerSeatedInVehicle(vehicle, _)
if TestFilter(_ => { player.VisibleSlots.contains(player.DrawnSlot) }) => if TestFilter(() => { player.VisibleSlots.contains(player.DrawnSlot) }) =>
player.DrawnSlot = Player.HandsDownSlot player.DrawnSlot = Player.HandsDownSlot
startPlayerSeatedInVehicle(vehicle) startPlayerSeatedInVehicle(vehicle)

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

@ -61,9 +61,9 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
isCloaking, isCloaking,
isNotRendered, isNotRendered,
canSeeReallyFar canSeeReallyFar
) if TestFilter(_ => isNotSameTarget) => ) if TestFilter(NotSameTargetTest) =>
val pstateToSave = pstate.copy(timestamp = 0) val pstateToSave = pstate.copy(timestamp = 0)
val (lastMsg, lastTime, lastPosition, wasVisible, wasShooting) = ops.lastSeenStreamMessage.get(filterGuid.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(
filterGuid, 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(filterGuid.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(filterGuid.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(
filterGuid, 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(filterGuid.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(filterGuid.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 TestFilter(_ => { isSameTarget && player.VisibleSlots.contains(slot) }) => if TestFilter(() => { SameTarget && player.VisibleSlots.contains(slot) }) =>
sendResponse(ObjectHeldMessage(filterGuid, 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)
@ -160,33 +160,33 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
} }
case AvatarAction.ObjectHeld(slot, _) case AvatarAction.ObjectHeld(slot, _)
if TestFilter(_ => { isSameTarget && slot > -1 }) => if TestFilter(() => { SameTarget && slot > -1 }) =>
sendResponse(ObjectHeldMessage(filterGuid, slot, unk1=true)) sendResponse(ObjectHeldMessage(FilterGuid, slot, unk1=true))
case AvatarAction.ObjectHeld(_, _) case AvatarAction.ObjectHeld(_, _)
if TestFilter(_ => isSameTarget) => () if TestFilter(SameTargetTest) => ()
case AvatarAction.ObjectHeld(_, previousSlot) => case AvatarAction.ObjectHeld(_, previousSlot) =>
sendResponse(ObjectHeldMessage(filterGuid, previousSlot, unk1=false)) sendResponse(ObjectHeldMessage(FilterGuid, previousSlot, unk1=false))
case ChangeFireState_Start(weaponGuid) case ChangeFireState_Start(weaponGuid)
if TestFilter(_ => { isNotSameTarget && ops.lastSeenStreamMessage.get(filterGuid.guid).exists { _.visible } }) => if TestFilter(() => { NotSameTarget && ops.lastSeenStreamMessage.get(FilterGuid.guid).exists { _.visible } }) =>
sendResponse(ChangeFireStateMessage_Start(weaponGuid)) sendResponse(ChangeFireStateMessage_Start(weaponGuid))
val entry = ops.lastSeenStreamMessage(filterGuid.guid) val entry = ops.lastSeenStreamMessage(FilterGuid.guid)
ops.lastSeenStreamMessage.put(filterGuid.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 TestFilter(_ => { isNotSameTarget && ops.lastSeenStreamMessage.get(filterGuid.guid).exists { msg => msg.visible || msg.shooting.nonEmpty } }) => if TestFilter(() => { NotSameTarget && ops.lastSeenStreamMessage.get(FilterGuid.guid).exists { msg => msg.visible || msg.shooting.nonEmpty } }) =>
sendResponse(ChangeFireStateMessage_Stop(weaponGuid)) sendResponse(ChangeFireStateMessage_Stop(weaponGuid))
val entry = ops.lastSeenStreamMessage(filterGuid.guid) val entry = ops.lastSeenStreamMessage(FilterGuid.guid)
ops.lastSeenStreamMessage.put(filterGuid.guid, entry.copy(shooting = None)) ops.lastSeenStreamMessage.put(FilterGuid.guid, entry.copy(shooting = None))
case AvatarAction.LoadCreatedPlayer(pkt) case AvatarAction.LoadCreatedPlayer(pkt)
if TestFilter(_ => isNotSameTarget) => if TestFilter(NotSameTargetTest) =>
sendResponse(pkt) sendResponse(pkt)
case AvatarAction.EquipmentCreatedInHand(pkt) case AvatarAction.EquipmentCreatedInHand(pkt)
if TestFilter(_ => isNotSameTarget) => if TestFilter(NotSameTargetTest) =>
sendResponse(pkt) sendResponse(pkt)
case AvatarAction.Destroy(victim, killer, weapon, pos) => case AvatarAction.Destroy(victim, killer, weapon, pos) =>
@ -197,7 +197,7 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
sendResponse(ops.destroyDisplayMessage(killer, victim, method, unk)) sendResponse(ops.destroyDisplayMessage(killer, victim, method, unk))
case AvatarAction.TerminalOrderResult(terminalGuid, action, result) case AvatarAction.TerminalOrderResult(terminalGuid, action, result)
if TestFilter(_ => { result && (action == TransactionType.Buy || action == TransactionType.Loadout) }) => if TestFilter(() => { result && (action == TransactionType.Buy || action == TransactionType.Loadout) }) =>
sendResponse(ItemTransactionResultMessage(terminalGuid, action, result)) sendResponse(ItemTransactionResultMessage(terminalGuid, action, result))
sessionLogic.terminals.lastTerminalOrderFulfillment = true sessionLogic.terminals.lastTerminalOrderFulfillment = true
AvatarActor.savePlayerData(player) AvatarActor.savePlayerData(player)
@ -219,7 +219,7 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
inventory, inventory,
drop, drop,
delete delete
) if TestFilter(_ => { resolvedGuid == target }) => ) if TestFilter(() => { ResolvedGuid == target }) =>
sendResponse(ArmorChangedMessage(target, exosuit, subtype)) sendResponse(ArmorChangedMessage(target, exosuit, subtype))
sendResponse(PlanetsideAttributeMessage(target, attribute_type=4, armor)) sendResponse(PlanetsideAttributeMessage(target, attribute_type=4, armor))
//happening to this player //happening to this player
@ -297,7 +297,7 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
oldInventory, oldInventory,
inventory, inventory,
drops drops
) if TestFilter(_ => { resolvedGuid == target }) => ) if TestFilter(() => { ResolvedGuid == target }) =>
sendResponse(ArmorChangedMessage(target, exosuit, subtype)) sendResponse(ArmorChangedMessage(target, exosuit, subtype))
sendResponse(PlanetsideAttributeMessage(target, attribute_type = 4, armor)) sendResponse(PlanetsideAttributeMessage(target, attribute_type = 4, armor))
//happening to this player //happening to this player
@ -331,9 +331,9 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
case AvatarAction.UseKit(kguid, kObjId) => case AvatarAction.UseKit(kguid, kObjId) =>
sendResponse( sendResponse(
UseItemMessage( UseItemMessage(
resolvedGuid, ResolvedGuid,
kguid, kguid,
resolvedGuid, ResolvedGuid,
unk2 = 4294967295L, unk2 = 4294967295L,
unk3 = false, unk3 = false,
unk4 = Vector3.Zero, unk4 = Vector3.Zero,
@ -354,7 +354,7 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
sendResponse(ChatMsg(ChatMessageType.UNK_225, msg)) sendResponse(ChatMsg(ChatMessageType.UNK_225, msg))
case AvatarAction.UpdateKillsDeathsAssists(_, kda: Kill) case AvatarAction.UpdateKillsDeathsAssists(_, kda: Kill)
if TestFilter(_ => kda.experienceEarned > 0) => if TestFilter(() => kda.experienceEarned > 0) =>
continent.actor ! ZoneActor.RewardOurSupporters( continent.actor ! ZoneActor.RewardOurSupporters(
PlayerSource(player), PlayerSource(player),
Players.produceContributionTranscriptFromKill(continent, player, kda), Players.produceContributionTranscriptFromKill(continent, player, kda),
@ -389,7 +389,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 TestFilter(_ => { isNotSameTarget && ops.lastSeenStreamMessage.get(filterGuid.guid).exists { _.visible }}) => if TestFilter(() => { NotSameTarget && 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) =>
@ -444,11 +444,11 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
} }
case AvatarAction.ReleasePlayer(tplayer) case AvatarAction.ReleasePlayer(tplayer)
if TestFilter(_ => isNotSameTarget) => if TestFilter(NotSameTargetTest) =>
sessionLogic.zoning.spawn.DepictPlayerAsCorpse(tplayer) sessionLogic.zoning.spawn.DepictPlayerAsCorpse(tplayer)
case AvatarAction.Revive(revivalTargetGuid) case AvatarAction.Revive(revivalTargetGuid)
if TestFilter(_ => { resolvedGuid == revivalTargetGuid }) => if TestFilter(() => { ResolvedGuid == revivalTargetGuid }) =>
log.info(s"No time for rest, ${player.Name}. Back on your feet!") log.info(s"No time for rest, ${player.Name}. Back on your feet!")
sessionLogic.zoning.spawn.reviveTimer.cancel() sessionLogic.zoning.spawn.reviveTimer.cancel()
sessionLogic.zoning.spawn.deadState = DeadState.Alive sessionLogic.zoning.spawn.deadState = DeadState.Alive
@ -463,12 +463,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 TestFilter(_ => isNotSameTarget) => if TestFilter(NotSameTargetTest) =>
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) case AvatarAction.ChangeFireMode(itemGuid, mode)
if TestFilter(_ => isNotSameTarget) => if TestFilter(NotSameTargetTest) =>
sendResponse(ChangeFireModeMessage(itemGuid, mode)) sendResponse(ChangeFireModeMessage(itemGuid, mode))
case AvatarAction.EnvironmentalDamage(_, _, _) => case AvatarAction.EnvironmentalDamage(_, _, _) =>
@ -476,7 +476,7 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
sessionLogic.zoning.CancelZoningProcess() sessionLogic.zoning.CancelZoningProcess()
case AvatarAction.DropCreatedItem(pkt) case AvatarAction.DropCreatedItem(pkt)
if TestFilter(_ => isNotSameTarget) => if TestFilter(NotSameTargetTest) =>
sendResponse(pkt) sendResponse(pkt)
/* rare messages */ /* rare messages */
@ -490,11 +490,11 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
)) ))
case AvatarAction.LoadCreatedProjectile(pkt) case AvatarAction.LoadCreatedProjectile(pkt)
if TestFilter(_ => isNotSameTarget) => if TestFilter(NotSameTargetTest) =>
sendResponse(pkt) sendResponse(pkt)
case AvatarAction.ProjectileState(projectileGuid, shotPos, shotVel, shotOrient, seq, end, targetGuid) case AvatarAction.ProjectileState(projectileGuid, shotPos, shotVel, shotOrient, seq, end, targetGuid)
if TestFilter(_ => isNotSameTarget) => if TestFilter(NotSameTargetTest) =>
sendResponse(ProjectileStateMessage(projectileGuid, shotPos, shotVel, shotOrient, seq, end, targetGuid)) sendResponse(ProjectileStateMessage(projectileGuid, shotPos, shotVel, shotOrient, seq, end, targetGuid))
case AvatarAction.ProjectileExplodes(projectileGuid, projectile) => case AvatarAction.ProjectileExplodes(projectileGuid, projectile) =>
@ -515,11 +515,11 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
sendResponse(GenericActionMessage(mode)) sendResponse(GenericActionMessage(mode))
case AvatarAction.PutDownFDU(target) case AvatarAction.PutDownFDU(target)
if TestFilter(_ => isNotSameTarget) => if TestFilter(NotSameTargetTest) =>
sendResponse(GenericObjectActionMessage(target, code=53)) sendResponse(GenericObjectActionMessage(target, code=53))
case AvatarAction.StowEquipment(target, slot, item) case AvatarAction.StowEquipment(target, slot, item)
if TestFilter(_ => isNotSameTarget) => if TestFilter(NotSameTargetTest) =>
val definition = item.Definition val definition = item.Definition
sendResponse( sendResponse(
ObjectCreateDetailedMessage( ObjectCreateDetailedMessage(
@ -531,7 +531,7 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
) )
case WeaponDryFire(weaponGuid) case WeaponDryFire(weaponGuid)
if TestFilter(_ => { isNotSameTarget && ops.lastSeenStreamMessage.get(filterGuid.guid).exists { _.visible } }) => if TestFilter(() => { NotSameTarget && 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 =>
sendResponse(WeaponDryFireMessage(weaponGuid)) sendResponse(WeaponDryFireMessage(weaponGuid))

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

@ -39,7 +39,7 @@ class VehicleHandlerLogic(val ops: SessionVehicleHandlers, implicit val context:
wheelDirection, wheelDirection,
unk5, unk5,
unk6 unk6
) if TestFilter(_ => { isNotSameTarget && player.VehicleSeated.contains(vehicleGuid) }) => ) if TestFilter(() => { NotSameTarget && player.VehicleSeated.contains(vehicleGuid) }) =>
//player who is also in the vehicle (not driver) //player who is also in the vehicle (not driver)
sendResponse(VehicleStateMessage(vehicleGuid, unk1, pos, orient, vel, unk2, unk3, unk4, wheelDirection, unk5, unk6)) sendResponse(VehicleStateMessage(vehicleGuid, unk1, pos, orient, vel, unk2, unk3, unk4, wheelDirection, unk5, unk6))
player.Position = pos player.Position = pos
@ -59,36 +59,36 @@ class VehicleHandlerLogic(val ops: SessionVehicleHandlers, implicit val context:
wheelDirection, wheelDirection,
unk5, unk5,
unk6 unk6
) if TestFilter(_ => isNotSameTarget) => ) if TestFilter(NotSameTargetTest) =>
//player who is watching the vehicle from the outside //player who is watching the vehicle from the outside
sendResponse(VehicleStateMessage(vehicleGuid, unk1, pos, ang, vel, unk2, unk3, unk4, wheelDirection, unk5, unk6)) sendResponse(VehicleStateMessage(vehicleGuid, unk1, pos, ang, vel, unk2, unk3, unk4, wheelDirection, unk5, unk6))
case VehicleAction.ChildObjectState(objectGuid, pitch, yaw) case VehicleAction.ChildObjectState(objectGuid, pitch, yaw)
if TestFilter(_ => isNotSameTarget) => if TestFilter(NotSameTargetTest) =>
sendResponse(ChildObjectStateMessage(objectGuid, pitch, yaw)) sendResponse(ChildObjectStateMessage(objectGuid, pitch, yaw))
case VehicleAction.FrameVehicleState(vguid, u1, pos, oient, vel, u2, u3, u4, is_crouched, u6, u7, u8, u9, uA) case VehicleAction.FrameVehicleState(vguid, u1, pos, oient, vel, u2, u3, u4, is_crouched, u6, u7, u8, u9, uA)
if TestFilter(_ => isNotSameTarget) => if TestFilter(NotSameTargetTest) =>
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) case VehicleAction.DismountVehicle(bailType, wasKickedByDriver)
if TestFilter(_ => isNotSameTarget) => if TestFilter(NotSameTargetTest) =>
sendResponse(DismountVehicleMsg(filterGuid, bailType, wasKickedByDriver)) sendResponse(DismountVehicleMsg(FilterGuid, bailType, wasKickedByDriver))
case VehicleAction.MountVehicle(vehicleGuid, seat) case VehicleAction.MountVehicle(vehicleGuid, seat)
if TestFilter(_ => isNotSameTarget) => if TestFilter(NotSameTargetTest) =>
sendResponse(ObjectAttachMessage(vehicleGuid, filterGuid, seat)) sendResponse(ObjectAttachMessage(vehicleGuid, FilterGuid, seat))
case VehicleAction.DeployRequest(objectGuid, state, unk1, unk2, pos) case VehicleAction.DeployRequest(objectGuid, state, unk1, unk2, pos)
if TestFilter(_ => isNotSameTarget) => if TestFilter(NotSameTargetTest) =>
sendResponse(DeployRequestMessage(filterGuid, objectGuid, state, unk1, unk2, pos)) sendResponse(DeployRequestMessage(FilterGuid, objectGuid, state, unk1, unk2, pos))
case VehicleAction.EquipmentCreatedInSlot(pkt) case VehicleAction.EquipmentCreatedInSlot(pkt)
if TestFilter(_ => isNotSameTarget) => if TestFilter(NotSameTargetTest) =>
sendResponse(pkt) sendResponse(pkt)
case VehicleAction.InventoryState(obj, parentGuid, start, conData) case VehicleAction.InventoryState(obj, parentGuid, start, conData)
if TestFilter(_ => isNotSameTarget) => if TestFilter(NotSameTargetTest) =>
//TODO prefer ObjectDetachMessage, but how to force ammo pools to update properly? //TODO prefer ObjectDetachMessage, but how to force ammo pools to update properly?
val objGuid = obj.GUID val objGuid = obj.GUID
sendResponse(ObjectDeleteMessage(objGuid, unk1=0)) sendResponse(ObjectDeleteMessage(objGuid, unk1=0))
@ -100,10 +100,10 @@ class VehicleHandlerLogic(val ops: SessionVehicleHandlers, implicit val context:
)) ))
case VehicleAction.KickPassenger(_, wasKickedByDriver, vehicleGuid) case VehicleAction.KickPassenger(_, wasKickedByDriver, vehicleGuid)
if TestFilter(_ => isNotSameTarget) => if TestFilter(NotSameTargetTest) =>
//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(filterGuid, 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)
@ -113,27 +113,27 @@ 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(filterGuid, BailType.Kicked, wasKickedByDriver)) sendResponse(DismountVehicleMsg(FilterGuid, BailType.Kicked, wasKickedByDriver))
case VehicleAction.InventoryState2(objGuid, parentGuid, value) case VehicleAction.InventoryState2(objGuid, parentGuid, value)
if TestFilter(_ => isNotSameTarget) => if TestFilter(NotSameTargetTest) =>
sendResponse(InventoryStateMessage(objGuid, unk=0, parentGuid, value)) sendResponse(InventoryStateMessage(objGuid, unk=0, parentGuid, value))
case VehicleAction.LoadVehicle(vehicle, vtype, vguid, vdata) case VehicleAction.LoadVehicle(vehicle, vtype, vguid, vdata)
if TestFilter(_ => isNotSameTarget) => if TestFilter(NotSameTargetTest) =>
//this is not be suitable for vehicles with people who are seated in it before it spawns (if that is possible) //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)) sendResponse(ObjectCreateMessage(vtype, vguid, vdata))
Vehicles.ReloadAccessPermissions(vehicle, player.Name) Vehicles.ReloadAccessPermissions(vehicle, player.Name)
case VehicleAction.SeatPermissions(vehicleGuid, seatGroup, permission) case VehicleAction.SeatPermissions(vehicleGuid, seatGroup, permission)
if TestFilter(_ => isNotSameTarget) => if TestFilter(NotSameTargetTest) =>
sendResponse(PlanetsideAttributeMessage(vehicleGuid, seatGroup, permission)) sendResponse(PlanetsideAttributeMessage(vehicleGuid, seatGroup, permission))
case VehicleAction.UnloadVehicle(_, vehicleGuid) => case VehicleAction.UnloadVehicle(_, vehicleGuid) =>
sendResponse(ObjectDeleteMessage(vehicleGuid, unk1=1)) sendResponse(ObjectDeleteMessage(vehicleGuid, unk1=1))
case VehicleAction.UnstowEquipment(itemGuid) case VehicleAction.UnstowEquipment(itemGuid)
if TestFilter(_ => isNotSameTarget) => if TestFilter(NotSameTargetTest) =>
//TODO prefer ObjectDetachMessage, but how to force ammo pools to update properly? //TODO prefer ObjectDetachMessage, but how to force ammo pools to update properly?
sendResponse(ObjectDeleteMessage(itemGuid, unk1=0)) sendResponse(ObjectDeleteMessage(itemGuid, unk1=0))
@ -142,7 +142,7 @@ class VehicleHandlerLogic(val ops: SessionVehicleHandlers, implicit val context:
sessionLogic.zoning.spawn.DrawCurrentAmsSpawnPoint() sessionLogic.zoning.spawn.DrawCurrentAmsSpawnPoint()
case VehicleAction.KickCargo(vehicle, speed, delay) case VehicleAction.KickCargo(vehicle, speed, delay)
if TestFilter(_ => { player.VehicleSeated.nonEmpty && sessionLogic.zoning.spawn.deadState == DeadState.Alive && speed > 0 }) => if TestFilter(() => { player.VehicleSeated.nonEmpty && sessionLogic.zoning.spawn.deadState == DeadState.Alive && speed > 0 }) =>
val strafe = 1 + Vehicles.CargoOrientation(vehicle) val strafe = 1 + Vehicles.CargoOrientation(vehicle)
val reverseSpeed = if (strafe > 1) { 0 } else { speed } val reverseSpeed = if (strafe > 1) { 0 } else { speed }
//strafe or reverse, not both //strafe or reverse, not both
@ -170,7 +170,7 @@ class VehicleHandlerLogic(val ops: SessionVehicleHandlers, implicit val context:
context.system.scheduler.scheduleOnce(delay milliseconds, context.self, resp) context.system.scheduler.scheduleOnce(delay milliseconds, context.self, resp)
case VehicleAction.KickCargo(cargo, _, _) case VehicleAction.KickCargo(cargo, _, _)
if TestFilter(_ => { player.VehicleSeated.nonEmpty && sessionLogic.zoning.spawn.deadState == DeadState.Alive }) => if TestFilter(() => { player.VehicleSeated.nonEmpty && sessionLogic.zoning.spawn.deadState == DeadState.Alive }) =>
sessionLogic.vehicles.TotalDriverVehicleControl(cargo) sessionLogic.vehicles.TotalDriverVehicleControl(cargo)
case VehicleSpawnPad.AttachToRails(vehicle, pad) => case VehicleSpawnPad.AttachToRails(vehicle, pad) =>

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

@ -2,33 +2,22 @@
package net.psforever.actors.session.support package net.psforever.actors.session.support
import akka.actor.Actor.Receive import akka.actor.Actor.Receive
import net.psforever.objects.Default import net.psforever.objects.{Default, Player}
import net.psforever.services.base.message.EventResponse import net.psforever.services.base.message.EventResponse
import net.psforever.types.PlanetSideGUID import net.psforever.types.PlanetSideGUID
trait CommonHandlerFunctions { /**
_: CommonSessionInterfacingFunctionality => * A shared filter container utilized by all response handlers connected by a certain mode.
protected var resolvedGuid: PlanetSideGUID = Default.GUID0 * It is expected that the filters are treated in a true-oriented context -
protected var filterGuid: PlanetSideGUID = Default.GUID0 * always check `isNotSameTarget` and not `!isSameTarget`, etc..
protected var isNotSameTarget: Boolean = false */
protected var isSameTarget: Boolean = false protected[support] class CommonHandlerFilters {
var resolvedGuid: PlanetSideGUID = Default.GUID0
var filterGuid: PlanetSideGUID = Default.GUID0
var isNotSameTarget: Boolean = false
var isSameTarget: Boolean = false
private var ignoreFilter: Boolean = false def Configure(player: Player, guid: PlanetSideGUID): Unit = {
def IgnoreFilter: Boolean = ignoreFilter
def IgnoreFilter_=(state: Boolean): Boolean = {
ignoreFilter = state
IgnoreFilter
}
/**
* na
* @param toChannel na
* @param guid na
* @param reply na
*/
def handle(toChannel: String, guid: PlanetSideGUID, reply: EventResponse): Boolean = {
filterGuid = guid filterGuid = guid
if (player != null && player.HasGUID) { if (player != null && player.HasGUID) {
resolvedGuid = player.GUID resolvedGuid = player.GUID
@ -39,20 +28,73 @@ trait CommonHandlerFunctions {
isNotSameTarget = false isNotSameTarget = false
isSameTarget = false isSameTarget = false
} }
}
}
trait CommonHandlerFunctions {
_: CommonSessionInterfacingFunctionality =>
final def ResolvedGuid: PlanetSideGUID = sessionLogic.handlerFilters.resolvedGuid
final def FilterGuid: PlanetSideGUID = sessionLogic.handlerFilters.filterGuid
final def NotSameTarget: Boolean = sessionLogic.handlerFilters.isNotSameTarget
final def SameTarget: Boolean = sessionLogic.handlerFilters.isSameTarget
val NotSameTargetTest: () => Boolean = () => NotSameTarget
val SameTargetTest: () => Boolean = () => SameTarget
private var ignoreFilter: Boolean = false
final def IgnoreFilter: Boolean = ignoreFilter
final def IgnoreFilter_=(state: Boolean): Boolean = {
ignoreFilter = state
IgnoreFilter
}
/**
* Process the output of a received response envelope.
* Sets the response handler filter.
* @param toChannel set of subscribers on an event system bus the envelope should reach
* @param guid a specific subscriber endpoint to be excluded
* @param reply output payload transported by this envelope
* @return `true`, if the response was processed; `false`, otherwise
*/
final def handle(toChannel: String, guid: PlanetSideGUID, reply: EventResponse): Boolean = {
sessionLogic.handlerFilters.Configure(player, guid)
tryToHandle(reply) tryToHandle(reply)
} }
def receive: Receive /**
* Can the response handler process this message (with the guard boolean permissions set as they currently are).
* @see `Actor.isDefinedAt`
* @param x payload for processing
* @return `true`, if the payload was processed; `false`, otherwise
*/
def isDefinedAt(x: Any): Boolean = receive.isDefinedAt(x) def isDefinedAt(x: Any): Boolean = receive.isDefinedAt(x)
/**
* Process the output.
* @param x payload for processing
* @return `true`, if the payload was processed; `false`, otherwise
*/
final def tryToHandle(x: Any): Boolean = { final def tryToHandle(x: Any): Boolean = {
var passed = true var passed = true
receive.applyOrElse(x, (_: Any) => { passed = false }) receive.applyOrElse(x, (_: Any) => { passed = false })
passed passed
} }
def TestFilter(filter: Unit => Boolean): Boolean = { /**
* If ignoring guard booleans (filters), always pass.
* If not, test filters using the provided function.
* @param filter contained guard booleans
* @return `true`. if ignoring filter tests or the filter test passed; `false`, otherwise
*/
final def TestFilter(filter: () => Boolean): Boolean = {
ignoreFilter || filter() ignoreFilter || filter()
} }
/**
* @see `Actor.receive`
*/
def receive: Receive
} }

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

@ -12,52 +12,52 @@ class CommonHandlerLogic(val sessionLogic: SessionData, implicit val context: Ac
def receive: Receive = { def receive: Receive = {
case PlanetsideAttribute(target_guid, attributeType, attributeValue) case PlanetsideAttribute(target_guid, attributeType, attributeValue)
if TestFilter(_ => isNotSameTarget) => if TestFilter(NotSameTargetTest) =>
sendResponse(PlanetsideAttributeMessage(target_guid, attributeType, attributeValue)) sendResponse(PlanetsideAttributeMessage(target_guid, attributeType, attributeValue))
case GenericObjectAction(objectGuid, actionCode) case GenericObjectAction(objectGuid, actionCode)
if TestFilter(_ => isNotSameTarget) => if TestFilter(NotSameTargetTest) =>
sendResponse(GenericObjectActionMessage(objectGuid, actionCode)) sendResponse(GenericObjectActionMessage(objectGuid, actionCode))
case ObjectDelete(itemGuid, unk) case ObjectDelete(itemGuid, unk)
if TestFilter(_ => isNotSameTarget) => if TestFilter(NotSameTargetTest) =>
sendResponse(ObjectDeleteMessage(itemGuid, unk)) sendResponse(ObjectDeleteMessage(itemGuid, unk))
case ChangeFireState_Start(weaponGuid) case ChangeFireState_Start(weaponGuid)
if TestFilter(_ => isNotSameTarget) => if TestFilter(NotSameTargetTest) =>
sendResponse(ChangeFireStateMessage_Start(weaponGuid)) sendResponse(ChangeFireStateMessage_Start(weaponGuid))
case ChangeFireState_Stop(weaponGuid) case ChangeFireState_Stop(weaponGuid)
if TestFilter(_ => isNotSameTarget) => if TestFilter(NotSameTargetTest) =>
sendResponse(ChangeFireStateMessage_Stop(weaponGuid)) sendResponse(ChangeFireStateMessage_Stop(weaponGuid))
case ReloadTool(itemGuid) case ReloadTool(itemGuid)
if TestFilter(_ => isNotSameTarget) => if TestFilter(NotSameTargetTest) =>
sendResponse(ReloadMessage(itemGuid, ammo_clip=1, unk1=0)) sendResponse(ReloadMessage(itemGuid, ammo_clip=1, unk1=0))
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 TestFilter(_ => isNotSameTarget) => if TestFilter(NotSameTargetTest) =>
sessionLogic.avatarResponse.changeAmmoProcedure(weapon_guid, previous_guid, ammo_id, ammo_guid, weapon_slot, ammo_data) sessionLogic.avatarResponse.changeAmmoProcedure(weapon_guid, previous_guid, ammo_id, ammo_guid, weapon_slot, ammo_data)
sendResponse(ChangeAmmoMessage(weapon_guid, 1)) sendResponse(ChangeAmmoMessage(weapon_guid, 1))
case WeaponDryFire(weaponGuid) case WeaponDryFire(weaponGuid)
if TestFilter(_ => isNotSameTarget) => if TestFilter(NotSameTargetTest) =>
continent.GUID(weaponGuid).collect { continent.GUID(weaponGuid).collect {
case tool: Tool if tool.Magazine == 0 => case tool: Tool if tool.Magazine == 0 =>
sendResponse(WeaponDryFireMessage(weaponGuid)) sendResponse(WeaponDryFireMessage(weaponGuid))
} }
case HintsAtAttacker(sourceGuid) case HintsAtAttacker(sourceGuid)
if TestFilter(_ => { player.isAlive }) => if TestFilter(() => { player.isAlive }) =>
sendResponse(HitHint(sourceGuid, filterGuid)) sendResponse(HitHint(sourceGuid, FilterGuid))
sessionLogic.zoning.CancelZoningProcessWithDescriptiveReason("cancel_dmg") sessionLogic.zoning.CancelZoningProcessWithDescriptiveReason("cancel_dmg")
case SetEmpire(objectGuid, faction) case SetEmpire(objectGuid, faction)
if TestFilter(_ => isNotSameTarget) => if TestFilter(NotSameTargetTest) =>
sendResponse(SetEmpireMessage(objectGuid, faction)) sendResponse(SetEmpireMessage(objectGuid, faction))
case ConcealPlayer(_) => case ConcealPlayer(_) =>
sendResponse(GenericObjectActionMessage(filterGuid, code=9)) sendResponse(GenericObjectActionMessage(FilterGuid, code=9))
case SendResponse(msgs) => case SendResponse(msgs) =>
msgs.foreach(sendResponse) msgs.foreach(sendResponse)

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

@ -120,6 +120,8 @@ class SessionData(
def zoning: ZoningOperations = zoningOpt.orNull def zoning: ZoningOperations = zoningOpt.orNull
def chat: ChatOperations = chatOpt.orNull def chat: ChatOperations = chatOpt.orNull
val handlerFilters: CommonHandlerFilters = new CommonHandlerFilters()
ServiceManager.serviceManager ! Lookup("accountIntermediary") ServiceManager.serviceManager ! Lookup("accountIntermediary")
ServiceManager.serviceManager ! Lookup("accountPersistence") ServiceManager.serviceManager ! Lookup("accountPersistence")
ServiceManager.serviceManager ! Lookup("galaxy") ServiceManager.serviceManager ! Lookup("galaxy")

4
src/main/scala/net/psforever/actors/session/support/SessionMountHandlers.scala
View file

@ -208,9 +208,9 @@ class SessionMountHandlers(
sessionLogic.keepAliveFunc = sessionLogic.zoning.NormalKeepAlive sessionLogic.keepAliveFunc = sessionLogic.zoning.NormalKeepAlive
continent.VehicleEvents ! MessageEnvelope( continent.VehicleEvents ! MessageEnvelope(
continent.id, continent.id,
SendResponse(List( SendResponse(
PlanetsideAttributeMessage(obj.GUID, 81, 1), PlanetsideAttributeMessage(obj.GUID, 81, 1),
ObjectDetachMessage(obj.GUID, tplayer.GUID, tplayer.Position, obj.Orientation)) ObjectDetachMessage(obj.GUID, tplayer.GUID, tplayer.Position, obj.Orientation)
) )
) )
} }

20
src/main/scala/net/psforever/actors/session/support/SessionOutfitHandlers.scala
View file

@ -73,7 +73,7 @@ object SessionOutfitHandlers {
player.outfit_id = outfitId player.outfit_id = outfitId
player.outfit_name = outfitName player.outfit_name = outfitName
zone.AvatarEvents ! BundledEnvelope( zone.AvatarEvents ! BundledEnvelope(
MessageEnvelope(pname, SendResponse(List( MessageEnvelope(pname, SendResponse(
OutfitEvent(outfitId, Update( OutfitEvent(outfitId, Update(
OutfitInfo( OutfitInfo(
outfitName, 0, 0, 1, outfitName, 0, 0, 1,
@ -84,7 +84,7 @@ object SessionOutfitHandlers {
OutfitMemberUpdate(outfitId, charid, 7, flag = true), OutfitMemberUpdate(outfitId, charid, 7, flag = true),
ChatMsg(ChatMessageType.UNK_227, "@OutfitCreateSuccess"), ChatMsg(ChatMessageType.UNK_227, "@OutfitCreateSuccess"),
OutfitMembershipResponse(CreateResponse, 0, 0, charid, 0, "", "", flag = true), OutfitMembershipResponse(CreateResponse, 0, 0, charid, 0, "", "", flag = true),
))), )),
MessageEnvelope( MessageEnvelope(
zoneid, zoneid,
PlanetsideAttribute(player.GUID, 39, outfitId) PlanetsideAttribute(player.GUID, 39, outfitId)
@ -148,7 +148,7 @@ object SessionOutfitHandlers {
val outfitName = outfit.name val outfitName = outfit.name
val seconds: Long = outfit.created.atZone(ZoneId.systemDefault()).toInstant.toEpochMilli / 1000 val seconds: Long = outfit.created.atZone(ZoneId.systemDefault()).toInstant.toEpochMilli / 1000
fromZone.AvatarEvents ! BundledEnvelope( fromZone.AvatarEvents ! BundledEnvelope(
MessageEnvelope(fromName, SendResponse(List( MessageEnvelope(fromName, SendResponse(
OutfitMembershipResponse( OutfitMembershipResponse(
OutfitMembershipResponse.PacketType.InviteAccepted, 0, 0, OutfitMembershipResponse.PacketType.InviteAccepted, 0, 0,
toCharId, fromCharId, toName, outfitName, flag = false toCharId, fromCharId, toName, outfitName, flag = false
@ -159,10 +159,10 @@ object SessionOutfitHandlers {
OutfitMemberEventAction.PacketType.Padding, 0 OutfitMemberEventAction.PacketType.Padding, 0
) )
) )
))) ))
) )
toZone.AvatarEvents ! BundledEnvelope( toZone.AvatarEvents ! BundledEnvelope(
MessageEnvelope(toName, SendResponse(List( MessageEnvelope(toName, SendResponse(
OutfitMembershipResponse( OutfitMembershipResponse(
OutfitMembershipResponse.PacketType.InviteAccepted, 0, 0, OutfitMembershipResponse.PacketType.InviteAccepted, 0, 0,
toCharId, fromCharId, toName, outfitName, flag = true toCharId, fromCharId, toName, outfitName, flag = true
@ -174,7 +174,7 @@ object SessionOutfitHandlers {
14, unk11 = true, 0, seconds, 0, 0, 0 14, unk11 = true, 0, seconds, 0, 0, 0
))), ))),
OutfitMemberUpdate(outfitId, toCharId, 0, flag=true) OutfitMemberUpdate(outfitId, toCharId, 0, flag=true)
))), )),
MessageEnvelope( MessageEnvelope(
toZoneId, toZoneId,
PlanetsideAttribute(toGuid, 39, outfitId) PlanetsideAttribute(toGuid, 39, outfitId)
@ -266,13 +266,13 @@ object SessionOutfitHandlers {
if (deleted > 0) { if (deleted > 0) {
findPlayerByIdForOutfitAction(zones, kickedId, kickedBy).foreach { kicked => findPlayerByIdForOutfitAction(zones, kickedId, kickedBy).foreach { kicked =>
kicked.Zone.AvatarEvents ! BundledEnvelope( kicked.Zone.AvatarEvents ! BundledEnvelope(
MessageEnvelope(kicked.Name, SendResponse(List( MessageEnvelope(kicked.Name, SendResponse(
OutfitEvent(outfit_id, Leaving()), OutfitEvent(outfit_id, Leaving()),
OutfitMembershipResponse( OutfitMembershipResponse(
OutfitMembershipResponse.PacketType.YouGotKicked, 0, 1, OutfitMembershipResponse.PacketType.YouGotKicked, 0, 1,
kickedBy.CharId, kicked.CharId, kickedBy.Name, kicked.Name, flag = false kickedBy.CharId, kicked.CharId, kickedBy.Name, kicked.Name, flag = false
) )
))), )),
MessageEnvelope(kicked.Zone.id, MessageEnvelope(kicked.Zone.id,
PlanetsideAttribute(kicked.GUID, 39, 0) PlanetsideAttribute(kicked.GUID, 39, 0)
), ),
@ -599,7 +599,7 @@ object SessionOutfitHandlers {
case (Some(outfit), memberCount, points) => case (Some(outfit), memberCount, points) =>
val seconds: Long = outfit.created.atZone(ZoneId.systemDefault()).toInstant.toEpochMilli / 1000 val seconds: Long = outfit.created.atZone(ZoneId.systemDefault()).toInstant.toEpochMilli / 1000
player.Zone.AvatarEvents ! BundledEnvelope( player.Zone.AvatarEvents ! BundledEnvelope(
MessageEnvelope(player.Name, SendResponse(List( MessageEnvelope(player.Name, SendResponse(
OutfitEvent(outfitId, Update(OutfitInfo( OutfitEvent(outfitId, Update(OutfitInfo(
outfit.name, points, points, memberCount, outfit.name, points, points, memberCount,
OutfitRankNames( OutfitRankNames(
@ -611,7 +611,7 @@ object SessionOutfitHandlers {
14, unk11 = true, 0, seconds, 0, 0, 0 14, unk11 = true, 0, seconds, 0, 0, 0
))), ))),
OutfitMemberUpdate(outfit.id, player.CharId, membership.rank, flag = true) OutfitMemberUpdate(outfit.id, player.CharId, membership.rank, flag = true)
))), )),
MessageEnvelope( MessageEnvelope(
player.Zone.id, player.Zone.id,
PlanetsideAttribute(player.GUID, 39, outfit.id) PlanetsideAttribute(player.GUID, 39, outfit.id)

2
src/main/scala/net/psforever/actors/session/support/ZoningOperations.scala
View file

@ -3502,7 +3502,7 @@ class ZoningOperations(
val events = zone.AvatarEvents val events = zone.AvatarEvents
events ! MessageEnvelope( events ! MessageEnvelope(
channel, channel,
SendResponse(List(PlanetsideAttributeMessage(guid, 0, 120), PlanetsideAttributeMessage(guid, 1, 120))) SendResponse(PlanetsideAttributeMessage(guid, 0, 120), PlanetsideAttributeMessage(guid, 1, 120))
) )
case _ => () case _ => ()
} }

8
src/main/scala/net/psforever/actors/zone/building/MajorFacilityLogic.scala
View file

@ -242,10 +242,10 @@ case object MajorFacilityLogic
val guid = building.GUID val guid = building.GUID
//1. reset ???; might be global? //1. reset ???; might be global?
//2. This facility's generator is back on line //2. This facility's generator is back on line
val list = SendResponse(List( val list = SendResponse(
PlanetsideAttributeMessage(guid, 46, 0), PlanetsideAttributeMessage(guid, 46, 0),
GenericObjectActionMessage(guid, 17) GenericObjectActionMessage(guid, 17)
)) )
events ! BundledEnvelope(building.PlayersInSOI.map { player => MessageEnvelope(player.Name, list) }) events ! BundledEnvelope(building.PlayersInSOI.map { player => MessageEnvelope(player.Name, list) })
true true
case _ => case _ =>
@ -300,7 +300,7 @@ case object MajorFacilityLogic
//2 .disable spawn target on deployment map //2 .disable spawn target on deployment map
events ! MessageEnvelope( events ! MessageEnvelope(
zoneId, zoneId,
SendResponse(List(PlanetsideAttributeMessage(guid, 48, 1), PlanetsideAttributeMessage(guid, 38, 0))) SendResponse(PlanetsideAttributeMessage(guid, 48, 1), PlanetsideAttributeMessage(guid, 38, 0))
) )
Behaviors.same Behaviors.same
} }
@ -325,7 +325,7 @@ case object MajorFacilityLogic
//2. enable spawn target on deployment map //2. enable spawn target on deployment map
events ! MessageEnvelope( events ! MessageEnvelope(
zoneId, zoneId,
SendResponse(List(PlanetsideAttributeMessage(guid, 48, 0), PlanetsideAttributeMessage(guid, 38, 1))) SendResponse(PlanetsideAttributeMessage(guid, 48, 0), PlanetsideAttributeMessage(guid, 38, 1))
) )
Behaviors.same Behaviors.same
} }

2
src/main/scala/net/psforever/objects/serverobject/damage/DamageableAmenity.scala
View file

@ -39,7 +39,7 @@ object DamageableAmenity {
val targetGUID = target.GUID val targetGUID = target.GUID
events ! MessageEnvelope( events ! MessageEnvelope(
zoneId, zoneId,
SendResponse(List(PlanetsideAttributeMessage(targetGUID, 50, 1), PlanetsideAttributeMessage(targetGUID, 51, 1))) SendResponse(PlanetsideAttributeMessage(targetGUID, 50, 1), PlanetsideAttributeMessage(targetGUID, 51, 1))
) )
} }
} }

2
src/main/scala/net/psforever/objects/serverobject/hackable/GenericHackables.scala
View file

@ -274,7 +274,7 @@ object GenericHackables {
) )
zone.LocalEvents ! MessageEnvelope( zone.LocalEvents ! MessageEnvelope(
zone.id, zone.id,
SendResponse(List(GenericObjectActionMessage(target.GUID, 61), GenericObjectActionMessage(target.GUID, 58))) SendResponse(GenericObjectActionMessage(target.GUID, 61), GenericObjectActionMessage(target.GUID, 58))
) )
//amenities if applicable //amenities if applicable
virus match { virus match {

2
src/main/scala/net/psforever/objects/serverobject/repair/RepairableAmenity.scala
View file

@ -40,7 +40,7 @@ object RepairableAmenity {
val targetGUID = target.GUID val targetGUID = target.GUID
events ! MessageEnvelope( events ! MessageEnvelope(
zoneId, zoneId,
SendResponse(List(PlanetsideAttributeMessage(targetGUID, 50, 0), PlanetsideAttributeMessage(targetGUID, 51, 0))) SendResponse(PlanetsideAttributeMessage(targetGUID, 50, 0), PlanetsideAttributeMessage(targetGUID, 51, 0))
) )
RestorationOfHistory(target) RestorationOfHistory(target)
} }

4
src/main/scala/net/psforever/objects/serverobject/structures/participation/FacilityHackParticipation.scala
View file

@ -110,10 +110,10 @@ trait FacilityHackParticipation extends ParticipationLogic {
import net.psforever.objects.serverobject.terminals.Terminal import net.psforever.objects.serverobject.terminals.Terminal
import net.psforever.objects.GlobalDefinitions import net.psforever.objects.GlobalDefinitions
val mainTerm = building.Amenities.filter(x => x.isInstanceOf[Terminal] && x.Definition == GlobalDefinitions.main_terminal).head.GUID val mainTerm = building.Amenities.filter(x => x.isInstanceOf[Terminal] && x.Definition == GlobalDefinitions.main_terminal).head.GUID
val pkts = SendResponse(List( val pkts = SendResponse(
GenericObjectActionMessage(mainTerm, 61), GenericObjectActionMessage(mainTerm, 61),
GenericObjectActionMessage(mainTerm, 58) GenericObjectActionMessage(mainTerm, 58)
)) )
val events = building.Zone.AvatarEvents val events = building.Zone.AvatarEvents
events ! BundledEnvelope(list.map { p => events ! BundledEnvelope(list.map { p =>
MessageEnvelope(p.Name, pkts) MessageEnvelope(p.Name, pkts)

4
src/main/scala/net/psforever/objects/serverobject/turret/TurretControl.scala
View file

@ -43,7 +43,7 @@ trait TurretControl
val tguid = TurretObject.GUID val tguid = TurretObject.GUID
events ! MessageEnvelope( events ! MessageEnvelope(
zoneId, zoneId,
SendResponse(List(PlanetsideAttributeMessage(tguid, 50, 0), PlanetsideAttributeMessage(tguid, 51, 0))) SendResponse(PlanetsideAttributeMessage(tguid, 50, 0), PlanetsideAttributeMessage(tguid, 51, 0))
) )
} }
@ -62,7 +62,7 @@ trait TurretControl
CancelJammeredStatus(target) CancelJammeredStatus(target)
events ! MessageEnvelope( events ! MessageEnvelope(
zoneId, zoneId,
SendResponse(List(PlanetsideAttributeMessage(tguid, 50, 1), PlanetsideAttributeMessage(tguid, 51, 1))) SendResponse(PlanetsideAttributeMessage(tguid, 50, 1), PlanetsideAttributeMessage(tguid, 51, 1))
) )
} }
} }

2
src/main/scala/net/psforever/objects/vehicles/control/AntTransferBehavior.scala
View file

@ -163,7 +163,7 @@ trait AntTransferBehavior extends TransferBehavior with NtuStorageBehavior {
//2. orb particle effect off //2. orb particle effect off
events ! MessageEnvelope( events ! MessageEnvelope(
zoneId, zoneId,
SendResponse(List(PlanetsideAttributeMessage(vguid, 52, 0L), PlanetsideAttributeMessage(vguid, 49, 0L))) SendResponse(PlanetsideAttributeMessage(vguid, 52, 0L), PlanetsideAttributeMessage(vguid, 49, 0L))
) )
} else if (transferEvent == TransferBehavior.Event.Discharging) { } else if (transferEvent == TransferBehavior.Event.Discharging) {
events ! MessageEnvelope( events ! MessageEnvelope(

4
src/main/scala/net/psforever/services/base/envelope/GenericMessageEnvelope.scala
View file

@ -17,8 +17,8 @@ trait GenericMessageEnvelope
object GenericMessageEnvelope { object GenericMessageEnvelope {
/** /**
* The `unapply`ed data from a message envelope resembles the data from includes the filter and the channel information. * The extracted data from a message envelope resembles the data from,
* The original channel information. * including the filter and the original channel information.
* @param obj response envelope * @param obj response envelope
* @return a tuple containing the channel, filter, and reply message * @return a tuple containing the channel, filter, and reply message
*/ */

2
src/main/scala/net/psforever/services/base/envelope/GenericResponseEnvelope.scala
View file

@ -24,7 +24,7 @@ object GenericResponseEnvelope {
* @param stamp marker indicating the routing through which the original message was processed * @param stamp marker indicating the routing through which the original message was processed
* @param channel set of subscribers on an event system bus the envelope should reach * @param channel set of subscribers on an event system bus the envelope should reach
* @param filter a specific subscriber endpoint to be excluded * @param filter a specific subscriber endpoint to be excluded
* @param msg input payload transported by this envelope * @param msg output payload transported by this envelope
* @return a faked but typically acceptable response envelope * @return a faked but typically acceptable response envelope
*/ */
def apply(stamp: EventSystemStamp, channel: String, filter: PlanetSideGUID, msg: EventMessage): GenericResponseEnvelope = { def apply(stamp: EventSystemStamp, channel: String, filter: PlanetSideGUID, msg: EventMessage): GenericResponseEnvelope = {

11
src/main/scala/net/psforever/services/base/envelope/MessageEnvelope.scala
View file

@ -49,11 +49,6 @@ trait MessageTransformationBehavior
def reply: EventResponse = outputReply def reply: EventResponse = outputReply
} }
/**
* A proper event system envelope.
*/
case class MessageEnvelope(channel: String, filter: PlanetSideGUID, msg: EventMessage)
extends MessageTransformationBehavior
object MessageEnvelope { object MessageEnvelope {
def apply(msg: EventMessage): MessageEnvelope = def apply(msg: EventMessage): MessageEnvelope =
@ -62,3 +57,9 @@ object MessageEnvelope {
def apply(channel: String, msg: EventMessage): MessageEnvelope = def apply(channel: String, msg: EventMessage): MessageEnvelope =
MessageEnvelope(channel, Default.GUID0, msg) MessageEnvelope(channel, Default.GUID0, msg)
} }
/**
* A proper event system envelope.
*/
case class MessageEnvelope(channel: String, filter: PlanetSideGUID, msg: EventMessage)
extends MessageTransformationBehavior

2
src/main/scala/net/psforever/services/base/message/SendResponse.scala
View file

@ -7,4 +7,6 @@ final case class SendResponse(pkts: Seq[PlanetSideGamePacket]) extends SelfRespo
object SendResponse { object SendResponse {
def apply(pkt: PlanetSideGamePacket): SendResponse = SendResponse(Seq(pkt)) def apply(pkt: PlanetSideGamePacket): SendResponse = SendResponse(Seq(pkt))
def apply(first: PlanetSideGamePacket, msgs: PlanetSideGamePacket*): SendResponse = SendResponse(first +: msgs)
} }