@rpgjs/common 4.2.1 → 5.0.0-alpha.0

package/dist/Player.d.ts

@@ -0,0 +1,198 @@
+import { Item } from './database';
+import { Observable } from 'rxjs';
+import * as Matter from 'matter-js';
+export declare enum Direction {
+    Up = "up",
+    Down = "down",
+    Left = "left",
+    Right = "right"
+}
+export declare enum Animation {
+    Stand = "stand",
+    Walk = "walk",
+    Attack = "attack",
+    Defense = "defense",
+    Skill = "skill"
+}
+export interface Hitbox {
+    w: number;
+    h: number;
+}
+export interface ShowAnimationParams {
+    graphic?: string | string[];
+    animationName: string;
+    loop?: boolean;
+}
+export interface AttachShapeOptions {
+    /** Width of the shape in pixels */
+    width: number;
+    /** Height of the shape in pixels */
+    height: number;
+    /** Circle radius in pixels (for zone shapes) */
+    radius?: number;
+    /** Vision aperture in degrees. 360 = full circle, <360 = cone */
+    angle?: number;
+    /** Facing direction used when angle < 360 */
+    direction?: Direction;
+    /** 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';
+    /** The name of the shape */
+    name?: string;
+    /** An object to retrieve information when interacting with the shape */
+    properties?: object;
+}
+export declare class RpgCommonPlayer {
+    id: string;
+    x: import('@signe/reactive').WritableSignal<number>;
+    y: import('@signe/reactive').WritableSignal<number>;
+    z: import('@signe/reactive').WritableSignal<number>;
+    tint: import('@signe/reactive').WritableSignal<string>;
+    direction: import('@signe/reactive').WritableSignal<Direction>;
+    speed: import('@signe/reactive').WritableSignal<number>;
+    graphics: import('@signe/reactive').WritableArraySignal<any>;
+    canMove: import('@signe/reactive').WritableSignal<boolean>;
+    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>;
+    _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[]>;
+    _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>;
+    private _intendedDirection;
+    /**
+     * 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
+     * player.changeDirection(Direction.Right);
+     * ```
+     */
+    changeDirection(direction: Direction): void;
+    /**
+     * Get the current facing direction
+     *
+     * @returns Current direction the player is facing
+     *
+     * @example
+     * ```ts
+     * const currentDirection = player.getDirection();
+     * if (currentDirection === Direction.Up) {
+     *   // Player is facing up
+     * }
+     * ```
+     */
+    getDirection(): Direction;
+    /**
+     * 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);
+     * ```
+     */
+    setIntendedDirection(direction: Direction | null): void;
+    /**
+     * Get the intended movement direction
+     *
+     * @returns The direction the player intends to move, or null if not moving
+     *
+     * @example
+     * ```ts
+     * const intended = player.getIntendedDirection();
+     * if (intended === Direction.Left) {
+     *   // Player is trying to move left
+     * }
+     * ```
+     */
+    getIntendedDirection(): Direction | null;
+    /**
+     * 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
+     * player.applyPhysic(body);
+     * ```
+     */
+    applyPhysic(body: Matter.Body): void;
+    _showAnimation(params: ShowAnimationParams): 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.
+     *
+     * @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
+     * 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');
+     *   }
+     * });
+     * ```
+     */
+    createMovingHitbox(hitboxes: Array<{
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    }>, options?: {
+        speed?: number;
+    }): Observable<any[]>;
+    getCurrentMap(): any;
+}

package/{lib → dist}/Utils.d.ts

@@ -1,4 +1,4 @@
-import { constructor } from "@rpgjs/types";
+export type Constructor<T = {}> = new (...args: any[]) => T;
 export declare function random(min: number, max: number): number;
 export declare function isBrowser(): boolean;
 export declare function isFunction(val: unknown): boolean;
@@ -14,7 +14,22 @@ export declare function intersection([start1, end1]: [number, number], [start2,
 export declare function capitalize(s: unknown): string;
 export declare function camelToKebab(str: string): string;
 export declare function arrayEquals(a: any[], b: any[]): boolean;
-export declare function applyMixins(derivedCtor: constructor<any>, baseCtors: constructor<any>[]): void;
+/**
+ * Combines multiple mixins into one
+ *
+ * @param mixins - Array of mixin functions to combine
+ * @returns A single mixin function that applies all mixins
+ *
+ * @example
+ * ```ts
+ * const AllMixins = combineMixins([WithStats, WithInventory, WithComponentManager]);
+ * class MyClass extends AllMixins(BaseClass) {
+ *   // MyClass now has all capabilities from all mixins
+ * }
+ * ```
+ */
+export declare function combineMixins(mixins: Array<(<T extends Constructor>(Base: T) => any)>): <T extends Constructor>(Base: T) => T;
+export declare function applyMixins(derivedCtor: any, baseCtors: any[]): void;
 export declare function generateUID(): string;
 export declare function createConstructor<T>(...propNames: any[]): T;
 export declare function sharedArrayBuffer(): any;
@@ -30,6 +45,7 @@ export declare function preciseNow(): number;
 export declare function round(num: number, decimals?: number): number;
 export declare function set(obj: any, path: any, value: any, onlyPlainObject?: boolean): any;
 export declare function elementToPositionAbsolute(element: HTMLElement): void;
+export declare function mergeObjectWithMethods<T, S>(target: T, source: S): T & S;
 declare const _default: {
     random: typeof random;
     isBrowser: typeof isBrowser;
@@ -59,5 +75,6 @@ declare const _default: {
     round: typeof round;
     camelToKebab: typeof camelToKebab;
     elementToPositionAbsolute: typeof elementToPositionAbsolute;
+    mergeObjectWithMethods: typeof mergeObjectWithMethods;
 };
 export default _default;

package/dist/database/Item.d.ts

@@ -0,0 +1,10 @@
+import { RpgCommonPlayer } from '../Player';
+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>;
+    quantity: import('@signe/reactive').WritableSignal<number>;
+    onAdd: (player: RpgCommonPlayer) => void;
+    constructor(data: any);
+}

package/dist/database/index.d.ts

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

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export * from './Player';
+export * from './rooms/Map';
+export * from './modules';
+export * from './services/updateMap';
+export * from './Utils';
+export * from './PrebuiltGui';
+export * from './movement';
+export * as Matter from 'matter-js';
+export * from './database';