@rpgjs/server 5.0.0-beta.5 → 5.0.0-beta.6

package/dist/node/index.js

@@ -1,4 +1,4 @@
-import { a as isMapUpdateAuthorized, c as updateMap, h as injector, i as createMapUpdateHeaders, l as context, n as MAP_UPDATE_TOKEN_ENV, o as readMapUpdateToken, p as setInject, r as MAP_UPDATE_TOKEN_HEADER, s as resolveMapUpdateToken, t as provideServerModules } from "../module-BmvXIvlE.js";
+import { a as isMapUpdateAuthorized, c as updateMap, h as injector, i as createMapUpdateHeaders, l as context, n as MAP_UPDATE_TOKEN_ENV, o as readMapUpdateToken, p as setInject, r as MAP_UPDATE_TOKEN_HEADER, s as resolveMapUpdateToken, t as provideServerModules } from "../module-Dy124Jyk.js";
 //#region src/node/connection.ts
 function readEnvVariable(name) {
 	const value = globalThis.process?.env?.[name];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rpgjs/server",
-  "version": "5.0.0-beta.5",
+  "version": "5.0.0-beta.6",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "exports": {
@@ -22,9 +22,9 @@
   "description": "",
   "dependencies": {
     "@canvasengine/tiled": "2.0.0-beta.58",
-    "@rpgjs/common": "5.0.0-beta.5",
-    "@rpgjs/physic": "5.0.0-beta.5",
-    "@rpgjs/testing": "5.0.0-beta.5",
+    "@rpgjs/common": "5.0.0-beta.6",
+    "@rpgjs/physic": "5.0.0-beta.6",
+    "@rpgjs/testing": "5.0.0-beta.6",
     "@rpgjs/database": "^4.3.0",
     "@signe/di": "^2.9.0",
     "@signe/reactive": "^2.9.0",

package/src/Player/Player.ts

@@ -461,7 +461,7 @@ export class RpgPlayer extends BasicPlayerMixins(RpgCommonPlayer) {
         const centerX = positions.x + width / 2;
         const centerY = positions.y + height / 2;
         
-        this.map.physic.teleport(entity, { x: centerX, y: centerY });
+        this.map.physic.teleportEntity(entity, { x: centerX, y: centerY });
       }
     }
     this.x.set(positions.x)

package/src/rooms/map.ts

@@ -24,7 +24,6 @@ import { Subject } from "rxjs";
 import { BehaviorSubject } from "rxjs";
 import { COEFFICIENT_ELEMENTS, DAMAGE_CRITICAL, DAMAGE_PHYSIC, DAMAGE_SKILL } from "../presets";
 import { z } from "zod";
-import { EntityState } from "@rpgjs/physic";
 import { MapOptions } from "../decorators/map";
 import { EventMode } from "../decorators/event";
 import { BaseRoom } from "./BaseRoom";
@@ -1054,10 +1053,20 @@ export class RpgMap extends RpgCommonMap<RpgPlayer> implements RoomOnJoin {
    */
   @Action('action')
   onAction(player: RpgPlayer, action: any) {
-    // Get collisions using the helper method from RpgCommonMap
-    const collisions = (this as any).getCollisions(player.id);
-    const events = collisions
-      .map(id => this.getEvent(id))
+    const direction =
+      typeof player.getDirection === "function"
+        ? player.getDirection()
+        : typeof player.direction === "function"
+          ? player.direction()
+          : undefined;
+    const collisions = new Set<string>((this as any).getCollisions(player.id));
+    const interactionCollisions = (this as any).getInteractionCollisions?.(player.id, direction);
+    if (Array.isArray(interactionCollisions)) {
+      interactionCollisions.forEach(id => collisions.add(id));
+    }
+
+    const events = Array.from(collisions)
+      .map(id => this.getEvent<RpgEvent>(id))
       .filter((event): event is RpgEvent => !!event && this.isEventVisibleForPlayer(event, player));
     if (events.length > 0) {
       events.forEach(event => {
@@ -2500,18 +2509,15 @@ export class RpgMap extends RpgCommonMap<RpgPlayer> implements RoomOnJoin {
     const centerX = x + width / 2;
     const centerY = y + height / 2;
 
-    // Create static entity (hitbox) in physics engine
+    // Create static obstacle in physics engine
     const entityId = `shape-${name}`;
-    const entity = this.physic.createEntity({
-      uuid: entityId,
-      position: { x: centerX, y: centerY },
-      width: width,
-      height: height,
-      mass: Infinity, // Static entity
-      state: EntityState.Static,
-      restitution: 0, // No bounce
+    this.physic.createStaticObstacle(entityId, {
+      x: centerX,
+      y: centerY,
+      width,
+      height,
+      restitution: 0,
     });
-    entity.freeze(); // Ensure it's frozen
 
     // Build properties object
     const properties: Record<string, any> = {

package/tests/action-interaction.spec.ts

@@ -0,0 +1,97 @@
+import { afterEach, beforeEach, describe, expect, test } from "vitest";
+import { testing, TestingFixture } from "@rpgjs/testing";
+import { Control, createModule, defineModule, Direction } from "@rpgjs/common";
+import { RpgClient } from "../../client/src";
+import { RpgPlayer, RpgServer } from "../src";
+
+let actionCount = 0;
+
+const serverModule = defineModule<RpgServer>({
+  maps: [
+    {
+      id: "interaction-map",
+      file: "",
+    },
+  ],
+  player: {
+    async onConnected(player) {
+      await player.changeMap("interaction-map", { x: 100, y: 100 });
+    },
+  },
+});
+
+const clientModule = defineModule<RpgClient>({});
+
+let fixture: TestingFixture;
+let client: any;
+let player: RpgPlayer;
+
+beforeEach(async () => {
+  actionCount = 0;
+  const myModule = createModule("ActionInteractionTestModule", [
+    {
+      server: serverModule,
+      client: clientModule,
+    },
+  ]);
+
+  fixture = await testing(myModule);
+  client = await fixture.createClient();
+  player = await client.waitForMapChange("interaction-map");
+});
+
+afterEach(async () => {
+  await fixture.clear();
+});
+
+describe("Action interactions", () => {
+  test("triggers onAction for an event just in front of the player", async () => {
+    const map = player.getCurrentMap() as any;
+    const hitbox = player.hitbox();
+
+    await map.createDynamicEvent({
+      id: "front-event",
+      x: player.x(),
+      y: player.y() + hitbox.h + 2,
+      event: {
+        onAction() {
+          actionCount += 1;
+        },
+      },
+    });
+    await fixture.nextTick();
+
+    player.changeDirection(Direction.Down);
+
+    expect(map.getCollisions(player.id)).not.toContain("front-event");
+    expect(map.getInteractionCollisions(player.id, Direction.Down)).toContain("front-event");
+
+    map.onAction(player, { action: Control.Action });
+    await fixture.wait(0);
+
+    expect(actionCount).toBe(1);
+  });
+
+  test("ignores a nearby event behind the player", async () => {
+    const map = player.getCurrentMap() as any;
+    const hitbox = player.hitbox();
+
+    await map.createDynamicEvent({
+      id: "behind-event",
+      x: player.x(),
+      y: player.y() - hitbox.h - 2,
+      event: {
+        onAction() {
+          actionCount += 1;
+        },
+      },
+    });
+    await fixture.nextTick();
+
+    player.changeDirection(Direction.Down);
+    map.onAction(player, { action: Control.Action });
+    await fixture.wait(0);
+
+    expect(actionCount).toBe(0);
+  });
+});

package/tests/item.spec.ts

@@ -1,10 +1,11 @@
 import { beforeEach, test, expect, afterEach, describe, vi } from "vitest";
 import { testing, waitForSyncComplete, TestingFixture } from "@rpgjs/testing";
 import { defineModule, createModule } from "@rpgjs/common";
-import { RpgPlayer, RpgServer } from "../src";
+import { RpgEvent, RpgPlayer, RpgServer } from "../src";
 import { RpgClient } from "../../client/src";
 import { ItemLog } from "../src/logs";
 import type { ItemObject } from "../src/Player/ItemManager";
+import { syncClass } from "@signe/sync";
 
 // Define test items as objects for database
 const TestPotion = {
@@ -124,6 +125,76 @@ describe("Item Management - Basic Operations", () => {
     expect(item.quantity()).toBe(5);
     expect(item.name()).toBe("Test Potion");
   });
+
+  test("should sync cloneable event items and equipments initialized before sync", () => {
+    const event = new RpgEvent();
+    event.id = "enemy-event";
+    event.setMap(player.getCurrentMap()!);
+    event.execMethod = vi.fn() as any;
+    event.addItem("TestSword", 1);
+    event.equip("TestSword", true);
+
+    const packets: any[] = [];
+    const memory: Record<string, any> = {};
+    const setPath = (target: Record<string, any>, path: string, value: any) => {
+      const parts = path.split(".");
+      let current = target;
+      for (let i = 0; i < parts.length - 1; i++) {
+        current = current[parts[i]] ??= {};
+      }
+      current[parts[parts.length - 1]] = value;
+    };
+
+    syncClass(event, {
+      onSync(values) {
+        const packet: Record<string, any> = {};
+        for (const [path, value] of values) {
+          setPath(packet, path, value);
+          setPath(memory, path, value);
+        }
+        structuredClone({ type: "sync", value: packet });
+        packets.push(packet);
+        values.clear();
+      },
+    });
+
+    expect(packets).toContainEqual({
+      items: {
+        "0": expect.objectContaining({
+          id: "TestSword",
+          name: "Test Sword",
+          quantity: 1,
+        }),
+      },
+    });
+    expect(packets).toContainEqual({
+      equipments: {
+        "0": expect.objectContaining({
+          id: "TestSword",
+          name: "Test Sword",
+          quantity: 1,
+        }),
+      },
+    });
+    expect(memory).toEqual(
+      expect.objectContaining({
+        items: {
+          "0": expect.objectContaining({
+            id: "TestSword",
+            name: "Test Sword",
+            quantity: 1,
+          }),
+        },
+        equipments: {
+          "0": expect.objectContaining({
+            id: "TestSword",
+            name: "Test Sword",
+            quantity: 1,
+          }),
+        },
+      })
+    );
+  });
   
 
   test("should add item using object", () => {

package/tests/move.spec.ts

@@ -48,6 +48,17 @@ afterEach(async () => {
 
 
 describe("Move Routes - Basic Movements", () => {
+  test("should create player physics body with rectangular RPG hitbox and speed", async () => {
+    const map = player.getCurrentMap() as any;
+    const entity = map.getBody(player.id);
+    const hitbox = player.hitbox();
+
+    expect(entity).toBeDefined();
+    expect(entity.width).toBe(hitbox.w);
+    expect(entity.height).toBe(hitbox.h);
+    expect(entity.radius).toBe(0);
+    expect(entity.maxLinearVelocity).toBe(player.speed() * 50);
+  });
 
   test("should move right using Direction enum", async () => {
     const initialX = player.x();
@@ -117,6 +128,59 @@ describe("Move Routes - Basic Movements", () => {
   });
 });
 
+describe("Map Shapes", () => {
+  test("should create static obstacle body for map shape", async () => {
+    const map = player.getCurrentMap() as any;
+    const shape = map.createShape({
+      x: 40,
+      y: 56,
+      width: 24,
+      height: 32,
+      name: "test-obstacle",
+    });
+    const entity = map.physic.getEntityByUUID("shape-test-obstacle");
+
+    expect(shape.name).toBe("test-obstacle");
+    expect(entity).toBeDefined();
+    expect(entity.position.x).toBe(52);
+    expect(entity.position.y).toBe(72);
+    expect(entity.width).toBe(24);
+    expect(entity.height).toBe(32);
+    expect(entity.isStatic()).toBe(true);
+  });
+
+  test("should detect entities with moving hitbox sensor", async () => {
+    const map = player.getCurrentMap() as any;
+    const hitbox = player.hitbox();
+    const hitsPromise = new Promise<any[]>((resolve, reject) => {
+      let subscription: { unsubscribe: () => void };
+      const timeout = setTimeout(() => {
+        subscription.unsubscribe();
+        reject(new Error("moving hitbox did not detect player"));
+      }, 500);
+      subscription = map.createMovingHitbox([
+        {
+          x: player.x(),
+          y: player.y(),
+          width: hitbox.w,
+          height: hitbox.h,
+        },
+      ]).subscribe({
+        next: (hits: any[]) => {
+          clearTimeout(timeout);
+          subscription.unsubscribe();
+          resolve(hits);
+        },
+        error: reject,
+      });
+      map.physic.getZoneManager().update();
+    });
+
+    const hits = await hitsPromise;
+    expect(hits.map((hit) => hit.id)).toContain(player.id);
+  });
+});
+
 describe("Move Routes - Move Helper Functions", () => {
   test("should move right using Move.right()", async () => {
     const initialX = player.x();
@@ -598,4 +662,4 @@ describe("Move Routes - Stuck Detection", () => {
     // Player should have moved successfully
     expect(player.x()).toBeGreaterThan(initialX);
   });
-});
+});

package/tests/world-maps.spec.ts

@@ -396,6 +396,10 @@ describe('Map WorldMapsManager Integration', () => {
     const worldY = player.worldPositionY()
     expect(worldX).toBe(100)
     expect(worldY).toBe(200)
+    const entity = map?.physic.getEntityByUUID(player.id)
+    const hitbox = player.hitbox()
+    expect(entity?.position.x).toBe(100 + hitbox.w / 2)
+    expect(entity?.position.y).toBe(200 + hitbox.h / 2)
 
     // Change to map2 which is at worldX: 1024, worldY: 0
     await player.changeMap('map2', { x: 50, y: 100 })