Data Types

Backwards Compatibility

Each type described here also has a version given in brackets. Make sure you use the right version for a given type when parsing.

Float32 vs Half (Float16)

When the half variant of a type, such as Vector3 and Quaternion is used, it will be explicitly written as HalfVector3 and HalfQuaternion.

Headers

ReplayRecorder.Header (0.0.1)

ReplayRecorder.Header {
  string: version
  bool: isMaster
}

version - The version of ReplayRecorder.dll in use.
isMaster - Whether the recorder was ran as Host (True) or Client (False).

ReplayRecorder.EndOfHeader (0.0.1)

Contains no data, simply signals the end of the header list.

Vanilla.Metadata (0.0.1)

Vanilla.Metadata {
  string: version
}

version - The version of Vanilla.dll in use.

Vanilla.Metadata (0.0.2)

Vanilla.Metadata {
  string: version
  bool: compatibility_OldBulkheadSound
}

version - The version of Vanilla.dll in use.
compatibility_OldBulkheadSound - Whether the compatibility layer for the mod oldBulkheadSounds is in use.
- If True, then alert blame for waking enemies as host may be inconsistent for scream doors.

Vanilla.Map.Geometry (0.0.1)

Represents a single surface of the in game navmesh.

Vanilla.Map.Geometry {
  byte: dimension
  ushort: nVertices
  uint: nIndices
  Vector3[nVertices]: vertices
  ushort[nIndices]: indices
}

dimension - The dimension that this surface belongs to.
nVertices - The number of vertices in this surface.
nIndices - The number of indices in this surface.
vertices - The vertex array of the surface.
indices - The indices array of the surface.

The mesh follows unity convention and thus the winding order is clockwise. Keep this in mind when you render the mesh vertices if you follow a different convention.

Vanilla.Map.Geometry.EOH (0.0.1)

Contains no data, simply signals that all map geometry has been written. It is used internally as the mechanism that triggers ReplayRecorder.EndOfHeader checks if all header types have been written at least once.

If this type did not exist, upon writing one Vanilla.Map.Geometry type, ReplayRecorder.EndOfHeader would trigger even though not all map surfaces have been written yet.

Vanilla.Map.Doors (0.0.1)

Vanilla.Map.Doors {
  ushort: nDoors
  {
    int: id
    
    byte: dimension
    Vector3: position
    HalfQuaternion: rotation
    
    ushort: serialNumber
    bool: isCheckpoint
    byte: type
    byte: size
  }[nDoors]
}

nDoors - The total number of doors.

Each Door entry:

id - The id of a given door.
dimension - The dimension the door is in.
position - The location of the door.
rotation - The rotation of the door.
serialNumber - The terminal id of the door, used in game to ping the door on terminals.
isCheckpoint - If true, the door is a checkpoint door.

type - Byte representation of the enum:

enum DoorType {
  WeakDoor = 0
  SecurityDoor = 1
  BulkheadDoor = 2
  BulkheadDoorMain = 3
  ApexDoor = 4
}

size - Byte representation of the enum:

enum DoorSize {
  Small = 0
  Medium = 1
  Large = 2
}

It seems that in game, the door size Medium and Large have the same meaning for the long rectangular doors, whereas Small represents the single square doors.

Vanilla.Map.Ladders (0.0.1)

Vanilla.Map.Ladders {
  ushort: nLadders
  {
    byte: dimension
    Vector3: top
    HalfQuaternion: rotation
    Half: height
  }[nLadders]
}

nLadders - The total number of ladders.

Each Ladder entry:

dimension - The dimension the ladder is in.
top - The position of the top of the ladder.
rotation - The rotation of the ladder.
height - The height that the ladder extends downwards.

Vanilla.Map.Terminals (0.0.1)

Vanilla.Map.Terminals {
  ushort: nTerminals
  {
    int: id
    byte: dimension
    Vector3: position
    HalfQuaternion: rotation
  }[nTerminals]
}

nTerminals - The total number of terminals.

Each Terminal entry:

id - The id for the given terminal.
dimension - The dimension the terminal is in.
position - The position of the terminal.
rotation - The rotation of the terminal.

Vanilla.Map.Terminals (0.0.2)

Vanilla.Map.Terminals {
  ushort: nTerminals
  {
    int: id
    byte: dimension
    Vector3: position
    HalfQuaternion: rotation
    ushort: serialNumber
  }[nTerminals]
}

nTerminals - The total number of terminals.

Each Terminal entry:

id - The id for the given terminal.
dimension - The dimension the terminal is in.
position - The position of the terminal.
rotation - The rotation of the terminal.
serialNumber - The terminal id of the terminal, used in game to ping the terminal on terminals.

Vanilla.Map.Generators (0.0.1)

Vanilla.Map.Generators {
  ushort: nGenerators
  {
    int: id
    byte: dimension
    Vector3: position
    HalfQuaternion: rotation
    ushort: serialNumber
  }[nGenerators]
}

nGenerators - The total number of generators.

Each Generator entry:

id - The id of a given generator.
dimension - The dimension the generator is in.
position - The position of the generator.
rotation - The rotation of the generator.
serialNumber - The terminal id of the generator, used in game to ping the generator on terminals.

Vanilla.Map.ResourceContainers (0.0.1)

Vanilla.Map.ResourceContainers {
  ushort: nContainers
  {
    int: id
    byte: dimension
    Vector3: position
    HalfQuaternion: rotation
    ushort: serialNumber
    bool: isLocker
  }[nContainers]
}

nContainers - The total number of Resource Containers.

Each Resource Container entry:

id - The id of a given container.
dimension - The dimension the container is in.
position - The position of the container.
rotation - The rotation of the container.
serialNumber - The terminal id of the container, used in game to ping the container on terminals.
isLocker - Whether the container is a locker (True) or a box (False).

Vanilla.Map.ResourceContainers (0.0.2)

Vanilla.Map.ResourceContainers {
  ushort: nContainers
  {
    int: id
    byte: dimension
    Vector3: position
    HalfQuaternion: rotation
    ushort: serialNumber
    bool: isLocker
    : consumableType,
    bool: registered
  }[nContainers]
}

nContainers - The total number of Resource Containers.

Each Resource Container entry:

id - The id of a given container.
dimension - The dimension the container is in.
position - The position of the container.
rotation - The rotation of the container.
serialNumber - The terminal id of the container, used in game to ping the container on terminals.
isLocker - Whether the container is a locker (True) or a box (False).
consumableType - The consumable type the locker was assigned
registered - Whether the container is active (True) or not (False). Active containers are actually visible and interactable within the level.

Vanilla.Map.ResourceContainers (0.0.3)

Vanilla.Map.ResourceContainers {
  ushort: nContainers
  {
    int: id
    byte: dimension
    Vector3: position
    HalfQuaternion: rotation
    ushort: serialNumber
    bool: isLocker
    : consumableType,
    bool: registered
    byte: assignedLockType
  }[nContainers]
}

nContainers - The total number of Resource Containers.

Each Resource Container entry:

id - The id of a given container.
dimension - The dimension the container is in.
position - The position of the container.
rotation - The rotation of the container.
serialNumber - The terminal id of the container, used in game to ping the container on terminals.
isLocker - Whether the container is a locker (True) or a box (False).
consumableType - The consumable type the locker was assigned
registered - Whether the container is active (True) or not (False). Active containers are actually visible and interactable within the level.
assignedLockType - The type of lock the container may spawn with. Byte representation of the enum:
```
enum LockType {
  None = 0
  Melee = 1
  Hack = 2
}
```

assignedLockType is not representative of if the container is locked or not. It simply is the type of lock the container will have if it is locked. This is useful information for speedrunners that want to create routes to specific consumable spawn locations with containers that only spawn with melee-able locks.

Vanilla.Map.DisinfectStations (0.0.1)

Vanilla.Map.DisinfectStations {
  ushort: nStations
  {
    int: id
    byte: dimension
    Vector3: position
    HalfQuaternion: rotation
    ushort: serialNumber
  }[nStations]
}

nStations - The total number of Disinfect Stations.

Each Disinfect Station entry:

id - The id of a given station.
dimension - The dimension the station is in.
position - The position of the station.
rotation - The rotation of the station.
serialNumber - The terminal id of the station, used in game to ping the station on terminals.

Vanilla.Map.BulkheadControllers (0.0.1)

Vanilla.Map.BulkheadControllers {
  ushort: nControllers
  {
    int: id
    byte: dimension
    Vector3: position
    HalfQuaternion: rotation
    ushort: serialNumber
    bool: mainLayer
    (int?): mainDoorId
    bool: secondaryLayer
    (int?): secondaryDoorId
    bool: overloadLayer
    (int?): overloadDoorId
  }[nControllers]
}

nControllers - The total number of Bulkhead Controllers.

Each Bulkhad Controller entry:

id - The id of a given controller.
dimension - The dimension the controlleris in.
position - The position of the controller.
rotation - The rotation of the controller.
serialNumber - The terminal id of the controller, used in game to ping the controller on terminals.
mainLayer - True if this controller activates the Main objective, otherwise false
mainDoorId - If the mainLayer is False, then this value does not exist and does not need to be parsed. If True, then this is the ID for the door which opens when Main objective is activated
secondaryLayer - True if this controller activates the Secondary objective, otherwise false
secondaryDoorId - If the secondaryLayer is False, then this value does not exist and does not need to be parsed. If True, then this is the ID for the door which opens when Secondary objective is activated
overloadLayer - True if this controller activates the Overload objective, otherwise false
overloadDoorId - If the overloadLayer is False, then this value does not exist and does not need to be parsed. If True, then this is the ID for the door which opens when Overload objective is activated

Vanilla.Enemy.Spitters (0.0.1)

Vanilla.Enemy.Spitters {
  ushort: nSpitters
  {
    int: id
    byte: dimension
    Vector3: position
    HalfQuaternion: rotation
    Half: scale
  }[nSpitters]
}

nSpitters - The total number of Spitters.

Each Spitter entry:

id - The id of a given spitter.
dimension - The dimension the spitter is in.
position - The position of the spitter.
rotation - The rotation of the spitter.
scale - The size of the spitter assigned by the game.

Events

ReplayRecorder.Spawn (0.0.1)

ReplayRecorder.Spawn {
  type: ushort
  id: int
  ...
}

type - The type identifier for the dynamic being spawned.
id - The id of the dynamic.
... - The spawn data to be parsed as specified by the type.

ReplayRecorder.Despawn (0.0.1)

ReplayRecorder.Despawn {
  type: ushort
  id: int
  ...
}

type - The type identifier for the dynamic being spawned.
id - The id of the dynamic.
... - The despawn data to be parsed as specified by the type.

Vanilla.Checkpoint (0.0.1)

Vanilla.Checkpoint {
}

No data, simply signals that a restart to checkpoint was triggered.

Vanilla.StatTracker.Pack (0.0.1)

Vanilla.StatTracker.Pack {
  byte: type
  ushort: source
  ushort: target
}

type - Byte representation of the enum:

enum PackType {
  Ammo = 0
  Tool = 1
  Healing = 2
  Disinfect = 3
}

In game there is no distinction between a medipack, healing syringe (I2-HP) or any other form of healing item as its simply handled as "Add this amount of hp". For this reason, "Healing" for pack use refers to all usages of healing items as opposed to just the pack.

A consistent solution to identify what healing item has yet to be found.

source - The id of the player that gave the resource
target - The id of the player that was given the resource

Vanilla.StatTracker.Damage (0.0.1)

Vanilla.StatTracker.Damage {
  byte: type
  int: source
  ushort: target
  Half: damage
  : gear
  bool: sentry
  Half: staggerDamage
}

type - Byte representation of the enum:

enum DamageType {
  Bullet = 0
  Explosive = 1
  Melee = 2
  Projectile = 3
  Tongue = 4
  Fall = 5
}

source - id of the player, enemy or mine, that dealt the damage. id's are unique between players and enemies, so if it does not exist in one it must be the other. If the damage type was Explosive the source is always a mine
target - id of the player or enemy that received the damage. id's are unique between players and enemies, so if it does not exist in one it must be the other
damage - The amount of damage dealt
gear - The item used to deal the damage (if Unknown, then damage was not dealt by an item)
sentry - If True the damage was dealt by a sentry, otherwise if False the damage was dealt by the player themself
staggerDamage - The amount of stagger damage dealt

You can still receive damage events for enemies that are already dead and have been despawned. This is due to ping and the game is receiving these events late from clients that still think the enemy is alive. Simply ignoring these events is fine - later versions no longer record these redundant events but for backwards compatibility its important to handle this case.

Due to floating point inaccuracy with Half, an enemy may die with close to 0 health when calculating the current enemy health from these damage events.

For this reason, to properly credit kills you should keep track when the enemy was last hit and by who. When the enemy is finally despawned, you can grant kill credit if it died within 500ms (implementation defined time) of being hit and its hp is close enough to 0.

Vanilla.StatTracker.Revive (0.0.1)

Vanilla.StatTracker.Revive {
  ushort: source
  ushort: target
}

source - The source player that performed the revive
target - The target player that was revived

Vanilla.StatTracker.TongueDodge (0.0.1)

Vanilla.StatTracker.TongueDodge {
  ushort: source
  ushort: target
}

source - The source enemy that is attacking
target - The target player that dodged the tongue

Vanilla.Map.Weakdoor.Punch (0.0.1)

This event is used to trigger the punch animation effect.

Vanilla.Map.Weakdoor.Punch {
  int: id
}

id - The id of the door that was punched.

Vanilla.Map.DoorStatusChange (0.0.1)

Vanilla.Map.Weakdoor.Punch {
  int: id
  byte: status
}

id - The id of the door that was updated.

status - Byte representation of the enum:

enum DoorState {
  Closed = 0
  Opened = 1
  Glued = 2
  Destroyed = 3
}

Vanilla.Player.Gunshots (0.0.1)

Vanilla.Player.Gunshots {
  int: owner
  byte: dimension
  Half: damage
  bool: sentry
  Vector3: start
  Vector3: end
}

owner - id of the player that performed the shot. If the id is -1 then no owner was found and the shot probably comes from a modded gun.
dimension - The dimension the shot was performed in
damage - The raw damage of the shot (Used to render stronger bullets as thicker lines to make them look beefier)
sentry - Whether the shot was performed by a sentry (Used to render sentry bullets differently)
start - The start position of the shot
end - The end position of the shot

Note that these represent the ray casts the game makes, thus penetrating shots show up as 2 gunshots, one starting at the player and ending at first enemy, the second starting at the enemy and ending on the terrain etc...

An int id was used as opposed to a ushort id because this was going to support gunshots made by static level sentries from modded content - but for now remains unused.

Vanilla.Player.Gunshots (0.0.2)

Vanilla.Player.Gunshots {
  int: owner
  byte: dimension
  Half: damage
  bool: sentry
  Vector3: start
  Vector3: end
  silent: bool
}

owner - id of the player that performed the shot. If the id is -1 then no owner was found and the shot probably comes from a modded gun.
dimension - The dimension the shot was performed in
damage - The raw damage of the shot (Used to render stronger bullets as thicker lines to make them look beefier)
sentry - Whether the shot was performed by a sentry (Used to render sentry bullets differently)
start - The start position of the shot
end - The end position of the shot
silent - Whether this shot was a silent shot (Used to render silent shots differently)

Refer to the same footnotes as from Vanilla.Player.Gunshots (0.0.1)

If you wish to count the number of silent shots, keep note of the previous footnotes that these events represent each ray cast made by the game. So you need to batch multiple rays from shotgun or penetration into a single shot when counting.

Vanilla.Mine.Detonate (0.0.1)

Vanilla.Mine.Detonate {
  int: id
  ushort: player
  bool: shot
}

id - The id of the mine
player - The id of the player that this detonation belongs to, used to determine who to grant kill credit / assists to when tracking stats
shot - If true then the mine was manually shot by the recorded player and not triggered by an enemy

Vanilla.Enemy.Alert (0.0.1)

Vanilla.Enemy.Alert {
  int: enemy
  byte: slot
}

enemy - id of the enemy that was alerted
slot - The slot index of the player that triggered the enemy to alert

For scouts, alerts from running simply trigger it to put out its tendrils.

Vanilla.Enemy.Spitter.Explode (0.0.1)

This event is used to trigger the explode animation for spitters when they attack players.

Vanilla.Enemy.Spitter.Explode {
  int: id
}

id - The id of the spitter that just exploded

Vanilla.Enemy.LimbDestruction (0.0.1)

Vanilla.Enemy.LimbDestruction {
  int: enemy
  byte: limb
}

enemy - The id of the enemy that lost a limb
limb - Byte representation of the enum:
```
enum Limb {
  Head = 0
}
```

Currently only supports detecting if the head was destroyed. This will be updated in the future, but is low priority.

Vanilla.Enemy.Animation.AttackWindup (0.0.1)

Vanilla.Enemy.Animation.AttackWindup {
  int: enemy
  byte: animIndex
}

enemy - The id of the enemy
animIndex - Which attack animation to use

Vanilla.Enemy.Animation.Hitreact (0.0.1)

Vanilla.Enemy.Animation.Hitreact {
  int: enemy
  byte: animIndex
  byte: direction
  byte: type
}

enemy - The id of the enemy
animIndex - Which react animation to use

direction - Byte representation of the enum:

enum HitReactDirection {  
  Forward = 0
  Backward = 1
  Left = 2
  Right = 3
}

type - Byte representation of the enum:

enum HitReactType {
  Light = 0
  Heavy = 1
}

Each hit react type and direction has its own set of animations that gets indexed. This is why direction and type are required.

Vanilla.Enemy.Animation.Melee (0.0.1)

Vanilla.Enemy.Animation.Melee {
  int: enemy
  byte: animIndex
  byte: direction
}

enemy - The id of the enemy
animIndex - Which melee animation to use

direction - Byte representation of the enum:

enum MeleeDirection {
  Forward = 0
  Backward = 1
}

Each melee direction has its own set of animations that gets indexed. This is why direction is required.

Vanilla.Enemy.Animation.Jump (0.0.1)

Vanilla.Enemy.Animation.AttackWindup {
  int: enemy
  byte: animIndex
}

enemy - The id of the enemy
animIndex - Which jump animation to use

Vanilla.Enemy.Animation.Heartbeat (0.0.1)

Vanilla.Enemy.Animation.Heartbeat {
  int: enemy
  byte: animIndex
}

enemy - The id of the enemy
animIndex - Which heartbeat animation to use

Vanilla.Enemy.Animation.Wakeup (0.0.1)

Vanilla.Enemy.Animation.Wakeup {
  int: enemy
  byte: animIndex
  bool: turn
}

enemy - The id of the enemy
animIndex - Which wakeup animation to use
turn - Whether the animation is of the enemy turning around or not

Each wakeup direction has its own set of animations that gets indexed. This is why turn is required.

Vanilla.Enemy.Animation.PouncerGrab (0.0.1)

This event is used to trigger the pouncer grab animation.

Vanilla.Enemy.Animation.PouncerGrab {
  int: enemy
}

enemy - The id of the enemy

Vanilla.Enemy.Animation.PouncerSpit (0.0.1)

This event is used to trigger the pouncer spit animation.

Vanilla.Enemy.Animation.PouncerSpit {
  int: enemy
}

enemy - The id of the enemy

Vanilla.Enemy.Animation.ScoutScream (0.0.1)

This event is used to trigger the scout scream animation including wind up and wind down.

Vanilla.Enemy.Animation.ScoutScream {
  int: enemy
  bool: start
}

enemy - The id of the enemy
start - Whether this is the wind up sequence (True) or the wind down sequence (False)

For some reason this event gets triggered even when the scout is dead. I have no idea why, just be aware of this and ignore events for already dead enemies.

Vanilla.Enemy.Animation.BigFlyerCharge (0.0.1)

This event is used to trigger the opening of the big flyer eye when it is charging up an attack

Vanilla.Enemy.Animation.BigFlyerCharge {
  int: enemy
  Half: chargeDuration
}

enemy - The id of the enemy
chargeDuration - How long the charge lasts for in seconds, not including the additional time the eye remains open for after the shot has be made. It is up to the implementation how long to leave the eye open for after the shot has been made, the behaviour I chose was to linger for half a second.

Currently there is a bug where this event is not triggered for clients. So client recorded replays will not be able to properly animate the opening of the eye.

A fix is being worked on.

Vanilla.Enemy.TongueEvent (0.0.1)

This event is used to record the fully extended tongue of an enemy as the polling rate of the dynamic that is used to track the tongue may not record it.

Vanilla.Enemy.TongueEvent {
  int: enemy
  byte: numPoints
  Vector3: start
  {
    HalfVector3: delta
  }[numPoints - 1]
}

enemy - The id of the enemy owning the tongue
numPoints - The number of spline points that make up the tongue, including the start point
start - The starting point of the spline
delta - The difference between the current spline point and the last. For example if the last spline was located at (0, 0, 1) and the read delta was (0, 1, 0), then the current spline point is located at (0, 1, 1).

Vanilla.Player.Animation.MeleeSwing (0.0.1)

Vanilla.Player.Animation.MeleeSwing {
  int: player
  bool: charged
}

player - The id of the player making the melee swing
charged - Whether the melee swing was a charged swing or not (charged swings have different animations)

Vanilla.Player.Animation.MeleeShove (0.0.1)

Vanilla.Player.Animation.MeleeShove {
  int: player
}

player - The id of the player making the shove

Vanilla.Player.Animation.ConsumableThrow (0.0.1)

Vanilla.Player.Animation.MeleeShove {
  int: player
}

player - The id of the player making the throw

Vanilla.Player.Animation.Revive (0.0.1)

Vanilla.Player.Animation.MeleeShove {
  int: player
}

player - The id of the player getting up after being revived

This event doesn't always get triggered at checkpoints, so you should also compare the downed state with the animation state in Vanilla.Player.Animation.

How this is handled is largely an implementation detail.

Vanilla.Player.Animation.Downed (0.0.1)

Vanilla.Player.Animation.MeleeShove {
  int: player
}

player - The id of the player getting downed

Dynamics

Dynamics consist of 3 parts:

Spawn - The format of the dynamic when received as a spawn event.
Update - The format of the dynamic when updated in a given snapshot.
Despawn - The format of the dynamic when received as a despawn event.

Vanilla.Player (0.0.1)

Spawn

Vanilla.Player {
  byte: dimension
  Vector3: position
  HalfQuaternion: rotation
  uint64: steamId
  byte: slot
  string: nickname
}

dimension - Initial dimension the player spawned in
position - Initial position of the player
rotation - Initial rotation of the player
steamId - 64 bit unsigned integer representing Steam user ID
slot - Slot index of player
nickname - Name of player as displayed in game (may be different to steam profile)

Update

Vanilla.Player {
  byte: dimension
  bool: absolute
  (Vector3 | HalfVector3): position
  HalfQuaternion: rotation 
  : equippedId
}

dimension - Current dimension the player is in
absolute - Whether the position is the current position of the player (True) or is the change in position that occurred since last update (False)
position - If absolute is True, it is a Vector3 that represents the current position of the player. Otherwise, it is a HalfVector3 that represents the change in position that occurred since last update. For example, if absolute is False and the location last update was (0, 10, 0). If the read HalfVector3 is (0, 0, 1), then the current position of the player is (0, 10, 1). If absolute was True and the read Vector3 was (0, 10, 1), then the current position of the player is (0, 10, 1).
rotation - The current rotation of the player, unaffected by absolute
equippedId - Players currently equipped item

Despawn
Vanilla.Player {
}

No additional data, the player is simply despawned

Vanilla.Player.Backpack (0.0.1)

Separated from Vanilla.Player as it is unlikely that the equipped information changes frequently thus avoids writing it every time the player is animated or moved.

Spawn

Vanilla.Player.Backpack {
  : melee
  : primary
  : special
  : tool
  : pack
  : consumable
  : heavyItem
  : hackingTool
  : vanityHelmet
  : vanityTorso
  : vanityLegs
  : vanityBackpack
  : vanityPallete
}

melee - The equipped melee weapon
primary - The equipped primary weapon
special - The equipped special weapon
tool - The equipped tool
pack - The equipped resource pack
consumable - The equipped consumable item
heavyItem - The equipped heavy item
vanityHelmet - The equipped vanity helmet
vanityTorso - The equipped vanity torso
vanityLegs - The equipped vanity legs
vanityBackpack - The equipped vanity backpack
vanityPallete - The equipped vanity colour pallete

Update
Exact same format as Spawn

Despawn

Vanilla.Player.Backpack {
}

No additional data, the player backpack is simply despawned

Vanilla.Player.Stats (0.0.1)

Separated from Vanilla.Player as it is unlikely that status changes unless in combat, thus avoids writes when the player is moving around during down time.

Spawn

Vanilla.Player.Stats {
  byte: health
  byte: infection
  byte: primaryAmmo
  byte: secondaryAmmo
  byte: toolAmmo
  byte: consumableAmmo
  byte: packAmmo
}

health - Current health of the player as a percentage. To get the health as a percentage, divide this value by 255
infection - Current infection of the player as a percentage. To get the infection as a percentage, divide this value by 255
primaryAmmo - Current primary ammo of the player as a percentage. To get the ammo as a percentage, divide this value by 255
secondaryAmmo - Current secondary ammo of the player as a percentage. To get the ammo as a percentage, divide this value by 255
toolAmmo - Current tool ammo of the player as a percentage. To get the ammo as a percentage, divide this value by 255
consumableAmmo - Current number of consumables the player has as a percentage. To get the number of consumables as a percentage, divide this value by 255
packAmmo - Current number of packs the player has as a percentage. To get the number of packs as a percentage, divide this value by 255

It is important to note that this version has failed to account for the fact that the packAmmo value in-game may be greater than 100% (6 use packs). So the value packAmmo may be wrong in those cases due to overflow.

Update
Exact same format as Spawn

Despawn

Vanilla.Player.Backpack {
}

No additional data, the player backpack is simply despawned

Vanilla.Player.Stats (0.0.2)

Exactly the same format as version 0.0.1 except packAmmo has properly been scaled to account for 6 use packs. Instead of 100% meaning 5 use, 100% means 6 use.

Vanilla.Player.Animation (0.0.1)

Spawn

Vanilla.Player.Animation {
  byte: velRight
  byte: velFwd
  byte: crouch
  HalfVector: lookDir
  byte: state
  bool: chargingMelee
  bool: chargingThrow
  bool: isReloading
  Half: reloadDuration 
}

velRight - Current (-)left/(+)right animation velocity of the player as a value between -10 and 10. To obtain this value apply the following equation: $(\frac{\text{velRight}}{255}\cdot2-1)\cdot10$
velFwd - Current (-)backward/(+)foward animation velocity of the player as a value between -10 and 10. To obtain this value apply the following equation: $(\frac{\text{velFwd}}{255}\cdot2-1)\cdot10$
crouch - The current crouch animation lerp value as a percentage. To get the percentage, divide the parsed value by 255.
lookDir - The target direction the player is facing

state - The byte representation of the following enum for current animation states:

enum AnimState {
  stand = 0
  crouch = 1
  run = 2
  jump = 3
  fall = 4
  land = 5
  stunned = 6
  downed = 7
  climbLadder = 8
  onTerminal = 9 
  melee = 10
  empty = 11
  grabbedByTrap = 12
  grabbedByTank = 13
  testing = 14
  inElevator = 15
  grabbedByPouncer = 16
  standStill = 17
}

chargingMelee - Whether the player is charging their melee weapon
chargingThrow - Whether the player is charging to throw a consumable
isReloading - Whether the player is currently reloading
reloadDuration - The duration of the current reload (Used by the renderer to scale reload animation sequences approapriately)

Update
Exact same format as Spawn

Despawn

Vanilla.Player.Animation {
}

No additional data, the player animation instance is simply despawned

Vanilla.Cfoam (0.0.1)

Spawn

Vanilla.Cfoam {
  byte: dimension
  Vector3: position
  Half: scale
}

dimension - Initial dimension of cfoam blob
position - Initial position of cfoam blob
Half - Initial scale of cfoam blob

Update

Vanilla.Cfoam {
  byte: dimension
  bool: absolute
  (Vector3 | HalfVector3): position
  Half: scale
}

dimension - Current dimension the player is in
absolute - Whether the position is the current position of the cfoam blob (True) or is the change in position that occurred since last update (False)
position - If absolute is True, it is a Vector3 that represents the current position of the cfoam blob. Otherwise, it is a HalfVector3 that represents the change in position that occurred since last update. For example, if absolute is False and the location last update was (0, 10, 0). If the read HalfVector3 is (0, 0, 1), then the current position of the cfoam blob is (0, 10, 1). If absolute was True and the read Vector3 was (0, 10, 1), then the current position of the cfoam blob is (0, 10, 1).
scale - Current scale of the cfoam blob

Despawn
Vanilla.Cfoam {
}

No additional data, the cfoam blob is simply despawned

Vanilla.Mine (0.0.1)

Spawn

Vanilla.Mine {
  byte: dimension
  Vector3: position
  HalfQuaternion: rotation
  byte: type
  ushort: player
}

dimension - Initial dimension the mine spawned in
position - Initial position of the mine
rotation - Initial rotation of the mine

type - Byte representation of the enum:

enum MineType {
  MineDeployer = 0
  CfoamMine = 1
  ConsumableMine = 2
}

player - The player that owns this mine

Update

Vanilla.Mine {
  byte: dimension
  bool: absolute
  (Vector3 | HalfVector3): position
  HalfQuaternion: rotation 
  Half: length
}

dimension - Current dimension the mine is in
absolute - Whether the position is the current position of the mine (True) or is the change in position that occurred since last update (False)
position - If absolute is True, it is a Vector3 that represents the current position of the mine. Otherwise, it is a HalfVector3 that represents the change in position that occurred since last update. For example, if absolute is False and the location last update was (0, 10, 0). If the read HalfVector3 is (0, 0, 1), then the current position of the mine is (0, 10, 1). If absolute was True and the read Vector3 was (0, 10, 1), then the current position of the mine is (0, 10, 1).
rotation - The current rotation of the mine, unaffected by absolute
length - The length of the mine detection laser

Despawn
Vanilla.Mine {
}

No additional data, the mine is simply despawned

Vanilla.Mine (0.0.2)

Spawn

Vanilla.Mine {
  byte: dimension
  Vector3: position
  HalfQuaternion: rotation
  : item
  ushort: player
}

dimension - Initial dimension the mine spawned in
position - Initial position of the mine
rotation - Initial rotation of the mine
item - The item type of the mine
player - The player that owns this mine

Update

Vanilla.Mine {
  byte: dimension
  bool: absolute
  (Vector3 | HalfVector3): position
  HalfQuaternion: rotation 
  Half: length
}

dimension - Current dimension the mine is in
absolute - Whether the position is the current position of the mine (True) or is the change in position that occurred since last update (False)
position - If absolute is True, it is a Vector3 that represents the current position of the mine. Otherwise, it is a HalfVector3 that represents the change in position that occurred since last update. For example, if absolute is False and the location last update was (0, 10, 0). If the read HalfVector3 is (0, 0, 1), then the current position of the mine is (0, 10, 1). If absolute was True and the read Vector3 was (0, 10, 1), then the current position of the mine is (0, 10, 1).
rotation - The current rotation of the mine, unaffected by absolute
length - The length of the mine detection laser

Despawn
Vanilla.Mine {
}

No additional data, the mine is simply despawned

Vanilla.Sentry (0.0.1)

Spawn

Vanilla.Sentry {
  byte: dimension
  Vector3: position
  HalfQuaternion: rotation
  ushort: player
}

dimension - Initial dimension the sentry spawned in
position - Initial position of the sentry
rotation - The rotation of the sentry's base (assume initial rotation of turret is identity)
player - The player that owns this sentry

Update

Vanilla.Sentry {
  HalfQuaternion: rotation 
}

rotation - The rotation of the sentry's turret (not base)

Despawn
Vanilla.Sentry {
}

No additional data, the sentry is simply despawned

Vanilla.DynamicItem (0.0.1)

Used to represent physics based items such as thrown fog repellers or cfoam grenades etc...

Spawn

Vanilla.DynamicItem {
  byte: dimension
  Vector3: position
  HalfQuaternion: rotation
  : item
}

dimension - Initial dimension the dynamic item spawned in
position - Initial position of the dynamic item
rotation - Initial rotation of the dynamic item
item - The item type of the dynamic item

Update

Vanilla.DynamicItem {
  byte: dimension
  bool: absolute
  (Vector3 | HalfVector3): position
  HalfQuaternion: rotation
}

dimension - Current dimension the dynamic item is in
absolute - Whether the position is the current position of the dynamic item (True) or is the change in position that occurred since last update (False)
position - If absolute is True, it is a Vector3 that represents the current position of the dynamic item. Otherwise, it is a HalfVector3 that represents the change in position that occurred since last update. For example, if absolute is False and the location last update was (0, 10, 0). If the read HalfVector3 is (0, 0, 1), then the current position of the dynamic item is (0, 10, 1). If absolute was True and the read Vector3 was (0, 10, 1), then the current position of the dynamic item is (0, 10, 1).
rotation - The current rotation of the dynamic item, unaffected by absolute

Despawn
Vanilla.DynamicItem {
}

No additional data, the dynamic item is simply despawned

Vanilla.FogSphere (0.0.1)

Used to represent the radius that fog repellers act upon.

Spawn

Vanilla.FogSphere {
  byte: dimension
  Vector3: position
  HalfQuaternion: rotation
  Half: radius
}

dimension - Initial dimension the fog sphere spawned in
position - Initial position of the fog sphere
rotation - Initial rotation of the fog sphere
item - The item type of the fog sphere
radius - The initial radius of the fog sphere

Update

Vanilla.FogSphere {
  byte: dimension
  bool: absolute
  (Vector3 | HalfVector3): position
  HalfQuaternion: rotation
  Half: radius
}

dimension - Current dimension the dynamic item is in
absolute - Whether the position is the current position of the dynamic item (True) or is the change in position that occurred since last update (False)
position - If absolute is True, it is a Vector3 that represents the current position of the dynamic item. Otherwise, it is a HalfVector3 that represents the change in position that occurred since last update. For example, if absolute is False and the location last update was (0, 10, 0). If the read HalfVector3 is (0, 0, 1), then the current position of the dynamic item is (0, 10, 1). If absolute was True and the read Vector3 was (0, 10, 1), then the current position of the dynamic item is (0, 10, 1).
rotation - The current rotation of the dynamic item, unaffected by absolute
radius - The current radius of the fog sphere

Despawn
Vanilla.FogSphere {
}

No additional data, the fog sphere is simply despawned

Vanilla.Bioscan (0.0.1)

Spawn

Vanilla.Bioscan {
  byte: dimension
  Vector3: position
  Half: radius
}

dimension - Initial dimension of bioscan
position - Initial position of bioscan
Half - Radius of bioscan

Update

Vanilla.Bioscan {
  byte: dimension
  bool: absolute
  (Vector3 | HalfVector3): position
}

dimension - Current dimension the bioscan is in
absolute - Whether the position is the current position of the bioscan (True) or is the change in position that occurred since last update (False)
position - If absolute is True, it is a Vector3 that represents the current position of the bioscan. Otherwise, it is a HalfVector3 that represents the change in position that occurred since last update. For example, if absolute is False and the location last update was (0, 10, 0). If the read HalfVector3 is (0, 0, 1), then the current position of the bioscan is (0, 10, 1). If absolute was True and the read Vector3 was (0, 10, 1), then the current position of the bioscan is (0, 10, 1).

Despawn
Vanilla.Bioscan {
}

No additional data, the bioscan is simply despawned

Vanilla.Bioscan.Status (0.0.1)

Separated from Vanilla.Bioscan as it is unlikely that the scan moves (not many moving scans in the game). Thus its more space efficient to update colour and progress separately to avoid writing location data.

Spawn

Vanilla.Bioscan.Status {
  byte: progress
  byte: red
  byte: green
  byte: blue
}

progress - Current progress of the scan as a percentage. To get the scan percentage, divide this value by 255
red - Red channel of the scan
green - Green channel of the scan
blue - Blue channel of the scan

Update
Exact same format as Spawn

Despawn

Vanilla.Bioscan.Status {
}

No additional data, the bioscan status instance is simply despawned

Vanilla.Holopath (0.0.1)

Spawn

Vanilla.Holopath {
  byte: dimension
  byte: numPoints
  Vector3: start
  {
    HalfVector3: delta
  }[numPoints - 1]
}

dimension - Initial dimension of holopath
numPoints - The number of spline points that make up the holopath, including the start point
start - The starting point of the spline
delta - The difference between the current spline point and the last. For example if the last spline was located at (0, 0, 1) and the read delta was (0, 1, 0), then the current spline point is located at (0, 1, 1).

Update

Vanilla.Holopath {
  byte: progress
}

progress - Current progress of the holopath as a percentage. To get the scan percentage, divide this value by 255

Progress of the holopath determines how much of the holopath to show. 0 means that none should be shown, whilst 1 means that the entire holopath is visible.

Despawn
Vanilla.Holopath {
}

No additional data, the holopath is simply despawned

Vanilla.Map.WeakDoor (0.0.1)

The id of the dynamic will match the id of the door in Vanilla.Map.Doors

Spawn

Vanilla.Map.WeakDoor {
  Half: maxHealth
  byte: lockBack
  byte: lockFront 
}

maxHealth - Max health of the door
lockBack - Byte representation of the enum:
```
enum LockType {
  None
  Melee
  Hack
}
```
Represents the type of lock on the back of the door (-z direction)
lockFront - Byte representation of the enum:
```
enum LockType {
  None
  Melee
  Hack
}
```
Represents the type of lock on the front of the door (+z direction)

Update

Vanilla.Map.WeakDoor {
  byte: health
  byte: lockBack
  byte: lockFront 
}

health - Current health of the door as a percentage. To get the health as a percentage, divide this value by 255
lockBack - Byte representation of the enum:
```
enum LockType {
  None
  Melee
  Hack
}
```
Represents the type of lock on the back of the door (-z direction)
lockFront - Byte representation of the enum:
```
enum LockType {
  None
  Melee
  Hack
}
```
Represents the type of lock on the front of the door (+z direction)

The health of the door is a host only feature - when as client the door health is always read as 0.

Despawn

Vanilla.Map.WeakDoor {
}

No additional data, the weak door instance is simply despawned

Vanilla.Map.Generators.State (0.0.1)

The id of the dynamic will match the id of the generator in Vanilla.Map.Generators. Only active generators will have this dynamic instance, if a generator does not have this instance then the generator does not accept a cell in-game (un-interactive generator).

Spawn

Vanilla.Map.Generators.State {
  bool: powered
}

powered - Whether the generator is powered (True) or not (False)

Update
Exact same format as Spawn

Depawn

Vanilla.Map.Generators.State {
}

No additional data, the generator is simply despawned

Vanilla.Map.Items (0.0.1)

Spawn

Vanilla.Map.Items {
  byte: dimension
  Vector3: position
  HalfQuaternion: rotation
  bool: onGround
  bool: linkedToMachine
  byte: playerSlot
  byte: serialNumber
  : item
}

dimension - Initial dimension the item spawned in
position - Initial position of the item
rotation - Initial rotation of the item
onGround - Whether the item is on the ground (True) or not such as when in a generator or held by a player (False)
linkedToMachine - Whether the item is inside a machine such as a generator (True) or not (False)
playerSlot - The slot index of the player holding the item. If no player is holding the item, this value reads 255
serialNumber - The terminal id of the item, used in game to ping the item on terminals.
item - The item type of the item

Update

Vanilla.Map.Items{
  byte: dimension
  Vector3: position
  HalfQuaternion: rotation
  bool: onGround
  bool: linkedToMachine
  byte: playerSlot
  byte: serialNumber
}

dimension - Initial dimension the item spawned in
position - Initial position of the item
rotation - Initial rotation of the item
onGround - Whether the item is on the ground (True) or not such as when in a generator or held by a player (False)
linkedToMachine - Whether the item is inside a machine such as a generator (True) or not (False)
playerSlot - The slot index of the player holding the item. If no player is holding the item, this value reads 255
serialNumber - The terminal id of the item, used in game to ping the item on terminals.

No absolute property is used for delta changes as items generally teleport from one far location to another so there's no point using a delta.

Despawn
Vanilla.Map.Items {
}

No additional data, the item is simply despawned

Vanilla.Map.ResourceContainers.State (0.0.1)

Spawn

Vanilla.Map.ResourceContainers.State {
  bool: closed
  byte: lock
}

closed - Whether the locker is closed (True) or not (False)
lock - Byte representation of the enum:
```
enum LockType {
  None
  Melee
  Hack
}
```
Represents if the locker has a lock on it or not

Update

Vanilla.Map.ResourceContainers.State {
  bool: closed
}

closed - Whether the locker is closed (True) or not (False)

Despawn

Vanilla.Map.ResourceContainers.State {
}

No additional data, the resource container state instance is simply despawned

Vanilla.Enemy (0.0.1)

Spawn

Vanilla.Enemy {
  byte: dimension
  Vector3: position
  HalfQuaternion: rotation
  ushort: animHandle
  Half: scale
  : type
}

dimension - Initial dimension the enemy spawned in
position - Initial position of the enemy
rotation - Initial rotation of the enemy

animHandle - Bit Flag for the animation set the enemy uses:

[Flags]
enum AnimHandle {
  unspecified = 1
  cripple = 2
  runner = 4
  fiddler = 8
  low = 0x10
  crawlFlip = 0x20
  crawl = 0x40
  giant = 0x80
  big = 0x100
  exploder = 0x200
  birtherCrawlFlip = 0x400
  pouncer = 0x800
}

What animations these handles link to can be found here.

scale - The size scale assigned to the enemy by the game
type - The enemy type

Update

Vanilla.Enemy {
  byte: dimension
  bool: absolute
  (Vector3 | HalfVector3): position
  HalfQuaternion: rotation 
  bool: tagged
  byte: consumedPlayerSlotIndex
}

dimension - Current dimension the enemy is in
absolute - Whether the position is the current position of the enemy (True) or is the change in position that occurred since last update (False)
position - If absolute is True, it is a Vector3 that represents the current position of the enemy. Otherwise, it is a HalfVector3 that represents the change in position that occurred since last update. For example, if absolute is False and the location last update was (0, 10, 0). If the read HalfVector3 is (0, 0, 1), then the current position of the enemy is (0, 10, 1). If absolute was True and the read Vector3 was (0, 10, 1), then the current position of the enemy is (0, 10, 1).
rotation - The current rotation of the enemy, unaffected by absolute
tagged - Whether the enemy is bio tracked (True) or not (False)
consumedPlayerSlotIndex - The slot index of the player consumed by this enemy. Reads 255 if no player is consumed. This is in the context of being snatched by a pouncer.

Despawn
Vanilla.Enemy {
}

No additional data, the enemy is simply despawned

Vanilla.Enemy (0.0.2)

Spawn

Vanilla.Enemy {
  byte: dimension
  Vector3: position
  HalfQuaternion: rotation
  ushort: animHandle
  Half: scale
  : type
  Half: maxHealth
}

dimension - Initial dimension the enemy spawned in
position - Initial position of the enemy
rotation - Initial rotation of the enemy

animHandle - Bit Flag for the animation set the enemy uses:

[Flags]
enum AnimHandle {
  unspecified = 1
  cripple = 2
  runner = 4
  fiddler = 8
  low = 0x10
  crawlFlip = 0x20
  crawl = 0x40
  giant = 0x80
  big = 0x100
  exploder = 0x200
  birtherCrawlFlip = 0x400
  pouncer = 0x800
}

What animations these handles link to can be found here.

scale - The size scale assigned to the enemy by the game
type - The enemy type
maxHealth - The max health of the enemy

Previously the max health of an enemy was determined on the parser side by the enemy type, but this made it annoying to handle modded enemies, thus the max health was moved to be handled automatically. This was adopted fairly early on, so feel free to not fully support versions prior which had previously not provided the max health. How you decided to do this is implementation defined.

Update

Vanilla.Enemy {
  byte: dimension
  bool: absolute
  (Vector3 | HalfVector3): position
  HalfQuaternion: rotation 
  bool: tagged
  byte: consumedPlayerSlotIndex
}

dimension - Current dimension the enemy is in
absolute - Whether the position is the current position of the enemy (True) or is the change in position that occurred since last update (False)
position - If absolute is True, it is a Vector3 that represents the current position of the enemy. Otherwise, it is a HalfVector3 that represents the change in position that occurred since last update. For example, if absolute is False and the location last update was (0, 10, 0). If the read HalfVector3 is (0, 0, 1), then the current position of the enemy is (0, 10, 1). If absolute was True and the read Vector3 was (0, 10, 1), then the current position of the enemy is (0, 10, 1).
rotation - The current rotation of the enemy, unaffected by absolute
tagged - Whether the enemy is bio tracked (True) or not (False)
consumedPlayerSlotIndex - The slot index of the player consumed by this enemy. Reads 255 if no player is consumed. This is in the context of being snatched by a pouncer.

Despawn
Vanilla.Enemy {
}

No additional data, the enemy is simply despawned

Vanilla.Enemy (0.0.3)

Spawn

Vanilla.Enemy {
  byte: dimension
  Vector3: position
  HalfQuaternion: rotation
  ushort: animHandle
  Half: scale
  : type
  Half: maxHealth
}

dimension - Initial dimension the enemy spawned in
position - Initial position of the enemy
rotation - Initial rotation of the enemy

animHandle - Bit Flag for the animation set the enemy uses:

[Flags]
enum AnimHandle {
  unspecified = 1
  cripple = 2
  runner = 4
  fiddler = 8
  low = 0x10
  crawlFlip = 0x20
  crawl = 0x40
  giant = 0x80
  big = 0x100
  exploder = 0x200
  birtherCrawlFlip = 0x400
  pouncer = 0x800
}

What animations these handles link to can be found here.

scale - The size scale assigned to the enemy by the game
type - The enemy type
maxHealth - The max health of the enemy

Refer to the footnotes in Vanilla.Enemy (0.0.2)

Update

Vanilla.Enemy {
  byte: dimension
  bool: absolute
  (Vector3 | HalfVector3): position
  HalfQuaternion: rotation 
  bool: tagged
  byte: consumedPlayerSlotIndex
  byte: targetPlayerSlotIndex
}

dimension - Current dimension the enemy is in
absolute - Whether the position is the current position of the enemy (True) or is the change in position that occurred since last update (False)
position - If absolute is True, it is a Vector3 that represents the current position of the enemy. Otherwise, it is a HalfVector3 that represents the change in position that occurred since last update. For example, if absolute is False and the location last update was (0, 10, 0). If the read HalfVector3 is (0, 0, 1), then the current position of the enemy is (0, 10, 1). If absolute was True and the read Vector3 was (0, 10, 1), then the current position of the enemy is (0, 10, 1).
rotation - The current rotation of the enemy, unaffected by absolute
tagged - Whether the enemy is bio tracked (True) or not (False)
consumedPlayerSlotIndex - The slot index of the player consumed by this enemy. Reads 255 if no player is consumed. This is in the context of being snatched by a pouncer.
targetPlayerSlotIndex - The slot index of the player the enemy is currently targetting. Reads 255 if no player is being targetted.

Despawn
Vanilla.Enemy {
}

No additional data, the enemy is simply despawned

Vanilla.Enemy (0.0.4)

Spawn

Vanilla.Enemy {
  byte: dimension
  Vector3: position
  HalfQuaternion: rotation
  ushort: animHandle
  Half: scale
  : type
  Half: maxHealth
}

dimension - Initial dimension the enemy spawned in
position - Initial position of the enemy
rotation - Initial rotation of the enemy

animHandle - Bit Flag for the animation set the enemy uses:

[Flags]
enum AnimHandle {
  unspecified = 1
  cripple = 2
  runner = 4
  fiddler = 8
  low = 0x10
  crawlFlip = 0x20
  crawl = 0x40
  giant = 0x80
  big = 0x100
  exploder = 0x200
  birtherCrawlFlip = 0x400
  pouncer = 0x800
}

What animations these handles link to can be found here.

scale - The size scale assigned to the enemy by the game
type - The enemy type
maxHealth - The max health of the enemy

Refer to the footnotes in Vanilla.Enemy (0.0.2)

Update

Vanilla.Enemy {
  byte: dimension
  bool: absolute
  (Vector3 | HalfVector3): position
  HalfQuaternion: rotation 
  bool: tagged
  byte: consumedPlayerSlotIndex
  byte: targetPlayerSlotIndex
  byte: staggerProgress
  bool: canStagger
}

dimension - Current dimension the enemy is in
absolute - Whether the position is the current position of the enemy (True) or is the change in position that occurred since last update (False)
position - If absolute is True, it is a Vector3 that represents the current position of the enemy. Otherwise, it is a HalfVector3 that represents the change in position that occurred since last update. For example, if absolute is False and the location last update was (0, 10, 0). If the read HalfVector3 is (0, 0, 1), then the current position of the enemy is (0, 10, 1). If absolute was True and the read Vector3 was (0, 10, 1), then the current position of the enemy is (0, 10, 1).
rotation - The current rotation of the enemy, unaffected by absolute
tagged - Whether the enemy is bio tracked (True) or not (False)
consumedPlayerSlotIndex - The slot index of the player consumed by this enemy. Reads 255 if no player is consumed. This is in the context of being snatched by a pouncer.
targetPlayerSlotIndex - The slot index of the player the enemy is currently targetting. Reads 255 if no player is being targetted.
staggerProgress - Current progress towards staggering the enemy as a percentage. To get the progress percentage, divide this value by 255. Only representative of staggers caused through damage alone as limb breaks always trigger a stagger.
canStagger - Whether the enemy can be staggered. Unused by all enemies except the pouncer which can only be staggered while running to snatch someone or while in the middle of snatching someone.

Despawn
Vanilla.Enemy {
}

No additional data, the enemy is simply despawned

Vanilla.Enemy.Animation (0.0.1)

Spawn

Vanilla.Enemy.Animation {
  byte: velRight
  byte: velUp
  byte: velFwd
  byte: state
  bool: upLadder
  byte: detect
}

velRight - Current (-)left/(+)right animation velocity of the player as a value between -10 and 10. To obtain this value apply the following equation: $(\frac{\text{velRight}}{255}\cdot2-1)\cdot10$
velUp - Current (-)down/(+)up animation velocity of the enemy as a value between -10 and 10. To obtain this value apply the following equation: $(\frac{\text{velUp}}{255}\cdot2-1)\cdot10$
velFwd - Current (-)backward/(+)foward animation velocity of the player as a value between -10 and 10. To obtain this value apply the following equation: $(\frac{\text{velFwd}}{255}\cdot2-1)\cdot10$

state - The byte representation of the following enum for current animation states:

enum AnimState {
  None = 0
  StandStill = 1
  PathMove = 3
  Knockdown = 4
  JumpDissolve = 5
  LiquidSnake = 6
  KnockdownRecover = 7
  Hitreact = 8
  ShortcutJump = 9
  FloaterFly = 10
  FloaterHitReact = 11
  Dead = 12
  ScoutDetection = 13
  ScoutScream = 14
  Hibernate = 15
  HibernateWakeUp = 16
  Scream = 17
  StuckInGlue = 18
  ShooterAttack = 19
  StrikerAttack = 20
  TankAttack = 21
  TankMultiTargetAttack = 22
  TentacleDragMove = 23
  StrikerMelee = 24
  ClimbLadder = 25
  Jump = 26
  BirtherGiveBirth = 27
  TriggerFogSphere = 28
  PathMoveFlyer = 29
  HitReactFlyer = 30
  ShooterAttackFlyer = 31
  DeadFlyer = 32
  DeadSquidBoss = 33
}

upLadder - True if the enemy is traversing up the ladder and False if it is traversing down. Only applies when the current animation state is ClimbLadder
detect - The current detection animation lerp value as a percentage. To get the percentage, divide the parsed value by 255.

Update
Exact same format as Spawn

Despawn

Vanilla.Enemy.Animation {
}

No additional data, the enemy animation instance is simply despawned

Vanilla.Enemy.LimbCustom (0.0.1)

Represents boss tumours such as those on Tank, Mom and Kraken enemies.

Spawn

Vanilla.Enemy.LimbCustom {
  ushort: owner
  byte: bone
  HalfVector3: offset
  Half: scale
}

owner - id for the enemy that owns this tumour

bone - Byte representation for the enum:

enum Bone {  
  hip = 0
  leftUpperLeg = 1
  leftLowerLeg = 2
  leftFoot = 3
  rightUpperLeg = 4
  rightLowerLeg = 5
  rightFoot = 6
  spine0 = 7
  spine1 = 8
  spine2 = 9
  leftShoulder = 10
  leftUpperArm = 11
  leftLowerArm = 12
  leftHand = 13
  rightShoulder = 14
  rightUpperArm = 15
  rightLowerArm = 16
  rightHand = 17
  neck = 18
  head = 19
}

Note that if your model has only a spine and chest bone then chest is mapped to spine2 whilst spine is mapped to spine0.

offset - The position of the tumour relative to the enemy root position (position given from Vanilla.Enemy) when the enemy is in its initialisation pose (Defined as the pose the model has in its Unity Prefab - this can be obtained via an asset ripper). Luckily the starting pose for all models that have tumours is a typical A-Pose. Since no tumours are placed on limbs, its safe to use a regular T-Pose instead.
scale - The size of the tumour

To attach the tumour to a given enemy model, have the model in its initialisation pose (Defined as the pose the model has in its Unity Prefab - this can be obtained via an asset ripper) and position the tumour such that its located at the enemy root position (position given from Vanilla.Enemy) with the offset applied. Then attach it to the correct bone maintaining world position.

To avoid placing the model in its initial pose every time a tumour is spawned, you may store the inverse of each bones world transform matrix when it is posed correctly and apply that to get the local position for attaching the tumour.

Update

Vanilla.Enemy.LimbCustom {
  bool: visible
}

active - Whether the tumour is visible (True) or not (False). Only really applies to Kraken enemy where tumours appear at set points in time.

Despawn

Vanilla.Enemy.LimbCustom {
}

No additional data, the custom limb is simply despawned

Vanilla.Enemy.Projectile (0.0.1)

Spawn

Vanilla.Enemy.Projectile {
  byte: dimension
  Vector3: position
  HalfQuaternion: rotation
}

dimension - Initial dimension the projectile spawned in
position - Initial position of the projectile
rotation - Initial rotation of the projectile

Update

Vanilla.Enemy.Projectile {
  byte: dimension
  bool: absolute
  (Vector3 | HalfVector3): position
  HalfQuaternion: rotation
}

dimension - Current dimension the projectile is in
absolute - Whether the position is the current position of the projectile (True) or is the change in position that occurred since last update (False)
position - If absolute is True, it is a Vector3 that represents the current position of the projectile. Otherwise, it is a HalfVector3 that represents the change in position that occurred since last update. For example, if absolute is False and the location last update was (0, 10, 0). If the read HalfVector3 is (0, 0, 1), then the current position of the projectile is (0, 10, 1). If absolute was True and the read Vector3 was (0, 10, 1), then the current position of the projectile is (0, 10, 1).
rotation - The current rotation of the projectile, unaffected by absolute

Despawn

Vanilla.Enemy.Projectile {
}

No additional data, the projectile is simply despawned

Vanilla.Enemy.Spitters.State (0.0.1)

Spawn

Vanilla.Enemy.Spitter.State {
  byte: state
}

state - Byte representation of the enum:

enum AnimState {  
  Frozen = 0
  Woke = 1
  Retracted = 2
}

Update
Exact same format as Spawn

Despawn

Vanilla.Enemy.Spitter.State {
}

No additional data, the spitter is simply despawned

Vanilla.Enemy.Tendril (0.0.1)

Spawn

Vanilla.Enemy.Tendril {
  HalfVector3: startPos
  HalfVector3: endPos
  bool: detect
  ushort: owner
}

startPos - Start position of tendril relative to enemy root position (The position given by Vanilla.Enemy)
endPos - End position of tendril relative to enemy root position (The position given by Vanilla.Enemy)
detect - Whether the tendril has touched a player (True) or not (False)
owner - The id of the enemy this tendril belongs to

Update

Vanilla.Enemy.Tendril {
  HalfVector3: startPos
  HalfVector3: endPos
  bool: detect
}

startPos - Start position of tendril relative to enemy root position (The position given by Vanilla.Enemy)
endPos - End position of tendril relative to enemy root position (The position given by Vanilla.Enemy)
detect - Whether the tendril has touched a player (True) or not (False)

Despawn

Vanilla.Enemy.Tendril {
}

No additional data, the tendril is simply despawned

Vanilla.Enemy.Tongue (0.0.1)

Spawn

Vanilla.Enemy.Tongue {
  ushort: enemy
  byte: dimension
  byte: progress
  byte: numPoints
  Vector3: start
  {
    HalfVector3: delta
  }[numPoints - 1]
}

enemy - The id of the enemy owning the tongue
dimension - The initial dimension the tongue is in
progress - Current progress of the tongue as a percentage. To get the tongue percentage, divide this value by 255
numPoints - The number of spline points that make up the tongue, including the start point
start - The starting point of the spline
delta - The difference between the current spline point and the last. For example if the last spline was located at (0, 0, 1) and the read delta was (0, 1, 0), then the current spline point is located at (0, 1, 1).

Progress of the tongue determines how much of the tongue to show. 0 means that none should be shown, whilst 1 means that the entire tongue is visible.

Update

Vanilla.Enemy.Tongue {
  byte: dimension
  byte: progress
  byte: numPoints
  Vector3: start
  {
    HalfVector3: delta
  }[numPoints - 1]
}

dimension - The initial dimension the tongue is in
progress - Current progress of the tongue as a percentage. To get the tongue percentage, divide this value by 255
numPoints - The number of spline points that make up the tongue, including the start point
start - The starting point of the spline
delta - The difference between the current spline point and the last. For example if the last spline was located at (0, 0, 1) and the read delta was (0, 1, 0), then the current spline point is located at (0, 1, 1).

Progress of the tongue determines how much of the tongue to show. 0 means that none should be shown, whilst 1 means that the entire tongue is visible.

Despawn

Vanilla.Enemy.Tongue {
}

No additional data, the tongue is simply despawned

Vanilla.Objectives.Reactor (0.0.1)

Spawn

Vanilla.Objectives.Reactor {
  ushort: serialNumber
  byte: layer
  int: masterTerminal
  byte: numWaves
  {
    ushort: codeTerminalSerialNumber
    string: code
  }[numWaves]
}

serialNumber - The serial number of the reactor objective, in game is denoted as REACTOR_XXX

layer - Byte representation of the enum:

enum ObjectiveLayer {
  Main = 0
  Secondary = 1
  Overload = 2
}

masterTerminal - The id of the terminal that the reactor is linked to
numWaves - The total number of waves the reactor requires

For each wave entry:

codeTerminalSerialNumber - The serial number of the terminal containing the reactor log for the code. If no terminal log is required, this value is ushort.MaxValue = 65535
code - The reactor wave verification code

Update

Vanilla.Objectives.Reactor {
  byte: status
  byte: wave
  Half: waveDuration
  byte: waveProgress
}

status - Byte representation of the enum:

enum ReactorStatus {
  InactiveIdle = 0
  ActiveIdle = 1
  StartupIntro = 2
  StartupIntense = 3
  StartupWaitForVerify = 4
  StartupComplete = 5
  ShutdownIntro = 6
  ShutdownWaitForVerify = 7
  ShutdownPuzzleChaos = 8
  ShutdownComplete = 9
}

wave - The current wave the reactor is on (starting at index 0)
waveDuration - How long the wave is in seconds
waveProgress - Current progress of the wave as a percentage. To get the percentage, divide this value by 255

ReactorStatus enum describes the reactor states:

InactiveIdle / ActiveIdle - The objective is not active

StartupIntro - Reactor warmup sequence

StartupIntense - Reactor wave fight (spawns enemies)

StartupWaitForVerify - Waiting for verification code

StartupComplete - Show objective completed message

ShutdownIntro - Reactor shutdown start sequence (waveDuration and waveProgress don't do anything)

ShutdownWaitForVerify - Reactor shutdown wait for code to start (waveDuration and waveProgress don't do anything)

ShutdownPuzzleChaos - Trigger bio scan chained puzzle (Shutdown objectives involve doing a chained puzzle instead of reactor waves, hence waveDuration and waveProgress not doing anything)

ShutdownComplete - Show objective completed message

Despawn

Vanilla.Objectives.Reactor {
}

No additional data, the reactor objective is simply despawned

PreviousReplay Format NextEnemy Animations

Last updated 9 months ago