SessionActor

Companion object SessionActor

class SessionActor extends Actor with MDCContextAware

Source: SessionActor.scala

Linear Supertypes

MDCContextAware, ActorLogging, Actor, AnyRef, Any

Ordering

Alphabetic
By Inheritance

Inherited

SessionActor
MDCContextAware
ActorLogging
Actor
AnyRef
Any

Hide All
Show All

Visibility

Public
Protected

Instance Constructors

new SessionActor(middlewareActor: ActorRef[Command], connectionId: String, sessionId: Long)

Type Members

type Receive = PartialFunction[Any, Unit]
Definition Classes
Actor

Value Members

final def !=(arg0: Any): Boolean
Definition Classes
AnyRef → Any
final def ##: Int
Definition Classes
AnyRef → Any
final def ==(arg0: Any): Boolean
Definition Classes
AnyRef → Any
def AccessContainer(container: Container): Unit
def AccessContainerChannel(events: ActorRef, channel: String): Unit
Join an entity-specific group for shared updates.
Join an entity-specific group for shared updates.
events
the event system bus to which to subscribe
channel
the channel name
def AccessCorpseContents(tplayer: Player): Unit
Common preparation for interfacing with a corpse (former player's backpack).
Common preparation for interfacing with a corpse (former player's backpack). Join a corpse-specific group for shared updates. Construct every object in the player's hands and inventory for shared manipulation updates.
tplayer
the corpse
See also
Container.Inventory
GridInventory.Items
Player.HolsterItems
def AccessGenericContainer(container: PlanetSideServerObject with Container): Unit
def AccessVehicleContents(vehicle: Vehicle): Unit
Common preparation for interfacing with a vehicle trunk.
Common preparation for interfacing with a vehicle trunk. Join a vehicle-specific group for shared updates. Construct every object in the vehicle's inventory for shared manipulation updates.
vehicle
the vehicle
See also
Container.Inventory
GridInventory.Items
def AdministrativeKick(tplayer: Player): Unit
def ApplyPurchaseTimersBeforePackingLoadout(player: Player, target: PlanetSideServerObject with Container, slots: List[InventoryItem]): Unit
Enforce constraints on bulk purchases as determined by a given player's previous purchase times and hard acquisition delays.
Enforce constraints on bulk purchases as determined by a given player's previous purchase times and hard acquisition delays. Intended to assist in sanitizing loadout information from the perspective of the player, or target owner. The equipment is expected to be unregistered and already fitted to their ultimate slot in the target container.
player
the player whose purchasing constraints are to be tested
target
the location in which the equipment will be stowed
slots
the equipment, in the standard object-slot format container
def AvatarCreate(): Unit
A part of the process of spawning the player into the game world.
A part of the process of spawning the player into the game world. The function should work regardless of whether the player is alive or dead - it will make them alive. It adds the WorldSessionActor-current Player to the current zone and sends out the expected packets.

If that player is in a vehicle, it will construct that vehicle. If the player is the driver of the vehicle, they must temporarily be removed from the driver mount in order for the vehicle to be constructed properly. These two previous statements operate through similar though distinct mechanisms and imply different conditions. In reality, they produce the same output but enforce different relationships between the components. The vehicle without a rendered player will always be created if that vehicle exists. The vehicle should only be constructed once.
def AvatarCreateInVehicle(tplayer: Player, vehicle: Vehicle, seat: Int): Unit
Create an avatar character so that avatar's player is mounted in a vehicle's mount.
Create an avatar character so that avatar's player is mounted in a vehicle's mount. A part of the process of spawning the player into the game world.

This is a very specific configuration of the player character that is not visited very often. The value of player.VehicleSeated should be set to accommodate Packet.DetailedConstructorData and, though not explicitly checked, should be the same as the globally unique identifier that is assigned to the vehicle parameter for the current zone. The priority of this function is consider "initial" so it introduces the avatar to the game world in this state and is permitted to introduce the avatar to the vehicle's internal settings in a similar way. Neither the player avatar nor the vehicle should be reconstructed before the next zone load operation to avoid damaging the critical setup of this function.
tplayer
the player avatar seated in the vehicle's mount
vehicle
the vehicle the player is riding
seat
the mount index
See also
AccessContainer
UpdateWeaponAtSeatPosition
def AvatarRejoin(): Unit
A part of the process of spawning the player into the game world in the case of a restored game connection (relogging).

A login protocol that substitutes the first call to avatarSetupFunc (replacing AvatarCreate) in consideration of a user re-logging into the game before the period of time where an avatar/player instance would decay and be cleaned-up.
A part of the process of spawning the player into the game world in the case of a restored game connection (relogging).

A login protocol that substitutes the first call to avatarSetupFunc (replacing AvatarCreate) in consideration of a user re-logging into the game before the period of time where an avatar/player instance would decay and be cleaned-up. Large portions of this function operate as a combination of the mechanics for normal AvatarCreate and for AvatarCreateInVehicle. Unlike either of the previous, this functionlality is disinterested in updating other clients as the target player and potential vehicle already exist as far as other clients are concerned.

If that player is in a vehicle, it will construct that vehicle. If the player is the driver of the vehicle, they must temporarily be removed from the driver mount in order for the vehicle to be constructed properly. These two previous statements operate through similar though distinct mechanisms and imply different conditions. In reality, they produce the same output but enforce different relationships between the components. The vehicle without a rendered player will always be created if that vehicle exists.

The value of player.VehicleSeated should be set to accommodate Packet.DetailedConstructorData and, though not explicitly checked, should be the same as the globally unique identifier that is assigned to the vehicle parameter for the current zone. The priority of this function is consider "initial" so it introduces the avatar to the game world in this state and is permitted to introduce the avatar to the vehicle's internal settings in a similar way. Neither the player avatar nor the vehicle should be reconstructed before the next zone load operation to avoid damaging the critical setup of this function.
def CanNotChangeDeployment(obj: PlanetSideServerObject with Deployment, state: types.DriveState.Value, reason: String): Unit
Common reporting behavior when a Deployment object fails to properly transition between states.
Common reporting behavior when a Deployment object fails to properly transition between states.
obj
the game object that could not
state
the DriveState that could not be promoted
reason
a string explaining why the state can not or will not change
def CancelAllProximityUnits(): Unit
Cease all current interactions with proximity-based units.
Cease all current interactions with proximity-based units. Pair with PlayerActionsToCancel, except when logging out (stopping). This operations may invoke callback messages.
See also
postStop
def CancelZoningProcess(): Unit
The user no longer expects to perform a zoning event, or the process is merely resetting its internal state.
def CancelZoningProcessWithDescriptiveReason(msg: String): Unit
The user no longer expects to perform a zoning event for this reason.
The user no longer expects to perform a zoning event for this reason.
msg
the message to the user
def CancelZoningProcessWithReason(msg: String, msgType: Option[ChatMessageType] = None): Unit
The user no longer expects to perform a zoning event for this reason.
The user no longer expects to perform a zoning event for this reason.
msg
the message to the user
msgType
the type of message, influencing how it is presented to the user; normally, this message uses the same value as zoningChatMessageTypes defaults to None
def CapacitorTick(jump_thrust: Boolean): Unit
def CargoMountBehaviorForUs(carrier: Vehicle, cargo: Vehicle, mountPoint: Int): (ObjectAttachMessage, CargoMountPointStatusMessage)
Dispatch an ObjectAttachMessage packet and a CargoMountPointStatusMessage packet only to this client.
Dispatch an ObjectAttachMessage packet and a CargoMountPointStatusMessage packet only to this client.
carrier
the ferrying vehicle
cargo
the ferried vehicle
mountPoint
the point on the ferryoing vehicle where the ferried vehicle is attached
returns
a tuple composed of an ObjectAttachMessage packet and a CargoMountPointStatusMessage packet
See also
CargoMountPointStatusMessage
ObjectAttachMessage
def CargoMountMessagesForUs(attachMessage: ObjectAttachMessage, mountPointStatusMessage: CargoMountPointStatusMessage): Unit
Dispatch an ObjectAttachMessage packet and a CargoMountPointStatusMessage packet only to this client.
Dispatch an ObjectAttachMessage packet and a CargoMountPointStatusMessage packet only to this client.
attachMessage
an ObjectAttachMessage packet suitable for initializing cargo operations
mountPointStatusMessage
a CargoMountPointStatusMessage packet suitable for initializing cargo operations
See also
CargoMountPointStatusMessage
ObjectAttachMessage
def CheckForHitPositionDiscrepancy(projectile_guid: PlanetSideGUID, hitPos: Vector3, target: PlanetSideGameObject with FactionAffinity with Vitality): Unit
def ConditionalDriverVehicleControl(vehicle: Vehicle): Unit
Place the current vehicle under the control of the driver's commands, but leave it in a cancellable auto-drive.
Place the current vehicle under the control of the driver's commands, but leave it in a cancellable auto-drive. Stop all movement entirely.
vehicle
the vehicle
def CountSpawnDelay(toZoneId: String, toSpawnPoint: SpawnPoint, fromZoneId: String): FiniteDuration
Given an origin and a destination, determine how long the process of traveling should take in reconstruction time.
Given an origin and a destination, determine how long the process of traveling should take in reconstruction time. For most destinations, the unit of receiving ("spawn point") determines the reconstruction time. Possession of a lattice-linked friendly Bio Laboratory halves the time of spawning at facilities. In a special consideration, travel to any sanctuary or sanctuary-special zone should be as immediate as zone loading.
toZoneId
the zone where the target is headed
toSpawnPoint
the unit the target is using as a destination
fromZoneId
the zone where the target current is located
returns
how long the spawning process will take
def DeconstructDeployable(obj: Deployable, guid: PlanetSideGUID, pos: Vector3, orient: Vector3, deletionType: Int): Unit
Common behavior for deconstructing deployables in the game environment.
Common behavior for deconstructing deployables in the game environment.
obj
the deployable
guid
the globally unique identifier for the deployable
pos
the previous position of the deployable
orient
the previous orientation of the deployable
deletionType
the value passed to ObjectDeleteMessage concerning the deconstruction animation
def DepictPlayerAsCorpse(tplayer: Player): Unit
Creates a player that has the characteristics of a corpse.
Creates a player that has the characteristics of a corpse. To the game, that is a backpack (or some pastry, festive graphical modification allowing).
tplayer
the player
See also
CorpseConverter.converter
def DeployableBuildActivity(obj: Deployable): Unit
Common actions related to constructing a new Deployable object in the game environment.

The map icon for the deployable just introduced is also created on the clients of all faction-affiliated players.
Common actions related to constructing a new Deployable object in the game environment.

The map icon for the deployable just introduced is also created on the clients of all faction-affiliated players. This icon is important as, short of destroying it, the owner has no other means of controlling the created object that it is associated with.
obj
the Deployable object to be built
def DestroyDisplayMessage(killer: SourceEntry, victim: SourceEntry, method: Int, unk: Int = 121): DestroyDisplayMessage
Properly format a DestroyDisplayMessage packet given sufficient information about a target (victim) and an actor (killer).
Properly format a DestroyDisplayMessage packet given sufficient information about a target (victim) and an actor (killer). For the packet, the charId field is important for determining distinction between players.
killer
the killer's entry
victim
the victim's entry
method
the manner of death
unk
na; defaults to 121, the object id of avatar
returns
a DestroyDisplayMessage packet that is properly formatted
def DismountAction(tplayer: Player, obj: PlanetSideGameObject with Mountable, seatNum: Int): Unit
Common activities/procedure when a player dismounts a valid mountable object.
Common activities/procedure when a player dismounts a valid mountable object.
tplayer
the player
obj
the mountable object
seatNum
the mount out of which which the player is disembarking
def DisplayContainerContents(containerId: PlanetSideGUID, items: Iterable[InventoryItem]): Unit
Depict the contents of a container by building them in the local client in their container as a group of detailed entities.
Depict the contents of a container by building them in the local client in their container as a group of detailed entities.
containerId
the container's unique identifier
items
a list of the entities to be depicted
See also
ObjectCreateDetailedMessage
ObjectCreateMessageParent
PacketConverter.DetailedConstructorData
def DontRedrawIcons(obj: Deployable): Unit
Do not draw any icon for this deployable object.

When a client first joins a zone, all deployables are drawn on the continent map once.
Do not draw any icon for this deployable object.

When a client first joins a zone, all deployables are drawn on the continent map once. Should the player place any deployables, those deployables belong to that player. Ownership causes icon to be drawn in yellow to the player (as opposed to a white icon) and that signifies a certain level of control over the deployable, at least the ability to quietly deconstruct it. Under normal death/respawn cycles while the player is in a given zone, the map icons for owned deployables remain manipulable by that given user. They do not have to be redrawn to stay accurate. Upon leaving a zone, where the icons are erased, and returning back to the zone, where they are drawn again, the deployables that a player owned should be restored in terms of their map icon visibility. This control can not be recovered, however, until they are updated with the player's globally unique identifier. Since the player does not need to redraw his own deployable icons each time he respawns, but will not possess a valid GUID for that zone until he spawns in it at least once, this function swaps out with another after the first spawn in any given zone. It stays swapped in until the player changes zones.
obj
a Deployable object
See also
RedrawDeployableIcons
SetCurrentAvatar
def DrawCurrentAmsSpawnPoint(): Unit
In the background, a list of advanced mobile spawn vehicles that are deployed in the zone is being updated constantly.
In the background, a list of advanced mobile spawn vehicles that are deployed in the zone is being updated constantly. Select, from this list, the AMS that is closest to the player's current or last position and draw its spawn selection icon onto the deployment map.
See also
BindPlayerMessage
DeadState.Release
def DriverVehicleControl(vehicle: Vehicle, speed: Int = 0, flight: Int = 0): Unit
Place the current vehicle under the control of the driver's commands, but leave it in a cancellable auto-drive.
Place the current vehicle under the control of the driver's commands, but leave it in a cancellable auto-drive.
vehicle
the vehicle
speed
how fast the vehicle is moving forward
flight
whether the vehicle is ascending or not, if the vehicle is an applicable type
def DropSpecialSlotItem(): Unit
def EmptyMagazine(weapon_guid: PlanetSideGUID, tool: Tool): Unit
For a certain weapon that can load ammunition, enforce that its magazine is empty.
For a certain weapon that can load ammunition, enforce that its magazine is empty. Punctuate that emptiness with a ceasation of weapons fire and a dry fire sound effect.
weapon_guid
the weapon (GUID)
tool
the weapon (object)
def EmptyMagazine(weapon_guid: PlanetSideGUID): Unit
For a certain weapon that cna load ammunition, enforce that its magazine is empty.
For a certain weapon that cna load ammunition, enforce that its magazine is empty.
weapon_guid
the weapon
def FindContainedEquipment(guid: PlanetSideGUID): (Option[PlanetSideGameObject with Container], Set[Equipment])
Check two locations for a controlled piece of equipment that is associated with the player and has the specified global unique identifier number.
def FindContainedEquipment(): (Option[PlanetSideGameObject with Container], Set[Equipment])
Check two locations for a controlled piece of equipment that is associated with the player.

The first location is dependent on whether the avatar is in a vehicle.
Check two locations for a controlled piece of equipment that is associated with the player.

The first location is dependent on whether the avatar is in a vehicle. Some vehicle seats may have a "controlled weapon" which counts as the first location to be checked. The second location is dependent on whether the avatar has a raised hand. That is only possible if the player has something in their hand at the moment, hence the second location. Players do have a concept called a "last drawn slot" (hand) but that former location is not eligible.

Along with any discovered item, a containing object such that the statement:
container.Find(object) = Some(slot)
... will return a proper result. For a mount controlled weapon, the vehicle is returned. For the player's hand, the player is returned.
returns
a Tuple of the returned values; the first value is a Container object; the second value is an Equipment object in the former
def FindContainedWeapon(guid: PlanetSideGUID): (Option[PlanetSideGameObject with Container], Set[Tool])
Check two locations for a controlled piece of equipment that is associated with the player.
Check two locations for a controlled piece of equipment that is associated with the player. Filter for discovered Tool-type Equipment with a specific global unique identifier number.
returns
a Tuple of the returned values; the first value is a Container object; the second value is an Tool object in the former
def FindContainedWeapon: (Option[PlanetSideGameObject with Container], Set[Tool])
Check two locations for a controlled piece of equipment that is associated with the player.
Check two locations for a controlled piece of equipment that is associated with the player. Filter for discovered Tool-type Equipment.
returns
a Tuple of the returned values; the first value is a Container object; the second value is an Tool object in the former
def FindDetectedProjectileTargets(targets: Iterable[PlanetSideGUID]): Iterable[String]
The main purpose of this method is to determine which targets will receive "locked on" warnings from remote projectiles.
The main purpose of this method is to determine which targets will receive "locked on" warnings from remote projectiles. For a given series of globally unique identifiers, indicating targets, and that may include mounted elements (players), estimate a series of channel names for communication with the vulnerable targets.
targets
the globally unique identifiers of the immediate detected targets
returns
channels names that allow direct communication to specific realized targets
def FindEnabledWeaponsToHandleWeaponFireAccountability(o: Option[PlanetSideGameObject with Container], tools: Set[Tool]): (Option[PlanetSideGameObject with Container], Set[Tool])
def FindEquipment(guid: PlanetSideGUID): Option[Equipment]
Runs FindContainedEquipment but ignores the Container object output and only discovers Equipment with the specified global unique identifier number.
Runs FindContainedEquipment but ignores the Container object output and only discovers Equipment with the specified global unique identifier number.
returns
an Equipment object
def FindEquipment(): Set[Equipment]
Runs FindContainedEquipment but ignores the Container object output.
Runs FindContainedEquipment but ignores the Container object output.
returns
an Equipment object
def FindEquipmentToDelete(object_guid: PlanetSideGUID, obj: Equipment): Boolean
A simple object searching algorithm that is limited to containers currently known and accessible by the player.
A simple object searching algorithm that is limited to containers currently known and accessible by the player. If all relatively local containers are checked and the object is not found, the player's locker inventory will be checked, and then the game environment (items on the ground) will be checked too. If the target object is discovered, it is removed from its current location and is completely destroyed.
object_guid
the target object's globally unique identifier; it is not expected that the object will be unregistered, but it is also not gauranteed
obj
the target object
returns
true, if the target object was discovered and removed; false, otherwise
See also
RequestDestroyMessage
Zone.ItemIs.Where
def FindInLocalContainer(object_guid: PlanetSideGUID)(parent: PlanetSideServerObject with Container): Option[(PlanetSideServerObject with Container, Option[Int])]
Given an object globally unique identifier, search in a given location for it.
Given an object globally unique identifier, search in a given location for it.
object_guid
the object
parent
a Container object wherein to search
returns
an optional tuple that contains two values; the first value is the container that matched correctly with the object's GUID; the second value is the slot position of the object
def FindLocalVehicle: Option[Vehicle]
Get the current Vehicle object that the player is riding/driving.
Get the current Vehicle object that the player is riding/driving. The vehicle must be found solely through use of player.VehicleSeated.
returns
the vehicle
def FindProjectileEntry(projectile_guid: PlanetSideGUID): Option[Projectile]
Given a globally unique identifier in the 40100 to 40124 range (with an optional 25 as buffer), find a projectile.
Given a globally unique identifier in the 40100 to 40124 range (with an optional 25 as buffer), find a projectile.
projectile_guid
the projectile's GUID
returns
the discovered projectile
def FindProximityUnitTargetsInScope(terminal: Terminal with ProximityUnit): Seq[PlanetSideGameObject]
na
na
terminal
na
returns
na
def FindWeapon: Set[Tool]
Runs FindContainedWeapon but ignores the Container object output.
Runs FindContainedWeapon but ignores the Container object output.
returns
a Tool object
def FireCycleCleanup(tool: Tool): Unit
After a weapon has finished shooting, determine if it needs to be sorted in a special way.
After a weapon has finished shooting, determine if it needs to be sorted in a special way.
tool
a weapon
def FirstTimeSquadSetup(): Unit
These messages are dispatched when first starting up the client and connecting to the server for the first time.
These messages are dispatched when first starting up the client and connecting to the server for the first time. While many of these messages will be reused for other situations, they appear in this order only during startup.
def ForgetAllProximityTerminals(term_guid: PlanetSideGUID): Unit
na
def FriskDeadBody(obj: Player): Unit
Remove items from a deceased player that are not expected to be found on a corpse.
Remove items from a deceased player that are not expected to be found on a corpse. Most all players have their melee slot knife (which can not be un-equipped normally) removed. MAX's have their primary weapon in the designated slot removed.
obj
the player to be turned into a corpse
def GetKnownVehicleAndSeat(): (Option[Vehicle], Option[Int])
If the player is seated in a vehicle, find that vehicle and get the mount index number at which the player is sat.

For special purposes involved in zone transfers, where the vehicle may or may not exist in either of the zones (yet), the value of interstellarFerry is also polled.
If the player is seated in a vehicle, find that vehicle and get the mount index number at which the player is sat.

For special purposes involved in zone transfers, where the vehicle may or may not exist in either of the zones (yet), the value of interstellarFerry is also polled. Making certain this field is blanked after the transfer is completed is important to avoid inspecting the wrong vehicle and failing simple vehicle checks where this function may be employed.
returns
a tuple consisting of a vehicle reference and a mount index if and only if the vehicle is known to this client and the WorldSessioNActor-global player occupies it; (None, None), otherwise (even if the vehicle can be determined)
See also
GetMountableAndSeat
interstellarFerry
def GetMountableAndSeat(direct: Option[PlanetSideGameObject with Mountable], occupant: Player, zone: Zone): (Option[PlanetSideGameObject with Mountable], Option[Int])
If the player is mounted in some entity, find that entity and get the mount index number at which the player is sat.
If the player is mounted in some entity, find that entity and get the mount index number at which the player is sat. The priority of object confirmation is direct then occupant.VehicleSeated. Once an object is found, the remainder are ignored.
direct
a game object in which the player may be sat
occupant
the player who is sat and may have specified the game object in which mounted
returns
a tuple consisting of a vehicle reference and a mount index if and only if the vehicle is known to this client and the WorldSessioNActor-global player occupies it; (None, None), otherwise (even if the vehicle can be determined)
def GetVehicleAndSeat(): (Option[Vehicle], Option[Int])
If the player is seated in a vehicle, find that vehicle and get the mount index number at which the player is sat.
If the player is seated in a vehicle, find that vehicle and get the mount index number at which the player is sat.
returns
a tuple consisting of a vehicle reference and a mount index if and only if the vehicle is known to this client and the WorldSessioNActor-global player occupies it; (None, None), otherwise (even if the vehicle can be determined)
See also
GetMountableAndSeat
def GiveSquadColorsInZone(members: Iterable[Long], value: Long): Unit
Allocate the listed squad members in zone and give their nameplates and their marquees the appropriate squad color.
Allocate the listed squad members in zone and give their nameplates and their marquees the appropriate squad color.
members
members of the squad to target
value
the assignment value
See also
PlanetsideAttributeMessage
def GiveSquadColorsInZone(members: Iterable[Long]): Unit
Allocate the listed squad members in zone and give their nameplates and their marquees the appropriate squad color.
Allocate the listed squad members in zone and give their nameplates and their marquees the appropriate squad color.
members
members of the squad to target
def GiveSquadColorsInZone(): Unit
Allocate all squad members in zone and give their nameplates and their marquees the appropriate squad color.
def GoToDeploymentMap(): Unit
Make this client display the deployment map, and all its available destination spawn points.
Make this client display the deployment map, and all its available destination spawn points.
See also
AvatarDeadStateMessage
DeadState.Release
Player.Release
def HackObject(target_guid: PlanetSideGUID, unk1: Long, unk2: Long): Unit
na
na
target_guid
na
unk1
na
unk2
na
def HandleAvatarServiceResponse(toChannel: String, guid: PlanetSideGUID, reply: Response): Unit
na
na
toChannel
na
guid
na
reply
na
def HandleDamageProxy(projectile: Projectile, pguid: PlanetSideGUID, hitPos: Vector3): List[(PlanetSideGameObject with FactionAffinity with Vitality, Projectile, Vector3, Vector3)]
Take a projectile that was introduced into the game world and determine if it generates a secondary damage projectile or an method of damage causation that requires additional management.
Take a projectile that was introduced into the game world and determine if it generates a secondary damage projectile or an method of damage causation that requires additional management.
projectile
the projectile
pguid
the client-local projectile identifier
hitPos
the game world position where the projectile is being recorded
returns
a for all affected targets, a combination of projectiles, projectile location, and the target's location; nothing if no targets were affected
def HandleDamageProxyLittleBuddyExplosion(proxy: Projectile, orientation: Vector3, distance: Float): Unit
def HandleDamageProxySetupLittleBuddy(listOfProjectiles: List[Projectile], detonationPosition: Vector3): Boolean
def HandleDealingDamage(target: PlanetSideGameObject with Vitality, data: DamageInteraction): Unit
Calculate the amount of damage to be dealt to an active target using the information reconstructed from a Resolvedprojectile and affect the target in a synchronized manner.
Calculate the amount of damage to be dealt to an active target using the information reconstructed from a Resolvedprojectile and affect the target in a synchronized manner. The active target and the target of the DamageResult do not have be the same. While the "tell" for being able to sustain damage is an entity of type Vitality, only specific Vitality entity types are being screened for sustaining damage.
target
a valid game object that is known to the server
data
a projectile that will affect the target
See also
DamageResistanceModel
Vitality
def HandleLocalServiceResponse(toChannel: String, guid: PlanetSideGUID, reply: Response): Unit
na
na
toChannel
na
guid
na
reply
na
def HandleMountMessages(tplayer: Player, reply: Exchange): Unit
na
na
tplayer
na
reply
na
def HandleProgressChange(delta: Float, completionAction: () => Unit, tickAction: (Float) => Boolean, tick: Long): Unit
Handle the message that indicates the level of completion of a process.
Handle the message that indicates the level of completion of a process. The process is any form of user-driven activity with a certain eventual outcome but indeterminate progress feedback per cycle.

This task is broken down into the "progression" from its initial state to the eventual outcome as is reported back to the player through some means of messaging window feedback. Though common in practice, this is not a requirement and the progress can accumulate without a user reportable method. To ensure that completion is reported properly, an exception is made that 99% completion is accounted uniquely before the final 100% is achieved. If the background process recording value is never set before running the initial operation or gets unset by failing a tickAction check the process is stopped.
delta
how much the progress changes each tick
completionAction
a custom action performed once the process is completed
tickAction
an optional action is is performed for each tick of progress; also performs a continuity check to determine if the process has been disrupted
See also
progressBarUpdate
progressBarValue
WorldSessionActor.Progress
def HandleProximityTerminalUse(terminal: Terminal with ProximityUnit): Unit
na
na
terminal
na
def HandleReleaseAvatar(tplayer: Player, zone: Zone): Unit
na
na
tplayer
na
zone
na
def HandleSetCurrentAvatar(tplayer: Player): Unit
Instruct the client to treat this player as the avatar.
Instruct the client to treat this player as the avatar. Initialize all client-specific data that is dependent on some player being declared the "avatar".
tplayer
the target player
def HandleTerminalMessage(tplayer: Player, msg: ItemTransactionMessage, order: Exchange): Unit
na
na
tplayer
na
msg
na
order
na
def HandleVehicleServiceResponse(toChannel: String, guid: PlanetSideGUID, reply: Response): Unit
na
na
toChannel
na
guid
na
reply
na
def HandleWeaponFire(weaponGUID: PlanetSideGUID, projectileGUID: PlanetSideGUID, shotOrigin: Vector3, shotVelocity: Option[Vector3]): Unit
def HandleWeaponFireAccountability(weaponGUID: PlanetSideGUID, projectileGUID: PlanetSideGUID): (Option[PlanetSideGameObject with Container], Option[Tool])
def HideContainerContents(items: List[InventoryItem]): Unit
Forget the contents of a container by deleting that content from the local client.
Forget the contents of a container by deleting that content from the local client.
items
a list of the entities to be depicted
See also
InventoryItem
ObjectDeleteMessage
def ImmediateDisconnect(): Unit
def KeepAlivePersistence(): Unit
The atypical response to receiving a KeepAliveMessage packet from the client.

KeepAliveMessage packets are the primary vehicle for persistence due to client reporting in the case where the player's avatar is riding in a vehicle in a mount with no weapon to control.
The atypical response to receiving a KeepAliveMessage packet from the client.

KeepAliveMessage packets are the primary vehicle for persistence due to client reporting in the case where the player's avatar is riding in a vehicle in a mount with no weapon to control.
See also
KeepAliveMessage
keepAliveFunc
turnCounterFunc
persist
def KeepAlivePersistenceInitial(): Unit
A really atypical response to receiving a KeepAliveMessage packet from the client that applies only during the character select portion and part of the first zone load activity.
def KickedByAdministration(): Unit
def LoadZoneAsPlayer(targetPlayer: Player, zoneId: String): Unit
Deal with a target player as free-standing infantry in the course of a redeployment action to a target continent whether that action is the result of a deconstruction (reconstruction), a death (respawning), or other position shifting action handled directly by the server.
Deal with a target player as free-standing infantry in the course of a redeployment action to a target continent whether that action is the result of a deconstruction (reconstruction), a death (respawning), or other position shifting action handled directly by the server.
The two important vectors are still whether the zone being transported to is the same or is different and whether the target player is alive or released (note: not just "dead" ...).
targetPlayer
the target player being moved around; not necessarily the same player as the WorldSessionActor-global player
zoneId
the zone in which the player will be placed
def LoadZoneCommonTransferActivity(): Unit
Common behavior when transferring between zones encompassing actions that disassociate the player with entities they left (will leave) in the previous zone.
Common behavior when transferring between zones encompassing actions that disassociate the player with entities they left (will leave) in the previous zone. It also sets up actions for the new zone loading process.
def LoadZoneInVehicle(vehicle: Vehicle, pos: Vector3, ori: Vector3, zone_id: String): Unit
Deal with a target player as a vehicle occupant in the course of a redeployment action to a target continent whether that action is the result of a deconstruction (reconstruction) or other position shifting action handled directly by the server.

The original target player must be alive and the only consideration is in what position the player is mounted in the vehicle.
Deal with a target player as a vehicle occupant in the course of a redeployment action to a target continent whether that action is the result of a deconstruction (reconstruction) or other position shifting action handled directly by the server.

The original target player must be alive and the only consideration is in what position the player is mounted in the vehicle. Any seated position that isn't the driver is a passenger. The most important role performed in this function is to declare a reference to the vehicle itsself since no other connection from the player to the vehicle is guaranteed to persist in a meaningful way during the transfer.
vehicle
the target vehicle being moved around; WILL necessarily be the same vehicles as is controlled by the WorldSessionActor-global player
pos
the game world coordinates where the vehicle will be positioned
ori
the direction in which the vehicle will be oriented
zone_id
the zone in which the vehicle and driver will be placed, or in which the vehicle has already been placed
returns
a tuple composed of an ActorRef destination and a message to send to that destination
def LoadZoneInVehicleAsDriver(vehicle: Vehicle, zoneId: String): Unit
Deal with a target player as a vehicle driver in the course of a redeployment action to a target continent whether that action is the result of a deconstruction (reconstruction) or other position shifting action handled directly by the server.

During a vehicle transfer, whether to the same zone or to a different zone, the driver has the important task of ensuring the certain safety of his passengers during transport.
Deal with a target player as a vehicle driver in the course of a redeployment action to a target continent whether that action is the result of a deconstruction (reconstruction) or other position shifting action handled directly by the server.

During a vehicle transfer, whether to the same zone or to a different zone, the driver has the important task of ensuring the certain safety of his passengers during transport. The driver must modify the conditions of the vehicle's passengers common communication channel originally determined entirely by the vehicle's soon-to-be blanked internal Actor object. Any cargo vehicles under the control of the target vehicle must also be made aware of the current state of the process. In the case of a series of ferrying vehicles and cargo vehicles, the vehicle to be deleted might not be the one immediately mounted. A reference to the top-level ferrying vehicle's former globally unique identifier has been retained for this purpose. This vehicle can be deleted for everyone if no more work can be detected.
vehicle
the target vehicle being moved around; WILL necessarily be the same vehicles as is controlled by the WorldSessionActor-global player
zoneId
the zone in which the vehicle and driver will be placed, or in which the vehicle has already been placed
returns
a tuple composed of an ActorRef destination and a message to send to that destination
def LoadZoneInVehicleAsPassenger(vehicle: Vehicle, zoneId: String): Unit
Deal with a target player as a vehicle passenger in the course of a redeployment action to a target continent whether that action is the result of a deconstruction (reconstruction) or other position shifting action handled directly by the server.

The way a vehicle is handled in reference to being a passenger is very similar to how an infantry player is handled in the same process.
Deal with a target player as a vehicle passenger in the course of a redeployment action to a target continent whether that action is the result of a deconstruction (reconstruction) or other position shifting action handled directly by the server.

The way a vehicle is handled in reference to being a passenger is very similar to how an infantry player is handled in the same process. If this player is the last person who requires a zone change which is the concluding zone transfer of what might have been a long chain of vehicle and passengers then that player is responsible for deleting the vehicle for other players of the previous zone. In the case of a series of ferrying vehicles and cargo vehicles, the vehicle to be deleted might not be the one immediately mounted. A reference to the top-level ferrying vehicle's former globally unique identifier has been retained for this purpose. This vehicle can be deleted for everyone if no more work can be detected.
vehicle
the target vehicle being moved around
zoneId
the zone in which the vehicle and driver will be placed
returns
a tuple composed of an ActorRef destination and a message to send to that destination
See also
GUIDTask.unregisterPlayer
LoadZoneCommonTransferActivity
Vehicles.AllGatedOccupantsInSameZone
PlayerLoaded
TaskBeforeZoneChange
UnaccessContainer
def LoadZoneLaunchDroppod(zone: Zone, spawnPosition: Vector3): Unit
Attach the player to a droppod vehicle and hurtle them through the stratosphere in some far off world.
Attach the player to a droppod vehicle and hurtle them through the stratosphere in some far off world. Perform all normal operation standardization (state cancels) as if any of form of zoning was being performed, then assemble the vehicle and work around some inconvenient setup requirements for vehicle gating. You can't instant action to respond to some activity using a droppod.
zone
the destination zone
spawnPosition
the destination drop position
def LoadZonePhysicalSpawnPoint(zoneId: String, pos: Vector3, ori: Vector3, respawnTime: FiniteDuration, physSpawnPoint: Option[SpawnPoint]): Unit
The starting point of behavior for a player who: is dead and is respawning; is deconstructing at a spawn tube and is respawning; is using a warp gate; or, any or none of the previous conditions, but the final result involves changing what zone the player occupies.
The starting point of behavior for a player who: is dead and is respawning; is deconstructing at a spawn tube and is respawning; is using a warp gate; or, any or none of the previous conditions, but the final result involves changing what zone the player occupies. This route is not taken when first spawning in the game world, unless special conditions need to be satisfied. The visible result will be apparent by the respawn timer being displayed to the client over the deployment map.

Two choices must be independently made to complete this part of the process. The first choice ivolves the state of the player who is spawning as the known entry state involve either being alive or being dead. A dead player (technically, a "corpse" that can no longer be revived) is embodied in a completely new player with a new globally unique identifier and a whole new inventory. A player who is transferring continents also satisfies the requirements for obtaining a completely new globally unique identifier, though the new identifier belongs to the new zone rather than the previous (still current) one. The second choice is satisfied by respawning in the same zone while still in a state of still being alive. In this singular case, the player retains his previous globally unique identifier. In all other cases, as indicated, a new globally unique identifier is selected.

If the player is alive and mounted in a vehicle, a different can of worms is produced. The ramifications of these conditions are not fully satisfied until the player loads into the new zone. Even then, the conclusion becomes delayed while a slightly lagged mechanism hoists players between zones.
zoneId
the zone in which the player will be placed
pos
the game world coordinates where the player will be positioned
ori
the direction in which the player will be oriented
respawnTime
the character downtime spent respawning, as clocked on the redeployment screen; does not factor in any time required for loading zone or game objects
def LoadZoneTransferPassengerMessages(player_guid: PlanetSideGUID, toZoneId: String, vehicle: Vehicle): Unit
Dispatch messages to all target players in immediate passenger and gunner seats and to the driver of all vehicles in cargo holds that their current ferrying vehicle is being transported from one zone to the next and that they should follow after it.
Dispatch messages to all target players in immediate passenger and gunner seats and to the driver of all vehicles in cargo holds that their current ferrying vehicle is being transported from one zone to the next and that they should follow after it. The messages address the avatar of their recipient WorldSessionActor objects.
player_guid
the driver of the target vehicle
toZoneId
the zone where the target vehicle will be moved
vehicle
the vehicle (object)
def LocalStopUsingProximityUnit(terminal: Terminal with ProximityUnit, target: PlanetSideGameObject): Unit
Stop using a proximity-base service.
Stop using a proximity-base service. Callback to handle flags specific to SessionActor. Special note is warranted when determining the identity of the proximity terminal. Medical terminals of both varieties can be cancelled by movement. Other sorts of proximity-based units are put on a timer.
terminal
the proximity-based unit
def MountingAction(tplayer: Player, obj: PlanetSideGameObject with Mountable, seatNum: Int): Unit
Common activities/procedure when a player mounts a valid object.
Common activities/procedure when a player mounts a valid object.
tplayer
the player
obj
the mountable object
seatNum
the mount into which the player is mounting
def NoPersistence(): Unit
Do not update this player avatar for persistence.
Do not update this player avatar for persistence. Set to persistFunc initially.
def NoSquadUpdates(): Unit
def NormalItemDrop(obj: PlanetSideServerObject with Container, zone: Zone)(item: Equipment): Unit
Drop an Equipment item onto the ground.
Drop an Equipment item onto the ground. Specifically, instruct the item where it will appear, add it to the list of items that are visible to multiple users, and then inform others that the item has been dropped.
obj
a Container object that represents where the item will be dropped; curried for callback
zone
the continent in which the item is being dropped; curried for callback
item
the item
def NormalKeepAlive(): Unit
The normal response to receiving a KeepAliveMessage packet from the client.

Even though receiving a KeepAliveMessage outside of zoning is uncommon, the behavior should be configured to maintain a neutral action.
The normal response to receiving a KeepAliveMessage packet from the client.

Even though receiving a KeepAliveMessage outside of zoning is uncommon, the behavior should be configured to maintain a neutral action.
See also
KeepAliveMessage
keepAliveFunc
def NormalTurnCounter(p: PlanetSideGUID): Unit
The upstream counter accumulates when the server receives specific messages from the client.
The upstream counter accumulates when the server receives specific messages from the client. It counts upwards until it reach maximum value, and then starts over. When it starts over, which should take an exceptionally long time to achieve, it starts counting at one rather than zero.
p
the player's globally unique identifier number
def PerformToolAmmoChange(tool: Tool, obj: PlanetSideServerObject with Container): Unit
na
na
tool
na
obj
na
def PeriodicUpdatesWhenEnrolledInSquad(): Unit
def PlayerActionsToCancel(): Unit
An event has occurred that would cause the player character to stop certain stateful activities.
An event has occurred that would cause the player character to stop certain stateful activities. These activities include shooting, the weapon being drawn, hacking, accessing (a container), flying, and running. Other players in the same zone must be made aware that the player has stopped as well.

Things whose configuration should not be changed:
- if the player is seated
- if the player is anchored
This is not a complete list but, for the purpose of enforcement, some pointers will be documented here.
def PrepareToTurnPlayerIntoCorpse(tplayer: Player, zone: Zone): Unit
Creates a player that has the characteristics of a corpse so long as the player has items in their knapsack or their holsters.
Creates a player that has the characteristics of a corpse so long as the player has items in their knapsack or their holsters. If the player has no items stored, the clean solution is to remove the player from the game. To the game, that is a backpack (or some pastry, festive graphical modification allowing).
tplayer
the player
See also
AvatarAction.ObjectDelete
AvatarAction.Release
AvatarServiceMessage
FriskDeadBody
GUIDTask.unregisterPlayer
ObjectDeleteMessage
WellLootedDeadBody
Zone.Corpse.Add
def RedrawDeployableIcons(obj: Deployable): Unit
Draw the icon for this deployable object.

When a client first joins a zone, all deployables are drawn on the continent map once.
Draw the icon for this deployable object.

When a client first joins a zone, all deployables are drawn on the continent map once. Should the player place any deployables, those deployables belong to that player. Ownership causes icon to be drawn in yellow to the player (as opposed to a white icon) and that signifies a certain level of control over the deployable, at least the ability to quietly deconstruct it. Under normal death/respawn cycles while the player is in a given zone, the map icons for owned deployables ramin manipulable to that given user. They do not havwe to be redrawn to stay accurate. Upon leaving a zone, where the icons are erased, and returning back to the zone, where they are drawn again, the deployables that a player owned should be restored in terms of their map icon visibility. This control can not be recovered, however, until they are updated with the player's globally unique identifier. Since the player does not need to redraw his own deployable icons each time he respawns, but will not possess a valid GUID for that zone until he spawns in it at least once, this function is swapped with another after the first spawn in any given zone. This function is restored upon transferring zones.
obj
a Deployable object
See also
DontRedrawIcons
SetCurrentAvatar
def RemoveBoomerTriggersFromInventory(): List[BoomerTrigger]
Search through the player's holsters and their inventory space and remove all BoomerTrigger objects, both functionally and visually.
Search through the player's holsters and their inventory space and remove all BoomerTrigger objects, both functionally and visually.
returns
all discovered BoomTrigger objects
def RequestSanctuaryZoneSpawn(tplayer: Player, currentZone: Int): Unit
Attempt to tranfer to the player's faction-specific sanctuary continent.
Attempt to tranfer to the player's faction-specific sanctuary continent. If the server thinks the player is already on his sanctuary continent, and dead, it will disconnect the player under the assumption that an error has occurred. Eventually, this functionality should support better error-handling before it jumps to the conclusion: "Disconnecting the client is the safest option."
tplayer
the player
currentZone
the current zone number
See also
Zones.SanctuaryZoneNumber
def ResolveProjectileInteraction(projectile: Projectile, resolution: objects.vital.base.DamageResolution.Value, target: PlanetSideGameObject with FactionAffinity with Vitality, pos: Vector3): Option[DamageInteraction]
na
na
projectile
the projectile object
resolution
the resolution status to promote the projectile
returns
a copy of the projectile
def ResolveProjectileInteraction(projectile: Projectile, index: Int, resolution: objects.vital.base.DamageResolution.Value, target: PlanetSideGameObject with FactionAffinity with Vitality, pos: Vector3): Option[DamageInteraction]
Find a projectile with the given globally unique identifier and mark it as a resolved shot.
Find a projectile with the given globally unique identifier and mark it as a resolved shot.
projectile
the projectile object
index
where the projectile was found
resolution
the resolution status to promote the projectile
returns
a copy of the projectile
def ResolveProjectileInteraction(projectile_guid: PlanetSideGUID, resolution: objects.vital.base.DamageResolution.Value, target: PlanetSideGameObject with FactionAffinity with Vitality, pos: Vector3): Option[DamageInteraction]
Find a projectile with the given globally unique identifier and mark it as a resolved shot.
Find a projectile with the given globally unique identifier and mark it as a resolved shot. A Resolved shot has either encountered an obstacle or is being cleaned up for not finding an obstacle.
projectile_guid
the projectile GUID
resolution
the resolution status to promote the projectile
returns
the projectile
def RespawnClone(tplayer: Player): Player
Produce a clone of the player that is equipped with the default infantry loadout.
Produce a clone of the player that is equipped with the default infantry loadout. The loadout is hardcoded. The player is expected to be in a Standard Exo-Suit.
tplayer
the original player
returns
the duplication of the player, in Standard Exo-Suit and with default equipment loadout
def RespawnSquadSetup(): Unit
These messages are used during each subsequent respawn to reset the squad colors on player nameplates and marquees.
These messages are used during each subsequent respawn to reset the squad colors on player nameplates and marquees. By using squadUI to maintain relevant information about squad members, especially the unique character identifier number, only the zone-specific squad members will receive the important messages about their squad member's spawn.
def SendPlanetsideAttributeMessage(target_guid: PlanetSideGUID, attribute_number: PlanetsideAttributeEnum, attribute_value: Long): Unit
Send a PlanetsideAttributeMessage packet to the client
Send a PlanetsideAttributeMessage packet to the client
target_guid
The target of the attribute
attribute_number
The attribute number
attribute_value
The attribute value
def ServerVehicleLock(vehicle: Vehicle): Unit
Lock all applicable controls of the current vehicle.
Lock all applicable controls of the current vehicle. This includes forward motion, turning, and, if applicable, strafing.
vehicle
the vehicle being controlled
def ServerVehicleLockReverse(): Unit
This function is applied to vehicles that are leaving a cargo vehicle's cargo hold to auto reverse them out Lock all applicable controls of the current vehicle Set the vehicle to move in reverse
def ServerVehicleLockStrafeLeft(): Unit
This function is applied to vehicles that are leaving a cargo vehicle's cargo hold to strafe left out of the cargo hold for vehicles that are mounted sideways e.g.
This function is applied to vehicles that are leaving a cargo vehicle's cargo hold to strafe left out of the cargo hold for vehicles that are mounted sideways e.g. router/BFR Lock all applicable controls of the current vehicle Set the vehicle to strafe left
def ServerVehicleLockStrafeRight(): Unit
This function is applied to vehicles that are leaving a cargo vehicle's cargo hold to strafe right out of the cargo hold for vehicles that are mounted sideways e.g.
This function is applied to vehicles that are leaving a cargo vehicle's cargo hold to strafe right out of the cargo hold for vehicles that are mounted sideways e.g. router/BFR Lock all applicable controls of the current vehicle Set the vehicle to strafe right
def ServerVehicleOverride(vehicle: Vehicle, speed: Int = 0, flight: Int = 0): Unit
Place the current vehicle under the control of the server's commands.
Place the current vehicle under the control of the server's commands.
vehicle
the vehicle
speed
how fast the vehicle is moving forward
flight
whether the vehicle is ascending or not, if the vehicle is an applicable type
def SetCurrentAvatarNormally(tplayer: Player): Unit
Instruct the client to treat this player as the avatar.
Instruct the client to treat this player as the avatar.
tplayer
the target player
See also
SetCurrentAvatar
def SquadMembersInZone(members: Iterable[Long]): Iterable[Player]
For the listed squad member unique character identifier numbers, find and return all squad members in the current zone.
For the listed squad member unique character identifier numbers, find and return all squad members in the current zone.
members
members of the squad to target
returns
a list of Player objects
def SquadUpdates(): Unit
def StartUsingProximityUnit(terminal: Terminal with ProximityUnit, target: PlanetSideGameObject): Unit
Queue a proximity-based service.
Queue a proximity-based service.
terminal
the proximity-based unit
target
the entity that is being considered for terminal operation
def StopUsingProximityUnit(terminal: Terminal with ProximityUnit): Unit
Stop using a proximity-base service.
Stop using a proximity-base service. If the suggested terminal detects our player or our player's vehicle as a valid target for its effect, inform it that we wish it stop affecting the discovered target(s).
terminal
the proximity-based unit
def SwapSquadUIElements(squad: Squad, fromIndex: Int, toIndex: Int): Unit
def ToggleMaxSpecialState(enable: Boolean): Unit
def ToggleTeleportSystem(router: Vehicle, systemPlan: Option[(InternalTelepad, TelepadDeployable)]): Unit
Attempt to link the router teleport system using the provided terminal information.
Attempt to link the router teleport system using the provided terminal information. Although additional states are necessary to properly use the teleportation system, e.g., deployment state, active state of the endpoints, etc., this decision is not made factoring those other conditions.
router
the vehicle that houses one end of the teleportation system (the InternalTelepad object)
systemPlan
specific object identification of the two endpoints of the teleportation system; if absent, the knowable endpoint is deleted from the client reflexively
def TotalDriverVehicleControl(vehicle: Vehicle): Unit
def TryDisposeOfLootedCorpse(obj: Player): Boolean
If the corpse has been well-looted, remove it from the ground.
If the corpse has been well-looted, remove it from the ground.
obj
the corpse
returns
true, if the obj is actually a corpse and has no objects in its holsters or backpack; false, otherwise
def TurnCounterDuringInterim(guid: PlanetSideGUID): Unit
During the interim period between the avatar being in one place/zone and completing the process of transitioning to another place/zone, the upstream message counter is zero'd awaiting new activity from the client.
During the interim period between the avatar being in one place/zone and completing the process of transitioning to another place/zone, the upstream message counter is zero'd awaiting new activity from the client. Until new upstream messages that pass some tests against their data start being reported, the counter does not accumulate properly.
guid
the player's globally unique identifier number
def TurnCounterDuringInterimWhileInPassengerSeat(guid: PlanetSideGUID): Unit
During the interim period between the avatar being in one place/zone and completing the process of transitioning to another place/zone, the upstream message counter is zero'd awaiting new activity from the client.
During the interim period between the avatar being in one place/zone and completing the process of transitioning to another place/zone, the upstream message counter is zero'd awaiting new activity from the client. Until new upstream messages that pass some tests against their data start being reported, the counter does not accumulate properly.

In the case that the transitioning player is seated in a vehicle mount that is not the driver and does not have a mounted weapon under its control, no obvious feedback will be provided by the client. For example, when as infantry, a PlayerStateMessageUpstream packet is dispatched by the client. For example, when in the driver mount, a VehicleStateMessage is dispatched by the client. In the given case, the only packet that indicates the player is seated is a KeepAliveMessage. Detection of this KeepALiveMessage, for the purpose of transitioning logic, can not be instantaneous to the zoning process or other checks for proper zoning conditions that will be disrupted. To avoid complications, the player in such a mount is initially spawned as infantry on their own client, realizes the state transition confirmation for infantry (turn counter), and is forced to transition into being seated, and only at that time will begin registering KeepAliveMessage to mark the end of their interim period.
guid
the player's globally unique identifier number
def TurnPlayerIntoCorpse(tplayer: Player, zone: Zone): Unit
Creates a player that has the characteristics of a corpse.
Creates a player that has the characteristics of a corpse. To the game, that is a backpack (or some pastry, festive graphical modification allowing). A player who has been kicked may not turn into a corpse.
tplayer
the player
See also
AvatarAction.Release
AvatarServiceMessage
CorpseConverter.converter
DepictPlayerAsCorpse
Player.Release
Zone.AvatarEvents
Zone.Corpse.Add
Zone.Population
def UnaccessContainer(container: Container): Unit
For the target container, initiate protocol to release it from "access".
def UnaccessContainer(): Unit
For whatever conatiner the character considers itself accessing, initiate protocol to release it from "access".
def UnaccessContainerChannel(events: ActorRef, channel: String): Unit
Leave an entity-specific group for shared updates.
Leave an entity-specific group for shared updates.
events
the event system bus to which to subscribe
channel
the channel name
def UnaccessCorpseContainer(tplayer: Player): Unit
Common preparation for disengaging from a corpse.
Common preparation for disengaging from a corpse. Leave the corpse-specific group that was used for shared updates. Deconstruct every object in the backpack's inventory.
tplayer
the corpse
def UnaccessGenericContainer(container: Container): Unit
def UnaccessVehicleContainer(vehicle: Vehicle): Unit
Common preparation for disengaging from a vehicle.
Common preparation for disengaging from a vehicle. Leave the vehicle-specific group that was used for shared updates. Deconstruct every object in the vehicle's inventory.
vehicle
the vehicle
def UpdateDeployableUIElements(list: List[(Int, Int, Int, Int)]): Unit
Initialize the deployables user interface elements.

All element initializations require both the maximum deployable amount and the current deployables active counts.
Initialize the deployables user interface elements.

All element initializations require both the maximum deployable amount and the current deployables active counts. Until initialized, all elements will be RED 0/0 as if the corresponding certification were not learned. The respective element will become a pair of numbers, the second always being non-zero, when properly initialized. The numbers will appear GREEN when more deployables of that type can be placed. The numbers will appear RED if the player can not place any more of that type of deployable. The numbers will appear YELLOW if the current deployable count is greater than the maximum count of that type such as may be the case when a player forgets a certification.
list
a tuple of each UI element with four numbers; even numbers are attribute ids; odd numbers are quantities; first pair is current quantity; second pair is maximum quantity
def UpdatePersistence(persistRef: ActorRef)(): Unit
Update this player avatar for persistence.
Update this player avatar for persistence. Set this to persistFunc when persistence is ready.
persistRef
reference to the persistence monitor
def UpdatePersistenceAndRefs(): Unit
Update this player avatar for persistence.
Update this player avatar for persistence. Set to persist when (new) player is loaded.
def UpdatePersistenceOnly(): Unit
Update this player avatar for persistence.
Update this player avatar for persistence. Set to persist initially.
def UpdateWeaponAtSeatPosition(objWithSeat: MountableWeapons, seatNum: Int): Unit
From a mount, find the weapon controlled from it, and update the ammunition counts for that weapon's magazines.
From a mount, find the weapon controlled from it, and update the ammunition counts for that weapon's magazines.
objWithSeat
the object that owns seats (and weaponry)
seatNum
the mount
def UseRouterTelepadEffect(playerGUID: PlanetSideGUID, srcGUID: PlanetSideGUID, destGUID: PlanetSideGUID): Unit
Animate(?) a player using a fully-linked Router teleportation system.
Animate(?) a player using a fully-linked Router teleportation system. In reality, this seems to do nothing visually?
playerGUID
the player being teleported
srcGUID
the origin of the teleportation
destGUID
the destination of the teleportation
def UseRouterTelepadSystem(router: Vehicle, internalTelepad: InternalTelepad, remoteTelepad: TelepadDeployable, src: PlanetSideGameObject with TelepadLike, dest: PlanetSideGameObject with TelepadLike): Unit
A player uses a fully-linked Router teleportation system.
A player uses a fully-linked Router teleportation system.
router
the Router vehicle
internalTelepad
the internal telepad within the Router vehicle
remoteTelepad
the remote telepad that is currently associated with this Router
src
the origin of the teleportation (where the player starts)
dest
the destination of the teleportation (where the player is going)
def ValidObject(id: Option[PlanetSideGUID], decorator: String): Option[PlanetSideGameObject]
def ValidObject(id: Option[PlanetSideGUID]): Option[PlanetSideGameObject]
def ValidObject(id: PlanetSideGUID, decorator: String): Option[PlanetSideGameObject]
def ValidObject(id: PlanetSideGUID): Option[PlanetSideGameObject]
def ValidObject(id: Int, decorator: String): Option[PlanetSideGameObject]
def ValidObject(id: Int): Option[PlanetSideGameObject]
def WellLootedDeadBody(obj: Player): Boolean
If the corpse has been well-looted, it has no items in its primary holsters nor any items in its inventory.
If the corpse has been well-looted, it has no items in its primary holsters nor any items in its inventory.
obj
the corpse
returns
true, if the obj is actually a corpse and has no objects in its holsters or backpack; false, otherwise
def ZoneChangeSquadSetup(): Unit
These messages are used during each subsequent respawn to reset the squad colors on player nameplates and marquees.
These messages are used during each subsequent respawn to reset the squad colors on player nameplates and marquees. During a zone change, on top of other squad mates in the zone needing to have their knowledge of this player's squad colors changed, the player must also set squad colors for each other squad members. Default respawn functionality may resume afterwards.
def ZoningStartInitialMessageAndTimer(): (Int, String)
The primary method of determination involves the faction affinity of the most favorable available region subset, e.g., in the overlapping sphere of influences of a friendly field tower and an enemy major facility, the time representative of the the tower has priority.
The primary method of determination involves the faction affinity of the most favorable available region subset, e.g., in the overlapping sphere of influences of a friendly field tower and an enemy major facility, the time representative of the the tower has priority. When no spheres of influence are being encroached, one is considered "in the wilderness". The messaging is different but the location is normally treated the same as if in a neutral sphere of influence. Being anywhere in one's faction's own sanctuary is a special case.
returns
a Tuple composed of the initial countdown time and the descriptor for message composition
var _session: Session
var accessedContainer: Option[PlanetSideGameObject with Container]
def account: Account
var accountIntermediary: ActorRef
var accountPersistence: ActorRef
var amsSpawnPoints: List[SpawnPoint]
def aroundPostRestart(reason: Throwable): Unit
Attributes
protected[akka]
Definition Classes
Actor
Annotations
@InternalApi()
def aroundPostStop(): Unit
Attributes
protected[akka]
Definition Classes
Actor
Annotations
@InternalApi()
def aroundPreRestart(reason: Throwable, message: Option[Any]): Unit
Attributes
protected[akka]
Definition Classes
Actor
Annotations
@InternalApi()
def aroundPreStart(): Unit
Attributes
protected[akka]
Definition Classes
Actor
Annotations
@InternalApi()
def aroundReceive(receive: akka.actor.Actor.Receive, msg: Any): Unit
Attributes
protected[akka]
Definition Classes
MDCContextAware → Actor
final def asInstanceOf[T0]: T0
Definition Classes
Any
def attemptRecoveryFromInventoryDisarrayException(inv: GridInventory): Unit
def attemptRecoveryFromNoGuidExceptionAsPlayer(p: Player, e: Throwable): Directive
def attemptRecoveryFromNoGuidExceptionAsVehicle(v: Vehicle, e: Throwable): Directive
def avatar: Avatar
var avatarActor: ActorRef[Command]
def avatarLoginResponse(avatar: Avatar): Unit
During login, when the avatar is set, the response code sets up session and deployable toolbox stats.
During login, when the avatar is set, the response code sets up session and deployable toolbox stats. Immediately contact the interstellar cluster to deal with zoning conditions. Only call this once during login and never any time after that.
avatar
the avatar being set as the current one belonging to this session
def beginZoningCountdown(runnable: Runnable): Unit
A zoning message was received.
A zoning message was received. That doesn't matter. In what stage of the zoning determination process is the client, and what is the next stage.

To perform any actions involving zoning, an initial request must have been dispatched and marked as dispatched. When invoked after, the process will switch over to a countdown of time until the zoning actually occurs. The origin will be evaluated based on comparison of faction affinity with the client's player and from that an initial time and a message will be generated. Afterwards, the process will queue another inquiry for another zoning response. Each time 5s of the countdown passes, another message will be sent and received; and, this is another pass of the countdown.

Once the countdown reaches 0, the transportation that has been promised by the zoning attempt may begin.
runnable
execute for the next step of the zoning process
var chatActor: ActorRef[Command]
var clientKeepAlive: Cancellable
def clone(): AnyRef
Attributes
protected[lang]
Definition Classes
AnyRef
Annotations
@throws(classOf[java.lang.CloneNotSupportedException]) @native()
var cluster: ActorRef[Command]
val collisionHistory: HashMap[ActorRef, Long]
def configAmenityAsDestroyed(amenity: Amenity): Unit
Configure the specific destroyed amenity by sending the client packets.
Configure the specific destroyed amenity by sending the client packets. These actions are performed during the loading of a zone.
amenity
the facility object
See also
Generator
ImplantTerminalMech
PlanetsideAttributeMessage
PlanetSideGameObject.Destroyed
def configAmenityAsWorking(amenity: Amenity): Unit
Configure the specific working amenity by sending the client packets.
Configure the specific working amenity by sending the client packets. Amenities that are not Damageable are also included. These actions are performed during the loading of a zone.
amenity
the facility object
See also
Door
GenericObjectStateMsg
Hackable
HackObject
PlanetsideAttributeMessage
ResourceSilo
SetEmpireMessage
VitalityDefinition.Damageable
def configZone(zone: Zone): Unit
Configure the buildings and each specific amenity for that building in a given zone by sending the client packets.
Configure the buildings and each specific amenity for that building in a given zone by sending the client packets. These actions are performed during the loading of a zone.
zone
the zone being loaded
See also
SetEmpireMessage
PlanetsideAttributeMessage
HackMessage
var connectionState: Int
implicit val context: ActorContext
Definition Classes
Actor
def continent: Zone
var deadState: packet.game.DeadState.Value
var drawDeloyableIcon: (PlanetSideGameObject with Deployable) => Unit
final def eq(arg0: AnyRef): Boolean
Definition Classes
AnyRef
def equals(arg0: AnyRef): Boolean
Definition Classes
AnyRef → Any
def failWithError(error: String): Unit
def fallHeightTracker(zHeight: Float): Unit
def finalize(): Unit
Attributes
protected[lang]
Definition Classes
AnyRef
Annotations
@throws(classOf[java.lang.Throwable])
var flying: Boolean
var galaxyService: ActorRef
final def getClass(): Class[_ <: AnyRef]
Definition Classes
AnyRef → Any
Annotations
@native()
def handleGamePkt(pkt: PlanetSideGamePacket): Any
def hashCode(): Int
Definition Classes
AnyRef → Any
Annotations
@native()
var heightHistory: Float
var heightLast: Float
var heightTrend: Boolean
def initBuilding(continentNumber: Int, buildingNumber: Int, building: Building): Unit
For a given continental structure, determine the method of generating server-join client configuration packets.
For a given continental structure, determine the method of generating server-join client configuration packets.
continentNumber
the zone id
buildingNumber
the building id
building
the building object
def initFacility(continentNumber: Int, buildingNumber: Int, building: Building): Unit
For a given facility structure, configure a client by dispatching the appropriate packets.
For a given facility structure, configure a client by dispatching the appropriate packets.
continentNumber
the zone id
buildingNumber
the building id
building
the building object
See also
BuildingInfoUpdateMessage
DensityLevelUpdateMessage
def initGate(continentNumber: Int, buildingNumber: Int, building: Building): Unit
For a given lattice warp gate structure, configure a client by dispatching the appropriate packets.
For a given lattice warp gate structure, configure a client by dispatching the appropriate packets. Unlike other facilities, gates do not have complicated BuildingInfoUpdateMessage packets. Also unlike facilities, gates have an additional packet.
continentNumber
the zone id
buildingNumber
the building id
building
the building object
See also
BuildingInfoUpdateMessage
DensityLevelUpdateMessage
BroadcastWarpgateUpdateMessage
var instantActionFallbackDestination: Option[Located]
var interimUngunnedVehicle: Option[PlanetSideGUID]
var interimUngunnedVehicleSeat: Option[Int]
var interstellarFerry: Option[Vehicle]
used during zone transfers to maintain reference to seated vehicle (which does not yet exist in the new zone) used during intrazone gate transfers, but not in a way distinct from prior zone transfer procedures should only be set during the transient period when moving between one spawn point and the next leaving set prior to a subsequent transfers may cause unstable vehicle associations, with memory leak potential
var interstellarFerryTopLevelGUID: Option[PlanetSideGUID]
used during zone transfers for cleanup to refer to the vehicle that instigated a transfer "top level" is the carrier in a carrier/ferried association or a projected carrier/(ferried carrier)/ferried association inherited from parent (carrier) to child (ferried) through the TransferPassenger message the old-zone unique identifier for the carrier no harm should come from leaving the field set to an old unique identifier value after the transfer period
def isAcceptableNextSpawnPoint(): Boolean
def isAcceptableSpawnPoint(spawnPoint: Option[SpawnPoint]): Boolean
def isAcceptableSpawnPoint(spawnPoint: SpawnPoint): Boolean
final def isInstanceOf[T0]: Boolean
Definition Classes
Any
var keepAliveFunc: () => Unit
var kitToBeUsed: Option[PlanetSideGUID]
var lastTerminalOrderFulfillment: Boolean
var lfsm: Boolean
When joining or creating a squad, the original state of the avatar's internal LFS variable is blanked.
When joining or creating a squad, the original state of the avatar's internal LFS variable is blanked. This WorldSessionActor-local variable is then used to indicate the ongoing state of the LFS UI component, now called "Looking for Squad Member." Only the squad leader may toggle the LFSM marquee. Upon leaving or disbanding a squad, this value is made false. Control switching between the Avatar-local and the WorldSessionActor-local variable is contingent on squadUI being populated.
var loadConfZone: Boolean
def log: LoggingAdapter
Definition Classes
ActorLogging
final def ne(arg0: AnyRef): Boolean
Definition Classes
AnyRef
var nextSpawnPoint: Option[SpawnPoint]
var noSpawnPointHere: Boolean
final def notify(): Unit
Definition Classes
AnyRef
Annotations
@native()
final def notifyAll(): Unit
Definition Classes
AnyRef
Annotations
@native()
var oldRefsMap: HashMap[PlanetSideGUID, String]
def performAvatarAwardMessageDelivery(messageBundles: Iterable[Iterable[PlanetSidePacket]], delay: Long): Unit
Coordinate timed dispatches of groups of packets.
Coordinate timed dispatches of groups of packets.
messageBundles
groups of packets to be dispatched
delay
dispatch packet divisions in intervals
var persist: () => Unit
var persistFunc: () => Unit
def player: Player
var populateAvatarAwardRibbonsFunc: (Int, Long) => Unit
def postRestart(reason: Throwable): Unit
Definition Classes
Actor
Annotations
@throws(classOf[java.lang.Exception])
def postStop(): Unit
Definition Classes
SessionActor → Actor
def preRestart(reason: Throwable, message: Option[Any]): Unit
Definition Classes
Actor
Annotations
@throws(classOf[java.lang.Exception])
def preStart(): Unit
Definition Classes
Actor
Annotations
@throws(classOf[java.lang.Exception])
var prefire: Set[PlanetSideGUID]
var progressBarUpdate: Cancellable
var progressBarValue: Option[Float]
val projectiles: Array[Option[Projectile]]
var propertyOverrideManager: ActorRef
val queuedSquadActions: Seq[() => Unit]
def receive: Receive
Definition Classes
SessionActor → Actor
var recentTeleportAttempt: Long
var respawnTimer: Cancellable
var reviveTimer: Cancellable
implicit final val self: ActorRef
Definition Classes
Actor
def sendResponse(packet: PlanetSidePacket): Unit
final def sender(): ActorRef
Definition Classes
Actor
var serverTime: Long
var serverVehicleControlVelocity: Option[Int]
val serviceManager: ActorRef
def session: Session
def session_=(session: Session): Unit
var setAvatar: Boolean
var setCurrentAvatarFunc: (Player) => Unit
def setupAvatarAwardMessageDelivery(tplayer: Player, bundleSize: Int, delay: Long): Unit
Extract the merit commendation advancement information from a player character, filter unnecessary or not applicable statistics, translate the information into packet data, and coordinate timed dispatches of groups of packets.
Extract the merit commendation advancement information from a player character, filter unnecessary or not applicable statistics, translate the information into packet data, and coordinate timed dispatches of groups of packets.
tplayer
the player character
bundleSize
divide packets into groups of this size
delay
dispatch packet divisions in intervals
def setupAvatarAwardMessageDelivery(bundleSize: Int, delay: Long): Unit
Extract the award advancement information from a player character, and coordinate timed dispatches of groups of packets.
Extract the award advancement information from a player character, and coordinate timed dispatches of groups of packets.
bundleSize
divide packets into groups of this size
delay
dispatch packet divisions in intervals
var setupAvatarFunc: () => Unit
var shiftOrientation: Option[Vector3]
var shiftPosition: Option[Vector3]
var shooting: Set[PlanetSideGUID]
var shootingStart: HashMap[PlanetSideGUID, Long]
var shootingStop: HashMap[PlanetSideGUID, Long]
var shotsWhileDead: Int
def skipAvatarAwardMessageDelivery(bundleSize: Int, delay: Long): Unit
Don't extract the award advancement information from a player character upon respawning or zoning.
Don't extract the award advancement information from a player character upon respawning or zoning. You only need to perform that population once at login.
bundleSize
it doesn't matter
delay
it doesn't matter
var specialItemSlotGuid: Option[PlanetSideGUID]
var squadService: ActorRef
var squadSetup: () => Unit
val squadUI: LongMap[SquadUIElement]
var squadUpdateCounter: Int
var squad_supplement_id: Int
def suicide(tplayer: Player): Unit
The player has lost the will to live and must be killed.
The player has lost the will to live and must be killed.
tplayer
the player to be killed
See also
Vitality
PlayerSuicide
def supervisorStrategy: SupervisorStrategy
Definition Classes
SessionActor → Actor
final def synchronized[T0](arg0: => T0): T0
Definition Classes
AnyRef
def taskThenZoneChange(task: TaskBundle, zoneMessage: FindZone): TaskBundle
Before changing zones, perform the following task (which can be a nesting of subtasks).
def toString(): String
Definition Classes
AnyRef → Any
var turnCounterFunc: (PlanetSideGUID) => Unit
def unhandled(message: Any): Unit
Definition Classes
Actor
lazy val unsignedIntMaxValue: Long
def updateBlockMap(target: BlockMapEntity, zone: Zone, newCoords: Vector3): Unit
def updateOldRefsMap(item: PlanetSideGameObject): IterableOnce[(PlanetSideGUID, String)]
def updateOldRefsMap(inventory: GridInventory): IterableOnce[(PlanetSideGUID, String)]
def updateOldRefsMap(): Unit
var updateSquad: () => Unit
var upstreamMessageCount: Int
Upstream message counter
Checks for server acknowledgement of the following messages in the following conditions:
PlayerStateMessageUpstream (infantry)
VehicleStateMessage (driver mount only)
ChildObjectStateMessage (any gunner mount that is not the driver)
KeepAliveMessage (any passenger mount that is not the driver)
As they should arrive roughly every 250 milliseconds this allows for a very crude method of scheduling tasks up to four times per second
var usingMedicalTerminal: Option[PlanetSideGUID]
final def wait(): Unit
Definition Classes
AnyRef
Annotations
@throws(classOf[java.lang.InterruptedException])
final def wait(arg0: Long, arg1: Int): Unit
Definition Classes
AnyRef
Annotations
@throws(classOf[java.lang.InterruptedException])
final def wait(arg0: Long): Unit
Definition Classes
AnyRef
Annotations
@throws(classOf[java.lang.InterruptedException]) @native()
var waypointCooldown: Long
def writeLogException(e: Throwable): Directive
def writeLogExceptionAndStop(e: Throwable): Directive
var zoneLoaded: Option[Boolean]
a flag for the zone having finished loading during zoning None when no zone is loaded Some(true) when a zone has successfully loaded Some(false) when the loading process has failed or was executed but did not complete for some reason
var zoneReload: Boolean
a flag that forces the current zone to reload itself during a zoning operation
var zoningChatMessageType: ChatMessageType
var zoningCounter: Int
var zoningStatus: objects.zones.Zoning.Status.Value
var zoningTimer: Cancellable
var zoningType: objects.zones.Zoning.Method.Value

Packages

SessionActor

Companion object SessionActor

class SessionActor extends Actor with MDCContextAware

Instance Constructors

Type Members

Value Members

Inherited from MDCContextAware

Inherited from ActorLogging

Inherited from Actor

Inherited from AnyRef

Inherited from Any

Ungrouped

Packages

SessionActor

Companion object SessionActor

class SessionActor extends Actor with MDCContextAware

Instance Constructors

Type Members

Value Members

Inherited from MDCContextAware

Inherited from ActorLogging

Inherited from Actor

Inherited from AnyRef

Inherited from Any

Ungrouped

SessionActor