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

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

@@ -1,52 +0,0 @@
-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

@@ -1,87 +0,0 @@
-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

@@ -1,50 +0,0 @@
-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

@@ -1,43 +0,0 @@
-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

@@ -1,55 +0,0 @@
-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

@@ -1,60 +0,0 @@
-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;
-}

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

@@ -1,78 +0,0 @@
-import { MovementStrategy } from '../MovementStrategy';
-import * as Matter from 'matter-js';
-/**
- * Implements a path following movement that navigates through waypoints
- *
- * The entity will follow a sequence of waypoints at a specified speed,
- * with optional looping behavior.
- *
- * @example
- * ```ts
- * // Create a patrol path for an NPC
- * const waypoints = [
- *   { x: 100, y: 100 },
- *   { x: 300, y: 100 },
- *   { x: 300, y: 300 },
- *   { x: 100, y: 300 }
- * ];
- *
- * // Follow path once
- * movementManager.add('npc1', new PathFollow(waypoints, 3));
- *
- * // Loop indefinitely (patrol)
- * movementManager.add('npc1', new PathFollow(waypoints, 3, true));
- * ```
- */
-export declare class PathFollow implements MovementStrategy {
-    private waypoints;
-    private speed;
-    private loop;
-    private pauseAtWaypoints;
-    private currentWaypoint;
-    private finished;
-    private direction;
-    private waypointThreshold;
-    /**
-     * Create a path following movement
-     *
-     * @param waypoints - Array of x,y positions to follow
-     * @param speed - Movement speed in pixels per frame
-     * @param loop - Whether to loop back to start after reaching final waypoint
-     * @param pauseAtWaypoints - Optional time in ms to pause at each waypoint
-     */
-    constructor(waypoints: Array<{
-        x: number;
-        y: number;
-    }>, speed: number, loop?: boolean, pauseAtWaypoints?: number);
-    private pauseTimer;
-    private isPaused;
-    /**
-     * Update path following logic
-     *
-     * @param body - Matter.js body to move
-     * @param dt - Time delta in milliseconds
-     */
-    update(body: Matter.Body, dt: number): void;
-    /**
-     * Check if path has been fully traversed
-     *
-     * @returns True if path following is complete
-     */
-    isFinished(): boolean;
-    /**
-     * Get current waypoint index
-     *
-     * @returns The index of the current target waypoint
-     */
-    getCurrentWaypoint(): number;
-    /**
-     * Set a new path of waypoints
-     *
-     * @param waypoints - New waypoints to follow
-     * @param resetProgress - Whether to start from the first waypoint
-     */
-    setWaypoints(waypoints: Array<{
-        x: number;
-        y: number;
-    }>, resetProgress?: boolean): void;
-}

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

@@ -1,138 +0,0 @@
-import { MovementStrategy } from '../MovementStrategy';
-import * as Matter from 'matter-js';
-/**
- * Type of projectile trajectory
- */
-export declare enum ProjectileType {
-    /** Straight line movement (arrows, bullets) */
-    Straight = "straight",
-    /** Parabolic arc (grenades, bombs) */
-    Arc = "arc",
-    /** Bouncing projectile (bouncing bombs, coins) */
-    Bounce = "bounce"
-}
-/**
- * Projectile configuration options
- */
-export interface ProjectileOptions {
-    /** Initial velocity in pixels per second */
-    speed: number;
-    /** Direction vector (will be normalized) */
-    direction: {
-        x: number;
-        y: number;
-    };
-    /** Maximum range in pixels before projectile disappears */
-    maxRange?: number;
-    /** Maximum lifetime in milliseconds */
-    lifetime?: number;
-    /** Initial height (Z coordinate) */
-    initialHeight?: number;
-    /** Maximum height of arc trajectory */
-    maxHeight?: number;
-    /** Gravity strength (pixels/second²) */
-    gravity?: number;
-    /** Number of bounces allowed (for bouncing projectiles) */
-    maxBounces?: number;
-    /** Energy retained after each bounce (0-1) */
-    bounciness?: number;
-    /** Air resistance/drag (0-1) */
-    drag?: number;
-}
-/**
- * Implements projectile movement with various trajectory types
- *
- * Supports:
- * - Straight movement (arrows, bullets)
- * - Parabolic arcs (thrown objects, grenades)
- * - Bouncing projectiles (coins, bouncing bombs)
- *
- * The z-coordinate represents height above ground for 3D effects
- *
- * @example
- * ```ts
- * // Create an arrow (straight projectile)
- * const arrow = new ProjectileMovement(ProjectileType.Straight, {
- *   speed: 300,
- *   direction: { x: 1, y: 0 },
- *   maxRange: 500
- * });
- *
- * // Create a thrown bomb (arc projectile)
- * const bomb = new ProjectileMovement(ProjectileType.Arc, {
- *   speed: 150,
- *   direction: { x: 0.7, y: 0.7 },
- *   maxHeight: 100,
- *   gravity: 400
- * });
- *
- * // Create bouncing coins (random directions with bounce)
- * function spawnCoin(x, y) {
- *   const randomAngle = Math.random() * Math.PI * 2;
- *   const coin = new ProjectileMovement(ProjectileType.Bounce, {
- *     speed: 80 + Math.random() * 40,
- *     direction: {
- *       x: Math.cos(randomAngle),
- *       y: Math.sin(randomAngle)
- *     },
- *     initialHeight: 0,
- *     maxHeight: 20 + Math.random() * 30,
- *     gravity: 500,
- *     maxBounces: 2,
- *     bounciness: 0.6
- *   });
- *
- *   // Create coin entity and add to the world
- *   // movementManager.add(coinId, coin);
- * }
- * ```
- */
-export declare class ProjectileMovement implements MovementStrategy {
-    private type;
-    private options;
-    private elapsed;
-    private distanceTraveled;
-    private startPosition;
-    private bounceCount;
-    private stage;
-    private finished;
-    private currentHeight;
-    private verticalVelocity;
-    private normalizedDirection;
-    private readonly defaultOptions;
-    /**
-     * Create a projectile movement
-     *
-     * @param type - Type of projectile trajectory
-     * @param options - Projectile configuration
-     */
-    constructor(type: ProjectileType, options: ProjectileOptions);
-    /**
-     * Update projectile movement
-     *
-     * @param body - Matter.js body to move
-     * @param dt - Time delta in milliseconds
-     */
-    update(body: Matter.Body, dt: number): void;
-    /**
-     * Update projectile while in flying stage
-     */
-    private updateFlying;
-    /**
-     * Update projectile while in bouncing stage (rolling/sliding)
-     */
-    private updateBouncing;
-    /**
-     * Check if projectile has completed its trajectory
-     */
-    isFinished(): boolean;
-    /**
-     * Get current height of projectile above ground
-     */
-    getHeight(): number;
-    /**
-     * Get position along trajectory (0 to 1)
-     * Useful for animation progress
-     */
-    getProgress(): number;
-}

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

@@ -1,27 +0,0 @@
-import { RpgCommonPhysic } from '../../Physic';
-import { MovementStrategy } from '../MovementStrategy';
-import * as Matter from 'matter-js';
-export declare class SeekAvoid implements MovementStrategy {
-    private phys;
-    private targetBody?;
-    private maxSpeed;
-    private repulseRadius;
-    private repulseWeight;
-    private arriveRadius;
-    private repulseRadius2;
-    private arriveRadius2;
-    /** (4 px)² : plancher pour éviter les divisions par 0 */
-    private readonly EPS2;
-    /**
-     * @param phys          Monde physique
-     * @param target        Fonction → position à suivre
-     * @param maxSpeed      Vitesse max (px / ms)
-     * @param repulseRadius Rayon de répulsion
-     * @param repulseWeight Intensité de la répulsion
-     * @param arriveRadius  Rayon dans lequel on “arrive” (≃ taille hitbox)
-     * @param getTargetBody (optionnel) fonction → body de la cible pour l’ignorer
-     */
-    constructor(phys: RpgCommonPhysic, targetBody?: Matter.Body, maxSpeed?: number, repulseRadius?: number, repulseWeight?: number, arriveRadius?: number);
-    update(body: Matter.Body, dt: number): void;
-    setParameters(max?: number, repR?: number, repW?: number, arrR?: number): void;
-}