@quake2ts/shared 0.0.1

package/src/protocol/entity.ts

@@ -0,0 +1,304 @@
+import { BinaryWriter } from '../io/index.js';
+import { EntityState } from './entityState.js';
+
+// Constants matching packages/engine/src/demo/parser.ts
+export const U_ORIGIN1   = (1 << 0);
+export const U_ORIGIN2   = (1 << 1);
+export const U_ANGLE2    = (1 << 2);
+export const U_ANGLE3    = (1 << 3);
+export const U_FRAME8    = (1 << 4);
+export const U_EVENT     = (1 << 5);
+export const U_REMOVE    = (1 << 6);
+export const U_MOREBITS1 = (1 << 7);
+
+export const U_NUMBER16  = (1 << 8);
+export const U_ORIGIN3   = (1 << 9);
+export const U_ANGLE1    = (1 << 10);
+export const U_MODEL     = (1 << 11);
+export const U_RENDERFX8 = (1 << 12);
+export const U_ALPHA     = (1 << 13); // Rerelease: Alpha
+export const U_EFFECTS8  = (1 << 14);
+export const U_MOREBITS2 = (1 << 15);
+
+export const U_SKIN8     = (1 << 16);
+export const U_FRAME16   = (1 << 17);
+export const U_RENDERFX16 = (1 << 18);
+export const U_EFFECTS16 = (1 << 19);
+export const U_MODEL2    = (1 << 20); // Rerelease
+export const U_MODEL3    = (1 << 21); // Rerelease
+export const U_MODEL4    = (1 << 22); // Rerelease
+export const U_MOREBITS3 = (1 << 23);
+
+export const U_OLDORIGIN = (1 << 24);
+export const U_SKIN16    = (1 << 25);
+export const U_SOUND     = (1 << 26);
+export const U_SOLID     = (1 << 27);
+export const U_SCALE     = (1 << 28); // Rerelease
+export const U_INSTANCE_BITS = (1 << 29); // Rerelease
+export const U_LOOP_VOLUME   = (1 << 30); // Rerelease
+export const U_MOREBITS4     = 0x80000000 | 0; // Bit 31 (sign bit)
+
+// Rerelease Extension Bits (Byte 5 - High Bits)
+export const U_LOOP_ATTENUATION_HIGH = (1 << 0);
+export const U_OWNER_HIGH            = (1 << 1);
+export const U_OLD_FRAME_HIGH        = (1 << 2);
+
+
+// A null state for new entities, used as a baseline for comparison.
+const NULL_STATE: EntityState = {
+  number: 0,
+  origin: { x: 0, y: 0, z: 0 },
+  angles: { x: 0, y: 0, z: 0 },
+  modelIndex: 0,
+  frame: 0,
+  skinNum: 0,
+  effects: 0,
+  renderfx: 0,
+  solid: 0,
+  sound: 0,
+  event: 0,
+  alpha: 0,
+  scale: 0,
+  instanceBits: 0,
+  loopVolume: 0,
+  loopAttenuation: 0,
+  owner: 0,
+  oldFrame: 0,
+  modelIndex2: 0,
+  modelIndex3: 0,
+  modelIndex4: 0
+};
+
+/**
+ * Writes the remove bit for an entity.
+ */
+export function writeRemoveEntity(
+    number: number,
+    writer: BinaryWriter
+): void {
+    let bits = U_REMOVE;
+
+    if (number >= 256) {
+        bits |= U_NUMBER16;
+    }
+
+    // Determine needed bytes for header (U_NUMBER16 is in bits 8-15)
+    if (bits & 0xFF00) {
+        bits |= U_MOREBITS1;
+    }
+
+    // Write Header
+    writer.writeByte(bits & 0xFF);
+    if (bits & U_MOREBITS1) {
+        writer.writeByte((bits >> 8) & 0xFF);
+    }
+
+    // Write Number
+    if (bits & U_NUMBER16) {
+        writer.writeShort(number);
+    } else {
+        writer.writeByte(number);
+    }
+}
+
+/**
+ * Writes the delta between two entity states to a binary writer.
+ */
+export function writeDeltaEntity(
+  from: EntityState,
+  to: EntityState,
+  writer: BinaryWriter,
+  force: boolean,
+  newEntity: boolean
+): void {
+  let bits = 0;
+  let bitsHigh = 0;
+
+  // If this is a new entity, use a null baseline
+  if (newEntity) {
+    from = NULL_STATE;
+  }
+
+  // --- Compare fields and build the bitmask ---
+  if (to.modelIndex !== from.modelIndex || force) {
+    bits |= U_MODEL;
+  }
+  if (to.modelIndex2 !== from.modelIndex2 || force) {
+      bits |= U_MODEL2;
+  }
+  if (to.modelIndex3 !== from.modelIndex3 || force) {
+      bits |= U_MODEL3;
+  }
+  if (to.modelIndex4 !== from.modelIndex4 || force) {
+      bits |= U_MODEL4;
+  }
+
+  if (to.origin.x !== from.origin.x || force) {
+    bits |= U_ORIGIN1;
+  }
+  if (to.origin.y !== from.origin.y || force) {
+    bits |= U_ORIGIN2;
+  }
+  if (to.origin.z !== from.origin.z || force) {
+    bits |= U_ORIGIN3;
+  }
+  if (to.angles.x !== from.angles.x || force) {
+    bits |= U_ANGLE1;
+  }
+  if (to.angles.y !== from.angles.y || force) {
+    bits |= U_ANGLE2;
+  }
+  if (to.angles.z !== from.angles.z || force) {
+    bits |= U_ANGLE3;
+  }
+
+  if (to.frame !== from.frame || force) {
+      if (to.frame >= 256) bits |= U_FRAME16;
+      else bits |= U_FRAME8;
+  }
+
+  if (to.skinNum !== from.skinNum || force) {
+      if (to.skinNum >= 256) bits |= U_SKIN16;
+      else bits |= U_SKIN8;
+  }
+
+  if (to.effects !== from.effects || force) {
+      if (to.effects >= 256) bits |= U_EFFECTS16;
+      else bits |= U_EFFECTS8;
+  }
+
+  if (to.renderfx !== from.renderfx || force) {
+      if (to.renderfx >= 256) bits |= U_RENDERFX16;
+      else bits |= U_RENDERFX8;
+  }
+
+  if (to.solid !== from.solid || force) {
+    bits |= U_SOLID;
+  }
+  if (to.sound !== from.sound || force) {
+    bits |= U_SOUND;
+  }
+  if (to.event !== from.event || force) {
+    bits |= U_EVENT;
+  }
+
+  // Rerelease Fields
+  if ((to.alpha !== from.alpha || force) && to.alpha !== undefined) {
+      bits |= U_ALPHA;
+  }
+  if ((to.scale !== from.scale || force) && to.scale !== undefined) {
+      bits |= U_SCALE;
+  }
+  if ((to.instanceBits !== from.instanceBits || force) && to.instanceBits !== undefined) {
+      bits |= U_INSTANCE_BITS;
+  }
+  if ((to.loopVolume !== from.loopVolume || force) && to.loopVolume !== undefined) {
+      bits |= U_LOOP_VOLUME;
+  }
+
+  // High Bits Fields
+  if ((to.loopAttenuation !== from.loopAttenuation || force) && to.loopAttenuation !== undefined) {
+      bitsHigh |= U_LOOP_ATTENUATION_HIGH;
+  }
+  if ((to.owner !== from.owner || force) && to.owner !== undefined) {
+      bitsHigh |= U_OWNER_HIGH;
+  }
+  if ((to.oldFrame !== from.oldFrame || force) && to.oldFrame !== undefined) {
+      bitsHigh |= U_OLD_FRAME_HIGH;
+  }
+
+
+  // Handle entity number
+  if (to.number >= 256) {
+      bits |= U_NUMBER16;
+  }
+
+  // Determine needed bytes for header
+
+  // If we have high bits, we set U_MOREBITS4 on the 4th byte
+  if (bitsHigh > 0) {
+      bits |= U_MOREBITS4;
+  }
+
+  // Now calculate cascading flags
+  if (bits & 0xFF000000) { // e.g. U_MOREBITS4 (bit 31) is here
+      bits |= U_MOREBITS3;
+  }
+  if (bits & 0xFFFF0000) { // e.g. U_MOREBITS3 (bit 23) is here
+      bits |= U_MOREBITS2;
+  }
+  if (bits & 0xFFFFFF00) { // e.g. U_MOREBITS2 (bit 15) is here
+      bits |= U_MOREBITS1;
+  }
+
+  // Write Header
+  writer.writeByte(bits & 0xFF);
+
+  if (bits & U_MOREBITS1) {
+      writer.writeByte((bits >> 8) & 0xFF);
+  }
+  if (bits & U_MOREBITS2) {
+      writer.writeByte((bits >> 16) & 0xFF);
+  }
+  if (bits & U_MOREBITS3) {
+      writer.writeByte((bits >> 24) & 0xFF);
+  }
+  if (bits & U_MOREBITS4) {
+      writer.writeByte(bitsHigh & 0xFF);
+  }
+
+  // Write Number
+  if (bits & U_NUMBER16) {
+      writer.writeShort(to.number);
+  } else {
+      writer.writeByte(to.number);
+  }
+
+  // Write Fields in Order (matching NetworkMessageParser.parseDelta)
+  if (bits & U_MODEL) writer.writeByte(to.modelIndex);
+  if (bits & U_MODEL2) writer.writeByte(to.modelIndex2 ?? 0);
+  if (bits & U_MODEL3) writer.writeByte(to.modelIndex3 ?? 0);
+  if (bits & U_MODEL4) writer.writeByte(to.modelIndex4 ?? 0);
+
+  if (bits & U_FRAME8) writer.writeByte(to.frame);
+  if (bits & U_FRAME16) writer.writeShort(to.frame);
+
+  if (bits & U_SKIN8) writer.writeByte(to.skinNum);
+  if (bits & U_SKIN16) writer.writeShort(to.skinNum);
+
+  if (bits & U_EFFECTS8) writer.writeByte(to.effects);
+  if (bits & U_EFFECTS16) writer.writeShort(to.effects);
+
+  if (bits & U_RENDERFX8) writer.writeByte(to.renderfx);
+  if (bits & U_RENDERFX16) writer.writeShort(to.renderfx);
+
+  if (bits & U_ORIGIN1) writer.writeCoord(to.origin.x);
+  if (bits & U_ORIGIN2) writer.writeCoord(to.origin.y);
+  if (bits & U_ORIGIN3) writer.writeCoord(to.origin.z);
+
+  if (bits & U_ANGLE1) writer.writeAngle(to.angles.x);
+  if (bits & U_ANGLE2) writer.writeAngle(to.angles.y);
+  if (bits & U_ANGLE3) writer.writeAngle(to.angles.z);
+
+  if (bits & U_OLDORIGIN) {
+      // Not implemented in EntityState usually, skip or zero
+      // writer.writePos(to.old_origin);
+  }
+
+  if (bits & U_SOUND) writer.writeByte(to.sound ?? 0);
+
+  if (bits & U_EVENT) writer.writeByte(to.event ?? 0);
+
+  if (bits & U_SOLID) writer.writeShort(to.solid);
+
+  // Rerelease Fields Writing
+  if (bits & U_ALPHA) writer.writeByte(Math.floor((to.alpha ?? 0) * 255));
+  if (bits & U_SCALE) writer.writeFloat(to.scale ?? 0);
+  if (bits & U_INSTANCE_BITS) writer.writeLong(to.instanceBits ?? 0);
+  if (bits & U_LOOP_VOLUME) writer.writeByte(Math.floor((to.loopVolume ?? 0) * 255));
+
+  // High bits fields
+  if (bitsHigh & U_LOOP_ATTENUATION_HIGH) writer.writeByte(Math.floor((to.loopAttenuation ?? 0) * 255));
+  if (bitsHigh & U_OWNER_HIGH) writer.writeShort(to.owner ?? 0);
+  if (bitsHigh & U_OLD_FRAME_HIGH) writer.writeShort(to.oldFrame ?? 0);
+}

package/src/protocol/entityEvent.ts

@@ -0,0 +1,14 @@
+export enum EntityEvent {
+  None = 0,
+  ItemRespawn = 1,
+  Footstep = 2,
+  FallShort = 3,
+  Fall = 4,
+  FallFar = 5,
+  PlayerTeleport = 6,
+  OtherTeleport = 7,
+
+  // [Paril-KEX]
+  OtherFootstep = 8,
+  LadderStep = 9,
+}

package/src/protocol/entityState.ts

@@ -0,0 +1,28 @@
+import { Vec3 } from '../math/vec3.js';
+
+export interface EntityState {
+  readonly number: number;
+  readonly origin: Vec3;
+  readonly angles: Vec3;
+  readonly oldOrigin?: Vec3; // [Paril-KEX] for lerping
+  readonly modelIndex: number;
+  readonly modelIndex2?: number; // [Paril-KEX]
+  readonly modelIndex3?: number; // [Paril-KEX]
+  readonly modelIndex4?: number; // [Paril-KEX]
+  readonly frame: number;
+  readonly skinNum: number;
+  readonly effects: number;
+  readonly renderfx: number;
+  readonly solid: number;
+  readonly sound?: number;
+  readonly event?: number;
+
+  // Rerelease fields
+  readonly alpha?: number;
+  readonly scale?: number;
+  readonly instanceBits?: number;
+  readonly loopVolume?: number;
+  readonly loopAttenuation?: number;
+  readonly owner?: number;
+  readonly oldFrame?: number;
+}

package/src/protocol/index.ts

@@ -0,0 +1,19 @@
+
+export * from './configstrings.js';
+export * from './contracts.js';
+export * from './cvar.js';
+export * from './usercmd.js';
+export * from './player-state.js';
+export * from './ops.js';
+export * from './tempEntity.js';
+export * from './constants.js';
+export * from './layout.js';
+export * from './stats.js';
+export * from './writeUserCmd.js';
+export * from './renderFx.js';
+export * from './crc.js';
+export * from './effects.js';
+export * from './entityEvent.js';
+export * from './entity.js';
+export * from './entityState.js';
+export * from './player.js';

package/src/protocol/layout.ts

@@ -0,0 +1,9 @@
+// Matching rerelease/game.h:1584-1593
+export enum LayoutFlags {
+    LAYOUTS_LAYOUT = 1,
+    LAYOUTS_INVENTORY = 2,
+    LAYOUTS_HIDE_HUD = 4,
+    LAYOUTS_INTERMISSION = 8,
+    LAYOUTS_HELP = 16,
+    LAYOUTS_HIDE_CROSSHAIR = 32
+}

package/src/protocol/ops.ts

@@ -0,0 +1,49 @@
+
+export enum ServerCommand {
+  bad = 0,
+
+  // these ops are known to the game dll
+  muzzleflash = 1,
+  muzzleflash2 = 2,
+  temp_entity = 3,
+  layout = 4,
+  inventory = 5,
+
+  // the rest are private to the client and server
+  nop = 6,
+  disconnect = 7,
+  reconnect = 8,
+  sound = 9,            // <see code>
+  print = 10,           // [byte] id [string] null terminated string
+  stufftext = 11,       // [string] stuffed into client's console buffer, should be \n terminated
+  serverdata = 12,      // [long] protocol ...
+  configstring = 13,    // [short] [string]
+  spawnbaseline = 14,
+  centerprint = 15,     // [string] to put in center of the screen
+  download = 16,        // [short] size [size bytes]
+  playerinfo = 17,      // variable
+  packetentities = 18,  // [...]
+  deltapacketentities = 19, // [...]
+  frame = 20,
+  splitclient = 21,
+  configblast = 22,
+  spawnbaselineblast = 23,
+  level_restart = 24,
+  damage = 25,
+  locprint = 26,
+  fog = 27,
+  waitingforplayers = 28,
+  bot_chat = 29,
+  poi = 30,
+  help_path = 31,
+  muzzleflash3 = 32,
+  achievement = 33
+}
+
+export enum ClientCommand {
+  bad = 0,
+  nop = 1,
+  move = 2,             // [[usercmd_t]
+  userinfo = 3,         // [[userinfo string]
+  stringcmd = 4         // [string] message
+}

package/src/protocol/player-state.ts

@@ -0,0 +1,51 @@
+
+import { Vec3 } from '../math/vec3.js';
+
+import { WaterLevel } from '../pmove/constants.js';
+
+export interface DamageIndicator {
+    direction: Vec3;
+    strength: number;
+}
+
+export interface PlayerState {
+  origin: Vec3;
+  velocity: Vec3;
+  viewAngles: Vec3;
+  onGround: boolean;
+  waterLevel: WaterLevel;
+  watertype: number; // Added for correct fluid effects
+  mins: Vec3;
+  maxs: Vec3;
+  damageAlpha: number;
+  damageIndicators: DamageIndicator[];
+  blend: [number, number, number, number]; // r, g, b, a
+  pickupIcon?: string; // Name of the icon to draw (e.g. 'w_railgun')
+  centerPrint?: string;
+  notify?: string;
+
+  // Stats array (STAT_HEALTH, STAT_AMMO, etc.)
+  stats: number[];
+
+  // View effects
+  kick_angles: Vec3;
+  kick_origin: Vec3;
+  gunoffset: Vec3;
+  gunangles: Vec3;
+  gunindex: number;
+
+  // New fields for Q2 network compatibility
+  pm_type: number;
+  pm_time: number;
+  pm_flags: number;
+  gun_frame: number;
+  rdflags: number;
+  fov: number;
+  renderfx: number;
+
+  // Rerelease fields
+  gunskin?: number;
+  gunrate?: number;
+  damage_blend?: [number, number, number, number];
+  team_id?: number;
+}

package/src/protocol/player.ts

@@ -0,0 +1,165 @@
+import { BinaryWriter, Vec3 } from '../index.js';
+
+export interface ProtocolPlayerState {
+  pm_type: number;
+  origin: Vec3;
+  velocity: Vec3;
+  pm_time: number;
+  pm_flags: number;
+  gravity: number;
+  delta_angles: Vec3;
+  viewoffset: Vec3;
+  viewangles: Vec3;
+  kick_angles: Vec3;
+  gun_index: number;
+  gun_frame: number;
+  gun_offset: Vec3;
+  gun_angles: Vec3;
+  blend: number[]; // [r,g,b,a]
+  fov: number;
+  rdflags: number;
+  stats: number[];
+  watertype: number;
+
+  // Optional / Extension fields if needed
+  gunskin?: number;
+  gunrate?: number;
+  damage_blend?: number[];
+  team_id?: number;
+}
+
+// Bitflags matching demo/parser.ts
+const PS_M_TYPE = (1 << 0);
+const PS_M_ORIGIN = (1 << 1);
+const PS_M_VELOCITY = (1 << 2);
+const PS_M_TIME = (1 << 3);
+const PS_M_FLAGS = (1 << 4);
+const PS_M_GRAVITY = (1 << 5);
+const PS_M_DELTA_ANGLES = (1 << 6);
+const PS_VIEWOFFSET = (1 << 7);
+const PS_VIEWANGLES = (1 << 8);
+const PS_KICKANGLES = (1 << 9);
+const PS_BLEND = (1 << 10);
+const PS_FOV = (1 << 11);
+const PS_WEAPONINDEX = (1 << 12);
+const PS_WEAPONFRAME = (1 << 13);
+const PS_RDFLAGS = (1 << 14);
+const PS_WATERTYPE = (1 << 15);
+
+export function writePlayerState(writer: BinaryWriter, ps: ProtocolPlayerState): void {
+  // Determine mask
+  let mask = 0;
+
+  if (ps.pm_type !== 0) mask |= PS_M_TYPE;
+  if (ps.origin.x !== 0 || ps.origin.y !== 0 || ps.origin.z !== 0) mask |= PS_M_ORIGIN;
+  if (ps.velocity.x !== 0 || ps.velocity.y !== 0 || ps.velocity.z !== 0) mask |= PS_M_VELOCITY;
+  if (ps.pm_time !== 0) mask |= PS_M_TIME;
+  if (ps.pm_flags !== 0) mask |= PS_M_FLAGS;
+  if (ps.gravity !== 0) mask |= PS_M_GRAVITY;
+  if (ps.delta_angles.x !== 0 || ps.delta_angles.y !== 0 || ps.delta_angles.z !== 0) mask |= PS_M_DELTA_ANGLES;
+  if (ps.viewoffset.x !== 0 || ps.viewoffset.y !== 0 || ps.viewoffset.z !== 0) mask |= PS_VIEWOFFSET;
+  if (ps.viewangles.x !== 0 || ps.viewangles.y !== 0 || ps.viewangles.z !== 0) mask |= PS_VIEWANGLES;
+  if (ps.kick_angles.x !== 0 || ps.kick_angles.y !== 0 || ps.kick_angles.z !== 0) mask |= PS_KICKANGLES;
+  if (ps.gun_index !== 0) mask |= PS_WEAPONINDEX;
+
+  // Weapon frame includes offset/angles
+  if (ps.gun_frame !== 0 ||
+      ps.gun_offset.x !== 0 || ps.gun_offset.y !== 0 || ps.gun_offset.z !== 0 ||
+      ps.gun_angles.x !== 0 || ps.gun_angles.y !== 0 || ps.gun_angles.z !== 0) {
+      mask |= PS_WEAPONFRAME;
+  }
+
+  if (ps.blend && (ps.blend[0] !== 0 || ps.blend[1] !== 0 || ps.blend[2] !== 0 || ps.blend[3] !== 0)) {
+      mask |= PS_BLEND;
+  }
+
+  if (ps.fov !== 0) mask |= PS_FOV;
+  if (ps.rdflags !== 0) mask |= PS_RDFLAGS;
+  if (ps.watertype !== 0) mask |= PS_WATERTYPE;
+
+  // Stats mask calculation
+  let statsMask = 0;
+  // Only support first 32 stats for now
+  for (let i = 0; i < 32; i++) {
+      if (ps.stats[i] && ps.stats[i] !== 0) {
+          statsMask |= (1 << i);
+      }
+  }
+
+  // Write header
+  writer.writeShort(mask);
+
+  // Write fields
+  if (mask & PS_M_TYPE) writer.writeByte(ps.pm_type);
+
+  if (mask & PS_M_ORIGIN) {
+      writer.writeShort(Math.round(ps.origin.x * 8));
+      writer.writeShort(Math.round(ps.origin.y * 8));
+      writer.writeShort(Math.round(ps.origin.z * 8));
+  }
+
+  if (mask & PS_M_VELOCITY) {
+      writer.writeShort(Math.round(ps.velocity.x * 8));
+      writer.writeShort(Math.round(ps.velocity.y * 8));
+      writer.writeShort(Math.round(ps.velocity.z * 8));
+  }
+
+  if (mask & PS_M_TIME) writer.writeByte(ps.pm_time);
+  if (mask & PS_M_FLAGS) writer.writeByte(ps.pm_flags);
+  if (mask & PS_M_GRAVITY) writer.writeShort(ps.gravity);
+
+  if (mask & PS_M_DELTA_ANGLES) {
+      writer.writeShort(Math.round(ps.delta_angles.x * (32768 / 180)));
+      writer.writeShort(Math.round(ps.delta_angles.y * (32768 / 180)));
+      writer.writeShort(Math.round(ps.delta_angles.z * (32768 / 180)));
+  }
+
+  if (mask & PS_VIEWOFFSET) {
+      writer.writeChar(Math.round(ps.viewoffset.x * 4));
+      writer.writeChar(Math.round(ps.viewoffset.y * 4));
+      writer.writeChar(Math.round(ps.viewoffset.z * 4));
+  }
+
+  if (mask & PS_VIEWANGLES) {
+      writer.writeAngle16(ps.viewangles.x);
+      writer.writeAngle16(ps.viewangles.y);
+      writer.writeAngle16(ps.viewangles.z);
+  }
+
+  if (mask & PS_KICKANGLES) {
+      writer.writeChar(Math.round(ps.kick_angles.x * 4));
+      writer.writeChar(Math.round(ps.kick_angles.y * 4));
+      writer.writeChar(Math.round(ps.kick_angles.z * 4));
+  }
+
+  if (mask & PS_WEAPONINDEX) writer.writeByte(ps.gun_index);
+
+  if (mask & PS_WEAPONFRAME) {
+      writer.writeByte(ps.gun_frame);
+      writer.writeChar(Math.round(ps.gun_offset.x * 4));
+      writer.writeChar(Math.round(ps.gun_offset.y * 4));
+      writer.writeChar(Math.round(ps.gun_offset.z * 4));
+      writer.writeChar(Math.round(ps.gun_angles.x * 4));
+      writer.writeChar(Math.round(ps.gun_angles.y * 4));
+      writer.writeChar(Math.round(ps.gun_angles.z * 4));
+  }
+
+  if (mask & PS_BLEND) {
+      writer.writeByte(Math.round(ps.blend[0]));
+      writer.writeByte(Math.round(ps.blend[1]));
+      writer.writeByte(Math.round(ps.blend[2]));
+      writer.writeByte(Math.round(ps.blend[3]));
+  }
+
+  if (mask & PS_FOV) writer.writeByte(ps.fov);
+  if (mask & PS_RDFLAGS) writer.writeByte(ps.rdflags);
+  if (mask & PS_WATERTYPE) writer.writeByte(ps.watertype);
+
+  // Write Stats
+  writer.writeLong(statsMask);
+  for (let i = 0; i < 32; i++) {
+      if (statsMask & (1 << i)) {
+          writer.writeShort(ps.stats[i]);
+      }
+  }
+}

package/src/protocol/renderFx.ts

@@ -0,0 +1,22 @@
+export enum RenderFx {
+  MinLight = 1,
+  ViewerModel = 2,
+  WeaponModel = 4,
+  FullBright = 8,
+  DepthHack = 16,
+  Translucent = 32,
+  FrameLerp = 64,
+  Beam = 128,
+  CustomLight = 256,
+  Glow = 512,
+  ShellRed = 1024,
+  ShellGreen = 2048,
+  ShellBlue = 4096,
+  IrVisible = 32768,
+  ShellDouble = 65536,
+  ShellHalfDam = 131072,
+  MinLightPlus = 262144,
+  ExtraLight = 524288,
+  BeamLightning = 1048576,
+  Flashlight = 2097152, // 1 << 21
+}