@rpgjs/server 5.0.0-alpha.32 → 5.0.0-alpha.35

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/world-maps.spec.ts

@@ -410,6 +410,47 @@ describe('Map WorldMapsManager Integration', () => {
     expect(worldX2).toBe(1074)
     expect(worldY2).toBe(100)
   })
+
+  test('should keep movement sync after returning to initial map', async () => {
+    player = await client.waitForMapChange('map1')
+
+    await player.changeMap('map2', { x: 50, y: 100 })
+    player = await client.waitForMapChange('map2')
+    expect(player.getCurrentMap()?.id).toBe('map2')
+
+    await player.changeMap('map1', { x: 100, y: 100 })
+    player = await client.waitForMapChange('map1')
+    const map = player.getCurrentMap()
+    expect(map?.id).toBe('map1')
+
+    const beforeX = player.x()
+    await map?.movePlayer(player as any, Direction.Right)
+    map?.nextTick(16)
+    await new Promise(resolve => setTimeout(resolve, 10))
+
+    expect(player.x()).toBeGreaterThan(beforeX)
+  })
+
+  test('should keep restored player position after loadPhysic rebuild', async () => {
+    player = await client.waitForMapChange('map1')
+    const map = player.getCurrentMap()
+    expect(map).toBeDefined()
+
+    await player.teleport({ x: 0, y: 0 })
+    map?.loadPhysic()
+
+    // Simulate a late position restore (e.g. session transfer snapshot hydration).
+    player.x.set(100)
+    player.y.set(100)
+    await new Promise(resolve => setTimeout(resolve, 10))
+
+    const topLeft = map?.getBodyPosition(player.id, 'top-left')
+    expect(topLeft).toBeDefined()
+    expect(Math.round(topLeft!.x)).toBe(100)
+    expect(Math.round(topLeft!.y)).toBe(100)
+    expect(player.x()).toBe(100)
+    expect(player.y()).toBe(100)
+  })
 })
 
 /**
@@ -588,6 +629,47 @@ describe('Automatic Map Change on Border Touch', () => {
     }
   })
 
+  test('should not immediately bounce back after returning from adjacent map', async () => {
+    player = await client.waitForMapChange('map1')
+    await player.autoChangeMap({ x: 513, y: 384 }, Direction.Right)
+
+    const hitbox = player.hitbox()
+    const marginTopDown = 16 // tileHeight / 2
+    const topBorderY = marginTopDown - 1
+
+    player.changeDirection(Direction.Up)
+    await player.teleport({ x: 512, y: topBorderY })
+    const movedUp = await player.autoChangeMap({ x: 512, y: topBorderY - 1 }, Direction.Up)
+    expect(movedUp).toBe(true)
+
+    player = await client.waitForMapChange('map4')
+    expect(player.getCurrentMap()?.id).toBe('map4')
+
+    const map4 = player.getCurrentMap()
+    const bottomBorderY = (map4?.heightPx ?? 768) - hitbox.h - marginTopDown + 1
+
+    player.changeDirection(Direction.Down)
+    await player.teleport({ x: 512, y: bottomBorderY })
+    // First downward move after return should be blocked to avoid ping-pong map swaps.
+    const firstDownAttempt = await player.autoChangeMap({ x: 512, y: bottomBorderY + 1 }, Direction.Down)
+    expect(firstDownAttempt).toBe(false)
+
+    // Move away from border to unlock transitions, then touch border again.
+    await player.teleport({ x: 512, y: 384 })
+    player.changeDirection(Direction.Up)
+    await player.autoChangeMap({ x: 512, y: 383 }, Direction.Up)
+
+    const mapAfterUnlock = player.getCurrentMap()
+    const downBorderY = (mapAfterUnlock?.heightPx ?? 768) - hitbox.h - marginTopDown + 1
+    await player.teleport({ x: 512, y: downBorderY })
+    player.changeDirection(Direction.Down)
+    const movedDown = await player.autoChangeMap({ x: 512, y: downBorderY + 1 }, Direction.Down)
+    expect(movedDown).toBe(true)
+
+    player = await client.waitForMapChange('map1')
+    expect(player.getCurrentMap()?.id).toBe('map1')
+  })
+
   test('should not change map when player is not at border', async () => {
     player = await client.waitForMapChange('map1')
     const initialMapId = player.getCurrentMap()?.id
@@ -811,4 +893,4 @@ describe('Automatic Map Change with Non-Adjacent Maps', () => {
     expect(map2Info).toBeDefined()
     expect(map2Info?.worldX).toBe(1025) // Gap exists
   })
-})
+})