@rpgjs/client 5.0.0-beta.2 → 5.0.0-beta.20

package/src/Game/EventComponentResolver.spec.ts

@@ -0,0 +1,84 @@
+import { describe, expect, test } from "vitest";
+import { EventComponentResolverRegistry, normalizeEventComponent } from "./EventComponentResolver";
+
+describe("EventComponentResolverRegistry", () => {
+  test("uses the last resolver returning a custom event component", () => {
+    const registry = new EventComponentResolverRegistry();
+    const firstComponent = (() => null) as any;
+    const secondComponent = (() => null) as any;
+    const event = { id: "event-1" } as any;
+
+    registry.add(() => firstComponent);
+    registry.add(() => null);
+    registry.add(() => ({ component: secondComponent, props: { variant: "open" } }));
+
+    expect(registry.resolve(event)).toEqual({
+      component: secondComponent,
+      props: { variant: "open" }
+    });
+  });
+
+  test("returns null when no resolver matches", () => {
+    const registry = new EventComponentResolverRegistry();
+
+    registry.add(() => undefined);
+    registry.add(() => null);
+
+    expect(registry.resolve({ id: "event-1" } as any)).toBeNull();
+  });
+
+  test("can clear registered resolvers", () => {
+    const registry = new EventComponentResolverRegistry();
+    const component = (() => null) as any;
+
+    registry.add(() => component);
+    registry.clear();
+
+    expect(registry.resolve({ id: "event-1" } as any)).toBeNull();
+  });
+
+  test("always injects the real sprite prop for direct components", () => {
+    const component = (() => null) as any;
+    const sprite = { id: "event-1" } as any;
+
+    expect(normalizeEventComponent(component, sprite)).toEqual({
+      component,
+      props: { sprite },
+      dependencies: [],
+      renderGraphic: false
+    });
+  });
+
+  test("keeps custom props from replacing the sprite prop", () => {
+    const component = (() => null) as any;
+    const sprite = { id: "real-event" } as any;
+    const spoofedSprite = { id: "spoofed-event" };
+
+    const normalized = normalizeEventComponent({
+      component,
+      props: { sprite: spoofedSprite, variant: "wood" },
+      dependencies: () => ["ready"],
+      renderGraphic: true
+    }, sprite);
+
+    expect(normalized).toEqual({
+      component,
+      props: { variant: "wood", sprite },
+      dependencies: ["ready"],
+      renderGraphic: true
+    });
+  });
+
+  test("supports dynamic props", () => {
+    const component = (() => null) as any;
+    const sprite = { id: "event-1", name: "CHEST" } as any;
+
+    expect(normalizeEventComponent({
+      component,
+      props: (event) => ({ label: (event as any).name })
+    }, sprite)?.props).toEqual({
+      label: "CHEST",
+      sprite
+    });
+  });
+});

package/src/Game/EventComponentResolver.ts

@@ -0,0 +1,74 @@
+import type { EventComponentConfig, EventComponentSprite } from "../RpgClient";
+import type { RpgClientEvent } from "./Event";
+
+export type EventComponentResolver = (event: EventComponentSprite) => EventComponentConfig | null | undefined;
+
+export interface NormalizedEventComponentConfig {
+  component: any;
+  props: Record<string, any>;
+  dependencies: any[];
+  renderGraphic: boolean;
+}
+
+export class EventComponentResolverRegistry {
+  private resolvers: EventComponentResolver[] = [];
+
+  add(resolver: EventComponentResolver) {
+    this.resolvers.push(resolver);
+    return resolver;
+  }
+
+  resolve(event: RpgClientEvent): EventComponentConfig | null {
+    let resolved: EventComponentConfig | null = null;
+    this.resolvers.forEach((resolver) => {
+      const result = resolver(event as EventComponentSprite);
+      if (result !== undefined && result !== null) {
+        resolved = result;
+      }
+    });
+    return resolved;
+  }
+
+  clear() {
+    this.resolvers = [];
+  }
+}
+
+function withoutReservedSpriteProp(props: unknown): Record<string, any> {
+  if (!props || typeof props !== "object") return {};
+  const { sprite: _ignoredSprite, ...safeProps } = props as Record<string, any>;
+  return safeProps;
+}
+
+export function normalizeEventComponent(
+  componentConfig: EventComponentConfig | null | undefined,
+  sprite: RpgClientEvent
+): NormalizedEventComponentConfig | null {
+  if (!componentConfig) return null;
+
+  if (typeof componentConfig === "object" && "component" in componentConfig) {
+    const propsValue = componentConfig.props !== undefined
+      ? componentConfig.props
+      : componentConfig.data;
+    const props = typeof propsValue === "function"
+      ? propsValue(sprite as EventComponentSprite)
+      : propsValue;
+
+    return {
+      component: componentConfig.component,
+      props: {
+        ...withoutReservedSpriteProp(props),
+        sprite
+      },
+      dependencies: componentConfig.dependencies ? componentConfig.dependencies(sprite as EventComponentSprite) : [],
+      renderGraphic: componentConfig.renderGraphic === true
+    };
+  }
+
+  return {
+    component: componentConfig,
+    props: { sprite },
+    dependencies: [],
+    renderGraphic: false
+  };
+}

package/src/Game/Map.ts

@@ -1,5 +1,9 @@
 import {
   RpgCommonMap,
+  cloneLightingState,
+  normalizeLightingState,
+  type LightSpot,
+  type LightingState,
   type WeatherState,
   type MapPhysicsInitContext,
   type MapPhysicsEntityContext,
@@ -11,6 +15,43 @@ import { RpgClientEvent } from "./Event";
 import { RpgClientEngine } from "../RpgClientEngine";
 import { inject } from "../core/inject";
 
+type TestGlobalScope = typeof globalThis & {
+  process?: {
+    env?: {
+      TEST?: string;
+    };
+  };
+  __RPGJS_TEST__?: boolean;
+};
+
+const lightingColorsEqual = (
+  left: LightSpot["color"],
+  right: LightSpot["color"],
+): boolean => {
+  if (Array.isArray(left) || Array.isArray(right)) {
+    return Array.isArray(left)
+      && Array.isArray(right)
+      && left.length === right.length
+      && left.every((value, index) => value === right[index]);
+  }
+  return left === right;
+};
+
+const lightSpotsEqual = (left: LightSpot | undefined, right: LightSpot): boolean => {
+  if (!left) return false;
+  return left.id === right.id
+    && left.x === right.x
+    && left.y === right.y
+    && left.radius === right.radius
+    && left.intensity === right.intensity
+    && lightingColorsEqual(left.color, right.color)
+    && left.flicker === right.flicker
+    && left.flickerSpeed === right.flickerSpeed
+    && left.pulse === right.pulse
+    && left.pulseSpeed === right.pulseSpeed
+    && left.phase === right.phase;
+};
+
 export class RpgClientMap extends RpgCommonMap<any> {
   engine: RpgClientEngine = inject(RpgClientEngine)
   @users(RpgClientPlayer) players = signal<Record<string, RpgClientPlayer>>({});
@@ -18,19 +59,43 @@ export class RpgClientMap extends RpgCommonMap<any> {
   currentPlayer = computed(() => this.players()[this.engine.playerIdSignal()!])
   weatherState = signal<WeatherState | null>(null);
   localWeatherOverride = signal<WeatherState | null>(null);
+  lightingState = signal<LightingState | null>(null);
+  localLightSpots = signal<Record<string, LightSpot>>({});
   weather = computed<WeatherState | null>(() => {
     const local = this.localWeatherOverride() 
     const state = this.weatherState()
     return local ?? state
   });
+  lighting = computed<LightingState | null>(() => {
+    const state = cloneLightingState(this.lightingState());
+    const localSpots = Object.entries(this.localLightSpots()).map(([id, spot]) => ({
+      ...spot,
+      id: spot.id ?? id,
+    }));
+
+    if (!state && localSpots.length === 0) {
+      return null;
+    }
+
+    const next: LightingState = { ...(state ?? {}) };
+    if (!state?.ambient) {
+      delete next.ambient;
+    }
+    next.spots = [
+      ...(state?.spots ?? []),
+      ...localSpots,
+    ];
+    return next;
+  });
   private manualClientPhysicsTick = false;
   private readonly isTestEnvironment: boolean;
 
   constructor() {
     super();
     // Détecter l'environnement de test
-    const isTest = (typeof process !== 'undefined' && process.env?.TEST === 'true')
-      || (typeof window !== 'undefined' && (window as any).__RPGJS_TEST__ === true);
+    const testGlobal = globalThis as TestGlobalScope;
+    const isTest = testGlobal.process?.env?.TEST === 'true'
+      || testGlobal.__RPGJS_TEST__ === true;
     this.isTestEnvironment = isTest;
     if (isTest) {
       this.autoTickEnabled = false;
@@ -51,6 +116,16 @@ export class RpgClientMap extends RpgCommonMap<any> {
     const currentPlayer = !force && currentPlayerId
       ? this.players()[currentPlayerId]
       : undefined;
+    const players = this.players();
+    const events = this.events();
+
+    Object.entries(players).forEach(([id, player]) => {
+      if (!player || (!force && id === currentPlayerId)) return;
+      (player as any).resetAnimationState?.();
+    });
+    Object.values(events).forEach((event) => {
+      (event as any)?.resetAnimationState?.();
+    });
 
     this.players.set(
       currentPlayerId && currentPlayer ? { [currentPlayerId]: currentPlayer } : {}
@@ -58,6 +133,8 @@ export class RpgClientMap extends RpgCommonMap<any> {
     this.events.set({})
     this.weatherState.set(null);
     this.localWeatherOverride.set(null);
+    this.lightingState.set(null);
+    this.localLightSpots.set({});
     this.clearPhysic()
   }
 
@@ -73,6 +150,61 @@ export class RpgClientMap extends RpgCommonMap<any> {
     this.localWeatherOverride.set(null);
   }
 
+  getLighting(): LightingState | null {
+    return this.lighting();
+  }
+
+  addLightSpot(id: string, spot: LightSpot): void {
+    const normalized = normalizeLightingState({ spots: [{ ...spot, id }] });
+    const nextSpot = normalized?.spots?.[0];
+    if (!nextSpot) {
+      return;
+    }
+    this.localLightSpots.update((spots) => {
+      if (lightSpotsEqual(spots[id], nextSpot)) {
+        return spots;
+      }
+      return {
+        ...spots,
+        [id]: nextSpot,
+      };
+    });
+  }
+
+  patchLightSpot(id: string, patch: Partial<LightSpot>): void {
+    this.localLightSpots.update((spots) => {
+      const current = spots[id];
+      if (!current) {
+        return spots;
+      }
+      return {
+        ...spots,
+        [id]: {
+          ...current,
+          ...patch,
+          id,
+          x: patch.x ?? current.x,
+          y: patch.y ?? current.y,
+        },
+      };
+    });
+  }
+
+  removeLightSpot(id: string): void {
+    this.localLightSpots.update((spots) => {
+      if (!(id in spots)) {
+        return spots;
+      }
+      const next = { ...spots };
+      delete next[id];
+      return next;
+    });
+  }
+
+  clearLightSpots(): void {
+    this.localLightSpots.set({});
+  }
+
   stepClientPhysics(deltaMs: number): number {
     if (!this.manualClientPhysicsTick) {
       return 0;

package/src/Game/Object.spec.ts

@@ -0,0 +1,59 @@
+import { describe, expect, test, vi } from "vitest";
+import { signal } from "canvasengine";
+import { appendFramePayload, RpgClientObject, withGraphicDisplayScale } from "./Object";
+
+vi.mock("../RpgClientEngine", () => ({
+  RpgClientEngine: class RpgClientEngine {},
+}));
+
+vi.mock("../core/inject", () => ({
+  inject: () => ({}),
+}));
+
+function createObject() {
+  const object = Object.create(RpgClientObject.prototype) as RpgClientObject;
+  object.animationName = signal("stand");
+  object.graphics = signal(["hero"]) as any;
+  object.animationCurrentIndex = signal(0);
+  object.animationIsPlaying = signal(false);
+  return object;
+}
+
+describe("RpgClientObject animations", () => {
+  test("accepts a single frame payload without requiring iterable spread", () => {
+    expect(
+      appendFramePayload({ stale: true }, { x: 10, y: 20, ts: 1 }),
+    ).toEqual([{ x: 10, y: 20, ts: 1 }]);
+  });
+
+  test("keeps instance scale outside the spritesheet transform scale", () => {
+    expect(withGraphicDisplayScale({ id: "hero" }, 0.5)).toEqual({
+      id: "hero",
+      displayScale: 0.5,
+    });
+  });
+
+  test("marks temporary animation as finished before restoring locomotion animation", async () => {
+    const object = createObject();
+    const animationChanges: Array<{ name: string; isPlaying: boolean }> = [];
+
+    object.animationName.observable.subscribe((name) => {
+      animationChanges.push({
+        name,
+        isPlaying: object.animationIsPlaying(),
+      });
+    });
+
+    const done = object.setAnimation("attack", 1, { timeoutMs: 10000 });
+    object.animationCurrentIndex.set(1);
+
+    await done;
+
+    expect(object.animationName()).toBe("stand");
+    expect(object.animationIsPlaying()).toBe(false);
+    expect(animationChanges).toContainEqual({
+      name: "stand",
+      isPlaying: false,
+    });
+  });
+});