quake2ts 0.0.563 → 0.0.565

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

@@ -30,6 +30,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  HandshakeStage: () => HandshakeStage,
   InputInjector: () => InputInjector,
   MockPointerLock: () => MockPointerLock,
   MockTransport: () => MockTransport,
@@ -42,15 +43,18 @@ __export(index_exports, {
   createBinaryWriterMock: () => createBinaryWriterMock,
   createControlledTimer: () => createControlledTimer,
   createCustomNetworkCondition: () => createCustomNetworkCondition,
+  createDeltaSnapshot: () => createDeltaSnapshot,
   createEntity: () => createEntity,
   createEntityStateFactory: () => createEntityStateFactory,
   createGameStateSnapshotFactory: () => createGameStateSnapshotFactory,
   createMockAudioContext: () => createMockAudioContext,
   createMockCanvas: () => createMockCanvas,
   createMockCanvasContext2D: () => createMockCanvasContext2D,
+  createMockConnection: () => createMockConnection,
   createMockEngine: () => createMockEngine,
   createMockGame: () => createMockGame,
   createMockGameState: () => createMockGameState,
+  createMockHandshake: () => createMockHandshake,
   createMockImage: () => createMockImage,
   createMockImageData: () => createMockImageData,
   createMockIndexedDB: () => createMockIndexedDB,
@@ -65,10 +69,13 @@ __export(index_exports, {
   createMockSessionStorage: () => createMockSessionStorage,
   createMockTransport: () => createMockTransport,
   createMockUDPSocket: () => createMockUDPSocket,
+  createMockUserInfo: () => createMockUserInfo,
   createMockWebGL2Context: () => createMockWebGL2Context,
+  createMultiplayerTestScenario: () => createMultiplayerTestScenario,
   createNetChanMock: () => createNetChanMock,
   createPlayerStateFactory: () => createPlayerStateFactory,
   createPlaywrightTestClient: () => createPlaywrightTestClient,
+  createServerSnapshot: () => createServerSnapshot,
   createSpawnContext: () => createSpawnContext,
   createStorageTestScenario: () => createStorageTestScenario,
   createTestContext: () => createTestContext,
@@ -82,16 +89,24 @@ __export(index_exports, {
   makeLeafModel: () => makeLeafModel,
   makeNode: () => makeNode,
   makePlane: () => makePlane,
+  serializeUserInfo: () => serializeUserInfo,
   setupBrowserEnvironment: () => setupBrowserEnvironment,
   setupMockAudioContext: () => setupMockAudioContext,
   setupNodeEnvironment: () => setupNodeEnvironment,
   simulateFrames: () => simulateFrames,
   simulateFramesWithMock: () => simulateFramesWithMock,
+  simulateHandshake: () => simulateHandshake,
   simulateNetworkCondition: () => simulateNetworkCondition,
+  simulatePlayerInput: () => simulatePlayerInput,
+  simulatePlayerJoin: () => simulatePlayerJoin,
+  simulatePlayerLeave: () => simulatePlayerLeave,
+  simulateServerTick: () => simulateServerTick,
+  simulateSnapshotDelivery: () => simulateSnapshotDelivery,
   stairTrace: () => import_shared3.stairTrace,
   teardownBrowserEnvironment: () => teardownBrowserEnvironment,
   teardownMockAudioContext: () => teardownMockAudioContext,
   throttleBandwidth: () => throttleBandwidth,
+  verifySnapshotConsistency: () => verifySnapshotConsistency,
   waitForGameReady: () => waitForGameReady
 });
 module.exports = __toCommonJS(index_exports);
@@ -698,6 +713,214 @@ function createMockServer(overrides) {
   };
 }
 
+// src/server/mocks/connection.ts
+var import_server2 = require("@quake2ts/server");
+var HandshakeStage = /* @__PURE__ */ ((HandshakeStage2) => {
+  HandshakeStage2[HandshakeStage2["None"] = 0] = "None";
+  HandshakeStage2[HandshakeStage2["Challenge"] = 1] = "Challenge";
+  HandshakeStage2[HandshakeStage2["Connect"] = 2] = "Connect";
+  HandshakeStage2[HandshakeStage2["Info"] = 3] = "Info";
+  HandshakeStage2[HandshakeStage2["Active"] = 4] = "Active";
+  return HandshakeStage2;
+})(HandshakeStage || {});
+function serializeUserInfo(info) {
+  return Object.entries(info).reduce((acc, [key, value]) => {
+    if (value !== void 0) {
+      return `${acc}\\${key}\\${value}`;
+    }
+    return acc;
+  }, "");
+}
+function createMockUserInfo(overrides) {
+  return {
+    name: "Player",
+    skin: "male/grunt",
+    model: "male/grunt",
+    fov: 90,
+    hand: 0,
+    rate: 25e3,
+    msg: 1,
+    ...overrides
+  };
+}
+function createMockConnection(state = import_server2.ClientState.Connected, overrides) {
+  return createMockServerClient(0, {
+    state,
+    userInfo: serializeUserInfo(createMockUserInfo()),
+    challenge: Math.floor(Math.random() * 1e5),
+    ...overrides
+  });
+}
+function createMockHandshake(stage = 0 /* None */) {
+  return {
+    stage,
+    clientNum: -1,
+    challenge: 0,
+    qport: Math.floor(Math.random() * 65536)
+  };
+}
+async function simulateHandshake(client, server) {
+  const challenge = Math.floor(Math.random() * 1e5);
+  client.challenge = challenge;
+  if (server && server.clients) {
+  }
+  client.state = import_server2.ClientState.Connected;
+  client.state = import_server2.ClientState.Active;
+  return true;
+}
+
+// src/server/helpers/multiplayer.ts
+var import_server3 = require("@quake2ts/server");
+function createMultiplayerTestScenario(numPlayers = 2) {
+  const baseServer = createMockServerState();
+  const clients = [];
+  const entities = [];
+  const server = {
+    ...baseServer,
+    clients: new Array(numPlayers).fill(null),
+    entities: []
+  };
+  for (let i = 0; i < numPlayers; i++) {
+    const client = createMockServerClient(i, {
+      state: import_server3.ClientState.Active,
+      userInfo: serializeUserInfo(createMockUserInfo({ name: `Player${i}` }))
+    });
+    const entity = {
+      classname: "player",
+      s: { origin: { x: 0, y: 0, z: 0 }, number: i + 1 },
+      client
+    };
+    client.edict = entity;
+    server.clients[i] = client;
+    clients.push(client);
+    entities.push(entity);
+  }
+  server.entities = entities;
+  return {
+    server,
+    clients,
+    entities
+  };
+}
+async function simulatePlayerJoin(server, userInfo) {
+  const index = server.clients.findIndex((c) => !c || c.state === import_server3.ClientState.Free);
+  if (index === -1) {
+    throw new Error("Server full");
+  }
+  const client = createMockServerClient(index, {
+    state: import_server3.ClientState.Connected,
+    userInfo: serializeUserInfo(createMockUserInfo(userInfo))
+  });
+  server.clients[index] = client;
+  client.state = import_server3.ClientState.Active;
+  const entity = {
+    classname: "player",
+    s: { origin: { x: 0, y: 0, z: 0 }, number: index + 1 },
+    client
+  };
+  client.edict = entity;
+  if (server.entities && Array.isArray(server.entities)) {
+    server.entities[index + 1] = entity;
+  }
+  return client;
+}
+function simulatePlayerLeave(server, clientNum) {
+  const client = server.clients[clientNum];
+  if (client) {
+    client.state = import_server3.ClientState.Free;
+    client.edict = null;
+  }
+}
+function simulateServerTick(server, deltaTime = 0.1) {
+  server.time += deltaTime;
+  server.frame++;
+  server.clients.forEach((client) => {
+    if (client && client.state === import_server3.ClientState.Active) {
+    }
+  });
+}
+function simulatePlayerInput(client, input) {
+  const cmd = {
+    msec: 100,
+    buttons: 0,
+    angles: { x: 0, y: 0, z: 0 },
+    forwardmove: 0,
+    sidemove: 0,
+    upmove: 0,
+    sequence: client.lastCmd.sequence + 1,
+    lightlevel: 0,
+    impulse: 0,
+    ...input
+  };
+  client.lastCmd = cmd;
+  client.commandQueue.push(cmd);
+  client.commandCount++;
+}
+
+// src/server/helpers/snapshot.ts
+function createServerSnapshot(serverState, clientNum) {
+  const visibleEntities = [];
+  if (serverState.baselines) {
+    serverState.baselines.forEach((ent, index) => {
+      if (ent && index !== clientNum + 1) {
+        visibleEntities.push({ ...ent });
+      }
+    });
+  }
+  return {
+    serverTime: serverState.time,
+    playerState: {
+      origin: { x: 0, y: 0, z: 0 },
+      viewangles: { x: 0, y: 0, z: 0 },
+      pm_type: 0
+    },
+    entities: visibleEntities
+  };
+}
+function createDeltaSnapshot(oldSnapshot, newSnapshot) {
+  const deltaEntities = [];
+  const removedEntities = [];
+  const oldMap = new Map(oldSnapshot.entities.map((e) => [e.number, e]));
+  const newMap = new Map(newSnapshot.entities.map((e) => [e.number, e]));
+  newSnapshot.entities.forEach((newEnt) => {
+    const oldEnt = oldMap.get(newEnt.number);
+    if (!oldEnt) {
+      deltaEntities.push(newEnt);
+    } else if (JSON.stringify(newEnt) !== JSON.stringify(oldEnt)) {
+      deltaEntities.push(newEnt);
+    }
+  });
+  oldSnapshot.entities.forEach((oldEnt) => {
+    if (!newMap.has(oldEnt.number)) {
+      removedEntities.push(oldEnt.number);
+    }
+  });
+  return {
+    snapshot: newSnapshot,
+    deltaEntities,
+    removedEntities
+  };
+}
+function verifySnapshotConsistency(snapshots) {
+  const report = { valid: true, errors: [] };
+  if (snapshots.length < 2) return report;
+  for (let i = 1; i < snapshots.length; i++) {
+    const prev = snapshots[i - 1];
+    const curr = snapshots[i];
+    if (curr.serverTime <= prev.serverTime) {
+      report.valid = false;
+      report.errors.push(`Snapshot ${i} has time ${curr.serverTime} <= prev ${prev.serverTime}`);
+    }
+  }
+  return report;
+}
+async function simulateSnapshotDelivery(snapshot, reliability = 1) {
+  if (Math.random() > reliability) {
+    return null;
+  }
+  return snapshot;
+}
+
 // src/setup/browser.ts
 var import_jsdom = require("jsdom");
 var import_canvas = require("@napi-rs/canvas");
@@ -1764,6 +1987,7 @@ function createVisualTestScenario(page, sceneName) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  HandshakeStage,
   InputInjector,
   MockPointerLock,
   MockTransport,
@@ -1776,15 +2000,18 @@ function createVisualTestScenario(page, sceneName) {
   createBinaryWriterMock,
   createControlledTimer,
   createCustomNetworkCondition,
+  createDeltaSnapshot,
   createEntity,
   createEntityStateFactory,
   createGameStateSnapshotFactory,
   createMockAudioContext,
   createMockCanvas,
   createMockCanvasContext2D,
+  createMockConnection,
   createMockEngine,
   createMockGame,
   createMockGameState,
+  createMockHandshake,
   createMockImage,
   createMockImageData,
   createMockIndexedDB,
@@ -1799,10 +2026,13 @@ function createVisualTestScenario(page, sceneName) {
   createMockSessionStorage,
   createMockTransport,
   createMockUDPSocket,
+  createMockUserInfo,
   createMockWebGL2Context,
+  createMultiplayerTestScenario,
   createNetChanMock,
   createPlayerStateFactory,
   createPlaywrightTestClient,
+  createServerSnapshot,
   createSpawnContext,
   createStorageTestScenario,
   createTestContext,
@@ -1816,16 +2046,24 @@ function createVisualTestScenario(page, sceneName) {
   makeLeafModel,
   makeNode,
   makePlane,
+  serializeUserInfo,
   setupBrowserEnvironment,
   setupMockAudioContext,
   setupNodeEnvironment,
   simulateFrames,
   simulateFramesWithMock,
+  simulateHandshake,
   simulateNetworkCondition,
+  simulatePlayerInput,
+  simulatePlayerJoin,
+  simulatePlayerLeave,
+  simulateServerTick,
+  simulateSnapshotDelivery,
   stairTrace,
   teardownBrowserEnvironment,
   teardownMockAudioContext,
   throttleBandwidth,
+  verifySnapshotConsistency,
   waitForGameReady
 });
 //# sourceMappingURL=index.cjs.map