@rpgjs/server 5.0.0-alpha.4 → 5.0.0-alpha.41

package/tests/prediction-reconciliation.spec.ts

@@ -0,0 +1,182 @@
+import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
+import { testing, type TestingFixture } from "@rpgjs/testing";
+import { createModule, defineModule, Direction } from "@rpgjs/common";
+import { RpgPlayer, RpgServer } from "../src";
+
+const serverModule = defineModule<RpgServer>({
+  maps: [
+    {
+      id: "test-map",
+      file: "",
+    },
+  ],
+  player: {
+    async onConnected(player) {
+      await player.changeMap("test-map", { x: 100, y: 100 });
+    },
+  },
+});
+
+let fixture: TestingFixture;
+let client: any;
+let player: RpgPlayer;
+let serverMap: any;
+
+beforeEach(async () => {
+  const module = createModule("PredictionServerModule", [
+    {
+      server: serverModule,
+    },
+  ]);
+  fixture = await testing(module);
+  client = await fixture.createClient();
+  player = await client.waitForMapChange("test-map");
+  serverMap = fixture.server.subRoom as any;
+});
+
+afterEach(async () => {
+  await fixture.clear();
+});
+
+describe("Prediction + Reconciliation Server Protocol", () => {
+  test("should reply pong with server tick", () => {
+    const emitSpy = vi.spyOn(player, "emit");
+    const payload = {
+      clientTime: 1234,
+      clientFrame: 42,
+    };
+
+    serverMap.onPing(player, payload);
+
+    expect(emitSpy).toHaveBeenCalledWith(
+      "pong",
+      expect.objectContaining({
+        clientTime: payload.clientTime,
+        clientFrame: payload.clientFrame,
+        serverTick: serverMap.getTick(),
+      }),
+    );
+  });
+
+  test("should include authoritative ack metadata in sync interceptor", async () => {
+    const frame = 7;
+    await serverMap.onInput(player, {
+      input: Direction.Right,
+      frame,
+      tick: 0,
+      timestamp: Date.now(),
+    });
+    await serverMap.processInput(player.id);
+
+    const intercepted = serverMap.interceptorPacket(
+      player,
+      { type: "sync", value: {} },
+      player.conn,
+    );
+
+    expect(intercepted?.value?.ack).toEqual(
+      expect.objectContaining({
+        frame,
+        serverTick: expect.any(Number),
+        x: expect.any(Number),
+        y: expect.any(Number),
+        direction: expect.any(String),
+      }),
+    );
+  });
+
+  test("should align ack position with the synced local player payload when available", () => {
+    player._lastFramePositions = {
+      frame: 21,
+      position: {
+        x: 0,
+        y: 0,
+        direction: Direction.Down,
+      },
+      serverTick: 1,
+    };
+
+    const intercepted = serverMap.interceptorPacket(
+      player,
+      {
+        type: "sync",
+        value: {
+          players: {
+            [player.id]: {
+              x: 321,
+              y: 45,
+              direction: Direction.Left,
+            },
+          },
+        },
+      },
+      player.conn,
+    );
+
+    expect(intercepted?.value?.ack).toEqual(
+      expect.objectContaining({
+        frame: 21,
+        x: 321,
+        y: 45,
+        direction: Direction.Left,
+        serverTick: serverMap.getTick(),
+      }),
+    );
+  });
+
+  test("should queue trajectory frames and replay them progressively on server ticks", async () => {
+    const baseTs = Date.now();
+    await serverMap.onInput(player, {
+      input: Direction.Right,
+      frame: 3,
+      tick: 3,
+      timestamp: baseTs + 32,
+      trajectory: [
+        {
+          input: Direction.Right,
+          frame: 1,
+          tick: 1,
+          timestamp: baseTs,
+          x: 101,
+          y: 100,
+          direction: Direction.Right,
+        },
+        {
+          input: Direction.Right,
+          frame: 2,
+          tick: 2,
+          timestamp: baseTs + 16,
+          x: 102,
+          y: 100,
+          direction: Direction.Right,
+        },
+        {
+          input: Direction.Right,
+          frame: 3,
+          tick: 3,
+          timestamp: baseTs + 32,
+          x: 103,
+          y: 100,
+          direction: Direction.Right,
+        },
+      ],
+    });
+
+    expect(player.pendingInputs.map((entry: any) => entry.frame)).toEqual([1, 2, 3]);
+
+    await serverMap.processInput(player.id);
+    expect(player._lastFramePositions?.frame).toBe(1);
+    expect(player._lastFramePositions?.position?.x).toBe(101);
+    expect(player.pendingInputs.map((entry: any) => entry.frame)).toEqual([2, 3]);
+
+    await serverMap.processInput(player.id);
+    expect(player._lastFramePositions?.frame).toBe(2);
+    expect(player._lastFramePositions?.position?.x).toBe(102);
+    expect(player.pendingInputs.map((entry: any) => entry.frame)).toEqual([3]);
+
+    await serverMap.processInput(player.id);
+    expect(player._lastFramePositions?.frame).toBe(3);
+    expect(player._lastFramePositions?.position?.x).toBe(103);
+    expect(player.pendingInputs).toHaveLength(0);
+  });
+});

package/tests/random-move.spec.ts

@@ -0,0 +1,65 @@
+
+import { test, expect, describe, vi } from "vitest";
+import { Direction } from "@rpgjs/common";
+import { Move } from "../src/Player/MoveManager";
+
+describe("Improved Random Movement Unit Tests", () => {
+    test("Move.random(repeat) should return array of identical directions", () => {
+        // Mock Math.random to return a fixed value
+        const randomSpy = vi.spyOn(Math, 'random').mockReturnValue(0.1); // Should map to index 0 (Right)
+
+        const directions = Move.random(5);
+
+        expect(directions).toHaveLength(5);
+        expect(directions.every(d => d === Direction.Right)).toBe(true);
+
+        randomSpy.mockRestore();
+    });
+
+    test("Move.random(repeat) should produce different directions with different random values", () => {
+        const randomSpy = vi.spyOn(Math, 'random');
+
+        randomSpy.mockReturnValue(0.1); // Right
+        const rightDirs = Move.random(1);
+        expect(rightDirs[0]).toBe(Direction.Right);
+
+        randomSpy.mockReturnValue(0.3); // Left
+        const leftDirs = Move.random(1);
+        expect(leftDirs[0]).toBe(Direction.Left);
+
+        randomSpy.mockReturnValue(0.6); // Up
+        const upDirs = Move.random(1);
+        expect(upDirs[0]).toBe(Direction.Up);
+
+        randomSpy.mockReturnValue(0.9); // Down
+        const downDirs = Move.random(1);
+        expect(downDirs[0]).toBe(Direction.Down);
+
+        randomSpy.mockRestore();
+    });
+
+    test("Move.tileRandom(repeat) should return consistent direction for tiles", () => {
+        // Mock Math.random to return a fixed value
+        const randomSpy = vi.spyOn(Math, 'random').mockReturnValue(0.1); // Should map to index 0 (Right)
+
+        const mockPlayer = {
+            speed: 3
+        } as any;
+
+        const mockMap = {
+            tileWidth: 32,
+            tileHeight: 32
+        } as any;
+
+        const callback = Move.tileRandom(3);
+        const directions = callback(mockPlayer, mockMap);
+
+        // repeatTile = Math.floor(32 / 3) * 3 = 10 * 3 = 30
+        // So we expect 30 directions, all Right
+
+        expect(directions.length).toBe(30);
+        expect(directions.every(d => d === Direction.Right)).toBe(true);
+
+        randomSpy.mockRestore();
+    });
+});