@quake2ts/test-utils 0.0.1 → 0.0.739

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quake2ts/test-utils",
-  "version": "0.0.1",
+  "version": "0.0.739",
   "type": "module",
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",
@@ -26,25 +26,43 @@
     "dist",
     "src"
   ],
-  "dependencies": {
-    "gl-matrix": "^3.4.4",
-    "@quake2ts/game": "0.0.1",
-    "@quake2ts/server": "0.0.1",
-    "@quake2ts/engine": "^0.0.1",
-    "@quake2ts/shared": "0.0.1"
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/jburnhams/quake2.git",
+    "directory": "quake2ts/packages/test-utils"
   },
   "peerDependencies": {
     "@webgpu/types": "^0.1.68",
+    "gl-matrix": "^3.4.4",
     "pixelmatch": "^7.1.0",
     "playwright": "^1.57.0",
     "pngjs": "^7.0.0",
     "vitest": "^1.6.0",
-    "webgpu": "^0.3.8"
+    "webgpu": "^0.3.8",
+    "@quake2ts/engine": "^0.0.739",
+    "@quake2ts/game": "0.0.739",
+    "@quake2ts/server": "0.0.739",
+    "@quake2ts/shared": "0.0.739"
   },
   "peerDependenciesMeta": {
+    "@quake2ts/engine": {
+      "optional": true
+    },
+    "@quake2ts/game": {
+      "optional": true
+    },
+    "@quake2ts/server": {
+      "optional": true
+    },
+    "@quake2ts/shared": {
+      "optional": true
+    },
     "@webgpu/types": {
       "optional": true
     },
+    "gl-matrix": {
+      "optional": true
+    },
     "pixelmatch": {
       "optional": true
     },
@@ -59,6 +77,7 @@
     }
   },
   "devDependencies": {
+    "gl-matrix": "^3.4.4",
     "@napi-rs/canvas": "^0.1.84",
     "@types/jsdom": "^27.0.0",
     "@types/pixelmatch": "^5.2.6",
@@ -72,7 +91,11 @@
     "tsup": "^8.1.0",
     "typescript": "^5.4.5",
     "vitest": "^1.6.0",
-    "webgpu": "^0.3.8"
+    "webgpu": "^0.3.8",
+    "@quake2ts/engine": "^0.0.739",
+    "@quake2ts/game": "0.0.739",
+    "@quake2ts/server": "0.0.739",
+    "@quake2ts/shared": "0.0.739"
   },
   "scripts": {
     "build": "tsup src/index.ts --format esm,cjs --dts",

package/src/e2e/visual.ts

@@ -1,172 +1,105 @@
-import { Canvas, Image } from '@napi-rs/canvas';
+import { Page } from 'playwright';
+import { PNG } from 'pngjs';
+import pixelmatch from 'pixelmatch';
+import { Canvas } from '@napi-rs/canvas';
 import fs from 'fs/promises';
 import path from 'path';
 
 export interface VisualDiff {
-    diffPercentage: number;
-    diffImage?: Buffer;
+  diffPixels: number;
+  diffPercentage: number;
+  isMatch: boolean;
+  diffImage?: Buffer;
 }
 
-/**
- * Captures a screenshot of the game using Playwright.
- * @param page Playwright Page object
- * @param name Output filename (without extension)
- */
-export async function captureGameScreenshot(page: any, name: string): Promise<Buffer> {
-    return await page.screenshot({ path: `${name}.png` });
+export interface VisualScenario {
+  sceneName: string;
+  setup?: (page: Page) => Promise<void>;
 }
 
 /**
- * Saves a canvas to a PNG file.
- * Compatible with both JSDOM/HTMLCanvasElement and @napi-rs/canvas.
+ * Captures a screenshot of the game canvas.
  */
-export async function takeScreenshot(canvas: Canvas | HTMLCanvasElement, filepath: string): Promise<void> {
-    let buffer: Buffer;
-
-    // Handle @napi-rs/canvas Canvas object
-    if ('toBuffer' in canvas && typeof canvas.toBuffer === 'function') {
-        buffer = canvas.toBuffer('image/png');
-    }
-    // Handle JSDOM HTMLCanvasElement (if backed by node-canvas or similar)
-    else if ('toDataURL' in canvas) {
-        const dataUrl = canvas.toDataURL('image/png');
-        const base64 = dataUrl.replace(/^data:image\/png;base64,/, '');
-        buffer = Buffer.from(base64, 'base64');
-    } else {
-        throw new Error('Unsupported canvas type for screenshot');
-    }
-
-    await fs.mkdir(path.dirname(filepath), { recursive: true });
-    await fs.writeFile(filepath, buffer);
+export async function captureGameScreenshot(page: Page, name: string): Promise<Buffer> {
+  const canvasElement = page.locator('canvas');
+  if (await canvasElement.count() > 0) {
+    return await canvasElement.screenshot({ path: `${name}.png` });
+  }
+  return await page.screenshot({ path: `${name}.png` });
 }
 
 /**
- * Compares a canvas state against a baseline image file.
- * Returns true if they match (within optional threshold logic, currently strict pixel match).
- * If baseline does not exist, it saves the current state as baseline and returns true.
+ * Saves a canvas to a PNG file.
  */
-export async function compareScreenshot(canvas: Canvas | HTMLCanvasElement, baselinePath: string): Promise<boolean> {
-    try {
-        await fs.access(baselinePath);
-    } catch {
-        // Baseline doesn't exist, save current as baseline
-        console.warn(`Baseline not found at ${baselinePath}, saving current as baseline.`);
-        await takeScreenshot(canvas, baselinePath);
-        return true;
-    }
-
-    // Load baseline
-    const baselineBuffer = await fs.readFile(baselinePath);
-    const baselineImage = new Image();
-    baselineImage.src = baselineBuffer;
-
-    // Get dimensions (assume match for now, or fail)
-    const width = baselineImage.width;
-    const height = baselineImage.height;
-
-    // Get current image data
-    // We need to draw both to canvases to get pixel data easily with @napi-rs/canvas
-    // If input is already a canvas, we can use it.
-
-    // Helper to get buffer from input canvas
-    let currentBuffer: Buffer;
-    if ('toBuffer' in canvas && typeof canvas.toBuffer === 'function') {
-        currentBuffer = canvas.toBuffer('image/png');
-    } else if ('toDataURL' in canvas) {
-        const dataUrl = canvas.toDataURL('image/png');
-        currentBuffer = Buffer.from(dataUrl.replace(/^data:image\/png;base64,/, ''), 'base64');
-    } else {
-        throw new Error('Unsupported canvas type');
-    }
-
-    // Simple Buffer comparison first (fastest)
-    if (baselineBuffer.equals(currentBuffer)) {
-        return true;
-    }
-
-    // If buffers differ, it could be metadata or compression. Do pixel check.
-    // Note: Creating a new canvas to draw the image onto for pixel access
-    // This requires the 'Canvas' constructor which we imported.
-    const baselineCanvas = new Canvas(width, height);
-    const ctx = baselineCanvas.getContext('2d');
-    ctx.drawImage(baselineImage, 0, 0);
-    const baselineData = ctx.getImageData(0, 0, width, height).data;
-
-    // Load current buffer to image to draw (handles JSDOM/napi differences uniformally)
-    const currentImage = new Image();
-    currentImage.src = currentBuffer;
-
-    if (currentImage.width !== width || currentImage.height !== height) {
-        console.error(`Dimension mismatch: Baseline ${width}x${height} vs Current ${currentImage.width}x${currentImage.height}`);
-        return false;
-    }
-
-    const currentCanvas = new Canvas(width, height);
-    const ctx2 = currentCanvas.getContext('2d');
-    ctx2.drawImage(currentImage, 0, 0);
-    const currentData = ctx2.getImageData(0, 0, width, height).data;
-
-    let diffPixels = 0;
-    const totalPixels = width * height;
-
-    // Simple pixel diff
-    for (let i = 0; i < baselineData.length; i += 4) {
-        if (baselineData[i] !== currentData[i] ||         // R
-            baselineData[i+1] !== currentData[i+1] ||     // G
-            baselineData[i+2] !== currentData[i+2] ||     // B
-            baselineData[i+3] !== currentData[i+3]) {     // A
-            diffPixels++;
-        }
-    }
-
-    if (diffPixels > 0) {
-        console.error(`Visual regression: ${diffPixels} pixels differ (${(diffPixels/totalPixels*100).toFixed(2)}%)`);
-        // Save diff image? (Optional, skipping for now)
-        return false;
-    }
-
-    return true;
+export async function takeScreenshot(canvas: Canvas | HTMLCanvasElement, filepath: string): Promise<void> {
+  let buffer: Buffer;
+
+  // Handle @napi-rs/canvas Canvas object
+  if ('toBuffer' in canvas && typeof canvas.toBuffer === 'function') {
+    buffer = canvas.toBuffer('image/png');
+  }
+  // Handle JSDOM HTMLCanvasElement
+  else if ('toDataURL' in canvas) {
+    const dataUrl = canvas.toDataURL('image/png');
+    const base64 = dataUrl.replace(/^data:image\/png;base64,/, '');
+    buffer = Buffer.from(base64, 'base64');
+  } else {
+    throw new Error('Unsupported canvas type for screenshot');
+  }
+
+  await fs.mkdir(path.dirname(filepath), { recursive: true });
+  await fs.writeFile(filepath, buffer);
 }
 
 /**
- * Compares two screenshots (Buffers).
- * Uses simple buffer check. Kept for backward compatibility or direct buffer comparison.
+ * Compares two image buffers using pixelmatch.
  */
 export function compareScreenshots(baseline: Buffer, current: Buffer, threshold: number = 0.01): VisualDiff {
-    // Basic length check first
-    if (baseline.length !== current.length) {
-        return { diffPercentage: 1.0 };
+  try {
+    const img1 = PNG.sync.read(baseline);
+    const img2 = PNG.sync.read(current);
+
+    if (img1.width !== img2.width || img1.height !== img2.height) {
+      throw new Error(`Image dimensions do not match: ${img1.width}x${img1.height} vs ${img2.width}x${img2.height}`);
     }
 
-    let diffPixels = 0;
-    const totalPixels = baseline.length; // Approximate bytes
+    const { width, height } = img1;
+    const diff = new PNG({ width, height });
 
-    for (let i = 0; i < baseline.length; i++) {
-        if (baseline[i] !== current[i]) {
-            diffPixels++;
-        }
-    }
+    const diffPixels = pixelmatch(
+      img1.data,
+      img2.data,
+      diff.data,
+      width,
+      height,
+      { threshold }
+    );
 
-    const diffPercentage = diffPixels / totalPixels;
+    const diffPercentage = diffPixels / (width * height);
+    const isMatch = diffPixels === 0;
 
     return {
-        diffPercentage,
+      diffPixels,
+      diffPercentage,
+      isMatch,
+      diffImage: PNG.sync.write(diff)
     };
-}
-
-export interface VisualScenario {
-    sceneName: string;
-    setup: () => Promise<void>;
+  } catch (error) {
+    // Fallback or error handling
+    console.error('Error comparing screenshots:', error);
+    return {
+      diffPixels: -1,
+      diffPercentage: 1.0,
+      isMatch: false
+    };
+  }
 }
 
 /**
  * Creates a visual test scenario.
  */
 export function createVisualTestScenario(sceneName: string): VisualScenario {
-    return {
-        sceneName,
-        setup: async () => {
-            // Setup scene logic
-        }
-    };
+  return {
+    sceneName
+  };
 }

package/src/game/factories.ts

@@ -157,6 +157,23 @@ export function createPlayerEntityFactory(overrides: Partial<Entity> = {}): Part
     movetype: MoveType.Walk,
     svflags: ServerFlags.Player,
     viewheight: 22,
+    client: {
+        inventory: {
+            ammo: { counts: [], caps: [] },
+            ownedWeapons: new Set(),
+            powerups: new Map(),
+            keys: new Set(),
+            items: new Set()
+        },
+        weaponStates: {
+            currentWeapon: null,
+            lastFireTime: 0,
+            weaponFrame: 0,
+            weaponIdleTime: 0,
+            states: new Map(), // Initialize states map correctly
+            activeWeaponId: null
+        }
+    } as any,
     ...overrides
   });
 }

package/src/game/helpers.ts

@@ -228,12 +228,8 @@ export function createPhysicsTestContext(bspModel?: BspModel): TestContext {
     // For now, we'll just store the model on the context if we extended TestContext,
     // but the task specifically asks to "Include collision world, traces".
 
-    // In a real scenario, we might want to hook up a real BSP trace function here
+    // In a real scenario, we might want to hook up a real BSP physics engine mock here
     // or a mock that uses the BSP data.
-    // Since we don't have a full BSP physics engine mock ready to drop in,
-    // we will stick with the default trace mock which is already set up in createTestContext,
-    // but we acknowledge the bspModel parameter for future expansion where we might
-    // use it to seed the trace results.
   }
 
   return context;
@@ -308,3 +304,37 @@ export function createGameImportsAndEngine(overrides?: {
 
   return { imports, engine };
 }
+
+/**
+ * Creates a mock GameExports object with mocked properties.
+ * This is useful for testing game logic that consumes the game object.
+ *
+ * @param overrides Optional overrides for the game object properties
+ */
+export function createMockGameExports(overrides: Partial<any> = {}): any {
+  return {
+      init: vi.fn(),
+      shutdown: vi.fn(),
+      frame: vi.fn().mockReturnValue({ state: {} }),
+      clientThink: vi.fn(),
+      time: 0,
+      spawnWorld: vi.fn(),
+      deathmatch: false,
+      coop: false,
+      gameImports: {},
+      gameEngine: {},
+      entities: {
+          spawn: vi.fn(),
+          free: vi.fn(),
+          find: vi.fn(),
+          findByClassname: vi.fn(),
+          findByRadius: vi.fn(() => []),
+          forEachEntity: vi.fn(),
+          timeSeconds: 0,
+          ...overrides.entities,
+      },
+      multicast: vi.fn(),
+      unicast: vi.fn(),
+      ...overrides
+  };
+}

package/src/index.ts

@@ -12,7 +12,7 @@ export * from './game/helpers/save.js';
 export * from './game/mocks/ai.js';
 export * from './game/mocks/combat.js';
 export * from './game/mocks/items.js';
-export * from './game/mocks.js';
+// Removed export * from './game/mocks.js';
 export * from './server/mocks/transport.js';
 export * from './server/mockTransport.js';
 export * from './server/mockNetDriver.js';

package/src/server/mocks/state.ts

@@ -4,11 +4,27 @@ import { Entity } from '@quake2ts/game';
 import { vi } from 'vitest';
 import { createMockNetDriver } from './transport.js';
 
-// Define GameState interface locally or import from where it should be.
-// Based on grep, GameStateSnapshot is in @quake2ts/game.
-// But test-utils/src/game/mocks.ts defines a local GameState interface.
-// Let's use that one or define a compatible one here.
-import { GameState } from '../../game/mocks.js';
+// Define GameState interface locally as we removed game/mocks.ts
+export interface GameState {
+    levelName: string;
+    time: number;
+    entities: Entity[];
+    clients: any[]; // Mock client objects
+}
+
+/**
+ * Creates a mock game state object.
+ * @param overrides Optional overrides for the game state.
+ */
+export function createMockGameState(overrides?: Partial<GameState>): GameState {
+    return {
+        levelName: 'test_level',
+        time: 0,
+        entities: [],
+        clients: [],
+        ...overrides
+    };
+}
 
 /**
  * Creates a mock server state object.
@@ -152,11 +168,3 @@ export function createMockServer(overrides?: Partial<MockServer>): MockServer {
         ...overrides
     };
 }
-
-// Re-export GameState from game mocks if needed, or use the one from game/mocks
-// Since we have a createMockGameState in game/mocks.ts, we should probably use that or alias it.
-// The task says "Add createMockGameState() factory".
-// If it is already in game/mocks.ts, we can just export it from there or re-export it here.
-// But to avoid duplication, I will just re-export the one from game mocks if the intention is to have it available under server utils.
-
-export { createMockGameState, type GameState } from '../../game/mocks.js';

package/src/game/mocks.ts

@@ -1,105 +0,0 @@
-import { Entity, GameExports, GameImports } from '@quake2ts/game';
-import { vi } from 'vitest';
-
-/**
- * Interface for mock GameState.
- */
-export interface GameState {
-    levelName: string;
-    time: number;
-    entities: Entity[];
-    clients: any[]; // Mock client objects
-}
-
-/**
- * Creates a mock game state object.
- * @param overrides Optional overrides for the game state.
- */
-export function createMockGameState(overrides?: Partial<GameState>): GameState {
-    return {
-        levelName: 'test_level',
-        time: 0,
-        entities: [],
-        clients: [],
-        ...overrides
-    };
-}
-
-/**
- * Creates a mock GameExports object.
- */
-export function createMockGameExports(overrides?: Partial<GameExports>): GameExports {
-    return {
-        init: vi.fn(),
-        shutdown: vi.fn(),
-        spawnWorld: vi.fn(),
-        frame: vi.fn().mockReturnValue({ state: {} }),
-        clientConnect: vi.fn().mockReturnValue(true),
-        clientBegin: vi.fn().mockReturnValue({ index: 1, origin: { x: 0, y: 0, z: 0 } }),
-        clientDisconnect: vi.fn(),
-        clientThink: vi.fn(),
-        respawn: vi.fn(),
-        entities: {
-            getByIndex: vi.fn(),
-            forEachEntity: vi.fn(),
-            findByRadius: vi.fn(),
-            find: vi.fn(),
-            checkAnyCollision: vi.fn(),
-            trace: vi.fn(),
-            pointcontents: vi.fn(),
-            link: vi.fn(),
-            unlink: vi.fn(),
-            spawn: vi.fn(),
-            free: vi.fn(),
-            activeCount: 0,
-            world: { classname: 'worldspawn' } as any,
-        } as any,
-        multicast: vi.fn(),
-        unicast: vi.fn(),
-        configstring: vi.fn(),
-        serverCommand: vi.fn(),
-        sound: vi.fn(),
-        soundIndex: vi.fn(),
-        centerprintf: vi.fn(),
-        trace: vi.fn(),
-        time: 0,
-        deathmatch: false,
-        skill: 1,
-        rogue: false,
-        xatrix: false,
-        coop: false,
-        friendlyFire: false,
-        random: {
-             next: vi.fn(),
-             nextFloat: vi.fn(),
-             range: vi.fn(),
-             crandom: vi.fn(),
-             getState: vi.fn(),
-             setState: vi.fn()
-        } as any,
-        createSave: vi.fn(),
-        loadSave: vi.fn(),
-        serialize: vi.fn(),
-        loadState: vi.fn(),
-        setGodMode: vi.fn(),
-        setNoclip: vi.fn(),
-        setNotarget: vi.fn(),
-        giveItem: vi.fn(),
-        damage: vi.fn(),
-        teleport: vi.fn(),
-        registerHooks: vi.fn(),
-        hooks: {
-            onMapLoad: vi.fn(),
-            onMapUnload: vi.fn(),
-            onPlayerSpawn: vi.fn(),
-            onPlayerDeath: vi.fn(),
-            register: vi.fn(),
-            onPickup: vi.fn(), // Added onPickup mock
-        } as any,
-        setSpectator: vi.fn(),
-        registerEntitySpawn: vi.fn(),
-        unregisterEntitySpawn: vi.fn(),
-        getCustomEntities: vi.fn(),
-        ...overrides
-    };
-}