From cc3e1dde86a6aea061d6068f303d9c6dd18aef32 Mon Sep 17 00:00:00 2001 From: FateJH Date: Tue, 1 May 2018 23:34:13 -0400 Subject: [PATCH] packets RespawnAMSInfoMessage and SquadWaypointEvent, the latter with tests; system of keeping track of deployed AMS vehicles and displaying their data to interested users added through the VehicleService path --- .../psforever/packet/GamePacketOpcode.scala | 4 +- .../packet/game/RespawnAMSInfoMessage.scala | 75 ++++++++++++++ .../packet/game/SquadWaypointEvent.scala | 78 +++++++++++++++ .../scala/game/SquadWaypointEventTest.scala | 99 +++++++++++++++++++ .../src/main/scala/WorldSessionActor.scala | 52 +++++++++- .../services/vehicle/VehicleAction.scala | 2 + .../services/vehicle/VehicleResponse.scala | 3 + .../services/vehicle/VehicleService.scala | 24 ++++- .../vehicle/VehicleServiceMessage.scala | 2 + 9 files changed, 335 insertions(+), 4 deletions(-) create mode 100644 common/src/main/scala/net/psforever/packet/game/RespawnAMSInfoMessage.scala create mode 100644 common/src/main/scala/net/psforever/packet/game/SquadWaypointEvent.scala create mode 100644 common/src/test/scala/game/SquadWaypointEventTest.scala diff --git a/common/src/main/scala/net/psforever/packet/GamePacketOpcode.scala b/common/src/main/scala/net/psforever/packet/GamePacketOpcode.scala index 9d5864769..f1a6ea45a 100644 --- a/common/src/main/scala/net/psforever/packet/GamePacketOpcode.scala +++ b/common/src/main/scala/net/psforever/packet/GamePacketOpcode.scala @@ -475,7 +475,7 @@ object GamePacketOpcode extends Enumeration { case 0x81 => game.DestroyDisplayMessage.decode case 0x82 => noDecoder(TriggerBotAction) case 0x83 => noDecoder(SquadWaypointRequest) - case 0x84 => noDecoder(SquadWaypointEvent) + case 0x84 => game.SquadWaypointEvent.decode case 0x85 => noDecoder(OffshoreVehicleMessage) case 0x86 => game.ObjectDeployedMessage.decode case 0x87 => noDecoder(ObjectDeployedCountMessage) @@ -568,7 +568,7 @@ object GamePacketOpcode extends Enumeration { // OPCODES 0xd0-df case 0xd0 => noDecoder(UnknownMessage208) case 0xd1 => game.DisplayedAwardMessage.decode - case 0xd2 => noDecoder(RespawnAMSInfoMessage) + case 0xd2 => game.RespawnAMSInfoMessage.decode case 0xd3 => noDecoder(ComponentDamageMessage) case 0xd4 => noDecoder(GenericObjectActionAtPositionMessage) case 0xd5 => game.PropertyOverrideMessage.decode diff --git a/common/src/main/scala/net/psforever/packet/game/RespawnAMSInfoMessage.scala b/common/src/main/scala/net/psforever/packet/game/RespawnAMSInfoMessage.scala new file mode 100644 index 000000000..d0361623c --- /dev/null +++ b/common/src/main/scala/net/psforever/packet/game/RespawnAMSInfoMessage.scala @@ -0,0 +1,75 @@ +// Copyright (c) 2017 PSForever +package net.psforever.packet.game + +import net.psforever.packet.{GamePacketOpcode, Marshallable, PacketHelpers, PlanetSideGamePacket} +import net.psforever.types.Vector3 +import scodec.{Attempt, Codec, Err} +import scodec.codecs._ +import shapeless.{::, HNil} + +final case class RespawnInfo(unk1 : List[Vector3], + unk2 : List[Boolean]) + +final case class RespawnAMSInfoMessage(unk1 : PlanetSideGUID, + unk2 : Boolean, + unk3 : Option[RespawnInfo]) + extends PlanetSideGamePacket { + type Packet = RespawnAMSInfoMessage + def opcode = GamePacketOpcode.RespawnAMSInfoMessage + def encode = RespawnAMSInfoMessage.encode(this) +} + +object RespawnAMSInfoMessage extends Marshallable[RespawnAMSInfoMessage] { + def apply(u1 : PlanetSideGUID, u2 : Boolean) : RespawnAMSInfoMessage = { + RespawnAMSInfoMessage(u1, u2, None) + } + + def apply(u1 : PlanetSideGUID, u2 : Boolean, u3 : RespawnInfo) : RespawnAMSInfoMessage = { + RespawnAMSInfoMessage(u1, u2, Some(u3)) + } + + private val info_codec : Codec[RespawnInfo] = ( + uint(6) >>:~ { size => //max 63 + ("unk1" | PacketHelpers.listOfNSized(size, Vector3.codec_pos)) :: + ("unk2" | PacketHelpers.listOfNSized(size, bool)) + }).exmap[RespawnInfo] ({ + case _ :: a :: b :: HNil => + Attempt.Successful(RespawnInfo(a, b)) + }, + { + case RespawnInfo(a, b) => + val alen = a.length + if(alen != b.length) { + Attempt.Failure(Err(s"respawn info lists must match in length - $alen vs ${b.length}")) + } + else if(alen > 63) { + Attempt.Failure(Err(s"respawn info lists too long - $alen > 63")) + } + else { + Attempt.Successful(alen :: a :: b :: HNil) + } + } + ) + + /* + technically, the order of reading should be 16u + 1u + 7u which is byte-aligned + the 7u, however, is divided into a subsequent 1u + 6u reading + if that second 1u is true, the 6u doesn't matter and doesn't need to be read when not necessary + */ + implicit val codec : Codec[RespawnAMSInfoMessage] = ( + ("unk1" | PlanetSideGUID.codec) :: + ("unk2" | bool) :: + (bool >>:~ { test => + conditional(!test, "unk3" | info_codec).hlist + }) + ).xmap[RespawnAMSInfoMessage] ( + { + case u1 :: u2 :: _ :: u3 :: HNil => + RespawnAMSInfoMessage(u1, u2, u3) + }, + { + case RespawnAMSInfoMessage(u1, u2, u3) => + u1 :: u2 :: u3.isDefined :: u3 :: HNil + } + ) +} diff --git a/common/src/main/scala/net/psforever/packet/game/SquadWaypointEvent.scala b/common/src/main/scala/net/psforever/packet/game/SquadWaypointEvent.scala new file mode 100644 index 000000000..3874b625a --- /dev/null +++ b/common/src/main/scala/net/psforever/packet/game/SquadWaypointEvent.scala @@ -0,0 +1,78 @@ +// Copyright (c) 2017 PSForever +package net.psforever.packet.game + +import net.psforever.packet.{GamePacketOpcode, Marshallable, PlanetSideGamePacket} +import net.psforever.types.Vector3 +import scodec.{Attempt, Codec, Err} +import scodec.codecs._ +import shapeless.{::, HNil} + +final case class WaypointEvent(unk1 : Int, + pos : Vector3, + unk2 : Int) + +final case class SquadWaypointEvent(unk1 : Int, + unk2 : Int, + unk3 : Long, + unk4 : Int, + unk5 : Option[Long], + unk6 : Option[WaypointEvent]) + extends PlanetSideGamePacket { + type Packet = SquadWaypointEvent + def opcode = GamePacketOpcode.SquadWaypointEvent + def encode = SquadWaypointEvent.encode(this) +} + +object SquadWaypointEvent extends Marshallable[SquadWaypointEvent] { + def apply(unk1 : Int, unk2 : Int, unk3 : Long, unk4 : Int, unk_a : Long) : SquadWaypointEvent = + SquadWaypointEvent(unk1, unk2, unk3, unk4, Some(unk_a), None) + + def apply(unk1 : Int, unk2 : Int, unk3 : Long, unk4 : Int, unk_a : Int, pos : Vector3, unk_b : Int) : SquadWaypointEvent = + SquadWaypointEvent(unk1, unk2, unk3, unk4, None, Some(WaypointEvent(unk_a, pos, unk_b))) + + def apply(unk1 : Int, unk2 : Int, unk3 : Long, unk4 : Int) : SquadWaypointEvent = + SquadWaypointEvent(unk1, unk2, unk3, unk4, None, None) + + private val waypoint_codec : Codec[WaypointEvent] = ( + ("unk1" | uint16L) :: + ("pos" | Vector3.codec_pos) :: + ("unk2" | uint(3)) + ).as[WaypointEvent] + + implicit val codec : Codec[SquadWaypointEvent] = ( + ("unk1" | uint2) >>:~ { unk1 => + ("unk2" | uint16L) :: + ("unk3" | uint32L) :: + ("unk4" | uint8L) :: + ("unk5" | conditional(unk1 == 1, uint32L)) :: + ("unk6" | conditional(unk1 == 0, waypoint_codec)) + } + ).exmap[SquadWaypointEvent] ( + { + case 0 :: a :: b :: c :: None :: Some(d) :: HNil => + Attempt.Successful(SquadWaypointEvent(0, a, b, c, None, Some(d))) + + case 1 :: a :: b :: c :: Some(d) :: None :: HNil => + Attempt.Successful(SquadWaypointEvent(1, a, b, c, Some(d), None)) + + case a :: b :: c :: d :: None :: None :: HNil => + Attempt.Successful(SquadWaypointEvent(a, b, c, d, None, None)) + + case n :: _ :: _ :: _ :: _ :: _ :: HNil => + Attempt.Failure(Err(s"unexpected format for unk1 - $n")) + }, + { + case SquadWaypointEvent(0, a, b, c, None, Some(d)) => + Attempt.Successful(0 :: a :: b :: c :: None :: Some(d) :: HNil) + + case SquadWaypointEvent(1, a, b, c, Some(d), None) => + Attempt.Successful(1 :: a :: b :: c :: Some(d) :: None :: HNil) + + case SquadWaypointEvent(a, b, c, d, None, None) => + Attempt.Successful(a :: b :: c :: d :: None :: None :: HNil) + + case SquadWaypointEvent(n, _, _, _, _, _) => + Attempt.Failure(Err(s"unexpected format for unk1 - $n")) + } + ) +} diff --git a/common/src/test/scala/game/SquadWaypointEventTest.scala b/common/src/test/scala/game/SquadWaypointEventTest.scala new file mode 100644 index 000000000..3c2b8bb81 --- /dev/null +++ b/common/src/test/scala/game/SquadWaypointEventTest.scala @@ -0,0 +1,99 @@ +// Copyright (c) 2017 PSForever +package game + +import org.specs2.mutable._ +import net.psforever.packet._ +import net.psforever.packet.game.{SquadWaypointEvent, WaypointEvent} +import net.psforever.types.Vector3 +import scodec.bits._ + +class SquadWaypointEventTest extends Specification { + val string_1 = hex"84 82c025d9b6c04000" + val string_2 = hex"84 8280000000000100" + val string_3 = hex"84 00c03f1e5e808042803f3018f316800008" + val string_4 = hex"84 40c03f1e5e80804100000000" //fabricated example + + "decode (1)" in { + PacketCoding.DecodePacket(string_1).require match { + case SquadWaypointEvent(unk1, unk2, unk3, unk4, unk5, unk6) => + unk1 mustEqual 2 + unk2 mustEqual 11 + unk3 mustEqual 31155863L + unk4 mustEqual 0 + unk5 mustEqual None + unk6 mustEqual None + case _ => + ko + } + } + + "decode (2)" in { + PacketCoding.DecodePacket(string_2).require match { + case SquadWaypointEvent(unk1, unk2, unk3, unk4, unk5, unk6) => + unk1 mustEqual 2 + unk2 mustEqual 10 + unk3 mustEqual 0L + unk4 mustEqual 4 + unk5 mustEqual None + unk6 mustEqual None + case _ => + ko + } + } + + "decode (3)" in { + PacketCoding.DecodePacket(string_3).require match { + case SquadWaypointEvent(unk1, unk2, unk3, unk4, unk5, unk6) => + unk1 mustEqual 0 + unk2 mustEqual 3 + unk3 mustEqual 41581052L + unk4 mustEqual 1 + unk5 mustEqual None + unk6 mustEqual Some(WaypointEvent(10, Vector3(3457.9688f, 5514.4688f, 0.0f), 1)) + case _ => + ko + } + } + + "decode (4)" in { + PacketCoding.DecodePacket(string_4).require match { + case SquadWaypointEvent(unk1, unk2, unk3, unk4, unk5, unk6) => + unk1 mustEqual 1 + unk2 mustEqual 3 + unk3 mustEqual 41581052L + unk4 mustEqual 1 + unk5 mustEqual Some(4L) + unk6 mustEqual None + case _ => + ko + } + } + + "encode (1)" in { + val msg = SquadWaypointEvent(2, 11, 31155863L, 0) + val pkt = PacketCoding.EncodePacket(msg).require.toByteVector + + pkt mustEqual string_1 + } + + "encode (2)" in { + val msg = SquadWaypointEvent(2, 10, 0L, 4) + val pkt = PacketCoding.EncodePacket(msg).require.toByteVector + + pkt mustEqual string_2 + } + + "encode (3)" in { + val msg = SquadWaypointEvent(0, 3, 41581052L, 1, 10, Vector3(3457.9688f, 5514.4688f, 0.0f), 1) + val pkt = PacketCoding.EncodePacket(msg).require.toByteVector + + pkt mustEqual string_3 + } + + "encode (4)" in { + val msg = SquadWaypointEvent(1, 3, 41581052L, 1, 4L) + val pkt = PacketCoding.EncodePacket(msg).require.toByteVector + + pkt mustEqual string_4 + } +} diff --git a/pslogin/src/main/scala/WorldSessionActor.scala b/pslogin/src/main/scala/WorldSessionActor.scala index 05075da16..2e3c329f5 100644 --- a/pslogin/src/main/scala/WorldSessionActor.scala +++ b/pslogin/src/main/scala/WorldSessionActor.scala @@ -76,6 +76,8 @@ class WorldSessionActor extends Actor with MDCContextAware { var deadState : DeadState.Value = DeadState.Dead var whenUsedLastKit : Long = 0 + var amsSpawnPoint : Option[SpawnTube] = None + var clientKeepAlive : Cancellable = DefaultCancellable.obj var progressBarUpdate : Cancellable = DefaultCancellable.obj var reviveTimer : Cancellable = DefaultCancellable.obj @@ -546,6 +548,27 @@ class WorldSessionActor extends Actor with MDCContextAware { } } + case VehicleResponse.UpdateAmsSpawnPoint(list) => + //if(player.isBackpack) { + //dismiss old ams spawn point + ClearCurrentAmsSpawnPoint() + //draw new ams spawn point + list + .filter(tube => tube.Faction == player.Faction) + .sortBy(tube => Vector3.DistanceSquared(tube.Position, player.Position)) + .headOption match { + case Some(tube) => + sendResponse( + DeployableObjectsInfoMessage( + DeploymentAction.Build, + DeployableInfo(tube.GUID, DeployableIcon.AegisShieldGenerator, tube.Position, player.GUID) + ) + ) + amsSpawnPoint = Some(tube) + case None => ; + } + //} + case _ => ; } @@ -1251,6 +1274,7 @@ class WorldSessionActor extends Actor with MDCContextAware { log.info(s"Zone.Lattice.SpawnPoint: spawn point on $zone_id in ${building.Id} @ ${spawn_tube.GUID.guid} selected") respawnTimer.cancel reviveTimer.cancel + ClearCurrentAmsSpawnPoint() val sameZone = zone_id == continent.Id val backpack = player.isBackpack val respawnTime : Long = if(sameZone) { 10 } else { 0 } //s @@ -1730,6 +1754,7 @@ class WorldSessionActor extends Actor with MDCContextAware { deadState = DeadState.Release sendResponse(AvatarDeadStateMessage(DeadState.Release, 0, 0, player.Position, player.Faction, true)) continent.Population ! Zone.Population.Release(avatar) + vehicleService ! VehicleServiceMessage(continent.Id, VehicleAction.UpdateAmsSpawnPoint(continent)) player.VehicleSeated match { case None => FriskCorpse(player) @@ -3989,7 +4014,18 @@ class WorldSessionActor extends Actor with MDCContextAware { obj match { case vehicle : Vehicle => ReloadVehicleAccessPermissions(vehicle) //TODO we should not have to do this imho - sendResponse(PlanetsideAttributeMessage(obj.GUID, 81, 1)) + // + if(obj.Definition == GlobalDefinitions.ams) { + obj.DeploymentState match { + case DriveState.Deployed => + vehicleService ! VehicleServiceMessage.AMSDeploymentChange(continent) + sendResponse(PlanetsideAttributeMessage(obj.GUID, 81, 1)) + case DriveState.Undeploying => + vehicleService ! VehicleServiceMessage.AMSDeploymentChange(continent) + sendResponse(PlanetsideAttributeMessage(obj.GUID, 81, 0)) + case _ => ; + } + } case _ => ; } } @@ -4013,6 +4049,20 @@ class WorldSessionActor extends Actor with MDCContextAware { log.error(s"DeployRequest: $obj can not transition to $state - $reason$mobileShift") } + def ClearCurrentAmsSpawnPoint() : Unit = { + amsSpawnPoint match { + case Some(tube) => + sendResponse( + DeployableObjectsInfoMessage( + DeploymentAction.Dismiss, + DeployableInfo(tube.GUID, DeployableIcon.AegisShieldGenerator, tube.Position, player.GUID) + ) + ) + amsSpawnPoint = None + case None => ; + } + } + /** * For a given continental structure, determine the method of generating server-join client configuration packets. * @param continentNumber the zone id diff --git a/pslogin/src/main/scala/services/vehicle/VehicleAction.scala b/pslogin/src/main/scala/services/vehicle/VehicleAction.scala index c876f3407..68c9788e9 100644 --- a/pslogin/src/main/scala/services/vehicle/VehicleAction.scala +++ b/pslogin/src/main/scala/services/vehicle/VehicleAction.scala @@ -25,4 +25,6 @@ object VehicleAction { final case class UnloadVehicle(player_guid : PlanetSideGUID, continent : Zone, vehicle : Vehicle) extends Action final case class UnstowEquipment(player_guid : PlanetSideGUID, item_guid : PlanetSideGUID) extends Action final case class VehicleState(player_guid : PlanetSideGUID, vehicle_guid : PlanetSideGUID, unk1 : Int, pos : Vector3, ang : Vector3, vel : Option[Vector3], unk2 : Option[Int], unk3 : Int, unk4 : Int, wheel_direction : Int, unk5 : Boolean, unk6 : Boolean) extends Action + + final case class UpdateAmsSpawnPoint(zone : Zone) extends Action } diff --git a/pslogin/src/main/scala/services/vehicle/VehicleResponse.scala b/pslogin/src/main/scala/services/vehicle/VehicleResponse.scala index e29437cfb..f3c9f9ebe 100644 --- a/pslogin/src/main/scala/services/vehicle/VehicleResponse.scala +++ b/pslogin/src/main/scala/services/vehicle/VehicleResponse.scala @@ -1,6 +1,7 @@ // Copyright (c) 2017 PSForever package services.vehicle +import net.psforever.objects.serverobject.tube.SpawnTube import net.psforever.objects.{PlanetSideGameObject, Vehicle} import net.psforever.packet.game.PlanetSideGUID import net.psforever.packet.game.objectcreate.ConstructorData @@ -28,4 +29,6 @@ object VehicleResponse { final case class UnloadVehicle(vehicle_guid : PlanetSideGUID) extends Response final case class UnstowEquipment(item_guid : PlanetSideGUID) extends Response final case class VehicleState(vehicle_guid : PlanetSideGUID, unk1 : Int, pos : Vector3, ang : Vector3, vel : Option[Vector3], unk2 : Option[Int], unk3 : Int, unk4 : Int, wheel_direction : Int, unk5 : Boolean, unk6 : Boolean) extends Response + + final case class UpdateAmsSpawnPoint(list : List[SpawnTube]) extends Response } diff --git a/pslogin/src/main/scala/services/vehicle/VehicleService.scala b/pslogin/src/main/scala/services/vehicle/VehicleService.scala index 8fb490cdb..902f0c7a2 100644 --- a/pslogin/src/main/scala/services/vehicle/VehicleService.scala +++ b/pslogin/src/main/scala/services/vehicle/VehicleService.scala @@ -5,6 +5,8 @@ import akka.actor.{Actor, ActorRef, Props} import net.psforever.objects.serverobject.pad.VehicleSpawnPad import net.psforever.objects.zones.Zone import services.vehicle.support.{DeconstructionActor, DelayedDeconstructionActor} +import net.psforever.types.DriveState + import services.{GenericEventBus, Service} class VehicleService extends Actor { @@ -93,6 +95,10 @@ class VehicleService extends Actor { VehicleEvents.publish( VehicleServiceResponse(s"/$forChannel/Vehicle", player_guid, VehicleResponse.VehicleState(vehicle_guid, unk1, pos, ang, vel, unk2, unk3, unk4, wheel_direction, unk5, unk6)) ) + + //unlike other messages, just return to sender, don't publish + case VehicleAction.UpdateAmsSpawnPoint(zone : Zone) => + sender ! VehicleServiceResponse(s"/$forChannel/Vehicle", Service.defaultPlayerGUID, VehicleResponse.UpdateAmsSpawnPoint(AmsSpawnPoints(zone))) case _ => ; } @@ -113,7 +119,7 @@ class VehicleService extends Actor { VehicleEvents.publish( VehicleServiceResponse(s"/$zone_id/Vehicle", Service.defaultPlayerGUID, VehicleResponse.UnloadVehicle(vehicle_guid)) ) - + //from VehicleSpawnControl case VehicleSpawnPad.ConcealPlayer(player_guid, zone_id) => VehicleEvents.publish( @@ -161,7 +167,23 @@ class VehicleService extends Actor { vehicleDelayedDecon ! DelayedDeconstructionActor.UnscheduleDeconstruction(vehicle.GUID) vehicleDecon ! DeconstructionActor.RequestDeleteVehicle(vehicle, zone) + //correspondence from WorldSessionActor + case VehicleServiceMessage.AMSDeploymentChange(zone) => + VehicleEvents.publish( + VehicleServiceResponse(s"/${zone.Id}/Vehicle", Service.defaultPlayerGUID, VehicleResponse.UpdateAmsSpawnPoint(AmsSpawnPoints(zone))) + ) + case msg => log.info(s"Unhandled message $msg from $sender") } + + import net.psforever.objects.serverobject.tube.SpawnTube + def AmsSpawnPoints(zone : Zone) : List[SpawnTube] = { + import net.psforever.objects.vehicles.UtilityType + import net.psforever.objects.GlobalDefinitions + zone.Vehicles + .filter(veh => veh.Definition == GlobalDefinitions.ams && veh.DeploymentState == DriveState.Deployed) + .flatMap(veh => veh.Utilities.values.filter(util => util.UtilType == UtilityType.ams_respawn_tube) ) + .map(util => util().asInstanceOf[SpawnTube]) + } } diff --git a/pslogin/src/main/scala/services/vehicle/VehicleServiceMessage.scala b/pslogin/src/main/scala/services/vehicle/VehicleServiceMessage.scala index 48c03dab3..61ec68542 100644 --- a/pslogin/src/main/scala/services/vehicle/VehicleServiceMessage.scala +++ b/pslogin/src/main/scala/services/vehicle/VehicleServiceMessage.scala @@ -13,4 +13,6 @@ object VehicleServiceMessage { final case class RevokeActorControl(vehicle : Vehicle) final case class RequestDeleteVehicle(vehicle : Vehicle, continent : Zone) final case class UnscheduleDeconstruction(vehicle_guid : PlanetSideGUID) + + final case class AMSDeploymentChange(zone : Zone) }