@rpgjs/common 4.3.0 → 5.0.0-alpha.0

package/dist/modules.d.ts

@@ -0,0 +1,92 @@
+import { Context, Provider } from '@signe/di';
+import { Observable } from 'rxjs';
+export declare const ModulesToken = "ModulesToken";
+export declare class Hooks {
+    private modules;
+    private namespace;
+    /**
+     * Store of all module hooks by ID
+     */
+    private moduleHooks;
+    /**
+     * Store of all hook functions by ID
+     */
+    private hookFunctions;
+    constructor(modules: any[], namespace: string);
+    private init;
+    /**
+     * Call hooks for a specific ID, passing arguments to all subscribed hooks
+     *
+     * @param hookId - The unique identifier of the module hook
+     * @param args - Arguments to pass to the hook functions
+     * @returns An Observable that emits an array with all hook results when subscribed
+     * @example
+     * ```ts
+     * // Call all hook functions for the ID 'my-namespace-type-hook'
+     * callHooks('my-namespace-type-hook', { x: 10, y: 20 }).subscribe(results => {
+     *   console.log('Hook results:', results);  // Array of all hook function results
+     * });
+     *
+     * // Hook functions are only executed when you subscribe to the returned Observable
+     * const observable = callHooks('my-namespace-type-hook', player);
+     * // ... later ...
+     * observable.subscribe(results => {
+     *   // Process results array
+     * });
+     * ```
+     */
+    callHooks(hookId: string, ...args: any[]): Observable<any[]>;
+}
+/**
+ * Provide modules configuration to Angular Dependency Injection
+ * Registers hook functions for later execution
+ *
+ * @param modules - Array of modules to provide
+ * @param namespace - Namespace to prefix hook IDs
+ * @returns Provider configuration for Angular DI
+ * @example
+ * ```ts
+ * // Define modules
+ * const modules = [
+ *   {
+ *     player: {
+ *       onMove: (player) => {
+ *         // Handle player movement
+ *       }
+ *     }
+ *   }
+ * ];
+ *
+ * // Provide modules
+ * const provider = provideModules(modules, 'game');
+ * ```
+ */
+export declare function provideModules(modules: any[], namespace: string, transform?: (modules: any, context: Context) => any): {
+    provide: string;
+    useFactory: (context: Context) => Hooks;
+};
+export declare function findModules(context: Context, namespace: string): any[];
+/**
+ * Create module providers from a token name and array of providers
+ * Transforms objects with server/client properties into separate ModuleServer and ModuleClient providers
+ *
+ * @param tokenName - The base token name for the module
+ * @param providers - Array of providers that can be regular providers or objects with server/client properties
+ * @returns Flattened array of providers with transformed server/client objects
+ * @example
+ * ```ts
+ * // Input: createModule('battle', [{ server: serverModule, client: clientModule }])
+ * // Output: [
+ * //   { provide: 'battleModuleServer', useValue: { server: serverModule, client: clientModule }, meta: { server: true, isModule: true } },
+ * //   { provide: 'battleModuleClient', useValue: { server: serverModule, client: clientModule }, meta: { client: true, isModule: true } }
+ * // ]
+ *
+ * // Regular providers are passed through unchanged
+ * createModule('battle', [regularProvider, { server, client }])
+ * ```
+ */
+export declare function createModule(tokenName: string, providers: (Provider | Provider[] | ({
+    server?: any;
+    client?: any;
+}))[]): any[];
+export declare function defineModule<T>(options: T): T;

package/dist/movement/MovementManager.d.ts

@@ -0,0 +1,84 @@
+import { MovementStrategy } from './MovementStrategy';
+import { RpgCommonPhysic } from '../Physic';
+/**
+ * Manager for entity movement strategies
+ *
+ * Handles the execution and lifecycle of all movement strategies
+ * for entities in the game world.
+ *
+ * @example
+ * ```ts
+ * // In game loop
+ * const movementManager = new MovementManager();
+ *
+ * // Add dash movement to player
+ * movementManager.add('player1', new Dash(200, { x: 1, y: 0 }, 300));
+ *
+ * // Update in game loop
+ * function gameLoop(dt) {
+ *   movementManager.update(dt, physic);
+ *   physic.update(dt);
+ * }
+ * ```
+ */
+export declare class MovementManager {
+    /** Map of entity IDs to their active movement strategies */
+    private strategies;
+    /**
+     * Add a movement strategy to an entity
+     *
+     * @param id - Entity ID
+     * @param strategy - Movement strategy to apply
+     */
+    add(id: string, strategy: MovementStrategy): void;
+    /**
+     * Remove a specific movement strategy from an entity
+     *
+     * @param id - Entity ID
+     * @param strategy - The strategy instance to remove
+     * @returns True if the strategy was found and removed
+     */
+    remove(id: string, strategy: MovementStrategy): boolean;
+    /**
+     * Remove all movement strategies from an entity
+     *
+     * @param id - Entity ID
+     */
+    clear(id: string): void;
+    /**
+     * Check if an entity has any active movement strategies
+     *
+     * @param id - Entity ID
+     * @returns True if entity has active strategies
+     *
+     * @example
+     * ```ts
+     * // Check if player has active movements
+     * if (movementManager.hasActiveStrategies('player1')) {
+     *   // Don't accept input while movements are active
+     * }
+     * ```
+     */
+    hasActiveStrategies(id: string): boolean;
+    /**
+     * Get all active movement strategies for an entity
+     *
+     * @param id - Entity ID
+     * @returns Array of active strategies or empty array if none
+     *
+     * @example
+     * ```ts
+     * // Get all player movements
+     * const movements = movementManager.getStrategies('player1');
+     * ```
+     */
+    getStrategies(id: string): MovementStrategy[];
+    /**
+     * Update all movement strategies
+     * Must be called BEFORE physics.update()
+     *
+     * @param dt - Time delta in milliseconds
+     * @param physic - Physics system to get bodies from
+     */
+    update(dt: number, physic: RpgCommonPhysic): void;
+}

package/dist/movement/MovementStrategy.d.ts

@@ -0,0 +1,39 @@
+import * as Matter from 'matter-js';
+/**
+ * Interface defining the contract for movement strategies
+ *
+ * Movement strategies are responsible for calculating how a body should move
+ * each frame without directly modifying the physics engine.
+ *
+ * @example
+ * ```ts
+ * class SimpleMove implements MovementStrategy {
+ *   constructor(private vx: number, private vy: number) {}
+ *
+ *   update(body: Matter.Body, dt: number): void {
+ *     Matter.Body.setVelocity(body, { x: this.vx, y: this.vy });
+ *   }
+ * }
+ * ```
+ */
+export interface MovementStrategy {
+    /**
+     * Called each frame BEFORE the physics engine update
+     * Calculates and applies movement to the provided body
+     *
+     * @param body - The Matter.js body to move
+     * @param dt - Time delta in milliseconds
+     */
+    update(body: Matter.Body, dt: number): void;
+    /**
+     * Returns true when the movement is finished (optional)
+     * If implemented, the strategy will be automatically removed
+     * from the movement manager when it returns true
+     */
+    isFinished?(): boolean;
+    /**
+     * Event triggered when the movement completes (optional)
+     * Useful for chaining movements
+     */
+    onFinished?(): void;
+}

package/dist/movement/index.d.ts

@@ -0,0 +1,12 @@
+export * from './MovementStrategy';
+export * from './MovementManager';
+export * from './strategies/LinearMove';
+export * from './strategies/Dash';
+export * from './strategies/Knockback';
+export * from './strategies/PathFollow';
+export * from './strategies/Oscillate';
+export * from './strategies/CompositeMovement';
+export * from './strategies/SeekAvoid';
+export * from './strategies/LinearRepulsion';
+export * from './strategies/IceMovement';
+export * from './strategies/ProjectileMovement';

package/dist/movement/strategies/CompositeMovement.d.ts

@@ -0,0 +1,76 @@
+import { MovementStrategy } from '../MovementStrategy';
+import * as Matter from 'matter-js';
+/**
+ * Combines multiple movement strategies into a single movement
+ *
+ * Allows composition of movement patterns by either:
+ * - Running multiple strategies in parallel (adding their effects)
+ * - Running strategies in sequence (one after another)
+ *
+ * @example
+ * ```ts
+ * // Parallel movement (oscillate while following a path)
+ * const composite = new CompositeMovement('parallel', [
+ *   new PathFollow(waypoints, 2),
+ *   new Oscillate({ x: 0, y: 1 }, 10, 1000)
+ * ]);
+ *
+ * // Sequential movement (dash, then knockback)
+ * const sequence = new CompositeMovement('sequence', [
+ *   new Dash(8, { x: 1, y: 0 }, 200),
+ *   new Knockback({ x: -0.5, y: 0 }, 3, 300)
+ * ]);
+ *
+ * movementManager.add('entity1', composite);
+ * ```
+ */
+export declare class CompositeMovement implements MovementStrategy {
+    private mode;
+    private strategies;
+    private currentStrategyIndex;
+    /**
+     * Create a composite movement
+     *
+     * @param mode - How to combine strategies ('parallel' or 'sequence')
+     * @param strategies - Array of movement strategies to combine
+     */
+    constructor(mode: 'parallel' | 'sequence', strategies: MovementStrategy[]);
+    /**
+     * Apply the composite movement
+     *
+     * @param body - Matter.js body to move
+     * @param dt - Time delta in milliseconds
+     */
+    update(body: Matter.Body, dt: number): void;
+    /**
+     * Update all strategies in parallel
+     */
+    private updateParallel;
+    /**
+     * Update strategies in sequence
+     */
+    private updateSequence;
+    /**
+     * Check if all strategies have finished
+     *
+     * @returns True if all strategies are completed
+     */
+    isFinished(): boolean;
+    /**
+     * Add a new strategy to the composite
+     *
+     * @param strategy - Movement strategy to add
+     */
+    add(strategy: MovementStrategy): void;
+    /**
+     * Remove a strategy from the composite
+     *
+     * @param strategy - Movement strategy to remove
+     * @returns True if the strategy was found and removed
+     */
+    remove(strategy: MovementStrategy): boolean;
+    /**
+     * Reset the composite to start from the beginning
+     */
+    reset(): void;
+}

package/dist/movement/strategies/Dash.d.ts

@@ -0,0 +1,52 @@
+import { MovementStrategy } from '../MovementStrategy';
+import * as Matter from 'matter-js';
+/**
+ * Implements a dash movement in a specified direction for a limited time
+ *
+ * Dash applies high velocity movement in a direction for a short duration
+ *
+ * @example
+ * ```ts
+ * // Dash right for 200ms at speed 10
+ * movementManager.add('player1', new Dash(10, { x: 1, y: 0 }, 200));
+ *
+ * // Dash diagonally (normalized)
+ * movementManager.add('player1', new Dash(8, { x: 0.7071, y: 0.7071 }, 150));
+ * ```
+ */
+export declare class Dash implements MovementStrategy {
+    private speed;
+    private direction;
+    private duration;
+    private elapsed;
+    private finished;
+    /**
+     * Create a dash movement
+     *
+     * @param speed - Movement speed (pixels per frame)
+     * @param direction - Normalized direction vector { x, y }
+     * @param duration - Duration in milliseconds
+     */
+    constructor(speed: number, direction: {
+        x: number;
+        y: number;
+    }, duration: number);
+    /**
+     * Apply dash movement to the body
+     *
+     * @param body - Matter.js body to move
+     * @param dt - Time delta in milliseconds
+     */
+    update(body: Matter.Body, dt: number): void;
+    /**
+     * Check if dash duration has elapsed
+     *
+     * @returns True if dash is complete
+     */
+    isFinished(): boolean;
+    /**
+     * Optional callback for when dash completes
+     * Can be used to chain into another movement
+     */
+    onFinished(): void;
+}

package/dist/movement/strategies/IceMovement.d.ts

@@ -0,0 +1,87 @@
+import { MovementStrategy } from '../MovementStrategy';
+import * as Matter from 'matter-js';
+/**
+ * Implements a slippery movement for icy surfaces
+ *
+ * Creates a realistic ice-physics effect with:
+ * - Slow acceleration when starting to move
+ * - Slippery inertia when stopping
+ * - Gradual turning with momentum
+ *
+ * @example
+ * ```ts
+ * // Apply ice movement to player on ice terrain
+ * movementManager.add('player1', new IceMovement({ x: 1, y: 0 }, 5));
+ *
+ * // Update direction when player changes direction
+ * iceMovement.setTargetDirection({ x: 0, y: 1 });
+ * ```
+ */
+export declare class IceMovement implements MovementStrategy {
+    private targetDirection;
+    private maxSpeed;
+    private acceleration;
+    private friction;
+    private duration?;
+    private currentVx;
+    private currentVy;
+    private stopped;
+    private elapsed;
+    /**
+     * Create an ice movement behavior
+     *
+     * @param targetDirection - Desired movement direction (normalized vector)
+     * @param maxSpeed - Maximum speed when fully accelerated
+     * @param acceleration - Acceleration rate (0-1, lower = more slippery start)
+     * @param friction - Friction rate (0-1, lower = more slippery stop)
+     * @param duration - Optional duration limit for the movement
+     */
+    constructor(targetDirection: {
+        x: number;
+        y: number;
+    }, maxSpeed?: number, acceleration?: number, friction?: number, duration?: number | undefined);
+    /**
+     * Update the ice movement physics
+     *
+     * @param body - Matter.js body to move
+     * @param dt - Time delta in milliseconds
+     */
+    update(body: Matter.Body, dt: number): void;
+    /**
+     * Check if movement is finished
+     * (movement is considered finished when almost stopped)
+     *
+     * @returns True if movement is effectively stopped
+     */
+    isFinished(): boolean;
+    /**
+     * Stop the movement (will start applying friction)
+     */
+    stop(): void;
+    /**
+     * Resume movement in the current direction
+     */
+    resume(): void;
+    /**
+     * Set a new target direction
+     * The actual movement will gradually change toward this direction
+     *
+     * @param direction - New target direction
+     */
+    setTargetDirection(direction: {
+        x: number;
+        y: number;
+    }): void;
+    /**
+     * Set movement parameters
+     *
+     * @param maxSpeed - New maximum speed
+     * @param acceleration - New acceleration rate
+     * @param friction - New friction rate
+     */
+    setParameters(maxSpeed?: number, acceleration?: number, friction?: number): void;
+    /**
+     * Normalize the direction vector
+     */
+    private normalizeDirection;
+}

package/dist/movement/strategies/Knockback.d.ts

@@ -0,0 +1,50 @@
+import { MovementStrategy } from '../MovementStrategy';
+import * as Matter from 'matter-js';
+/**
+ * Implements a knockback effect with decreasing force over time
+ *
+ * Applies an initial velocity that gradually decreases to simulate
+ * being pushed back by an impact
+ *
+ * @example
+ * ```ts
+ * // Knockback player to the left with force 8 for 300ms
+ * movementManager.add('player1', new Knockback({ x: -1, y: 0 }, 8, 300));
+ *
+ * // Knockback with decay (resistance)
+ * movementManager.add('enemy1', new Knockback({ x: 0, y: 1 }, 5, 200, 0.9));
+ * ```
+ */
+export declare class Knockback implements MovementStrategy {
+    private direction;
+    private force;
+    private duration;
+    private decayFactor;
+    private elapsed;
+    private currentSpeed;
+    /**
+     * Create a knockback movement
+     *
+     * @param direction - Normalized direction vector { x, y }
+     * @param force - Initial force of the knockback
+     * @param duration - Duration in milliseconds
+     * @param decayFactor - Speed decay multiplier per frame (0.8-0.95 typical)
+     */
+    constructor(direction: {
+        x: number;
+        y: number;
+    }, force: number, duration: number, decayFactor?: number);
+    /**
+     * Apply knockback movement with decreasing force
+     *
+     * @param body - Matter.js body to move
+     * @param dt - Time delta in milliseconds
+     */
+    update(body: Matter.Body, dt: number): void;
+    /**
+     * Check if knockback duration has elapsed
+     *
+     * @returns True if knockback is complete
+     */
+    isFinished(): boolean;
+}

package/dist/movement/strategies/LinearMove.d.ts

@@ -0,0 +1,43 @@
+import { MovementStrategy } from '../MovementStrategy';
+import * as Matter from 'matter-js';
+/**
+ * Applies constant velocity movement in a specified direction
+ *
+ * Used for simple linear movement at a constant speed
+ *
+ * @example
+ * ```ts
+ * // Move entity right at 5 pixels per frame
+ * movementManager.add('entity1', new LinearMove(5, 0));
+ *
+ * // Move diagonally
+ * movementManager.add('entity1', new LinearMove(3, 3));
+ * ```
+ */
+export declare class LinearMove implements MovementStrategy {
+    private vx;
+    private vy;
+    private duration?;
+    /**
+     * Create a linear movement
+     *
+     * @param vx - X velocity component
+     * @param vy - Y velocity component
+     * @param duration - Optional duration in milliseconds (if not set, movement continues indefinitely)
+     */
+    constructor(vx: number, vy: number, duration?: number | undefined);
+    private elapsed;
+    /**
+     * Apply velocity to the body
+     *
+     * @param body - Matter.js body to move
+     * @param dt - Time delta in milliseconds
+     */
+    update(body: Matter.Body, dt: number): void;
+    /**
+     * Check if movement duration has elapsed
+     *
+     * @returns True if movement should stop
+     */
+    isFinished(): boolean;
+}

package/dist/movement/strategies/LinearRepulsion.d.ts

@@ -0,0 +1,55 @@
+import { RpgCommonPhysic } from '../../Physic';
+import { MovementStrategy } from '../MovementStrategy';
+import * as Matter from 'matter-js';
+/**
+ * Implements a seek behavior with linear obstacle avoidance
+ *
+ * Similar to SeekAvoid but uses a linear repulsion model instead of inverse square.
+ * This creates a smoother avoidance field with gradual transitions.
+ *
+ * @example
+ * ```ts
+ * // Make enemy follow player with smooth avoidance
+ * const playerPosition = () => Matter.Vector.create(player.x(), player.y());
+ * movementManager.add('enemy1', new LinearRepulsion(physics, playerPosition, 3, 50, 5));
+ * ```
+ */
+export declare class LinearRepulsion implements MovementStrategy {
+    private phys;
+    private target;
+    private maxSpeed;
+    private repulseRadius;
+    private repulseWeight;
+    private repulseRadius2;
+    /**
+     * Create a seeking movement with linear obstacle avoidance
+     *
+     * @param phys - Physics system to query for nearby obstacles
+     * @param target - Function returning the current target position
+     * @param maxSpeed - Maximum movement speed
+     * @param repulseRadius - Radius around entity to check for obstacles
+     * @param repulseWeight - Strength of repulsion from obstacles
+     */
+    constructor(phys: RpgCommonPhysic, target: () => Matter.Vector, maxSpeed?: number, repulseRadius?: number, repulseWeight?: number);
+    /**
+     * Update seek and avoid behavior with linear repulsion
+     *
+     * @param body - Matter.js body to move
+     * @param dt - Time delta in milliseconds
+     */
+    update(body: Matter.Body, dt: number): void;
+    /**
+     * Update the target to follow
+     *
+     * @param newTarget - Function returning the new target position
+     */
+    setTarget(newTarget: () => Matter.Vector): void;
+    /**
+     * Update movement parameters
+     *
+     * @param maxSpeed - New maximum speed
+     * @param repulseRadius - New repulsion radius
+     * @param repulseWeight - New repulsion weight
+     */
+    setParameters(maxSpeed?: number, repulseRadius?: number, repulseWeight?: number): void;
+}

package/dist/movement/strategies/Oscillate.d.ts

@@ -0,0 +1,60 @@
+import { MovementStrategy } from '../MovementStrategy';
+import * as Matter from 'matter-js';
+/**
+ * Implements an oscillating movement pattern
+ *
+ * Entity moves back and forth along a single axis or in a pattern
+ * like sine wave, useful for patrols or ambient movements
+ *
+ * @example
+ * ```ts
+ * // Horizontal oscillation with amplitude 100 and period 3000ms
+ * movementManager.add('entity1', new Oscillate({ x: 1, y: 0 }, 100, 3000));
+ *
+ * // Vertical oscillation
+ * movementManager.add('entity1', new Oscillate({ x: 0, y: 1 }, 50, 2000));
+ *
+ * // Circular oscillation
+ * movementManager.add('entity1', new Oscillate({ x: 1, y: 0 }, 100, 4000, 'circular'));
+ * ```
+ */
+export declare class Oscillate implements MovementStrategy {
+    private direction;
+    private amplitude;
+    private period;
+    private type;
+    private duration?;
+    private elapsed;
+    private startPosition;
+    private positionSet;
+    /**
+     * Create an oscillating movement
+     *
+     * @param direction - Primary axis of oscillation (normalized)
+     * @param amplitude - Maximum distance from center position
+     * @param period - Time in ms for a complete cycle
+     * @param type - Oscillation pattern type ('linear', 'sine', 'circular')
+     * @param duration - Optional total duration in ms (undefined for infinite)
+     */
+    constructor(direction: {
+        x: number;
+        y: number;
+    }, amplitude: number, period: number, type?: 'linear' | 'sine' | 'circular', duration?: number | undefined);
+    /**
+     * Apply oscillating movement
+     *
+     * @param body - Matter.js body to move
+     * @param dt - Time delta in milliseconds
+     */
+    update(body: Matter.Body, dt: number): void;
+    /**
+     * Check if oscillation duration has elapsed
+     *
+     * @returns True if movement is finished
+     */
+    isFinished(): boolean;
+    /**
+     * Reset the oscillation to start from the current position
+     */
+    reset(): void;
+}