@rpgjs/server 5.0.0-alpha.9 → 5.0.0-beta.1

package/tests/node-transport.spec.ts

@@ -0,0 +1,223 @@
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { RpgServerEngine } from "../src/RpgServerEngine";
+import {
+  MAP_UPDATE_TOKEN_ENV,
+  PartyConnection,
+  createRpgServerTransport,
+} from "../src/node";
+
+function wait(ms = 0): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+class MockWebSocket {
+  readyState = 1;
+  sent: string[] = [];
+  private handlers = new Map<string, Array<(...args: any[]) => void>>();
+
+  send(data: string): void {
+    this.sent.push(data);
+  }
+
+  close(): void {
+    this.readyState = 3;
+    this.emit("close");
+  }
+
+  on(event: string, callback: (...args: any[]) => void): void {
+    const listeners = this.handlers.get(event) || [];
+    listeners.push(callback);
+    this.handlers.set(event, listeners);
+  }
+
+  emit(event: string, ...args: any[]): void {
+    for (const callback of this.handlers.get(event) || []) {
+      callback(...args);
+    }
+  }
+}
+
+class MockServer extends RpgServerEngine {
+  requests: Array<{ method: string; roomId: string; url: string; body: any }> = [];
+  messages: Array<{ connectionId: string; message: string }> = [];
+  closedConnections: string[] = [];
+  connectedContexts: Array<{ connectionId: string; url: string }> = [];
+
+  constructor(public room: any) {
+    super();
+  }
+
+  async onRequest(req: any) {
+    let body: any;
+    try {
+      body = await req.json();
+    } catch {
+      body = await req.text();
+    }
+    this.requests.push({
+      method: req.method,
+      roomId: this.room.id,
+      url: req.url,
+      body,
+    });
+
+    return {
+      method: req.method,
+      roomId: this.room.id,
+      url: req.url,
+      body,
+    };
+  }
+
+  async onMessage(message: string, connection: any) {
+    this.messages.push({
+      connectionId: connection.id,
+      message,
+    });
+  }
+
+  async onConnect(connection: any, context: any) {
+    this.connectedContexts.push({
+      connectionId: connection.id,
+      url: context.request.url,
+    });
+  }
+
+  async onClose(connection: any) {
+    this.closedConnections.push(connection.id);
+  }
+}
+
+class RealServer extends RpgServerEngine {}
+
+describe("createRpgServerTransport", () => {
+  const originalMapUpdateToken = process.env[MAP_UPDATE_TOKEN_ENV];
+
+  beforeEach(() => {
+    PartyConnection.configurePacketLoss(false, 0);
+    PartyConnection.configureBandwidth(false, 100);
+    PartyConnection.configureLatency(false, 0);
+    delete process.env[MAP_UPDATE_TOKEN_ENV];
+  });
+
+  afterEach(() => {
+    if (typeof originalMapUpdateToken === "string") {
+      process.env[MAP_UPDATE_TOKEN_ENV] = originalMapUpdateToken;
+      return;
+    }
+    delete process.env[MAP_UPDATE_TOKEN_ENV];
+  });
+
+  it("handles fetch-style HTTP requests without Vite", async () => {
+    const transport = createRpgServerTransport(MockServer as any, {
+      initializeMaps: false,
+    });
+
+    const response = await transport.fetch("http://localhost/parties/main/lobby/echo?foo=bar", {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+      },
+      body: JSON.stringify({ hello: "world" }),
+    });
+
+    expect(response.status).toBe(200);
+    expect(await response.json()).toEqual({
+      method: "POST",
+      roomId: "lobby",
+      url: "http://localhost/parties/main/lobby/echo?foo=bar",
+      body: { hello: "world" },
+    });
+  });
+
+  it("handles websocket connections without the Vite wrapper", async () => {
+    const transport = createRpgServerTransport(MockServer as any, {
+      initializeMaps: false,
+    });
+    const ws = new MockWebSocket();
+
+    const handled = await transport.acceptWebSocket(ws as any, {
+      url: "http://localhost/parties/main/lobby?_pk=player-1",
+      method: "GET",
+      headers: {
+        host: "localhost",
+      },
+    });
+
+    expect(handled).toBe(true);
+
+    await wait(10);
+
+    const server = transport.getServer("lobby") as MockServer;
+    expect(server.connectedContexts).toEqual([
+      {
+        connectionId: "player-1",
+        url: "http://localhost/parties/main/lobby?_pk=player-1",
+      },
+    ]);
+    expect(JSON.parse(ws.sent[0])).toMatchObject({
+      type: "connected",
+      id: "player-1",
+    });
+
+    ws.emit("message", Buffer.from("ping"));
+    await wait(10);
+
+    expect(server.messages).toEqual([
+      {
+        connectionId: "player-1",
+        message: "ping",
+      },
+    ]);
+
+    ws.emit("close");
+    await wait(10);
+
+    expect(server.closedConnections).toEqual(["player-1"]);
+  });
+
+  it("rejects map/update in production when the token is missing", async () => {
+    process.env[MAP_UPDATE_TOKEN_ENV] = "prod-secret";
+
+    const transport = createRpgServerTransport(RealServer as any, {
+      initializeMaps: false,
+    });
+
+    const response = await transport.fetch("http://localhost/parties/main/map-town/map/update", {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+      },
+      body: JSON.stringify({
+        id: "town",
+        width: 320,
+        height: 240,
+        events: [],
+      }),
+    });
+
+    expect(response.status).toBe(401);
+    expect(await response.json()).toMatchObject({
+      error: "Unauthorized map update",
+    });
+  });
+
+  it("sends the configured token when transport.updateMap() is used", async () => {
+    process.env[MAP_UPDATE_TOKEN_ENV] = "prod-secret";
+
+    const transport = createRpgServerTransport(RealServer as any, {
+      initializeMaps: false,
+      mapUpdateToken: "prod-secret",
+    });
+
+    const response = await transport.updateMap("town", {
+      id: "town",
+      width: 320,
+      height: 240,
+      events: [],
+    });
+
+    expect(response.status).toBe(200);
+    expect(response.headers.get("content-type")).toContain("application/json");
+  });
+});

package/tests/player-param.spec.ts

@@ -0,0 +1,45 @@
+
+import { testing } from '@rpgjs/testing'
+import { beforeEach, describe, expect, test, vi } from 'vitest'
+import { ATK, MAXHP, MAXHP_CURVE, MAXSP, MAXSP_CURVE, RpgPlayer } from '../src'
+
+let player: RpgPlayer
+
+beforeEach(async () => {
+   const fixture = await testing();  
+   const client = await fixture.createClient()
+   player = client.player
+   player.initializeDefaultStats()
+})
+
+test('Test HP', () => {
+   expect(player.hp).toBe(MAXHP_CURVE.start)
+})
+
+test('Test SP', () => {
+   expect(player.sp).toBe(MAXSP_CURVE.start)
+})
+
+test('Test MaxHP', () => {
+   expect(player.param[MAXHP]).toBe(MAXHP_CURVE.start)
+})
+
+test('Test MaxSP', () => {
+   expect(player.param[MAXSP]).toBe(MAXSP_CURVE.start)
+})
+
+test('Set fixed parameter value', () => {
+   player.setParameter(MAXHP, 1000)
+   player.setParameter(MAXSP, 250)
+
+   expect(player.param[MAXHP]).toBe(1000)
+   expect(player.param[MAXSP]).toBe(250)
+})
+
+test('Allow direct param assignment for fixed values', () => {
+   player.param[MAXHP] = 900
+   player.param[MAXSP] = 120
+
+   expect(player.param[MAXHP]).toBe(900)
+   expect(player.param[MAXSP]).toBe(120)
+})

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();
+    });
+});