@rpgjs/common 5.0.0-alpha.1 → 5.0.0-alpha.11

package/dist/Physic.d.ts

@@ -136,11 +136,29 @@ export declare class RpgCommonPhysic {
      *
      * @example
      * ```ts
-     * // Add a wall
+     * // Add a rectangular wall
      * physic.addStaticHitbox('wall1', 100, 50, 32, 128);
      * ```
      */
     addStaticHitbox(id: string, x: number, y: number, width: number, height: number): string;
+    /**
+     * Add a static hitbox with polygon shape (immovable objects like walls, obstacles)
+     *
+     * @param id - Unique identifier for the hitbox
+     * @param points - Array of 2D points [[x1, y1], [x2, y2], ...] to create a polygon
+     * @returns The id of the created hitbox
+     *
+     * @example
+     * ```ts
+     * // Add a triangular obstacle
+     * physic.addStaticHitbox('triangle1', [
+     *   [100, 100],
+     *   [150, 50],
+     *   [200, 100]
+     * ]);
+     * ```
+     */
+    addStaticHitbox(id: string, points: number[][]): string;
     /**
      * Add a movable hitbox (players, NPCs, dynamic objects)
      *
@@ -425,6 +443,40 @@ export declare class RpgCommonPhysic {
      * ```
      */
     getWorld(): Matter.World;
+    /**
+     * Get debug information about all hitboxes
+     *
+     * Useful for debugging collision issues
+     *
+     * @returns Array of hitbox debug information
+     *
+     * @example
+     * ```ts
+     * // Debug all hitboxes
+     * const info = physic.getDebugInfo();
+     * console.log('All hitboxes:', info);
+     * ```
+     */
+    getDebugInfo(): Array<{
+        id: string;
+        type: 'static' | 'movable';
+        position: {
+            x: number;
+            y: number;
+        };
+        bounds: {
+            min: {
+                x: number;
+                y: number;
+            };
+            max: {
+                x: number;
+                y: number;
+            };
+        };
+        verticesCount: number;
+        isPolygon: boolean;
+    }>;
     /**
      * Create a new Zone sensor. Never collides physically but triggers events.
      *

package/dist/Player.d.ts

@@ -1,6 +1,7 @@
 import { Item } from './database';
 import { Observable } from 'rxjs';
-import * as Matter from 'matter-js';
+import { Constructor } from './Utils';
+import * as Matter from "matter-js";
 export declare enum Direction {
     Up = "up",
     Down = "down",
@@ -37,14 +38,16 @@ export interface AttachShapeOptions {
     /** If true, walls (static hitboxes) stop vision */
     limitedByWalls?: boolean;
     /** Indicate where the shape is placed relative to the player */
-    positioning?: 'center' | 'top' | 'bottom' | 'left' | 'right';
+    positioning?: "center" | "top" | "bottom" | "left" | "right";
     /** The name of the shape */
     name?: string;
     /** An object to retrieve information when interacting with the shape */
     properties?: object;
 }
-export declare class RpgCommonPlayer {
+export declare abstract class RpgCommonPlayer {
     id: string;
+    name: import('@signe/reactive').WritableSignal<string>;
+    type: import('@signe/reactive').WritableSignal<string>;
     x: import('@signe/reactive').WritableSignal<number>;
     y: import('@signe/reactive').WritableSignal<number>;
     z: import('@signe/reactive').WritableSignal<number>;
@@ -56,8 +59,8 @@ export declare class RpgCommonPlayer {
     hitbox: import('@signe/reactive').WritableObjectSignal<Hitbox>;
     _gold: import('@signe/reactive').WritableSignal<number>;
     animationName: import('@signe/reactive').WritableSignal<string>;
-    _hp: import('@signe/reactive').WritableSignal<number>;
-    _sp: import('@signe/reactive').WritableSignal<number>;
+    hpSignal: import('@signe/reactive').WritableSignal<number>;
+    spSignal: import('@signe/reactive').WritableSignal<number>;
     _exp: import('@signe/reactive').WritableSignal<number>;
     _level: import('@signe/reactive').WritableSignal<number>;
     _class: import('@signe/reactive').WritableObjectSignal<{}>;
@@ -152,6 +155,36 @@ export declare class RpgCommonPlayer {
      * ```
      */
     applyPhysic(body: Matter.Body): void;
+    abstract setAnimation(animationName: string, nbTimes: number): void;
+    abstract showComponentAnimation(id: string, params: any): void;
+    /**
+     * Display a spritesheet animation on the player
+     *
+     * This method displays a temporary visual animation using a spritesheet.
+     * The animation can either be displayed as an overlay on the player or replace
+     * the player's current graphic temporarily. This is useful for spell effects,
+     * transformations, or other visual feedback that uses predefined spritesheets.
+     *
+     * @param graphic - The ID of the spritesheet to use for the animation
+     * @param animationName - The name of the animation within the spritesheet (default: 'default')
+     * @param replaceGraphic - Whether to replace the player's sprite with the animation (default: false)
+     *
+     * @example
+     * ```ts
+     * // Show explosion animation as overlay on player
+     * player.showAnimation("explosion");
+     *
+     * // Show specific spell effect animation
+     * player.showAnimation("spell-effects", "fireball");
+     *
+     * // Transform player graphic temporarily with animation
+     * player.showAnimation("transformation", "werewolf", true);
+     *
+     * // Show healing effect on player
+     * player.showAnimation("healing-effects", "holy-light");
+     * ```
+     */
+    showAnimation(graphic: string, animationName?: string, replaceGraphic?: boolean): void;
     _showAnimation(params: ShowAnimationParams): void;
     /**
      * Create a temporary and moving hitbox relative to the player's position
@@ -195,4 +228,7 @@ export declare class RpgCommonPlayer {
         speed?: number;
     }): Observable<any[]>;
     getCurrentMap(): any;
+    get hp(): number;
+    get sp(): number;
 }
+export type PlayerCtor<T extends RpgCommonPlayer = RpgCommonPlayer> = Constructor<T>;

package/dist/index.d.ts

@@ -7,3 +7,4 @@ export * from './PrebuiltGui';
 export * from './movement';
 export * as Matter from 'matter-js';
 export * from './database';
+export * from './Physic';

package/dist/index.js

@@ -2275,6 +2275,8 @@ var Animation = /* @__PURE__ */ ((Animation2) => {
 })(Animation || {});
 class RpgCommonPlayer {
   constructor() {
+    this.name = signal("");
+    this.type = signal("");
     this.x = signal(0);
     this.y = signal(0);
     this.z = signal(0);
@@ -2289,8 +2291,8 @@ class RpgCommonPlayer {
     });
     this._gold = signal(0);
     this.animationName = signal("stand");
-    this._hp = signal(0);
-    this._sp = signal(0);
+    this.hpSignal = signal(0);
+    this.spSignal = signal(0);
     this._exp = signal(0);
     this._level = signal(0);
     this._class = signal({});
@@ -2308,14 +2310,14 @@ class RpgCommonPlayer {
   }
   /**
    * Change the player's facing direction
-   * 
+   *
    * Updates the direction the player is facing, which affects animations
    * and directional abilities. This should be called when the player
    * intends to move in a specific direction, not when they are pushed
    * by physics or sliding.
-   * 
+   *
    * @param direction - The new direction to face
-   * 
+   *
    * @example
    * ```ts
    * // Player presses right arrow key
@@ -2327,9 +2329,9 @@ class RpgCommonPlayer {
   }
   /**
    * Get the current facing direction
-   * 
+   *
    * @returns Current direction the player is facing
-   * 
+   *
    * @example
    * ```ts
    * const currentDirection = player.getDirection();
@@ -2343,18 +2345,18 @@ class RpgCommonPlayer {
   }
   /**
    * Set the intended movement direction
-   * 
+   *
    * This should be called when the player intends to move in a direction,
    * typically from input handling. This direction will be used to update
    * the player's facing direction regardless of physics interactions.
-   * 
+   *
    * @param direction - The intended movement direction, or null if not moving
-   * 
+   *
    * @example
    * ```ts
    * // Player presses down arrow key
    * player.setIntendedDirection(Direction.Down);
-   * 
+   *
    * // Player releases all movement keys
    * player.setIntendedDirection(null);
    * ```
@@ -2367,9 +2369,9 @@ class RpgCommonPlayer {
   }
   /**
    * Get the intended movement direction
-   * 
+   *
    * @returns The direction the player intends to move, or null if not moving
-   * 
+   *
    * @example
    * ```ts
    * const intended = player.getIntendedDirection();
@@ -2383,14 +2385,14 @@ class RpgCommonPlayer {
   }
   /**
    * Apply physics body position to player coordinates
-   * 
+   *
    * Synchronizes the player's position with their physics body after
    * physics calculations. This method no longer automatically changes
    * the player's direction based on position changes, as direction
    * should be controlled by intended movement instead.
-   * 
+   *
    * @param body - The Matter.js physics body
-   * 
+   *
    * @example
    * ```ts
    * // Called automatically by physics system
@@ -2408,6 +2410,43 @@ class RpgCommonPlayer {
       this.y.set(topLeftY);
     }
   }
+  /**
+   * Display a spritesheet animation on the player
+   * 
+   * This method displays a temporary visual animation using a spritesheet.
+   * The animation can either be displayed as an overlay on the player or replace
+   * the player's current graphic temporarily. This is useful for spell effects,
+   * transformations, or other visual feedback that uses predefined spritesheets.
+   * 
+   * @param graphic - The ID of the spritesheet to use for the animation
+   * @param animationName - The name of the animation within the spritesheet (default: 'default')
+   * @param replaceGraphic - Whether to replace the player's sprite with the animation (default: false)
+   * 
+   * @example
+   * ```ts
+   * // Show explosion animation as overlay on player
+   * player.showAnimation("explosion");
+   * 
+   * // Show specific spell effect animation
+   * player.showAnimation("spell-effects", "fireball");
+   * 
+   * // Transform player graphic temporarily with animation
+   * player.showAnimation("transformation", "werewolf", true);
+   * 
+   * // Show healing effect on player
+   * player.showAnimation("healing-effects", "holy-light");
+   * ```
+   */
+  showAnimation(graphic, animationName = "default", replaceGraphic = false) {
+    if (replaceGraphic) {
+      this.setAnimation(animationName, 1);
+      return;
+    }
+    this.showComponentAnimation("animation", {
+      graphic,
+      animationName
+    });
+  }
   _showAnimation(params) {
     const { graphic, animationName, loop } = params;
     if (graphic) {
@@ -2420,20 +2459,20 @@ class RpgCommonPlayer {
   }
   /**
    * Create a temporary and moving hitbox relative to the player's position
-   * 
+   *
    * Creates a temporary hitbox that moves through multiple positions sequentially,
    * with all coordinates being relative to the player's current position.
    * For example, you can use it for player attacks, spells, or area effects
    * that should follow the player's position.
-   * 
+   *
    * The method creates a zone sensor that moves through the specified hitbox positions
    * at the given speed, detecting collisions with other players and events at each step.
-   * 
+   *
    * @param hitboxes - Array of hitbox positions relative to player position
    * @param options - Configuration options for the movement
    * @param map - Reference to the map instance for physics access
    * @returns Observable that emits arrays of hit entities and completes when movement is finished
-   * 
+   *
    * @example
    * ```ts
    * // Create a forward attack relative to player position
@@ -2463,10 +2502,22 @@ class RpgCommonPlayer {
   getCurrentMap() {
     return this["map"];
   }
+  get hp() {
+    return this.hpSignal();
+  }
+  get sp() {
+    return this.spSignal();
+  }
 }
 __decorateClass([
   id()
 ], RpgCommonPlayer.prototype, "id");
+__decorateClass([
+  sync()
+], RpgCommonPlayer.prototype, "name");
+__decorateClass([
+  sync()
+], RpgCommonPlayer.prototype, "type");
 __decorateClass([
   sync()
 ], RpgCommonPlayer.prototype, "x");
@@ -2502,10 +2553,10 @@ __decorateClass([
 ], RpgCommonPlayer.prototype, "animationName");
 __decorateClass([
   sync()
-], RpgCommonPlayer.prototype, "_hp");
+], RpgCommonPlayer.prototype, "hpSignal");
 __decorateClass([
   sync()
-], RpgCommonPlayer.prototype, "_sp");
+], RpgCommonPlayer.prototype, "spSignal");
 __decorateClass([
   sync()
 ], RpgCommonPlayer.prototype, "_exp");
@@ -14079,32 +14130,61 @@ class RpgCommonPhysic {
       return dy > 0 ? Direction.Down : Direction.Up;
     }
   }
-  /**
-   * Add a static hitbox (immovable objects like walls, obstacles)
-   * 
-   * @param id - Unique identifier for the hitbox
-   * @param x - X position
-   * @param y - Y position
-   * @param width - Width of hitbox
-   * @param height - Height of hitbox
-   * @returns The id of the created hitbox
-   * 
-   * @example
-   * ```ts
-   * // Add a wall
-   * physic.addStaticHitbox('wall1', 100, 50, 32, 128);
-   * ```
-   */
-  addStaticHitbox(id, x, y, width, height) {
+  addStaticHitbox(id, xOrPoints, y, width, height) {
     if (this.hitboxes.has(id)) {
       throw new Error(`Hitbox with id ${id} already exists`);
     }
-    const centerX = x + width / 2;
-    const centerY = y + height / 2;
-    const body = matterExports.Bodies.rectangle(centerX, centerY, width, height, {
-      isStatic: true,
-      label: id
-    });
+    let body;
+    if (Array.isArray(xOrPoints)) {
+      const points = xOrPoints;
+      if (points.length < 3) {
+        throw new Error(`Polygon must have at least 3 points, got ${points.length}`);
+      }
+      for (let i = 0; i < points.length; i++) {
+        const point = points[i];
+        if (!Array.isArray(point) || point.length !== 2 || typeof point[0] !== "number" || typeof point[1] !== "number") {
+          throw new Error(`Invalid point at index ${i}: ${JSON.stringify(point)}. Expected [x, y] with numbers.`);
+        }
+      }
+      let centerX = 0, centerY = 0;
+      for (const point of points) {
+        centerX += point[0];
+        centerY += point[1];
+      }
+      centerX /= points.length;
+      centerY /= points.length;
+      const vertices = points.map((point) => ({
+        x: point[0] - centerX,
+        y: point[1] - centerY
+      }));
+      try {
+        body = matterExports.Bodies.fromVertices(0, 0, [vertices], {
+          isStatic: true,
+          label: id
+        });
+        if (!body) {
+          throw new Error(`Matter.Bodies.fromVertices returned null/undefined`);
+        }
+        if (!body.vertices || body.vertices.length === 0) {
+          throw new Error(`Created body has no vertices`);
+        }
+        matterExports.Body.setPosition(body, { x: centerX, y: centerY });
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        throw new Error(`Failed to create polygon body from points ${JSON.stringify(points)}: ${errorMessage}`);
+      }
+    } else {
+      const x = xOrPoints;
+      if (y === void 0 || width === void 0 || height === void 0) {
+        throw new Error("Rectangle hitbox requires x, y, width, and height parameters");
+      }
+      const centerX = x + width / 2;
+      const centerY = y + height / 2;
+      body = matterExports.Bodies.rectangle(centerX, centerY, width, height, {
+        isStatic: true,
+        label: id
+      });
+    }
     matterExports.Composite.add(this.world, body);
     this.hitboxes.set(id, {
       id,
@@ -14688,6 +14768,39 @@ class RpgCommonPhysic {
   getWorld() {
     return this.world;
   }
+  /**
+   * Get debug information about all hitboxes
+   * 
+   * Useful for debugging collision issues
+   * 
+   * @returns Array of hitbox debug information
+   * 
+   * @example
+   * ```ts
+   * // Debug all hitboxes
+   * const info = physic.getDebugInfo();
+   * console.log('All hitboxes:', info);
+   * ```
+   */
+  getDebugInfo() {
+    const info = [];
+    for (const [id, hitboxData] of this.hitboxes.entries()) {
+      const body = hitboxData.body;
+      info.push({
+        id,
+        type: hitboxData.type,
+        position: { x: body.position.x, y: body.position.y },
+        bounds: {
+          min: { x: body.bounds.min.x, y: body.bounds.min.y },
+          max: { x: body.bounds.max.x, y: body.bounds.max.y }
+        },
+        verticesCount: body.vertices.length,
+        isPolygon: body.vertices.length > 4
+        // Rectangles have 4 vertices
+      });
+    }
+    return info;
+  }
   /* ----------------------------------------------------------------------- */
   /*                               ZONES                                    */
   /* ----------------------------------------------------------------------- */
@@ -16227,7 +16340,11 @@ class RpgCommonMap {
     this.physic.addStaticHitbox("map-height-top", 0, -100, this.data().width, gap);
     this.physic.addStaticHitbox("map-height-bottom", 0, this.data().height, this.data().width, gap);
     for (let staticHitbox of hitboxes) {
-      this.physic.addStaticHitbox(staticHitbox.id ?? generateShortUUID(), staticHitbox.x, staticHitbox.y, staticHitbox.width, staticHitbox.height);
+      if ("x" in staticHitbox) {
+        this.physic.addStaticHitbox(staticHitbox.id ?? generateShortUUID(), staticHitbox.x, staticHitbox.y, staticHitbox.width, staticHitbox.height);
+      } else if ("points" in staticHitbox) {
+        this.physic.addStaticHitbox(staticHitbox.id ?? generateShortUUID(), staticHitbox.points);
+      }
     }
     this.events.observable.subscribe(({ value: event, type }) => {
       if (type == "add") {
@@ -16737,5 +16854,5 @@ var PrebuiltGui = /* @__PURE__ */ ((PrebuiltGui2) => {
   return PrebuiltGui2;
 })(PrebuiltGui || {});
 
-export { Animation, CompositeMovement, Dash, Direction, Hooks, IceMovement, Item, Knockback, LinearMove, LinearRepulsion, matter$1 as Matter, ModulesToken, MovementManager, Oscillate, PathFollow, PrebuiltGui, ProjectileMovement, ProjectileType, RpgCommonMap, RpgCommonPlayer, SeekAvoid, UpdateMapService, UpdateMapToken, applyMixins, arrayEquals, arrayFlat, arrayUniq, basename, camelToKebab, capitalize, combineMixins, createConstructor, createModule, defineModule, elementToPositionAbsolute, extractId, findModules, fps2ms, generateUID, hexaToNumber, intersection, isArray, isBrowser, isClass, isFunction, isInstanceOf, isObject, isPromise, isString, mergeObjectWithMethods, preciseNow, provideModules, random, round, set, sharedArrayBuffer, toRadians };
+export { Animation, CompositeMovement, Dash, Direction, Hooks, IceMovement, Item, Knockback, LinearMove, LinearRepulsion, matter$1 as Matter, ModulesToken, MovementManager, Oscillate, PathFollow, PrebuiltGui, ProjectileMovement, ProjectileType, RpgCommonMap, RpgCommonPhysic, RpgCommonPlayer, SeekAvoid, UpdateMapService, UpdateMapToken, applyMixins, arrayEquals, arrayFlat, arrayUniq, basename, camelToKebab, capitalize, combineMixins, createConstructor, createModule, defineModule, elementToPositionAbsolute, extractId, findModules, fps2ms, generateUID, hexaToNumber, intersection, isArray, isBrowser, isClass, isFunction, isInstanceOf, isObject, isPromise, isString, mergeObjectWithMethods, preciseNow, provideModules, random, round, set, sharedArrayBuffer, toRadians };
 //# sourceMappingURL=index.js.map