quake2ts 0.0.568 → 0.0.570

package/packages/game/dist/types/entities/index.d.ts

@@ -1,4 +1,4 @@
-export { Entity, type DieCallback, type EntityFieldDescriptor, type EntityFieldType, type PainCallback, type ThinkCallback, type TouchCallback, type UseCallback, type MonsterInfo, type MonsterMove, type MonsterFrame, MoveType, Solid, ServerFlags, DeadFlag, ENTITY_FIELD_METADATA, } from './entity.js';
+export { Entity, type DieCallback, type EntityFieldDescriptor, type EntityFieldType, type PainCallback, type ThinkCallback, type TouchCallback, type UseCallback, type MonsterInfo, type MonsterMove, type MonsterFrame, type MonsterAction, type AIAction, MoveType, Solid, ServerFlags, DeadFlag, EntityFlags, EntityEffects, MuzzleFlash, ENTITY_FIELD_METADATA, } from './entity.js';
 export { EntitySystem, type EntitySystemSnapshot, type SerializedEntityState, type SerializedTargetAwareness, type LevelState } from './system.js';
 export { type EntityPoolSnapshot } from './pool.js';
 export { type ThinkScheduleEntry } from './thinkScheduler.js';

package/packages/game/dist/types/entities/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/entities/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,MAAM,EACN,KAAK,WAAW,EAChB,KAAK,qBAAqB,EAC1B,KAAK,eAAe,EACpB,KAAK,YAAY,EACjB,KAAK,aAAa,EAClB,KAAK,aAAa,EAClB,KAAK,WAAW,EAChB,KAAK,WAAW,EAChB,KAAK,WAAW,EAChB,KAAK,YAAY,EACjB,QAAQ,EACR,KAAK,EACL,WAAW,EACX,QAAQ,EACR,qBAAqB,GACtB,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,YAAY,EAAE,KAAK,oBAAoB,EAAE,KAAK,qBAAqB,EAAE,KAAK,yBAAyB,EAAE,KAAK,UAAU,EAAE,MAAM,aAAa,CAAC;AACnJ,OAAO,EAAE,KAAK,kBAAkB,EAAE,MAAM,WAAW,CAAC;AACpD,OAAO,EAAE,KAAK,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAC9D,OAAO,EACL,oBAAoB,EACpB,0BAA0B,EAC1B,eAAe,EACf,qBAAqB,EACrB,qBAAqB,EACrB,yBAAyB,EACzB,aAAa,EACb,KAAK,YAAY,EACjB,KAAK,YAAY,EACjB,KAAK,YAAY,EACjB,KAAK,aAAa,GACnB,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AACtD,cAAc,kBAAkB,CAAC;AACjC,cAAc,gBAAgB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/entities/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,MAAM,EACN,KAAK,WAAW,EAChB,KAAK,qBAAqB,EAC1B,KAAK,eAAe,EACpB,KAAK,YAAY,EACjB,KAAK,aAAa,EAClB,KAAK,aAAa,EAClB,KAAK,WAAW,EAChB,KAAK,WAAW,EAChB,KAAK,WAAW,EAChB,KAAK,YAAY,EACjB,KAAK,aAAa,EAClB,KAAK,QAAQ,EACb,QAAQ,EACR,KAAK,EACL,WAAW,EACX,QAAQ,EACR,WAAW,EACX,aAAa,EACb,WAAW,EACX,qBAAqB,GACtB,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,YAAY,EAAE,KAAK,oBAAoB,EAAE,KAAK,qBAAqB,EAAE,KAAK,yBAAyB,EAAE,KAAK,UAAU,EAAE,MAAM,aAAa,CAAC;AACnJ,OAAO,EAAE,KAAK,kBAAkB,EAAE,MAAM,WAAW,CAAC;AACpD,OAAO,EAAE,KAAK,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAC9D,OAAO,EACL,oBAAoB,EACpB,0BAA0B,EAC1B,eAAe,EACf,qBAAqB,EACrB,qBAAqB,EACrB,yBAAyB,EACzB,aAAa,EACb,KAAK,YAAY,EACjB,KAAK,YAAY,EACjB,KAAK,YAAY,EACjB,KAAK,aAAa,GACnB,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AACtD,cAAc,kBAAkB,CAAC;AACjC,cAAc,gBAAgB,CAAC"}

package/packages/test-utils/dist/index.cjs

@@ -41,27 +41,35 @@ __export(index_exports, {
   compareScreenshots: () => compareScreenshots,
   createBinaryStreamMock: () => createBinaryStreamMock,
   createBinaryWriterMock: () => createBinaryWriterMock,
+  createCombatTestContext: () => createCombatTestContext,
   createControlledTimer: () => createControlledTimer,
   createCustomNetworkCondition: () => createCustomNetworkCondition,
   createDeltaSnapshot: () => createDeltaSnapshot,
   createEntity: () => createEntity,
+  createEntityFactory: () => createEntityFactory,
   createEntityStateFactory: () => createEntityStateFactory,
   createGameStateSnapshotFactory: () => createGameStateSnapshotFactory,
+  createItemEntityFactory: () => createItemEntityFactory,
+  createMockAI: () => createMockAI,
   createMockAudioContext: () => createMockAudioContext,
   createMockCanvas: () => createMockCanvas,
   createMockCanvasContext2D: () => createMockCanvasContext2D,
   createMockConnection: () => createMockConnection,
+  createMockDamageInfo: () => createMockDamageInfo,
   createMockEngine: () => createMockEngine,
   createMockGPUAdapter: () => createMockGPUAdapter,
   createMockGPUCanvasContext: () => createMockGPUCanvasContext,
   createMockGPUDevice: () => createMockGPUDevice,
   createMockGame: () => createMockGame,
+  createMockGameExports: () => createMockGameExports,
   createMockGameState: () => createMockGameState,
   createMockHandshake: () => createMockHandshake,
   createMockImage: () => createMockImage,
   createMockImageData: () => createMockImageData,
   createMockIndexedDB: () => createMockIndexedDB,
   createMockLocalStorage: () => createMockLocalStorage,
+  createMockMonsterAI: () => createMockMonsterAI,
+  createMockMonsterMove: () => createMockMonsterMove,
   createMockNetDriver: () => createMockNetDriver,
   createMockNetworkAddress: () => createMockNetworkAddress,
   createMockPerformance: () => createMockPerformance,
@@ -76,15 +84,21 @@ __export(index_exports, {
   createMockTransport: () => createMockTransport,
   createMockUDPSocket: () => createMockUDPSocket,
   createMockUserInfo: () => createMockUserInfo,
+  createMockWeapon: () => createMockWeapon,
   createMockWebGL2Context: () => createMockWebGL2Context,
+  createMonsterEntityFactory: () => createMonsterEntityFactory,
   createMultiplayerTestScenario: () => createMultiplayerTestScenario,
   createNetChanMock: () => createNetChanMock,
+  createPhysicsTestContext: () => createPhysicsTestContext,
+  createPlayerEntityFactory: () => createPlayerEntityFactory,
   createPlayerStateFactory: () => createPlayerStateFactory,
   createPlaywrightTestClient: () => createPlaywrightTestClient,
+  createProjectileEntityFactory: () => createProjectileEntityFactory,
   createServerSnapshot: () => createServerSnapshot,
-  createSpawnContext: () => createSpawnContext,
+  createSpawnTestContext: () => createSpawnTestContext,
   createStorageTestScenario: () => createStorageTestScenario,
   createTestContext: () => createTestContext,
+  createTriggerEntityFactory: () => createTriggerEntityFactory,
   createVisualTestScenario: () => createVisualTestScenario,
   intersects: () => import_shared3.intersects,
   ladderTrace: () => import_shared3.ladderTrace,
@@ -95,6 +109,7 @@ __export(index_exports, {
   makeLeafModel: () => makeLeafModel,
   makeNode: () => makeNode,
   makePlane: () => makePlane,
+  mockMonsterAttacks: () => mockMonsterAttacks,
   serializeUserInfo: () => serializeUserInfo,
   setupBrowserEnvironment: () => setupBrowserEnvironment,
   setupMockAudioContext: () => setupMockAudioContext,
@@ -268,6 +283,7 @@ function makeBrushFromMinsMaxs(mins, maxs, contents = import_shared.CONTENTS_SOL
 }
 
 // src/game/factories.ts
+var import_game = require("@quake2ts/game");
 var createPlayerStateFactory = (overrides) => ({
   pm_type: 0,
   pm_time: 0,
@@ -350,10 +366,77 @@ var createGameStateSnapshotFactory = (overrides) => ({
   pm_type: 0,
   ...overrides
 });
+function createEntityFactory(overrides = {}) {
+  const ent = new import_game.Entity(1);
+  Object.assign(ent, {
+    classname: "info_null",
+    health: 0,
+    max_health: 0,
+    takedamage: false,
+    deadflag: import_game.DeadFlag.Alive,
+    solid: import_game.Solid.Not,
+    movetype: import_game.MoveType.None,
+    flags: 0,
+    svflags: 0,
+    ...overrides
+  });
+  return ent;
+}
+function createPlayerEntityFactory(overrides = {}) {
+  return createEntityFactory({
+    classname: "player",
+    health: 100,
+    max_health: 100,
+    takedamage: true,
+    solid: import_game.Solid.BoundingBox,
+    movetype: import_game.MoveType.Walk,
+    svflags: import_game.ServerFlags.Player,
+    viewheight: 22,
+    ...overrides
+  });
+}
+function createMonsterEntityFactory(classname, overrides = {}) {
+  return createEntityFactory({
+    classname,
+    health: 100,
+    max_health: 100,
+    takedamage: true,
+    solid: import_game.Solid.BoundingBox,
+    movetype: import_game.MoveType.Step,
+    svflags: import_game.ServerFlags.Monster,
+    deadflag: import_game.DeadFlag.Alive,
+    ...overrides
+  });
+}
+function createItemEntityFactory(classname, overrides = {}) {
+  return createEntityFactory({
+    classname,
+    solid: import_game.Solid.Trigger,
+    movetype: import_game.MoveType.Toss,
+    ...overrides
+  });
+}
+function createProjectileEntityFactory(classname, overrides = {}) {
+  return createEntityFactory({
+    classname,
+    solid: import_game.Solid.Bsp,
+    movetype: import_game.MoveType.FlyMissile,
+    svflags: import_game.ServerFlags.Projectile,
+    ...overrides
+  });
+}
+function createTriggerEntityFactory(classname, overrides = {}) {
+  return createEntityFactory({
+    classname,
+    solid: import_game.Solid.Trigger,
+    movetype: import_game.MoveType.None,
+    ...overrides
+  });
+}
 
 // src/game/helpers.ts
 var import_vitest2 = require("vitest");
-var import_game = require("@quake2ts/game");
+var import_game2 = require("@quake2ts/game");
 var import_shared2 = require("@quake2ts/shared");
 var import_shared3 = require("@quake2ts/shared");
 var createMockEngine = () => ({
@@ -363,8 +446,8 @@ var createMockEngine = () => ({
   centerprintf: import_vitest2.vi.fn()
 });
 var createMockGame = (seed = 12345) => {
-  const spawnRegistry = new import_game.SpawnRegistry();
-  const hooks = new import_game.ScriptHookRegistry();
+  const spawnRegistry = new import_game2.SpawnRegistry();
+  const hooks = new import_game2.ScriptHookRegistry();
   const game = {
     random: (0, import_shared2.createRandomGenerator)({ seed }),
     registerEntitySpawn: import_vitest2.vi.fn((classname, spawnFunc) => {
@@ -406,7 +489,7 @@ function createTestContext(options) {
   const hooks = game.hooks;
   const entities = {
     spawn: import_vitest2.vi.fn(() => {
-      const ent = new import_game.Entity(entityList.length + 1);
+      const ent = new import_game2.Entity(entityList.length + 1);
       entityList.push(ent);
       hooks.onEntitySpawn(ent);
       return ent;
@@ -485,7 +568,7 @@ function createTestContext(options) {
     deathmatch: false,
     coop: false,
     activeCount: entityList.length,
-    world: entityList.find((e) => e.classname === "worldspawn") || new import_game.Entity(0)
+    world: entityList.find((e) => e.classname === "worldspawn") || new import_game2.Entity(0)
     // ... other EntitySystem properties would go here
   };
   return {
@@ -502,14 +585,115 @@ function createTestContext(options) {
     precacheImage: import_vitest2.vi.fn()
   };
 }
-function createSpawnContext() {
+function createSpawnTestContext(mapName) {
+  const ctx = createTestContext();
+  if (mapName) {
+    ctx.game.spawnWorld();
+  }
+  return ctx;
+}
+function createCombatTestContext() {
+  return createTestContext();
+}
+function createPhysicsTestContext() {
   return createTestContext();
 }
 function createEntity() {
-  return new import_game.Entity(1);
+  return new import_game2.Entity(1);
 }
 
+// src/game/mocks/ai.ts
+var import_vitest3 = require("vitest");
+function createMockAI(overrides = {}) {
+  return {
+    checkAttack: import_vitest3.vi.fn(() => false),
+    findTarget: import_vitest3.vi.fn(() => null),
+    visible: import_vitest3.vi.fn(() => true),
+    infront: import_vitest3.vi.fn(() => true),
+    ...overrides
+  };
+}
+function createMockMonsterAI(overrides = {}) {
+  return {
+    stand: import_vitest3.vi.fn(),
+    walk: import_vitest3.vi.fn(),
+    run: import_vitest3.vi.fn(),
+    dodge: import_vitest3.vi.fn(),
+    attack: import_vitest3.vi.fn(),
+    melee: import_vitest3.vi.fn(),
+    sight: import_vitest3.vi.fn(),
+    idle: import_vitest3.vi.fn(),
+    ...overrides
+  };
+}
+function createMockMonsterMove(first, last, think, action) {
+  const frames = [];
+  for (let i = first; i <= last; i++) {
+    frames.push({
+      ai: action,
+      dist: 0,
+      think
+    });
+  }
+  return {
+    firstframe: first,
+    lastframe: last,
+    frames,
+    endfunc: null
+  };
+}
+
+// src/game/mocks/combat.ts
+var import_vitest4 = require("vitest");
+var import_game3 = require("@quake2ts/game");
+function createMockDamageInfo(overrides = {}) {
+  return {
+    damage: 10,
+    mod: import_game3.DamageMod.UNKNOWN,
+    knockback: 0,
+    attacker: null,
+    inflictor: null,
+    dir: null,
+    point: null,
+    ...overrides
+  };
+}
+var WEAPON_NAMES = {
+  "weapon_blaster": "Blaster",
+  "weapon_shotgun": "Shotgun",
+  "weapon_supershotgun": "Super Shotgun",
+  "weapon_machinegun": "Machinegun",
+  "weapon_chaingun": "Chaingun",
+  "weapon_grenadelauncher": "Grenade Launcher",
+  "weapon_rocketlauncher": "Rocket Launcher",
+  "weapon_hyperblaster": "HyperBlaster",
+  "weapon_railgun": "Railgun",
+  "weapon_bfg": "BFG10K"
+};
+function createMockWeapon(name = "Mock Weapon") {
+  const displayName = WEAPON_NAMES[name] || name;
+  return {
+    name: displayName,
+    ammoType: "bullets",
+    ammoUse: 1,
+    selection: import_vitest4.vi.fn(),
+    think: import_vitest4.vi.fn(),
+    command: import_vitest4.vi.fn()
+  };
+}
+var mockMonsterAttacks = {
+  fireBlaster: import_vitest4.vi.fn(),
+  fireRocket: import_vitest4.vi.fn(),
+  fireGrenade: import_vitest4.vi.fn(),
+  fireHeat: import_vitest4.vi.fn(),
+  fireBullet: import_vitest4.vi.fn(),
+  fireShotgun: import_vitest4.vi.fn(),
+  fireRailgun: import_vitest4.vi.fn(),
+  fireBFG: import_vitest4.vi.fn()
+};
+
 // src/game/mocks.ts
+var import_vitest5 = require("vitest");
 function createMockGameState(overrides) {
   return {
     levelName: "test_level",
@@ -519,9 +703,97 @@ function createMockGameState(overrides) {
     ...overrides
   };
 }
+function createMockGameExports(overrides) {
+  return {
+    init: import_vitest5.vi.fn(),
+    shutdown: import_vitest5.vi.fn(),
+    spawnWorld: import_vitest5.vi.fn(),
+    frame: import_vitest5.vi.fn().mockReturnValue({ state: {} }),
+    clientConnect: import_vitest5.vi.fn().mockReturnValue(true),
+    clientBegin: import_vitest5.vi.fn().mockReturnValue({ index: 1, origin: { x: 0, y: 0, z: 0 } }),
+    clientDisconnect: import_vitest5.vi.fn(),
+    clientThink: import_vitest5.vi.fn(),
+    // clientUserInfoChanged is not in GameExports
+    // clientCommand is not in GameExports (it's serverCommand?) No, clientCommand might be missing from interface but present in impl or legacy.
+    // Checking GameExports interface in src/index.ts:
+    /*
+      clientConnect(ent: Entity | null, userInfo: string): string | true;
+      clientBegin(client: PlayerClient): Entity;
+      clientDisconnect(ent: Entity): void;
+      clientThink(ent: Entity, cmd: UserCommand): void;
+      respawn(ent: Entity): void;
+      ...
+      configstring(index: number, value: string): void;
+      serverCommand(cmd: string): void;
+    */
+    respawn: import_vitest5.vi.fn(),
+    entities: {
+      getByIndex: import_vitest5.vi.fn(),
+      forEachEntity: import_vitest5.vi.fn(),
+      findByRadius: import_vitest5.vi.fn(),
+      find: import_vitest5.vi.fn(),
+      checkAnyCollision: import_vitest5.vi.fn(),
+      trace: import_vitest5.vi.fn(),
+      pointcontents: import_vitest5.vi.fn(),
+      link: import_vitest5.vi.fn(),
+      // linkentity mapped to link in EntitySystem? No, linkentity in imports, link/unlink in System.
+      unlink: import_vitest5.vi.fn(),
+      spawn: import_vitest5.vi.fn(),
+      free: import_vitest5.vi.fn(),
+      activeCount: 0,
+      world: { classname: "worldspawn" }
+    },
+    multicast: import_vitest5.vi.fn(),
+    unicast: import_vitest5.vi.fn(),
+    configstring: import_vitest5.vi.fn(),
+    serverCommand: import_vitest5.vi.fn(),
+    sound: import_vitest5.vi.fn(),
+    soundIndex: import_vitest5.vi.fn(),
+    centerprintf: import_vitest5.vi.fn(),
+    trace: import_vitest5.vi.fn(),
+    time: 0,
+    deathmatch: false,
+    skill: 1,
+    rogue: false,
+    xatrix: false,
+    coop: false,
+    friendlyFire: false,
+    random: {
+      next: import_vitest5.vi.fn(),
+      nextFloat: import_vitest5.vi.fn(),
+      range: import_vitest5.vi.fn(),
+      crandom: import_vitest5.vi.fn(),
+      getState: import_vitest5.vi.fn(),
+      setState: import_vitest5.vi.fn()
+    },
+    createSave: import_vitest5.vi.fn(),
+    loadSave: import_vitest5.vi.fn(),
+    serialize: import_vitest5.vi.fn(),
+    loadState: import_vitest5.vi.fn(),
+    setGodMode: import_vitest5.vi.fn(),
+    setNoclip: import_vitest5.vi.fn(),
+    setNotarget: import_vitest5.vi.fn(),
+    giveItem: import_vitest5.vi.fn(),
+    damage: import_vitest5.vi.fn(),
+    teleport: import_vitest5.vi.fn(),
+    registerHooks: import_vitest5.vi.fn(),
+    hooks: {
+      onMapLoad: import_vitest5.vi.fn(),
+      onMapUnload: import_vitest5.vi.fn(),
+      onPlayerSpawn: import_vitest5.vi.fn(),
+      onPlayerDeath: import_vitest5.vi.fn(),
+      register: import_vitest5.vi.fn()
+    },
+    setSpectator: import_vitest5.vi.fn(),
+    registerEntitySpawn: import_vitest5.vi.fn(),
+    unregisterEntitySpawn: import_vitest5.vi.fn(),
+    getCustomEntities: import_vitest5.vi.fn(),
+    ...overrides
+  };
+}
 
 // src/server/mocks/transport.ts
-var import_vitest3 = require("vitest");
+var import_vitest6 = require("vitest");
 var MockTransport = class {
   constructor() {
     this.address = "127.0.0.1";
@@ -529,11 +801,11 @@ var MockTransport = class {
     this.sentMessages = [];
     this.receivedMessages = [];
     this.listening = false;
-    this.listenSpy = import_vitest3.vi.fn().mockImplementation(async (port) => {
+    this.listenSpy = import_vitest6.vi.fn().mockImplementation(async (port) => {
       this.port = port;
       this.listening = true;
     });
-    this.closeSpy = import_vitest3.vi.fn().mockImplementation(() => {
+    this.closeSpy = import_vitest6.vi.fn().mockImplementation(() => {
       this.listening = false;
     });
   }
@@ -589,11 +861,11 @@ var MockTransport = class {
 };
 function createMockUDPSocket(overrides) {
   const socket = {
-    send: import_vitest3.vi.fn(),
-    on: import_vitest3.vi.fn(),
-    close: import_vitest3.vi.fn(),
-    bind: import_vitest3.vi.fn(),
-    address: import_vitest3.vi.fn().mockReturnValue({ address: "127.0.0.1", family: "IPv4", port: 0 }),
+    send: import_vitest6.vi.fn(),
+    on: import_vitest6.vi.fn(),
+    close: import_vitest6.vi.fn(),
+    bind: import_vitest6.vi.fn(),
+    address: import_vitest6.vi.fn().mockReturnValue({ address: "127.0.0.1", family: "IPv4", port: 0 }),
     ...overrides
   };
   return socket;
@@ -610,13 +882,13 @@ function createMockTransport(address = "127.0.0.1", port = 27910, overrides) {
 }
 function createMockNetDriver(overrides) {
   return {
-    connect: import_vitest3.vi.fn().mockResolvedValue(void 0),
-    disconnect: import_vitest3.vi.fn(),
-    send: import_vitest3.vi.fn(),
-    onMessage: import_vitest3.vi.fn(),
-    onClose: import_vitest3.vi.fn(),
-    onError: import_vitest3.vi.fn(),
-    isConnected: import_vitest3.vi.fn().mockReturnValue(true),
+    connect: import_vitest6.vi.fn().mockResolvedValue(void 0),
+    disconnect: import_vitest6.vi.fn(),
+    send: import_vitest6.vi.fn(),
+    onMessage: import_vitest6.vi.fn(),
+    onClose: import_vitest6.vi.fn(),
+    onError: import_vitest6.vi.fn(),
+    isConnected: import_vitest6.vi.fn().mockReturnValue(true),
     ...overrides
   };
 }
@@ -624,7 +896,7 @@ function createMockNetDriver(overrides) {
 // src/server/mocks/state.ts
 var import_server = require("@quake2ts/server");
 var import_shared4 = require("@quake2ts/shared");
-var import_vitest4 = require("vitest");
+var import_vitest7 = require("vitest");
 function createMockServerState(overrides) {
   return {
     state: import_server.ServerState.Game,
@@ -666,13 +938,13 @@ function createMockServerClient(clientNum, overrides) {
       incomingSequence: 0,
       outgoingSequence: 0,
       lastReceived: 0,
-      process: import_vitest4.vi.fn(),
-      transmit: import_vitest4.vi.fn(),
-      writeReliableByte: import_vitest4.vi.fn(),
-      writeReliableShort: import_vitest4.vi.fn(),
-      writeReliableLong: import_vitest4.vi.fn(),
-      writeReliableString: import_vitest4.vi.fn(),
-      writeReliableData: import_vitest4.vi.fn()
+      process: import_vitest7.vi.fn(),
+      transmit: import_vitest7.vi.fn(),
+      writeReliableByte: import_vitest7.vi.fn(),
+      writeReliableShort: import_vitest7.vi.fn(),
+      writeReliableLong: import_vitest7.vi.fn(),
+      writeReliableString: import_vitest7.vi.fn(),
+      writeReliableData: import_vitest7.vi.fn()
     },
     // Cast as any because NetChan might be complex to fully mock here
     userInfo: "",
@@ -714,13 +986,13 @@ function createMockServerClient(clientNum, overrides) {
 }
 function createMockServer(overrides) {
   return {
-    start: import_vitest4.vi.fn().mockResolvedValue(void 0),
-    stop: import_vitest4.vi.fn(),
-    multicast: import_vitest4.vi.fn(),
-    unicast: import_vitest4.vi.fn(),
-    configstring: import_vitest4.vi.fn(),
-    kickPlayer: import_vitest4.vi.fn(),
-    changeMap: import_vitest4.vi.fn().mockResolvedValue(void 0),
+    start: import_vitest7.vi.fn().mockResolvedValue(void 0),
+    stop: import_vitest7.vi.fn(),
+    multicast: import_vitest7.vi.fn(),
+    unicast: import_vitest7.vi.fn(),
+    configstring: import_vitest7.vi.fn(),
+    kickPlayer: import_vitest7.vi.fn(),
+    changeMap: import_vitest7.vi.fn().mockResolvedValue(void 0),
     ...overrides
   };
 }
@@ -782,19 +1054,19 @@ async function simulateHandshake(client, server) {
 }
 
 // src/server/mocks/commands.ts
-var import_vitest5 = require("vitest");
+var import_vitest8 = require("vitest");
 function createMockServerConsole(overrides) {
   const outputBuffer = [];
   const commandBuffer = [];
   return {
-    exec: import_vitest5.vi.fn((cmd) => {
+    exec: import_vitest8.vi.fn((cmd) => {
       commandBuffer.push(cmd);
       return `Executed: ${cmd}`;
     }),
-    print: import_vitest5.vi.fn((text) => {
+    print: import_vitest8.vi.fn((text) => {
       outputBuffer.push(text);
     }),
-    broadcast: import_vitest5.vi.fn((text) => {
+    broadcast: import_vitest8.vi.fn((text) => {
       outputBuffer.push(`Broadcast: ${text}`);
     }),
     commandBuffer,
@@ -807,13 +1079,13 @@ function createMockRConClient(password = "") {
     connected: false,
     lastCommand: "",
     lastResponse: "",
-    connect: import_vitest5.vi.fn(async (address, port, pwd) => {
+    connect: import_vitest8.vi.fn(async (address, port, pwd) => {
       return pwd === password;
     }),
-    sendCommand: import_vitest5.vi.fn(async (cmd) => {
+    sendCommand: import_vitest8.vi.fn(async (cmd) => {
       return `RCON Response for: ${cmd}`;
     }),
-    disconnect: import_vitest5.vi.fn()
+    disconnect: import_vitest8.vi.fn()
   };
 }
 function simulateServerCommand(server, command) {
@@ -1456,10 +1728,10 @@ function createMockImage(width, height, src) {
 }
 
 // src/engine/mocks/webgpu.ts
-var import_vitest6 = require("vitest");
+var import_vitest9 = require("vitest");
 function createMockGPUAdapter() {
   return {
-    requestDevice: import_vitest6.vi.fn().mockResolvedValue(createMockGPUDevice()),
+    requestDevice: import_vitest9.vi.fn().mockResolvedValue(createMockGPUDevice()),
     features: /* @__PURE__ */ new Set(),
     limits: {}
   };
@@ -1469,40 +1741,40 @@ function createMockGPUDevice() {
     features: /* @__PURE__ */ new Set(),
     limits: {},
     queue: {
-      submit: import_vitest6.vi.fn(),
-      writeBuffer: import_vitest6.vi.fn(),
-      writeTexture: import_vitest6.vi.fn(),
-      copyExternalImageToTexture: import_vitest6.vi.fn()
-    },
-    createCommandEncoder: import_vitest6.vi.fn().mockReturnValue({
-      beginRenderPass: import_vitest6.vi.fn().mockReturnValue({
-        setPipeline: import_vitest6.vi.fn(),
-        draw: import_vitest6.vi.fn(),
-        end: import_vitest6.vi.fn()
+      submit: import_vitest9.vi.fn(),
+      writeBuffer: import_vitest9.vi.fn(),
+      writeTexture: import_vitest9.vi.fn(),
+      copyExternalImageToTexture: import_vitest9.vi.fn()
+    },
+    createCommandEncoder: import_vitest9.vi.fn().mockReturnValue({
+      beginRenderPass: import_vitest9.vi.fn().mockReturnValue({
+        setPipeline: import_vitest9.vi.fn(),
+        draw: import_vitest9.vi.fn(),
+        end: import_vitest9.vi.fn()
       }),
-      finish: import_vitest6.vi.fn()
+      finish: import_vitest9.vi.fn()
     }),
-    createRenderPipeline: import_vitest6.vi.fn(),
-    createShaderModule: import_vitest6.vi.fn(),
-    createBindGroup: import_vitest6.vi.fn(),
-    createBindGroupLayout: import_vitest6.vi.fn(),
-    createBuffer: import_vitest6.vi.fn(),
-    createTexture: import_vitest6.vi.fn(),
-    createSampler: import_vitest6.vi.fn()
+    createRenderPipeline: import_vitest9.vi.fn(),
+    createShaderModule: import_vitest9.vi.fn(),
+    createBindGroup: import_vitest9.vi.fn(),
+    createBindGroupLayout: import_vitest9.vi.fn(),
+    createBuffer: import_vitest9.vi.fn(),
+    createTexture: import_vitest9.vi.fn(),
+    createSampler: import_vitest9.vi.fn()
   };
 }
 function createMockGPUCanvasContext() {
   return {
-    configure: import_vitest6.vi.fn(),
-    unconfigure: import_vitest6.vi.fn(),
-    getCurrentTexture: import_vitest6.vi.fn()
+    configure: import_vitest9.vi.fn(),
+    unconfigure: import_vitest9.vi.fn(),
+    getCurrentTexture: import_vitest9.vi.fn()
   };
 }
 function setupWebGPUMocks() {
   const mockAdapter = createMockGPUAdapter();
   const mockGpu = {
-    requestAdapter: import_vitest6.vi.fn().mockResolvedValue(mockAdapter),
-    getPreferredCanvasFormat: import_vitest6.vi.fn().mockReturnValue("bgra8unorm")
+    requestAdapter: import_vitest9.vi.fn().mockResolvedValue(mockAdapter),
+    getPreferredCanvasFormat: import_vitest9.vi.fn().mockReturnValue("bgra8unorm")
   };
   Object.defineProperty(global.navigator, "gpu", {
     value: mockGpu,
@@ -2119,27 +2391,35 @@ function createVisualTestScenario(page, sceneName) {
   compareScreenshots,
   createBinaryStreamMock,
   createBinaryWriterMock,
+  createCombatTestContext,
   createControlledTimer,
   createCustomNetworkCondition,
   createDeltaSnapshot,
   createEntity,
+  createEntityFactory,
   createEntityStateFactory,
   createGameStateSnapshotFactory,
+  createItemEntityFactory,
+  createMockAI,
   createMockAudioContext,
   createMockCanvas,
   createMockCanvasContext2D,
   createMockConnection,
+  createMockDamageInfo,
   createMockEngine,
   createMockGPUAdapter,
   createMockGPUCanvasContext,
   createMockGPUDevice,
   createMockGame,
+  createMockGameExports,
   createMockGameState,
   createMockHandshake,
   createMockImage,
   createMockImageData,
   createMockIndexedDB,
   createMockLocalStorage,
+  createMockMonsterAI,
+  createMockMonsterMove,
   createMockNetDriver,
   createMockNetworkAddress,
   createMockPerformance,
@@ -2154,15 +2434,21 @@ function createVisualTestScenario(page, sceneName) {
   createMockTransport,
   createMockUDPSocket,
   createMockUserInfo,
+  createMockWeapon,
   createMockWebGL2Context,
+  createMonsterEntityFactory,
   createMultiplayerTestScenario,
   createNetChanMock,
+  createPhysicsTestContext,
+  createPlayerEntityFactory,
   createPlayerStateFactory,
   createPlaywrightTestClient,
+  createProjectileEntityFactory,
   createServerSnapshot,
-  createSpawnContext,
+  createSpawnTestContext,
   createStorageTestScenario,
   createTestContext,
+  createTriggerEntityFactory,
   createVisualTestScenario,
   intersects,
   ladderTrace,
@@ -2173,6 +2459,7 @@ function createVisualTestScenario(page, sceneName) {
   makeLeafModel,
   makeNode,
   makePlane,
+  mockMonsterAttacks,
   serializeUserInfo,
   setupBrowserEnvironment,
   setupMockAudioContext,