quake2ts 0.0.567 → 0.0.569

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,16 +41,21 @@ __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,
@@ -62,6 +67,9 @@ __export(index_exports, {
   createMockImageData: () => createMockImageData,
   createMockIndexedDB: () => createMockIndexedDB,
   createMockLocalStorage: () => createMockLocalStorage,
+  createMockMonsterAI: () => createMockMonsterAI,
+  createMockMonsterMove: () => createMockMonsterMove,
+  createMockNetDriver: () => createMockNetDriver,
   createMockNetworkAddress: () => createMockNetworkAddress,
   createMockPerformance: () => createMockPerformance,
   createMockRAF: () => createMockRAF,
@@ -75,15 +83,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,
@@ -94,6 +108,7 @@ __export(index_exports, {
   makeLeafModel: () => makeLeafModel,
   makeNode: () => makeNode,
   makePlane: () => makePlane,
+  mockMonsterAttacks: () => mockMonsterAttacks,
   serializeUserInfo: () => serializeUserInfo,
   setupBrowserEnvironment: () => setupBrowserEnvironment,
   setupMockAudioContext: () => setupMockAudioContext,
@@ -267,6 +282,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,
@@ -349,10 +365,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 = () => ({
@@ -362,8 +445,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) => {
@@ -405,7 +488,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;
@@ -484,7 +567,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 {
@@ -501,13 +584,113 @@ 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
 function createMockGameState(overrides) {
   return {
@@ -520,7 +703,7 @@ function createMockGameState(overrides) {
 }
 
 // src/server/mocks/transport.ts
-var import_vitest3 = require("vitest");
+var import_vitest5 = require("vitest");
 var MockTransport = class {
   constructor() {
     this.address = "127.0.0.1";
@@ -528,11 +711,11 @@ var MockTransport = class {
     this.sentMessages = [];
     this.receivedMessages = [];
     this.listening = false;
-    this.listenSpy = import_vitest3.vi.fn().mockImplementation(async (port) => {
+    this.listenSpy = import_vitest5.vi.fn().mockImplementation(async (port) => {
       this.port = port;
       this.listening = true;
     });
-    this.closeSpy = import_vitest3.vi.fn().mockImplementation(() => {
+    this.closeSpy = import_vitest5.vi.fn().mockImplementation(() => {
       this.listening = false;
     });
   }
@@ -588,11 +771,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_vitest5.vi.fn(),
+    on: import_vitest5.vi.fn(),
+    close: import_vitest5.vi.fn(),
+    bind: import_vitest5.vi.fn(),
+    address: import_vitest5.vi.fn().mockReturnValue({ address: "127.0.0.1", family: "IPv4", port: 0 }),
     ...overrides
   };
   return socket;
@@ -607,11 +790,23 @@ function createMockTransport(address = "127.0.0.1", port = 27910, overrides) {
   Object.assign(transport, overrides);
   return transport;
 }
+function createMockNetDriver(overrides) {
+  return {
+    connect: import_vitest5.vi.fn().mockResolvedValue(void 0),
+    disconnect: import_vitest5.vi.fn(),
+    send: import_vitest5.vi.fn(),
+    onMessage: import_vitest5.vi.fn(),
+    onClose: import_vitest5.vi.fn(),
+    onError: import_vitest5.vi.fn(),
+    isConnected: import_vitest5.vi.fn().mockReturnValue(true),
+    ...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_vitest6 = require("vitest");
 function createMockServerState(overrides) {
   return {
     state: import_server.ServerState.Game,
@@ -641,15 +836,7 @@ function createMockServerStatic(maxClients = 16, overrides) {
   };
 }
 function createMockServerClient(clientNum, overrides) {
-  const mockNet = {
-    connect: import_vitest4.vi.fn(),
-    disconnect: import_vitest4.vi.fn(),
-    send: import_vitest4.vi.fn(),
-    onMessage: import_vitest4.vi.fn(),
-    onClose: import_vitest4.vi.fn(),
-    onError: import_vitest4.vi.fn(),
-    isConnected: import_vitest4.vi.fn().mockReturnValue(true)
-  };
+  const mockNet = createMockNetDriver();
   return {
     index: clientNum,
     state: import_server.ClientState.Connected,
@@ -661,13 +848,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_vitest6.vi.fn(),
+      transmit: import_vitest6.vi.fn(),
+      writeReliableByte: import_vitest6.vi.fn(),
+      writeReliableShort: import_vitest6.vi.fn(),
+      writeReliableLong: import_vitest6.vi.fn(),
+      writeReliableString: import_vitest6.vi.fn(),
+      writeReliableData: import_vitest6.vi.fn()
     },
     // Cast as any because NetChan might be complex to fully mock here
     userInfo: "",
@@ -709,13 +896,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_vitest6.vi.fn().mockResolvedValue(void 0),
+    stop: import_vitest6.vi.fn(),
+    multicast: import_vitest6.vi.fn(),
+    unicast: import_vitest6.vi.fn(),
+    configstring: import_vitest6.vi.fn(),
+    kickPlayer: import_vitest6.vi.fn(),
+    changeMap: import_vitest6.vi.fn().mockResolvedValue(void 0),
     ...overrides
   };
 }
@@ -777,19 +964,19 @@ async function simulateHandshake(client, server) {
 }
 
 // src/server/mocks/commands.ts
-var import_vitest5 = require("vitest");
+var import_vitest7 = require("vitest");
 function createMockServerConsole(overrides) {
   const outputBuffer = [];
   const commandBuffer = [];
   return {
-    exec: import_vitest5.vi.fn((cmd) => {
+    exec: import_vitest7.vi.fn((cmd) => {
       commandBuffer.push(cmd);
       return `Executed: ${cmd}`;
     }),
-    print: import_vitest5.vi.fn((text) => {
+    print: import_vitest7.vi.fn((text) => {
       outputBuffer.push(text);
     }),
-    broadcast: import_vitest5.vi.fn((text) => {
+    broadcast: import_vitest7.vi.fn((text) => {
       outputBuffer.push(`Broadcast: ${text}`);
     }),
     commandBuffer,
@@ -802,13 +989,13 @@ function createMockRConClient(password = "") {
     connected: false,
     lastCommand: "",
     lastResponse: "",
-    connect: import_vitest5.vi.fn(async (address, port, pwd) => {
+    connect: import_vitest7.vi.fn(async (address, port, pwd) => {
       return pwd === password;
     }),
-    sendCommand: import_vitest5.vi.fn(async (cmd) => {
+    sendCommand: import_vitest7.vi.fn(async (cmd) => {
       return `RCON Response for: ${cmd}`;
     }),
-    disconnect: import_vitest5.vi.fn()
+    disconnect: import_vitest7.vi.fn()
   };
 }
 function simulateServerCommand(server, command) {
@@ -1451,10 +1638,10 @@ function createMockImage(width, height, src) {
 }
 
 // src/engine/mocks/webgpu.ts
-var import_vitest6 = require("vitest");
+var import_vitest8 = require("vitest");
 function createMockGPUAdapter() {
   return {
-    requestDevice: import_vitest6.vi.fn().mockResolvedValue(createMockGPUDevice()),
+    requestDevice: import_vitest8.vi.fn().mockResolvedValue(createMockGPUDevice()),
     features: /* @__PURE__ */ new Set(),
     limits: {}
   };
@@ -1464,40 +1651,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_vitest8.vi.fn(),
+      writeBuffer: import_vitest8.vi.fn(),
+      writeTexture: import_vitest8.vi.fn(),
+      copyExternalImageToTexture: import_vitest8.vi.fn()
+    },
+    createCommandEncoder: import_vitest8.vi.fn().mockReturnValue({
+      beginRenderPass: import_vitest8.vi.fn().mockReturnValue({
+        setPipeline: import_vitest8.vi.fn(),
+        draw: import_vitest8.vi.fn(),
+        end: import_vitest8.vi.fn()
       }),
-      finish: import_vitest6.vi.fn()
+      finish: import_vitest8.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_vitest8.vi.fn(),
+    createShaderModule: import_vitest8.vi.fn(),
+    createBindGroup: import_vitest8.vi.fn(),
+    createBindGroupLayout: import_vitest8.vi.fn(),
+    createBuffer: import_vitest8.vi.fn(),
+    createTexture: import_vitest8.vi.fn(),
+    createSampler: import_vitest8.vi.fn()
   };
 }
 function createMockGPUCanvasContext() {
   return {
-    configure: import_vitest6.vi.fn(),
-    unconfigure: import_vitest6.vi.fn(),
-    getCurrentTexture: import_vitest6.vi.fn()
+    configure: import_vitest8.vi.fn(),
+    unconfigure: import_vitest8.vi.fn(),
+    getCurrentTexture: import_vitest8.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_vitest8.vi.fn().mockResolvedValue(mockAdapter),
+    getPreferredCanvasFormat: import_vitest8.vi.fn().mockReturnValue("bgra8unorm")
   };
   Object.defineProperty(global.navigator, "gpu", {
     value: mockGpu,
@@ -2114,16 +2301,21 @@ 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,
@@ -2135,6 +2327,9 @@ function createVisualTestScenario(page, sceneName) {
   createMockImageData,
   createMockIndexedDB,
   createMockLocalStorage,
+  createMockMonsterAI,
+  createMockMonsterMove,
+  createMockNetDriver,
   createMockNetworkAddress,
   createMockPerformance,
   createMockRAF,
@@ -2148,15 +2343,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,
@@ -2167,6 +2368,7 @@ function createVisualTestScenario(page, sceneName) {
   makeLeafModel,
   makeNode,
   makePlane,
+  mockMonsterAttacks,
   serializeUserInfo,
   setupBrowserEnvironment,
   setupMockAudioContext,