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

corrected various issues identified in the comments of PR#1247

Browse source
This commit is contained in:
Fate-JH 2024-10-29 12:06:36 -04:00
parent 186f568c64
commit 720bc97838
21 changed files with 541 additions and 435 deletions
Download patch file Download diff file Expand all files Collapse all files

12
src/main/scala/net/psforever/actors/session/AvatarActor.scala
View file

@ -1131,6 +1131,11 @@ class AvatarActor(
var supportExperienceTimer: Cancellable = Default.Cancellable var supportExperienceTimer: Cancellable = Default.Cancellable
var experienceDebt: Long = 0L var experienceDebt: Long = 0L
private def setSession(newSession: Session): Unit = {
session = Some(newSession)
_avatar = Option(newSession.avatar)
}
def avatar: Avatar = _avatar.get def avatar: Avatar = _avatar.get
def avatar_=(avatar: Avatar): Unit = { def avatar_=(avatar: Avatar): Unit = {
@ -1156,8 +1161,7 @@ class AvatarActor(
postLoginBehaviour() postLoginBehaviour()
case SetSession(newSession) => case SetSession(newSession) =>
session = Some(newSession) setSession(newSession)
_avatar = Option(newSession.avatar)
postLoginBehaviour() postLoginBehaviour()
case other => case other =>
@ -1177,7 +1181,7 @@ class AvatarActor(
Behaviors Behaviors
.receiveMessage[Command] { .receiveMessage[Command] {
case SetSession(newSession) => case SetSession(newSession) =>
session = Some(newSession) setSession(newSession)
Behaviors.same Behaviors.same
case SetLookingForSquad(lfs) => case SetLookingForSquad(lfs) =>
@ -1330,7 +1334,7 @@ class AvatarActor(
Behaviors Behaviors
.receiveMessagePartial[Command] { .receiveMessagePartial[Command] {
case SetSession(newSession) => case SetSession(newSession) =>
session = Some(newSession) setSession(newSession)
Behaviors.same Behaviors.same
case ReplaceAvatar(newAvatar) => case ReplaceAvatar(newAvatar) =>

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

@ -3,9 +3,14 @@ package net.psforever.actors.session.csr
import akka.actor.{ActorContext, typed} import akka.actor.{ActorContext, typed}
import net.psforever.actors.session.support.AvatarHandlerFunctions import net.psforever.actors.session.support.AvatarHandlerFunctions
import net.psforever.login.WorldSession.PutLoadoutEquipmentInInventory
import net.psforever.objects.PlanetSideGameObject
import net.psforever.objects.definition.converter.OCM import net.psforever.objects.definition.converter.OCM
import net.psforever.objects.inventory.Container
import net.psforever.objects.serverobject.containable.ContainableBehavior import net.psforever.objects.serverobject.containable.ContainableBehavior
import net.psforever.objects.serverobject.mount.Mountable
import net.psforever.packet.game.{AvatarImplantMessage, CreateShortcutMessage, ImplantAction} import net.psforever.packet.game.{AvatarImplantMessage, CreateShortcutMessage, ImplantAction}
import net.psforever.services.avatar.{AvatarAction, AvatarServiceMessage}
import net.psforever.types.ImplantType import net.psforever.types.ImplantType
// //
@ -382,7 +387,9 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
slot = 0 slot = 0
)) ))
} }
sessionLogic.general.applyPurchaseTimersBeforePackingLoadout(player, player, holsters ++ inventory) (holsters ++ inventory).foreach { case InventoryItem(item, slot) =>
TaskWorkflow.execute(PutLoadoutEquipmentInInventory(player)(item, slot))
}
DropLeftovers(player)(drops) DropLeftovers(player)(drops)
case AvatarResponse.ChangeLoadout(target, armor, exosuit, subtype, slot, _, oldHolsters, _, _, _, _) => case AvatarResponse.ChangeLoadout(target, armor, exosuit, subtype, slot, _, oldHolsters, _, _, _, _) =>
@ -431,6 +438,8 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
sendResponse(ReloadMessage(itemGuid, ammo_clip=1, unk1=0)) sendResponse(ReloadMessage(itemGuid, ammo_clip=1, unk1=0))
case AvatarResponse.Killed(mount) => case AvatarResponse.Killed(mount) =>
val pguid = player.GUID
val avatarId = player.Definition.ObjectId
//pure logic //pure logic
sessionLogic.shooting.shotsWhileDead = 0 sessionLogic.shooting.shotsWhileDead = 0
sessionLogic.zoning.CancelZoningProcess() sessionLogic.zoning.CancelZoningProcess()
@ -456,12 +465,16 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
case obj: Vehicle if obj.Destroyed => case obj: Vehicle if obj.Destroyed =>
sessionLogic.vehicles.ConditionalDriverVehicleControl(obj) sessionLogic.vehicles.ConditionalDriverVehicleControl(obj)
sessionLogic.general.unaccessContainer(obj) sessionLogic.general.unaccessContainer(obj)
player.VehicleSeated = None case obj: PlanetSideGameObject with Mountable with Container if obj.Destroyed =>
sendResponse(OCM.detailed(player)) sessionLogic.general.unaccessContainer(obj)
case _: Vehicle => case _ => ()
player.VehicleSeated = None
sendResponse(OCM.detailed(player))
} }
player.VehicleSeated = None
sendResponse(OCM.detailed(player))
continent.AvatarEvents ! AvatarServiceMessage(
continent.id,
AvatarAction.LoadPlayer(pguid, avatarId, pguid, player.Definition.Packet.ConstructorData(player).get, None)
)
sendResponse(ChatMsg(ChatMessageType.UNK_225, "CSR MODE")) sendResponse(ChatMsg(ChatMessageType.UNK_225, "CSR MODE"))
case AvatarResponse.Release(tplayer) if isNotSameTarget => case AvatarResponse.Release(tplayer) if isNotSameTarget =>

178
src/main/scala/net/psforever/actors/session/csr/CustomerServiceRepresentativeMode.scala
View file

@ -1,16 +1,19 @@
// Copyright (c) 2024 PSForever // Copyright (c) 2024 PSForever
package net.psforever.actors.session.csr package net.psforever.actors.session.csr
import net.psforever.actors.session.SessionActor
import net.psforever.actors.session.support.{ChatFunctions, GalaxyHandlerFunctions, GeneralFunctions, LocalHandlerFunctions, ModeLogic, MountHandlerFunctions, PlayerMode, SessionData, SquadHandlerFunctions, TerminalHandlerFunctions, VehicleFunctions, VehicleHandlerFunctions, WeaponAndProjectileFunctions} import net.psforever.actors.session.support.{ChatFunctions, GalaxyHandlerFunctions, GeneralFunctions, LocalHandlerFunctions, ModeLogic, MountHandlerFunctions, PlayerMode, SessionData, SquadHandlerFunctions, TerminalHandlerFunctions, VehicleFunctions, VehicleHandlerFunctions, WeaponAndProjectileFunctions}
import net.psforever.objects.{Deployables, Session, Vehicle} import net.psforever.objects.{Deployables, PlanetSideGameObject, Player, Session, Vehicle}
import net.psforever.objects.avatar.Certification import net.psforever.objects.avatar.Certification
import net.psforever.packet.PlanetSidePacket import net.psforever.objects.serverobject.ServerObject
import net.psforever.packet.game.{ChatMsg, ObjectCreateDetailedMessage} import net.psforever.objects.serverobject.mount.Mountable
import net.psforever.packet.game.objectcreate.{ObjectCreateMessageParent, RibbonBars} import net.psforever.objects.vital.Vitality
import net.psforever.objects.zones.Zone
import net.psforever.packet.game.{ChatMsg, ObjectCreateDetailedMessage, PlanetsideAttributeMessage}
import net.psforever.packet.game.objectcreate.RibbonBars
import net.psforever.services.avatar.{AvatarAction, AvatarServiceMessage} import net.psforever.services.avatar.{AvatarAction, AvatarServiceMessage}
import net.psforever.services.chat.{CustomerServiceChannel, SpectatorChannel} import net.psforever.services.chat.{CustomerServiceChannel, SpectatorChannel}
import net.psforever.types.{ChatMessageType, MeritCommendation} import net.psforever.services.vehicle.{VehicleAction, VehicleServiceMessage}
import net.psforever.types.{ChatMessageType, MeritCommendation, PlanetSideGUID}
class CustomerServiceRepresentativeMode(data: SessionData) extends ModeLogic { class CustomerServiceRepresentativeMode(data: SessionData) extends ModeLogic {
val avatarResponse: AvatarHandlerLogic = AvatarHandlerLogic(data.avatarResponse) val avatarResponse: AvatarHandlerLogic = AvatarHandlerLogic(data.avatarResponse)
@ -32,8 +35,8 @@ class CustomerServiceRepresentativeMode(data: SessionData) extends ModeLogic {
val player = session.player val player = session.player
val avatar = session.avatar val avatar = session.avatar
val continent = session.zone val continent = session.zone
val sendResponse: PlanetSidePacket=>Unit = data.sendResponse
// //
data.zoning.displayZoningMessageWhenCancelled = false
if (oldCertifications.isEmpty) { if (oldCertifications.isEmpty) {
oldCertifications = avatar.certifications oldCertifications = avatar.certifications
oldRibbons = avatar.decoration.ribbonBars oldRibbons = avatar.decoration.ribbonBars
@ -47,49 +50,27 @@ class CustomerServiceRepresentativeMode(data: SessionData) extends ModeLogic {
)) ))
) )
player.avatar = newAvatar player.avatar = newAvatar
data.context.self ! SessionActor.SetAvatar(newAvatar) data.session = session.copy(avatar = newAvatar, player = player)
Deployables.InitializeDeployableQuantities(newAvatar) Deployables.InitializeDeployableQuantities(newAvatar)
} }
val vehicleAndSeat = data.vehicles.GetMountableAndSeat(None, player, continent) match { requireDismount(continent, player)
case (Some(obj: Vehicle), Some(seatNum)) => data.keepAlivePersistenceFunc = keepAlivePersistanceCSR
Some(ObjectCreateMessageParent(obj.GUID, seatNum))
case _ =>
None
}
// //
val pguid = player.GUID CustomerServiceRepresentativeMode.renderPlayer(data, continent, player)
val definition = player.Definition
val objectClass = definition.ObjectId
val packet = definition.Packet
sendResponse(ObjectCreateDetailedMessage(
0L,
objectClass,
pguid,
vehicleAndSeat,
packet.DetailedConstructorData(player).get
))
data.zoning.spawn.HandleSetCurrentAvatar(player)
continent.AvatarEvents ! AvatarServiceMessage(continent.id, AvatarAction.LoadPlayer(
pguid,
objectClass,
pguid,
packet.ConstructorData(player).get,
vehicleAndSeat
))
if (player.silenced) { if (player.silenced) {
data.chat.commandIncomingSilence(session, ChatMsg(ChatMessageType.CMT_SILENCE, "player 0")) data.chat.commandIncomingSilence(session, ChatMsg(ChatMessageType.CMT_SILENCE, "player 0"))
} }
data.chat.JoinChannel(SpectatorChannel) data.chat.JoinChannel(SpectatorChannel)
data.chat.JoinChannel(CustomerServiceChannel) data.chat.JoinChannel(CustomerServiceChannel)
sendResponse(ChatMsg(ChatMessageType.UNK_225, "CSR MODE ON")) data.sendResponse(ChatMsg(ChatMessageType.UNK_225, "CSR MODE ON"))
} }
override def switchFrom(session: Session): Unit = { override def switchFrom(session: Session): Unit = {
val player = session.player val player = session.player
val avatar = session.avatar val avatar = session.avatar
val continent = session.zone val continent = session.zone
val sendResponse: PlanetSidePacket => Unit = data.sendResponse
// //
data.zoning.displayZoningMessageWhenCancelled = true
val newAvatar = avatar.copy( val newAvatar = avatar.copy(
certifications = oldCertifications, certifications = oldCertifications,
decoration = avatar.decoration.copy(ribbonBars = oldRibbons) decoration = avatar.decoration.copy(ribbonBars = oldRibbons)
@ -97,37 +78,90 @@ class CustomerServiceRepresentativeMode(data: SessionData) extends ModeLogic {
oldCertifications = Set() oldCertifications = Set()
oldRibbons = RibbonBars() oldRibbons = RibbonBars()
player.avatar = newAvatar player.avatar = newAvatar
data.context.self ! SessionActor.SetAvatar(newAvatar) data.session = session.copy(avatar = newAvatar, player = player)
val vehicleAndSeat = data.vehicles.GetMountableAndSeat(None, player, continent) match {
case (Some(obj: Vehicle), Some(seatNum)) =>
Some(ObjectCreateMessageParent(obj.GUID, seatNum))
case _ =>
None
}
Deployables.InitializeDeployableQuantities(newAvatar) Deployables.InitializeDeployableQuantities(newAvatar)
// //
val pguid = player.GUID requireDismount(continent, player)
val definition = player.Definition data.keepAlivePersistenceFunc = data.keepAlivePersistence
val objectClass = definition.ObjectId //
val packet = definition.Packet CustomerServiceRepresentativeMode.renderPlayer(data, continent, player)
sendResponse(ObjectCreateDetailedMessage(
0L,
objectClass,
pguid,
vehicleAndSeat,
packet.DetailedConstructorData(player).get
))
data.zoning.spawn.HandleSetCurrentAvatar(player)
continent.AvatarEvents ! AvatarServiceMessage(continent.id, AvatarAction.LoadPlayer(
pguid,
objectClass,
pguid,
packet.ConstructorData(player).get,
vehicleAndSeat
))
data.chat.LeaveChannel(SpectatorChannel) data.chat.LeaveChannel(SpectatorChannel)
data.chat.LeaveChannel(CustomerServiceChannel) data.chat.LeaveChannel(CustomerServiceChannel)
sendResponse(ChatMsg(ChatMessageType.UNK_225, "CSR MODE OFF")) data.sendResponse(ChatMsg(ChatMessageType.UNK_225, "CSR MODE OFF"))
}
private def requireDismount(zone: Zone, player: Player): Unit = {
data.vehicles.GetMountableAndSeat(None, player, zone) match {
case (Some(obj: Vehicle), Some(seatNum)) if seatNum == 0 =>
data.vehicles.ServerVehicleOverrideStop(obj)
obj.Actor ! ServerObject.AttributeMsg(10, 3) //faction-accessible driver seat
obj.Actor ! Mountable.TryDismount(player, seatNum)
player.VehicleSeated = None
case (Some(obj), Some(seatNum)) =>
obj.Actor ! Mountable.TryDismount(player, seatNum)
player.VehicleSeated = None
case _ =>
player.VehicleSeated = None
}
}
private def keepAlivePersistanceCSR(): Unit = {
data.keepAlivePersistence()
topOffHealthOfPlayer(data.player)
data.continent.GUID(data.player.VehicleSeated)
.collect {
case obj: PlanetSideGameObject with Vitality => topOffHealth(obj)
}
}
private def topOffHealth(obj: PlanetSideGameObject with Vitality): Unit = {
obj match {
case p: Player => topOffHealthOfPlayer(p)
case v: Vehicle => topOffHealthOfVehicle(v)
case o: PlanetSideGameObject with Vitality => topOffHealthOfGeneric(o)
case _ => ()
}
}
private def topOffHealthOfPlayer(player: Player): Unit = {
//driver below half health, full heal
val maxHealthOfPlayer = player.MaxHealth.toLong
if (player.Health < maxHealthOfPlayer * 0.5f) {
player.Health = maxHealthOfPlayer.toInt
player.LogActivity(player.ClearHistory().head)
data.sendResponse(PlanetsideAttributeMessage(player.GUID, 0, maxHealthOfPlayer))
data.continent.AvatarEvents ! AvatarServiceMessage(data.zoning.zoneChannel, AvatarAction.PlanetsideAttribute(player.GUID, 0, maxHealthOfPlayer))
}
}
private def topOffHealthOfVehicle(vehicle: Vehicle): Unit = {
topOffHealthOfGeneric(vehicle)
//vehicle shields below half, full shields
val maxShieldsOfVehicle = vehicle.MaxShields.toLong
val shieldsUi = vehicle.Definition.shieldUiAttribute
if (vehicle.Shields < maxShieldsOfVehicle) {
val guid = vehicle.GUID
vehicle.Shields = maxShieldsOfVehicle.toInt
data.sendResponse(PlanetsideAttributeMessage(guid, shieldsUi, maxShieldsOfVehicle))
data.continent.VehicleEvents ! VehicleServiceMessage(
data.continent.id,
VehicleAction.PlanetsideAttribute(PlanetSideGUID(0), guid, shieldsUi, maxShieldsOfVehicle)
)
}
}
private def topOffHealthOfGeneric(obj: PlanetSideGameObject with Vitality): Unit = {
//below half health, full heal
val guid = obj.GUID
val maxHealthOf = obj.MaxHealth.toLong
if (obj.Health < maxHealthOf) {
obj.Health = maxHealthOf.toInt
data.sendResponse(PlanetsideAttributeMessage(guid, 0, maxHealthOf))
data.continent.VehicleEvents ! VehicleServiceMessage(
data.continent.id,
VehicleAction.PlanetsideAttribute(PlanetSideGUID(0), guid, 0, maxHealthOf)
)
}
} }
} }
@ -135,4 +169,24 @@ case object CustomerServiceRepresentativeMode extends PlayerMode {
def setup(data: SessionData): ModeLogic = { def setup(data: SessionData): ModeLogic = {
new CustomerServiceRepresentativeMode(data) new CustomerServiceRepresentativeMode(data)
} }
private[csr] def renderPlayer(data: SessionData, zone: Zone, player: Player): Unit = {
val pguid = player.GUID
val definition = player.Definition
val objectClass = definition.ObjectId
val packet = definition.Packet
data.sendResponse(ObjectCreateDetailedMessage(
objectClass,
pguid,
packet.DetailedConstructorData(player).get
))
data.zoning.spawn.HandleSetCurrentAvatar(player)
zone.AvatarEvents ! AvatarServiceMessage(zone.id, AvatarAction.LoadPlayer(
pguid,
objectClass,
pguid,
packet.ConstructorData(player).get,
None
))
}
} }

167
src/main/scala/net/psforever/actors/session/csr/GeneralLogic.scala
View file

@ -131,7 +131,7 @@ class GeneralLogic(val ops: GeneralOperations, implicit val context: ActorContex
sessionLogic.zoning.CancelZoningProcess() sessionLogic.zoning.CancelZoningProcess()
} }
player.Cloaked = player.ExoSuit == ExoSuitType.Infiltration && isCloaking player.Cloaked = player.ExoSuit == ExoSuitType.Infiltration && isCloaking
maxCapacitorTick() maxCapacitorTick(jumpThrust)
if (isMovingPlus && sessionLogic.terminals.usingMedicalTerminal.isDefined) { if (isMovingPlus && sessionLogic.terminals.usingMedicalTerminal.isDefined) {
continent.GUID(sessionLogic.terminals.usingMedicalTerminal) match { continent.GUID(sessionLogic.terminals.usingMedicalTerminal) match {
case Some(term: Terminal with ProximityUnit) => case Some(term: Terminal with ProximityUnit) =>
@ -297,60 +297,55 @@ class GeneralLogic(val ops: GeneralOperations, implicit val context: ActorContex
case _ => case _ =>
None None
} }
cancelZoningWhenGeneralHandled( sessionLogic.validObject(pkt.object_guid, decorator = "UseItem") match {
sessionLogic.validObject(pkt.object_guid, decorator = "UseItem") match { case Some(door: Door) =>
case Some(door: Door) => handleUseDoor(door, equipment)
handleUseDoor(door, equipment) case Some(resourceSilo: ResourceSilo) =>
GeneralOperations.UseItem.Unhandled ops.handleUseResourceSilo(resourceSilo, equipment)
case Some(resourceSilo: ResourceSilo) => case Some(panel: IFFLock) =>
ops.handleUseResourceSilo(resourceSilo, equipment) ops.handleUseGeneralEntity(panel, equipment)
case Some(panel: IFFLock) => case Some(obj: Player) =>
ops.handleUseGeneralEntity(panel, equipment) ops.handleUsePlayer(obj, equipment, pkt)
case Some(obj: Player) => case Some(locker: Locker) =>
ops.handleUsePlayer(obj, equipment, pkt) ops.handleUseLocker(locker, equipment, pkt)
GeneralOperations.UseItem.Unhandled case Some(gen: Generator) =>
case Some(locker: Locker) => ops.handleUseGeneralEntity(gen, equipment)
ops.handleUseLocker(locker, equipment, pkt) case Some(mech: ImplantTerminalMech) =>
case Some(gen: Generator) => ops.handleUseGeneralEntity(mech, equipment)
ops.handleUseGeneralEntity(gen, equipment) case Some(captureTerminal: CaptureTerminal) =>
case Some(mech: ImplantTerminalMech) => ops.handleUseCaptureTerminal(captureTerminal, equipment)
ops.handleUseGeneralEntity(mech, equipment) case Some(obj: FacilityTurret) =>
case Some(captureTerminal: CaptureTerminal) => ops.handleUseFacilityTurret(obj, equipment, pkt)
ops.handleUseCaptureTerminal(captureTerminal, equipment) case Some(obj: Vehicle) =>
case Some(obj: FacilityTurret) => ops.handleUseVehicle(obj, equipment, pkt)
ops.handleUseFacilityTurret(obj, equipment, pkt) case Some(terminal: Terminal) =>
case Some(obj: Vehicle) => ops.handleUseTerminal(terminal, equipment, pkt)
ops.handleUseVehicle(obj, equipment, pkt) case Some(obj: SpawnTube) =>
case Some(terminal: Terminal) => ops.handleUseSpawnTube(obj, equipment)
ops.handleUseTerminal(terminal, equipment, pkt) case Some(obj: SensorDeployable) =>
case Some(obj: SpawnTube) => ops.handleUseGeneralEntity(obj, equipment)
ops.handleUseSpawnTube(obj, equipment) case Some(obj: TurretDeployable) =>
case Some(obj: SensorDeployable) => ops.handleUseGeneralEntity(obj, equipment)
ops.handleUseGeneralEntity(obj, equipment) case Some(obj: TrapDeployable) =>
case Some(obj: TurretDeployable) => ops.handleUseGeneralEntity(obj, equipment)
ops.handleUseGeneralEntity(obj, equipment) case Some(obj: ShieldGeneratorDeployable) =>
case Some(obj: TrapDeployable) => ops.handleUseGeneralEntity(obj, equipment)
ops.handleUseGeneralEntity(obj, equipment) case Some(obj: TelepadDeployable) if player.spectator =>
case Some(obj: ShieldGeneratorDeployable) => ops.handleUseTelepadDeployable(obj, equipment, pkt, ops.useRouterTelepadSystemSecretly)
ops.handleUseGeneralEntity(obj, equipment) case Some(obj: Utility.InternalTelepad) if player.spectator =>
case Some(obj: TelepadDeployable) if player.spectator => ops.handleUseInternalTelepad(obj, pkt, ops.useRouterTelepadSystemSecretly)
ops.handleUseTelepadDeployable(obj, equipment, pkt, ops.useRouterTelepadSystemSecretly) case Some(obj: TelepadDeployable) =>
case Some(obj: Utility.InternalTelepad) if player.spectator => ops.handleUseTelepadDeployable(obj, equipment, pkt, ops.useRouterTelepadSystem)
ops.handleUseInternalTelepad(obj, pkt, ops.useRouterTelepadSystemSecretly) case Some(obj: Utility.InternalTelepad) =>
case Some(obj: TelepadDeployable) => ops.handleUseInternalTelepad(obj, pkt, ops.useRouterTelepadSystem)
ops.handleUseTelepadDeployable(obj, equipment, pkt, ops.useRouterTelepadSystem) case Some(obj: CaptureFlag) =>
case Some(obj: Utility.InternalTelepad) => ops.handleUseCaptureFlag(obj)
ops.handleUseInternalTelepad(obj, pkt, ops.useRouterTelepadSystem) case Some(_: WarpGate) =>
case Some(obj: CaptureFlag) => ops.handleUseWarpGate(equipment)
ops.handleUseCaptureFlag(obj) case Some(obj) =>
case Some(_: WarpGate) => ops.handleUseDefaultEntity(obj, equipment)
ops.handleUseWarpGate(equipment) case None => ()
case Some(obj) => }
ops.handleUseDefaultEntity(obj, equipment)
case None =>
GeneralOperations.UseItem.Unhandled
}
)
} }
def handleUnuseItem(pkt: UnuseItemMessage): Unit = { def handleUnuseItem(pkt: UnuseItemMessage): Unit = {
@ -379,7 +374,7 @@ class GeneralLogic(val ops: GeneralOperations, implicit val context: ActorContex
case dtype => dtype case dtype => dtype
} }
sessionLogic.zoning.CancelZoningProcess() sessionLogic.zoning.CancelZoningProcess()
ops.handleDeployObject(continent, ammoType, pos, orient, player.WhichSide, PlanetSideEmpire.NEUTRAL, None) ops.handleDeployObject(continent, ammoType, pos, orient, player.WhichSide, PlanetSideEmpire.NEUTRAL)
case Some(obj) => case Some(obj) =>
log.warn(s"DeployObject: what is $obj, ${player.Name}? It's not a construction tool!") log.warn(s"DeployObject: what is $obj, ${player.Name}? It's not a construction tool!")
case None => case None =>
@ -727,16 +722,7 @@ class GeneralLogic(val ops: GeneralOperations, implicit val context: ActorContex
/* supporting functions */ /* supporting functions */
def handleUseDoor(door: Door, equipment: Option[Equipment]): Unit = { def handleUseDoor(door: Door, equipment: Option[Equipment]): Unit = {
if (player.spectator) { if (!player.spectator) {
//opens just for us
val guid = door.GUID
openDoor.collect {
case oldDoor if guid != oldDoor.GUID =>
sendResponse(GenericObjectStateMsg(oldDoor.GUID, state=17))
}
sendResponse(GenericObjectStateMsg(guid, state=16))
openDoor = Some(door)
} else {
//opens for everyone //opens for everyone
equipment match { equipment match {
case Some(tool: Tool) if tool.Definition == GlobalDefinitions.medicalapplicator => case Some(tool: Tool) if tool.Definition == GlobalDefinitions.medicalapplicator =>
@ -747,39 +733,58 @@ class GeneralLogic(val ops: GeneralOperations, implicit val context: ActorContex
} }
} }
private def maxCapacitorTick(): Unit = { private def maxCapacitorTick(jumpThrust: Boolean): Unit = {
if (player.ExoSuit == ExoSuitType.MAX) { if (player.ExoSuit == ExoSuitType.MAX) {
val activate = (jumpThrust || player.isOverdrived || player.isShielded) && player.Capacitor > 0
player.CapacitorState match { player.CapacitorState match {
case CapacitorStateType.Idle => maxCapacitorTickIdle() case CapacitorStateType.Discharging => maxCapacitorTickDischarging(activate)
case _ => maxCapacitorTickCharging() case CapacitorStateType.Charging => maxCapacitorTickCharging(activate)
case _ => maxCapacitorTickIdle(activate)
} }
} else if (player.CapacitorState != CapacitorStateType.Idle) { } else if (player.CapacitorState != CapacitorStateType.Idle) {
player.CapacitorState = CapacitorStateType.Idle player.CapacitorState = CapacitorStateType.Idle
} }
} }
private def maxCapacitorTickIdle(): Unit = { private def maxCapacitorTickIdle(activate: Boolean): Unit = {
if (player.Capacitor < player.ExoSuitDef.MaxCapacitor) { if (activate) {
player.CapacitorState = CapacitorStateType.Discharging
//maxCapacitorTickDischarging(activate)
} else if (player.Capacitor < player.ExoSuitDef.MaxCapacitor) {
player.CapacitorState = CapacitorStateType.Charging player.CapacitorState = CapacitorStateType.Charging
maxCapacitorTickCharging()
} }
} }
private def maxCapacitorTickCharging(): Unit = { private def maxCapacitorTickDischarging(activate: Boolean): Unit = {
if (player.Capacitor < player.ExoSuitDef.MaxCapacitor) { if (activate) {
val timeDiff = (System.currentTimeMillis() - player.CapacitorLastChargedMillis).toFloat / 1000 val timeDiff = (System.currentTimeMillis() - player.CapacitorLastUsedMillis).toFloat / 1000
val chargeAmount = player.ExoSuitDef.CapacitorRechargePerSecond * timeDiff val drainAmount = player.ExoSuitDef.CapacitorDrainPerSecond.toFloat * timeDiff
player.Capacitor += chargeAmount player.Capacitor -= drainAmount
sendResponse(PlanetsideAttributeMessage(player.GUID, 7, player.Capacitor.toInt)) sendResponse(PlanetsideAttributeMessage(player.GUID, 7, player.Capacitor.toInt))
} else if (player.Capacitor == 0) {
if (player.Faction == PlanetSideEmpire.TR) {
ops.toggleMaxSpecialState(enable = false)
}
player.Capacitor = player.ExoSuitDef.MaxCapacitor.toFloat
sendResponse(PlanetsideAttributeMessage(player.GUID, 7, player.Capacitor.toInt))
player.CapacitorState = CapacitorStateType.Idle
} else if (player.Capacitor < player.ExoSuitDef.MaxCapacitor) {
player.CapacitorState = CapacitorStateType.Charging
} else { } else {
player.CapacitorState = CapacitorStateType.Idle player.CapacitorState = CapacitorStateType.Idle
} }
} }
private def cancelZoningWhenGeneralHandled(results: GeneralOperations.UseItem.Behavior): Unit = { private def maxCapacitorTickCharging(activate: Boolean): Unit = {
results match { val maxCapacitor = player.ExoSuitDef.MaxCapacitor
case GeneralOperations.UseItem.Unhandled => () if (activate) {
case _ => sessionLogic.zoning.CancelZoningProcess() player.CapacitorState = CapacitorStateType.Discharging
//maxCapacitorTickDischarging(activate)
} else if (player.Capacitor < player.ExoSuitDef.MaxCapacitor) {
player.Capacitor = maxCapacitor.toFloat
sendResponse(PlanetsideAttributeMessage(player.GUID, 7, maxCapacitor))
} else {
player.CapacitorState = CapacitorStateType.Idle
} }
} }
} }

8
src/main/scala/net/psforever/actors/session/csr/MountHandlerLogic.scala
View file

@ -67,14 +67,14 @@ class MountHandlerLogic(val ops: SessionMountHandlers, implicit val context: Act
sessionLogic.zoning.CancelZoningProcess() sessionLogic.zoning.CancelZoningProcess()
sessionLogic.terminals.CancelAllProximityUnits() sessionLogic.terminals.CancelAllProximityUnits()
ops.MountingAction(tplayer, obj, seatNumber) ops.MountingAction(tplayer, obj, seatNumber)
sessionLogic.keepAliveFunc = sessionLogic.keepAlivePersistence sessionLogic.keepAliveFunc = sessionLogic.keepAlivePersistenceFunc
case Mountable.CanMount(obj: Vehicle, seatNumber, _) case Mountable.CanMount(obj: Vehicle, seatNumber, _)
if obj.Definition == GlobalDefinitions.orbital_shuttle => if obj.Definition == GlobalDefinitions.orbital_shuttle =>
sessionLogic.zoning.CancelZoningProcess() sessionLogic.zoning.CancelZoningProcess()
sessionLogic.terminals.CancelAllProximityUnits() sessionLogic.terminals.CancelAllProximityUnits()
ops.MountingAction(tplayer, obj, seatNumber) ops.MountingAction(tplayer, obj, seatNumber)
sessionLogic.keepAliveFunc = sessionLogic.keepAlivePersistence sessionLogic.keepAliveFunc = sessionLogic.keepAlivePersistenceFunc
case Mountable.CanMount(obj: Vehicle, seatNumber, _) case Mountable.CanMount(obj: Vehicle, seatNumber, _)
if obj.Definition == GlobalDefinitions.ant => if obj.Definition == GlobalDefinitions.ant =>
@ -141,7 +141,7 @@ class MountHandlerLogic(val ops: SessionMountHandlers, implicit val context: Act
sendResponse(PlanetsideAttributeMessage(obj_guid, attribute_type=113, obj.Capacitor)) sendResponse(PlanetsideAttributeMessage(obj_guid, attribute_type=113, obj.Capacitor))
sessionLogic.general.accessContainer(obj) sessionLogic.general.accessContainer(obj)
ops.updateWeaponAtSeatPosition(obj, seatNumber) ops.updateWeaponAtSeatPosition(obj, seatNumber)
sessionLogic.keepAliveFunc = sessionLogic.keepAlivePersistence sessionLogic.keepAliveFunc = sessionLogic.keepAlivePersistenceFunc
tplayer.Actor ! ResetAllEnvironmentInteractions tplayer.Actor ! ResetAllEnvironmentInteractions
ops.MountingAction(tplayer, obj, seatNumber) ops.MountingAction(tplayer, obj, seatNumber)
@ -153,7 +153,7 @@ class MountHandlerLogic(val ops: SessionMountHandlers, implicit val context: Act
sendResponse(PlanetsideAttributeMessage(obj_guid, obj.Definition.shieldUiAttribute, obj.Shields)) sendResponse(PlanetsideAttributeMessage(obj_guid, obj.Definition.shieldUiAttribute, obj.Shields))
sessionLogic.general.accessContainer(obj) sessionLogic.general.accessContainer(obj)
ops.updateWeaponAtSeatPosition(obj, seatNumber) ops.updateWeaponAtSeatPosition(obj, seatNumber)
sessionLogic.keepAliveFunc = sessionLogic.keepAlivePersistence sessionLogic.keepAliveFunc = sessionLogic.keepAlivePersistenceFunc
tplayer.Actor ! ResetAllEnvironmentInteractions tplayer.Actor ! ResetAllEnvironmentInteractions
ops.MountingAction(tplayer, obj, seatNumber) ops.MountingAction(tplayer, obj, seatNumber)

42
src/main/scala/net/psforever/actors/session/csr/SpectateAsCustomerServiceRepresentativeMode.scala
View file

@ -4,7 +4,9 @@ package net.psforever.actors.session.csr
import net.psforever.actors.session.support.{AvatarHandlerFunctions, ChatFunctions, GalaxyHandlerFunctions, GeneralFunctions, LocalHandlerFunctions, MountHandlerFunctions, SquadHandlerFunctions, TerminalHandlerFunctions, VehicleFunctions, VehicleHandlerFunctions, WeaponAndProjectileFunctions} import net.psforever.actors.session.support.{AvatarHandlerFunctions, ChatFunctions, GalaxyHandlerFunctions, GeneralFunctions, LocalHandlerFunctions, MountHandlerFunctions, SquadHandlerFunctions, TerminalHandlerFunctions, VehicleFunctions, VehicleHandlerFunctions, WeaponAndProjectileFunctions}
import net.psforever.actors.zone.ZoneActor import net.psforever.actors.zone.ZoneActor
import net.psforever.objects.serverobject.ServerObject import net.psforever.objects.serverobject.ServerObject
import net.psforever.objects.{Session, Vehicle} import net.psforever.objects.serverobject.mount.Mountable
import net.psforever.objects.{Player, Session, Vehicle}
import net.psforever.objects.zones.Zone
import net.psforever.packet.PlanetSidePacket import net.psforever.packet.PlanetSidePacket
import net.psforever.services.avatar.{AvatarAction, AvatarServiceMessage} import net.psforever.services.avatar.{AvatarAction, AvatarServiceMessage}
import net.psforever.services.chat.SpectatorChannel import net.psforever.services.chat.SpectatorChannel
@ -31,24 +33,16 @@ class SpectatorCSRModeLogic(data: SessionData) extends ModeLogic {
val player = session.player val player = session.player
val continent = session.zone val continent = session.zone
val pguid = player.GUID val pguid = player.GUID
val sendResponse: PlanetSidePacket=>Unit = data.sendResponse val sendResponse: PlanetSidePacket => Unit = data.sendResponse
// //
data.vehicles.GetMountableAndSeat(None, player, continent) match {
case (Some(obj: Vehicle), Some(seatNum)) if seatNum == 0 =>
data.vehicles.ServerVehicleOverrideStop(obj)
obj.Actor ! ServerObject.AttributeMsg(10, 3) //faction-accessible driver seat
obj.Seat(seatNum).foreach(_.unmount(player))
player.VehicleSeated = None
case (Some(obj), Some(seatNum)) =>
obj.Seat(seatNum).foreach(_.unmount(player))
player.VehicleSeated = None
case _ => ()
}
data.squadService ! SquadServiceMessage( data.squadService ! SquadServiceMessage(
player, player,
continent, continent,
SquadAction.Membership(SquadRequestType.Leave, player.CharId, Some(player.CharId), player.Name, None) SquadAction.Membership(SquadRequestType.Leave, player.CharId, Some(player.CharId), player.Name, None)
) )
if (requireDismount(data, continent, player)) {
CustomerServiceRepresentativeMode.renderPlayer(data, continent, player)
}
// //
player.spectator = true player.spectator = true
//player.bops = true //player.bops = true
@ -56,6 +50,7 @@ class SpectatorCSRModeLogic(data: SessionData) extends ModeLogic {
data.chat.JoinChannel(SpectatorChannel) data.chat.JoinChannel(SpectatorChannel)
continent.actor ! ZoneActor.RemoveFromBlockMap(player) continent.actor ! ZoneActor.RemoveFromBlockMap(player)
continent.AvatarEvents ! AvatarServiceMessage(continent.id, AvatarAction.ObjectDelete(pguid, pguid)) continent.AvatarEvents ! AvatarServiceMessage(continent.id, AvatarAction.ObjectDelete(pguid, pguid))
sendResponse(ChatMsg(ChatMessageType.CMT_TOGGLESPECTATORMODE, "on"))
sendResponse(ChatMsg(ChatMessageType.UNK_225, "CSR SPECTATOR MODE ON")) sendResponse(ChatMsg(ChatMessageType.UNK_225, "CSR SPECTATOR MODE ON"))
} }
@ -64,7 +59,7 @@ class SpectatorCSRModeLogic(data: SessionData) extends ModeLogic {
val pguid = player.GUID val pguid = player.GUID
val continent = data.continent val continent = data.continent
val avatarId = player.Definition.ObjectId val avatarId = player.Definition.ObjectId
//val sendResponse: PlanetSidePacket => Unit = data.sendResponse val sendResponse: PlanetSidePacket => Unit = data.sendResponse
// //
player.spectator = false player.spectator = false
player.bops = false player.bops = false
@ -75,6 +70,25 @@ class SpectatorCSRModeLogic(data: SessionData) extends ModeLogic {
continent.id, continent.id,
AvatarAction.LoadPlayer(pguid, avatarId, pguid, player.Definition.Packet.ConstructorData(player).get, None) AvatarAction.LoadPlayer(pguid, avatarId, pguid, player.Definition.Packet.ConstructorData(player).get, None)
) )
sendResponse(ChatMsg(ChatMessageType.CMT_TOGGLESPECTATORMODE, "off"))
}
private def requireDismount(data: SessionData, zone: Zone, player: Player): Boolean = {
data.vehicles.GetMountableAndSeat(None, player, zone) match {
case (Some(obj: Vehicle), Some(seatNum)) if seatNum == 0 =>
data.vehicles.ServerVehicleOverrideStop(obj)
obj.Actor ! ServerObject.AttributeMsg(10, 3) //faction-accessible driver seat
obj.Actor ! Mountable.TryDismount(player, seatNum)
player.VehicleSeated = None
true
case (Some(obj), Some(seatNum)) =>
obj.Actor ! Mountable.TryDismount(player, seatNum)
player.VehicleSeated = None
true
case _ =>
player.VehicleSeated = None
false
}
} }
} }

12
src/main/scala/net/psforever/actors/session/csr/TerminalHandlerLogic.scala
View file

@ -9,7 +9,6 @@ import net.psforever.objects.{Player, Vehicle}
import net.psforever.objects.guid.TaskWorkflow import net.psforever.objects.guid.TaskWorkflow
import net.psforever.objects.serverobject.terminals.{OrderTerminalDefinition, Terminal} import net.psforever.objects.serverobject.terminals.{OrderTerminalDefinition, Terminal}
import net.psforever.packet.game.{FavoritesRequest, ItemTransactionMessage, ItemTransactionResultMessage, ProximityTerminalUseMessage} import net.psforever.packet.game.{FavoritesRequest, ItemTransactionMessage, ItemTransactionResultMessage, ProximityTerminalUseMessage}
import net.psforever.types.TransactionType
object TerminalHandlerLogic { object TerminalHandlerLogic {
def apply(ops: SessionTerminalHandlers): TerminalHandlerLogic = { def apply(ops: SessionTerminalHandlers): TerminalHandlerLogic = {
@ -62,13 +61,7 @@ class TerminalHandlerLogic(val ops: SessionTerminalHandlers, implicit val contex
*/ */
def handle(tplayer: Player, msg: ItemTransactionMessage, order: Terminal.Exchange): Unit = { def handle(tplayer: Player, msg: ItemTransactionMessage, order: Terminal.Exchange): Unit = {
order match { order match {
case Terminal.BuyEquipment(item)
if tplayer.avatar.purchaseCooldown(item.Definition).nonEmpty =>
sendResponse(ItemTransactionResultMessage(msg.terminal_guid, TransactionType.Buy, success = false))
ops.lastTerminalOrderFulfillment = true
case Terminal.BuyEquipment(item) => case Terminal.BuyEquipment(item) =>
avatarActor ! AvatarActor.UpdatePurchaseTime(item.Definition)
TaskWorkflow.execute(BuyNewEquipmentPutInInventory( TaskWorkflow.execute(BuyNewEquipmentPutInInventory(
continent.GUID(tplayer.VehicleSeated) match { continent.GUID(tplayer.VehicleSeated) match {
case Some(v: Vehicle) => v case Some(v: Vehicle) => v
@ -97,11 +90,6 @@ class TerminalHandlerLogic(val ops: SessionTerminalHandlers, implicit val contex
avatarActor ! AvatarActor.SellImplant(msg.terminal_guid, implant) avatarActor ! AvatarActor.SellImplant(msg.terminal_guid, implant)
ops.lastTerminalOrderFulfillment = true ops.lastTerminalOrderFulfillment = true
case Terminal.BuyVehicle(vehicle, _, _)
if tplayer.avatar.purchaseCooldown(vehicle.Definition).nonEmpty || player.spectator =>
sendResponse(ItemTransactionResultMessage(msg.terminal_guid, TransactionType.Buy, success = false))
ops.lastTerminalOrderFulfillment = true
case Terminal.BuyVehicle(vehicle, weapons, trunk) => case Terminal.BuyVehicle(vehicle, weapons, trunk) =>
ops.buyVehicle(msg.terminal_guid, msg.transaction_type, vehicle, weapons, trunk) ops.buyVehicle(msg.terminal_guid, msg.transaction_type, vehicle, weapons, trunk)
ops.lastTerminalOrderFulfillment = true ops.lastTerminalOrderFulfillment = true

57
src/main/scala/net/psforever/actors/session/csr/VehicleLogic.scala
View file

@ -5,10 +5,11 @@ import akka.actor.{ActorContext, typed}
import net.psforever.actors.session.AvatarActor import net.psforever.actors.session.AvatarActor
import net.psforever.actors.session.support.{SessionData, VehicleFunctions, VehicleOperations} import net.psforever.actors.session.support.{SessionData, VehicleFunctions, VehicleOperations}
import net.psforever.objects.serverobject.PlanetSideServerObject import net.psforever.objects.serverobject.PlanetSideServerObject
import net.psforever.objects.{Vehicle, Vehicles} import net.psforever.objects.{PlanetSideGameObject, Player, Vehicle, Vehicles}
import net.psforever.objects.serverobject.deploy.Deployment import net.psforever.objects.serverobject.deploy.Deployment
import net.psforever.objects.serverobject.mount.Mountable import net.psforever.objects.serverobject.mount.Mountable
import net.psforever.objects.vehicles.control.BfrFlight import net.psforever.objects.vehicles.control.BfrFlight
import net.psforever.objects.vital.Vitality
import net.psforever.objects.zones.Zone import net.psforever.objects.zones.Zone
import net.psforever.packet.game.{ChildObjectStateMessage, DeployRequestMessage, FrameVehicleStateMessage, PlanetsideAttributeMessage, VehicleStateMessage, VehicleSubStateMessage} import net.psforever.packet.game.{ChildObjectStateMessage, DeployRequestMessage, FrameVehicleStateMessage, PlanetsideAttributeMessage, VehicleStateMessage, VehicleSubStateMessage}
import net.psforever.services.avatar.{AvatarAction, AvatarServiceMessage} import net.psforever.services.avatar.{AvatarAction, AvatarServiceMessage}
@ -47,6 +48,7 @@ class VehicleLogic(val ops: VehicleOperations, implicit val context: ActorContex
//we're driving the vehicle //we're driving the vehicle
sessionLogic.persist() sessionLogic.persist()
sessionLogic.turnCounterFunc(player.GUID) sessionLogic.turnCounterFunc(player.GUID)
topOffHealthOfPlayer()
topOffHealth(obj) topOffHealth(obj)
sessionLogic.general.fallHeightTracker(pos.z) sessionLogic.general.fallHeightTracker(pos.z)
if (obj.MountedIn.isEmpty) { if (obj.MountedIn.isEmpty) {
@ -131,6 +133,7 @@ class VehicleLogic(val ops: VehicleOperations, implicit val context: ActorContex
//we're driving the vehicle //we're driving the vehicle
sessionLogic.persist() sessionLogic.persist()
sessionLogic.turnCounterFunc(player.GUID) sessionLogic.turnCounterFunc(player.GUID)
topOffHealthOfPlayer()
topOffHealth(obj) topOffHealth(obj)
val (position, angle, velocity, notMountedState) = continent.GUID(obj.MountedIn) match { val (position, angle, velocity, notMountedState) = continent.GUID(obj.MountedIn) match {
case Some(v: Vehicle) => case Some(v: Vehicle) =>
@ -216,11 +219,16 @@ class VehicleLogic(val ops: VehicleOperations, implicit val context: ActorContex
case Some(mount: Mountable) => (o, mount.PassengerInSeat(player)) case Some(mount: Mountable) => (o, mount.PassengerInSeat(player))
case _ => (None, None) case _ => (None, None)
}) match { }) match {
case (None, None) | (_, None) | (Some(_: Vehicle), Some(0)) => () case (None, None) | (_, None) | (Some(_: Vehicle), Some(0)) =>
case _ => ()
case (Some(obj: PlanetSideGameObject with Vitality), _) =>
sessionLogic.persist() sessionLogic.persist()
sessionLogic.turnCounterFunc(player.GUID) sessionLogic.turnCounterFunc(player.GUID)
topOffHealthOfPlayer() topOffHealthOfPlayer()
topOffHealth(obj)
case _ =>
sessionLogic.persist()
sessionLogic.turnCounterFunc(player.GUID)
} }
//the majority of the following check retrieves information to determine if we are in control of the child //the majority of the following check retrieves information to determine if we are in control of the child
tools.find { _.GUID == object_guid } match { tools.find { _.GUID == object_guid } match {
@ -333,6 +341,15 @@ class VehicleLogic(val ops: VehicleOperations, implicit val context: ActorContex
} }
} }
private def topOffHealth(obj: PlanetSideGameObject with Vitality): Unit = {
obj match {
case _: Player => topOffHealthOfPlayer()
case v: Vehicle => topOffHealthOfVehicle(v)
case o: PlanetSideGameObject with Vitality => topOffHealthOfGeneric(o)
case _ => ()
}
}
private def topOffHealthOfPlayer(): Unit = { private def topOffHealthOfPlayer(): Unit = {
//driver below half health, full heal //driver below half health, full heal
val maxHealthOfPlayer = player.MaxHealth.toLong val maxHealthOfPlayer = player.MaxHealth.toLong
@ -340,32 +357,38 @@ class VehicleLogic(val ops: VehicleOperations, implicit val context: ActorContex
player.Health = maxHealthOfPlayer.toInt player.Health = maxHealthOfPlayer.toInt
player.LogActivity(player.ClearHistory().head) player.LogActivity(player.ClearHistory().head)
sendResponse(PlanetsideAttributeMessage(player.GUID, 0, maxHealthOfPlayer)) sendResponse(PlanetsideAttributeMessage(player.GUID, 0, maxHealthOfPlayer))
continent.AvatarEvents ! AvatarServiceMessage(continent.id, AvatarAction.PlanetsideAttribute(player.GUID, 0, maxHealthOfPlayer)) continent.AvatarEvents ! AvatarServiceMessage(sessionLogic.zoning.zoneChannel, AvatarAction.PlanetsideAttribute(player.GUID, 0, maxHealthOfPlayer))
} }
} }
private def topOffHealth(vehicle: Vehicle): Unit = { private def topOffHealthOfVehicle(vehicle: Vehicle): Unit = {
topOffHealthOfPlayer() topOffHealthOfPlayer()
//vehicle below half health, full heal topOffHealthOfGeneric(vehicle)
val guid = vehicle.GUID
val maxHealthOfVehicle = vehicle.MaxHealth.toLong
if (vehicle.Health < maxHealthOfVehicle) {
vehicle.Health = maxHealthOfVehicle.toInt
sendResponse(PlanetsideAttributeMessage(guid, 0, maxHealthOfVehicle))
continent.VehicleEvents ! VehicleServiceMessage(
continent.id,
VehicleAction.PlanetsideAttribute(PlanetSideGUID(0), guid, 0, maxHealthOfVehicle)
)
}
//vehicle shields below half, full shields //vehicle shields below half, full shields
val maxShieldsOfVehicle = vehicle.MaxShields.toLong val maxShieldsOfVehicle = vehicle.MaxShields.toLong
val shieldsUi = vehicle.Definition.shieldUiAttribute val shieldsUi = vehicle.Definition.shieldUiAttribute
if (vehicle.Shields < maxShieldsOfVehicle) { if (vehicle.Shields < maxShieldsOfVehicle) {
val guid = vehicle.GUID
vehicle.Shields = maxShieldsOfVehicle.toInt vehicle.Shields = maxShieldsOfVehicle.toInt
sendResponse(PlanetsideAttributeMessage(guid, shieldsUi, maxShieldsOfVehicle)) sendResponse(PlanetsideAttributeMessage(guid, shieldsUi, maxShieldsOfVehicle))
continent.VehicleEvents ! VehicleServiceMessage( continent.VehicleEvents ! VehicleServiceMessage(
continent.id, continent.id,
VehicleAction.PlanetsideAttribute(PlanetSideGUID(0), guid, shieldsUi, maxHealthOfVehicle) VehicleAction.PlanetsideAttribute(PlanetSideGUID(0), guid, shieldsUi, maxShieldsOfVehicle)
)
}
}
private def topOffHealthOfGeneric(obj: PlanetSideGameObject with Vitality): Unit = {
topOffHealthOfPlayer()
//vehicle below half health, full heal
val guid = obj.GUID
val maxHealthOf = obj.MaxHealth.toLong
if (obj.Health < maxHealthOf) {
obj.Health = maxHealthOf.toInt
sendResponse(PlanetsideAttributeMessage(guid, 0, maxHealthOf))
continent.VehicleEvents ! VehicleServiceMessage(
continent.id,
VehicleAction.PlanetsideAttribute(PlanetSideGUID(0), guid, 0, maxHealthOf)
) )
} }
} }

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

@ -312,10 +312,14 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
//redraw //redraw
if (maxhand) { if (maxhand) {
sendResponse(PlanetsideAttributeMessage(target, attribute_type=7, player.Capacitor.toLong)) sendResponse(PlanetsideAttributeMessage(target, attribute_type=7, player.Capacitor.toLong))
TaskWorkflow.execute(HoldNewEquipmentUp(player)( val maxArmDefinition = GlobalDefinitions.MAXArms(subtype, player.Faction)
Tool(GlobalDefinitions.MAXArms(subtype, player.Faction)), TaskWorkflow.execute(HoldNewEquipmentUp(player)(Tool(maxArmDefinition), slot = 0))
0 player.avatar.purchaseCooldown(maxArmDefinition)
)) .collect(a => a)
.getOrElse {
avatarActor ! AvatarActor.UpdatePurchaseTime(maxArmDefinition)
None
}
} }
//draw free hand //draw free hand
player.FreeHand.Equipment.foreach { obj => player.FreeHand.Equipment.foreach { obj =>
@ -343,6 +347,8 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
) )
} }
DropLeftovers(player)(drop) DropLeftovers(player)(drop)
//deactivate non-passive implants
avatarActor ! AvatarActor.DeactivateActiveImplants
case AvatarResponse.ChangeExosuit(target, armor, exosuit, subtype, slot, _, oldHolsters, holsters, _, _, drop, delete) => case AvatarResponse.ChangeExosuit(target, armor, exosuit, subtype, slot, _, oldHolsters, holsters, _, _, drop, delete) =>
sendResponse(ArmorChangedMessage(target, exosuit, subtype)) sendResponse(ArmorChangedMessage(target, exosuit, subtype))
@ -395,14 +401,19 @@ class AvatarHandlerLogic(val ops: SessionAvatarHandlers, implicit val context: A
drops.foreach(item => sendResponse(ObjectDeleteMessage(item.obj.GUID, unk1=0))) drops.foreach(item => sendResponse(ObjectDeleteMessage(item.obj.GUID, unk1=0)))
//redraw //redraw
if (maxhand) { if (maxhand) {
val maxArmWeapon = GlobalDefinitions.MAXArms(subtype, player.Faction)
sendResponse(PlanetsideAttributeMessage(target, attribute_type=7, player.Capacitor.toLong)) sendResponse(PlanetsideAttributeMessage(target, attribute_type=7, player.Capacitor.toLong))
TaskWorkflow.execute(HoldNewEquipmentUp(player)( TaskWorkflow.execute(HoldNewEquipmentUp(player)(Tool(maxArmWeapon), slot = 0))
Tool(GlobalDefinitions.MAXArms(subtype, player.Faction)), val cooldown = player.avatar.purchaseCooldown(maxArmWeapon)
slot = 0 if (!oldHolsters.exists { case (e, _) => e.Definition == maxArmWeapon } &&
)) player.avatar.purchaseCooldown(maxArmWeapon).isEmpty) {
avatarActor ! AvatarActor.UpdatePurchaseTime(maxArmWeapon) //switching for first time causes cooldown
}
} }
sessionLogic.general.applyPurchaseTimersBeforePackingLoadout(player, player, holsters ++ inventory) sessionLogic.general.applyPurchaseTimersBeforePackingLoadout(player, player, holsters ++ inventory)
DropLeftovers(player)(drops) DropLeftovers(player)(drops)
//deactivate non-passive implants
avatarActor ! AvatarActor.DeactivateActiveImplants
case AvatarResponse.ChangeLoadout(target, armor, exosuit, subtype, slot, _, oldHolsters, _, _, _, _) => case AvatarResponse.ChangeLoadout(target, armor, exosuit, subtype, slot, _, oldHolsters, _, _, _, _) =>
//redraw handled by callbacks //redraw handled by callbacks

107
src/main/scala/net/psforever/actors/session/normal/GeneralLogic.scala
View file

@ -333,56 +333,51 @@ class GeneralLogic(val ops: GeneralOperations, implicit val context: ActorContex
case _ => case _ =>
None None
} }
cancelZoningWhenGeneralHandled( sessionLogic.validObject(pkt.object_guid, decorator = "UseItem") match {
sessionLogic.validObject(pkt.object_guid, decorator = "UseItem") match { case Some(door: Door) =>
case Some(door: Door) => ops.handleUseDoor(door, equipment)
ops.handleUseDoor(door, equipment) case Some(resourceSilo: ResourceSilo) =>
GeneralOperations.UseItem.Unhandled ops.handleUseResourceSilo(resourceSilo, equipment)
case Some(resourceSilo: ResourceSilo) => case Some(panel: IFFLock) =>
ops.handleUseResourceSilo(resourceSilo, equipment) ops.handleUseGeneralEntity(panel, equipment)
case Some(panel: IFFLock) => case Some(obj: Player) =>
ops.handleUseGeneralEntity(panel, equipment) ops.handleUsePlayer(obj, equipment, pkt)
case Some(obj: Player) => case Some(locker: Locker) =>
ops.handleUsePlayer(obj, equipment, pkt) ops.handleUseLocker(locker, equipment, pkt)
GeneralOperations.UseItem.Unhandled case Some(gen: Generator) =>
case Some(locker: Locker) => ops.handleUseGeneralEntity(gen, equipment)
ops.handleUseLocker(locker, equipment, pkt) case Some(mech: ImplantTerminalMech) =>
case Some(gen: Generator) => ops.handleUseGeneralEntity(mech, equipment)
ops.handleUseGeneralEntity(gen, equipment) case Some(captureTerminal: CaptureTerminal) =>
case Some(mech: ImplantTerminalMech) => ops.handleUseCaptureTerminal(captureTerminal, equipment)
ops.handleUseGeneralEntity(mech, equipment) case Some(obj: FacilityTurret) =>
case Some(captureTerminal: CaptureTerminal) => ops.handleUseFacilityTurret(obj, equipment, pkt)
ops.handleUseCaptureTerminal(captureTerminal, equipment) case Some(obj: Vehicle) =>
case Some(obj: FacilityTurret) => ops.handleUseVehicle(obj, equipment, pkt)
ops.handleUseFacilityTurret(obj, equipment, pkt) case Some(terminal: Terminal) =>
case Some(obj: Vehicle) => ops.handleUseTerminal(terminal, equipment, pkt)
ops.handleUseVehicle(obj, equipment, pkt) case Some(obj: SpawnTube) =>
case Some(terminal: Terminal) => ops.handleUseSpawnTube(obj, equipment)
ops.handleUseTerminal(terminal, equipment, pkt) case Some(obj: SensorDeployable) =>
case Some(obj: SpawnTube) => ops.handleUseGeneralEntity(obj, equipment)
ops.handleUseSpawnTube(obj, equipment) case Some(obj: TurretDeployable) =>
case Some(obj: SensorDeployable) => ops.handleUseGeneralEntity(obj, equipment)
ops.handleUseGeneralEntity(obj, equipment) case Some(obj: TrapDeployable) =>
case Some(obj: TurretDeployable) => ops.handleUseGeneralEntity(obj, equipment)
ops.handleUseGeneralEntity(obj, equipment) case Some(obj: ShieldGeneratorDeployable) =>
case Some(obj: TrapDeployable) => ops.handleUseGeneralEntity(obj, equipment)
ops.handleUseGeneralEntity(obj, equipment) case Some(obj: TelepadDeployable) =>
case Some(obj: ShieldGeneratorDeployable) => ops.handleUseTelepadDeployable(obj, equipment, pkt, ops.useRouterTelepadSystem)
ops.handleUseGeneralEntity(obj, equipment) case Some(obj: Utility.InternalTelepad) =>
case Some(obj: TelepadDeployable) => ops.handleUseInternalTelepad(obj, pkt, ops.useRouterTelepadSystem)
ops.handleUseTelepadDeployable(obj, equipment, pkt, ops.useRouterTelepadSystem) case Some(obj: CaptureFlag) =>
case Some(obj: Utility.InternalTelepad) => ops.handleUseCaptureFlag(obj)
ops.handleUseInternalTelepad(obj, pkt, ops.useRouterTelepadSystem) case Some(_: WarpGate) =>
case Some(obj: CaptureFlag) => ops.handleUseWarpGate(equipment)
ops.handleUseCaptureFlag(obj) case Some(obj) =>
case Some(_: WarpGate) => ops.handleUseDefaultEntity(obj, equipment)
ops.handleUseWarpGate(equipment) case None => ()
case Some(obj) => }
ops.handleUseDefaultEntity(obj, equipment)
case None =>
GeneralOperations.UseItem.Unhandled
}
)
} }
def handleUnuseItem(pkt: UnuseItemMessage): Unit = { def handleUnuseItem(pkt: UnuseItemMessage): Unit = {
@ -411,7 +406,7 @@ class GeneralLogic(val ops: GeneralOperations, implicit val context: ActorContex
} }
log.info(s"${player.Name} is constructing a $ammoType deployable") log.info(s"${player.Name} is constructing a $ammoType deployable")
sessionLogic.zoning.CancelZoningProcessWithDescriptiveReason("cancel_use") sessionLogic.zoning.CancelZoningProcessWithDescriptiveReason("cancel_use")
ops.handleDeployObject(continent, ammoType, pos, orient, player.WhichSide, player.Faction, Some((player, obj))) ops.handleDeployObject(continent, ammoType, pos, orient, player.WhichSide, player.Faction, player, obj)
case Some(obj) => case Some(obj) =>
log.warn(s"DeployObject: what is $obj, ${player.Name}? It's not a construction tool!") log.warn(s"DeployObject: what is $obj, ${player.Name}? It's not a construction tool!")
case None => case None =>
@ -976,14 +971,4 @@ class GeneralLogic(val ops: GeneralOperations, implicit val context: ActorContex
) )
) )
} }
private def cancelZoningWhenGeneralHandled(results: GeneralOperations.UseItem.Behavior): Unit = {
results match {
case GeneralOperations.UseItem.Handled =>
sessionLogic.zoning.CancelZoningProcessWithDescriptiveReason("cancel_use")
case GeneralOperations.UseItem.HandledPassive =>
sessionLogic.zoning.CancelZoningProcessWithDescriptiveReason("cancel")
case _ => ()
}
}
} }

8
src/main/scala/net/psforever/actors/session/normal/MountHandlerLogic.scala
View file

@ -63,7 +63,7 @@ class MountHandlerLogic(val ops: SessionMountHandlers, implicit val context: Act
sessionLogic.zoning.CancelZoningProcessWithDescriptiveReason("cancel_use") sessionLogic.zoning.CancelZoningProcessWithDescriptiveReason("cancel_use")
sessionLogic.terminals.CancelAllProximityUnits() sessionLogic.terminals.CancelAllProximityUnits()
ops.MountingAction(tplayer, obj, seatNumber) ops.MountingAction(tplayer, obj, seatNumber)
sessionLogic.keepAliveFunc = sessionLogic.keepAlivePersistence sessionLogic.keepAliveFunc = sessionLogic.keepAlivePersistenceFunc
case Mountable.CanMount(obj: Vehicle, seatNumber, _) case Mountable.CanMount(obj: Vehicle, seatNumber, _)
if obj.Definition == GlobalDefinitions.orbital_shuttle => if obj.Definition == GlobalDefinitions.orbital_shuttle =>
@ -71,7 +71,7 @@ class MountHandlerLogic(val ops: SessionMountHandlers, implicit val context: Act
sessionLogic.zoning.CancelZoningProcessWithDescriptiveReason("cancel_mount") sessionLogic.zoning.CancelZoningProcessWithDescriptiveReason("cancel_mount")
sessionLogic.terminals.CancelAllProximityUnits() sessionLogic.terminals.CancelAllProximityUnits()
ops.MountingAction(tplayer, obj, seatNumber) ops.MountingAction(tplayer, obj, seatNumber)
sessionLogic.keepAliveFunc = sessionLogic.keepAlivePersistence sessionLogic.keepAliveFunc = sessionLogic.keepAlivePersistenceFunc
case Mountable.CanMount(obj: Vehicle, seatNumber, _) case Mountable.CanMount(obj: Vehicle, seatNumber, _)
if obj.Definition == GlobalDefinitions.ant => if obj.Definition == GlobalDefinitions.ant =>
@ -148,7 +148,7 @@ class MountHandlerLogic(val ops: SessionMountHandlers, implicit val context: Act
sendResponse(PlanetsideAttributeMessage(obj_guid, attribute_type=113, obj.Capacitor)) sendResponse(PlanetsideAttributeMessage(obj_guid, attribute_type=113, obj.Capacitor))
sessionLogic.general.accessContainer(obj) sessionLogic.general.accessContainer(obj)
ops.updateWeaponAtSeatPosition(obj, seatNumber) ops.updateWeaponAtSeatPosition(obj, seatNumber)
sessionLogic.keepAliveFunc = sessionLogic.keepAlivePersistence sessionLogic.keepAliveFunc = sessionLogic.keepAlivePersistenceFunc
tplayer.Actor ! ResetAllEnvironmentInteractions tplayer.Actor ! ResetAllEnvironmentInteractions
ops.MountingAction(tplayer, obj, seatNumber) ops.MountingAction(tplayer, obj, seatNumber)
@ -166,7 +166,7 @@ class MountHandlerLogic(val ops: SessionMountHandlers, implicit val context: Act
sendResponse(PlanetsideAttributeMessage(obj_guid, obj.Definition.shieldUiAttribute, obj.Shields)) sendResponse(PlanetsideAttributeMessage(obj_guid, obj.Definition.shieldUiAttribute, obj.Shields))
sessionLogic.general.accessContainer(obj) sessionLogic.general.accessContainer(obj)
ops.updateWeaponAtSeatPosition(obj, seatNumber) ops.updateWeaponAtSeatPosition(obj, seatNumber)
sessionLogic.keepAliveFunc = sessionLogic.keepAlivePersistence sessionLogic.keepAliveFunc = sessionLogic.keepAlivePersistenceFunc
tplayer.Actor ! ResetAllEnvironmentInteractions tplayer.Actor ! ResetAllEnvironmentInteractions
ops.MountingAction(tplayer, obj, seatNumber) ops.MountingAction(tplayer, obj, seatNumber)

13
src/main/scala/net/psforever/actors/session/normal/TerminalHandlerLogic.scala
View file

@ -5,14 +5,11 @@ import akka.actor.{ActorContext, typed}
import net.psforever.actors.session.AvatarActor import net.psforever.actors.session.AvatarActor
import net.psforever.actors.session.support.{SessionData, SessionTerminalHandlers, TerminalHandlerFunctions} import net.psforever.actors.session.support.{SessionData, SessionTerminalHandlers, TerminalHandlerFunctions}
import net.psforever.login.WorldSession.{BuyNewEquipmentPutInInventory, SellEquipmentFromInventory} import net.psforever.login.WorldSession.{BuyNewEquipmentPutInInventory, SellEquipmentFromInventory}
import net.psforever.objects.{GlobalDefinitions, Player, Vehicle} import net.psforever.objects.{Player, Vehicle}
import net.psforever.objects.guid.TaskWorkflow import net.psforever.objects.guid.TaskWorkflow
import net.psforever.objects.serverobject.pad.VehicleSpawnPad
import net.psforever.objects.serverobject.terminals.Terminal import net.psforever.objects.serverobject.terminals.Terminal
import net.psforever.objects.sourcing.AmenitySource import net.psforever.packet.game.{FavoritesRequest, ItemTransactionMessage, ItemTransactionResultMessage, ProximityTerminalUseMessage}
import net.psforever.objects.vital.TerminalUsedActivity import net.psforever.types.TransactionType
import net.psforever.packet.game.{FavoritesRequest, ItemTransactionMessage, ItemTransactionResultMessage, ProximityTerminalUseMessage, UnuseItemMessage}
import net.psforever.types.{TransactionType, Vector3}
object TerminalHandlerLogic { object TerminalHandlerLogic {
def apply(ops: SessionTerminalHandlers): TerminalHandlerLogic = { def apply(ops: SessionTerminalHandlers): TerminalHandlerLogic = {
@ -89,6 +86,10 @@ class TerminalHandlerLogic(val ops: SessionTerminalHandlers, implicit val contex
case Terminal.BuyVehicle(vehicle, weapons, trunk) => case Terminal.BuyVehicle(vehicle, weapons, trunk) =>
ops.buyVehicle(msg.terminal_guid, msg.transaction_type, vehicle, weapons, trunk) ops.buyVehicle(msg.terminal_guid, msg.transaction_type, vehicle, weapons, trunk)
.collect {
case _: Vehicle =>
avatarActor ! AvatarActor.UpdatePurchaseTime(vehicle.Definition)
}
ops.lastTerminalOrderFulfillment = true ops.lastTerminalOrderFulfillment = true
case Terminal.NoDeal() if msg != null => case Terminal.NoDeal() if msg != null =>

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

@ -5,10 +5,11 @@ import akka.actor.{ActorContext, typed}
import net.psforever.actors.session.AvatarActor import net.psforever.actors.session.AvatarActor
import net.psforever.actors.session.support.{SessionData, VehicleFunctions, VehicleOperations} import net.psforever.actors.session.support.{SessionData, VehicleFunctions, VehicleOperations}
import net.psforever.objects.serverobject.PlanetSideServerObject import net.psforever.objects.serverobject.PlanetSideServerObject
import net.psforever.objects.{Vehicle, Vehicles} import net.psforever.objects.{PlanetSideGameObject, Vehicle, Vehicles}
import net.psforever.objects.serverobject.deploy.Deployment import net.psforever.objects.serverobject.deploy.Deployment
import net.psforever.objects.serverobject.mount.Mountable import net.psforever.objects.serverobject.mount.Mountable
import net.psforever.objects.vehicles.control.BfrFlight import net.psforever.objects.vehicles.control.BfrFlight
import net.psforever.objects.vital.Vitality
import net.psforever.objects.zones.Zone import net.psforever.objects.zones.Zone
import net.psforever.packet.game.{ChatMsg, ChildObjectStateMessage, DeployRequestMessage, FrameVehicleStateMessage, VehicleStateMessage, VehicleSubStateMessage} import net.psforever.packet.game.{ChatMsg, ChildObjectStateMessage, DeployRequestMessage, FrameVehicleStateMessage, VehicleStateMessage, VehicleSubStateMessage}
import net.psforever.services.vehicle.{VehicleAction, VehicleServiceMessage} import net.psforever.services.vehicle.{VehicleAction, VehicleServiceMessage}
@ -214,7 +215,8 @@ class VehicleLogic(val ops: VehicleOperations, implicit val context: ActorContex
case Some(mount: Mountable) => (o, mount.PassengerInSeat(player)) case Some(mount: Mountable) => (o, mount.PassengerInSeat(player))
case _ => (None, None) case _ => (None, None)
}) match { }) match {
case (None, None) | (_, None) | (Some(_: Vehicle), Some(0)) => () case (None, None) | (_, None) | (Some(_: Vehicle), Some(0)) =>
()
case _ => case _ =>
sessionLogic.persist() sessionLogic.persist()
sessionLogic.turnCounterFunc(player.GUID) sessionLogic.turnCounterFunc(player.GUID)

240
src/main/scala/net/psforever/actors/session/support/GeneralOperations.scala
View file

@ -1058,30 +1058,53 @@ class GeneralOperations(
orientation: Vector3, orientation: Vector3,
side: Sidedness, side: Sidedness,
faction: PlanetSideEmpire.Value, faction: PlanetSideEmpire.Value,
optionalOwnerBuiltWith: Option[(Player, ConstructionItem)] owner: Player,
builtWith: ConstructionItem
): Unit = { ): Unit = {
val deployableEntity: Deployable = Deployables.Make(deployableType)() val (deployableEntity, tasking) = commonHandleDeployObjectSetup(zone, deployableType, position, orientation, side, faction)
deployableEntity.Position = position deployableEntity.AssignOwnership(owner)
deployableEntity.Orientation = orientation
deployableEntity.WhichSide = side
deployableEntity.Faction = faction
val tasking: TaskBundle = deployableEntity match {
case turret: TurretDeployable =>
GUIDTask.registerDeployableTurret(zone.GUID, turret)
case _ =>
GUIDTask.registerObject(zone.GUID, deployableEntity)
}
val zoneBuildCommand = optionalOwnerBuiltWith
.collect { case (owner, tool) =>
deployableEntity.AssignOwnership(owner)
Zone.Deployable.BuildByOwner(deployableEntity, owner, tool)
}
.getOrElse(Zone.Deployable.Build(deployableEntity))
//execute //execute
TaskWorkflow.execute(CallBackForTask(tasking, zone.Deployables, zoneBuildCommand, context.self)) TaskWorkflow.execute(CallBackForTask(
tasking,
zone.Deployables,
Zone.Deployable.BuildByOwner(deployableEntity, owner, builtWith),
context.self
))
} }
def handleUseDoor(door: Door, equipment: Option[Equipment]): GeneralOperations.UseItem.Behavior = { def handleDeployObject(
zone: Zone,
deployableType: DeployedItem.Value,
position: Vector3,
orientation: Vector3,
side: Sidedness,
faction: PlanetSideEmpire.Value
): Unit = {
val (deployableEntity, tasking) = commonHandleDeployObjectSetup(zone, deployableType, position, orientation, side, faction)
//execute
TaskWorkflow.execute(CallBackForTask(
tasking,
zone.Deployables,
Zone.Deployable.Build(deployableEntity),
context.self
)).onComplete {
_ =>
Players.buildCooldownReset(zone, player.Name, deployableEntity.GUID)
deployableEntity.Actor ! Deployable.Deconstruct(Some(20.minutes))
if (deployableType == DeployedItem.boomer) {
val trigger = new BoomerTrigger
trigger.Companion = deployableEntity.GUID
deployableEntity.asInstanceOf[BoomerDeployable].Trigger = trigger
TaskWorkflow.execute(CallBackForTask(
GUIDTask.registerEquipment(zone.GUID, trigger),
zone.Ground,
Zone.Ground.DropItem(trigger, position + Vector3.z(value = 0.5f), Vector3.z(orientation.z))
))
}
}
}
def handleUseDoor(door: Door, equipment: Option[Equipment]): Unit = {
equipment match { equipment match {
case Some(tool: Tool) if tool.Definition == GlobalDefinitions.medicalapplicator => case Some(tool: Tool) if tool.Definition == GlobalDefinitions.medicalapplicator =>
val distance: Float = math.max( val distance: Float = math.max(
@ -1092,88 +1115,72 @@ class GeneralOperations(
case _ => case _ =>
door.Actor ! CommonMessages.Use(player) door.Actor ! CommonMessages.Use(player)
} }
GeneralOperations.UseItem.Handled
} }
def handleUseResourceSilo(resourceSilo: ResourceSilo, equipment: Option[Equipment]): GeneralOperations.UseItem.Behavior = { def handleUseResourceSilo(resourceSilo: ResourceSilo, equipment: Option[Equipment]): Unit = {
sessionLogic.zoning.CancelZoningProcessWithDescriptiveReason("cancel_use")
val vehicleOpt = continent.GUID(player.avatar.vehicle) val vehicleOpt = continent.GUID(player.avatar.vehicle)
(vehicleOpt, equipment) match { (vehicleOpt, equipment) match {
case (Some(vehicle: Vehicle), Some(item)) case (Some(vehicle: Vehicle), Some(item))
if GlobalDefinitions.isBattleFrameVehicle(vehicle.Definition) && if GlobalDefinitions.isBattleFrameVehicle(vehicle.Definition) &&
GlobalDefinitions.isBattleFrameNTUSiphon(item.Definition) => GlobalDefinitions.isBattleFrameNTUSiphon(item.Definition) =>
resourceSilo.Actor ! CommonMessages.Use(player, Some(vehicle)) resourceSilo.Actor ! CommonMessages.Use(player, Some(vehicle))
GeneralOperations.UseItem.Handled
case (Some(vehicle: Vehicle), _) case (Some(vehicle: Vehicle), _)
if vehicle.Definition == GlobalDefinitions.ant && if vehicle.Definition == GlobalDefinitions.ant &&
vehicle.DeploymentState == DriveState.Deployed && vehicle.DeploymentState == DriveState.Deployed &&
Vector3.DistanceSquared(resourceSilo.Position.xy, vehicle.Position.xy) < math.pow(resourceSilo.Definition.UseRadius, 2) => Vector3.DistanceSquared(resourceSilo.Position.xy, vehicle.Position.xy) < math.pow(resourceSilo.Definition.UseRadius, 2) =>
resourceSilo.Actor ! CommonMessages.Use(player, Some(vehicle)) resourceSilo.Actor ! CommonMessages.Use(player, Some(vehicle))
GeneralOperations.UseItem.Handled case _ => ()
case _ =>
GeneralOperations.UseItem.Unhandled
} }
} }
def handleUsePlayer(obj: Player, equipment: Option[Equipment], msg: UseItemMessage): GeneralOperations.UseItem.Behavior = { def handleUsePlayer(obj: Player, equipment: Option[Equipment], msg: UseItemMessage): Unit = {
sessionLogic.zoning.CancelZoningProcessWithDescriptiveReason("cancel_use")
if (obj.isBackpack) { if (obj.isBackpack) {
if (equipment.isEmpty) { if (equipment.isEmpty) {
log.info(s"${player.Name} is looting the corpse of ${obj.Name}") log.info(s"${player.Name} is looting the corpse of ${obj.Name}")
sendResponse(msg) sendResponse(msg)
accessContainer(obj) accessContainer(obj)
GeneralOperations.UseItem.Handled
} else {
GeneralOperations.UseItem.Unhandled
} }
} else if (!msg.unk3 && player.isAlive) { //potential kit use } else if (!msg.unk3 && player.isAlive) { //potential kit use
(continent.GUID(msg.item_used_guid), kitToBeUsed) match { (continent.GUID(msg.item_used_guid), kitToBeUsed) match {
case (Some(kit: Kit), None) => case (Some(kit: Kit), None) =>
kitToBeUsed = Some(msg.item_used_guid) kitToBeUsed = Some(msg.item_used_guid)
player.Actor ! CommonMessages.Use(player, Some(kit)) player.Actor ! CommonMessages.Use(player, Some(kit))
GeneralOperations.UseItem.Handled
case (Some(_: Kit), Some(_)) | (None, Some(_)) => case (Some(_: Kit), Some(_)) | (None, Some(_)) =>
//a kit is already queued to be used; ignore this request //a kit is already queued to be used; ignore this request
sendResponse(ChatMsg(ChatMessageType.UNK_225, wideContents=false, "", "Please wait ...", None)) sendResponse(ChatMsg(ChatMessageType.UNK_225, wideContents=false, "", "Please wait ...", None))
GeneralOperations.UseItem.Unhandled
case (Some(item), _) => case (Some(item), _) =>
log.error(s"UseItem: ${player.Name} looking for Kit to use, but found $item instead") log.error(s"UseItem: ${player.Name} looking for Kit to use, but found $item instead")
GeneralOperations.UseItem.Unhandled
case (None, None) => case (None, None) =>
log.warn(s"UseItem: anticipated a Kit ${msg.item_used_guid} for ${player.Name}, but can't find it") log.warn(s"UseItem: anticipated a Kit ${msg.item_used_guid} for ${player.Name}, but can't find it") }
GeneralOperations.UseItem.Unhandled
}
} else if (msg.object_id == ObjectClass.avatar && msg.unk3) { } else if (msg.object_id == ObjectClass.avatar && msg.unk3) {
equipment match { equipment match {
case Some(tool: Tool) if tool.Definition == GlobalDefinitions.bank => case Some(tool: Tool) if tool.Definition == GlobalDefinitions.bank =>
obj.Actor ! CommonMessages.Use(player, equipment) obj.Actor ! CommonMessages.Use(player, equipment)
GeneralOperations.UseItem.Handled
case Some(tool: Tool) if tool.Definition == GlobalDefinitions.medicalapplicator => case Some(tool: Tool) if tool.Definition == GlobalDefinitions.medicalapplicator =>
obj.Actor ! CommonMessages.Use(player, equipment) obj.Actor ! CommonMessages.Use(player, equipment)
GeneralOperations.UseItem.Handled case _ => ()
case _ =>
GeneralOperations.UseItem.Unhandled
} }
} else {
GeneralOperations.UseItem.Unhandled
} }
} }
def handleUseLocker(locker: Locker, equipment: Option[Equipment], msg: UseItemMessage): GeneralOperations.UseItem.Behavior = { def handleUseLocker(locker: Locker, equipment: Option[Equipment], msg: UseItemMessage): Unit = {
equipment match { equipment match {
case Some(item) => case Some(item) =>
sendUseGeneralEntityMessage(locker, item) sendUseGeneralEntityMessage(locker, item)
GeneralOperations.UseItem.Unhandled
case None if locker.Faction == player.Faction || locker.HackedBy.nonEmpty => case None if locker.Faction == player.Faction || locker.HackedBy.nonEmpty =>
log.info(s"${player.Name} is accessing a locker") log.info(s"${player.Name} is accessing a locker")
sessionLogic.zoning.CancelZoningProcessWithDescriptiveReason("cancel_use")
val playerLocker = player.avatar.locker val playerLocker = player.avatar.locker
sendResponse(msg.copy(object_guid = playerLocker.GUID, object_id = 456)) sendResponse(msg.copy(object_guid = playerLocker.GUID, object_id = 456))
accessContainer(playerLocker) accessContainer(playerLocker)
GeneralOperations.UseItem.Handled case _ => ()
case _ =>
GeneralOperations.UseItem.Unhandled
} }
} }
def handleUseCaptureTerminal(captureTerminal: CaptureTerminal, equipment: Option[Equipment]): GeneralOperations.UseItem.Behavior = { def handleUseCaptureTerminal(captureTerminal: CaptureTerminal, equipment: Option[Equipment]): Unit = {
equipment match { equipment match {
case Some(item) => case Some(item) =>
sendUseGeneralEntityMessage(captureTerminal, item) sendUseGeneralEntityMessage(captureTerminal, item)
@ -1182,33 +1189,25 @@ class GeneralOperations(
case Some(llu: CaptureFlag) => case Some(llu: CaptureFlag) =>
if (llu.Target.GUID == captureTerminal.Owner.GUID) { if (llu.Target.GUID == captureTerminal.Owner.GUID) {
continent.LocalEvents ! LocalServiceMessage(continent.id, LocalAction.LluCaptured(llu)) continent.LocalEvents ! LocalServiceMessage(continent.id, LocalAction.LluCaptured(llu))
GeneralOperations.UseItem.Handled
} else { } else {
log.info( log.info(
s"LLU target is not this base. Target GUID: ${llu.Target.GUID} This base: ${captureTerminal.Owner.GUID}" s"LLU target is not this base. Target GUID: ${llu.Target.GUID} This base: ${captureTerminal.Owner.GUID}"
) )
} }
GeneralOperations.UseItem.Unhandled case _ => log.warn("Item in specialItemSlotGuid is not registered with continent or is not a LLU")
case _ =>
log.warn("Item in specialItemSlotGuid is not registered with continent or is not a LLU")
GeneralOperations.UseItem.Unhandled
} }
case _ => case _ => ()
GeneralOperations.UseItem.Unhandled
} }
} }
def handleUseFacilityTurret(obj: FacilityTurret, equipment: Option[Equipment], msg: UseItemMessage): GeneralOperations.UseItem.Behavior = { def handleUseFacilityTurret(obj: FacilityTurret, equipment: Option[Equipment], msg: UseItemMessage): Unit = {
equipment equipment.foreach { item =>
.collect { item => sendUseGeneralEntityMessage(obj, item)
sendUseGeneralEntityMessage(obj, item) obj.Actor ! CommonMessages.Use(player, Some((item, msg.unk2.toInt))) //try upgrade path
obj.Actor ! CommonMessages.Use(player, Some((item, msg.unk2.toInt))) //try upgrade path }
GeneralOperations.UseItem.Handled
}
.getOrElse(GeneralOperations.UseItem.Unhandled)
} }
def handleUseVehicle(obj: Vehicle, equipment: Option[Equipment], msg: UseItemMessage): GeneralOperations.UseItem.Behavior = { def handleUseVehicle(obj: Vehicle, equipment: Option[Equipment], msg: UseItemMessage): Unit = {
equipment match { equipment match {
case Some(item) => case Some(item) =>
sendUseGeneralEntityMessage(obj, item) sendUseGeneralEntityMessage(obj, item)
@ -1220,33 +1219,29 @@ class GeneralOperations(
.contains(player.GUID)) .contains(player.GUID))
) { ) {
log.info(s"${player.Name} is looking in the ${obj.Definition.Name}'s trunk") log.info(s"${player.Name} is looking in the ${obj.Definition.Name}'s trunk")
sessionLogic.zoning.CancelZoningProcessWithDescriptiveReason("cancel_use")
obj.AccessingTrunk = player.GUID obj.AccessingTrunk = player.GUID
accessContainer(obj) accessContainer(obj)
sendResponse(msg) sendResponse(msg)
GeneralOperations.UseItem.Handled
} else {
GeneralOperations.UseItem.Unhandled
} }
case _ => case _ => ()
GeneralOperations.UseItem.Unhandled
} }
} }
def handleUseTerminal(terminal: Terminal, equipment: Option[Equipment], msg: UseItemMessage): GeneralOperations.UseItem.Behavior = { def handleUseTerminal(terminal: Terminal, equipment: Option[Equipment], msg: UseItemMessage): Unit = {
equipment match { equipment match {
case Some(item) => case Some(item) =>
sendUseGeneralEntityMessage(terminal, item) sendUseGeneralEntityMessage(terminal, item)
GeneralOperations.UseItem.Handled
case None case None
if terminal.Owner == Building.NoBuilding || terminal.Faction == player.Faction || if terminal.Owner == Building.NoBuilding || terminal.Faction == player.Faction ||
terminal.HackedBy.nonEmpty || terminal.Faction == PlanetSideEmpire.NEUTRAL => terminal.HackedBy.nonEmpty || terminal.Faction == PlanetSideEmpire.NEUTRAL =>
val tdef = terminal.Definition val tdef = terminal.Definition
if (tdef.isInstanceOf[MatrixTerminalDefinition]) { if (tdef.isInstanceOf[MatrixTerminalDefinition]) {
//TODO matrix spawn point; for now, just blindly bind to show work (and hope nothing breaks) //TODO matrix spawn point; for now, just blindly bind to show work (and hope nothing breaks)
sessionLogic.zoning.CancelZoningProcessWithDescriptiveReason("cancel_use")
sendResponse( sendResponse(
BindPlayerMessage(BindStatus.Bind, "", display_icon=true, logging=true, SpawnGroup.Sanctuary, 0, 0, terminal.Position) BindPlayerMessage(BindStatus.Bind, "", display_icon=true, logging=true, SpawnGroup.Sanctuary, 0, 0, terminal.Position)
) )
GeneralOperations.UseItem.Handled
} else if ( } else if (
tdef == GlobalDefinitions.multivehicle_rearm_terminal || tdef == GlobalDefinitions.bfr_rearm_terminal || tdef == GlobalDefinitions.multivehicle_rearm_terminal || tdef == GlobalDefinitions.bfr_rearm_terminal ||
tdef == GlobalDefinitions.air_rearm_terminal || tdef == GlobalDefinitions.ground_rearm_terminal tdef == GlobalDefinitions.air_rearm_terminal || tdef == GlobalDefinitions.ground_rearm_terminal
@ -1258,49 +1253,45 @@ class GeneralOperations(
) )
sendResponse(msg) sendResponse(msg)
sendResponse(msg.copy(object_guid = vehicle.GUID, object_id = vehicle.Definition.ObjectId)) sendResponse(msg.copy(object_guid = vehicle.GUID, object_id = vehicle.Definition.ObjectId))
GeneralOperations.UseItem.Handled
case None => case None =>
log.error(s"UseItem: Expecting a seated vehicle, ${player.Name} found none") log.error(s"UseItem: Expecting a seated vehicle, ${player.Name} found none")
GeneralOperations.UseItem.Unhandled
} }
} else if (tdef == GlobalDefinitions.teleportpad_terminal) { } else if (tdef == GlobalDefinitions.teleportpad_terminal) {
//explicit request //explicit request
log.info(s"${player.Name} is purchasing a router telepad") log.info(s"${player.Name} is purchasing a router telepad")
sessionLogic.zoning.CancelZoningProcessWithDescriptiveReason("cancel_use")
terminal.Actor ! Terminal.Request( terminal.Actor ! Terminal.Request(
player, player,
ItemTransactionMessage(msg.object_guid, TransactionType.Buy, 0, "router_telepad", 0, PlanetSideGUID(0)) ItemTransactionMessage(msg.object_guid, TransactionType.Buy, 0, "router_telepad", 0, PlanetSideGUID(0))
) )
GeneralOperations.UseItem.Handled
} else if (tdef == GlobalDefinitions.targeting_laser_dispenser) { } else if (tdef == GlobalDefinitions.targeting_laser_dispenser) {
//explicit request //explicit request
log.info(s"${player.Name} is purchasing a targeting laser") log.info(s"${player.Name} is purchasing a targeting laser")
sessionLogic.zoning.CancelZoningProcessWithDescriptiveReason("cancel_use")
terminal.Actor ! Terminal.Request( terminal.Actor ! Terminal.Request(
player, player,
ItemTransactionMessage(msg.object_guid, TransactionType.Buy, 0, "flail_targeting_laser", 0, PlanetSideGUID(0)) ItemTransactionMessage(msg.object_guid, TransactionType.Buy, 0, "flail_targeting_laser", 0, PlanetSideGUID(0))
) )
GeneralOperations.UseItem.Handled
} else { } else {
log.info(s"${player.Name} is accessing a ${terminal.Definition.Name}") log.info(s"${player.Name} is accessing a ${terminal.Definition.Name}")
sessionLogic.zoning.CancelZoningProcessWithDescriptiveReason("cancel_use")
sendResponse(msg) sendResponse(msg)
GeneralOperations.UseItem.Handled
} }
case _ => case _ => ()
GeneralOperations.UseItem.Unhandled
} }
} }
def handleUseSpawnTube(obj: SpawnTube, equipment: Option[Equipment]): GeneralOperations.UseItem.Behavior = { def handleUseSpawnTube(obj: SpawnTube, equipment: Option[Equipment]): Unit = {
equipment match { equipment match {
case Some(item) => case Some(item) =>
sendUseGeneralEntityMessage(obj, item) sendUseGeneralEntityMessage(obj, item)
case None if player.Faction == obj.Faction => case None if player.Faction == obj.Faction =>
//deconstruction //deconstruction
sessionLogic.zoning.CancelZoningProcessWithDescriptiveReason("cancel_use")
sessionLogic.actionsToCancel() sessionLogic.actionsToCancel()
sessionLogic.terminals.CancelAllProximityUnits() sessionLogic.terminals.CancelAllProximityUnits()
sessionLogic.zoning.spawn.startDeconstructing(obj) sessionLogic.zoning.spawn.startDeconstructing(obj)
GeneralOperations.UseItem.Handled case _ => ()
case _ =>
GeneralOperations.UseItem.Unhandled
} }
} }
@ -1309,7 +1300,7 @@ class GeneralOperations(
equipment: Option[Equipment], equipment: Option[Equipment],
msg: UseItemMessage, msg: UseItemMessage,
useTelepadFunc: (Vehicle, InternalTelepad, TelepadDeployable, PlanetSideGameObject with TelepadLike, PlanetSideGameObject with TelepadLike) => Unit useTelepadFunc: (Vehicle, InternalTelepad, TelepadDeployable, PlanetSideGameObject with TelepadLike, PlanetSideGameObject with TelepadLike) => Unit
): GeneralOperations.UseItem.Behavior = { ): Unit = {
if (equipment.isEmpty) { if (equipment.isEmpty) {
(continent.GUID(obj.Router) match { (continent.GUID(obj.Router) match {
case Some(vehicle: Vehicle) => Some((vehicle, vehicle.Utility(UtilityType.internal_router_telepad_deployable))) case Some(vehicle: Vehicle) => Some((vehicle, vehicle.Utility(UtilityType.internal_router_telepad_deployable)))
@ -1317,25 +1308,20 @@ class GeneralOperations(
case None => None case None => None
}) match { }) match {
case Some((vehicle: Vehicle, Some(util: Utility.InternalTelepad))) => case Some((vehicle: Vehicle, Some(util: Utility.InternalTelepad))) =>
sessionLogic.zoning.CancelZoningProcessWithDescriptiveReason("cancel")
player.WhichSide = vehicle.WhichSide player.WhichSide = vehicle.WhichSide
useTelepadFunc(vehicle, util, obj, obj, util) useTelepadFunc(vehicle, util, obj, obj, util)
GeneralOperations.UseItem.HandledPassive
case Some((vehicle: Vehicle, None)) => case Some((vehicle: Vehicle, None)) =>
log.error( log.error(
s"telepad@${msg.object_guid.guid} is not linked to a router - ${vehicle.Definition.Name}" s"telepad@${msg.object_guid.guid} is not linked to a router - ${vehicle.Definition.Name}"
) )
GeneralOperations.UseItem.Unhandled
case Some((o, _)) => case Some((o, _)) =>
log.error( log.error(
s"telepad@${msg.object_guid.guid} is linked to wrong kind of object - ${o.Definition.Name}, ${obj.Router}" s"telepad@${msg.object_guid.guid} is linked to wrong kind of object - ${o.Definition.Name}, ${obj.Router}"
) )
obj.Actor ! Deployable.Deconstruct() obj.Actor ! Deployable.Deconstruct()
GeneralOperations.UseItem.Unhandled case _ => ()
case _ =>
GeneralOperations.UseItem.Unhandled
} }
} else {
GeneralOperations.UseItem.Unhandled
} }
} }
@ -1343,19 +1329,16 @@ class GeneralOperations(
obj: InternalTelepad, obj: InternalTelepad,
msg: UseItemMessage, msg: UseItemMessage,
useTelepadFunc: (Vehicle, InternalTelepad, TelepadDeployable, PlanetSideGameObject with TelepadLike, PlanetSideGameObject with TelepadLike) => Unit useTelepadFunc: (Vehicle, InternalTelepad, TelepadDeployable, PlanetSideGameObject with TelepadLike, PlanetSideGameObject with TelepadLike) => Unit
): GeneralOperations.UseItem.Behavior = { ): Unit = {
continent.GUID(obj.Telepad) match { continent.GUID(obj.Telepad) match {
case Some(pad: TelepadDeployable) => case Some(pad: TelepadDeployable) =>
player.WhichSide = pad.WhichSide player.WhichSide = pad.WhichSide
useTelepadFunc(obj.Owner.asInstanceOf[Vehicle], obj, pad, obj, pad) useTelepadFunc(obj.Owner.asInstanceOf[Vehicle], obj, pad, obj, pad)
GeneralOperations.UseItem.HandledPassive
case Some(o) => case Some(o) =>
log.error( log.error(
s"internal telepad@${msg.object_guid.guid} is not linked to a remote telepad - ${o.Definition.Name}@${o.GUID.guid}" s"internal telepad@${msg.object_guid.guid} is not linked to a remote telepad - ${o.Definition.Name}@${o.GUID.guid}"
) )
GeneralOperations.UseItem.Unhandled case None => ()
case None =>
GeneralOperations.UseItem.Unhandled
} }
} }
@ -1433,63 +1416,55 @@ class GeneralOperations(
recentTeleportAttempt = time recentTeleportAttempt = time
} }
def handleUseCaptureFlag(obj: CaptureFlag): GeneralOperations.UseItem.Behavior = { def handleUseCaptureFlag(obj: CaptureFlag): Unit = {
// LLU can normally only be picked up the faction that owns it // LLU can normally only be picked up the faction that owns it
specialItemSlotGuid match { specialItemSlotGuid match {
case None if obj.Faction == player.Faction => case None if obj.Faction == player.Faction =>
specialItemSlotGuid = Some(obj.GUID) specialItemSlotGuid = Some(obj.GUID)
player.Carrying = SpecialCarry.CaptureFlag player.Carrying = SpecialCarry.CaptureFlag
continent.LocalEvents ! CaptureFlagManager.PickupFlag(obj, player) continent.LocalEvents ! CaptureFlagManager.PickupFlag(obj, player)
GeneralOperations.UseItem.Handled
case None => case None =>
log.warn(s"${player.Faction} player ${player.toString} tried to pick up a ${obj.Faction} LLU - ${obj.GUID}") log.warn(s"${player.Faction} player ${player.toString} tried to pick up a ${obj.Faction} LLU - ${obj.GUID}")
GeneralOperations.UseItem.Unhandled
case Some(guid) if guid != obj.GUID => case Some(guid) if guid != obj.GUID =>
// Ignore duplicate pickup requests // Ignore duplicate pickup requests
log.warn( log.warn(
s"${player.Faction} player ${player.toString} tried to pick up a ${obj.Faction} LLU, but their special slot already contains $guid" s"${player.Faction} player ${player.toString} tried to pick up a ${obj.Faction} LLU, but their special slot already contains $guid"
) )
GeneralOperations.UseItem.Unhandled case _ => ()
case _ =>
GeneralOperations.UseItem.Unhandled
} }
} }
def handleUseWarpGate(equipment: Option[Equipment]): GeneralOperations.UseItem.Behavior = { def handleUseWarpGate(equipment: Option[Equipment]): Unit = {
sessionLogic.zoning.CancelZoningProcessWithDescriptiveReason("cancel_use")
(continent.GUID(player.VehicleSeated), equipment) match { (continent.GUID(player.VehicleSeated), equipment) match {
case (Some(vehicle: Vehicle), Some(item)) case (Some(vehicle: Vehicle), Some(item))
if GlobalDefinitions.isBattleFrameVehicle(vehicle.Definition) && if GlobalDefinitions.isBattleFrameVehicle(vehicle.Definition) &&
GlobalDefinitions.isBattleFrameNTUSiphon(item.Definition) => GlobalDefinitions.isBattleFrameNTUSiphon(item.Definition) =>
vehicle.Actor ! CommonMessages.Use(player, equipment) vehicle.Actor ! CommonMessages.Use(player, equipment)
GeneralOperations.UseItem.Handled case _ => ()
case _ =>
GeneralOperations.UseItem.Unhandled
} }
} }
def handleUseGeneralEntity(obj: PlanetSideServerObject, equipment: Option[Equipment]): GeneralOperations.UseItem.Behavior = { def handleUseGeneralEntity(obj: PlanetSideServerObject, equipment: Option[Equipment]): Unit = {
equipment equipment.foreach { item =>
.collect { item => sessionLogic.zoning.CancelZoningProcessWithDescriptiveReason("cancel_use")
obj.Actor ! CommonMessages.Use(player, Some(item)) obj.Actor ! CommonMessages.Use(player, Some(item))
GeneralOperations.UseItem.Handled }
}
.getOrElse(GeneralOperations.UseItem.Unhandled)
} }
def sendUseGeneralEntityMessage(obj: PlanetSideServerObject, equipment: Equipment): GeneralOperations.UseItem.Behavior = { def sendUseGeneralEntityMessage(obj: PlanetSideServerObject, equipment: Equipment): Unit = {
sessionLogic.zoning.CancelZoningProcessWithDescriptiveReason("cancel_use")
obj.Actor ! CommonMessages.Use(player, Some(equipment)) obj.Actor ! CommonMessages.Use(player, Some(equipment))
GeneralOperations.UseItem.Handled
} }
def handleUseDefaultEntity(obj: PlanetSideGameObject, equipment: Option[Equipment]): GeneralOperations.UseItem.Behavior = { def handleUseDefaultEntity(obj: PlanetSideGameObject, equipment: Option[Equipment]): Unit = {
sessionLogic.zoning.CancelZoningProcessWithDescriptiveReason("cancel_use")
equipment match { equipment match {
case Some(item) case Some(item)
if GlobalDefinitions.isBattleFrameArmorSiphon(item.Definition) || if GlobalDefinitions.isBattleFrameArmorSiphon(item.Definition) ||
GlobalDefinitions.isBattleFrameNTUSiphon(item.Definition) => () GlobalDefinitions.isBattleFrameNTUSiphon(item.Definition) => ()
GeneralOperations.UseItem.Handled
case _ => case _ =>
log.warn(s"UseItem: ${player.Name} does not know how to handle $obj") log.warn(s"UseItem: ${player.Name} does not know how to handle $obj")
GeneralOperations.UseItem.Unhandled
} }
} }
@ -1500,6 +1475,28 @@ class GeneralOperations(
) )
} }
private def commonHandleDeployObjectSetup(
zone: Zone,
deployableType: DeployedItem.Value,
position: Vector3,
orientation: Vector3,
side: Sidedness,
faction: PlanetSideEmpire.Value
): (Deployable, TaskBundle) = {
val deployableEntity: Deployable = Deployables.Make(deployableType)()
deployableEntity.Position = position
deployableEntity.Orientation = orientation
deployableEntity.WhichSide = side
deployableEntity.Faction = faction
val tasking: TaskBundle = deployableEntity match {
case turret: TurretDeployable =>
GUIDTask.registerDeployableTurret(zone.GUID, turret)
case _ =>
GUIDTask.registerObject(zone.GUID, deployableEntity)
}
(deployableEntity, tasking)
}
override protected[session] def actionsToCancel(): Unit = { override protected[session] def actionsToCancel(): Unit = {
progressBarValue = None progressBarValue = None
kitToBeUsed = None kitToBeUsed = None
@ -1519,11 +1516,12 @@ class GeneralOperations(
} }
} }
case Some(o) if player.isAlive =>
unaccessContainer(o)
sendResponse(UnuseItemMessage(player.GUID, o.GUID))
case Some(o) => case Some(o) =>
unaccessContainer(o) unaccessContainer(o)
if (player.isAlive) {
sendResponse(UnuseItemMessage(player.GUID, o.GUID))
}
case None => () case None => ()
} }

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

@ -89,6 +89,7 @@ class SessionData(
private[session] var persistFunc: () => Unit = noPersistence private[session] var persistFunc: () => Unit = noPersistence
private[session] var persist: () => Unit = updatePersistenceOnly private[session] var persist: () => Unit = updatePersistenceOnly
private[session] var keepAliveFunc: () => Unit = keepAlivePersistenceInitial private[session] var keepAliveFunc: () => Unit = keepAlivePersistenceInitial
private[session] var keepAlivePersistenceFunc: () => Unit = keepAlivePersistence
private[session] var turnCounterFunc: PlanetSideGUID => Unit = SessionData.NoTurnCounterYet private[session] var turnCounterFunc: PlanetSideGUID => Unit = SessionData.NoTurnCounterYet
private[session] val oldRefsMap: mutable.HashMap[PlanetSideGUID, String] = new mutable.HashMap[PlanetSideGUID, String]() private[session] val oldRefsMap: mutable.HashMap[PlanetSideGUID, String] = new mutable.HashMap[PlanetSideGUID, String]()
private var contextSafeEntity: PlanetSideGUID = PlanetSideGUID(0) private var contextSafeEntity: PlanetSideGUID = PlanetSideGUID(0)
@ -471,7 +472,7 @@ class SessionData(
def keepAlivePersistenceInitial(): Unit = { def keepAlivePersistenceInitial(): Unit = {
persist() persist()
if (player != null && player.HasGUID) { if (player != null && player.HasGUID) {
keepAliveFunc = keepAlivePersistence keepAliveFunc = keepAlivePersistenceFunc
} }
} }

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

@ -30,12 +30,12 @@ class SessionLocalHandlers(
} }
def handleTurretDeployableIsDismissed(obj: TurretDeployable): Unit = { def handleTurretDeployableIsDismissed(obj: TurretDeployable): Unit = {
Players.buildCooldownReset(continent, player.Name, obj) Players.buildCooldownReset(continent, player.Name, obj.GUID)
TaskWorkflow.execute(GUIDTask.unregisterDeployableTurret(continent.GUID, obj)) TaskWorkflow.execute(GUIDTask.unregisterDeployableTurret(continent.GUID, obj))
} }
def handleDeployableIsDismissed(obj: Deployable): Unit = { def handleDeployableIsDismissed(obj: Deployable): Unit = {
Players.buildCooldownReset(continent, player.Name, obj) Players.buildCooldownReset(continent, player.Name, obj.GUID)
TaskWorkflow.execute(GUIDTask.unregisterObject(continent.GUID, obj)) TaskWorkflow.execute(GUIDTask.unregisterObject(continent.GUID, obj))
} }

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

@ -90,12 +90,11 @@ class SessionTerminalHandlers(
vehicle: Vehicle, vehicle: Vehicle,
weapons: List[InventoryItem], weapons: List[InventoryItem],
trunk: List[InventoryItem] trunk: List[InventoryItem]
): Unit = { ): Option[Vehicle] = {
continent.map.terminalToSpawnPad continent.map.terminalToSpawnPad
.find { case (termid, _) => termid == terminalGuid.guid } .find { case (termid, _) => termid == terminalGuid.guid }
.map { case (a: Int, b: Int) => (continent.GUID(a), continent.GUID(b)) } .map { case (a: Int, b: Int) => (continent.GUID(a), continent.GUID(b)) }
.collect { case (Some(term: Terminal), Some(pad: VehicleSpawnPad)) => .collect { case (Some(term: Terminal), Some(pad: VehicleSpawnPad)) =>
avatarActor ! AvatarActor.UpdatePurchaseTime(vehicle.Definition)
vehicle.Faction = player.Faction vehicle.Faction = player.Faction
vehicle.Position = pad.Position vehicle.Position = pad.Position
vehicle.Orientation = pad.Orientation + Vector3.z(pad.Definition.VehicleCreationZOrientOffset) vehicle.Orientation = pad.Orientation + Vector3.z(pad.Definition.VehicleCreationZOrientOffset)
@ -126,6 +125,7 @@ class SessionTerminalHandlers(
sendResponse(UnuseItemMessage(player.GUID, terminalGuid)) sendResponse(UnuseItemMessage(player.GUID, terminalGuid))
} }
player.LogActivity(TerminalUsedActivity(AmenitySource(term), transactionType)) player.LogActivity(TerminalUsedActivity(AmenitySource(term), transactionType))
vehicle
} }
.orElse { .orElse {
log.error( log.error(

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

@ -202,6 +202,7 @@ class ZoningOperations(
private var zoningChatMessageType: ChatMessageType = ChatMessageType.CMT_QUIT private var zoningChatMessageType: ChatMessageType = ChatMessageType.CMT_QUIT
private var zoningCounter: Int = 0 private var zoningCounter: Int = 0
private var zoningTimer: Cancellable = Default.Cancellable private var zoningTimer: Cancellable = Default.Cancellable
var displayZoningMessageWhenCancelled: Boolean = true
/* packets */ /* packets */
@ -906,7 +907,7 @@ class ZoningOperations(
* defaults to `None` * defaults to `None`
*/ */
def CancelZoningProcessWithReason(msg: String, msgType: Option[ChatMessageType] = None): Unit = { def CancelZoningProcessWithReason(msg: String, msgType: Option[ChatMessageType] = None): Unit = {
if (zoningStatus != Zoning.Status.None) { if (displayZoningMessageWhenCancelled && zoningStatus != Zoning.Status.None) {
sendResponse(ChatMsg(msgType.getOrElse(zoningChatMessageType), wideContents=false, "", msg, None)) sendResponse(ChatMsg(msgType.getOrElse(zoningChatMessageType), wideContents=false, "", msg, None))
} }
CancelZoningProcess() CancelZoningProcess()
@ -2298,7 +2299,7 @@ class ZoningOperations(
* @param zone na * @param zone na
*/ */
def HandleReleaseAvatar(tplayer: Player, zone: Zone): Unit = { def HandleReleaseAvatar(tplayer: Player, zone: Zone): Unit = {
sessionLogic.keepAliveFunc = sessionLogic.keepAlivePersistence sessionLogic.keepAliveFunc = sessionLogic.keepAlivePersistenceFunc
tplayer.Release tplayer.Release
tplayer.VehicleSeated match { tplayer.VehicleSeated match {
case None => case None =>
@ -3023,7 +3024,7 @@ class ZoningOperations(
sessionLogic.keepAliveFunc = sessionLogic.vehicles.GetMountableAndSeat(None, player, continent) match { sessionLogic.keepAliveFunc = sessionLogic.vehicles.GetMountableAndSeat(None, player, continent) match {
case (Some(v: Vehicle), Some(seatNumber)) case (Some(v: Vehicle), Some(seatNumber))
if seatNumber > 0 && v.WeaponControlledFromSeat(seatNumber).isEmpty => if seatNumber > 0 && v.WeaponControlledFromSeat(seatNumber).isEmpty =>
sessionLogic.keepAlivePersistence sessionLogic.keepAlivePersistenceFunc
case _ => case _ =>
NormalKeepAlive NormalKeepAlive
} }
@ -3476,7 +3477,7 @@ class ZoningOperations(
//sit down //sit down
sendResponse(ObjectAttachMessage(vguid, pguid, seat)) sendResponse(ObjectAttachMessage(vguid, pguid, seat))
sessionLogic.general.accessContainer(vehicle) sessionLogic.general.accessContainer(vehicle)
sessionLogic.keepAliveFunc = sessionLogic.keepAlivePersistence sessionLogic.keepAliveFunc = sessionLogic.keepAlivePersistenceFunc
case _ => () case _ => ()
//we can't find a vehicle? and we're still here? that's bad //we can't find a vehicle? and we're still here? that's bad
player.VehicleSeated = None player.VehicleSeated = None

15
src/main/scala/net/psforever/login/WorldSession.scala
View file

@ -1067,6 +1067,13 @@ object WorldSession {
} }
} }
/**
* Perform a task and, upon completion, dispatch a message.
* @param task task to be completed first
* @param sendTo where to send the message
* @param pass message
* @return a `TaskBundle` object
*/
def CallBackForTask(task: TaskBundle, sendTo: ActorRef, pass: Any): TaskBundle = { def CallBackForTask(task: TaskBundle, sendTo: ActorRef, pass: Any): TaskBundle = {
TaskBundle( TaskBundle(
new StraightforwardTask() { new StraightforwardTask() {
@ -1085,6 +1092,14 @@ object WorldSession {
) )
} }
/**
* Perform a task and, upon completion, dispatch a message whose origin is specific and different from normal.
* @param task task to be completed first
* @param sendTo where to send the message
* @param pass message
* @param replyTo whom to attribute the message being passed (e.g., `tell`)
* @return a `TaskBundle` object
*/
def CallBackForTask(task: TaskBundle, sendTo: ActorRef, pass: Any, replyTo: ActorRef): TaskBundle = { def CallBackForTask(task: TaskBundle, sendTo: ActorRef, pass: Any, replyTo: ActorRef): TaskBundle = {
TaskBundle( TaskBundle(
new StraightforwardTask() { new StraightforwardTask() {

10
src/main/scala/net/psforever/objects/Players.scala
View file

@ -18,7 +18,7 @@ import net.psforever.objects.vital.projectile.ProjectileReason
import net.psforever.objects.vital.{InGameActivity, InGameHistory, RevivingActivity} import net.psforever.objects.vital.{InGameActivity, InGameHistory, RevivingActivity}
import net.psforever.objects.zones.Zone import net.psforever.objects.zones.Zone
import net.psforever.packet.game._ import net.psforever.packet.game._
import net.psforever.types.{ChatMessageType, ExoSuitType, Vector3} import net.psforever.types.{ChatMessageType, ExoSuitType, PlanetSideGUID, Vector3}
import net.psforever.services.Service import net.psforever.services.Service
import net.psforever.services.avatar.{AvatarAction, AvatarServiceMessage} import net.psforever.services.avatar.{AvatarAction, AvatarServiceMessage}
import net.psforever.services.local.{LocalAction, LocalServiceMessage} import net.psforever.services.local.{LocalAction, LocalServiceMessage}
@ -327,7 +327,7 @@ object Players {
*/ */
def successfulBuildActivity(zone: Zone, channel: String, obj: Deployable): Unit = { def successfulBuildActivity(zone: Zone, channel: String, obj: Deployable): Unit = {
//sent to avatar event bus to preempt additional tool management //sent to avatar event bus to preempt additional tool management
buildCooldownReset(zone, channel, obj) buildCooldownReset(zone, channel, obj.GUID)
//sent to local event bus to cooperate with deployable management //sent to local event bus to cooperate with deployable management
zone.LocalEvents ! LocalServiceMessage( zone.LocalEvents ! LocalServiceMessage(
channel, channel,
@ -339,13 +339,13 @@ object Players {
* Common actions related to constructing a new `Deployable` object in the game environment. * Common actions related to constructing a new `Deployable` object in the game environment.
* @param zone in which zone these messages apply * @param zone in which zone these messages apply
* @param channel to whom to send the messages * @param channel to whom to send the messages
* @param obj the `Deployable` object * @param guid `Deployable` object
*/ */
def buildCooldownReset(zone: Zone, channel: String, obj: Deployable): Unit = { def buildCooldownReset(zone: Zone, channel: String, guid: PlanetSideGUID): Unit = {
//sent to avatar event bus to preempt additional tool management //sent to avatar event bus to preempt additional tool management
zone.AvatarEvents ! AvatarServiceMessage( zone.AvatarEvents ! AvatarServiceMessage(
channel, channel,
AvatarAction.SendResponse(Service.defaultPlayerGUID, GenericObjectActionMessage(obj.GUID, 21)) AvatarAction.SendResponse(Service.defaultPlayerGUID, GenericObjectActionMessage(guid, 21))
) )
} }

29
src/main/scala/net/psforever/objects/avatar/PlayerControl.scala
View file

@ -385,15 +385,13 @@ class PlayerControl(player: Player, avatarActor: typed.ActorRef[AvatarActor.Comm
} }
if (Players.CertificationToUseExoSuit(player, exosuit, subtype)) { if (Players.CertificationToUseExoSuit(player, exosuit, subtype)) {
if (exosuit == ExoSuitType.MAX) { if (exosuit == ExoSuitType.MAX) {
val weapon = GlobalDefinitions.MAXArms(subtype, player.Faction) val cooldown = player.avatar.purchaseCooldown(GlobalDefinitions.MAXArms(subtype, player.Faction))
val cooldown = player.avatar.purchaseCooldown(weapon)
if (originalSubtype == subtype) { if (originalSubtype == subtype) {
(exosuit, subtype) //same MAX subtype is free (exosuit, subtype) //same MAX subtype
} else if (cooldown.nonEmpty) { } else if (cooldown.nonEmpty) {
fallbackSuit //different MAX subtype can not have cooldown fallbackSuit //different MAX subtype
} else { } else {
avatarActor ! AvatarActor.UpdatePurchaseTime(weapon) (exosuit, subtype) //switching
(exosuit, subtype) //switching for first time causes cooldown
} }
} else { } else {
(exosuit, subtype) (exosuit, subtype)
@ -475,8 +473,6 @@ class PlayerControl(player: Player, avatarActor: typed.ActorRef[AvatarActor.Comm
case InventoryItem(citem: ConstructionItem, _) => case InventoryItem(citem: ConstructionItem, _) =>
Deployables.initializeConstructionItem(player.avatar.certifications, citem) Deployables.initializeConstructionItem(player.avatar.certifications, citem)
} }
//deactivate non-passive implants
avatarActor ! AvatarActor.DeactivateActiveImplants
val zone = player.Zone val zone = player.Zone
zone.AvatarEvents ! AvatarServiceMessage( zone.AvatarEvents ! AvatarServiceMessage(
Players.ZoneChannelIfSpectating(player), Players.ZoneChannelIfSpectating(player),
@ -556,7 +552,7 @@ class PlayerControl(player: Player, avatarActor: typed.ActorRef[AvatarActor.Comm
//don't know where boomer trigger "should" go //don't know where boomer trigger "should" go
TaskWorkflow.execute(PutNewEquipmentInInventoryOrDrop(player)(trigger)) TaskWorkflow.execute(PutNewEquipmentInInventoryOrDrop(player)(trigger))
} }
Players.buildCooldownReset(zone, player.Name, obj) Players.buildCooldownReset(zone, player.Name, obj.GUID)
case _ => () case _ => ()
} }
deployablePair = None deployablePair = None
@ -573,7 +569,7 @@ class PlayerControl(player: Player, avatarActor: typed.ActorRef[AvatarActor.Comm
player.Actor ! Player.LoseDeployable(obj) player.Actor ! Player.LoseDeployable(obj)
TelepadControl.TelepadError(zone, player.Name, msg = "@Telepad_NoDeploy_RouterLost") TelepadControl.TelepadError(zone, player.Name, msg = "@Telepad_NoDeploy_RouterLost")
} }
Players.buildCooldownReset(zone, player.Name, obj) Players.buildCooldownReset(zone, player.Name, obj.GUID)
case _ => () case _ => ()
} }
deployablePair = None deployablePair = None
@ -581,7 +577,7 @@ class PlayerControl(player: Player, avatarActor: typed.ActorRef[AvatarActor.Comm
case Zone.Deployable.IsBuilt(obj) => case Zone.Deployable.IsBuilt(obj) =>
deployablePair match { deployablePair match {
case Some((deployable, tool)) if deployable eq obj => case Some((deployable, tool)) if deployable eq obj =>
Players.buildCooldownReset(player.Zone, player.Name, obj) Players.buildCooldownReset(player.Zone, player.Name, obj.GUID)
player.Find(tool) match { player.Find(tool) match {
case Some(index) => case Some(index) =>
Players.commonDestroyConstructionItem(player, tool, index) Players.commonDestroyConstructionItem(player, tool, index)
@ -613,10 +609,7 @@ class PlayerControl(player: Player, avatarActor: typed.ActorRef[AvatarActor.Comm
val weapon = GlobalDefinitions.MAXArms(subtype, player.Faction) val weapon = GlobalDefinitions.MAXArms(subtype, player.Faction)
player.avatar.purchaseCooldown(weapon) player.avatar.purchaseCooldown(weapon)
.collect(_ => false) .collect(_ => false)
.getOrElse { .getOrElse(true)
avatarActor ! AvatarActor.UpdatePurchaseTime(weapon)
true
}
} else { } else {
true true
}) })
@ -671,8 +664,6 @@ class PlayerControl(player: Player, avatarActor: typed.ActorRef[AvatarActor.Comm
//insert //insert
afterHolsters.foreach(elem => player.Slot(elem.start).Equipment = elem.obj) afterHolsters.foreach(elem => player.Slot(elem.start).Equipment = elem.obj)
afterInventory.foreach(elem => player.Inventory.InsertQuickly(elem.start, elem.obj)) afterInventory.foreach(elem => player.Inventory.InsertQuickly(elem.start, elem.obj))
//deactivate non-passive implants
avatarActor ! AvatarActor.DeactivateActiveImplants
player.Zone.AvatarEvents ! AvatarServiceMessage( player.Zone.AvatarEvents ! AvatarServiceMessage(
Players.ZoneChannelIfSpectating(player), Players.ZoneChannelIfSpectating(player),
AvatarAction.ChangeExosuit( AvatarAction.ChangeExosuit(
@ -744,7 +735,7 @@ class PlayerControl(player: Player, avatarActor: typed.ActorRef[AvatarActor.Comm
else { else {
log.warn(s"cannot build a ${obj.Definition.Name}") log.warn(s"cannot build a ${obj.Definition.Name}")
DropEquipmentFromInventory(player)(tool, Some(obj.Position)) DropEquipmentFromInventory(player)(tool, Some(obj.Position))
Players.buildCooldownReset(zone, player.Name, obj) Players.buildCooldownReset(zone, player.Name, obj.GUID)
obj.Position = Vector3.Zero obj.Position = Vector3.Zero
obj.AssignOwnership(None) obj.AssignOwnership(None)
zone.Deployables ! Zone.Deployable.Dismiss(obj) zone.Deployables ! Zone.Deployable.Dismiss(obj)
@ -755,7 +746,7 @@ class PlayerControl(player: Player, avatarActor: typed.ActorRef[AvatarActor.Comm
obj.AssignOwnership(None) obj.AssignOwnership(None)
val zone = player.Zone val zone = player.Zone
zone.Deployables ! Zone.Deployable.Dismiss(obj) zone.Deployables ! Zone.Deployable.Dismiss(obj)
Players.buildCooldownReset(zone, player.Name, obj) Players.buildCooldownReset(zone, player.Name, obj.GUID)
} }
} }