# PSF-LoginServer - master - net.psforever.packet.game
PSF - LoginServer - master - net.psforever.packet.game
Keywords: PSF LoginServer master net.psforever.packet.game

PSF-LoginServer - master < Back


# Packages

-  package root
  Definition Classes
    root
-  package net
  Definition Classes
    root
-  package psforever
  Definition Classes
    net
-  package packet
  Definition Classes
    psforever
-  package control
  Definition Classes
    packet
-  package crypto
  Definition Classes
    packet
-  package game
  Definition Classes
    packet
-  package objectcreate
- ActionCancelMessage
- ActionProgressMessage
- ActionResultMessage
- Additional1
- Additional2
- Additional3
- AggravatedDamageMessage
- ArmorChangedMessage
- AvatarDeadStateMessage
- AvatarFirstTimeEventMessage
- AvatarGrenadeStateMessage
- AvatarImplantMessage
- AvatarJumpMessage
- AvatarSearchCriteriaMessage
- AvatarStatisticsMessage
- AvatarVehicleTimerMessage
- BattleDiagramAction
- BattleExperienceMessage
- BattleplanMessage
- BeginZoningMessage
- BindPlayerMessage
- BindStatus
- BroadcastWarpgateUpdateMessage
- BugReportMessage
- BugType
- BuildingInfoUpdateMessage
- CaptureFlagUpdateMessage
- CargoMountPointStatusMessage
- ChainLashMessage
- ChangeAmmoMessage
- ChangeFireModeMessage
- ChangeFireStateMessage_Start
- ChangeFireStateMessage_Stop
- ChangeShortcutBankMessage
- CharacterCreateRequestMessage
- CharacterInfoMessage
- CharacterKnowledgeInfo
- CharacterKnowledgeMessage
- CharacterNoRecordMessage
- CharacterRequestAction
- CharacterRequestMessage
- ChatChannel
- ChatMsg
- ChildObjectStateMessage
- CloudInfo
- ConnectToWorldMessage
- ConnectToWorldRequestMessage
- ContinentalLockUpdateMessage
- CreateShortcutMessage
- DamageFeedbackMessage
- DamageMessage
- DamageWithPositionMessage
- DataChallenge
- DataChallengeMessage
- DataChallengeMessageResp
- DeadState
- DelayedPathMountMsg
- DensityLevelUpdateMessage
- DeployObjectMessage
- DeployOutcome
- DeployRequestMessage
- DeployableIcon
- DeployableInfo
- DeployableObjectsInfoMessage
- DeploymentAction
- DestroyDisplayMessage
- DestroyMessage
- DiagramActionCode
- DiagramStroke
- DisconnectMessage
- DismountBuildingMsg
- DismountVehicleCargoMsg
- DismountVehicleMsg
- DisplayedAwardMessage
- DrawString
- DropItemMessage
- DroppodError
- DroppodFreefallingMessage
- DroppodLaunchInfo
- DroppodLaunchRequestMessage
- DroppodLaunchResponseMessage
- DrowningTarget
- EmoteMsg
- ExperienceAddedMessage
- FacilityBenefitShieldChargeRequestMessage
- FavoritesAction
- FavoritesMessage
- FavoritesRequest
- FireHintMessage
- FlagInfo
- Friend
- FriendAction
- FriendsRequest
- FriendsResponse
- GamePropertyScope
- GamePropertyTarget
- GenericActionEnum
- GenericActionMessage
- GenericCollisionMsg
- GenericObjectActionEnum
- GenericObjectActionMessage
- GenericObjectStateMsg
- HackMessage
- HackState
- HitHint
- HitInfo
- HitMessage
- HotSpotInfo
- HotSpotUpdateMessage
- ImplantAction
- InvalidTerrainMessage
- InventoryStateMessage
- ItemTransactionMessage
- ItemTransactionResultMessage
- KeepAliveMessage
- LashMessage
- LoadMapMessage
- LoginMessage
- LoginRespMessage
- LongRangeProjectileInfoMessage
- LootItemMessage
- MailMessage
- MemberEvent
- MountVehicleCargoMsg
- MountVehicleMsg
- MoveItemMessage
- ObjectAttachMessage
- ObjectCreateDetailedMessage
- ObjectCreateMessage
- ObjectDeleteMessage
- ObjectDeployedMessage
- ObjectDetachMessage
- ObjectDetectedMessage
- ObjectHeldMessage
- OrbitalShuttleTimeMsg
- OrbitalStrikeWaypointMessage
- OxygenStateMessage
- PadAndShuttlePair
- PickupItemMessage
- PingMsg
- PlanetSideZoneID
- PlanetsideAttributeEnum
- PlanetsideAttributeMessage
- PlanetsideStringAttributeMessage
- PlayerStasisMessage
- PlayerStateMessage
- PlayerStateMessageUpstream
- PlayerStateShiftMessage
- ProjectileCharacteristics
- ProjectileStateMessage
- PropertyOverrideMessage
- ProximityTerminalUseMessage
- QuantityDeltaUpdateMessage
- QuantityUpdateMessage
- ReleaseAvatarRequestMessage
- ReloadMessage
- RepairMessage
- ReplicationStreamMessage
- RequestDestroyMessage
- RespawnAMSInfoMessage
- RespawnInfo
- RibbonBarsSlot
- ServerType
- ServerVehicleOverrideMsg
- SetChatFilterMessage
- SetCurrentAvatarMessage
- SetEmpireMessage
- ShiftState
- Shortcut
- SimDataChallenge
- SimDataChallengeResp
- SpawnRequestMessage
- SplashHitMessage
- SplashedTarget
- SquadAction
- SquadDefinitionActionMessage
- SquadDetail
- SquadDetailDefinitionUpdateMessage
- SquadHeader
- SquadInfo
- SquadInvitationRequestMessage
- SquadListing
- SquadMemberEvent
- SquadMembershipRequest
- SquadMembershipResponse
- SquadPositionDetail
- SquadPositionEntry
- SquadState
- SquadStateInfo
- SquadWaypointEvent
- SquadWaypointRequest
- Statistics
- StormInfo
- StreamLengthToken
- StrokeFive
- StrokeSeven
- Style
- TargetInfo
- TargetRequest
- TargetingImplantRequest
- TargetingInfoMessage
- TerrainCondition
- TimeOfDayMessage
- TrainingZoneMessage
- TriggerEffectMessage
- TriggerEnvironmentalDamageMessage
- TriggerSoundMessage
- TriggeredEffect
- TriggeredEffectLocation
- TriggeredSound
- UnuseItemMessage
- UseItemMessage
- VNLWorldStatusMessage
- VehicleStateMessage
- VehicleSubStateMessage
- Vertex
- VoiceHostInfo
- VoiceHostKill
- VoiceHostRequest
- WarpQueuePrompt
- WarpgateRequest
- Waypoint
- WaypointEvent
- WaypointEventAction
- WaypointInfo
- WeaponDelayFireMessage
- WeaponDryFireMessage
- WeaponFireMessage
- WeaponJammedMessage
- WeaponLazeTargetPositionMessage
- WeatherMessage
- WorldConnectionInfo
- WorldInformation
- WorldStatus
- ZipLineMessage
- ZoneForcedCavernConnectionsMessage
- ZoneInfoMessage
- ZoneLockInfoMessage
- ZonePopulationUpdateMessage
-  package reset
  Definition Classes
    packet

p

net.psforever.packet

# game

#### package game


Ordering

1. Alphabetic

Visibility

1. Public
2. Protected

### Package Members

1.  package objectcreate

### Type Members

1.  final case class ActionCancelMessage (player_guid: PlanetSideGUID, object_guid: PlanetSideGUID, unk: Int) extends PlanetSideGamePacket with Product with Serializable

   na

   na

   player_guid

     na

   object_guid

     na

   unk

     na

2.  final case class ActionProgressMessage (action: Int, unk2: Long) extends PlanetSideGamePacket with Product with Serializable

   6,7,8 - Start implant initialization timer for slots 0,1,2 respectively.

   6,7,8 - Start implant initialization timer for slots 0,1,2 respectively. Allowed values: 0-100 (50 will start timer at 50% complete)

3.  final case class ActionResultMessage (successful: Boolean, errorCode: Option[Long]) extends PlanetSideGamePacket with Product with Serializable

   Is sent by the server when the client has performed an action from a menu item (i.e create character, delete character, etc...)

4.  final case class Additional1 (unk1: String, unk2: Int, unk3: Long) extends Product with Serializable

   na

   na

   unk1

     na

   unk2

     na

   unk3

     na

5.  final case class Additional2 (unk1: Int, unk2: Long) extends Product with Serializable

   na

   na

   unk1

     na

   unk2

     na

6.  final case class Additional3 (unk1: Boolean, unk2: Int) extends Product with Serializable

   na

   na

   unk1

     na

   unk2

     na

7.  final case class AggravatedDamageMessage (guid: PlanetSideGUID, damage: Long) extends PlanetSideGamePacket with Product with Serializable

   Dispatched from the server to cause a damage reaction from a specific target.

   Dispatched from the server to cause a damage reaction from a specific target. Infantry targets should be the primary target of this packet, as indicated by their identifier. Infantry targets display their flinch animation. All targets yelp in agony. Infantry targets use their assigned voice. Non-infantry targets use the "grizzled"(?) voice.

   guid

     the target entity's global unique identifier

   damage

     the amount of damsge being simulated

8.  final case class ArmorChangedMessage (player_guid: PlanetSideGUID, armor: types.ExoSuitType.Value, subtype: Int) extends PlanetSideGamePacket with Product with Serializable

   Force a player model to change its exo-suit.

   Force a player model to change its exo-suit. Set all GUI elements and functional elements to be associated with that type of exo-suit. Inventory and holster contents are discarded.
   Due to the way armor is handled internally, a player of one faction may not spawn in the exo-suit of another faction. That style of exo-suit is never available through this packet. As MAX units do not get their weapon by default, all the MAX values produce the same faction-appropriate mechanized exo-suit body visually. (The MAX weapons are supplied in subsequent packets.)
   Mechanized Assault Subtypes:
   `0 - na
   1 - AI MAX
   2 - AV MAX
   3 - AA MAX ```

   player_guid

     the player

   armor

     the type of exo-suit

   subtype

     the exo-suit subtype, if any

9.  final case class AvatarDeadStateMessage (state: DeadState.Value, timer_max: Long, timer: Long, pos: Vector3, faction: types.PlanetSideEmpire.Value, unk5: Boolean) extends PlanetSideGamePacket with Product with Serializable

   Dispatched by the server to manipulate the client's management of the `Player` object owned by the user as his "avatar."
   The cycle of a player is generally `Alive` to `Dead` and `Dead` to `Release` and `Release` to `RespawnTimer` to `Alive`.

   Dispatched by the server to manipulate the client's management of the `Player` object owned by the user as his "avatar."
   The cycle of a player is generally `Alive` to `Dead` and `Dead` to `Release` and `Release` to `RespawnTimer` to `Alive`. When deconstructing oneself, the user makes a jump between `Alive` and `Release`; and, he may make a further jump from `Release` to `Alive` depending on spawning choices. Being `Alive` is the most common state. (Despite what anyone says.) Being `Dead` is just a technical requirement to initialize the revive timer. The player should be sufficiently "dead" by having his health points decreased to zero. If the timer is reduced to zero, the player is sent back to their faction-appropriate sanctuary continent.
   `Release` causes a "dead" player to have its character model converted into a backpack or a form of pastry. This cancels the revival timer - the player may no longer be revived - and brings the user to the deployment map. From the deployment map, the user may select a place where they may respawn a new character. The options available form this spawn are not only related to the faction affinity of the bases compared to the user's player(s) but also to the field `faction` as is provided in the packet. If the player is converted to a state of `Release` while being alive, the deployment map is still displayed. Their character model is not replaced by a backpack or pastry.
   `RespawnTimer` is like `Dead` as it is just a formal distinction to cause the client to display a timer. The state indicates that the player is being resurrected at a previously-selected location in the state `Alive`.

   state

     avatar's mortal relationship with the world; the following timers are applicable during `Death` and `RespawnTimer`; `faction` is applicable mainly during `Release`

   timer_max

     total length of respawn countdown, in milliseconds

   timer

     initial length of the respawn timer, in milliseconds

   pos

     player's last position

   faction

     spawn points available for this faction on redeployment map

   unk5

     na

10.  final case class AvatarFirstTimeEventMessage (avatar_guid: PlanetSideGUID, object_id: PlanetSideGUID, unk: Long, event_name: String) extends PlanetSideGamePacket with Product with Serializable

    Dispatched to the server when the player encounters something for the very first time in their campaign.

    Dispatched to the server when the player encounters something for the very first time in their campaign. For example, the first time the player rubs up against a game object with a yellow exclamation point. For example, the first time the player draws a specific weapon.
    When the first time events (FTE's) are received, battle experience is awarded. Text information about the object will be displayed. A certain itemized checkbox under the "Training" tab that corresponds is marked off. The latter list indicates all "encounter-able" game objects for which a FTE exists. These effects only happen once per character/campaign. (The Motion Sensor will occasionally erroneously display the information window on repeat encounters. No additional experience is given, though.)
    FTE's are recorded in a great `List` of `String`s in the middle of player `ObjectCreateMessage` data. Tutorial complete events are enqueued nearby.

    avatar_guid

      the player

    object_id

      the game object that triggers the event

    unk

      na

    event_name

      the string name of the event

11.  final case class AvatarGrenadeStateMessage (player_guid: PlanetSideGUID, state: types.GrenadeState.Value) extends PlanetSideGamePacket with Product with Serializable

    Report the state of the grenade throw animation for this player.

    Report the state of the grenade throw animation for this player. The default state is "held at side," though the client's avatar never has to announce this.
    The throwing animation has a minor timing glitch. Causing another player to raise his arm will always result in that arm being lowered a few seconds later. This is as opposed to the client's avatar, who can seem to hold a grenade in the "prepare to throw" state indefinitely. If the avatar looks away from a player whose grenade arm is up ("prepare to throw"), however, when they look back at the player, his grenade arm will occasionally have been lowered ("held at side") again before it would normally be lowered.
    A client will dispatch state 'Primed' and state 'Thrown' for the avatar's actions. A client will only react temporarily for another character other than the avatar when the given a state 'Primed'. If that internal state is not changed, however, that other character will not respond to any subsequent 'Primed' state. (This may also be a glitch.)
    States:
    `1 - prepare to throw (grenade held back over shoulder)
    2 - throwing (grenade released overhand and then reset) (avatar only)
    ```

    player_guid

      the player

    state

      the animation state

12.  final case class AvatarImplantMessage (player_guid: PlanetSideGUID, action: ImplantAction.Value, implantSlot: Int, status: Int) extends PlanetSideGamePacket with Product with Serializable

    Change the state of the implant.

    Change the state of the implant. Spawn messages for certain implant-related events.
    The implant Second Wind is technically an invalid `ImplantType` for this packet. This owes to the unique activation trigger for that implant - a near-death experience of ~0HP.

    player_guid

      the player

    action

      how to affect the implant or the slot

    implantSlot

      : from 0 to 2

    status

      : a value that depends on context from `ImplantAction`:
      `Add` - 0-9 depending on the `ImplantType`
      `Remove` - any valid value; field is not significant to this action
      `Initialization` - 0 to revoke slot; 1 to allocate implant slot
      `Activation` - 0 to deactivate implant; 1 to activate implant
      `UnlockMessage` - 0-3 as an unlocked implant slot; display a message
      `OutOfStamina` - lock implant; 1 to lock; 0 to unlock; display a message

    See also

      `ImplantType`

13.  final case class AvatarJumpMessage (state: Boolean) extends PlanetSideGamePacket with Product with Serializable

    Tell the server that the player is is jumping.

    Tell the server that the player is is jumping. This will allow it to coordinate animation with other clients.
    During the jump, the avatar's "height" coordinate does change, as reported in `PlayerStateMessageUpstream`. `PlayerStateMessage`, however, can depict another player with a proper jumping animation without the explicit coordinate change. The server must probably account for the distance to the ground when passing along data somehow.
    Exploration:
    Is `state` ever not `true`?

    state

      true

14.  final case class AvatarSearchCriteriaMessage (unk1: PlanetSideGUID, unk2: List[Int]) extends PlanetSideGamePacket with Product with Serializable

    na

    na

    unk1

      na

    unk2

      na

15.  final case class AvatarStatisticsMessage (unk: Int, stats: Statistics) extends PlanetSideGamePacket with Product with Serializable

    na

    na

    unk

      na

    stats

      na

16.  final case class AvatarVehicleTimerMessage (player_guid: PlanetSideGUID, text: String, time: Long, unk1: Boolean) extends PlanetSideGamePacket with Product with Serializable

    player_guid

      player guid !

    text

      name of the item or vehicle name (ex : medkit, fury ...)

    time

      in seconds

    unk1

      NA - Seems to be false when it's for medkit, true for vehicles

17.  final case class BattleDiagramAction (action: DiagramActionCode.Value, stroke: Option[DiagramStroke] = None) extends Product with Serializable

    A particular instruction in the rendering of this battleplan's diagram entry.

    A particular instruction in the rendering of this battleplan's diagram entry.

    action

      the behavior of this stroke; a hint to the kind of stroke data stored, if at all, and how to use it or incorporate prior data

    stroke

      the data; defaults to `None`

18.  final case class BattleExperienceMessage (player_guid: PlanetSideGUID, experience: Long, msg: Int) extends PlanetSideGamePacket with Product with Serializable

    Inform the client how many battle experience points (BEP) the player currently has earned.
    The amount of `experience` earned is an accumulating value.

    Inform the client how many battle experience points (BEP) the player currently has earned.
    The amount of `experience` earned is an accumulating value. Whenever the server sends this packet, the value of this field is equal to the player's current total BEP. Each packet updates to a higher BEP score and the client occasionally reports of the difference as an event message. "You have been awarded `x` battle experience points." Milestone notifications that occur due to BEP gain, e.g., rank progression, will trigger naturally as the client is updated.
    It is possible to award more battle experience than is necessary to progress one's character to the highest battle rank. (This must be accomplished in a single event packet.) Only the most significant notifications will be displayed in that case. If the BEP has been modified, there will be an extra three bits to indicate which message to display.
    Messages:
    0 - Normal
    1 - Normal (repeat?)
    2 - Support bonus ("due to support activity")
    4 - Rabbit bonus ("+25% rabbit Bonus")
    (Support message has priority over Rabbit message.)
    Exploration:
    `msg = 1` probably does not do the same thing as `mod = 0`.

    player_guid

      the player

    experience

      the current total experience

    msg

      modifies the awarded experience message

19.  final case class BattleplanMessage (char_id: Long, player_name: String, zone_id: Int, diagrams: List[BattleDiagramAction]) extends PlanetSideGamePacket with Product with Serializable

    Share drawn images and words on the tactical map among a group of players.
    Each packet usually contains a small portion of an image, herein called a "diagram." `BattleplanMessage` packets are accumulative towards a full diagram.

    Share drawn images and words on the tactical map among a group of players.
    Each packet usually contains a small portion of an image, herein called a "diagram." `BattleplanMessage` packets are accumulative towards a full diagram. Moreover, rather than the `player_name`, each diagram is associated on a client by the `char_id` field. Only squad leaders and platoon leaders can draw on the map and share with other players in their squad or platoon.
    To start drawing, a would-be artist must have all clients who will receive their diagrams acknowledge a `StartDrawing` action. The `char_id` with this `StartDrawing` will associate all diagrams submitted with the same `char_id`'s portfolio. Multiple portfolio definitions may exist on a client at a given time and each will manage their own diagrams. When a given portfolio submits a `StopDrawing` action that is received, the previous diagrams associated with it will be cleared. That `char_id` will no longer accept diagrams on that client. Other portfolios will continue to accept diagrams as initialized. When no portfolios are being accepted, the "Toggle -> Battleplan" button on that client's tactical map will be disabled. When there is at least one portfolio accepted, the "Battleplan" button will be functional and can be toggled.
    To construct line segments, chain `StrokeTwo` diagrams in the given packet entry. Each defined point will act like a successive vertex in a chain of segments. Any non-vertex entry in between entries, e.g., a change of line color, will break the chain of line segments. For example:
    RED-A-B-C will construct red lines segments A-B and B-C.
    RED-A-B-GREEN-C will only construct a red line segement A-B.
    RED-A-B-GREEN-C-D will construct a red line segement A-B and a green line segment C-D.
    (Default line color, if none is declared specifically, is gray.)
    To construct a message, define a point to act as the center baseline for the text. The message will be written above and outwards from that point. Messages do not carry properties over from line segments - they set their own color and do not have line thickness. Any single portfolio may have only fifteen messages written to the tactical map at a time.

    char_id

      na; same as in `CharacterInfoMessage`

    player_name

      the player who contributed this battle plan

    zone_id

      on which continent the battle plan will be overlaid; can identify as "no zone" 0 when performing instructions not specific to drawing

    diagrams

      a list of the itemized actions that will construct this plan or are used to modify the plan

20.  final case class BeginZoningMessage () extends PlanetSideGamePacket with Product with Serializable

    Dispatched by the client after the current map has been fully loaded locally and its objects are ready to be initialized.

    Dispatched by the client after the current map has been fully loaded locally and its objects are ready to be initialized. This packet is a direct response to `LoadMapMessage`.
    When the server receives the packet, for each object on that map, it sends the packets to the client:
    - `SetEmpireMessage`
    - `HackMessage`
    - `PlanetSideAttributeMessage`
    - ... and so forth
    Afterwards, an avatar POV is declared and the remaining details about the said avatar are assigned.

21.  final case class BindPlayerMessage (action: BindStatus.Value, bind_desc: String, display_icon: Boolean, logging: Boolean, spawn_group: SpawnGroup, zone_number: Long, unk4: Long, pos: Vector3) extends PlanetSideGamePacket with Product with Serializable

    A packet dispatched to maintain a manually-set respawn location.
    The packet establishes the player's ability to spawn in an arbitrary location that is not a normal local option.

    A packet dispatched to maintain a manually-set respawn location.
    The packet establishes the player's ability to spawn in an arbitrary location that is not a normal local option. This process is called "binding one's matrix." In addition to player establishing the binding, the packet updates as conditions of the respawn location changes.
    If `logging` is turned on, packets will display different messages depending on context. The bind descriptor will be used to flavor the events chat message. As long as the event is marked to be logged, when the packet is received, a message is displayed in the events window. If the logged action is applicable, the matrixing sound effect will be played too. Not displaying events is occasionally warranted for aesthetics. The game will always note if this is your first time binding regardless of the state of this flag.
    Bind Descriptors:
    `@amp_station`
    `@ams`
    `@comm_station` (interlink facility?)
    `@comm_station_dsp` (dropship center?)
    `@cryo_facility` (biolab?)
    `@tech_plant`
    Exploration:
    Find other bind descriptors.

    action

      the purpose of the packet

    bind_desc

      a text description of the respawn binding point

    display_icon

      show the selection icon on the redeployment map

    logging

      true, to report on bind point change visible in the events window; false, to render spawn change silently; some first time notifications will always display regardless of this flag

    spawn_group

      the kind of spawn request that will be made; affects the type of icon displayed; will coincide with the value of `unk2` in `SpawnRequestMessage` when the spawn option is selected

    zone_number

      the number of the zone in which to display this spawn option; if `zone_number` is not the current zone, and the action is positive, a small map of the alternate zone with selectable spawn point will become visible

    unk4

      na

    pos

      coordinates for any displayed deployment map icon; `x` and `y` determine the position

22.  final case class BroadcastWarpgateUpdateMessage (zone_id: Int, building_id: Int, tr: Boolean, nc: Boolean, vs: Boolean) extends PlanetSideGamePacket with Product with Serializable

    Dispatched by the server to promote a warp gate's broadcast functionality.
    Changes the map name of a warp gate into "Broadcast" and allow a given faction to access the gate's intercontinental transport functionality to/from that gate, even if the gate is not properly owned.

    Dispatched by the server to promote a warp gate's broadcast functionality.
    Changes the map name of a warp gate into "Broadcast" and allow a given faction to access the gate's intercontinental transport functionality to/from that gate, even if the gate is not properly owned. If an actual warp gate is not designated, nothing happens. If not set, the map name of the warp gate will default to whatever is normally written on the map. The map designation of geowarps is not affected by this packet.

    zone_id

      the zone ordinal number

    building_id

      the warp gate map id

    tr

      players belonging to the Terran Republic interact with this warp gate as a "broadcast gate"

    nc

      players belonging to the New Conglomerate interact with this warp gate as a "broadcast gate"

    vs

      players belonging to the Vanu Sovereignty interact with this warp gate as a "broadcast gate"

    See also

      `BuildingInfoUpdateMessage`

23.  final case class BugReportMessage (version_major: Long, version_minor: Long, version_date: String, bug_type: BugType.Value, repeatable: Boolean, location: Int, zone: Int, pos: Vector3, summary: String, desc: String) extends PlanetSideGamePacket with Product with Serializable

    Allow the user to report a bug they have found in the game.
    Bug reports are prepended by the version of the client on which the player is encountering the issue.

    Allow the user to report a bug they have found in the game.
    Bug reports are prepended by the version of the client on which the player is encountering the issue. The last delivered client by Sony Online Entertainment was `3.15.84` with date `Dec 2 2009`.
    The path of bug reports submitted to the game's official server is not known.

    version_major

      the client's major version number

    version_minor

      the client's minor version number

    version_date

      the date the client was compiled

    bug_type

      the kind of bug that took place

    repeatable

      whether the bug is repeatable

    location

      0 when "other location", 2 when "current location"

    zone

      which zone the bug took place

    pos

      the x y z location where the bug took place

    summary

      a short explanation of the bug

    desc

      a detailed explanation of the bug

24.  final case class BuildingInfoUpdateMessage (continent_id: Int, building_map_id: Int, ntu_level: Int, is_hacked: Boolean, empire_hack: types.PlanetSideEmpire.Value, hack_time_remaining: Long, empire_own: types.PlanetSideEmpire.Value, unk1: Long, unk1x: Option[Additional1], generator_state: types.PlanetSideGeneratorState.Value, spawn_tubes_normal: Boolean, force_dome_active: Boolean, lattice_benefit: Int, cavern_benefit: Int, unk4: List[Additional2], unk5: Long, unk6: Boolean, unk7: Int, unk7x: Option[Additional3], boost_spawn_pain: Boolean, boost_generator_pain: Boolean) extends PlanetSideGamePacket with Product with Serializable

    Update the state of map asset for a client's specific building's state.

    Update the state of map asset for a client's specific building's state. The most common application of this packet is to synchronize map state during world login.
    A "building" mainly constitutes any map-viewable structure that has properties or whose ownership can be asserted. This packet is valid for all major facilities, field towers, warp gates, and some static environment elements. Additional properties, if available, can be viewed by selecting the sphere of influence of a given building. The combination of continent UID and building UID ensures that all buildings are uniquely-defined. This packet can be applied on any continent and will affect the appropriate building on any other continent. As the intercontinental map is always available, all map assets will publish real time updates to all players. Map information configured by this packet is not obscured from any players, regardless of faction. (Network state updates will be delayed for, and the type of compromise will not be specified to, defenders.)
    Aside from the map-viewable aspects, a few properties set by this packet also have game world effects. Additionally, though most parameters are treated as mandatory, not all buildings will be able to use those parameters. A parameter that is not applicable for a given asset, e.g., NTU for a field tower, will be ignored. A collision between some parameters can occur. For example, if `is_hacking` is `false`, the other hacking fields are considered invalid. If `is_hacking` is `true` but the hacking empire is also the owning empire, the `is_hacking` state is invalid.
    Lattice benefits: (stackable)
    `00 - None
    01 - Amp Station
    02 - Dropship Center
    04 - Bio Laboratory
    08 - Interlink Facility
    16 - Technology Plant
    `
    Cavern benefits: (stackable)
    `000 - None
    004 - Speed Module
    008 - Shield Module
    016 - Vehicle Module
    032 - Equipment Module
    064 - Health Module
    128 - Pain Module
    `````

    continent_id

      the continent (zone)

    building_map_id

      the map id of this building from the MPO files

    ntu_level

      if the building has a silo, the amount of NTU in that silo; NTU is reported in multiples of 10%; valid for 0 (0%) to 10 (100%)

    is_hacked

      if the building can be hacked and will take time to convert, whether the building is being hacked

    empire_hack

      if the building is being hacked, the empire that is performing the hacking

    hack_time_remaining

      if the building is being hacked, the amount of time remaining until the hack finishes/clears; recorded in milliseconds (ms)

    empire_own

      the empire that owns the building currently

    unk1

      na; value != 0 causes the next field to be defined

    unk1x

      na

    generator_state

      if the building has a generator, the state of the generator

    spawn_tubes_normal

      if the building has spawn tubes, whether at least one of the tubes is powered and operational

    force_dome_active

      if the building is a capitol facility, whether the force dome is active

    lattice_benefit

      the benefits from other Lattice-linked bases does this building possess

    cavern_benefit

      cavern benefits; any non-zero value will cause the cavern module icon (yellow) to appear; proper module values cause the cavern module icon to render green; all benefits will report as due to a "Cavern Lock"

    unk4

      na

    unk5

      na

    unk6

      na

    unk7

      na; value != 8 causes the next field to be defined

    unk7x

      na

    boost_spawn_pain

      if the building has spawn tubes, the (boosted) strength of its enemy pain field

    boost_generator_pain

      if the building has a generator, the (boosted) strength of its enemy pain field

25.  final case class CaptureFlagUpdateMessage (zone_number: Int, flagInfoList: List[FlagInfo]) extends PlanetSideGamePacket with Product with Serializable

    zone_number

      The zone number this packet applies to

    flagInfoList

      The list of LLUs/Monolith units for this zone

26.  final case class CargoMountPointStatusMessage (cargo_vehicle_guid: PlanetSideGUID, requesting_vehicle: PlanetSideGUID, mounted_vehicle: PlanetSideGUID, dismounted_vehicle: PlanetSideGUID, slot: Int, mount_status: types.CargoStatus.Value, orientation: Int) extends PlanetSideGamePacket with Product with Serializable

    na

    na

    cargo_vehicle_guid

      always the carrier vehicle

    requesting_vehicle

      cargo vehicle that requested mounting during the mounting process; blank when the process is complete

    mounted_vehicle

      cargo vehicle that requested mounting after the mounting process is complete; blank before the process is complete

    dismounted_vehicle

      cargo vehicle that was mounted after disembarking; blank before disembark blank before mounting request, when packet `MountVehicleCargoMsg` is received

    slot

      cargo hold mount position; common values are 1 for the `lodestar` and 15 for the `dropship`

    mount_status

      cargo mount status

    orientation

      direction the cargo vehicle faces when stowed in the carrier cargo bay; 0 is "normal," front facing forward; 1 is "sideways," front facing the side of the carrier vehicle, e.g. `router`

    See also

      `CargoStatus`

      `MountVehicleCargoMsg`

27.  final case class ChainLashMessage (lash_origin_target: Option[PlanetSideGUID], lash_origin_pos: Option[Vector3], projectile_type: Int, targets: List[PlanetSideGUID]) extends PlanetSideGamePacket with Product with Serializable

    na

    na

    lash_origin_target

      na

    lash_origin_pos

      na

    projectile_type

      na

    targets

      na

28.  final case class ChangeAmmoMessage (item_guid: PlanetSideGUID, unk1: Long) extends PlanetSideGamePacket with Product with Serializable
29.  final case class ChangeFireModeMessage (item_guid: PlanetSideGUID, fire_mode: Int) extends PlanetSideGamePacket with Product with Serializable
30.  final case class ChangeFireStateMessage_Start (item_guid: PlanetSideGUID) extends PlanetSideGamePacket with Product with Serializable
31.  final case class ChangeFireStateMessage_Stop (item_guid: PlanetSideGUID) extends PlanetSideGamePacket with Product with Serializable
32.  final case class ChangeShortcutBankMessage (player_guid: PlanetSideGUID, bank: Int) extends PlanetSideGamePacket with Product with Serializable

    Switch the set of shortcuts displayed on the HUD's hotbar.
    The hotbar contains eight slots for user shortcuts - medkits, implants, and text macros.

    Switch the set of shortcuts displayed on the HUD's hotbar.
    The hotbar contains eight slots for user shortcuts - medkits, implants, and text macros. Next to the first slot are up and down arrow buttons with a number. By progressing through the options available from the arrows, eight sets of eight shortcut slots are revealed. Which set is visible determines the effect of the respective binding keys (the Function keys) for the hotbar. Each set is called a "bank," obviously.
    This packet coordinates the bank number both as an upstream and as a downstream packet.

    player_guid

      the player

    bank

      the shortcut bank (zero-indexed); 0-7 are the valid banks

33.  final case class CharacterCreateRequestMessage (name: String, headId: Int, voiceId: types.CharacterVoice.Value, gender: CharacterSex, empire: types.PlanetSideEmpire.Value) extends PlanetSideGamePacket with Product with Serializable

    Is sent by the PlanetSide client on character selection completion.

34.  final case class CharacterInfoMessage (unk: Long, zoneId: PlanetSideZoneID, charId: Long, guid: PlanetSideGUID, finished: Boolean, secondsSinceLastLogin: Long) extends PlanetSideGamePacket with Product with Serializable

    Is sent by the PlanetSide world server when sending character selection screen state.

    Is sent by the PlanetSide world server when sending character selection screen state. Provides metadata about a certain character for rendering purposes (zone background, etc). Acts as an array insert for the client character list. A blank displayed character is most likely caused by either: - a mismatch between an ObjectCreateMessage GUID and the GUID from this message. - bundling CharacterInfoMessage with OCDM, they should appear one after another

    finished

      True when there are no more characters to give info on

35.  final case class CharacterKnowledgeInfo (name: String, permissions: Set[Certification], unk1: Int, unk2: Int, unk3: PlanetSideGUID) extends Product with Serializable
36.  final case class CharacterKnowledgeMessage (char_id: Long, info: Option[CharacterKnowledgeInfo]) extends PlanetSideGamePacket with Product with Serializable
37.  final case class CharacterNoRecordMessage (unk: Long) extends PlanetSideGamePacket with Product with Serializable
38.  final case class CharacterRequestMessage (charId: Long, action: Type) extends PlanetSideGamePacket with Product with Serializable

    Is sent by the PlanetSide client when selecting a character to play from the character selection menu.

39.  final case class ChatMsg (messageType: ChatMessageType, wideContents: Boolean, recipient: String, contents: String, note: Option[String]) extends PlanetSideGamePacket with Product with Serializable

    Instructs client to display and/or process a chat message/command when sent server to client.

    Instructs client to display and/or process a chat message/command when sent server to client. Instructs server to route and/or process a chat message/command when sent client to server.

    messageType

      the type of the chat message (CMT)

    wideContents

      whether the contents contains wide characters or not. This is required because Java/Scala have one String type with a charset of UTF-16. Therefore, there is no way at runtime to determine the charset of String.

    recipient

      identifies the recipient of the message, such as in a tell (occasionally used as "sender" instead i.e. /note)

    contents

      the textual contents of the message

    note

      only used when the message is of note type

40.  final case class ChildObjectStateMessage (object_guid: PlanetSideGUID, pitch: Float, yaw: Float) extends PlanetSideGamePacket with Product with Serializable

    Dispatched from a client when its user is controlling a secondary object whose state must be updated.
    When `ChildObjectStateMessage` is being sent to the server, it replaces `PlayerStateMessage`.

    Dispatched from a client when its user is controlling a secondary object whose state must be updated.
    When `ChildObjectStateMessage` is being sent to the server, it replaces `PlayerStateMessage`. The packet frequently gets hidden in a `MultiPacket`, though it is not functionally essential to do that.
    Note the lack of position data. The secondary object in question is updated in position through another means or is stationary. The only concern is the direction the object is facing. The angles are relative to the object's normal forward-facing and typically begin tracking at 0, 0 (forward-facing).

    object_guid

      the object being manipulated (controlled)

    pitch

      the amount of pitch that affects orientation from forward facing (0)

    yaw

      the amount of yaw that affects orientation from forward-facing (0)

41.  final case class CloudInfo (id: Int, unk1: Vector3, unk2: Vector3) extends Product with Serializable

    Cloud data.
    The remaining fields should be divided between a "location" and a "velocity" as per debug output.

    Cloud data.
    The remaining fields should be divided between a "location" and a "velocity" as per debug output. The values are probably paired. The converted data, however, seems weird for the kind of information those fields would suggest.

    id

      the id of the cloud; zero-indexed counter (probably)

    unk1

      na; the z-component is always `0.0f`

    unk2

      na; the z-component is always `0.0f`

42.  final case class ConnectToWorldMessage (server: String, serverAddress: String, port: Int) extends PlanetSideGamePacket with Product with Serializable

    Is sent in response to the PlanetSide client in order to give server information on the world server.

    Is sent in response to the PlanetSide client in order to give server information on the world server.

    server

      The name of the server to connect to

    serverAddress

      The IP or hostname of the server to connect to

    port

      The 16-bit port number to connect on

43.  final case class ConnectToWorldRequestMessage (server: String, token: String, majorVersion: Long, minorVersion: Long, revision: Long, buildDate: String, unknown: Int) extends PlanetSideGamePacket with Product with Serializable
44.  final case class ContinentalLockUpdateMessage (continent_id: Int, empire: types.PlanetSideEmpire.Value) extends PlanetSideGamePacket with Product with Serializable

    Create a dispatched game packet that instructs the client to update the user about continents that are conquered.
    This generates the event message "The [empire] have captured [continent]." If the continent_guid is not a valid zone, no message is displayed.

    Create a dispatched game packet that instructs the client to update the user about continents that are conquered.
    This generates the event message "The [empire] have captured [continent]." If the continent_guid is not a valid zone, no message is displayed. If empire is not a valid empire, or refers to the neutral or Black Ops forces, no message is displayed.

    continent_id

      identifies the zone (continent)

    empire

      identifies the empire

45.  final case class CreateShortcutMessage (player_guid: PlanetSideGUID, slot: Int, unk: Int, addShortcut: Boolean, shortcut: Option[Shortcut] = None) extends PlanetSideGamePacket with Product with Serializable

    Facilitate a quick-use button for the hotbar.
    The hotbar is the eight quick-use slots along the bottom center of the HUD.

    Facilitate a quick-use button for the hotbar.
    The hotbar is the eight quick-use slots along the bottom center of the HUD. Each of these slots is the application of a medkit, or use of an implant, or repetition of a text macro. There are actually sixty-four of these slots, eight bound to the Function keys depending on which set is selected.
    When `addShortcut` is `true`, the provided `Shortcut` will be defined and attached to the respective hotbar slot indicated by `slot`. If it is `false`, the given `slot` will be unbound. Nothing happens if the `slot` selection is invalid.
    This packet coordinates the shortcut both as an upstream and as a downstream packet, leaning heavily towards the latter. An interesting application is that, if the user does not already have a medkit or a medkit shortcut; but, if he places a medkit in his inventory, the shortcut will be automatically added to his hotbar. This, in turn, dispatches a packet informing the server. The prior functionality will rarely be appreciated, however, as players rarely never have their medkit shortcut unbound.

    player_guid

      the player

    slot

      the hotbar slot number (one-indexed)

    unk

      na; always zero?

    addShortcut

      true, if we are adding a shortcut; false, if we are removing any current shortcut

    shortcut

      optional; details about the shortcut to be created

    See also

      ChangeShortcutBankMessage

46.  final case class DamageFeedbackMessage (unk1: Int, unk2: Boolean, unk2a: Option[PlanetSideGUID], unk2b: Option[String], unk2c: Option[Int], unk3: Boolean, unk3a: Option[PlanetSideGUID], unk3b: Option[String], unk3c: Option[Int], unk3d: Option[Int], unk4: Int, unk5: Long, unk6: Int) extends PlanetSideGamePacket with Product with Serializable

    na

    na

    unk1

      na

    unk2

      if no global unique identifier (below), the alternate identification for the entity

    unk2a

      the global unique identifier of the entity inflicting the damage

    unk2b

      if no global unique identifier (above), the name of the entity inflicting the damage

    unk2c

      if no global unique identifier (above), the object type of the entity inflicting the damage

    unk3

      if no global unique identifier (below), the alternate identification for the entity

    unk3a

      the global unique identifier of the entity absorbing the damage

    unk3b

      if no global unique identifier (above), the name of the entity absorbing the damage

    unk3c

      if no global unique identifier (above), the object type of the entity absorbing the damage

    unk3d

      na

    unk4

      an indicator for the target-specific vital statistic being affected

    unk5

      the amount of damage

    unk6

      na

47.  final case class DamageMessage (guid1: PlanetSideGUID, unk1: Int, guid2: PlanetSideGUID, unk2: Boolean) extends PlanetSideGamePacket with Product with Serializable

    na

    na

    guid1

      na

    unk1

      na

    guid2

      na

    unk2

      na

48.  final case class DamageWithPositionMessage (unk: Int, pos: Vector3) extends PlanetSideGamePacket with Product with Serializable

    Dispatched by the server to indicate a source of damage affecting the player.

    Dispatched by the server to indicate a source of damage affecting the player. Unlike `HitHint` the damage source is defined by an actual coordinate location rather than a physical target. Setting the position to the world origin, however, can cause the damage tick mark to point towards the previous damaging entity in some situations.
    The player will be shown a fading, outwards drifting, red tick mark. The location will indicate a general direction towards the source. If the option `Game/Show Damage Flash` is set, the player's screen will flash red briefly when a mark is displayed.

    unk

      the intensity of the damage tick marks

    pos

      the position

    See also

      `HitHint`

49.  final case class DataChallengeMessage (attribute: String, value: Long) extends PlanetSideGamePacket with Product with Serializable

    Our packet captures contain no examples of `DataChallengeMessage`.

    Our packet captures contain no examples of `DataChallengeMessage`.

    attribute

      na

    value

      na

50.  final case class DataChallengeMessageResp (attribute: String, value: Long) extends PlanetSideGamePacket with Product with Serializable

    Our packet captures contain no examples of `DataChallengeMessageResp`.

    Our packet captures contain no examples of `DataChallengeMessageResp`.

    attribute

      na

    value

      na

51.  final case class DelayedPathMountMsg (player_guid: PlanetSideGUID, vehicle_guid: PlanetSideGUID, u1: Int, u2: Boolean) extends PlanetSideGamePacket with Product with Serializable

    na

    na

    player_guid

      na

    vehicle_guid

      vehicle ?, turret ? Found a HART GUID for now. Need more search.

    u1

      na - maybe a delay ?

    u2

      na

52.  final case class DensityLevelUpdateMessage (zone_id: Int, building_id: Int, density: List[Int]) extends PlanetSideGamePacket with Product with Serializable

    na

    na

    zone_id

      the continent

    building_id

      the building

    density

      na

53.  final case class DeployObjectMessage (object_guid: PlanetSideGUID, unk1: Long, pos: Vector3, orient: Vector3, unk2: Long) extends PlanetSideGamePacket with Product with Serializable

    Dispatched from the client to request that an object be deployed.
    Information in the packet mainly reports about the surface on which the object will be coplanar when/if placed.

    Dispatched from the client to request that an object be deployed.
    Information in the packet mainly reports about the surface on which the object will be coplanar when/if placed. The server responds with a `ObjectDeployedMessage` packet with the results. If successful, that is followed by an `ObjectCreateMessage` packet and a `DeployableObjectsInfoMessage` packet.

    object_guid

      the object

    unk1

      na

    pos

      the location where the object is to be deployed

    orient

      the angle of orientation

    unk2

      na

54.  final case class DeployRequestMessage (player_guid: PlanetSideGUID, vehicle_guid: PlanetSideGUID, deploy_state: types.DriveState.Value, unk2: Int, unk3: Boolean, pos: Vector3) extends PlanetSideGamePacket with Product with Serializable

    Dispatched by the client when the player attempts to deploy a vehicle.

    Dispatched by the client when the player attempts to deploy a vehicle. Dispatched by the server to cause a specific vehicle to be deployed.
    "Deployment" usually isn't enough by itself. It only changes the physical configuration of the vehicle. (It's an animation request/trigger?) Anything that can be "deployed" does so for a very specific reason, to perform a complex function. These functions are not immediately available. Attributes must be set properly for the transition between behaviors to occur properly. In addition, the recently-deployed vehicles will hang in a state of limbo if not configured properly. It will not even dispatch an un-deploy request upon command in this state.
    This packet has nothing to do with ACE deployables.

    player_guid

      the player requesting the deployment

    vehicle_guid

      the vehicle to be deployed

    deploy_state

      either requests for a specific deployment state or assignment of the requested state

    unk2

      na; usually 0

    unk3

      na

    pos

      the position where the object will deploy itself

55.  final case class DeployableInfo (object_guid: PlanetSideGUID, icon: DeployableIcon.Value, pos: Vector3, player_guid: PlanetSideGUID) extends Product with Serializable

    The entry of a deployable item.

    The entry of a deployable item.

    object_guid

      the deployable item

    icon

      the map element depicting the item

    pos

      the position of the deployable in the world (and on the map)

    player_guid

      the player who is the owner

56.  final case class DeployableObjectsInfoMessage (action: DeploymentAction.Value, deployables: List[DeployableInfo]) extends PlanetSideGamePacket with Product with Serializable

    Dispatched by the server to inform the client of a change in deployable items and that the map should be updated.
    When this packet defines a `Build` `action`, an icon of the deployable item is added to the avatar's map.

    Dispatched by the server to inform the client of a change in deployable items and that the map should be updated.
    When this packet defines a `Build` `action`, an icon of the deployable item is added to the avatar's map. The actual object referenced does not have to actually exist on the client for the map element to appear. The identity of the element is discerned from its icon rather than the actual object (if it exists). When this packet defines a `Deconstruct` `action`, the icon of the deployable item is removed from the avatar's map. (The map icon to be removed is located by searching for the matching UID. The item does not need to exist to remove its icon.)
    All deployables have a map-icon-menu that allows for control of and some feedback about the item. At the very least, the item can be dismissed. The type of icon indicating the type of deployable item determines the map-icon-menu. Normally, the icon of a random (but friendly) deployable is gray and the menu is unresponsive. If the `player_guid` matches the client's avatar, the icon is yellow and that marks that the avatar owns this item. The avatar is capable of accessing the item's map-icon-menu and manipulating the item from there. If the deployable item actually doesn't exist, feedback is disabled, e.g., Aegis Shield Generators lack upgrade information.

    action

      how the entries in the following `List` are affected

    deployables

      a `List` of information regarding deployable items

57.  final case class DestroyDisplayMessage (killer: String, killer_charId: Long, killer_empire: types.PlanetSideEmpire.Value, killer_in_vehicle: Boolean, unk: Int, method: Int, victim: String, victim_charId: Long, victim_empire: types.PlanetSideEmpire.Value, victim_in_vehicle: Boolean) extends PlanetSideGamePacket with Product with Serializable

    Display a message in the event window that informs of a player death.
    The message is composed of three parts:
    1) killer information
    2) method information
    3) victim information
    In the case of a player kill, the player's name will be attributed directly.

    Display a message in the event window that informs of a player death.
    The message is composed of three parts:
    1) killer information
    2) method information
    3) victim information
    In the case of a player kill, the player's name will be attributed directly. In the case of an absentee kill, a description of the method of death will be attributed. In the case of a suicide, the player attributed is the player who was killed (message format displays only the victim).
    The four bytes that follow each name seems to be important to the identification of the associated player. The same value will be seen in every `DestroyDisplayMessage` that includes that player, with respect to whether they are listed as the "killer" or as the "victim." This holds true for every entry within the same login session, at least. Blanking either of these values out does not change anything about the format of the event message. If the two ids match, the packet will interpreted as the "suicide" format, even if the names do not match. In the case of absentee kills where there is no killer listed, this field is zero'd.
    When marked as being in a vehicle or a turret, the player's name will be enclosed within square brackets. The length of the player's name found at the start of the character string does not reflect whether or not there will be square brackets (fortunately). The color of the resulting icon is borrowed from the attributed killer's faction affiliation if it can be determined and the type of icon is the same as an object id. An unidentified method or a missing icon defaults to a skull and crossbones.

    killer

      the name of the player who did the killing

    killer_charId

      same as CharacterInfoMessage

    killer_empire

      the empire affiliation of the killer

    killer_in_vehicle

      true, if the killer was in a vehicle at the time of the kill; false, otherwise

    unk

      na; but does not like being set to 0

    method

      modifies the icon in the message, related to the way the victim was killed

    victim

      the name of the player who was killed

    victim_charId

      same as CharacterInfoMessage

    victim_empire

      the empire affiliation of the victim

    victim_in_vehicle

      true, if the victim was in a vehicle when he was killed; false, otherwise

58.  final case class DestroyMessage (unk1: PlanetSideGUID, unk2: PlanetSideGUID, unk3: PlanetSideGUID, pos: Vector3) extends PlanetSideGamePacket with Product with Serializable
59.  sealed trait DiagramStroke extends AnyRef

    A common ancestor of all the different "strokes" used to keep track of the data.

60.  final case class DisconnectMessage (msg: String, unk2: String, unk3: String) extends PlanetSideGamePacket with Product with Serializable

    Dispatched to the client to force a disconnect.
    The client's view of the game world will fade and be centered with a PlanetSide textbox with the given message.

    Dispatched to the client to force a disconnect.
    The client's view of the game world will fade and be centered with a PlanetSide textbox with the given message. Using the button on the textbox will drop the current world session and return the player to the world select screen. Technically, they're already disconnected by the time the textbox is visible. Being disconnected like this has no client-based consequences on its own.
    Exploration:
    When do the other two messages appear, if at all?

    msg

      the displayed message

    unk2

      na

    unk3

      na

61.  final case class DismountBuildingMsg (player_guid: PlanetSideGUID, building_guid: PlanetSideGUID) extends PlanetSideGamePacket with Product with Serializable

    Alert that the player is "dismounting" a building.
    Paragraph in which "'dismounting' a building" is explained.

    Alert that the player is "dismounting" a building.
    Paragraph in which "'dismounting' a building" is explained.

    player_guid

      the player

    building_guid

      the building

62.  final case class DismountVehicleCargoMsg (player_guid: PlanetSideGUID, vehicle_guid: PlanetSideGUID, bailed: Boolean, requestedByPassenger: Boolean, kicked: Boolean) extends PlanetSideGamePacket with Product with Serializable

    Note: For some reason this packet does not include the GUID of the vehicle that is being dismounted from.

    Note: For some reason this packet does not include the GUID of the vehicle that is being dismounted from. As a workaround vehicle.MountedIn in manually set/removed

    player_guid

      // GUID of the player that is rqeuesting dismount

    vehicle_guid

      GUID of the vehicle that is requesting dismount

    bailed

      If the vehicle bailed out of the cargo vehicle

    requestedByPassenger

      If a passenger of the vehicle in the cargo bay requests dismount this bit will be set

    kicked

      If the vehicle was kicked by the cargo vehicle pilot

63.  final case class DismountVehicleMsg (player_guid: PlanetSideGUID, bailType: types.BailType.Value, wasKickedByDriver: Boolean) extends PlanetSideGamePacket with Product with Serializable

    Dispatched by the client when the player wishes to get out of a vehicle.

    Dispatched by the client when the player wishes to get out of a vehicle.

    player_guid

      the player

    bailType

      The dismount action e.g. normal dismount, kicked by owner, bailed

    wasKickedByDriver

      Seems to be true if a passenger was manually kicked by the vehicle owner

64.  final case class DisplayedAwardMessage (player_guid: PlanetSideGUID, ribbon: types.MeritCommendation.Value = MeritCommendation.None, bar: RibbonBarsSlot.Value = RibbonBarsSlot.TermOfService) extends PlanetSideGamePacket with Product with Serializable

    Dispatched to configure a player's merit commendation ribbons.
    Normally, this packet is dispatched by the client when managing merit commendations through the "Character Info/Achievements" tab.

    Dispatched to configure a player's merit commendation ribbons.
    Normally, this packet is dispatched by the client when managing merit commendations through the "Character Info/Achievements" tab. On Gemini Live, this packet was also always dispatched once by the server during character login. It set the term of service ribbon explicitly. Generally, this was unnecessary, as the encoded character data maintains information about displayed ribbons. This behavior was probably a routine that ensured that correct yearly progression was tracked if the player earned it while offline. It never set any of the other ribbon slot positions during login.
    A specific ribbon may only be set once to one slot. The last set slot is considered the valid position to which that ribbon will be placed/moved.

    player_guid

      the player

    ribbon

      the award to be displayed; defaults to `MeritCommendation.None`; use `MeritCommendation.None` when indicating "no ribbon"

    bar

      any of the four positions where the award ribbon is to be displayed; defaults to `TermOfService`

    See also

      `RibbonBars`

      `MeritCommendation`

65.  final case class DrawString (x: Float, y: Float, color: Int, channel: Int, message: String) extends DiagramStroke with Product with Serializable

    Draw a string message on the tactical map.

    Draw a string message on the tactical map. String messages have their own color designation and will not inherit line properties.

    x

      the x-coordinate marking the bottom center of this message's text

    y

      the y-coordinate marking the bottom center of this message's text

    color

      the color of the message; 0 is gray (default); 1 is red; 2 is green; 3 is blue

    channel

      the available "slots" in which to display messages on the map; a maximum of 16 channels/messages (0-15) are available per player; no two messages may inhabit the same channel

    message

      the text to display

66.  final case class DropItemMessage (item_guid: PlanetSideGUID) extends PlanetSideGamePacket with Product with Serializable

    Dispatched by the client when the player's intent is to put an item down on the ground.
    When a player drops an item, it normally appears right under their feet (where they are standing).

    Dispatched by the client when the player's intent is to put an item down on the ground.
    When a player drops an item, it normally appears right under their feet (where they are standing). This part of the ground is chosen because it should be the stable. Also, those coordinates belonging to the player are the most accessible. This process, however, is not automatic. The server determines the exact position where the item gets placed.
    This packet is complemented by an `ObjectDetachMessage` packet from the server that performs the actual "dropping."

    item_guid

      the item to be dropped

67.  sealed abstract class DroppodError extends IntEnumEntry

    The types of errors that can be reported when attempting to droppod into a zone.
    All codes show the preceding text in the events chat window.

    The types of errors that can be reported when attempting to droppod into a zone.
    All codes show the preceding text in the events chat window. The typo in the message from `BlockedBySOI` can not be resolved by populating any of the greater packet's fields. `ZoneFullWarpQueue` utilizes the additional packet fields to establish the warp queue prompt with the warp queue and the player's position in that queue. The zone to which the player desires transportation is defined elsewhere in the greater packet.

68.  final case class DroppodFreefallingMessage (guid: PlanetSideGUID, pos: Vector3, vel: Vector3, pos2: Vector3, orientation1: Vector3, orientation2: Vector3) extends PlanetSideGamePacket with Product with Serializable

    Dispatched by the server to trigger a droppod's traditional behavior of plummeting from lower orbit like a rock and slowing to a gentle land, breaking apart like flower petals to introduce a soldier to the battlefield.
    Only works on droppod-type vehicles.

    Dispatched by the server to trigger a droppod's traditional behavior of plummeting from lower orbit like a rock and slowing to a gentle land, breaking apart like flower petals to introduce a soldier to the battlefield.
    Only works on droppod-type vehicles. Only works if a client avatar is mounted in the vehicle. The furthest the vehicle will fall is determined by that avatar player's interaction with the ground. The camera is maneuvered in three ways - where it starts, where it tracks the falling vehicle, where it zooms in upon landing. Only the "where it starts" portion of the camera is slightly manipulable.

    guid

      the global unique identifier of the droppod

    pos

      the position of the droppod

    vel

      how quickly the droppod is moving

    pos2

      suggestion for positioning external viewpoint while observing the droppod descending; the most common offset from the model position was `Vector3(-20, 1.156f, -50)`

    orientation1

      na; the y-component is usually 70.3125f

    orientation2

      na

69.  final case class DroppodLaunchInfo (guid: PlanetSideGUID, zone_number: Int, xypos: Vector3) extends Product with Serializable

    Information related to this droppod event.

    Information related to this droppod event.

    guid

      the player using the droppod

    zone_number

      the zone to which the player desires transportation

    xypos

      where in the zone (relative to the ground) the player will be placed

    See also

      `DroppodLaunchRequestMessage`

      `DroppodLaunchResponseMessage`

70.  final case class DroppodLaunchRequestMessage (info: DroppodLaunchInfo, unk: Int) extends PlanetSideGamePacket with Product with Serializable

    Dispatched from the client to indicate the player wishes to use an orbital droppod to rapidly deploy into a zone at a pre-approved position.
    Follows after an instance of "player stasis" where they are permitted to make this sort of selection by referencing a zone from the interstellar deployment map.

    Dispatched from the client to indicate the player wishes to use an orbital droppod to rapidly deploy into a zone at a pre-approved position.
    Follows after an instance of "player stasis" where they are permitted to make this sort of selection by referencing a zone from the interstellar deployment map. This is the conclusion of utilizing the high altitude rapid transport (HART) system though does not need to be limited only to prior use of the orbital shuttle.

    info

      information related to this droppod event

    unk

      na; consistently 3

    See also

      `PlayerStasisMessage`

71.  final case class DroppodLaunchResponseMessage (error_code: DroppodError, launch_info: DroppodLaunchInfo, queue_info: Option[WarpQueuePrompt]) extends PlanetSideGamePacket with Product with Serializable

    Dispatched from the client to indicate the player wished to use an orbital droppod but the player will be denied that request for a specific reason.

    Dispatched from the client to indicate the player wished to use an orbital droppod but the player will be denied that request for a specific reason. The reason manifests as text appended to the event chat window. Occasionally, a supplemental window will open with additional information about a delayed action (warp queue).

    error_code

      the error reporting why the zoning through droppod use failed

    launch_info

      information related to this droppod event

    queue_info

      if the error invokes the warp queue, the current information about the state of the queue

    Exceptions thrown

      `AssertionError` if the error code requires additional fields

    See also

      `DroppodLaunchInfo`

72.  final case class DrowningTarget (guid: PlanetSideGUID, progress: Float, condition: OxygenState) extends Product with Serializable

    Infomation about the progress bar displayed for a certain target's drowning condition.

    Infomation about the progress bar displayed for a certain target's drowning condition.

    guid

      the target

    progress

      the remaining countdown

    condition

      in what state of drowning the target is progressing

73.  final case class EmoteMsg (avatar_guid: PlanetSideGUID, emote: types.EmoteType.Value) extends PlanetSideGamePacket with Product with Serializable
74.  final case class ExperienceAddedMessage (exp: Int, unk: Boolean = true) extends PlanetSideGamePacket with Product with Serializable

    Displays a message about being awarded experience points in the events chat.
    This packet does not actually award any experience points.

    Displays a message about being awarded experience points in the events chat.
    This packet does not actually award any experience points. It merely generates the message:
    `"You have been awarded x experience points."`
    ... where `x` is the number of experience points that have been promised. If the `Boolean` parameter is `true`, `x` will be equal to the number provided followed by the word "Command." If the `Boolean` parameter is `false`, `x` will be represented as an obvious blank space character. (Yes, it prints to the events chat like that.)

    exp

      the number of (Command) experience points earned

    unk

      defaults to `true` for effect; if `false`, the number of experience points in the message will be blanked

75.  final case class FacilityBenefitShieldChargeRequestMessage (vehicle_guid: PlanetSideGUID) extends PlanetSideGamePacket with Product with Serializable

    Dispatched by the client when driving a vehicle in the sphere of influence of an allied base that is an amp station facility or that possesses the lattice-connected benefit of an amp station.

    Dispatched by the client when driving a vehicle in the sphere of influence of an allied base that is an amp station facility or that possesses the lattice-connected benefit of an amp station. The vehicle that is being driven will not have perfect fully-charged shields at the time.

    vehicle_guid

      the vehicle whose shield is being charged

76.  final case class FavoritesMessage (list: types.LoadoutType.Value, player_guid: PlanetSideGUID, line: Int, label: String, armor: Option[Int]) extends PlanetSideGamePacket with Product with Serializable

    Load the designator for an entry in the player's favorites list.
    This entry defines a user-defined loadout label that appears on a "Favorites" tab list and can be selected.

    Load the designator for an entry in the player's favorites list.
    This entry defines a user-defined loadout label that appears on a "Favorites" tab list and can be selected. A subsequent server request - `ItemTransactionMessage` - must be made to retrieve the said loadout contents. Multiple separated favorites lists are present in the game. All entries are prepended with their destination list which indicates how from how that list is viewable. Different lists also have different numbers of available lines to store loadout entries.
    Infantry equipment favorites are appended with a code for the type of exo-suit that they will load on a player. This does not match the same two field numbering system as in `ArmorChangedMessage` packets.
    Armors:
    `1 - Agile
    2 - Reinforced
    4 - AA MAX
    5 - AI MAX
    6 - AV MAX
    `
    Exploration:
    There are three unaccounted exo-suit indices - 0, 3, and 7; and, there are two specific kinds of exo-suit that are not defined - Infiltration and Standard. It is possible that one of the indices also defines the generic MAX (see` ArmorChangedMessage`). Which exo-suit is associated with which index?

    list

      the destination list

    player_guid

      the player

    line

      the zero-indexed line number of this entry in its list

    label

      the identifier for this entry

    armor

      the type of exo-suit, if an Infantry loadout

77.  final case class FavoritesRequest (player_guid: PlanetSideGUID, list: types.LoadoutType.Value, action: FavoritesAction.Value, line: Int, label: Option[String]) extends PlanetSideGamePacket with Product with Serializable

    na

    na

    player_guid

      the player

    list

      na

    action

      the behavior of this packet

    line

      what line of the applicable loadout ("Saved Favorites") list is modified

    label

      applicable when a load out is being saved; this is the string that will be displayed in the list of loadouts on that line

78.  final case class FireHintMessage (weapon_guid: PlanetSideGUID, pos: Vector3, u1: Int, u2: Int, u3: Int, u4: Int, u5: Option[Vector3] = None) extends PlanetSideGamePacket with Product with Serializable

    not sure for u1 / u2 / u3, maybe need a real brain ...

    not sure for u1 / u2 / u3, maybe need a real brain ...

    weapon_guid

      na

    pos

      na; pos of what ?!

    u1

      na

    u2

      na

    u3

      na

    u4

      na

    u5

      na; vel of what ?!

79.  final case class FlagInfo (u1: Int, owner_map_id: Int, target_map_id: Int, x: Float, y: Float, hack_time_remaining: Long, is_monolith_unit: Boolean) extends Product with Serializable

    u1

      No effect. Faction ID perhaps?

    owner_map_id

      The mapID of the base the LLU belongs to

    target_map_id

      The mapID of the base the LLU must be delivered to

    x

      X map position

    y

      Y map position

    hack_time_remaining

      Time remaining on hack - will override BuildingInfoUpdateMessage when displaying hack timer on map base details

    is_monolith_unit

      Changes the icon on the map to the monolith unit icon

80.  final case class Friend (name: String, online: Boolean = false) extends Product with Serializable

    An entry in the list of players known to and tracked by this player.

    An entry in the list of players known to and tracked by this player. They're called "friends" even though they can be used for a list of ignored players as well.

    name

      the name of the player

    online

      the player's current state of activity; defaults to `false`, or offline

81.  final case class FriendsRequest (action: Int, friend: String) extends PlanetSideGamePacket with Product with Serializable

    Manage the lists of other players whose names are retained by the given player.
    Players can be remembered by their names and added to a list of remembered names - the "friends list." They can also be dropped from the list.

    Manage the lists of other players whose names are retained by the given player.
    Players can be remembered by their names and added to a list of remembered names - the "friends list." They can also be dropped from the list. A list of "ignored" player names can also be retained. Ignored players will have their comments stifled in the given player's chat window. No name will be appended or removed from any list until the response to this packet is received.
    Actions that involve the "remove" functionality will locate the entered name in the local list before dispatching this packet. A complaint will be logged to the event window if the name is not found.
    Actions:
    0 - display friends list
    1 - add player to friends list
    2 - remove player from friends list
    4 - display ignored player list
    5 - add player to ignored player list
    6 - remove player from ignored player list
    Exploration:
    Are action = 3 and action = 7 supposed to do anything?

    action

      the purpose of this packet

    friend

      the player name that was entered; blank in certain situations

82.  final case class FriendsResponse (action: FriendAction.Value, unk1: Int, unk2: Boolean, unk3: Boolean, friends: List[Friend] = Nil) extends PlanetSideGamePacket with Product with Serializable

    Manage the lists of other players whose names are retained by the given player.
    Friends can be remembered and their current playing status can be reported.

    Manage the lists of other players whose names are retained by the given player.
    Friends can be remembered and their current playing status can be reported. Ignored players will have their comments stifled in the given player's chat window. This does not handle outfit member lists.
    Actions:
    0 - initialize friends list (no logging)
    1 - add entry to friends list
    2 - remove entry from friends list
    3 - update status of player in friends list; if player is not listed, he is not added
    4 - initialize ignored players list (no logging)
    5 - add entry to ignored players list
    6 - remove entry from ignored players list

    action

      the purpose of the entry(s) in this packet

    unk1

      na; always 0?

    unk2

      na; always `true`?

    unk3

      na; always `true`?

    friends

      a list of `Friend`s

83.  final case class GenericActionMessage (action: Int) extends PlanetSideGamePacket with Product with Serializable

    Reports that something has happened, or makes something happen.
    When sent from the server to a client, there are twenty-seven individual actions caused by this packet.

    Reports that something has happened, or makes something happen.
    When sent from the server to a client, there are twenty-seven individual actions caused by this packet. They are only vaguely organized by behavior and some numbers may not be associated with an action. When sent by the client to the server, an unknown number of actions are available. The highest known action is a server-sent 45.
    Actions (when sent from server):
    03 - symbol: show Mosquito radar
    04 - symbol: hide Mosquito radar
    07 - warning: missile lock
    08 - warning: Wasp missile lock
    09 - warning: T-REK lock
    11 - Drop special item e.g. LLU
    12 - sound: base captured fanfare
    14 - prompt: new character basic training
    15 - MAX Deploy
    16 - MAX Undeploy
    22 - message: awarded a cavern capture (updates cavern capture status)
    23 - award a cavern kill
    24 - message: you have been imprinted (updates imprinted status; does it?)
    25 - message: you are no longer imprinted (updates imprinted status; does it?)
    27 - event: purchase timers reset (does it?)
    31 - forced into first person view; in third person view, player character sinks into the ground; green deconstruction particle effect under feet
    32 - forced into first person view, attempt to deconstruct but fail; event: fail to deconstruct due to having a "parent vehicle"
    33 - event: fail to deconstruct
    43 - prompt: friendly fire in virtual reality zone
    45 - ?
    Actions (when sent from client):
    15 - Max anchor 16 - Max unanchor 20 - Client requests MAX special effect (NC shield and TR overdrive. VS jump jets are handled by the jump_thrust boolean on PlayerStateMessageUpstream) 21 - Disable MAX special effect (NC shield) 28 - Cancel warp queue (see: `DroppodLaunchResponseMessage`)
    29 - AFK
    30 - back in game
    36 - turn on "Looking for Squad"
    37 - turn off "Looking for Squad"

    action

      what this packet does

84.  final case class GenericCollisionMsg (unk1: Int, player: PlanetSideGUID, target: PlanetSideGUID, player_health: Int, target_health: Int, player_velocity: Vector3, target_velocity: Vector3, player_pos: Vector3, target_pos: Vector3, unk2: Long, unk3: Long, unk4: Long) extends PlanetSideGamePacket with Product with Serializable

    Dispatched by the client when the player has encountered a physical interaction that would cause damage.
    Collision information reports about two subjects who were involved in an altercation.

    Dispatched by the client when the player has encountered a physical interaction that would cause damage.
    Collision information reports about two subjects who were involved in an altercation. The first is the `player`, that is, the client's avatar. The second is the `target` with respect to the `player` - whatever the avatar ran into, or whatever ran into the avatar. In the case of isolated forms of collision such as fall damage the `target` fields are blank or zero'd.

    unk1

      na

    player

      the player or player-controlled vehicle

    target

      the other party in the collision

    player_health

      the player's health

    target_health

      the target's health

    player_velocity

      the player's velocity

    target_velocity

      the target's velocity

    player_pos

      the player's world coordinates

    target_pos

      the target's world coordinates

    unk2

      na

    unk3

      na

    unk4

      na

85.  final case class GenericObjectActionMessage (object_guid: PlanetSideGUID, code: Int) extends PlanetSideGamePacket with Product with Serializable

    Dispatched by the server to enact an effect on some game object.

    Dispatched by the server to enact an effect on some game object. (Write more some other time.)

    object_guid

      the target object

    code

      the action code (0-63)
      6 - Deconstructs player
      7 - Start imprinting process (progress bar + character animation)
      8 - Finish imprinting?
      9 - Cloak
      10 - Uncloak
      11 - Deploy capital base shield pole with animation and broadcasts "The capitol force dome at X has been activated"
      12 - Stow capital base shield pole with animation and broadcasts "The capitol force dome at X has been deactivated"
      13 - Deploy capital base shield pole (instantly, unless still in the middle of the stow animation)
      14 - Changes capture console to say "Facility hacked by the <Faction> LLU has been spawned." when looked at
      15 - Displays "This facility's generator is under attack!"
      16 - Displays "Generator has Overloaded! Evacuate Generator Room Immediately!"
      17 - Displays "This facility's generator is back on line"
      19 - Cause mines to explode
      20 - Hit flinch? (orig, 82->80)
      21 - Reset build cooldown from using an ACE
      22 - ???? (Has been seen on vehicle pad objects, possibly some sort of reset flag after base faction flip / hack clear?)
      23 - Plays vehicle pad animation moving downwards
      24 - Makes the vehicle bounce slightly. Have seen this in packet captures after taking a vehicle through a warpgate
      27 - Activates the router internal telepad for linking
      28 - Activates the router internal telepad for linking
      29 - Activates the telepad deployable (also used on the router's internal telepad)
      30 - Activates the telepad deployable (also used on the router's internal telepad)
      31 - Animation during router teleportation (source)
      32 - Animation during router teleportation (destination)
      34 - Time until item can be used ?????
      50 - For aircraft - client shows "The bailing mechanism failed! To fix the mechanism, land and repair the vehicle!"
      53 - Put down an FDU
      56 - Sets vehicle or player to be black ops
      57 - Reverts player from black ops

    See also

      GenericObjectActionEnum

86.  final case class GenericObjectStateMsg (object_guid: PlanetSideGUID, state: Long) extends PlanetSideGamePacket with Product with Serializable

    object_guid

      the target object

    state

      the state code 16 - open door 17 - close door

87.  final case class HackMessage (unk1: Int, target_guid: PlanetSideGUID, player_guid: PlanetSideGUID, progress: Int, unk5: Long, hack_state: HackState.Value, unk7: Long) extends PlanetSideGamePacket with Product with Serializable

    Dispatched by the server to control the progress of hacking.

    Dispatched by the server to control the progress of hacking. While "hacking" is typically performed against enemy targets, some actions that involve ally on ally hacking can occur. In this sense, hacking can be consider change progress.
    In general, the act of hacking is maintained by the server but the conclusion is managed by the client. Hacking typically locks the player into a cancellable firing animation and works as all-or-nothing. The progress bar window is displayed and updated each tick by the server; but, the client can cancel it on its own. When hacking is complete as indicated by the appropriate `HackState`, the client performs the intended action upon the target. Facility amenities will temporarily ignore IFF requirements; vehicles will permanently transfer control over to the hack-starter's empire; facility turret weapons will temporarily convert to their anti-vehicle or anti-aircraft configurations; facilities will be compromised and begin the long process of converting to the hack-starter's empire; and, so forth.
    As mentioned, one of the unexpected uses of this message will assist the conversion of allied facility turreted weapons to their upgraded armaments.

    unk1

      na; 0 commonly; 2 when performing (phalanx) upgrades; 3 for building objects during login phase; hack type? possibly player hacking level 0-3?

    target_guid

      the target of the hack

    player_guid

      the player

    progress

      the amount of progress visible; visible range is 0 - 100

    unk5

      na; often a large number; doesn't seem to be `char_id`?

    hack_state

      hack state

    unk7

      na; 5 - boost pain field at matrixing terminal? usually, 8?

88.  final case class HitHint (source_guid: PlanetSideGUID, player_guid: PlanetSideGUID) extends PlanetSideGamePacket with Product with Serializable

    Dispatched by the server to indicate a target or source of damage affecting the player.
    When a source is provided, and within render distance, the player will be shown a fading, outwards drifting, red tick mark.

    Dispatched by the server to indicate a target or source of damage affecting the player.
    When a source is provided, and within render distance, the player will be shown a fading, outwards drifting, red tick mark. The location and movement of the mark will indicate a general direction towards the source. If the option `Game/Show Damage Flash` is set, the player's screen will flash red briefly when a mark is displayed.
    For while some mark is being displayed, the player will also make a grunt of pain.

    source_guid

      the source of implied damage

    player_guid

      the player

89.  final case class HitInfo (shot_origin: Vector3, hit_pos: Vector3, hitobject_guid: Option[PlanetSideGUID]) extends Product with Serializable
90.  final case class HitMessage (seq_time: Int, projectile_guid: PlanetSideGUID, unk1: Int, hit_info: Option[HitInfo], unk2: Boolean, unk3: Boolean, unk4: Option[Int]) extends PlanetSideGamePacket with Product with Serializable
91.  final case class HotSpotInfo (x: Float, y: Float, scale: Float) extends Product with Serializable

    Information for positioning a hotspot on the continental map.
    The origin point is the lowest left corner of the map grid.

    Information for positioning a hotspot on the continental map.
    The origin point is the lowest left corner of the map grid. The coordinates of the hotspot do necessarily match up to the map's internal coordinate system - what you learn using the `/loc` command. Instead, all maps use a 0 - 8192 coordinate overlay.

    x

      the x-coord of the center of the hotspot

    y

      the y-coord of the center of the hotspot

    scale

      how big the hotspot sunburst icon appears

92.  final case class HotSpotUpdateMessage (zone_index: Int, priority: Int, spots: List[HotSpotInfo]) extends PlanetSideGamePacket with Product with Serializable

    A list of data for creating hotspots on a continental map.

    A list of data for creating hotspots on a continental map. Hotspots indicate player activity, almost always some form of combat or aggressive encounter.
    The hotspot system is an all-or-nothing affair. The received packet indicates the hotspots to display and the map will display only those hotspots. Inversely, if the received packet indicates no hotspots, the map will display no hotspots at all. To clear away only some hotspots but retains others, a continental list would have to be pruned selectively for the client.
    Exploration:
    What does (zone) priority entail?

    zone_index

      the zone

    priority

      na

    spots

      a List of HotSpotInfo

93.  final case class InvalidTerrainMessage (player_guid: PlanetSideGUID, vehicle_guid: PlanetSideGUID, proximity_alert: TerrainCondition.Value, pos: Vector3) extends PlanetSideGamePacket with Product with Serializable

    na

    na

    player_guid

      the player who is driving the vehicle

    vehicle_guid

      the vehicle

    proximity_alert

      whether this position is invalid; `true`, for the nearby terrain being unsuitable; `false`, when the vehicle has been moved back to a safe distance (place)

    pos

      the vehicle's current position in the game world

94.  final case class InventoryStateMessage (object_guid: PlanetSideGUID, unk: Int, container_guid: PlanetSideGUID, value: Long) extends PlanetSideGamePacket with Product with Serializable

    Dispatched by the server to update the value associated with an object in a specific container object.
    The object indicated by `object_guid` must be associated with the inventory (`container_guid`) at the time.

    Dispatched by the server to update the value associated with an object in a specific container object.
    The object indicated by `object_guid` must be associated with the inventory (`container_guid`) at the time. A common use for this packet is to update weapon data when gaining control over that weapon. For example, before boarding any kind of turret for the first time, it's ammunition component will have exactly one shot. This shot was established when the turret was first created. This information would be displayed in the holster icon across the bottom of the GUI while it is mounted. Furthermore, the mounted player will only fire the turret exactly one time. This packet can provide the turret with its correct and current amount of ammunition before the player mounts it.

    object_guid

      the object being affected

    unk

      na; usually 0

    container_guid

      the object in which `object_guid` is contained

    value

      an amount with which to update `object_guid`

95.  final case class ItemTransactionMessage (terminal_guid: PlanetSideGUID, transaction_type: types.TransactionType.Value, item_page: Int, item_name: String, unk1: Int, item_guid: PlanetSideGUID) extends PlanetSideGamePacket with Product with Serializable
96.  final case class ItemTransactionResultMessage (terminal_guid: PlanetSideGUID, transaction_type: types.TransactionType.Value, success: Boolean, error: Int = 0) extends PlanetSideGamePacket with Product with Serializable

    Dispatch to the client in response to an `ItemRequestMessage`, roughly after the request has been fulfilled.

    Dispatch to the client in response to an `ItemRequestMessage`, roughly after the request has been fulfilled. This TCP-like "after" behavior is typically supported by pushing this packet at the end of the `MultiPacket` that fulfills the request.

    terminal_guid

      the terminal used

    transaction_type

      the type of transaction

    success

      whether the transaction was a success

    error

      an error code, if applicable; no error by default

97.  final case class KeepAliveMessage (code: Int = 0) extends PlanetSideGamePacket with Product with Serializable
98.  final case class LashMessage (seq_time: Int, player: PlanetSideGUID, victim: PlanetSideGUID, bullet: PlanetSideGUID, hit_pos: Vector3, unk1: Int) extends PlanetSideGamePacket with Product with Serializable

    na

    na

    seq_time

      na

    player

      na

    victim

      na

    bullet

      na

    hit_pos

      na

    unk1

      na

99.  final case class LoadMapMessage (map_name: String, nav_map_name: String, unk1: Int, unk2: Long, weapons_unlocked: Boolean, checksum: Long) extends PlanetSideGamePacket with Product with Serializable

    map_name and nav_map_name should match (unless you want to be lost :))

    map_name and nav_map_name should match (unless you want to be lost :))

    ex: map13 & home3 = vs sanc map10 & z10 = amerish map07 & z7 = esamir

100.  final case class LoginMessage (majorVersion: Long, minorVersion: Long, buildDate: String, username: String, password: Option[String], token: Option[String], revision: Long) extends PlanetSideGamePacket with Product with Serializable
101.  final case class LoginRespMessage (token: String, error: Type, stationError: Type, subscriptionStatus: Type, unkUIRelated: Long, username: String, privilege: Long) extends PlanetSideGamePacket with Product with Serializable

     This message is sent from the server to the client upon reception of a LoginMessage.

     This message is sent from the server to the client upon reception of a LoginMessage.

     The result of the login is contained in this message. When a login is successful, a session token is returned to the client which then forwards this to the World server it chooses to connect to.

     In terms of failed logins, the PS client favors errors in this order

     1. LoginError 2. StationError 3. StationSubscriptionStatus

     Don't try and set more than one error at the same time. Just provide a single error message to be displayed.

     token

       A 'token' which acts exactly like a session cookie in a browser. Allows logins to not use a password

     error

       A general login error message

     stationError

       A PlanetSide Sony Online Entertainment (SOE) station result

     subscriptionStatus

       A response detailing the current subscription type

     unkUIRelated

       An unknown possible bitfield that controls some game variables (possibly expansions?)

     username

       The login username

     privilege

       If set above 10000, then the user has access to GM commands. Not sure of other values.

102.  final case class LongRangeProjectileInfoMessage (guid: PlanetSideGUID, pos: Vector3, vel: Option[Vector3]) extends PlanetSideGamePacket with Product with Serializable
103.  final case class LootItemMessage (item_guid: PlanetSideGUID, destination_guid: PlanetSideGUID) extends PlanetSideGamePacket with Product with Serializable

     Dispatched by the client when the user right-clicks on a piece of `Equipment` in an inventory that is not his own backpack in an attempt to quick-swap that `Equipment` into his inventory.

     Dispatched by the client when the user right-clicks on a piece of `Equipment` in an inventory that is not his own backpack in an attempt to quick-swap that `Equipment` into his inventory. Examples of this "other" inventory include: corpses, lockers, and vehicle trunks.
     Compared to `MoveItemMessage`, the source location where `item` currently resides is not provided. Additionally, while the over-all destination is provided, the specific insertion point of the destination is not.

     item_guid

       the item being taken

     destination_guid

       where the item will be placed; generally, the player is taking the item

     See also

       `MoveItemMessage`

104.  final case class MailMessage (sender: String, subject: String, message: String) extends PlanetSideGamePacket with Product with Serializable

     Dispatched from the server, sending a "priority message" to the given client's avatar.

     Dispatched from the server, sending a "priority message" to the given client's avatar. The messaging inbox is generally accessible through the use of `alt`+`i`. It is also made accessible through use of an icon in the lower right corner when there is an outstanding message.
     Exploration:
     How does the PlanetSide Classic mail system work? At the moment, it only seems possible to receive and read mail from the server.

     sender

       the name of the player who sent the mail

     subject

       the subject

     message

       the message

105.  final case class MountVehicleCargoMsg (player_guid: PlanetSideGUID, vehicle_guid: PlanetSideGUID, target_vehicle: PlanetSideGUID, unk4: Int) extends PlanetSideGamePacket with Product with Serializable

     player_guid

       The guid of the player sending the request to board another vehicle with a cargo vehicle

     vehicle_guid

       The guid of the vehicle for the requesting player

     target_vehicle

       The cargo vehicle guid e.g. Galaxy / Lodestar

106.  final case class MountVehicleMsg (player_guid: PlanetSideGUID, vehicle_guid: PlanetSideGUID, entry_point: Int) extends PlanetSideGamePacket with Product with Serializable

     Alert that the player wishes to board a vehicle at a specific entry point.
     The client will only dispatch this packet when it feels confident that the player can get into a vehicle.

     Alert that the player wishes to board a vehicle at a specific entry point.
     The client will only dispatch this packet when it feels confident that the player can get into a vehicle. It makes its own check whether or not to display that "enter vehicle here" icon on the ground. This is called an "entry point." Entry points and mount numbers are not required as one-to-one; multiple entry points can lead to the same mount, such as the driver mount of an ANT.
     The player is not allowed to board anything until the server responds in affirmation.

     player_guid

       the player

     vehicle_guid

       the vehicle

     entry_point

       the entry index that maps to a mount index, specific to the selected vehicle

107.  final case class MoveItemMessage (itemGuid: PlanetSideGUID, avatarGuid1: PlanetSideGUID, avatarGuid2: PlanetSideGUID, dest: Int, quantity: Int) extends PlanetSideGamePacket with Product with Serializable
108.  final case class ObjectAttachMessage (parent_guid: PlanetSideGUID, child_guid: PlanetSideGUID, slot: Int) extends PlanetSideGamePacket with Product with Serializable

     Change the location of an object - the child - within the inventory system for another object - the parent.

     Change the location of an object - the child - within the inventory system for another object - the parent. (Where the child object was before it was moved is not specified or important.)
     The data portion of this packet defines a parent object, a child object to-be, and a destination. After the packet is delivered, the child object will be expected to be a possession of the parent object in the codified inventory location. The "inventory" of the parent object is a generalization of that object's containment or installation positions. The inventory is has different referral words for these positions depending on the target parent; but, it is generally "seats" or "mounting points" for vehicles; and, it is generally "holsters" or "grid inventory positions" for players. For players, "holsters" and "grid inventory positions" have 1:1 numerical mapping. For vehicles, however, "seats" and "mounting points" are not consistently mapped and are much more context sensitive. For that reason, this installation position will hitherto be referred to as a generic "slot."
     Both the client and the server can send and receive this packet. Its interplay with other packets simulate a lazy TCP-like approach to object manipulation. If the client sends this packet, it will generally have already done what it was going to do. If the server sends this packet, the client will have been waiting on confirmation of an action it previously requested.
     Player inventory slots:
     `0x80` - 0 - pistol holster 1
     `0x81` - 1 - pistol holster 2
     `0x82` - 2 - rifle holster 1
     `0x83` - 3 - rifle holster 2
     `0x84` - 4 - knife holster
     `0x86` - 6 - grid (1,1)
     `0x00FA` - 250 - is a special dest/extra code that "attaches the item to the player's cursor" `0x00FC` - 252 - special item slot e.g. LLU (Possibly also cavern modules)

     parent_guid

       the parent object

     child_guid

       the child object

     slot

       a codified location within the parent object's inventory; 8u (0 - 127 or `0x80 - 0xFF`) or 16u (128 - 32767 or `0x0080 - 0x7FFF`)

109.  final case class ObjectCreateDetailedMessage (streamLength: Long, objectClass: Int, guid: PlanetSideGUID, parentInfo: Option[ObjectCreateMessageParent], data: ConstructorData) extends PlanetSideGamePacket with Product with Serializable

     Communicate with the client that a certain object with certain properties is to be created.

     Communicate with the client that a certain object with certain properties is to be created. In general, `ObjectCreateMessage` and its counterpart `ObjectCreateDetailedMessage` should look similar.
     In normal packet data order, the parent object is specified before the actual object is specified. This is most likely a method of early correction. "Does this parent object exist?" "Is this new object something that can be attached to this parent?" "Does the parent have the appropriate attachment slot?" There is no fail-safe method for any of these circumstances being false, however, and the object will simply not be created. In instance where the parent data does not exist, the object-specific data is immediately encountered.
     The object's GUID is assigned by the server. The clients are required to adhere to this new GUID referring to the object. There is no fail-safe for a conflict between what the server thinks is a new GUID and what any client thinks is an already-assigned GUID. Likewise, there is no fail-safe between a client failing or refusing to create an object and the server thinking an object has been created. (The GM-level command `/sync` tests for objects that "do not match" between the server and the client. It's implementation and scope are undefined.)
     Knowing the object's type is essential for parsing the specific information passed by the `data` parameter. If the object does not have encoding information or is unknown, it will not translate between byte data and a game object.

     streamLength

       the total length of the data that composes this packet in bits, excluding the opcode and end padding

     objectClass

       the code for the type of object being constructed

     guid

       the GUID this object will be assigned

     parentInfo

       if defined, the relationship between this object and another object (its parent)

     data

       the data used to construct this type of object; on decoding, set to `None` if the process failed

110.  final case class ObjectCreateMessage (streamLength: Long, objectClass: Int, guid: PlanetSideGUID, parentInfo: Option[ObjectCreateMessageParent], data: ConstructorData) extends PlanetSideGamePacket with Product with Serializable

     Communicate with the client that a certain object with certain properties is to be created.

     Communicate with the client that a certain object with certain properties is to be created. In general, `ObjectCreateMessage` and its counterpart `ObjectCreateDetailedMessage` should look similar.
     `ObjectCreateMessage` is capable of creating every non-environmental object in the game through the use of encoding patterns. The objects produced by this packet generally do not always fully express all the complexities of the object class. With respect to a client's avatar, all of the items in his inventory are given thorough detail so that the client can account for their interaction. The "shallow" objects produced by this packet are not like that. They express only the essential information necessary for client interaction when the client interacts with them. For example, a weapon defined by this packet may not care internally what fire mode it is in or how much ammunition it has. Such a weapon is not in the client's player's holster or inventory. It is imperceptive information to which he would not currently have access. An `0x17` game object is, therefore, a game object with only the essential data exposed.
     When interacting with an `0x17` game object, the server will swap back and forth between it and an `0x18` object. (Or it will be removed when it is placed somewhere a given client will no longer be able to see it.) The purpose of this conversion is to control network traffic and object agency. It is not necessary to keep track of all objects on every player on every client individually. This relates to the goal of this packet exposing only "essential data." One player does not need to know how much ammunition remains in a weapon belonging to another player normally. One player also does not need to know how much ammunition is used up when another player reloads their weapon. The only way the first player will know is when the weapon is transferred into his own inventory. All other clients are spared micromanagement of the hypothetical other player's weapon. Updated information is only made available when and where it is needed.
     Knowing the object's type is necessary for proper parsing. If the object does not have encoding information or is unknown, it will not translate between byte data and a game object.

     streamLength

       the total length of the data that composes this packet in bits; exclude the opcode (1 byte) and end padding (0-7 bits); when encoding, it will be calculated automatically

     objectClass

       the code for the type of object being constructed; always an 11-bit LE value

     guid

       the GUID this object will be assigned

     parentInfo

       if defined, the relationship between this object and another object (its parent)

     data

       the data used to construct this type of object; on decoding, set to `None` if the process failed

     See also

       ObjectCreateDetailedMessage

       ObjectCreateMessageParent

111.  final case class ObjectDeleteMessage (object_guid: PlanetSideGUID, unk1: Int) extends PlanetSideGamePacket with Product with Serializable
112.  final case class ObjectDeployedMessage (unk: Int, desc: String, action: DeployOutcome.Value, count: Long, max: Long) extends PlanetSideGamePacket with Product with Serializable

     Dispatched by the server to generate a message in the events chat when placing deployables.
     This packet does not actually modify anything in regards to deployables.

     Dispatched by the server to generate a message in the events chat when placing deployables.
     This packet does not actually modify anything in regards to deployables. The most common form of the generated message is:
     `"You have placed x of a possible y thing s."`
     ... where `x` is the current count of objects of this type that have been deployed; `y` is the (reported) maximum amount of objects of this type that can be deployed; and, `thing` is the token for objects of this type. If the `thing` is a valid string token, it will be replaced by language-appropriate descriptive text in the message. Otherwise, that text is placed directly into the message, with an obvious space between the text and the "s". "boomer," for example, is replaced by "Boomer Heavy Explosives" in the message for English language. "bullet_9mm_AP," however, is just "bullet_9mm_AP s."
     When the `action` is `Success`, the message in the chat will be shown as above. When the `action` is `Failure`, the message will be:
     `"thing failed to deploy and was destroyed."`
     ... where, again, `thing` is a valid string token.

     unk

       na; usually 0?

     desc

       descriptive text of what kind of object is being deployed; string token of the object, at best

     action

       the form the message will take

     count

       the current number of this type of object deployed

     max

       the maximum number of this type of object that can be deployed

113.  final case class ObjectDetachMessage (parent_guid: PlanetSideGUID, child_guid: PlanetSideGUID, pos: Vector3, roll: Float, pitch: Float, yaw: Float) extends PlanetSideGamePacket with Product with Serializable

     Dispatched by the server to cause two associated objects to disentangle from one another.
     `ObjectDetachMessage` is the opposite of `ObjectAttachMessage`.

     Dispatched by the server to cause two associated objects to disentangle from one another.
     `ObjectDetachMessage` is the opposite of `ObjectAttachMessage`. When detached, the resulting freed object will be placed at the given coordinates in the game world. For detachment from some container objects, a default placement point may exist. This usually matches the position where the original mounting occurred, or is relative to the current position of the container. This mounting position overrides the input one, but other temporary side-effects may occur. For example, if a player detaches from a vehicle with coordinates for "somewhere else," the camera will temporarily be moved to that location "somewhere else" for the duration of the animation but it will soon regain the player who appeared where expected.
     An object that is already dropped is a special case where the parent (container) does not technically exist. The parent also does not need to exist as the object will still be transported to the specified coordinates.

     parent_guid

       the container/connector object

     child_guid

       the contained/connected object

     pos

       where the contained/connected object will be placed after it has detached

     roll

       the amount of roll that affects orientation of the dropped item

     pitch

       the amount of pitch that affects orientation of the dropped item

     yaw

       the amount of yaw that affects orientation of the dropped item

114.  final case class ObjectDetectedMessage (player_guid1: PlanetSideGUID, player_guid2: PlanetSideGUID, unk: Int, list: List[PlanetSideGUID]) extends PlanetSideGamePacket with Product with Serializable

     Update a list of (new) objects that have been detected by this client in one way or another.

     Update a list of (new) objects that have been detected by this client in one way or another.

     player_guid1

       the player

     player_guid2

       the player(?); often matches with `player_guid1`

     unk

       na; commonly, zero

     list

       list of detected objects; normally contains at least one element

115.  final case class ObjectHeldMessage (avatar_guid: PlanetSideGUID, held_holsters: Int, unk1: Boolean) extends PlanetSideGamePacket with Product with Serializable
116.  final case class OrbitalShuttleTimeMsg (model_state: HartSequence, unk0: Int, arrival_time: Long, boarding_time: Long, other_time: Long, pairs: List[PadAndShuttlePair]) extends PlanetSideGamePacket with Product with Serializable

     Control the animation state transitions of the high altitude rapid transport (HART) orbital shuttle building and the accompanying orbital shuttle model.
     The animation sequence is controlled primarily by the first field and goes through a strict cycle of boarding, lift shuttle, takeoff, land, lower shuttle.

     Control the animation state transitions of the high altitude rapid transport (HART) orbital shuttle building and the accompanying orbital shuttle model.
     The animation sequence is controlled primarily by the first field and goes through a strict cycle of boarding, lift shuttle, takeoff, land, lower shuttle. All HART facilities (amenity `obbasemesh`) in a given zone are controlled by this packet. Multiple systems are controlled by a single field during a given animation, e.g., the boarding gantries are retracted or extended during the same part where the shuttle is raised or lowered. Certain neutral animation states - `State0`, `State5`, and `State7` - all behave the same way though denote different points in the sequence. Animation subsequence states are coordinated by the second field, though the specific purpose of the subsequence isn't always obvious, and the field isn't always necessary to achieve the result of the primary sequence.
     The total time of the system is bound between two states: whether the shuttle has left or whether it is boarding. When separated ("has left"), the shuttle will be lifted out of the bay to atop the building and will fly off into the horizon, remaining despawned until it returns to view, perches atop the building again, and is lowered into the bay. When boarding, the shuttle is fixed in the bay and is accepting passengers via one of the boarding hallways. Upon boarding the shuttle, the time until takeoff ("has left") is displayed to all waiting passengers in the form of a progress bar. This progress bar is fixed to a full time of 60 seconds (60000 milliseconds) in the client and will start at fractions of completion for boarding times under 60 seconds.
     Pairs of globally unique identifiers for the shuttle facility and the shuttle link the time fields to their function. All facilities and shuttles in a given zone are paired and enumerated for a single packet. If the HART facility identifier is missing or incorrect, the absent facility will continue to undergo correct animation state transition, but the door timer will not animate correctly and constantly display the time 10:37 and the door lights will be neither locked closed (red) or openable (green). If the shuttle identifier is missing or incorrect, the absent shuttle will continue to undergo partially correct animation state transitions, cycling between visible and invisible atop the HART facility, and the aforementioned progress bars visible by shuttle passengers will not display during the boarding phase if the shuttle is made available for boarding.

     model_state

       a control code that affects the over-all state of the HART system

     unk0

       na

     arrival_time

       the time for the orbital shuttle to return during instances when the shuttle is away; displayed on a related time near the shuttle boarding entryways; in milliseconds

     boarding_time

       the time for the orbital shuttle to depart during instances when the shuttle is boarding; frequently `8000L` when not in use; in milliseconds

     other_time

       time field used for a variety of things; in most uses, the amount of time that has passed since the start of the event, so usually `0` (at start of event); with respects to `model_state` and `unk3`: full departure time when `5`-`3` (variant of `7`-`3`); occasionally, full departure time when `0`-`0` in milliseconds

     pairs

       a list of entries that pair a paired facility pad unique identifier and shuttle unique identifier with a control code

117.  final case class OrbitalStrikeWaypointMessage (guid: PlanetSideGUID, coords: Option[Waypoint] = None) extends PlanetSideGamePacket with Product with Serializable

     Dispatched by the server to tell the client to display an orbital strike waypoint somewhere in the game world.
     Waypoints are kept unique by the `guid` that is passed with them.

     Dispatched by the server to tell the client to display an orbital strike waypoint somewhere in the game world.
     Waypoints are kept unique by the `guid` that is passed with them. To clear a waypoint is to pass the another packet to the client with the same GUID but with no coordinates. Passing new coordinates with that GUID will update the position of the indicated waypoint. If the GUID sent with the packet belongs to the client's avatar that player will be given text overlay instructions:
     "Press the fire key or button to launch an orbital strike at the waypoint."
     The text will fade shortly after the waypoint has been cleared.
     All `OrbitalStrikeWaypointMessage` packets sent to a client will create a waypoint that will be seen by that client. All rendered waypoints, regardless of the users who summoned them, will be seen in the faction color of the client's avatar. (Black OPs orbital strike waypoints are green, as expected.) The server should not notify the wrong clients about another faction's prepared orbital strikes; however, even if it did, those beams would be seen as a same-faction's marker.

     guid

       coordinates used to identify the waypoint; ostensibly, the GUID of the player who placed the waypoint

     coords

       the coordinates of the waypoint; `None` if clearing a waypoint (use the same `guid` as to create it)

118.  final case class OxygenStateMessage (player: DrowningTarget, vehicle: Option[DrowningTarget]) extends PlanetSideGamePacket with Product with Serializable

     Dispatched by the server to cause the player to slowly drown.

     Dispatched by the server to cause the player to slowly drown. If the player is mounted in a vehicle at the time, alert the player that the vehicle may be disabled.
     When a player walks too far underwater, a borderless red progress bar with a countdown from 100 (98) is displayed across the screen. The flavor text reads "Oxygen level". The countdown proceeds to zero at a fixed rate - it takes approximately 60s - and is timed with the depleting progress bar. When it reaches zero, the player will be killed. If the player is in a vehicle after a certain depth, a blue bar and countdown pair will superimpose the red indicators. It depletes much more rapidly than the red indicators - it takes approximately 5s. When it reaches zero, the vehicle will become disabled. All players in the vehicle's seats will be kicked and they will not be allowed back in.
     Normally, the countdowns should be set to begin at 100 (100.0). This is the earliest the drowning GUI will appear for either blue or red indicators. Greater intervals - up to 204.8 - will start the countdown silently but the GUI will be hidden until 100.0. (The progress indicators will actually appear to start counting from 98.)

     player

       the player's oxygen state

     vehicle

       optional oxygen state of the vehicle the player is driving; the player must be mounted in the vehicle (at start time)

119.  final case class PadAndShuttlePair (pad: PlanetSideGUID, shuttle: PlanetSideGUID, unk: Int) extends Product with Serializable

     Paired globally unique identifier numbers, the first one being the pad (`obbasemesh`) of a HART shuttle building, the second being the shuttle itself.

     Paired globally unique identifier numbers, the first one being the pad (`obbasemesh`) of a HART shuttle building, the second being the shuttle itself.

     pad

       the HART shuttle pad

     shuttle

       the HART orbital shuttle

     unk

       a control code; has indeterminate purpose regardless of the phase expressed in the greater packet; frequently `20` but also frequently varies

120.  final case class PickupItemMessage (item_guid: PlanetSideGUID, player_guid: PlanetSideGUID, unk1: Int, unk2: Int) extends PlanetSideGamePacket with Product with Serializable

     Dispatched by the client when the player's intent is to collect an item from the ground.
     When a player faces a freed item on the ground in the game world, a prompt appears that invites him to pick it up.

     Dispatched by the client when the player's intent is to collect an item from the ground.
     When a player faces a freed item on the ground in the game world, a prompt appears that invites him to pick it up. Doing so generates this packet. The server determines the exact inventory position where the item will get placed. If the inventory has insufficient space to accommodate the item, it gets put into the player's hand (on the cursor).
     This packet is complemented by an `ObjectAttachMessage` packet from the server that performs the actual "picking up."

     item_guid

       na

     player_guid

       na

     unk1

       na

     unk2

       na

121.  final case class PingMsg (serverSlot: Long, ticks: Long) extends PlanetSideGamePacket with Product with Serializable

     Sent periodically by the PlanetSide client when connected to the Login server.

     Sent periodically by the PlanetSide client when connected to the Login server. Not encrypted

     serverSlot

       Which server on the server display is the ping referring to

     ticks

       The number of ticks. Usually just reflected back to the client

122.  case class PlanetSideZoneID (zoneId: Long) extends Product with Serializable
123.  final case class PlanetsideAttributeMessage (guid: PlanetSideGUID, attribute_type: Int, attribute_value: Long) extends PlanetSideGamePacket with Product with Serializable

     na
     Global:
     `50 - State initialization for amenities`

     na
     Global:
     `50 - State initialization for amenities`

     - 0 - Normal, accessible ("Press 'e' to ...")
     - 1 - Fully destroyed model, inaccessible ("foo is destroyed and can not be accessed")

     `51 - Common initialization for amenities, complementary to attribute 50`

     - 0 - Normal, accessible
     - 1 - Partially destroyed model, still accessible
     - 2 - Explicitly set in transition from state 1; same as state 1?

     `67 - ???`
     Global (GUID=0)
     `75 - Russian client region check` (value checks with bitmask `& 8`)
     `82 - ???`
     `83 - max boomers`
     `84 - max he mines`
     `85 - max disruptor mines`
     `86 - max spitfire turrets`
     `87 - max motion sensors`
     `88 - max shadow turrets`
     `89 - max cerebus turrets`
     `90 - max Aegis shield generators`
     `91 - max TRAPs`
     `92 - max OMFTs`
     `93 - max sensor disruptors`
     `94 - boomers`
     `95 - he mines`
     `96 - disruptor mines`
     `97 - spitfire turrets`
     `98 - motion sensors`
     `99 - shadow turrets`
     `100 - cerebus turrets`
     `101 - Aegis shield generators`
     `102 - TRAPSs`
     `103 - OMFTs`
     `104 - sensor disruptors`
     `112 - enable/disable festive backpacks`
     Players/General:
     Server to client :
     `0 - health (setting to zero on vehicles/terminals will destroy them)`
     `1 - healthMax`
     `2 - stamina`
     `3 - staminaMax`
     `4 - armor`
     `5 - armorMax`
     `6 - PA_RELEASED - transform the (other) avatar in backpack on ground`
     `7 - Sets charge level for MAX capacitor`
     `8 - Enables empire specific max capacitor function - NC Shield, TR Overdrive, VS Jumpjets`
     `9 - Possibly unused now - PA_SHIELDSTRENGTH in beta client`
     `14 - Something with grief`
     `15 - Weapon Lock. Value exemple : 600 to have 1 min lock. Max possible is 30min lock`
     `16 - PA_DECONSTRUCTING in beta client`
     `17 - BEP. Value seems to be the same as BattleExperienceMessage`
     `18 - CEP.`
     `19 - Anchors. Value is 0 to disengage, 1 to engage.`
     `20 - Control console hacking, affects CC timer, yellow base warning lights and message "The FactionName has hacked into BaseName". Format is: Time left - 2 bytes, faction - 1 byte (1-4), isResecured - 1 byte (0-1)`

     - 65535 segments per faction in deciseconds (seconds * 10)
     - 0-65535 = Neutral 0 seconds to 1h 49m 14s - 0x0000 to 0xFFFF
     - 65536 (0x10000) - 131071 (0x1FFFF) - TR
     - 131072 (0x20000) - 196607 (0x2FFFF) - NC
     - 196608 (0x30000) - 262143 (0x3FFFF) - VS
     - 17039360 (0x1040000) - CC Resecured

     `24 - Learn certification:`

     - 01 - Medium Assault
     - 02 - Heavy Assault
     - 03 - Special Assault
     - 04 - Anti-Vehicular
     - 05 - Sniping
     - 06 - Elite Assault
     - 07 - Air Cavalry, Scout
     - 08 - Air Cavalry, Interceptor
     - 09 - Air Cavalry, Assault
     - 10 - Air Support
     - 11 - ATV
     - 12 - Light Scout
     - 13 - Assault Buggy
     - 14 - Armored Assault 1
     - 15 - Armored Assault 2
     - 16 - Ground Transport
     - 17 - Ground Support
     - 18 - BattleFrame Robotics
     - 19 - Flail
     - 20 - Switchblade
     - 21 - Harasser
     - 22 - Phantasm
     - 23 - Galaxy Gunship
     - 24 - BFR Anti Aircraft
     - 25 - BFR Anti Infantry
     - 26 - ?! Removed Cert ?
     - 27 - ?! Removed Cert ?
     - 28 - Reinforced ExoSuitDefinition
     - 29 - Infiltration Suit
     - 30 - AA MAX
     - 31 - AI MAX
     - 32 - AV MAX
     - 33 - Uni-MAX
     - 34 - Medical
     - 35 - Advanced Medical
     - 36 - Hacking
     - 37 - Advanced Hacking
     - 38 - Expert Hacking
     - 39 - Data Corruption
     - 40 - Electronics Expert (= Expert Hacking + Data Corruption) Must have Advanced Hacking
     - 41 - Engineering
     - 42 - Combat Engineering
     - 43 - Fortification Engineering
     - 44 - Assault Engineering
     - 45 - Advanced Engineering (= Fortification Engineering + Assault Engineering) Must have Combat Engineering

     `25 - Forget certification: ... (see 24)`
     `26 - Certification reset timer (in seconds)` `27 - PA_JAMMED - plays jammed buzzing sound in vicinity of target, jams weapon discharge`
     `28 - PA_IMPLANT_ACTIVE - Plays implant sounds. Valid values seem to be up to 20.`
     `29 - PA_VAPORIZED - Visible ?! That's not the cloaked effect, Maybe for spectator mode ?. Value is 0 to visible, 1 to invisible.`
     `31 - Looking for Squad info (marquee and ui):`

     - 0 - LFS
     - 1 is LFSM (Looking for Squad Members)``
     - `n` is the supplemental squad identifier number; same as "LFS;" for the leader, sets "LFSM" after the first manual flagging``

     `32 - Maintain the squad role index, when a member of a squad`
     `35 - Battle Rank`
     `36 - Command Rank`
     `38 - Spawn active or not. MUST use base MapId not base GUID`
     `43 - Info on avatar name : 0 = Nothing, 1 = "(LD)" message`
     `45 - NTU charge bar 0-10, 5 = 50% full. Seems to apply to both ANT and NTU Silo (possibly siphons?)`
     `46 - Sends "Generator damage is at a critical level!" message` `47 - Sets base NTU level to CRITICAL.`
     `48 - Set to 1 to send base power loss message & turns on red warning lights throughout base.`
     `49 - Vehicle texture effects state? (>0 turns on ANT panel glow or ntu silo panel glow + orbs) (bit?)`
     `52 - Vehicle particle effects? (>0 turns on orbs going towards ANT. Doesn't affect silo) (bit?)`
     `53 - LFS. Value is 1 to flag LFS`
     `54 - Player "Aura". Values can be expressed in the first byte's lower nibble:`

     - 0 - nothing
     - 1 - plasma
     - 2 - ancient
     - 4 - LLU (?)
     - 8 - fire
     - e.g., 13 = 8 + 4 + 1 = fire and LLU and plasma

     `55 - "Someone is attempting to Heal you". Value is 1`
     `56 - "Someone is attempting to Repair you". Value is 1`
     `64 - ????? related to using router telepads` `67 - Enables base shields (from cavern module/lock)`
     `73 - "You are locked into the Core Beam. Charging your Module now.". Value is 1 to active`
     `77 - Cavern Facility Captures. Value is the number of captures`
     `78 - Cavern Kills. Value is the number of kills`
     `106 - Avatar Cosmetics`
     `116 - Apply colour to REK beam and REK icon above players`

     - 0 = yellow
     - 1 = red
     - 2 = purple
     - 3 = blue

     Client to Server :
     `106 - Custom Head`
     `224 - Player/vehicle joins black ops`
     `228 - Player/vehicle leaves black ops`
     `Vehicles:`
     `10 - Driver mount permissions`

     - 0 - Locked
     - 1 - Group
     - 3 - Empire

     `11 - Gunner mount(s) permissions (same)`
     `12 - Passenger mount(s) permissions (same)`
     `13 - Trunk permissions (same)`
     `21 - Declare a player the vehicle's owner, by globally unique identifier`
     `22 - Toggles gunner and passenger mount points (1 = hides, 0 = reveals; this also locks their permissions)`
     `54 - Plays jammed buzzing sound in vicinity of target`
     `55 - Trigger APC EMP`
     `68 - Vehicle shield health`
     `79 - ???`
     `80 - Damage vehicle (unknown value)`
     `81 - ???`
     `113 - Vehicle capacitor - e.g. Leviathan EMP charge`

     guid

       the object

     attribute_type

       the field

     attribute_value

       the value

124.  final case class PlanetsideStringAttributeMessage (guid: PlanetSideGUID, string_type: Int, string_value: String) extends PlanetSideGamePacket with Product with Serializable

     na
     The one common use of this packet is to transmit information about the name of the player's outfit during login.

     na
     The one common use of this packet is to transmit information about the name of the player's outfit during login. The guid will belong to the player; the "type will be 0; the outfit name will appear on the appropriate window.

     guid

       na

     string_type

       na

     string_value

       na

125.  final case class PlayerStasisMessage (player_guid: PlanetSideGUID, stasis: Boolean = true) extends PlanetSideGamePacket with Product with Serializable

     Causes the avatar to be prepped for drop pod use.
     This packet is dispatched from the server to all occupants of the HART shuttle when it has completed its take-off animation.

     Causes the avatar to be prepped for drop pod use.
     This packet is dispatched from the server to all occupants of the HART shuttle when it has completed its take-off animation. When received by the client, that player's avatar is "removed from the world" and the Interstellar Map is displayed for them. The "Launch Drop Pod" button window is also made visible. Selecting individual continental maps for viewing and clicking on the landmasses has the expected behavior for drop pods implementation.
     Being seated on the HART shuttle at the time, a player's avatar does not physically exist when the packet is received. If the packet is received while the player is outside of the HART shuttle, the state of their avatar is not known to them. "Removed from the world" merely implies that one can not leave the Interstellar Map once it has been displayed. According to packet capture, their avatar is not explicitly deconstructed until the dropped-into map is loaded.
     When the packet is received on one's client, but is addressed to another player, nothing seems to happen to that player. If that player's model is outside of the HART, it will not deconstruct. Only the client's avatar can be affected by this packet.

     player_guid

       the player

     stasis

       `true` by default; nothing when `false` (?)

126.  final case class PlayerStateMessage (guid: PlanetSideGUID, pos: Vector3, vel: Option[Vector3], facingYaw: Float, facingPitch: Float, facingYawUpper: Float, timestamp: Int, is_crouching: Boolean = false, is_jumping: Boolean = false, jump_thrust: Boolean = false, is_cloaked: Boolean = false) extends PlanetSideGamePacket with Product with Serializable

     The server instructs some clients to render a player (usually not that client's avatar) to move in a certain way.
     This packet instructs the basic aspects of how the player character is positioned and how the player character moves.

     The server instructs some clients to render a player (usually not that client's avatar) to move in a certain way.
     This packet instructs the basic aspects of how the player character is positioned and how the player character moves. Each client keeps track of where a character "currently" is according to that client. `pos` reflects an update in regards to where the character should be moved. Data between this "currently" and "new" are interpolated over a fixed time interval. Position and velocity data is standard to normal PlanetSide ranges. All angles follow the convention that every `0x1` is about 2.8125 degrees; so, `0x10` is 45.0 degrees.
     The avatar model normally moves from where it "currently" is to `pos`. When `vel` is defined, `pos` is treated as where the avatar model starts its animation. In that case, it appears to teleport to `pos` to carry out the interpolated movement according to `vel`. After the move, it remains at essentially `pos + vel * t`. The repositioning always takes the same amount of time. The player model is left in a walking/running animation (in place) until directed otherwise.
     If the model must interact with the environment during a velocity-driven move, it copes with local physics. A demonstration of this is what happens when one player "runs past"/"into" another player running up stairs. The climbing player is frequently reported by the other to appear to bounce over that player's head. If the other player is off the ground, passing too near to the observer can cause a rubber band effect on trajectory. This effect is entirely client-side to the observer and affects the moving player in no way.

     guid

       the avatar's guid

     pos

       the position of the avatar in the world environment (in three coordinates)

     vel

       an optional velocity

     facingYaw

       a "yaw" angle

     facingPitch

       a "pitch" angle

     facingYawUpper

       a "yaw" angle that represents the angle of the avatar's upper body with respect to its forward-facing direction; this number is normally 0 for forward facing; the range is limited between approximately 61 degrees of center turned to left or right

     timestamp

       A sequential counter

     is_crouching

       avatar is crouching

     is_jumping

       avatar is jumping; must remain flagged for jump to maintain animation

     jump_thrust

       provide a measure of vertical stability when really close to the avatar character

     is_cloaked

       avatar is cloaked by virtue of an Infiltration Suit

127.  final case class PlayerStateMessageUpstream (avatar_guid: PlanetSideGUID, pos: Vector3, vel: Option[Vector3], facingYaw: Float, facingPitch: Float, facingYawUpper: Float, seq_time: Int, unk1: Int, is_crouching: Boolean, is_jumping: Boolean, jump_thrust: Boolean, is_cloaked: Boolean, unk2: Int, unk3: Int) extends PlanetSideGamePacket with Product with Serializable

     Constantly sent from the client to the server to update player avatar properties.
     Exploration:
     `seq_time` appears to be used in other message definitions as well.

     Constantly sent from the client to the server to update player avatar properties.
     Exploration:
     `seq_time` appears to be used in other message definitions as well. It seems to represent a timestamp for ordering, e.g., player and weapon events.

     avatar_guid

       the player's GUID

     pos

       where the player is in the world

     vel

       how the player is moving

     facingYaw

       a "yaw" angle

     facingPitch

       a "pitch" angle; 0 for forward-facing; 75.9375 for the up-facing limit; -73.125 for the down-facing limit

     facingYawUpper

       a "yaw" angle that represents the angle of the avatar's upper body with respect to its forward-facing direction; 0 for forward-facing; +/-61.875 for the clockwise/counterclockwise turn limits, respectively

     seq_time

       the "time frame" according to the server; starts at 0; max value is 1023 before resetting

     unk1

       na

     is_crouching

       avatar is crouching

     is_jumping

       avatar is jumping; must remain flagged for jump to maintain animation

     jump_thrust

       provide a measure of vertical stability when really close to the avatar character

     is_cloaked

       avatar is cloaked by virtue of an Infiltration Suit

     unk2

       na

     unk3

       na

128.  final case class PlayerStateShiftMessage (state: Option[ShiftState], unk: Option[Int] = None) extends PlanetSideGamePacket with Product with Serializable

     Push specific motion-based stimuli on a specific character.
     `PlayerStateMessageUpstream` involves data transmitted from a client to the server regarding its avatar.

     Push specific motion-based stimuli on a specific character.
     `PlayerStateMessageUpstream` involves data transmitted from a client to the server regarding its avatar. `PlayerStateMessage` involves data transmitted from the server to the clients regarding characters other than that client's avatar. `PlayerStateShiftMessage` involves data transmitted from the server to a client about that client's avatar. It temporarily asserts itself before normal player movement and asserts specific placement and motion. An application of this packet is being `/warp`ed within a zone via a non-triggering agent (like a teleporter). Another, more common, application of this packet is being thrown about when the target of an attempted roadkill.

     state

       if defined, the behaviors to influence the character

     unk

       na

129.  sealed abstract class ProjectileCharacteristics extends IntEnumEntry
130.  final case class ProjectileStateMessage (projectile_guid: PlanetSideGUID, shot_pos: Vector3, shot_vel: Vector3, shot_original_orient: Vector3, sequence_num: Int, end: Boolean, hit_target_guid: PlanetSideGUID) extends PlanetSideGamePacket with Product with Serializable

     Dispatched to deliberately control certain projectiles of a weapon on other players' clients.
     This packet should be generated by firing specific weapons in specific fire modes.

     Dispatched to deliberately control certain projectiles of a weapon on other players' clients.
     This packet should be generated by firing specific weapons in specific fire modes. For example, the Phoenix (`hunterseeker`) discharged in its primary fire mode generates this packet; but, the Phoenix in secondary fire mode does not. The Striker (`striker`) discharged in its primary fire mode generates this packet; but, the Striker in secondary fire mode does not. The chosen fire mode(s) are not a straight-fire projectile but one that has special control asserted over it. For the Phoenix, it is user operated (camera-guided). For the Striker, it tracks towards a valid target while the weapon's reticle hovers over that target.
     This packet will continue to be dispatched by the client for as long as the projectile being tracked is in the air. All projectiles have a maximum lifespan before they will lose control and either despawn and/or explode. This number is tracked in the packet for simplicity.
     This control can not be demonstrated until that projectile is physically constructed on the other clients in the same way that a player or a vehicle is constructed. A projectile that exhibits intentional construction behavior is flagged using the property `exists_on_remote_client`. The model comes with a number of caveats, some that originate from the object construction process itself, but also some from this packet. For example, as indicated by the static `shot_original_orient` values reported by this packet. a discharged controlled projectile will not normally rotate. A minor loss of lifespan may be levied.

     projectile_guid

       when dispatched by the client, the client-specific local unique identifier of the projectile; when dispatched by the server, the global unique identifier for the synchronized projectile object

     shot_pos

       the position of the projectile

     shot_vel

       the velocity of the projectile

     shot_original_orient

       the orientation of the projectile when it was discharged

     sequence_num

       an incrementing index of the packet in this projectile's lifetime; suggests the "time alive" and indicates a place in packet ordering

     end

       indicates the projectile has reached the end of its lifespan; usually, it should explode

     hit_target_guid

       the global unique identifier of the object the projwectile collided with; will be 0 if it reached the end of its life naturally, without colliding with anything

     See also

       `ProjectileDefinition`

       `RemoteProjectileData`

131.  final case class PropertyOverrideMessage (list: List[PropertyOverrideMessage.GamePropertyScope]) extends PlanetSideGamePacket with Product with Serializable

     Dispatched by the server to alert the client about custom permissions in different zones.
     The primarily way this packet was used on Gemini Live was to restrict weapons per zone.

     Dispatched by the server to alert the client about custom permissions in different zones.
     The primarily way this packet was used on Gemini Live was to restrict weapons per zone. The Battle Island restrictions, for example, were enforced by these properties.
     Exploration:
     What else can you do with this packet?

     list

       a `List` defining scopes for the targets of internal property changes

132.  final case class ProximityTerminalUseMessage (player_guid: PlanetSideGUID, object_guid: PlanetSideGUID, unk: Boolean) extends PlanetSideGamePacket with Product with Serializable

     The player's avatar has moved in relation to a set piece that reacts with the player due to his proximity.
     Elements that exhibit this behavior include Repair/Rearm Silos in facility courtyards and various cavern crystals.

     The player's avatar has moved in relation to a set piece that reacts with the player due to his proximity.
     Elements that exhibit this behavior include Repair/Rearm Silos in facility courtyards and various cavern crystals. The packets are only dispatched when it is appropriate for the player to be affected.
     Exploration:
     Packets where the bytes for the player's GUID are blank exist.

     player_guid

       the player

     object_guid

       the object whose functionality is triggered

     unk

       na

133.  final case class QuantityDeltaUpdateMessage (item_guid: PlanetSideGUID, quantity_delta: Int) extends PlanetSideGamePacket with Product with Serializable

     Instructs client to update the quantity of an item based on a delta when sent server to client.

     Instructs client to update the quantity of an item based on a delta when sent server to client.

     See also QuantityUpdateMessage

     item_guid

       the item to update

     quantity_delta

       the change in quantity of the item

134.  final case class QuantityUpdateMessage (item_guid: PlanetSideGUID, quantity: Int) extends PlanetSideGamePacket with Product with Serializable

     Instructs client to update the quantity of an item when sent server to client.

     Instructs client to update the quantity of an item when sent server to client.

     See also QuantityDeltaUpdateMessage

     item_guid

       the item to update

     quantity

       the quantity to update the item to

135.  final case class ReleaseAvatarRequestMessage () extends PlanetSideGamePacket with Product with Serializable

     Packet send by client when clic on button after death https://streamable.com/4r16m

136.  final case class ReloadMessage (item_guid: PlanetSideGUID, ammo_clip: Long, unk1: Int) extends PlanetSideGamePacket with Product with Serializable
137.  final case class RepairMessage (item_guid: PlanetSideGUID, repair_value: Long) extends PlanetSideGamePacket with Product with Serializable

     Dispatched to the client to report the amount of repair that is performed upon a target item.

     Dispatched to the client to report the amount of repair that is performed upon a target item. On the client, a progress bar window is displayed with the appropriate repair type and amount. The item could be a player or a vehicle or a stationary game object, e.g., a terminal.

     item_guid

       a game object; the kind of object influences the kind of repair

     repair_value

       the percentage of maximum health that the object possesses after repairs; as the value is a percentage, it should be from 0 to 100; at 100, the progress window does not display anymore; above 100, the progress window stays displayed unless the underlying process is interrupted

138.  final case class ReplicationStreamMessage (behavior: Int, behavior2: Option[Int], entries: Vector[SquadListing]) extends PlanetSideGamePacket with Product with Serializable

     Display the list of squads available to a given player.
     The four main operations are: initializing the list, updating entries in the list, removing entries from the list, and clearing the list.

     Display the list of squads available to a given player.
     The four main operations are: initializing the list, updating entries in the list, removing entries from the list, and clearing the list. The process of initializing the list and clearing the list actually are performed by similar behavior. Squads would just not be added after the list clears. Moreover, removing entries from the list overrides the behavior to update entries in the list. Squad list entries are typically referenced by their line index.
     Though often specified with a global identifier, squads are rarely accessed using that identifier. Outside of initialization activities, the specific index of the squad listing is referenced. During the list initialization process, the entries must be in ascending order of index. The total number of entries in a packet is not known until they have all been parsed. The minimum number of entries is "no entries." The maximum number of entries is supposedly 254. The last item is always the index 255 and this is interpreted as the end of the stream.
     When no updates are provided, the client loads a default (but invalid) selection of data comprising four squads:
     `0 Holeesh another purpose Desolation 6/7`
     `1 Korealis another purpose Drugaskan 10/10`
     `2 PsychoSanta blah blah blah 10/10`
     `3 Squishling another purpose Cyssor 8/10`
     The last entry is entirely in green text.
     Behaviors:
     `behavior behavior2`
     `1 X` Update where initial entry removes a squad from the list
     `5 6` Clear squad list and initialize new squad list
     `5 6` Clear squad list (transitions directly into 255-entry)
     `6 X` Update a squad in the list

     behavior

       a required code that suggests the operations of the data in this packet

     behavior2

       an optional code that suggests the operations of the data in this packet; during initialization, this code is read; it typically flags an "update" action

     entries

       a `Vector` of the squad listings

139.  final case class RequestDestroyMessage (object_guid: PlanetSideGUID) extends PlanetSideGamePacket with Product with Serializable
140.  final case class RespawnAMSInfoMessage (unk1: PlanetSideGUID, unk2: Boolean, unk3: Option[RespawnInfo]) extends PlanetSideGamePacket with Product with Serializable
141.  final case class RespawnInfo (unk1: List[Vector3], unk2: List[Boolean]) extends Product with Serializable
142.  sealed abstract class ServerType extends IntEnumEntry
143.  final case class ServerVehicleOverrideMsg (lock_accelerator: Boolean, lock_wheel: Boolean, reverse: Boolean, unk4: Boolean, lock_vthrust: Int, lock_strafe: Int, movement_speed: Int, unk8: Option[Long]) extends PlanetSideGamePacket with Product with Serializable

     Dispatched by server to assert control of a player's vehicle, usually temporarily, and to relinquish that control.
     The "vehicle" counts as any mobile platform where the user's character is currently sitting.

     Dispatched by server to assert control of a player's vehicle, usually temporarily, and to relinquish that control.
     The "vehicle" counts as any mobile platform where the user's character is currently sitting. If the player is not sitting in what the game considers a "vehicle," the packet is wasted. Either of the first two parameters - `lock_accelerator` or `lock_wheel` - constitutes any vehicle being overrode. Either of the latter two parameters - `lock_thrust` or `lock_strafe` - constitutes a flight vehicle being overrode. No message is displayed if the vehicle is placed under any form of server control. During server control, this is an acceleration value (?); during cancellable auto-drive, a constant velocity value. Vertical thrust control for aircraft is either on or off; the amount of that thrust can not be controlled.
     After being controlled, when the vehicle is no longer under control, it will transition into a state of constant speed auto-drive. The message regarding the vehicle being back in the driver's control will display, unless one of the aforementioned `lock_*` parameters is still set to `true`. When dismounting a bailable vehicle while it is under the server's control, the player will behave like they are bailing from it. (The vehicle actually has to be "bailable" first, of course.)
     "Something like speed:"
     For ground vehicles, for `n`, the calculated in-game speed for the value in this packet will be at least `3.45 x n`. For flight vehicles, for `n`, the forward air speed for the value in this packet will be at least `1.18 * n`. This approximation is not always going to be accurate but serves as a good rule of thumb.

     lock_accelerator

       driver has no control over vehicle acceleration

     lock_wheel

       driver has no control over vehicle turning

     reverse

       move in reverse 0 = forward 1 = reverse

     unk4

       na; something to do with vehicle bailable speed

     lock_vthrust

       pilot has no control over vertical thrust; asserts a constant positive vertical thrust; the only valid setting appears to be 1

     lock_strafe

       pilot has no control over strafing thrust; 0 = not locked 1 = no strafing 2 = strafe left automatically 3 = strafe right automatically

     movement_speed

       "something like speed"

     unk8

       na; set `lock_wheel` to `true` to expose this value

144.  final case class SetChatFilterMessage (send_channel: ChatChannel.Value, origin: Boolean, whitelist: List[ChatChannel.Value]) extends PlanetSideGamePacket with Product with Serializable

     Which comm.

     Which comm. channels are allowed to display in the main chat window. The server sends a `SetChatFilterMessage` and the client responds with the same during login.
     Nine channels exist. Their values can be modified by radio buttons found under the current chat window's "Options" pane. Each time the client updates the channel permissions, it sends this packet to the server nine times. The packet starts with the previous channel filter states and then updates each channel sequentially.
     The `send_channel` and the `channel_filter` values are in the following order:
     Unknown, Tells, Local, Squad, Outfit, Command, Platoon, Broadcast, Squad Leader
     The first channel is unlisted.

     send_channel

       automatically select the fully qualified channel to which the user sends messages

     origin

       where this packet was dispatched; `true`, from the server; `false`, from the client

     whitelist

       each channel permitted to post its messages; when evaluated from a packet, always in original order

145.  final case class SetCurrentAvatarMessage (guid: PlanetSideGUID, unk1: Int, unk2: Int) extends PlanetSideGamePacket with Product with Serializable
146.  final case class SetEmpireMessage (object_guid: PlanetSideGUID, empire: types.PlanetSideEmpire.Value) extends PlanetSideGamePacket with Product with Serializable

     The object_guid space for SetEmpireMessage is continent specific.

     The object_guid space for SetEmpireMessage is continent specific. SetEmpireMessage is usually followed by HackMessage (indicating the hack disposition of the same object_guid)

147.  final case class ShiftState (unk: Int, pos: Vector3, viewYawLim: Float, vel: Option[Vector3]) extends Product with Serializable

     Instructs an avatar to be stood, to look, and to move, in a certain way.
     The position defines a coordinate location in the avatar's current zone to which the avatar is immediately moved This movement is instantaneous and has no associated animation.

     Instructs an avatar to be stood, to look, and to move, in a certain way.
     The position defines a coordinate location in the avatar's current zone to which the avatar is immediately moved This movement is instantaneous and has no associated animation. If velocity is defined, the avatar is provided an "external force" that "pushes" the avatar in a given direction. This external force is not accumulative. Also, the external force is only applied once the avatar is set to the provided position.
     The angle defines the center of a range of angles that count as "in front of the avatar." Specifically, this range is the upper body's turn limit. A stationary player may look left and right, rotating their upper body only, until they hit a certain angle. Normally, the player's whole body will then turn to accommodate turning further than this angle. This packet marks that limit as a hard limit for rotation and will reset the player's model and camera if necessary. While it is in effect, the player will not turn their whole body once they can no longer turn their upper body.

     unk

       na

     pos

       the position to move the character to in the world environment

     viewYawLim

       the center of the range of upper body angles, the player's actual yaw; if this value is beyond its angular limit values, the model will attempt to snap to what it considers the closest upper body turning limit angle; the actual range is approximately `viewYawLimit +/- 61.8215`;

     vel

       if defined, the velocity to apply to to the character at the given position

     See also

       `PlayerStateMessageUpstream.facingYawUpper`

       `PlayerStateMessage.facingYawUpper`

148.  final case class Shortcut (purpose: Int, tile: String, effect1: String = "", effect2: String = "") extends Product with Serializable

     Details regarding this shortcut.
     The parameters `purpose` and `tile` are closely related.

     Details regarding this shortcut.
     The parameters `purpose` and `tile` are closely related. These two fields are consistent for all shortcuts of the same type. `purpose` indicates the purpose of the shortcut. `tile` is related to what kind of graphic is displayed in this shortcut's slot on the hotbar based on its purpose. The parameters `effect1` and `effect2` are exclusive to text macro shortcuts and are defaulted to empty `String`s.
     The `shortcut_macro` setting displays a word bubble superimposed by the (first three letters of) `effect1` text.
     Implants and the medkit should have self-explanatory graphics.
     Purpose:
     `0 - Medkit`
     `1 - Macro`
     `2 - Implant`
     Tile:
     `advanced_regen` (regeneration)
     `audio_amplifier`
     `darklight_vision`
     `medkit`
     `melee_booster`
     `personal_shield`
     `range_magnifier`
     `second_wind`
     `shortcut_macro`
     `silent_run` (sensor shield)
     `surge`
     `targeting` (enhanced targetting)
     Exploration:
     What is `purpose` when 3?

     purpose

       the primary use of this shortcut

     tile

       the visual element of the shortcut

     effect1

       for macros, a three letter acronym displayed in the hotbar

     effect2

       for macros, the chat message content

149.  final case class SimDataChallenge (unk1: List[Long], unk2: Boolean, unk3: Int, unk4: Long, unk5: Boolean) extends PlanetSideGamePacket with Product with Serializable

     na

     na

     unk1

       na

     unk2

       na

     unk3

       na

     unk4

       na

     unk5

       na

150.  final case class SimDataChallengeResp (unk1: List[Long], unk2: List[Long], unk3: Boolean) extends PlanetSideGamePacket with Product with Serializable

     na

     na

     unk1

       na

     unk2

       na

     unk3

       na

151.  final case class SpawnRequestMessage (unk1: Int, spawn_type: SpawnGroup, unk3: Int, unk4: Int, zone_number: Int) extends PlanetSideGamePacket with Product with Serializable

     na

     na

     unk1

       when defined, na; non-zero when selecting the sanctuary option from a non-sanctuary continent deployment map

     spawn_type

       the type of spawn point destination

     unk3

       na

     unk4

       na

     zone_number

       when defined, the zone number

152.  final case class SplashHitMessage (unk1: Int, projectile_uid: PlanetSideGUID, projectile_pos: Vector3, unk2: Int, unk3: Int, projectile_vel: Option[Vector3], unk4: Option[Int], targets: List[SplashedTarget]) extends PlanetSideGamePacket with Product with Serializable

     Dispatched to the server when a type of effect that influence multiple targets activates.
     Splash does not refer to the effect upon an applicable target.

     Dispatched to the server when a type of effect that influence multiple targets activates.
     Splash does not refer to the effect upon an applicable target. Splash denotes the fixed radius wherein a said effect exerts temporary influence. Being damaged is the most common splash effect; the jammering effect is another. A pain field does not count because it is an environmental constant. Lashing is considered different because it is a type of inheritable influence.
     Valid targets for splash are all interactive game objects that maintain a GUID. This includes: players, of course; vehicles, of course; doors; terminals; spawn tubes; and, such objects. Not all targets listed will actually be influenced by the effect carried by splash.
     The effect commonly modifies the visual depiction of the splash. Being able to "see" splash also does not necessarily mean that one will be influenced by it. Visually and spatially, it may seem to bleed through surfaces on occasion. The effect will not be carried, however. Splash will also respect the game's internal zoning and not pass through temporary obstacles like closed doors. Not being able to see splash also does not stop a target from being affected. The radius of influence is typically a bit larger than the visual indication.
     All sources of splash damage herein will be called "grenades" for simplicity.

     unk1

       na

     projectile_uid

       the grenade's object

     projectile_pos

       the position where the grenade landed (where it is)

     unk2

       na; frequently 42

     unk3

       na; frequently 0

     projectile_vel

       the velocity of the grenade when it landed

     unk4

       na

     targets

       a `List` of all targets influenced by the splash

153.  final case class SplashedTarget (uid: PlanetSideGUID, pos: Vector3, unk1: Long, unk2: Option[Int]) extends Product with Serializable

     An entry of the target that was hit by splash damage.

     An entry of the target that was hit by splash damage.

     uid

       the target's uid

     pos

       the target's position (when hit)

     unk1

       na

     unk2

       na

154.  abstract class SquadAction extends AnyRef

     The generic superclass of a specific behavior for this type of squad definition action.

     The generic superclass of a specific behavior for this type of squad definition action. All behaviors have a "code" that indicates how the rest of the data is parsed.

155.  final case class SquadDefinitionActionMessage (squad_guid: PlanetSideGUID, line: Int, action: SquadAction) extends PlanetSideGamePacket with Product with Serializable

     Manage composition and details of a player's current squad, or the currently-viewed squad.
     The `action` code indicates the format of the remainder data in the packet.

     Manage composition and details of a player's current squad, or the currently-viewed squad.
     The `action` code indicates the format of the remainder data in the packet. The following formats are translated; their purposes are listed:
     `(None)`
     `0` - Display Squad
     `1` - Answer Squad Join Request
     `2` - UNKNOWN
     `3` - Save Squad Favorite
     `4` - Load Squad Favorite
     `5` - Delete Squad Favorite
     `6` - UNKNOWN
     `8` - Request List Squad
     `9` - Stop List Squad
     `16` - Associate with Squad
     `17` - Set List Squad (ui)
     `18` - UNKNOWN
     `26` - Reset All
     `32` - UNKNOWN
     `35` - Cancel Squad Search
     `39` - No Squad Search Results
     `41` - Cancel Find
     `42` - UNKNOWN
     `43` - UNKNOWN
     `Boolean`
     `28` - Auto-approve Requests for Invitation
     `29` - UNKNOWN
     `30` - UNKNOWN
     `31` - Location Follows Squad Leader
     `Int`
     `10` - Select this Role for Yourself
     `11` - UNKNOWN
     `20` - (Squad leader) Change Squad Zone
     `21` - (Squad leader) Close Squad Member Position
     `22` - (Squad leader) Add Squad Member Position
     `33` - UNKNOWN
     `40` - Find LFS Soldiers that Meet the Requirements for this Role
     `Long`
     `13` - UNKNOWN
     `14` - UNKNOWN
     `15` - Select this Role for Yourself
     `37` - UNKNOWN
     `String`
     `7` - List Squad Favorite
     `19` - (Squad leader) Change Squad Purpose
     `Int :: Long`
     `12` - UNKNOWN
     `25` - (Squad leader) Change Squad Member Requirements - Weapons
     `38` - Assign Squad Member To Role
     `Int :: String`
     `23` - (Squad leader) Change Squad Member Requirements - Role
     `24` - (Squad leader) Change Squad Member Requirements - Detailed Orders
     `Long :: Long`
     `36` - UNKNOWN
     `String :: Long :: Int :: Int`
     `34` - Search for Squads with a Particular Role

     squad_guid

       the unique identifier of the squad, if non-zero

     line

       the original listing line number, if applicable

     action

       the purpose of this packet; also decides the content of the parameter fields

156.  final case class SquadDetail (unk1: Option[Int], unk2: Option[Int], leader_char_id: Option[Long], unk3: Option[Long], leader_name: Option[String], task: Option[String], zone_id: Option[PlanetSideZoneID], unk7: Option[Int], member_info: Option[List[SquadPositionEntry]]) extends Product with Serializable

     Information regarding a squad's position as a series of common fields.

     Information regarding a squad's position as a series of common fields. When parsed in an itemized way, only the important fields are represented. When parsed in a continuous manner, all of the fields are populated. All fields are optional for that reason.
     The squad leader does not necessarily have to be a person from the `member_info` list.

     unk1

       na; must be non-zero when parsed in a FullSquad pattern

     unk2

       na; not associated with any fields during itemized parsing

     leader_char_id

       he unique character identification number for the squad leader

     unk3

       na

     leader_name

       the name of the player who is the squad leader

     task

       the suggested responsibilities or mission statement of the squad

     zone_id

       the suggested area of engagement for this squad's activities; can also indicate the zone of the squad leader

     unk7

       na

     member_info

       a list of squad position data

157.  final case class SquadDetailDefinitionUpdateMessage (guid: PlanetSideGUID, detail: SquadDetail) extends PlanetSideGamePacket with Product with Serializable

     A compilation of the fields that communicate detailed information about squad structure and composition as a complement to the packet `ReplicationStreamMessage` and the packet `SquadDefinitionActionMessage`.

     A compilation of the fields that communicate detailed information about squad structure and composition as a complement to the packet `ReplicationStreamMessage` and the packet `SquadDefinitionActionMessage`. The information communicated by the `SquadDefinitionActionMessage` packets allocates individual fields of the squad's structure and the `ReplicationStreamMessage` packet reports very surface-level information about the squad to other players. The `SquadDetailDefinitionUpdateMessage` packet serves as a realization of the field information reported by the former and a fully fleshed-out explanation of the information presented by the latter.
     Squads are generally referenced by their own non-zero globally unique identifier that is valid server-wide. A zero GUID squad is also accessible for information related to the local unpublished squad that exists on a specific client. Only one published squad can have its information displayed at a time. While imperfect squad information can be shown, two major formats for the data in this packet are common. The first format lists all of the squad's fields and data and is used as an initialization of the squad locally. This format is always used the first time information about the squad is communicated to the client. The second format lists specific portions of the squad's fields and data and is used primarily for simple updating purposes.

     guid

       the globally unique identifier of the squad

     detail

       information regarding the squad

158.  final case class SquadInfo (leader: Option[String], task: Option[String], zone_id: Option[PlanetSideZoneID], size: Option[Int], capacity: Option[Int], squad_guid: Option[PlanetSideGUID] = None) extends Product with Serializable

     Maintain squad information for a given squad's listing.

     Maintain squad information for a given squad's listing. Only certain information will be transmitted depending on the purpose of the packet.

     leader

       the name of the squad leader, usually the first person in the squad member list; `None` if not applicable

     task

       the task the squad is trying to perform as a wide character string; `None` if not applicable

     zone_id

       the continent on which the squad is acting; `None` if not applicable

     size

       the current size of the squad; "can" be greater than `capacity`, though with issues; `None` if not applicable

     capacity

       the maximum number of members that the squad can tolerate; normal count is 10; maximum is 15 but naturally can not be assigned that many; `None` if not applicable

     squad_guid

       a GUID associated with the squad, used to recover the squad definition; sometimes it is defined but is still not applicable; `None` if not applicable (rarely applicable)

159.  final case class SquadInvitationRequestMessage (squad_guid: PlanetSideGUID, slot: Int, char_id: Long, name: String) extends PlanetSideGamePacket with Product with Serializable

     A message for communicating squad invitation.

     A message for communicating squad invitation. When received by a client, the event message "You have invited `name` to join your squad" is produced and a `SquadMembershipRequest` packet of type `Invite` using `char_id` as the optional unique character identifier field is dispatched to the server. The message is equivalent to a dispatched packet of type `SquadMembershipResponse` with an `Invite` event with the referral field set to `true`.

     squad_guid

       the squad's GUID

     slot

       a potentially valid slot index; 0-9; higher numbers produce no response

     char_id

       the unique character identifier

     name

       the character's name; frequently, though that does not produce a coherent message, the avatar's own name is supplied in the event message instead of the name of another player

     See also

       `SquadMembershipResponse`

160.  final case class SquadListing (index: Int = 255, listing: Option[SquadInfo] = None) extends Product with Serializable

     An indexed entry in the listing of squads.

     An indexed entry in the listing of squads.

     index

       the listing entry index for this squad; zero-based; 255 is the maximum index and is reserved to indicate the end of the listings for the packet

     listing

       the squad data; `None` when the index is 255, or when invoking a "remove" action on any squad at a known index

161.  final case class SquadMemberEvent (action: MemberEvent.Value, unk2: Int, char_id: Long, position: Int, player_name: Option[String], zone_number: Option[Int], unk7: Option[Long]) extends PlanetSideGamePacket with Product with Serializable
162.  final case class SquadMembershipRequest (request_type: types.SquadRequestType.Value, char_id: Long, unk3: Option[Long], player_name: String, unk5: Option[Option[String]]) extends PlanetSideGamePacket with Product with Serializable

     Dispatched by the client as manipulation protocol for squad and platoon members.

     Dispatched by the client as manipulation protocol for squad and platoon members. Answerable by a `SquadMembershipResponse` packet.

     request_type

       the purpose of the request

     char_id

       a squad member unique identifier; usually, the player being addresses by thie packet

     unk3

       na

     player_name

       name of the player being affected, if applicable

     unk5

       na

163.  final case class SquadMembershipResponse (request_type: types.SquadResponseType.Value, unk1: Int, unk2: Int, char_id: Long, other_id: Option[Long], player_name: String, unk5: Boolean, unk6: Option[Option[String]]) extends PlanetSideGamePacket with Product with Serializable

     Dispatched by the server as message generation protocol for squad and platoon members.

     Dispatched by the server as message generation protocol for squad and platoon members. Prompted by and answers for a `SquadMembershipRequest` packet.

     request_type

       the purpose of the request

     unk1

       na

     unk2

       na

     char_id

       a squad member unique identifier; usually, the player being addresses by thie packet

     other_id

       another squad member's unique identifier; may be the same as `char_id`

     player_name

       name of the player being affected, if applicable

     unk5

       adjusts the nature of the request-type response based on the message recipient

     unk6

       na; the internal field, the `Option[String]`, never seems to be set
       `request_type` (enum value) / `unk5` state (`false`/`true`)
       ----------------------------------------

       - `Invite` (0)
         false => [PROMPT] "`player_name` has invited you into a squad." [YES/NO]
         true => "You have invited `player_name` to join your squad."
       - `Unk01` (1)
         false => n/a
         true => n/a
       - `Accept` (2)
         false => "`player_name` has accepted your invitation to join into your squad.
         "You have formed a squad and are now that squad's commander." (if first time)
         true => "You have accepted an invitation to join a squad."
         "You have successfully joined a squad for the first time." (if first time)
       - `Reject` (3)
         false => "`player_name` does not want to join your squad at this time."
         true => "You have declined an invitation to join a squad."
       - `Cancel` (4)
         false => "`player_name` has withdrawn his invitation."
         true => "You have canceled your invitation to `player_name`."
       - `Leave` (5)
         false => "The Squad Leader has kicked you out of the squad."
         true => "You have kicked `player_name` out of the squad."
       - `Disband` (6)
         false => "The squad has been disbanded."
         true => "You have disbanded the squad."
       - `PlatoonInvite` (7)
         false => [PROMPT] "`player_name` has invited you into a platoon." [YES/NO]
         true => "You have invited `player_name`'s squad to join your platoon."
       - `PlatoonAccept` (8) false => "`player_name` has accepted your invitation to join into your platoon.
         "You have formed a platoon and are now that platoon commander." (if first time)
         true => "You have accepted an invitation to join a platoon."
         "You have successfully joined a platoon for the first time." (if first time)
       - `PlatoonReject` (9)
         false => "`player_name` does not want to join your platoon at this time."
         true => "You have declined an invitation to join a platoon."
       - `PlatoonCancel` (10)
         false => "`player_name` has withdrawn his invitation."
         true => "You have declined your invitation to `player_name`." (nonsense?)
       - `PlatoonLeave` (11)
         false => "The Platoon Leader has kicked you out of the platoon."
         true => "You have kicked `player_name`'s squad out of the platoon."
       - `PlatoonDisband` (12)
         false => "The platoon has been disbanded."
         true => "You have disbanded the platoon."
164.  final case class SquadPositionDetail (is_closed: Option[Boolean], role: Option[String], detailed_orders: Option[String], requirements: Option[Set[Certification]], char_id: Option[Long], name: Option[String]) extends Product with Serializable

     Information regarding a squad's position as a series of common fields.

     Information regarding a squad's position as a series of common fields. When parsed in an itemized way, only the important fields are represented. When parsed in a continuous manner, all of the fields are populated. All fields are optional for that reason.

     is_closed

       availability, whether the position can be occupied by a player; an unavailable position is referenced as "Closed" and no other position detail is displayed; an available unoccupied position is "Available"

     role

       the title of the position

     detailed_orders

       the suggested responsibilities of the position

     requirements

       the actual responsibilities of the position

     char_id

       the unique character identification number for the player that is occupying this position

     name

       the name of the player who is occupying this position

165.  final case class SquadPositionEntry (index: Int, info: Option[SquadPositionDetail]) extends Product with Serializable

     A container for squad position field data associating what would be the ordinal position of that field data in full squad data.

     A container for squad position field data associating what would be the ordinal position of that field data in full squad data.

     index

       the index for this squad position; expected to be a number 0-9 or 255; when 255, this indicated the end of enumerated squad position data and the data for that position is absent

     info

       the squad position field data

166.  final case class SquadState (guid: PlanetSideGUID, info_list: List[SquadStateInfo]) extends PlanetSideGamePacket with Product with Serializable

     Dispatched by the server to update a squad member's representative icons on the continental maps and the interstellar map.
     This packet must be preceded by the correct protocol to assign any character who is defined by `char_id` in `info_list` as a member of this client's player's assigned squad by means of associating that said `char_id`.

     Dispatched by the server to update a squad member's representative icons on the continental maps and the interstellar map.
     This packet must be preceded by the correct protocol to assign any character who is defined by `char_id` in `info_list` as a member of this client's player's assigned squad by means of associating that said `char_id`. The said preceding protocol also assigns the player's current zone (continent) and their ordinal position in the squad.

     guid

       the squad's unique identifier; must be consistent per packet on a given client; does not have to be the global uid of the squad as according to the server

     info_list

       information about the members in this squad who will be updated

     See also

       `SquadMemberEvent`

167.  final case class SquadStateInfo (char_id: Long, health: Int, armor: Int, pos: Vector3, unk4: Int, unk5: Int, unk6: Boolean, unk7: Int, unk8: Option[Int], unk9: Option[Boolean]) extends Product with Serializable

     Information about a specific squad member.

     Information about a specific squad member.

     char_id

       the character's unique identifier

     health

       the character's health value percentage, divided into 64 units

     armor

       the character's armor value percentage, divided into 64 units

     pos

       the world coordinates of the character

     unk4

       na; usually, 2

     unk5

       na; usually, 2

     unk6

       na; usually, false

     unk7

       na

     unk8

       na; if defined, will be defined with unk9

     unk9

       na; if defined, will be defined with unk8

168.  final case class SquadWaypointEvent (event_type: WaypointEventAction.Value, unk: Int, char_id: Long, waypoint_type: SquadWaypoint, unk5: Option[Long], waypoint_info: Option[WaypointEvent]) extends PlanetSideGamePacket with Product with Serializable
169.  final case class SquadWaypointRequest (request_type: WaypointEventAction.Value, char_id: Long, waypoint_type: SquadWaypoint, unk4: Option[Long], waypoint_info: Option[WaypointInfo]) extends PlanetSideGamePacket with Product with Serializable

     na

     na

     request_type

       the action to be performed

     char_id

       the unique id of player setting the waypoint

     waypoint_type

       the waypoint being updated; 0-3 for the standard squad waypoints numbered "1-4"; 4 for the squad leader experience waypoint; cycles through 0-3 continuously

     unk4

       na

     waypoint_info

       essential data about the waypoint

170.  final case class Statistics (unk1: Option[Int], unk2: Option[Int], unk3: List[Long]) extends Product with Serializable

     na

     na

     unk1

       na

     unk2

       na

     unk3

       na

171.  final case class StormInfo (loc: Vector3, intensity: Int, radius: Int) extends Product with Serializable

     Storm data.

     Storm data.

     loc

       the location of the storm; the z-component is always `0.0f`

     intensity

       na

     radius

       na; 100 is about 819.2

172.  class StreamLengthToken extends AnyRef

     A container that should be used to keep track of the current length of a stream of bits.

173.  final case class StrokeFive (x: Float, y: Float, unk: Float) extends DiagramStroke with Product with Serializable

     na

     na

     x

       the x-coordinate of this point

     y

       the y-coordinate of this point

     unk

       na; 1024.0f - 0.0f

174.  final case class StrokeSeven (unk: Int) extends DiagramStroke with Product with Serializable

     na

     na

     unk

       na

175.  final case class Style (thickness: Float, color: Int) extends DiagramStroke with Product with Serializable

     Set style properties for the line segemnt(s) to be drawn.

     Set style properties for the line segemnt(s) to be drawn. Color and thickness can not vary within a given line and will only apply to the subsequent line segments. Attempting to list a change in between coordinate points will invalidate that segment.

     thickness

       the line width in pixels; 0.0f - 16.0f; 3.0f is about normal and 0.0f is smaller than the map grid lines

     color

       the color of the line; 0 is gray (default); 1 is red; 2 is green; 3 is blue

176.  final case class TargetInfo (target_guid: PlanetSideGUID, health: Float, armor: Float = 0f) extends Product with Serializable

     An entry regarding a target's health and, if applicable, any secondary defensive option they possess, hitherto, "armor."

     An entry regarding a target's health and, if applicable, any secondary defensive option they possess, hitherto, "armor."

     target_guid

       the target

     health

       the amount of health the target has, as a percentage of a filled bar scaled between 0f and 1f inclusive

     armor

       the amount of armor the target has, as a percentage of a filled bar scaled between 0f and 1f inclusive; defaults to 0f

177.  final case class TargetRequest (target_guid: PlanetSideGUID, unk: Boolean) extends Product with Serializable

     An entry regarding a specific target.

     An entry regarding a specific target.

     target_guid

       the target

     unk

       na

178.  final case class TargetingImplantRequest (target_list: List[TargetRequest]) extends PlanetSideGamePacket with Product with Serializable

     Dispatched by the client when the advanced targeting implant activates to collect status information from the server.
     This packet is answered by a `TargetingInfoMessage` with `List` entries of thed corresponding UIDs.

     Dispatched by the client when the advanced targeting implant activates to collect status information from the server.
     This packet is answered by a `TargetingInfoMessage` with `List` entries of thed corresponding UIDs.

     target_list

       a `List` of targets

179.  final case class TargetingInfoMessage (target_list: List[TargetInfo]) extends PlanetSideGamePacket with Product with Serializable

     Dispatched by the server to update status information regarding the listed targets.
     This packet is often in response to a client-sent `TargetingImplantRequest` packet, when related to the implant's operation.

     Dispatched by the server to update status information regarding the listed targets.
     This packet is often in response to a client-sent `TargetingImplantRequest` packet, when related to the implant's operation. It can also arrive independent of a formal request and will operate even without the implant. The enumerated targets report their status as two "progress bars" that can be empty (0f) or filled (1f). When this packet is received, the client will actually update the current fields associated with those values for the target. For example, for `0x17` player characters, the values are assigned to their health points and armor points respectively. Allied player characters will have their "progress bar" visuals updated immediately; the implant is still necessary to view enemy target progress bars, if they will be visible.
     This function can be used to update fields properly. The value between 0 and 255 (0f to 1f) can be inserted directly into `ObjectCreateMessage` creations as it matches the scale. The target will be killed or destroyed as expected when health is set to zero.

     target_list

       a list of targets

180.  final case class TimeOfDayMessage (time: Long, unk: Long = 1092616192L) extends PlanetSideGamePacket with Product with Serializable

     Sets Auraxis time for a continent (zone) on the client.

     Sets Auraxis time for a continent (zone) on the client. Use the slash-command `/time` to view the current time in the event window. Auraxis time is represented as a standard military twenty-four hour clock, displayed in hours and minutes.
     Time is set per zone on map loading. Time affects, primarily, ambient light on surfaces. It goes from full daylight, to twilights, to slightly darker nights, though the actual intensity will differ by zone.
     Auraxis time is weird. The data from the server is deconstructed into both a current time and a rate of progression. The lower the value, the lower the rate; the greater the value, the greater the rate. The rate is the product of the number of "cycles" between the current time and an origin time and a base interval. The current time is constrained to a looping twenty-four hour interval.
     If no time is set, the client starts counting from 10:00 at an initial rate of about one Auraxis minute every four or five real seconds. Setting the current time to 1107296256 sets the current time to 00:00 with an indeterminate, but slow, rate. Time is normally initialized somewhere within an interval between 1174405120 and 1207959296. Setting the current time extremely high (near the numerical maximum) can cause psychedelic rendering. (Setting the time to 4294967040 exactly will reduce the rendering system to gibberish.)
     The interval from 1178164736 (~03:18) to 1203765248 (03:18) is about a full twenty-four hours. That is a count of 25600512.

     time

       Auraxis time

     unk

       consistently 1092616192; does nothing?

181.  final case class TrainingZoneMessage (zone: PlanetSideGUID, unk: Int = 0) extends PlanetSideGamePacket with Product with Serializable

     Dispatched when the player wants to go to the training zones.

     Dispatched when the player wants to go to the training zones. When a player enters the virtual reality hallways behind sanctuary spawn rooms and walks to the base of the ramp, he is presented with a prompt. From the prompt, the player accepts either "Shooting Range" or "Vehicle Training Area."
     Both sets of training zones utilize the same map for their type - `map14` for shooting and `map15` for vehicles. The factions are kept separate so there are actually six separated zones - two each - to accommodate the three factions. There is no global map notation, i.e., `map##`, for going to a faction-instance training zone map. The zone modifier is used in conjunction with the `LoadMapMessage` packet to determine the faction-instance of the training map.
     Players are sent to their respective empire's area by default. A TR player utilizing the virtual reality hallway in the NC sanctuary and will still only be offered the TR virtual reality areas. Black OPs do not have normal access to virtual reality areas.
     Zone:
     17 - `11` - TR Shooting Range
     18 - `12` - NC Shooting Range
     19 - `13` - VS Shooting Range
     20 - `14` - TR Vehicle Training Area
     21 - `15` - NC Vehicle Training Area
     22 - `16` - VS Vehicle Training Area

     zone

       the virtual reality zone to send the player

     unk

       na; always 0?

182.  final case class TriggerEffectMessage (object_guid: PlanetSideGUID, effect: String, unk: Option[TriggeredEffect] = None, location: Option[TriggeredEffectLocation] = None) extends PlanetSideGamePacket with Product with Serializable

     Dispatched by the server to cause a client to display a special graphical effect.
     The effect being triggered can be based around a specific game object or replayed freely, absent of an anchoring object.

     Dispatched by the server to cause a client to display a special graphical effect.
     The effect being triggered can be based around a specific game object or replayed freely, absent of an anchoring object. If object-based then the kinds of effects that can be activated are specific to the object. If unbound, then a wider range of effects can be displayed. Regardless, one category will rarely ever be activated under the same valid conditions of the other category. For example, the effect "on" will only work on objects that accept "on" normally, like a deployed `motionalarmsensor`. The effect "spawn_object_effect" can be applied anywhere in the environment; but, it can not be activated in conjunction with an existing object.

     object_guid

       an object that accepts the effect

     effect

       the name of the effect

     unk

       na; when activating an effect on an existing object

     location

       an optional position where the effect will be displayed; when activating an effect independently

183.  final case class TriggerEnvironmentalDamageMessage (unk1: Int, target_guid: PlanetSideGUID, unk2: Long) extends PlanetSideGamePacket with Product with Serializable

     Dispatched by the server to render a "damage cloud" around a target.
     Exploration:
     This is not common but it happened while on Gemini Live.

     Dispatched by the server to render a "damage cloud" around a target.
     Exploration:
     This is not common but it happened while on Gemini Live. Why does it happen?

     unk1

       na; usually 2; when 2, will generate a short dust cloud around the `target_guid`; if a player, will cause the "damage grunt animation" to occur, whether or not there is a dust cloud

     target_guid

       the target around which to generate the temporary damage effect

     unk2

       na; usually 5L

184.  final case class TriggerSoundMessage (sound: TriggeredSound.Value, pos: Vector3, unk: Int, volume: Float) extends PlanetSideGamePacket with Product with Serializable

     Dispatched by the server to cause a sound to be played at a certain location in the world.

     Dispatched by the server to cause a sound to be played at a certain location in the world.

     sound

       the kind of sound

     pos

       the location where the sound gets played

     unk

       na; may be radius

     volume

       the volume of the sound at the origin (0.0f - 1.0f)

185.  final case class TriggeredEffect (unk1: Boolean, unk2: Long) extends Product with Serializable

     na

     na

     unk1

       na; `true` to apply the effect usually

     unk2

       na

186.  final case class TriggeredEffectLocation (pos: Vector3, orient: Vector3) extends Product with Serializable

     Activate an effect that is not directly associated with an existing game object.

     Activate an effect that is not directly associated with an existing game object. Without a game object from which to inherit position and orientation, those explicit parameters must be provided.

     pos

       the position in the game world

     orient

       the angle of orientation

187.  final case class UnuseItemMessage (player_guid: PlanetSideGUID, item_guid: PlanetSideGUID) extends PlanetSideGamePacket with Product with Serializable

     Dispatched by the client when its player is done using something.
     The common example is sifting through backpacks, an activity that only one player is allowed to do at a time.

     Dispatched by the client when its player is done using something.
     The common example is sifting through backpacks, an activity that only one player is allowed to do at a time. When a backpack is accessed by one player, other players are blocked. When the first player is done accessing the backpack, this packet informs the server so other players may be allowed access.

     player_guid

       the player

     item_guid

       the item

188.  final case class UseItemMessage (avatar_guid: PlanetSideGUID, item_used_guid: PlanetSideGUID, object_guid: PlanetSideGUID, unk2: Long, unk3: Boolean, unk4: Vector3, unk5: Vector3, unk6: Int, unk7: Int, unk8: Int, object_id: Long) extends PlanetSideGamePacket with Product with Serializable

     (Where the child object was before it was moved is not specified or important.)

     (Where the child object was before it was moved is not specified or important.)

     avatar_guid

       the player

     item_used_guid

       the item used; e.g. a REK to hack or a medkit to heal.

     object_guid

       the object affected; e.g., door when opened, terminal when accessed, avatar when medkit used

     unk2

       na; when upgrading phalanx turrets, 1 for `AVCombo` and 2 for `FlakCombo`

     unk3

       using tools, e.g., a REK or nano-dispenser

     unk4

       seems to be related to T-REK viruses. 0 - unlock all doors 1 - disable linked benefits 2 - double ntu drain 3 - disable enemy radar 4 - access equipment terminals

     unk6

       na

     unk7

       na; 25 when door 223 when terminal

     unk8

       na; 0 when door 1 when use rek (252 then equipment term)

     object_id

       the object id `object_guid`'s object

     See also

       `Definition.ObjectId`
       `TurretUpgrade`

189.  final case class VNLWorldStatusMessage (welcomeMessage: String, worlds: Vector[WorldInformation]) extends PlanetSideGamePacket with Product with Serializable
190.  final case class VehicleStateMessage (vehicle_guid: PlanetSideGUID, unk1: Int, pos: Vector3, ang: Vector3, vel: Option[Vector3], flying: Option[Int], unk3: Int, unk4: Int, wheel_direction: Int, is_decelerating: Boolean, is_cloaked: Boolean) extends PlanetSideGamePacket with Product with Serializable

     Dispatched to report and update the operational condition of a given vehicle.

     Dispatched to report and update the operational condition of a given vehicle.

     vehicle_guid

       the vehicle

     unk1

       na

     pos

       the xyz-coordinate location in the world

     ang

       the orientation of the vehicle

     vel

       optional movement data

     flying

       flight information, valid only for a vehicle that can fly when in flight; `Some(7)`, when in a flying state (vertical thrust unnecessary to unlock movement); `Some(10) - Some(15)`, used by the HART during landing and take-off, in repeating order: 13, 14, 10, 11, 12, 15; `None`, when landed and for all vehicles that do not fly

     unk3

       na

     unk4

       na

     wheel_direction

       for ground vehicles, whether and how much the wheels are being turned; 15 for straight; 0 for hard right; 30 for hard left; values in between are possible; vehicles that hover also influence this field as expected

     is_decelerating

       If the vehicle is decelerating (in any direction), i.e. if the brake lights are on.

     is_cloaked

       vehicle is cloaked by virtue of being a Wraith or a Phantasm

     See also

       `PlacementData`

191.  final case class VehicleSubStateMessage (vehicle_guid: PlanetSideGUID, player_guid: PlanetSideGUID, vehicle_pos: Vector3, vehicle_ang: Vector3, vel: Option[Vector3], unk1: Boolean, unk2: Option[List[Boolean]]) extends PlanetSideGamePacket with Product with Serializable

     Dispatched by the client of a driver who is involved in a collision with another vehicle that has no driver.

     Dispatched by the client of a driver who is involved in a collision with another vehicle that has no driver. May be supplemented with `GenericCollisionMsg` packets that call out both vehicles. Multiple packets may be generated for a single event representing either entanglement, escalation, or a lack of resolution.

     vehicle_guid

       the vehicle that was collided with

     player_guid

       the player who drove into the vehicle

     vehicle_pos

       the xyz-coordinates of the displaced collision vehicle in reference to the player's client

     vehicle_ang

       the orientation of the displaced collision vehicle in reference to the player's client

     vel

       optional velocity (unknown)

     unk1

       na

     unk2

       na

192.  final case class Vertex (x: Float, y: Float) extends DiagramStroke with Product with Serializable

     Indicate coordinates on the tactical map.

     Indicate coordinates on the tactical map. Any adjacent sets of coordinates will be connected with a line segment.

     x

       the x-coordinate of this point

     y

       the y-coordinate of this point

193.  final case class VoiceHostInfo (player_guid: PlanetSideGUID, data: ByteVector) extends PlanetSideGamePacket with Product with Serializable

     Used by PlanetSide in conjunction with wiredred/pscs.exe to establish local platoon/squad voice chat.

     Used by PlanetSide in conjunction with wiredred/pscs.exe to establish local platoon/squad voice chat. We are not focusing on implementation of this feature. This packet should not be generated because `VoiceHostRequest` will be ignored.

     player_guid

       the player who sent this info (the originator of voice chat?)

     data

       everything else

194.  final case class VoiceHostKill () extends PlanetSideGamePacket with Product with Serializable

     Used by PlanetSide in conjunction with wiredred/pscs.exe to establish local platoon/squad voice chat.

     Used by PlanetSide in conjunction with wiredred/pscs.exe to establish local platoon/squad voice chat. We are not focusing on implementation of this feature. As a precaution, all attempts at sending `VoiceHostRequest` should be replied to with a `VoiceHostKill`. This packet seems to publish no data.

195.  final case class VoiceHostRequest (unk: Boolean, player_guid: PlanetSideGUID, data: ByteVector) extends PlanetSideGamePacket with Product with Serializable

     Used by PlanetSide in conjunction with wiredred/pscs.exe to establish local platoon/squad voice chat.

     Used by PlanetSide in conjunction with wiredred/pscs.exe to establish local platoon/squad voice chat. We are not focusing on implementation of this feature. At the most, we will merely record data about who requested it.

     unk

       na

     player_guid

       the player who sent this request

     data

       everything else

196.  final case class WarpQueuePrompt (queue_size: Long, place: Long) extends Product with Serializable

     Information displayed on the zone warp queue in terms of queue size and queue progression.

     Information displayed on the zone warp queue in terms of queue size and queue progression.

     queue_size

       the number of players trying to warp to this zone in the queue ('b' if a/b)

     place

       the player's spot in the queue ('a' if a/b)

197.  final case class WarpgateRequest (from_zone: PlanetSideGUID, from_gate_guid: PlanetSideGUID, to_gate_mapid: PlanetSideGUID, to_zone: PlanetSideGUID, unk1: Int, unk2: Int) extends PlanetSideGamePacket with Product with Serializable

     Alert the server that a player wishes to engage in warp gate transport.
     This packet is dispatched after a player interacts with the transportation beam in the center of a warp gate.

     Alert the server that a player wishes to engage in warp gate transport.
     This packet is dispatched after a player interacts with the transportation beam in the center of a warp gate. The player has either chosen a destination from the Interstellar Map or was assigned a fixed destination. When the the destination is limited to a specific continent and warp gate - "fixed" - the destination fields can be blanked. Otherwise, they must be specified. The process of gate transportation should not start until the server responds to this packet.
     Exploration 1:
     Does this packet apply to geowarp transport as well?

     from_zone

       the continent (zone)

     from_gate_guid

       the warp gate

     to_gate_mapid

       the destination warp gate

     to_zone

       the destination continent (zone)

     unk1

       na; always zero?

     unk2

       na; always zero?

198.  final case class Waypoint (x: Float, y: Float) extends Product with Serializable

     The position of a waypoint in the game world.

     The position of a waypoint in the game world. Only two coordinates are required as the beam travels from a specific height to ground level.

     x

       the x-coordinate of the waypoint

     y

       the y-coordinate of the waypoint

199.  final case class WaypointEvent (zone_number: Int, pos: Vector3, unk: Int) extends Product with Serializable
200.  final case class WaypointInfo (zone_number: Int, pos: Vector3) extends Product with Serializable

     na

     na

     zone_number

       the zone

     pos

       the continental map coordinate location of the waypoint; the z-coordinate is almost always 0.0

201.  final case class WeaponDelayFireMessage (seq_time: Int, weapon_guid: PlanetSideGUID) extends PlanetSideGamePacket with Product with Serializable

     WeaponDelayFireMessage seems to be sent when a weapon has a delayed projectile after firing, such as the knife.

     WeaponDelayFireMessage seems to be sent when a weapon has a delayed projectile after firing, such as the knife.

     See PlayerStateMessageUpstream for explanation of seq_time.

202.  final case class WeaponDryFireMessage (weapon_guid: PlanetSideGUID) extends PlanetSideGamePacket with Product with Serializable

     Instructs client to play a weapon's dryfire sound when sent server to client.

     Instructs client to play a weapon's dryfire sound when sent server to client.

     The particular sound played depends on the type of weapon that the guid is (likely from adb gamedata). See also WeaponJammedMessage

     weapon_guid

       the weapon that is dry firing

203.  final case class WeaponFireMessage (seq_time: Int, weapon_guid: PlanetSideGUID, projectile_guid: PlanetSideGUID, shot_origin: Vector3, unk1: Int, spread_a: Int, spread_b: Int, max_distance: Int, unk5: Int, projectile_type: ProjectileCharacteristics, thrown_projectile_vel: Option[Option[Vector3]]) extends PlanetSideGamePacket with Product with Serializable

     Dispatched form the client each time a weapon discharges.

     Dispatched form the client each time a weapon discharges.

     seq_time

       see PlayerStateMessageUpstream for explanation of seq_time

     weapon_guid

       the weapon of discharge; when dispatched to a client, an unreferenced entity results in the projectile not being rendered

     projectile_guid

       the (client-local) projectile unique identifier; when dispatched to a client, can be unreferenced (or blanked)

     shot_origin

       the position where the projectile is first spawned

     unk1

       na; always 0?

     spread_a

       related to the spread of the discharge; works with `spread_b` field in unknown way; the unmodified value is high (65535) when accurate, low (0) when not

     spread_b

       related to the spread of the discharge; works with `spread_a` field in unknown way

     max_distance

       maximum travel distance (m), with exceptions, e.g., decimator rockets are always 0

     unk5

       na; always 255?

     projectile_type

       the sort of projectile produced

     thrown_projectile_vel

       if a thrown projectile, its velocity

204.  final case class WeaponJammedMessage (weapon_guid: PlanetSideGUID) extends PlanetSideGamePacket with Product with Serializable

     Instructs client to play the weapon jammed sound when sent server to client.

     Instructs client to play the weapon jammed sound when sent server to client.

     Appears to have the same functionality and sound regardless of guid, as long as the client has that item in inventory. See also WeaponDryFireMessage

     weapon_guid

       the weapon that is jammed

205.  final case class WeaponLazeTargetPositionMessage (weapon_uid: PlanetSideGUID, player_pos: Vector3, lazed_pos: Vector3) extends PlanetSideGamePacket with Product with Serializable

     Dispatched to the server when a position is being marked by a laze pointer tool.
     When the laze tool is used, a progress bar window is displayed, along with the text "Acquiring Target Position." The player using the tool constantly sends packets to the server for as long as the progress bar is filling.

     Dispatched to the server when a position is being marked by a laze pointer tool.
     When the laze tool is used, a progress bar window is displayed, along with the text "Acquiring Target Position." The player using the tool constantly sends packets to the server for as long as the progress bar is filling. In all, about fifty packets are sent. (Measured during low-load testing. The actual number of packets may be related to network load.)
     While firing, the player's movement is locked for the duration. The weapon fire can be aborted at any time, returning control.

     weapon_uid

       the laze pointer tool

     player_pos

       the position of (the player holding the) laze pointer

     lazed_pos

       position of the tip of the laze pointer's beam, or where it intersects something

206.  final case class WeatherMessage (clouds: List[CloudInfo], storms: List[StormInfo]) extends PlanetSideGamePacket with Product with Serializable

     Dispatched by the server to update weather conditions.

     Dispatched by the server to update weather conditions. On former live (Gemini), the server sent a new packet to connected clients once every ~60s.
     Information about the fields in this packet come from extracted debug information. It is not necessarily "correct" but it is the best approximation for now.
     `Message type: %d (%s)\n length: %d\n
     Number of Clouds : %d\n
     Cloud ID: %d\n
     \tCloud Location: %f %f\n
     \tCloud Velocity: %f %f\n
     Number of Storms : %d\n
     Storm:\n
     \tStorm Location: %f %f\n
     \tStorm Intensity: %d\n
     \tStorm Radius: %d\n
     ```

     clouds

       a list of cloud data; typically, just one entry

     storms

       a list of storm data; typically, fluctuates between nine and eleven entries

207.  final case class WorldConnectionInfo (address: InetSocketAddress) extends Product with Serializable
208.  final case class WorldInformation (name: String, status: WorldStatus.Value, serverType: ServerType, connections: Vector[WorldConnectionInfo], empireNeed: types.PlanetSideEmpire.Value) extends Product with Serializable
209.  final case class ZipLineMessage (player_guid: PlanetSideGUID, forwards: Boolean, action: Int, path_id: Long, pos: Option[Vector3] = None) extends PlanetSideGamePacket with Product with Serializable

     Dispatched by the client when the player is interacting with a zip line.

     Dispatched by the client when the player is interacting with a zip line. Dispatched by the server to instruct the client to use the zip line. Cavern teleportation rings also count as "zip lines" as far as the game is concerned, in that they use this packet.
     Action:
     `0 - Attach to a node`
     `1 - Arrived at destination`
     `2 - Forcibly detach from zip line in mid-transit`

     player_guid

       the player

     forwards

       true if the player is travelling in the direction of the light pulses

     action

       how the player interacts with the zip line

     path_id

       the path id that this zipline belongs to, from the relevant .zpl file

     pos

       the coordinates of the point where the player is interacting with the zip line; "optional," in theory

210.  final case class ZoneForcedCavernConnectionsMessage (zone: Int, unk: Int) extends PlanetSideGamePacket with Product with Serializable

     Dispatched to the client in regards to cavern connections via geowarp gates.

     Dispatched to the client in regards to cavern connections via geowarp gates.

     zone

       the zone

     unk

       determines the number and composition of cavern links assuming two geowarps per continent the logic seems to be roughly: 0 - gate A disabled, B active 1 - gate A active, B disabled 2 - gate A and B active 3 - same as 2 (no change in destination) Destinations also change (north/south/east/west), but seemingly only to two of the currently active caverns can be linked to?

211.  final case class ZoneInfoMessage (zone: Int, empire_status: Boolean, lock_time: Long) extends PlanetSideGamePacket with Product with Serializable

     Change the "Empire Status" text in the Interstellar Map zone description for the specified zone.

     Change the "Empire Status" text in the Interstellar Map zone description for the specified zone. The Empire Incentives window also displays the changed information.
     The `Long` value is applicable to the caverns. It indicates how long the given cavern will remain locked until at least one of their geowarps will open during normal rotation. As thus, when a cavern has its status as "inactive," this number will always be a non-zero. On normal continents, this number is always zero, though a non-zero number will not have any effect anyway.

     zone

       the zone id

     empire_status

       `true` displays the queue availability for the avatar's empire; `false` displays "Inactive"

     lock_time

       how long until the continent naturally unlocks (in ms); only applicable to caverns

     See also

       `ZonePopulationUpdateMessage` for information on population and queues

212.  final case class ZoneLockInfoMessage (zone: Int, lock_status: Boolean, unk: Boolean) extends PlanetSideGamePacket with Product with Serializable

     Change the "Empire Status" text in the Interstellar Map zone description for the specified zone.

     Change the "Empire Status" text in the Interstellar Map zone description for the specified zone. The Empire Incentives window also displays the changed information.

     zone

       the zone id

     lock_status

       `true` displays "Locked;" `false` displays the queue availability for the avatar's empire

     unk

       na; usually `true`

213.  final case class ZonePopulationUpdateMessage (zone_id: Int, zone_queue: Long, tr_queue: Long, tr_pop: Long, nc_queue: Long, nc_pop: Long, vs_queue: Long, vs_pop: Long, bo_queue: Long = 0L, bo_pop: Long = 0L) extends PlanetSideGamePacket with Product with Serializable

     Report the raw numerical population for a zone (continent).
     Populations are displayed as percentages of the three main empires against each other.

     Report the raw numerical population for a zone (continent).
     Populations are displayed as percentages of the three main empires against each other. Populations specific to a zone will be displayed in the Incentives window for that zone. Populations in all zones will contribute to the Global Population window and the Incentives window for the server. The Black OPs population does not show up in the Incentives window for a zone but will be indirectly represented in the other two windows. This packet also shifts the flavor text for that zone.
     The size of zone's queue is the final upper population limit for that zone. Common values for the zone queue fields are 0 (locked) and 414 positions. When a continent can not accept any players at all, a lock icon will appear over its view pane in the Interstellar View. Setting the zone's queue to zero will also render this icon.
     The individual queue fields set the maximum empire occupancy for a zone that is represented in the zone Incentives text. Common values for the empire queue fields are 0 (locked population), 138 positions, and 500 positions. Zone Incentives text, however, will never report more than a "100+" vacancy. The actual limits are probably set based on server load. The latter queue value is typical for VR area zones.
     The value of the zone queue trumps the sum of all individual empire queues. Regardless of individual queues, once total zone population matches the zone queue size, all populations will lock. For normal zones, if the individual queues are not set properly, whole empires can even be locked out of a zone for this reason. In the worst case, other empires are allowed enough individual queue vacancy that they can occupy all the available slots. Sanctuary zones possess strange queue values that are occasionally zero'd. They do not have a lock icon and may not limit populations the same way as normal zones.

     zone_id

       the continent

     zone_queue

       the maximum population of all three (four) empires that can join this zone

     tr_queue

       the maximum number of TR players that can join this zone

     tr_pop

       the current TR population in this zone

     nc_queue

       the maximum number of NC players that can join this zone

     nc_pop

       the current NC population in this zone

     vs_queue

       the maximum number of VS players that can join this zone

     vs_pop

       the VS population in this zone

     bo_queue

       the maximum number of Black OPs players that can join this zone

     bo_pop

       the current Black OPs population in this zone

### Value Members

1.  object ActionCancelMessage extends Marshallable[ActionCancelMessage] with Serializable
2.  object ActionProgressMessage extends Marshallable[ActionProgressMessage] with Serializable
3.  object ActionResultMessage extends Marshallable[ActionResultMessage] with Serializable
4.  object AggravatedDamageMessage extends Marshallable[AggravatedDamageMessage] with Serializable
5.  object ArmorChangedMessage extends Marshallable[ArmorChangedMessage] with Serializable
6.  object AvatarDeadStateMessage extends Marshallable[AvatarDeadStateMessage] with Serializable
7.  object AvatarFirstTimeEventMessage extends Marshallable[AvatarFirstTimeEventMessage] with Serializable
8.  object AvatarGrenadeStateMessage extends Marshallable[AvatarGrenadeStateMessage] with Serializable
9.  object AvatarImplantMessage extends Marshallable[AvatarImplantMessage] with Serializable
10.  object AvatarJumpMessage extends Marshallable[AvatarJumpMessage] with Serializable
11.  object AvatarSearchCriteriaMessage extends Marshallable[AvatarSearchCriteriaMessage] with Serializable
12.  object AvatarStatisticsMessage extends Marshallable[AvatarStatisticsMessage] with Serializable
13.  object AvatarVehicleTimerMessage extends Marshallable[AvatarVehicleTimerMessage] with Serializable
14.  object BattleDiagramAction extends Serializable
15.  object BattleExperienceMessage extends Marshallable[BattleExperienceMessage] with Serializable
16.  object BattleplanMessage extends Marshallable[BattleplanMessage] with Serializable
17.  object BeginZoningMessage extends Marshallable[BeginZoningMessage] with Serializable
18.  object BindPlayerMessage extends Marshallable[BindPlayerMessage] with Serializable
19.  object BindStatus extends Enumeration

    The purpose of the `BindPlayerMessage` packet.
    `Bind` and `Unbind` are generally manual actions performed by the player.

    The purpose of the `BindPlayerMessage` packet.
    `Bind` and `Unbind` are generally manual actions performed by the player. `Available` is applied to automatic Advanced Mobile Spawn points and other "Bound" points at the time of redeployment. `Lost` and `Unavailable` remove the status of being bound and have slightly different connotations. Each generates a different a events chat message if logging it turned on.

20.  object BroadcastWarpgateUpdateMessage extends Marshallable[BroadcastWarpgateUpdateMessage] with Serializable
21.  object BugReportMessage extends Marshallable[BugReportMessage] with Serializable
22.  object BugType extends Enumeration

    An `Enumeration` of the kinds of bugs applicable to the reporting system.

23.  object BuildingInfoUpdateMessage extends Marshallable[BuildingInfoUpdateMessage] with Serializable
24.  object CaptureFlagUpdateMessage extends Marshallable[CaptureFlagUpdateMessage] with Serializable
25.  object CargoMountPointStatusMessage extends Marshallable[CargoMountPointStatusMessage] with Serializable
26.  object ChainLashMessage extends Marshallable[ChainLashMessage] with Serializable
27.  object ChangeAmmoMessage extends Marshallable[ChangeAmmoMessage] with Serializable
28.  object ChangeFireModeMessage extends Marshallable[ChangeFireModeMessage] with Serializable
29.  object ChangeFireStateMessage_Start extends Marshallable[ChangeFireStateMessage_Start] with Serializable
30.  object ChangeFireStateMessage_Stop extends Marshallable[ChangeFireStateMessage_Stop] with Serializable
31.  object ChangeShortcutBankMessage extends Marshallable[ChangeShortcutBankMessage] with Serializable
32.  object CharacterCreateRequestMessage extends Marshallable[CharacterCreateRequestMessage] with Serializable
33.  object CharacterInfoMessage extends Marshallable[CharacterInfoMessage] with Serializable
34.  object CharacterKnowledgeMessage extends Marshallable[CharacterKnowledgeMessage] with Serializable
35.  object CharacterNoRecordMessage extends Marshallable[CharacterNoRecordMessage] with Serializable
36.  object CharacterRequestAction extends Enumeration
37.  object CharacterRequestMessage extends Marshallable[CharacterRequestMessage] with Serializable
38.  object ChatChannel extends Enumeration

    An `Enumeration` of the valid chat channels.

39.  object ChatMsg extends Marshallable[ChatMsg] with Serializable
40.  object ChildObjectStateMessage extends Marshallable[ChildObjectStateMessage] with Serializable
41.  object ConnectToWorldMessage extends Marshallable[ConnectToWorldMessage] with Serializable
42.  object ConnectToWorldRequestMessage extends Marshallable[ConnectToWorldRequestMessage] with Serializable
43.  object ContinentalLockUpdateMessage extends Marshallable[ContinentalLockUpdateMessage] with Serializable
44.  object CreateShortcutMessage extends Marshallable[CreateShortcutMessage] with Serializable
45.  object DamageFeedbackMessage extends Marshallable[DamageFeedbackMessage] with Serializable
46.  object DamageMessage extends Marshallable[DamageMessage] with Serializable
47.  object DamageWithPositionMessage extends Marshallable[DamageWithPositionMessage] with Serializable
48.  object DataChallenge
49.  object DataChallengeMessage extends Marshallable[DataChallengeMessage] with Serializable
50.  object DataChallengeMessageResp extends Marshallable[DataChallengeMessageResp] with Serializable
51.  object DeadState extends Enumeration

    An `Enumeration` of the various states a `Player` may possess in the cycle of nanite life and death.

52.  object DelayedPathMountMsg extends Marshallable[DelayedPathMountMsg] with Serializable
53.  object DensityLevelUpdateMessage extends Marshallable[DensityLevelUpdateMessage] with Serializable
54.  object DeployObjectMessage extends Marshallable[DeployObjectMessage] with Serializable
55.  object DeployOutcome extends Enumeration

    An `Enumeration` for the forms of the event chat message produced by this packet.

56.  object DeployRequestMessage extends Marshallable[DeployRequestMessage] with Serializable
57.  object DeployableIcon extends Enumeration

    An `Enumeration` of the map element icons that can be displayed based on the type of deployable item.

58.  object DeployableObjectsInfoMessage extends Marshallable[DeployableObjectsInfoMessage] with Serializable
59.  object DeploymentAction extends Enumeration

    An `Enumeration` of the actions that can be performed upon a deployable item.

60.  object DestroyDisplayMessage extends Marshallable[DestroyDisplayMessage] with Serializable
61.  object DestroyMessage extends Marshallable[DestroyMessage] with Serializable
62.  object DiagramActionCode extends Enumeration

    A `Codec` for the actions that each layer of the diagram performs.

    A `Codec` for the actions that each layer of the diagram performs. `Style`, `Vertex`, `Action5`, `DrawString`, and `Action7` have additional `DiagramStroke` input data.

63.  object DisconnectMessage extends Marshallable[DisconnectMessage] with Serializable
64.  object DismountBuildingMsg extends Marshallable[DismountBuildingMsg] with Serializable
65.  object DismountVehicleCargoMsg extends Marshallable[DismountVehicleCargoMsg] with Serializable
66.  object DismountVehicleMsg extends Marshallable[DismountVehicleMsg] with Serializable
67.  object DisplayedAwardMessage extends Marshallable[DisplayedAwardMessage] with Serializable
68.  object DropItemMessage extends Marshallable[DropItemMessage] with Serializable
69.  object DroppodError extends IntEnum[DroppodError]
70.  object DroppodFreefallingMessage extends Marshallable[DroppodFreefallingMessage] with Serializable
71.  object DroppodLaunchInfo extends Serializable
72.  object DroppodLaunchRequestMessage extends Marshallable[DroppodLaunchRequestMessage] with Serializable
73.  object DroppodLaunchResponseMessage extends Marshallable[DroppodLaunchResponseMessage] with Serializable
74.  object DrowningTarget extends Serializable
75.  object EmoteMsg extends Marshallable[EmoteMsg] with Serializable
76.  object ExperienceAddedMessage extends Marshallable[ExperienceAddedMessage] with Serializable
77.  object FacilityBenefitShieldChargeRequestMessage extends Marshallable[FacilityBenefitShieldChargeRequestMessage] with Serializable
78.  object FavoritesAction extends Enumeration
79.  object FavoritesMessage extends Marshallable[FavoritesMessage] with Serializable
80.  object FavoritesRequest extends Marshallable[FavoritesRequest] with Serializable
81.  object FireHintMessage extends Marshallable[FireHintMessage] with Serializable
82.  object FlagInfo extends Marshallable[FlagInfo] with Serializable
83.  object Friend extends Marshallable[Friend] with Serializable
84.  object FriendAction extends Enumeration
85.  object FriendsRequest extends Marshallable[FriendsRequest] with Serializable
86.  object FriendsResponse extends Marshallable[FriendsResponse] with Serializable
87.  object GamePropertyScope
88.  object GamePropertyTarget
89.  object GenericActionEnum extends Enumeration
90.  object GenericActionMessage extends Marshallable[GenericActionMessage] with Serializable
91.  object GenericCollisionMsg extends Marshallable[GenericCollisionMsg] with Serializable
92.  object GenericObjectActionEnum extends Enumeration
93.  object GenericObjectActionMessage extends Marshallable[GenericObjectActionMessage] with Serializable
94.  object GenericObjectStateMsg extends Marshallable[GenericObjectStateMsg] with Serializable
95.  object HackMessage extends Marshallable[HackMessage] with Serializable
96.  object HackState extends Enumeration

    An `Enumeration` of the various states and activities of the hacking process.

    An `Enumeration` of the various states and activities of the hacking process. These values are closely tied to the condition of the hacking progress bar and/or the condition of the hacked object.
    `Start` initially displays the hacking progress bar.
    `Ongoing` is a neutral state that keeps the progress bar displayed while its value updates. (unconfirmed?)
    `Finished` disposes of the hacking progress bar. It does not, by itself, mean the hack was successful.
    `Hacked` modifies the target of the hack.
    `HackCleared` modifies the target of the hack, opposite of `Hacked`.

97.  object HitHint extends Marshallable[HitHint] with Serializable
98.  object HitMessage extends Marshallable[HitMessage] with Serializable
99.  object HotSpotInfo extends Marshallable[HotSpotInfo] with Serializable
100.  object HotSpotUpdateMessage extends Marshallable[HotSpotUpdateMessage] with Serializable
101.  object ImplantAction extends Enumeration

     An `Enumeration` for all the actions that can be applied to implants and implant slots.

102.  object InvalidTerrainMessage extends Marshallable[InvalidTerrainMessage] with Serializable
103.  object InventoryStateMessage extends Marshallable[InventoryStateMessage] with Serializable
104.  object ItemTransactionMessage extends Marshallable[ItemTransactionMessage] with Serializable
105.  object ItemTransactionResultMessage extends Marshallable[ItemTransactionResultMessage] with Serializable
106.  object KeepAliveMessage extends Marshallable[KeepAliveMessage] with Serializable
107.  object LashMessage extends Marshallable[LashMessage] with Serializable
108.  object LoadMapMessage extends Marshallable[LoadMapMessage] with Serializable
109.  object LoginMessage extends Marshallable[LoginMessage] with Serializable
110.  object LoginRespMessage extends Marshallable[LoginRespMessage] with Serializable
111.  object LongRangeProjectileInfoMessage extends Marshallable[LongRangeProjectileInfoMessage] with Serializable
112.  object LootItemMessage extends Marshallable[LootItemMessage] with Serializable
113.  object MailMessage extends Marshallable[MailMessage] with Serializable
114.  object MemberEvent extends Enumeration
115.  object MountVehicleCargoMsg extends Marshallable[MountVehicleCargoMsg] with Serializable
116.  object MountVehicleMsg extends Marshallable[MountVehicleMsg] with Serializable
117.  object MoveItemMessage extends Marshallable[MoveItemMessage] with Serializable
118.  object ObjectAttachMessage extends Marshallable[ObjectAttachMessage] with Serializable
119.  object ObjectCreateDetailedMessage extends Marshallable[ObjectCreateDetailedMessage] with Serializable
120.  object ObjectCreateMessage extends Marshallable[ObjectCreateMessage] with Serializable
121.  object ObjectDeleteMessage extends Marshallable[ObjectDeleteMessage] with Serializable
122.  object ObjectDeployedMessage extends Marshallable[ObjectDeployedMessage] with Serializable
123.  object ObjectDetachMessage extends Marshallable[ObjectDetachMessage] with Serializable
124.  object ObjectDetectedMessage extends Marshallable[ObjectDetectedMessage] with Serializable
125.  object ObjectHeldMessage extends Marshallable[ObjectHeldMessage] with Serializable
126.  object OrbitalShuttleTimeMsg extends Marshallable[OrbitalShuttleTimeMsg] with Serializable
127.  object OrbitalStrikeWaypointMessage extends Marshallable[OrbitalStrikeWaypointMessage] with Serializable
128.  object OxygenStateMessage extends Marshallable[OxygenStateMessage] with Serializable
129.  object PickupItemMessage extends Marshallable[PickupItemMessage] with Serializable
130.  object PingMsg extends Marshallable[PingMsg] with Serializable
131.  object PlanetSideZoneID extends Serializable
132.  object PlanetsideAttributeEnum extends Enumeration
133.  object PlanetsideAttributeMessage extends Marshallable[PlanetsideAttributeMessage] with Serializable
134.  object PlanetsideStringAttributeMessage extends Marshallable[PlanetsideStringAttributeMessage] with Serializable
135.  object PlayerStasisMessage extends Marshallable[PlayerStasisMessage] with Serializable
136.  object PlayerStateMessage extends Marshallable[PlayerStateMessage] with Serializable
137.  object PlayerStateMessageUpstream extends Marshallable[PlayerStateMessageUpstream] with Serializable
138.  object PlayerStateShiftMessage extends Marshallable[PlayerStateShiftMessage] with Serializable
139.  object ProjectileCharacteristics extends IntEnum[ProjectileCharacteristics]

     Characteristics about the projectile being produced by a `WeaponFireMessage` packet.

     Characteristics about the projectile being produced by a `WeaponFireMessage` packet. Not really useful outside of `WeaponFireMessage`?

140.  object ProjectileStateMessage extends Marshallable[ProjectileStateMessage] with Serializable
141.  object PropertyOverrideMessage extends Marshallable[PropertyOverrideMessage] with Serializable
142.  object ProximityTerminalUseMessage extends Marshallable[ProximityTerminalUseMessage] with Serializable
143.  object QuantityDeltaUpdateMessage extends Marshallable[QuantityDeltaUpdateMessage] with Serializable
144.  object QuantityUpdateMessage extends Marshallable[QuantityUpdateMessage] with Serializable
145.  object ReleaseAvatarRequestMessage extends Marshallable[ReleaseAvatarRequestMessage] with Serializable
146.  object ReloadMessage extends Marshallable[ReloadMessage] with Serializable
147.  object RepairMessage extends Marshallable[RepairMessage] with Serializable
148.  object ReplicationStreamMessage extends Marshallable[ReplicationStreamMessage] with Serializable
149.  object RequestDestroyMessage extends Marshallable[RequestDestroyMessage] with Serializable
150.  object RespawnAMSInfoMessage extends Marshallable[RespawnAMSInfoMessage] with Serializable
151.  object RibbonBarsSlot extends Enumeration

     An `Enumeration` of the slots for award ribbons on a player's `RibbonBars`.

152.  object ServerType extends IntEnum[ServerType]
153.  object ServerVehicleOverrideMsg extends Marshallable[ServerVehicleOverrideMsg] with Serializable
154.  object SetChatFilterMessage extends Marshallable[SetChatFilterMessage] with Serializable
155.  object SetCurrentAvatarMessage extends Marshallable[SetCurrentAvatarMessage] with Serializable
156.  object SetEmpireMessage extends Marshallable[SetEmpireMessage] with Serializable
157.  object ShiftState extends Serializable
158.  object Shortcut extends Marshallable[Shortcut] with Serializable
159.  object SimDataChallenge extends Marshallable[SimDataChallenge] with Serializable
160.  object SimDataChallengeResp extends Marshallable[SimDataChallengeResp] with Serializable
161.  object SpawnRequestMessage extends Marshallable[SpawnRequestMessage] with Serializable
162.  object SplashHitMessage extends Marshallable[SplashHitMessage] with Serializable
163.  object SplashedTarget extends Marshallable[SplashedTarget] with Serializable
164.  object SquadAction
165.  object SquadDefinitionActionMessage extends Marshallable[SquadDefinitionActionMessage] with Serializable
166.  object SquadDetail extends Serializable
167.  object SquadDetailDefinitionUpdateMessage extends Marshallable[SquadDetailDefinitionUpdateMessage] with Serializable
168.  object SquadHeader

     An object that contains all of the logic necessary to transform between the various forms of squad information found in formulaic packet data structures and a singular `SquadInfo` object with only the important data fields that were defined.

169.  object SquadInfo extends Serializable
170.  object SquadInvitationRequestMessage extends Marshallable[SquadInvitationRequestMessage] with Serializable
171.  object SquadListing extends Serializable
172.  object SquadMemberEvent extends Marshallable[SquadMemberEvent] with Serializable
173.  object SquadMembershipRequest extends Marshallable[SquadMembershipRequest] with Serializable
174.  object SquadMembershipResponse extends Marshallable[SquadMembershipResponse] with Serializable
175.  object SquadPositionDetail extends Serializable
176.  object SquadPositionEntry extends Serializable
177.  object SquadState extends Marshallable[SquadState] with Serializable
178.  object SquadStateInfo extends Serializable
179.  object SquadWaypointEvent extends Marshallable[SquadWaypointEvent] with Serializable
180.  object SquadWaypointRequest extends Marshallable[SquadWaypointRequest] with Serializable
181.  object Statistics extends Serializable
182.  object TargetInfo extends Serializable
183.  object TargetingImplantRequest extends Marshallable[TargetingImplantRequest] with Serializable
184.  object TargetingInfoMessage extends Marshallable[TargetingInfoMessage] with Serializable
185.  object TerrainCondition extends Enumeration

     An `Enumeration` of the two conditions of the terrain - safe and unsafe.

186.  object TimeOfDayMessage extends Marshallable[TimeOfDayMessage] with Serializable
187.  object TrainingZoneMessage extends Marshallable[TrainingZoneMessage] with Serializable
188.  object TriggerEffectMessage extends Marshallable[TriggerEffectMessage] with Serializable
189.  object TriggerEnvironmentalDamageMessage extends Marshallable[TriggerEnvironmentalDamageMessage] with Serializable
190.  object TriggerSoundMessage extends Marshallable[TriggerSoundMessage] with Serializable
191.  object TriggeredSound extends Enumeration

     An `Enumeration` of the sounds triggered by this packet.

     An `Enumeration` of the sounds triggered by this packet. Twenty-one possible sounds are available for playback.

192.  object UnuseItemMessage extends Marshallable[UnuseItemMessage] with Serializable
193.  object UseItemMessage extends Marshallable[UseItemMessage] with Serializable
194.  object VNLWorldStatusMessage extends Marshallable[VNLWorldStatusMessage] with Serializable
195.  object VehicleStateMessage extends Marshallable[VehicleStateMessage] with Serializable
196.  object VehicleSubStateMessage extends Marshallable[VehicleSubStateMessage] with Serializable
197.  object VoiceHostInfo extends Marshallable[VoiceHostInfo] with Serializable
198.  object VoiceHostKill extends Marshallable[VoiceHostKill] with Serializable
199.  object VoiceHostRequest extends Marshallable[VoiceHostRequest] with Serializable
200.  object WarpgateRequest extends Marshallable[WarpgateRequest] with Serializable
201.  object WaypointEventAction extends Enumeration

     Actions that can be requested of the specific waypoint.

202.  object WeaponDelayFireMessage extends Marshallable[WeaponDelayFireMessage] with Serializable
203.  object WeaponDryFireMessage extends Marshallable[WeaponDryFireMessage] with Serializable
204.  object WeaponFireMessage extends Marshallable[WeaponFireMessage] with Serializable
205.  object WeaponJammedMessage extends Marshallable[WeaponJammedMessage] with Serializable
206.  object WeaponLazeTargetPositionMessage extends Marshallable[WeaponLazeTargetPositionMessage] with Serializable
207.  object WeatherMessage extends Marshallable[WeatherMessage] with Serializable
208.  object WorldStatus extends Enumeration
209.  object ZipLineMessage extends Marshallable[ZipLineMessage] with Serializable
210.  object ZoneForcedCavernConnectionsMessage extends Marshallable[ZoneForcedCavernConnectionsMessage] with Serializable
211.  object ZoneInfoMessage extends Marshallable[ZoneInfoMessage] with Serializable
212.  object ZoneLockInfoMessage extends Marshallable[ZoneLockInfoMessage] with Serializable
213.  object ZonePopulationUpdateMessage extends Marshallable[ZonePopulationUpdateMessage] with Serializable

### Ungrouped