# PSF-LoginServer - master - net.psforever.actors.session.SessionActor
PSF - LoginServer - master - net.psforever.actors.session.SessionActor
Keywords: PSF LoginServer master net.psforever.actors.session.SessionActor

PSF-LoginServer - master < Back


# Packages

-  package root
  Definition Classes
    root
-  package net
  Definition Classes
    root
-  package psforever
  Definition Classes
    net
-  package actors
  Definition Classes
    psforever
-  package session
  Definition Classes
    actors
- AvatarActor
- ChatActor
- SessionActor

c

net.psforever.actors.session

# SessionActor 

###
Companion object SessionActor

#### class SessionActor extends Actor with MDCContextAware

Source
  SessionActor.scala

Linear Supertypes
MDCContextAware, ActorLogging, Actor, AnyRef, Any

Ordering

1. Alphabetic
2. By Inheritance

Inherited

1. SessionActor
2. MDCContextAware
3. ActorLogging
4. Actor
5. AnyRef
6. Any

1. Hide All
2. Show All

Visibility

1. Public
2. Protected

### Instance Constructors

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

### Type Members

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

### Value Members

1.  final def !=(arg0: Any): Boolean
   Definition Classes
     AnyRef → Any
2.  final def ##: Int
   Definition Classes
     AnyRef → Any
3.  final def ==(arg0: Any): Boolean
   Definition Classes
     AnyRef → Any
4.  def AccessContainer(container: Container): Unit
5.  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

6.  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`

7.  def AccessGenericContainer(container: PlanetSideServerObject with Container): Unit
8.  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`

9.  def AdministrativeKick(tplayer: Player): Unit
10.  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

11.  def ArmorRepairAction(tplayer: Player, repairValue: Int = 10): Boolean

    Restore, at most, a specific amount of personal armor points on a player.

    Restore, at most, a specific amount of personal armor points on a player. Send messages to connected client and to events system.

    tplayer

      the player

    repairValue

      the amount to repair; 10 by default

    returns

      whether the player can be repaired for any more armor points

12.  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.

13.  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`

14.  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.

15.  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

16.  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`

17.  def CancelZoningProcess(): Unit

    The user no longer expects to perform a zoning event, or the process is merely resetting its internal state.

18.  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

19.  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 `zoningChatMessageType`s defaults to `None`

20.  def CapacitorTick(jump_thrust: Boolean): Unit
21.  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`

22.  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`

23.  def CheckForHitPositionDiscrepancy(projectile_guid: PlanetSideGUID, hitPos: Vector3, target: PlanetSideGameObject with FactionAffinity with Vitality): Unit
24.  def CleanUpRemoteProjectile(projectile_guid: PlanetSideGUID, projectile: Projectile, local_index: Int): Unit

    For a given registered remote projectile, perform all the actions necessary to properly dispose of it.

    For a given registered remote projectile, perform all the actions necessary to properly dispose of it. Those actions involve: informing that the projectile should explode, unregistering the projectile's globally unique identifier, and managing the projectiles's local status information.

    projectile_guid

      the globally unique identifier of the projectile

    projectile

      the projectile

    local_index

      an index of the absolute sequence of the projectile, for internal lists

25.  def CleanUpRemoteProjectile(projectile_guid: PlanetSideGUID, projectile: Projectile): Unit

    For a given registered remote projectile, perform all the actions necessary to properly dispose of it.

    For a given registered remote projectile, perform all the actions necessary to properly dispose of it. Those actions involve: informing that the projectile should explode, unregistering the projectile's globally unique identifier, and managing the projectiles's local status information.

    projectile_guid

      the globally unique identifier of the projectile

    projectile

      the projectile

    See also

      `CleanUpRemoteProjectile(PlanetSideGUID, Projectile, Int)`

26.  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

27.  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

28.  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

29.  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`

30.  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

31.  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

32.  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

33.  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`

34.  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`

35.  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`

36.  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

37.  def DropSpecialSlotItem(): Unit
38.  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)

39.  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

40.  def FindContainedEquipment: (Option[PlanetSideGameObject with Container], Option[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

41.  def FindContainedWeapon: (Option[PlanetSideGameObject with Container], Option[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

42.  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

43.  def FindEquipment: Option[Equipment]

    Runs `FindContainedEquipment` but ignores the `Container` object output.

    Runs `FindContainedEquipment` but ignores the `Container` object output.

    returns

      an `Equipment` object

44.  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`

45.  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

46.  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

47.  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

48.  def FindProximityUnitTargetsInScope(terminal: Terminal with ProximityUnit): Seq[PlanetSideGameObject]

    na

    na

    terminal

      na

    returns

      na

49.  def FindWeapon: Option[Tool]

    Runs `FindContainedWeapon` but ignores the `Container` object output.

    Runs `FindContainedWeapon` but ignores the `Container` object output.

    returns

      a `Tool` object

50.  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

51.  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.

52.  def ForgetAllProximityTerminals(term_guid: PlanetSideGUID): Unit

    na

53.  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

54.  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`

55.  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)

56.  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`

57.  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`

58.  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

59.  def GiveSquadColorsInZone(): Unit

    Allocate all squad members in zone and give their nameplates and their marquees the appropriate squad color.

60.  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`

61.  def HackObject(target_guid: PlanetSideGUID, unk1: Long, unk2: Long): Unit

    na

    na

    target_guid

      na

    unk1

      na

    unk2

      na

62.  def HandleAvatarServiceResponse(toChannel: String, guid: PlanetSideGUID, reply: Response): Unit

    na

    na

    toChannel

      na

    guid

      na

    reply

      na

63.  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`

64.  def HandleLocalServiceResponse(toChannel: String, guid: PlanetSideGUID, reply: Response): Unit

    na

    na

    toChannel

      na

    guid

      na

    reply

      na

65.  def HandleMountMessages(tplayer: Player, reply: Exchange): Unit

    na

    na

    tplayer

      na

    reply

      na

66.  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`

67.  def HandleProximityTerminalUse(terminal: Terminal with ProximityUnit): Unit

    na

    na

    terminal

      na

68.  def HandleReleaseAvatar(tplayer: Player, zone: Zone): Unit

    na

    na

    tplayer

      na

    zone

      na

69.  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

70.  def HandleTerminalMessage(tplayer: Player, msg: ItemTransactionMessage, order: Exchange): Unit

    na

    na

    tplayer

      na

    msg

      na

    order

      na

71.  def HandleVehicleServiceResponse(toChannel: String, guid: PlanetSideGUID, reply: Response): Unit

    na

    na

    toChannel

      na

    guid

      na

    reply

      na

72.  def HandleWeaponFire(weaponGUID: PlanetSideGUID, projectileGUID: PlanetSideGUID, shotOrigin: Vector3, shotVelocity: Option[Vector3]): Unit
73.  def HandleWeaponFireAccountability(weaponGUID: PlanetSideGUID, projectileGUID: PlanetSideGUID): (Option[PlanetSideGameObject with Container], Option[Tool])
74.  def HealAction(tplayer: Player, healValue: Int = 10): Boolean

    Restore, at most, a specific amount of health points on a player.

    Restore, at most, a specific amount of health points on a player. Send messages to connected client and to events system.

    tplayer

      the player

    healValue

      the amount to heal; 10 by default

    returns

      whether the player can be repaired for any more health points

75.  def HealthAndArmorTerminal(unit: Terminal with ProximityUnit, target: Player): Unit

    When standing on the platform of a(n advanced) medical terminal, resotre the player's health and armor points (when they need their health and armor points restored).

    When standing on the platform of a(n advanced) medical terminal, resotre the player's health and armor points (when they need their health and armor points restored). If the player is both fully healed and fully repaired, stop using the terminal.

    unit

      the medical terminal

    target

      the player being healed

76.  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`

77.  def ImmediateDisconnect(): Unit
78.  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`

79.  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.

80.  def KickedByAdministration(): Unit
81.  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

82.  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.

83.  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

84.  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

85.  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`

86.  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

87.  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

88.  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)

89.  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

90.  def NewItemDrop(obj: PlanetSideServerObject with Container, zone: Zone)(item: Equipment): GiveTask

    Register an `Equipment` item and then drop it on the ground.

    Register an `Equipment` item and then drop it on the ground.

    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

    See also

      `NormalItemDrop`

91.  def NoPersistence(): Unit

    Do not update this player avatar for persistence.

92.  def NoSquadUpdates(): Unit
93.  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

94.  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`

95.  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

96.  def PerformToolAmmoChange(tool: Tool, obj: PlanetSideServerObject with Container): Unit

    na

    na

    tool

      na

    obj

      na

97.  def PeriodicUpdatesWhenEnrolledInSquad(): Unit
98.  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.

99.  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`

100.  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`

101.  def RegisterDrivenVehicle(obj: Vehicle, driver: Player): GiveTask
102.  def RegisterDroppod(vehicle: Vehicle, tplayer: Player): GiveTask

     Use this function to facilitate registering a droppod for a globally unique identifier in the event that the user has instigated an instant action event to a destination within the current zone.
     If going to another zone instead, this is uneccessary as the normal vehicle gating protocol is partially intersected for droppod operation, and will properly register the droppod before introducing it into the new zone without additional concern.

     Use this function to facilitate registering a droppod for a globally unique identifier in the event that the user has instigated an instant action event to a destination within the current zone.
     If going to another zone instead, this is uneccessary as the normal vehicle gating protocol is partially intersected for droppod operation, and will properly register the droppod before introducing it into the new zone without additional concern. The droppod should actually not be completely unregistered. If inquired, it will act like a GUID had already been assigned to it, but it was invalidated. This condition is artificial, but it necessary to pass certain operations related to vehicle gating. Additionally, the driver is only partially associated with the vehicle at this time. `interstellarFerry` is properly keeping track of the vehicle during the transition and the user who is the driver (second param) is properly seated but the said driver does not know about the vehicle through his usual convention - `VehicleSeated` - yet.

     vehicle

       the unregistered droppod

     tplayer

       the player using the droppod for instant action; should already be the driver of the droppod

     returns

       a `TaskResolver.GiveTask` message

     See also

       `GlobalDefinitions.droppod`

       `GUIDTask.RegisterObjectTask`

       `interstellarFerry`

       `Player.VehicleSeated`

       `PlayerLoaded`

       `TaskResolver.GiveTask`

       `Vehicles.Own`

103.  def RegisterProjectile(obj: Projectile): GiveTask

     Construct tasking that adds a completed but unregistered projectile into the scene.

     Construct tasking that adds a completed but unregistered projectile into the scene. After the projectile is registered to the curent zone's global unique identifier system, all connected clients save for the one that registered it will be informed about the projectile's "creation."

     obj

       the projectile to be registered

     returns

       a `TaskResolver.GiveTask` message

104.  def RegisterVehicle(vehicle: Vehicle): GiveTask

     Construct tasking that adds a completed and registered vehicle into the scene.

     Construct tasking that adds a completed and registered vehicle into the scene. Use this function to renew the globally unique identifiers on a vehicle that has already been added to the scene once.

     vehicle

       the `Vehicle` object

     returns

       a `TaskResolver.GiveTask` message

     See also

       `RegisterVehicleFromSpawnPad`

105.  def RegisterVehicleFromSpawnPad(obj: Vehicle, pad: VehicleSpawnPad, terminal: Terminal): GiveTask

     Construct tasking that adds a completed and registered vehicle into the scene.

     Construct tasking that adds a completed and registered vehicle into the scene. The major difference between `RegisterVehicle` and `RegisterVehicleFromSpawnPad` is the assumption that this vehicle lacks an internal `Actor`. Before being finished, that vehicle is supplied an `Actor` such that it may function properly. This function wraps around `RegisterVehicle` and is used in case, prior to this event, the vehicle is being brought into existence from scratch and was never a member of any `Zone`.

     obj

       the `Vehicle` object

     returns

       a `TaskResolver.GiveTask` message

     See also

       `RegisterVehicle`

106.  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

107.  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`

108.  def ReregisterProjectile(obj: Projectile): GiveTask

     If the projectile object is unregistered, register it.

     If the projectile object is unregistered, register it. If the projectile object is already registered, unregister it and then register it again.

     obj

       the projectile to be registered (a second time?)

     returns

       a `TaskResolver.GiveTask` message

     See also

       `RegisterProjectile(Projectile)`

       `UnregisterProjectile(Projectile)`

109.  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

110.  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

111.  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

112.  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

113.  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.

114.  def SelectProximityUnitBehavior(terminal: Terminal with ProximityUnit, target: PlanetSideGameObject): Unit

     Determine which functionality to pursue by a generic proximity-functional unit given the target for its activity.

     Determine which functionality to pursue by a generic proximity-functional unit given the target for its activity.

     terminal

       the proximity-based unit

     target

       the object being affected by the unit

     See also

       `VehicleService:receive, ProximityUnit.Action`

115.  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

116.  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

117.  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

118.  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

119.  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

120.  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

121.  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`

122.  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

123.  def SquadUpdates(): Unit
124.  def StartUsingProximityUnit(terminal: Terminal with ProximityUnit, target: PlanetSideGameObject): Unit

     Queue a proximity-base service.

     Queue a proximity-base service.

     terminal

       the proximity-based unit

     target

       the entity that is being considered for terminal operation

125.  def StopUsingProximityUnit(terminal: Terminal with ProximityUnit): Unit

     Stop using a proximity-base service.

     Stop using a proximity-base service. 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

126.  def SwapSquadUIElements(squad: Squad, fromIndex: Int, toIndex: Int): Unit
127.  def ToggleMaxSpecialState(enable: Boolean): Unit
128.  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

129.  def TotalDriverVehicleControl(vehicle: Vehicle): Unit
130.  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

131.  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

132.  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

133.  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`

134.  def UnaccessContainer(container: Container): Unit

     For the target container, initiate protocol to release it from "access".

135.  def UnaccessContainer(): Unit

     For whatever conatiner the character considers itself accessing, initiate protocol to release it from "access".

136.  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

137.  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

138.  def UnaccessGenericContainer(container: Container): Unit
139.  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

140.  def UnregisterDrivenVehicle(obj: Vehicle, driver: Player): GiveTask
141.  def UnregisterProjectile(obj: Projectile): GiveTask

     Construct tasking that removes a formerly complete and currently registered projectile from the scene.

     Construct tasking that removes a formerly complete and currently registered projectile from the scene. After the projectile is unregistered from the curent zone's global unique identifier system, all connected clients save for the one that registered it will be informed about the projectile's "destruction."

     obj

       the projectile to be unregistered

     returns

       a `TaskResolver.GiveTask` message

142.  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 `learn`ed. 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 `forget`s 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

143.  def UpdatePersistence(persistRef: ActorRef)(): Unit

     Update this player avatar for persistence.

     Update this player avatar for persistence.

     persistRef

       reference to the persistence monitor

144.  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

145.  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

146.  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)

147.  def ValidObject(id: Option[PlanetSideGUID]): Option[PlanetSideGameObject]
148.  def ValidObject(id: PlanetSideGUID): Option[PlanetSideGameObject]
149.  def ValidObject(id: Int): Option[PlanetSideGameObject]
150.  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

151.  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.

152.  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

153.  var _session: Session
154.  var accessedContainer: Option[PlanetSideGameObject with Container]
155.  def account: Account
156.  var accountIntermediary: ActorRef
157.  var accountPersistence: ActorRef
158.  var amsSpawnPoints: List[SpawnPoint]
159.  def aroundPostRestart(reason: Throwable): Unit
     Attributes
       protected[akka]
     Definition Classes
       Actor
     Annotations
       @InternalApi()
160.  def aroundPostStop(): Unit
     Attributes
       protected[akka]
     Definition Classes
       Actor
     Annotations
       @InternalApi()
161.  def aroundPreRestart(reason: Throwable, message: Option[Any]): Unit
     Attributes
       protected[akka]
     Definition Classes
       Actor
     Annotations
       @InternalApi()
162.  def aroundPreStart(): Unit
     Attributes
       protected[akka]
     Definition Classes
       Actor
     Annotations
       @InternalApi()
163.  def aroundReceive(receive: akka.actor.Actor.Receive, msg: Any): Unit
     Attributes
       protected[akka]
     Definition Classes
       MDCContextAware → Actor
164.  final def asInstanceOf[T0]: T0
     Definition Classes
       Any
165.  def avatar: Avatar
166.  var avatarActor: ActorRef[Command]
167.  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

168.  var chatActor: ActorRef[Command]
169.  var clientKeepAlive: Cancellable
170.  def clone(): AnyRef
     Attributes
       protected[lang]
     Definition Classes
       AnyRef
     Annotations
       @throws(classOf[java.lang.CloneNotSupportedException]) @native()
171.  var cluster: ActorRef[Command]
172.  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`

173.  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`

174.  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`

175.  var connectionState: Int
176.  implicit val context: ActorContext
     Definition Classes
       Actor
177.  def continent: Zone
178.  var deadState: packet.game.DeadState.Value
179.  var drawDeloyableIcon: (PlanetSideGameObject with Deployable) => Unit
180.  final def eq(arg0: AnyRef): Boolean
     Definition Classes
       AnyRef
181.  def equals(arg0: AnyRef): Boolean
     Definition Classes
       AnyRef → Any
182.  def failWithError(error: String): Unit
183.  def finalize(): Unit
     Attributes
       protected[lang]
     Definition Classes
       AnyRef
     Annotations
       @throws(classOf[java.lang.Throwable])
184.  var flying: Boolean
185.  var galaxyService: ActorRef
186.  final def getClass(): Class[_ <: AnyRef]
     Definition Classes
       AnyRef → Any
     Annotations
       @native()
187.  def handleGamePkt(pkt: PlanetSideGamePacket): Any
188.  def hashCode(): Int
     Definition Classes
       AnyRef → Any
     Annotations
       @native()
189.  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

190.  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`

191.  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`

192.  var instantActionFallbackDestination: Option[Located]
193.  var interimUngunnedVehicle: Option[PlanetSideGUID]
194.  var interimUngunnedVehicleSeat: Option[Int]
195.  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

196.  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

197.  def isAcceptableNextSpawnPoint(): Boolean
198.  def isAcceptableSpawnPoint(spawnPoint: Option[SpawnPoint]): Boolean
199.  def isAcceptableSpawnPoint(spawnPoint: SpawnPoint): Boolean
200.  final def isInstanceOf[T0]: Boolean
     Definition Classes
       Any
201.  var keepAliveFunc: () => Unit
202.  var kitToBeUsed: Option[PlanetSideGUID]
203.  var lastTerminalOrderFulfillment: Boolean
204.  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.

205.  var loadConfZone: Boolean
206.  def log: LoggingAdapter
     Definition Classes
       ActorLogging
207.  final def ne(arg0: AnyRef): Boolean
     Definition Classes
       AnyRef
208.  var nextSpawnPoint: Option[SpawnPoint]
209.  var noSpawnPointHere: Boolean
210.  final def notify(): Unit
     Definition Classes
       AnyRef
     Annotations
       @native()
211.  final def notifyAll(): Unit
     Definition Classes
       AnyRef
     Annotations
       @native()
212.  var persist: () => Unit
213.  def player: Player
214.  def postRestart(reason: Throwable): Unit
     Definition Classes
       Actor
     Annotations
       @throws(classOf[java.lang.Exception])
215.  def postStop(): Unit
     Definition Classes
       SessionActor → Actor
216.  def preRestart(reason: Throwable, message: Option[Any]): Unit
     Definition Classes
       Actor
     Annotations
       @throws(classOf[java.lang.Exception])
217.  def preStart(): Unit
     Definition Classes
       Actor
     Annotations
       @throws(classOf[java.lang.Exception])
218.  var prefire: Option[PlanetSideGUID]
219.  var progressBarUpdate: Cancellable
220.  var progressBarValue: Option[Float]
221.  val projectiles: Array[Option[Projectile]]
222.  val projectilesToCleanUp: Array[Boolean]
223.  var propertyOverrideManager: ActorRef
224.  val queuedSquadActions: Seq[() => Unit]
225.  def receive: Receive
     Definition Classes
       SessionActor → Actor
226.  var recentTeleportAttempt: Long
227.  var respawnTimer: Cancellable
228.  var reviveTimer: Cancellable
229.  implicit final val self: ActorRef
     Definition Classes
       Actor
230.  def sendResponse(packet: PlanetSidePacket): Unit
231.  final def sender(): ActorRef
     Definition Classes
       Actor
232.  var serverTime: Long
233.  var serverVehicleControlVelocity: Option[Int]
234.  val serviceManager: ActorRef
235.  def session: Session
236.  def session_=(session: Session): Unit
237.  var setAvatar: Boolean
238.  var setCurrentAvatarFunc: (Player) => Unit
239.  var setupAvatarFunc: () => Unit
240.  var shiftOrientation: Option[Vector3]
241.  var shiftPosition: Option[Vector3]
242.  var shooting: Option[PlanetSideGUID]
243.  var shootingStart: Long
244.  var shootingStop: Long
245.  var shotsWhileDead: Int
246.  var specialItemSlotGuid: Option[PlanetSideGUID]
247.  var squadService: ActorRef
248.  var squadSetup: () => Unit
249.  val squadUI: LongMap[SquadUIElement]
250.  var squadUpdateCounter: Int
251.  var squad_supplement_id: Int
252.  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`

253.  def supervisorStrategy: SupervisorStrategy
     Definition Classes
       Actor
254.  final def synchronized[T0](arg0: => T0): T0
     Definition Classes
       AnyRef
255.  def taskThenZoneChange(task: GiveTask, zoneMessage: FindZone): Unit

     Before changing zones, perform the following task (which can be a nesting of subtasks).

256.  def toString(): String
     Definition Classes
       AnyRef → Any
257.  var turnCounterFunc: (PlanetSideGUID) => Unit
258.  def unhandled(message: Any): Unit
     Definition Classes
       Actor
259.  lazy val unsignedIntMaxValue: Long
260.  def updateBlockMap(target: BlockMapEntity, zone: Zone, newCoords: Vector3): Unit
261.  var updateSquad: () => Unit
262.  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

263.  var usingMedicalTerminal: Option[PlanetSideGUID]
264.  final def wait(): Unit
     Definition Classes
       AnyRef
     Annotations
       @throws(classOf[java.lang.InterruptedException])
265.  final def wait(arg0: Long, arg1: Int): Unit
     Definition Classes
       AnyRef
     Annotations
       @throws(classOf[java.lang.InterruptedException])
266.  final def wait(arg0: Long): Unit
     Definition Classes
       AnyRef
     Annotations
       @throws(classOf[java.lang.InterruptedException]) @native()
267.  var waypointCooldown: Long
268.  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

269.  var zoneReload: Boolean

     a flag that forces the current zone to reload itself during a zoning operation

270.  var zoningChatMessageType: ChatMessageType
271.  var zoningCounter: Int
272.  var zoningStatus: objects.zones.Zoning.Status.Value
273.  var zoningTimer: Cancellable
274.  var zoningType: objects.zones.Zoning.Method.Value

### Inherited from MDCContextAware

### Inherited from ActorLogging

### Inherited from Actor

### Inherited from AnyRef

### Inherited from Any

### Ungrouped