@rpgjs/common 5.0.0-alpha.4 → 5.0.0-alpha.40

package/dist/PerlinNoise.d.ts

@@ -0,0 +1,167 @@
+/**
+ * Perlin Noise 2D Generator
+ *
+ * A simple, efficient, and performant implementation of 2D Perlin noise.
+ * Perlin noise generates smooth, natural-looking random values that are coherent
+ * across space, making it ideal for procedural generation and smooth random movements.
+ *
+ * ## Features
+ * - **Deterministic**: Same seed and coordinates always produce the same value
+ * - **Smooth**: Values change gradually, creating natural-looking patterns
+ * - **Performant**: Optimized for real-time use in movement systems
+ * - **Seeded**: Optional seed for reproducible results
+ *
+ * ## Usage
+ * ```ts
+ * const noise = new PerlinNoise2D();
+ * const value = noise.get(x, y); // Returns value between -1 and 1
+ *
+ * // With seed for deterministic results
+ * const seededNoise = new PerlinNoise2D(12345);
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Use in movement system for smooth random directions
+ * const noise = new PerlinNoise2D();
+ * const time = Date.now() * 0.001;
+ * const direction = Math.floor(noise.get(player.x(), player.y(), time) * 4) % 4;
+ * ```
+ */
+export declare class PerlinNoise2D {
+    private readonly permutation;
+    private readonly p;
+    /**
+     * Creates a new Perlin noise generator
+     *
+     * @param seed - Optional seed for deterministic noise generation. If not provided, uses a default seed.
+     *
+     * @example
+     * ```ts
+     * const noise = new PerlinNoise2D(12345);
+     * const value = noise.get(10, 20);
+     * ```
+     */
+    constructor(seed?: number);
+    /**
+     * Generates a permutation table based on seed
+     *
+     * @param seed - Seed value for permutation generation
+     * @returns Array of 256 shuffled values
+     */
+    private generatePermutation;
+    /**
+     * Fade function for smooth interpolation (ease curve)
+     *
+     * @param t - Value between 0 and 1
+     * @returns Smoothed value between 0 and 1
+     */
+    private fade;
+    /**
+     * Linear interpolation
+     *
+     * @param a - Start value
+     * @param b - End value
+     * @param t - Interpolation factor (0 to 1)
+     * @returns Interpolated value
+     */
+    private lerp;
+    /**
+     * Gradient function - generates a pseudo-random gradient vector
+     *
+     * @param hash - Hash value from permutation table
+     * @param x - X component
+     * @param y - Y component
+     * @returns Dot product of gradient and position
+     */
+    private grad;
+    /**
+     * Gets the noise value at the specified 2D coordinates
+     *
+     * Returns a value between approximately -1 and 1, though values near the edges
+     * are less common. For practical use, you may want to clamp or normalize the result.
+     *
+     * @param x - X coordinate
+     * @param y - Y coordinate
+     * @param scale - Optional scale factor (default: 0.1). Lower values create smoother, larger patterns.
+     * @returns Noise value between approximately -1 and 1
+     *
+     * @example
+     * ```ts
+     * const noise = new PerlinNoise2D();
+     * const value = noise.get(10, 20); // Basic usage
+     * const scaled = noise.get(10, 20, 0.05); // Smoother pattern
+     * ```
+     */
+    get(x: number, y: number, scale?: number): number;
+    /**
+     * Gets a normalized noise value between 0 and 1
+     *
+     * Convenience method that normalizes the noise output to a 0-1 range.
+     *
+     * @param x - X coordinate
+     * @param y - Y coordinate
+     * @param scale - Optional scale factor (default: 0.1)
+     * @returns Noise value between 0 and 1
+     *
+     * @example
+     * ```ts
+     * const noise = new PerlinNoise2D();
+     * const normalized = noise.getNormalized(10, 20);
+     * // Returns value between 0 and 1
+     * ```
+     */
+    getNormalized(x: number, y: number, scale?: number): number;
+    /**
+     * Gets a noise value mapped to a specific range
+     *
+     * Maps the noise output to a custom min-max range.
+     *
+     * @param x - X coordinate
+     * @param y - Y coordinate
+     * @param min - Minimum output value
+     * @param max - Maximum output value
+     * @param scale - Optional scale factor (default: 0.1)
+     * @returns Noise value between min and max
+     *
+     * @example
+     * ```ts
+     * const noise = new PerlinNoise2D();
+     * const direction = noise.getRange(10, 20, 0, 3); // Returns 0, 1, 2, or 3
+     * ```
+     */
+    getRange(x: number, y: number, min: number, max: number, scale?: number): number;
+    /**
+     * Gets an integer noise value in a specific range (inclusive)
+     *
+     * Useful for selecting discrete values like array indices or enum values.
+     *
+     * @param x - X coordinate
+     * @param y - Y coordinate
+     * @param min - Minimum integer value (inclusive)
+     * @param max - Maximum integer value (inclusive)
+     * @param scale - Optional scale factor (default: 0.1)
+     * @returns Integer noise value between min and max (inclusive)
+     *
+     * @example
+     * ```ts
+     * const noise = new PerlinNoise2D();
+     * const directionIndex = noise.getInt(10, 20, 0, 3); // Returns 0, 1, 2, or 3
+     * ```
+     */
+    getInt(x: number, y: number, min: number, max: number, scale?: number): number;
+}
+export declare function getSharedPerlinNoise(seed?: number): PerlinNoise2D;
+/**
+ * Resets the shared Perlin noise instance
+ *
+ * Useful for testing or when you need to change the seed.
+ *
+ * @param seed - Optional new seed for the instance
+ *
+ * @example
+ * ```ts
+ * resetSharedPerlinNoise(12345);
+ * ```
+ */
+export declare function resetSharedPerlinNoise(seed?: number): void;

package/dist/Player.d.ts

@@ -1,6 +1,16 @@
-import { Item } from './database';
-import { Observable } from 'rxjs';
-import * as Matter from 'matter-js';
+import { Item, Skill } from './database';
+import { Constructor } from './Utils';
+export declare enum Control {
+    Action = "action",
+    Attack = "attack",
+    Defense = "defense",
+    Skill = "skill",
+    Back = "back",
+    Up = 1,
+    Down = 3,
+    Right = 2,
+    Left = 4
+}
 export declare enum Direction {
     Up = "up",
     Down = "down",
@@ -37,14 +47,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,143 +68,134 @@ 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<{}>;
     items: import('@signe/reactive').WritableArraySignal<Item[]>;
     equipments: import('@signe/reactive').WritableArraySignal<any[]>;
     states: import('@signe/reactive').WritableArraySignal<any[]>;
-    skills: import('@signe/reactive').WritableArraySignal<any[]>;
+    skills: import('@signe/reactive').WritableArraySignal<Skill[]>;
     _effects: import('@signe/reactive').WritableArraySignal<any[]>;
     _through: import('@signe/reactive').WritableSignal<boolean>;
     _throughOtherPlayer: import('@signe/reactive').WritableSignal<boolean>;
     _throughEvent: import('@signe/reactive').WritableSignal<boolean>;
     _frequency: import('@signe/reactive').WritableSignal<number>;
+    _frames: import('@signe/reactive').WritableArraySignal<{
+        x: number;
+        y: number;
+        ts: number;
+    }[]>;
+    componentsTop: import('@signe/reactive').WritableSignal<string | null>;
+    componentsBottom: import('@signe/reactive').WritableSignal<string | null>;
+    componentsCenter: import('@signe/reactive').WritableSignal<string | null>;
+    componentsLeft: import('@signe/reactive').WritableSignal<string | null>;
+    componentsRight: import('@signe/reactive').WritableSignal<string | null>;
+    isConnected: import('@signe/reactive').WritableSignal<boolean>;
     private _intendedDirection;
+    private _directionFixed;
+    private _animationFixed;
     /**
-     * Change the player's facing direction
+     * Get whether direction changes are locked
      *
-     * 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
+     * @returns True if direction is locked and cannot be changed automatically
      *
      * @example
      * ```ts
-     * // Player presses right arrow key
-     * player.changeDirection(Direction.Right);
+     * if (player.directionFixed) {
+     *   // Direction is locked, won't change automatically
+     * }
      * ```
      */
-    changeDirection(direction: Direction): void;
+    get directionFixed(): boolean;
     /**
-     * Get the current facing direction
+     * Set whether direction changes are locked
      *
-     * @returns Current direction the player is facing
+     * When set to true, the player's direction will not change automatically
+     * during movement or from physics engine callbacks.
+     *
+     * @param value - True to lock direction, false to allow automatic changes
      *
      * @example
      * ```ts
-     * const currentDirection = player.getDirection();
-     * if (currentDirection === Direction.Up) {
-     *   // Player is facing up
-     * }
+     * // Lock direction during a special animation
+     * player.directionFixed = true;
+     * player.setAnimation('attack');
+     * // ... later
+     * player.directionFixed = false;
      * ```
      */
-    getDirection(): Direction;
+    set directionFixed(value: boolean);
     /**
-     * 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.
+     * Get whether animation changes are locked
      *
-     * @param direction - The intended movement direction, or null if not moving
+     * @returns True if animation is locked and cannot be changed automatically
      *
      * @example
      * ```ts
-     * // Player presses down arrow key
-     * player.setIntendedDirection(Direction.Down);
-     *
-     * // Player releases all movement keys
-     * player.setIntendedDirection(null);
+     * if (player.animationFixed) {
+     *   // Animation is locked, won't change automatically
+     * }
      * ```
      */
-    setIntendedDirection(direction: Direction | null): void;
+    get animationFixed(): boolean;
     /**
-     * Get the intended movement direction
+     * Set whether animation changes are locked
+     *
+     * When set to true, the player's animation will not change automatically
+     * during movement or from physics engine callbacks.
      *
-     * @returns The direction the player intends to move, or null if not moving
+     * @param value - True to lock animation, false to allow automatic changes
      *
      * @example
      * ```ts
-     * const intended = player.getIntendedDirection();
-     * if (intended === Direction.Left) {
-     *   // Player is trying to move left
-     * }
+     * // Lock animation during a special skill
+     * player.animationFixed = true;
+     * player.setAnimation('skill');
+     * // ... later
+     * player.animationFixed = false;
      * ```
      */
-    getIntendedDirection(): Direction | null;
+    set animationFixed(value: boolean);
+    pendingInputs: any[];
     /**
-     * Apply physics body position to player coordinates
+     * Change the player's facing direction
      *
-     * 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.
+     * 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.
+     *
+     * If `directionFixed` is true, this method will not change the direction.
      *
-     * @param body - The Matter.js physics body
+     * @param direction - The new direction to face
      *
      * @example
      * ```ts
-     * // Called automatically by physics system
-     * player.applyPhysic(body);
+     * // Player presses right arrow key
+     * player.changeDirection(Direction.Right);
+     *
+     * // Lock direction to prevent automatic changes
+     * player.directionFixed = true;
+     * player.changeDirection(Direction.Up); // This will be ignored
      * ```
      */
-    applyPhysic(body: Matter.Body): void;
-    _showAnimation(params: ShowAnimationParams): void;
+    changeDirection(direction: Direction): void;
     /**
-     * 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.
+     * Get the current facing direction
      *
-     * @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
+     * @returns Current direction the player is facing
      *
      * @example
      * ```ts
-     * // Create a forward attack relative to player position
-     * player.createMovingHitbox([
-     *   { x: 0, y: -32, width: 32, height: 32 },    // In front of player
-     *   { x: 0, y: -64, width: 32, height: 32 }     // Further in front
-     * ], { speed: 2 }, map).subscribe({
-     *   next(hits) {
-     *     // hits contains other RpgPlayer or RpgEvent objects that were hit
-     *     console.log('Hit entities:', hits);
-     *   },
-     *   complete() {
-     *     console.log('Attack finished');
-     *   }
-     * });
+     * const currentDirection = player.getDirection();
+     * if (currentDirection === Direction.Up) {
+     *   // Player is facing up
+     * }
      * ```
      */
-    createMovingHitbox(hitboxes: Array<{
-        x: number;
-        y: number;
-        width: number;
-        height: number;
-    }>, options?: {
-        speed?: number;
-    }): Observable<any[]>;
-    getCurrentMap(): any;
+    getDirection(): Direction;
+    abstract isEvent(): boolean;
 }
+export type PlayerCtor<T extends RpgCommonPlayer = RpgCommonPlayer> = Constructor<T>;

package/dist/PrebuiltGui.d.ts

@@ -13,6 +13,7 @@
 * PrebuiltGui.Save | rpg-save
 * PrebuiltGui.Controls | rpg-controls
 * PrebuiltGui.Notification | rpg-notification
+* PrebuiltGui.TitleScreen | rpg-title-screen
 * @memberof PrebuiltGui
 * */
 export declare enum PrebuiltGui {
@@ -23,5 +24,6 @@ export declare enum PrebuiltGui {
     Gameover = "rpg-gameover",
     Save = "rpg-save",
     Controls = "rpg-controls",
-    Notification = "rpg-notification"
+    Notification = "rpg-notification",
+    TitleScreen = "rpg-title-screen"
 }

package/dist/Presets.d.ts

@@ -0,0 +1,9 @@
+export declare const MAXHP: string;
+export declare const MAXSP: string;
+export declare const ATK: string;
+export declare const PDEF: string;
+export declare const SDEF: string;
+export declare const STR: string;
+export declare const AGI: string;
+export declare const INT: string;
+export declare const DEX: string;

package/dist/Shape.d.ts

@@ -0,0 +1,100 @@
+import { RpgCommonPlayer } from './Player';
+/**
+ * Shape positioning relative to the player
+ */
+export type ShapePositioning = "center" | "top" | "bottom" | "left" | "right" | "default";
+/**
+ * Represents a zone shape attached to a player or event
+ *
+ * Shapes are used for detection zones, vision cones, and area-of-effect abilities.
+ * They are backed by the physic engine's zone system for accurate detection.
+ *
+ * @example
+ * ```ts
+ * // Create a shape attached to a player
+ * const visionShape = player.attachShape("vision", {
+ *   radius: 150,
+ *   angle: 120,
+ *   direction: Direction.Right,
+ *   name: "Vision Zone",
+ *   properties: { type: "detection" }
+ * });
+ *
+ * // Check if a player is in the shape
+ * if (visionShape.playerIsIn(otherPlayer)) {
+ *   console.log("Player detected!");
+ * }
+ *
+ * // Get the owner of the shape
+ * const owner = visionShape.getPlayerOwner();
+ * ```
+ */
+export declare class RpgShape {
+    /** Name of the shape */
+    name: string;
+    /** Positioning relative to the player */
+    positioning: ShapePositioning;
+    /** Width of the shape in pixels */
+    width: number;
+    /** Height of the shape in pixels */
+    height: number;
+    /** X position of the shape center */
+    x: number;
+    /** Y position of the shape center */
+    y: number;
+    /** Custom properties attached to the shape */
+    properties: object;
+    /** Internal: Player that owns this shape */
+    private _playerOwner?;
+    /** Internal: Zone ID in the physic engine */
+    private _physicZoneId;
+    /** Internal: Map reference for zone queries */
+    private _map;
+    /**
+     * Creates a new RpgShape instance
+     *
+     * @param config - Shape configuration
+     */
+    constructor(config: {
+        name: string;
+        positioning: ShapePositioning;
+        width: number;
+        height: number;
+        x: number;
+        y: number;
+        properties: object;
+        playerOwner?: RpgCommonPlayer;
+        physicZoneId: string;
+        map: any;
+    });
+    /**
+     * Checks if a player is currently inside this shape
+     *
+     * @param player - The player to check
+     * @returns True if the player is inside the shape
+     *
+     * @example
+     * ```ts
+     * const shape = player.attachShape("detection", { radius: 100 });
+     * if (shape.playerIsIn(otherPlayer)) {
+     *   console.log("Player detected in zone");
+     * }
+     * ```
+     */
+    playerIsIn(player: RpgCommonPlayer): boolean;
+    /**
+     * Gets the player that owns this shape
+     *
+     * Returns the player on which `attachShape()` was called to create this shape.
+     *
+     * @returns The player owner or undefined if not available
+     *
+     * @example
+     * ```ts
+     * const shape = player.attachShape("vision", { radius: 150 });
+     * const owner = shape.getPlayerOwner();
+     * console.log(owner?.name); // Player's name
+     * ```
+     */
+    getPlayerOwner(): RpgCommonPlayer | undefined;
+}

package/dist/Utils.d.ts

@@ -1,4 +1,5 @@
 export type Constructor<T = {}> = new (...args: any[]) => T;
+export declare function delay(cb: () => void, ms?: number): void;
 export declare function random(min: number, max: number): number;
 export declare function isBrowser(): boolean;
 export declare function isFunction(val: unknown): boolean;

package/dist/database/Item.d.ts

@@ -1,10 +1,26 @@
 import { RpgCommonPlayer } from '../Player';
+interface ItemData {
+    name: string;
+    description: string;
+    price: number;
+    quantity: number;
+    atk: number;
+    pdef: number;
+    sdef: number;
+    icon: string;
+    onAdd: (player: RpgCommonPlayer) => void;
+}
 export declare class Item {
     id: import('@signe/reactive').WritableSignal<string>;
     name: import('@signe/reactive').WritableSignal<string>;
     description: import('@signe/reactive').WritableSignal<string>;
     price: import('@signe/reactive').WritableSignal<number>;
+    atk: import('@signe/reactive').WritableSignal<number>;
+    pdef: import('@signe/reactive').WritableSignal<number>;
+    sdef: import('@signe/reactive').WritableSignal<number>;
+    icon: import('@signe/reactive').WritableSignal<string>;
     quantity: import('@signe/reactive').WritableSignal<number>;
     onAdd: (player: RpgCommonPlayer) => void;
-    constructor(data: any);
+    constructor(data?: ItemData);
 }
+export {};

package/dist/database/Skill.d.ts

@@ -0,0 +1,21 @@
+export interface SkillData {
+    id: string;
+    name: string;
+    description: string;
+    spCost: number;
+    hitRate: number;
+    power: number;
+    coefficient: Record<string, number>;
+    icon: string;
+}
+export declare class Skill {
+    id: import('@signe/reactive').WritableSignal<string>;
+    name: import('@signe/reactive').WritableSignal<string>;
+    description: import('@signe/reactive').WritableSignal<string>;
+    spCost: import('@signe/reactive').WritableSignal<number>;
+    icon: import('@signe/reactive').WritableSignal<string>;
+    hitRate: import('@signe/reactive').WritableSignal<number>;
+    power: import('@signe/reactive').WritableSignal<number>;
+    coefficient: import('@signe/reactive').WritableObjectSignal<{}>;
+    constructor(data?: SkillData);
+}

package/dist/database/index.d.ts

@@ -1 +1,2 @@
 export * from './Item';
+export * from './Skill';

package/dist/index.d.ts

@@ -1,9 +1,14 @@
 export * from './Player';
+export * from './Shape';
 export * from './rooms/Map';
+export * from './rooms/WorldMaps';
 export * from './modules';
 export * from './services/updateMap';
+export * from './services/save';
 export * from './Utils';
 export * from './PrebuiltGui';
-export * from './movement';
-export * as Matter from 'matter-js';
 export * from './database';
+export * from './PerlinNoise';
+export * from '@rpgjs/physic';
+export * from './Presets';
+export * from './weather';