@quake2ts/shared 0.0.1

package/src/pmove/water.ts

@@ -0,0 +1,56 @@
+import { MASK_WATER, CONTENTS_NONE, type ContentsFlag } from '../bsp/contents.js';
+import type { Vec3 } from '../math/vec3.js';
+import { WaterLevel } from './constants.js';
+import type { PmovePointContentsFn } from './types.js';
+
+export interface WaterLevelParams {
+  readonly origin: Vec3;
+  readonly mins: Vec3;
+  readonly viewheight: number;
+  readonly pointContents: PmovePointContentsFn;
+}
+
+export interface WaterLevelResult {
+  readonly waterlevel: WaterLevel;
+  readonly watertype: ContentsFlag;
+}
+
+/**
+ * Mirrors the rerelease `PM_GetWaterLevel` helper: probes the player's feet,
+ * waist, and viewheight to determine how submerged they are and returns both
+ * the enum level plus the contents bits encountered at the lowest sample.
+ */
+export function getWaterLevel(params: WaterLevelParams): WaterLevelResult {
+  const { origin, mins, viewheight, pointContents } = params;
+
+  const sample2 = viewheight - mins.z;
+  const sample1 = sample2 / 2;
+
+  const point: Vec3 = {
+    x: origin.x,
+    y: origin.y,
+    z: origin.z + mins.z + 1,
+  };
+
+  let contents = pointContents(point);
+  if ((contents & MASK_WATER) === 0) {
+    return { waterlevel: WaterLevel.None, watertype: CONTENTS_NONE };
+  }
+
+  const watertype = contents;
+  let waterlevel = WaterLevel.Feet;
+
+  let point2: Vec3 = { x: point.x, y: point.y, z: origin.z + mins.z + sample1 };
+  contents = pointContents(point2);
+  if ((contents & MASK_WATER) !== 0) {
+    waterlevel = WaterLevel.Waist;
+
+    let point3: Vec3 = { x: point.x, y: point.y, z: origin.z + mins.z + sample2 };
+    contents = pointContents(point3);
+    if ((contents & MASK_WATER) !== 0) {
+      waterlevel = WaterLevel.Under;
+    }
+  }
+
+  return { waterlevel, watertype };
+}

package/src/protocol/bitpack.ts

@@ -0,0 +1,139 @@
+
+/**
+ * Helper to force a number into a signed 16-bit integer range (-32768 to 32767).
+ * This mimics the behavior of casting to `short` in C++.
+ */
+function toSigned16(val: number): number {
+  return (val << 16) >> 16;
+}
+
+/**
+ * Reads a 16-bit integer (unsigned) from the stats array at the given byte offset.
+ * Mimics reading `*(uint16_t*)((uint8_t*)stats + byteOffset)` in Little Endian.
+ */
+function readUint16LE(stats: number[], startIndex: number, byteOffset: number): number {
+  // Determine which element(s) of the array we are accessing
+  // stats is int16[], so each element is 2 bytes.
+  // absolute byte offset from stats[startIndex]
+  const elementIndex = Math.floor(byteOffset / 2);
+  const isOdd = (byteOffset % 2) !== 0;
+
+  // Access the array at the calculated index relative to startIndex
+  const index = startIndex + elementIndex;
+
+  // Read the primary element
+  const val0 = stats[index] || 0; // Handle potentially undefined/uninitialized slots as 0
+
+  if (!isOdd) {
+    // Aligned access: just return the element as uint16
+    return val0 & 0xFFFF;
+  } else {
+    // Unaligned access: High byte of val0 + Low byte of val1
+    const val1 = stats[index + 1] || 0;
+
+    // Low byte of result comes from High byte of val0
+    const low = (val0 >>> 8) & 0xFF;
+    // High byte of result comes from Low byte of val1
+    const high = val1 & 0xFF;
+
+    return (high << 8) | low;
+  }
+}
+
+/**
+ * Writes a 16-bit integer to the stats array at the given byte offset.
+ * Mimics writing `*(uint16_t*)((uint8_t*)stats + byteOffset) = value` in Little Endian.
+ */
+function writeUint16LE(stats: number[], startIndex: number, byteOffset: number, value: number): void {
+  const elementIndex = Math.floor(byteOffset / 2);
+  const isOdd = (byteOffset % 2) !== 0;
+  const index = startIndex + elementIndex;
+
+  // Ensure array has values at these indices to avoid NaN math
+  if (stats[index] === undefined) stats[index] = 0;
+
+  if (!isOdd) {
+    // Aligned access: overwrite the element
+    stats[index] = toSigned16(value);
+  } else {
+    // Unaligned access
+    if (stats[index + 1] === undefined) stats[index + 1] = 0;
+
+    const val0 = stats[index];
+    const val1 = stats[index + 1];
+
+    // We want to write `value` (which is Low byte `L_v` and High byte `H_v`)
+    // into the bytes at `byteOffset` and `byteOffset + 1`.
+
+    // Byte at `byteOffset` corresponds to High byte of `stats[index]`.
+    // It should become `value & 0xFF` (L_v).
+    // So `stats[index]` becomes `(Old_Low) | (L_v << 8)`.
+    const newHigh0 = value & 0xFF;
+    const newVal0 = (val0 & 0xFF) | (newHigh0 << 8);
+    stats[index] = toSigned16(newVal0);
+
+    // Byte at `byteOffset + 1` corresponds to Low byte of `stats[index+1]`.
+    // It should become `(value >> 8) & 0xFF` (H_v).
+    // So `stats[index+1]` becomes `(H_v) | (Old_High << 8)`.
+    const newLow1 = (value >>> 8) & 0xFF;
+    const newVal1 = newLow1 | (val1 & 0xFF00);
+    stats[index + 1] = toSigned16(newVal1);
+  }
+}
+
+/**
+ * Packs a value into the stats array using a specific bit width.
+ * Equivalent to C++ `set_compressed_integer`.
+ *
+ * @param stats The stats array (number[] representing int16s)
+ * @param startIndex The index in the stats array where the packed region begins (e.g. STAT_AMMO_INFO_START)
+ * @param id The ID of the item to set (0-based index within the packed region)
+ * @param count The value to set
+ * @param bitsPerValue Number of bits per item (e.g. 9 for ammo, 2 for powerups)
+ */
+export function setCompressedInteger(
+  stats: number[],
+  startIndex: number,
+  id: number,
+  count: number,
+  bitsPerValue: number
+): void {
+  const bitOffset = bitsPerValue * id;
+  const byteOffset = Math.floor(bitOffset / 8);
+  const bitShift = bitOffset % 8;
+  const mask = ((1 << bitsPerValue) - 1) << bitShift;
+
+  // Read the 16-bit word at the target byte address
+  let base = readUint16LE(stats, startIndex, byteOffset);
+
+  // Apply the mask and value
+  // Note: (count << bitShift) might overflow 16 bits if we aren't careful,
+  // but the mask will handle the high bits.
+  // However, in JS, bitwise ops are 32-bit.
+  // We need to ensure we only write back 16 bits.
+
+  const valueToWrite = (base & ~mask) | ((count << bitShift) & mask);
+
+  // Write the modified 16-bit word back
+  writeUint16LE(stats, startIndex, byteOffset, valueToWrite & 0xFFFF);
+}
+
+/**
+ * Unpacks a value from the stats array.
+ * Equivalent to C++ `get_compressed_integer`.
+ */
+export function getCompressedInteger(
+  stats: number[],
+  startIndex: number,
+  id: number,
+  bitsPerValue: number
+): number {
+  const bitOffset = bitsPerValue * id;
+  const byteOffset = Math.floor(bitOffset / 8);
+  const bitShift = bitOffset % 8;
+  const mask = ((1 << bitsPerValue) - 1) << bitShift;
+
+  const base = readUint16LE(stats, startIndex, byteOffset);
+
+  return (base & mask) >>> bitShift;
+}

package/src/protocol/configstrings.ts

@@ -0,0 +1,104 @@
+// Mirrors the Quake II rerelease configstring/index layout from `game.h`.
+// These constants intentionally track the numeric values used in the C++
+// game and client modules so the TypeScript engine/game/client layers can
+// share deterministic indices for precaches and HUD parsing.
+
+export const MAX_STRING_CHARS = 1024;
+export const MAX_STRING_TOKENS = 80;
+export const MAX_TOKEN_CHARS = 512;
+
+export const MAX_QPATH = 64;
+export const MAX_OSPATH = 128;
+
+export const MAX_CLIENTS = 256;
+export const MAX_EDICTS = 8192;
+export const MAX_LIGHTSTYLES = 256;
+export const MAX_MODELS = 8192;
+export const MAX_SOUNDS = 2048;
+export const MAX_IMAGES = 512;
+export const MAX_ITEMS = 256;
+export const MAX_GENERAL = MAX_CLIENTS * 2;
+export const MAX_SHADOW_LIGHTS = 256;
+export const MAX_WHEEL_ITEMS = 32;
+
+export const CS_MAX_STRING_LENGTH = 96;
+export const CS_MAX_STRING_LENGTH_OLD = 64;
+
+// Enum-style numeric constants that mirror the C++ `configstrings` enum. Only
+// the explicitly numbered entries are re-stated here; everything else follows
+// sequentially to keep the arithmetic (e.g., CS_SOUNDS = CS_MODELS +
+// MAX_MODELS) intact.
+export enum ConfigStringIndex {
+  Name = 0,
+  CdTrack = 1,
+  Sky = 2,
+  SkyAxis = 3,
+  SkyRotate = 4,
+  StatusBar = 5,
+
+  // Matching bg_local.h:55-76
+  HealthBarName = 55,
+  CONFIG_N64_PHYSICS = 56,
+  CONFIG_CTF_TEAMS = 57,
+  CONFIG_COOP_RESPAWN_STRING = 58,
+  Story = 54, // Arbitrarily placed in the gap for now
+
+  AirAccel = 59,
+  MaxClients = 60,
+  MapChecksum = 61,
+
+  Models = 62,
+  Sounds = Models + MAX_MODELS,
+  Images = Sounds + MAX_SOUNDS,
+  Lights = Images + MAX_IMAGES,
+  ShadowLights = Lights + MAX_LIGHTSTYLES,
+  Items = ShadowLights + MAX_SHADOW_LIGHTS,
+  Players = Items + MAX_ITEMS, // CS_PLAYERS (contains userinfo with name, skin, etc.)
+  PlayerSkins = Players, // Alias for legacy code compatibility
+  General = Players + MAX_CLIENTS,
+  WheelWeapons = General + MAX_GENERAL,
+  WheelAmmo = WheelWeapons + MAX_WHEEL_ITEMS,
+  WheelPowerups = WheelAmmo + MAX_WHEEL_ITEMS,
+  CdLoopCount = WheelPowerups + MAX_WHEEL_ITEMS,
+  GameStyle = CdLoopCount + 1,
+  MaxConfigStrings = GameStyle + 1,
+}
+
+// Mirror the C++ MAX_CONFIGSTRINGS value for consumers that prefer a standalone constant.
+export const MAX_CONFIGSTRINGS = ConfigStringIndex.MaxConfigStrings;
+
+/**
+ * Returns the maximum string length permitted for the given configstring index,
+ * mirroring the `CS_SIZE` helper in the rerelease. Statusbar and general ranges
+ * can legally occupy multiple 96-character slots; everything else is capped at
+ * `CS_MAX_STRING_LENGTH`.
+ */
+export function configStringSize(index: number): number {
+  if (index >= ConfigStringIndex.StatusBar && index < ConfigStringIndex.AirAccel) {
+    return CS_MAX_STRING_LENGTH * (ConfigStringIndex.AirAccel - index);
+  }
+
+  if (index >= ConfigStringIndex.General && index < ConfigStringIndex.WheelWeapons) {
+    return CS_MAX_STRING_LENGTH * (ConfigStringIndex.MaxConfigStrings - index);
+  }
+
+  return CS_MAX_STRING_LENGTH;
+}
+
+// Legacy constants
+export const CS_NAME = ConfigStringIndex.Name;
+export const CS_CDTRACK = ConfigStringIndex.CdTrack;
+export const CS_SKY = ConfigStringIndex.Sky;
+export const CS_SKYAXIS = ConfigStringIndex.SkyAxis;
+export const CS_SKYROTATE = ConfigStringIndex.SkyRotate;
+export const CS_STATUSBAR = ConfigStringIndex.StatusBar;
+export const CS_AIRACCEL = ConfigStringIndex.AirAccel;
+export const CS_MAXCLIENTS = ConfigStringIndex.MaxClients;
+export const CS_MAPCHECKSUM = ConfigStringIndex.MapChecksum;
+export const CS_MODELS = ConfigStringIndex.Models;
+export const CS_SOUNDS = ConfigStringIndex.Sounds;
+export const CS_IMAGES = ConfigStringIndex.Images;
+export const CS_LIGHTS = ConfigStringIndex.Lights;
+export const CS_ITEMS = ConfigStringIndex.Items;
+export const CS_PLAYERS = ConfigStringIndex.Players;
+export const CS_GENERAL = ConfigStringIndex.General;

package/src/protocol/constants.ts

@@ -0,0 +1,40 @@
+
+export const MAX_CHALLENGES = 1024;
+export const MAX_PACKET_ENTITIES = 256; // Standard Q2 value
+export const UPDATE_BACKUP = 16;
+export const CMD_BACKUP = 64;
+export const MAX_INFO_STRING = 512;
+export const MAX_MSGLEN = 1400; // MTU safe limit
+
+// Muzzle Flash Constants
+export const MZ_BLASTER = 0;
+export const MZ_MACHINEGUN = 1;
+export const MZ_SHOTGUN = 2;
+export const MZ_CHAINGUN1 = 3;
+export const MZ_CHAINGUN2 = 4;
+export const MZ_CHAINGUN3 = 5;
+export const MZ_RAILGUN = 6;
+export const MZ_ROCKET = 7;
+export const MZ_GRENADE = 8;
+export const MZ_LOGIN = 9;
+export const MZ_LOGOUT = 10;
+export const MZ_SSHOTGUN = 11;
+export const MZ_BFG = 12;
+export const MZ_HYPERBLASTER = 13;
+
+// Xatrix / Rogue Extensions
+export const MZ_IONRIPPER = 16;
+export const MZ_BLUEHYPERBLASTER = 17;
+export const MZ_PHALANX = 18;
+export const MZ_BFG2 = 19;
+export const MZ_PHALANX2 = 20;
+export const MZ_ETF_RIFLE = 30;
+export const MZ_PROX = 31;
+export const MZ_ETF_RIFLE_2 = 32;
+export const MZ_HEATBEAM = 33;
+export const MZ_BLASTER2 = 34;
+export const MZ_TRACKER = 35;
+export const MZ_NUKE1 = 36;
+export const MZ_NUKE2 = 37;
+export const MZ_NUKE4 = 38;
+export const MZ_NUKE8 = 39;

package/src/protocol/contracts.ts

@@ -0,0 +1,149 @@
+export interface ContractValidationResult {
+  missing: string[];
+  nonFunctions: string[];
+  extras: string[];
+}
+
+export interface ContractValidationOptions {
+  readonly name?: string;
+  readonly allowExtra?: boolean;
+}
+
+export type ContractFunctionMap<Keys extends readonly string[]> = Record<Keys[number], (...args: unknown[]) => unknown>;
+
+function normalize(object: Record<string, unknown> | undefined): Record<string, unknown> {
+  return object ?? {};
+}
+
+export function validateContract<Keys extends readonly string[]>(
+  table: Record<string, unknown> | undefined,
+  requiredKeys: Keys,
+  options: ContractValidationOptions = {},
+): ContractValidationResult {
+  const normalized = normalize(table);
+  const missing: string[] = [];
+  const nonFunctions: string[] = [];
+
+  for (const key of requiredKeys) {
+    if (!(key in normalized)) {
+      missing.push(key);
+      continue;
+    }
+
+    if (typeof normalized[key] !== 'function') {
+      nonFunctions.push(key);
+    }
+  }
+
+  const extras = options.allowExtra === false ? Object.keys(normalized).filter((key) => !requiredKeys.includes(key)) : [];
+
+  return { missing, nonFunctions, extras } satisfies ContractValidationResult;
+}
+
+export function assertContract<Keys extends readonly string[]>(
+  table: Record<string, unknown> | undefined,
+  requiredKeys: Keys,
+  options: ContractValidationOptions = {},
+): asserts table is ContractFunctionMap<Keys> {
+  const { missing, nonFunctions, extras } = validateContract(table, requiredKeys, options);
+  if (missing.length === 0 && nonFunctions.length === 0 && extras.length === 0) {
+    return;
+  }
+
+  const pieces: string[] = [];
+  if (missing.length > 0) {
+    pieces.push(`missing: ${missing.join(', ')}`);
+  }
+  if (nonFunctions.length > 0) {
+    pieces.push(`non-functions: ${nonFunctions.join(', ')}`);
+  }
+  if (extras.length > 0) {
+    pieces.push(`extras: ${extras.join(', ')}`);
+  }
+
+  const label = options.name ?? 'contract';
+  throw new Error(`${label} validation failed (${pieces.join('; ')})`);
+}
+
+export const GAME_IMPORT_KEYS = [
+  'Broadcast_Print',
+  'Com_Print',
+  'Client_Print',
+  'Center_Print',
+  'sound',
+  'positioned_sound',
+  'local_sound',
+  'configstring',
+  'get_configstring',
+  'Com_Error',
+  'modelindex',
+  'soundindex',
+  'imageindex',
+  'setmodel',
+  'trace',
+  'clip',
+  'pointcontents',
+  'inPVS',
+  'inPHS',
+  'SetAreaPortalState',
+  'AreasConnected',
+  'linkentity',
+  'unlinkentity',
+  'BoxEdicts',
+  'multicast',
+  'unicast',
+] as const;
+
+export const GAME_EXPORT_KEYS = [
+  'PreInit',
+  'Init',
+  'Shutdown',
+  'SpawnEntities',
+  'WriteGameJson',
+  'ReadGameJson',
+  'WriteLevelJson',
+  'ReadLevelJson',
+  'CanSave',
+  'ClientConnect',
+  'ClientThink',
+  'RunFrame',
+  'Pmove',
+] as const;
+
+export const CGAME_IMPORT_KEYS = [
+  'Com_Print',
+  'get_configstring',
+  'Com_Error',
+  'TagMalloc',
+  'TagFree',
+  'AddCommandString',
+  'CL_FrameValid',
+  'CL_FrameTime',
+  'CL_ClientTime',
+  'CL_ServerFrame',
+  'Draw_RegisterPic',
+  'Draw_GetPicSize',
+  'SCR_DrawChar',
+  'SCR_DrawPic',
+  'SCR_DrawColorPic',
+] as const;
+
+export const CGAME_EXPORT_KEYS = [
+  'Init',
+  'Shutdown',
+  'DrawHUD',
+  'TouchPics',
+  'LayoutFlags',
+  'GetActiveWeaponWheelWeapon',
+  'GetOwnedWeaponWheelWeapons',
+  'GetWeaponWheelAmmoCount',
+  'GetPowerupWheelCount',
+  'GetHitMarkerDamage',
+  'Pmove',
+  'ParseConfigString',
+  'ParseCenterPrint',
+  'ClearNotify',
+  'ClearCenterprint',
+  'NotifyMessage',
+  'GetMonsterFlashOffset',
+] as const;

package/src/protocol/crc.ts

@@ -0,0 +1,32 @@
+// Quake 2 CRC implementation
+// Ported from qcommon/crc.c
+
+const crc_table: number[] = [
+    0x00, 0x91, 0xe3, 0x72, 0x07, 0x96, 0xe4, 0x75, 0x0e, 0x9f, 0xed, 0x7c, 0x09, 0x98, 0xea, 0x7b,
+    0x1c, 0x8d, 0xff, 0x6e, 0x1b, 0x8a, 0xf8, 0x69, 0x12, 0x83, 0xf1, 0x60, 0x15, 0x84, 0xf6, 0x67,
+    0x38, 0xa9, 0xdb, 0x4a, 0x3f, 0xae, 0xdc, 0x4d, 0x36, 0xa7, 0xd5, 0x44, 0x31, 0xa0, 0xd2, 0x43,
+    0x24, 0xb5, 0xc7, 0x56, 0x23, 0xb2, 0xc0, 0x51, 0x2a, 0xbb, 0xc9, 0x58, 0x2d, 0xbc, 0xce, 0x5f,
+    0x70, 0xe1, 0x93, 0x02, 0x77, 0xe6, 0x94, 0x05, 0x7e, 0xef, 0x9d, 0x0c, 0x79, 0xe8, 0x9a, 0x0b,
+    0x6c, 0xfd, 0x8f, 0x1e, 0x6b, 0xfa, 0x88, 0x19, 0x62, 0xf3, 0x81, 0x10, 0x65, 0xf4, 0x86, 0x17,
+    0x48, 0xd9, 0xab, 0x3a, 0x4f, 0xde, 0xac, 0x3d, 0x46, 0xd7, 0xa5, 0x34, 0x41, 0xd0, 0xa2, 0x33,
+    0x54, 0xc5, 0xb7, 0x26, 0x53, 0xc2, 0xb0, 0x21, 0x5a, 0xcb, 0xb9, 0x28, 0x5d, 0xcc, 0xbe, 0x2f,
+    0xe0, 0x71, 0x03, 0x92, 0xe7, 0x76, 0x04, 0x95, 0xee, 0x7f, 0x0d, 0x9c, 0xe9, 0x78, 0x0a, 0x9b,
+    0xfc, 0x6d, 0x1f, 0x8e, 0xfb, 0x6a, 0x18, 0x89, 0xf2, 0x63, 0x11, 0x80, 0xf5, 0x64, 0x16, 0x87,
+    0xd8, 0x49, 0x3b, 0xaa, 0xdf, 0x4e, 0x3c, 0xad, 0xd6, 0x47, 0x35, 0xa4, 0xd1, 0x40, 0x32, 0xa3,
+    0xc4, 0x55, 0x27, 0xb6, 0xc3, 0x52, 0x20, 0xb1, 0xca, 0x5b, 0x29, 0xb8, 0xcd, 0x5c, 0x2e, 0xbf,
+    0x90, 0x01, 0x73, 0xe2, 0x97, 0x06, 0x74, 0xe5, 0x9e, 0x0f, 0x7d, 0xec, 0x99, 0x08, 0x7a, 0xeb,
+    0x8c, 0x1d, 0x6f, 0xfe, 0x8b, 0x1a, 0x68, 0xf9, 0x82, 0x13, 0x61, 0xf0, 0x85, 0x14, 0x66, 0xf7,
+    0xa8, 0x39, 0x4b, 0xda, 0xaf, 0x3e, 0x4c, 0xdd, 0xa6, 0x37, 0x45, 0xd4, 0xa1, 0x30, 0x42, 0xd3,
+    0xb4, 0x25, 0x56, 0xc7, 0xb3, 0x22, 0x50, 0xc1, 0xba, 0x2b, 0x59, 0xc8, 0xbd, 0x2c, 0x5e, 0xcf
+];
+
+/**
+ * Calculates 8-bit CRC for the given data
+ */
+export function crc8(data: Uint8Array): number {
+    let crc = 0;
+    for (let i = 0; i < data.length; i++) {
+        crc = crc_table[(crc ^ data[i]) & 0xff];
+    }
+    return crc;
+}

package/src/protocol/cvar.ts

@@ -0,0 +1,15 @@
+export const enum CvarFlags {
+  None = 0,
+  Archive = 1 << 0,
+  UserInfo = 1 << 1,
+  ServerInfo = 1 << 2,
+  Latch = 1 << 3,
+  Cheat = 1 << 4,
+}
+
+export interface CvarDefinition {
+  readonly name: string;
+  readonly defaultValue: string;
+  readonly description?: string;
+  readonly flags?: CvarFlags;
+}

package/src/protocol/effects.ts

@@ -0,0 +1,33 @@
+// Source: game.h (Quake 2)
+export enum EntityEffects {
+  Rotate = 0x00000004,
+  Gib = 0x00000008,
+  RotateScript = 0x00000010,
+  Blaster = 0x00000020,
+  Rocket = 0x00000040,
+  Grenade = 0x00000080,
+  HyperBlaster = 0x00000100,
+  Bfg = 0x00000200,
+  ColorShell = 0x00000400,
+  Powerscreen = 0x00000800,
+  Anim01 = 0x00001000,
+  Anim23 = 0x00002000,
+  AnimAll = 0x00004000,
+  AnimAllFast = 0x00008000,
+  Quad = 0x00010000,
+  Pent = 0x00020000,
+  Explosion = 0x00040000,
+  Teleport = 0x00080000,
+  Flag1 = 0x00100000,
+  Flag2 = 0x00200000,
+  Boomerang = 0x00400000,
+  Greengibs = 0x00800000,
+  Bluehyperblaster = 0x01000000,
+  Spinning = 0x02000000,
+  Plasma = 0x04000000,
+  Trap = 0x08000000,
+  Tracker = 0x10000000,
+  Double = 0x20000000,
+  Sphinx = 0x40000000,
+  TagTrail = 0x80000000,
+}