@rpgjs/common 4.3.0 → 5.0.0-alpha.1

package/src/movement/strategies/LinearMove.ts

@@ -0,0 +1,58 @@
+import * as Matter from 'matter-js';
+import { MovementStrategy } from '../MovementStrategy';
+
+/**
+ * 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 class LinearMove implements MovementStrategy {
+  /**
+   * 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(
+    private vx: number, 
+    private vy: number, 
+    private duration?: number
+  ) {
+    this.elapsed = 0;
+  }
+
+  private elapsed: number;
+
+  /**
+   * 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 {
+    if (this.duration !== undefined) {
+      this.elapsed += dt;
+    }
+    
+    Matter.Body.setVelocity(body, { x: this.vx, y: this.vy });
+  }
+
+  /**
+   * Check if movement duration has elapsed
+   * 
+   * @returns True if movement should stop
+   */
+  isFinished(): boolean {
+    return this.duration !== undefined && this.elapsed >= this.duration;
+  }
+} 

package/src/movement/strategies/LinearRepulsion.ts

@@ -0,0 +1,128 @@
+import * as Matter from 'matter-js';
+import { RpgCommonPhysic } from '../../Physic';
+import { MovementStrategy } from '../MovementStrategy';
+
+/** Utilitaires Vec2 pour éviter des new() à chaque frame */
+const vTmp1 = Matter.Vector.create();
+const vTmp2 = Matter.Vector.create();
+
+/**
+ * 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 class LinearRepulsion implements MovementStrategy {
+  private repulseRadius2: number;
+  
+  /**
+   * 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(
+    private phys: RpgCommonPhysic,
+    private target: () => Matter.Vector,
+    private maxSpeed = 2.5,
+    private repulseRadius = 32,
+    private repulseWeight = 4
+  ) {
+    this.repulseRadius2 = this.repulseRadius * this.repulseRadius;
+  }
+
+  /**
+   * 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 {
+    // 1) Attraction (pull) vers la cible actuelle
+    Matter.Vector.sub(this.target(), body.position, vTmp1);
+    const distance = Matter.Vector.magnitude(vTmp1);
+    if (distance > 0.0001) Matter.Vector.mult(vTmp1, 1 / distance, vTmp1);
+
+    // 2) Répulsion linéaire - force plus douce qui diminue graduellement
+    const area = {
+      min: { x: body.position.x - this.repulseRadius,
+             y: body.position.y - this.repulseRadius },
+      max: { x: body.position.x + this.repulseRadius,
+             y: body.position.y + this.repulseRadius }
+    };
+    const nearby = Matter.Query.region(this.phys.getWorld().bodies, area);
+
+    let pushX = 0, pushY = 0;
+    for (const b of nearby) {
+      if (b === body || b.isSensor) continue;
+      
+      Matter.Vector.sub(body.position, b.position, vTmp2);
+      const d2 = Matter.Vector.magnitudeSquared(vTmp2);
+      
+      if (d2 > this.repulseRadius2) continue;  // trop loin, pas de répulsion
+      
+      // Répulsion linéaire: force maximale au centre, nulle au bord
+      const d = Math.sqrt(d2);
+      const w = this.repulseWeight * (this.repulseRadius - d) / this.repulseRadius;
+      
+      // Normalisation du vecteur de répulsion
+      if (d > 0.0001) {
+        pushX += vTmp2.x * w / d;
+        pushY += vTmp2.y * w / d;
+      }
+    }
+
+    // Limiter la norme du push cumulé
+    const MAX_PUSH_LEN = this.maxSpeed * 3;
+    let pushLen = Math.hypot(pushX, pushY);
+    if (pushLen > MAX_PUSH_LEN) {
+      pushX = pushX * MAX_PUSH_LEN / pushLen;
+      pushY = pushY * MAX_PUSH_LEN / pushLen;
+    }
+
+    // 3) Vitesse désirée = pull + push, puis clamp à maxSpeed
+    const desired = Matter.Vector.create(
+      vTmp1.x * this.maxSpeed + pushX,
+      vTmp1.y * this.maxSpeed + pushY
+    );
+    const len = Matter.Vector.magnitude(desired);
+    if (len > this.maxSpeed) Matter.Vector.mult(desired, this.maxSpeed / len, desired);
+  
+    Matter.Body.setVelocity(body, desired);
+  }
+  
+  /**
+   * Update the target to follow
+   * 
+   * @param newTarget - Function returning the new target position
+   */
+  setTarget(newTarget: () => Matter.Vector): void {
+    this.target = newTarget;
+  }
+  
+  /**
+   * 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 {
+    if (maxSpeed !== undefined) this.maxSpeed = maxSpeed;
+    if (repulseRadius !== undefined) {
+      this.repulseRadius = repulseRadius;
+      this.repulseRadius2 = this.repulseRadius * this.repulseRadius;
+    }
+    if (repulseWeight !== undefined) this.repulseWeight = repulseWeight;
+  }
+} 

package/src/movement/strategies/Oscillate.ts

@@ -0,0 +1,144 @@
+import * as Matter from 'matter-js';
+import { MovementStrategy } from '../MovementStrategy';
+
+/**
+ * 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 class Oscillate implements MovementStrategy {
+  private elapsed: number = 0;
+  private startPosition: { x: number, y: number } = { x: 0, y: 0 };
+  private positionSet: boolean = false;
+  
+  /**
+   * 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(
+    private direction: { x: number, y: number },
+    private amplitude: number,
+    private period: number,
+    private type: 'linear' | 'sine' | 'circular' = 'sine',
+    private duration?: number
+  ) {
+    // Normalize direction vector
+    const magnitude = Math.sqrt(direction.x * direction.x + direction.y * direction.y);
+    if (magnitude !== 0 && magnitude !== 1) {
+      this.direction = {
+        x: direction.x / magnitude,
+        y: direction.y / magnitude
+      };
+    }
+  }
+  
+  /**
+   * Apply oscillating movement
+   * 
+   * @param body - Matter.js body to move
+   * @param dt - Time delta in milliseconds
+   */
+  update(body: Matter.Body, dt: number): void {
+    // Record start position on first update
+    if (!this.positionSet) {
+      this.startPosition = { ...body.position };
+      this.positionSet = true;
+    }
+    
+    this.elapsed += dt;
+    
+    // Calculate oscillation factor (0 to 1 to 0)
+    let factor: number;
+    let perpFactor: number = 0;
+    
+    // Calculate progress through cycle (0 to 1)
+    const cycleProgress = (this.elapsed % this.period) / this.period;
+    
+    switch (this.type) {
+      case 'linear':
+        // Triangle wave (0->1->0)
+        factor = cycleProgress < 0.5 
+          ? cycleProgress * 2 
+          : (1 - cycleProgress) * 2;
+        break;
+        
+      case 'sine':
+        // Sine wave
+        factor = Math.sin(cycleProgress * Math.PI * 2) * 0.5 + 0.5;
+        break;
+        
+      case 'circular':
+        // Circular motion
+        factor = Math.sin(cycleProgress * Math.PI * 2);
+        perpFactor = Math.cos(cycleProgress * Math.PI * 2);
+        break;
+        
+      default:
+        factor = Math.sin(cycleProgress * Math.PI * 2) * 0.5 + 0.5;
+    }
+    
+    // Calculate new position
+    let newX, newY;
+    
+    if (this.type === 'circular') {
+      // For circular, we need both sine and cosine components
+      const perpDirection = { x: -this.direction.y, y: this.direction.x };
+      
+      newX = this.startPosition.x + 
+             (this.direction.x * factor * this.amplitude) + 
+             (perpDirection.x * perpFactor * this.amplitude);
+             
+      newY = this.startPosition.y + 
+             (this.direction.y * factor * this.amplitude) + 
+             (perpDirection.y * perpFactor * this.amplitude);
+    } else {
+      // Map factor from 0-1 to -1 to 1 range for linear and sine
+      const mappedFactor = factor * 2 - 1;
+      
+      newX = this.startPosition.x + (this.direction.x * mappedFactor * this.amplitude);
+      newY = this.startPosition.y + (this.direction.y * mappedFactor * this.amplitude);
+    }
+    
+    // Calculate velocity based on position difference
+    const vx = (newX - body.position.x) / (dt / 1000);
+    const vy = (newY - body.position.y) / (dt / 1000);
+    
+    // Apply velocity
+    Matter.Body.setVelocity(body, { x: vx, y: vy });
+  }
+  
+  /**
+   * Check if oscillation duration has elapsed
+   * 
+   * @returns True if movement is finished
+   */
+  isFinished(): boolean {
+    return this.duration !== undefined && this.elapsed >= this.duration;
+  }
+  
+  /**
+   * Reset the oscillation to start from the current position
+   */
+  reset(): void {
+    this.elapsed = 0;
+    this.positionSet = false;
+  }
+} 

package/src/movement/strategies/PathFollow.ts

@@ -0,0 +1,156 @@
+import * as Matter from 'matter-js';
+import { MovementStrategy } from '../MovementStrategy';
+
+/**
+ * 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 class PathFollow implements MovementStrategy {
+  private currentWaypoint: number = 0;
+  private finished: boolean = false;
+  private direction: { x: number, y: number } = { x: 0, y: 0 };
+  private waypointThreshold: number = 5; // Distance threshold to consider waypoint reached
+  
+  /**
+   * 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(
+    private waypoints: Array<{ x: number, y: number }>,
+    private speed: number,
+    private loop: boolean = false,
+    private pauseAtWaypoints: number = 0
+  ) {
+    if (waypoints.length === 0) {
+      this.finished = true;
+    }
+  }
+  
+  private pauseTimer: number = 0;
+  private isPaused: boolean = false;
+  
+  /**
+   * Update path following logic
+   * 
+   * @param body - Matter.js body to move
+   * @param dt - Time delta in milliseconds
+   */
+  update(body: Matter.Body, dt: number): void {
+    if (this.finished || this.waypoints.length === 0) {
+      Matter.Body.setVelocity(body, { x: 0, y: 0 });
+      return;
+    }
+    
+    // Handle pausing at waypoints
+    if (this.isPaused) {
+      Matter.Body.setVelocity(body, { x: 0, y: 0 });
+      this.pauseTimer += dt;
+      
+      if (this.pauseTimer >= this.pauseAtWaypoints) {
+        this.isPaused = false;
+        this.pauseTimer = 0;
+      }
+      return;
+    }
+    
+    const currentTarget = this.waypoints[this.currentWaypoint];
+    const distanceX = currentTarget.x - body.position.x;
+    const distanceY = currentTarget.y - body.position.y;
+    const distance = Math.sqrt(distanceX * distanceX + distanceY * distanceY);
+    
+    // Check if waypoint is reached
+    if (distance <= this.waypointThreshold) {
+      // Go to next waypoint
+      this.currentWaypoint++;
+      
+      // Check if we've finished the path
+      if (this.currentWaypoint >= this.waypoints.length) {
+        if (this.loop) {
+          // Loop back to beginning
+          this.currentWaypoint = 0;
+        } else {
+          // End path following
+          this.finished = true;
+          Matter.Body.setVelocity(body, { x: 0, y: 0 });
+          return;
+        }
+      }
+      
+      // Pause at waypoint if specified
+      if (this.pauseAtWaypoints > 0) {
+        this.isPaused = true;
+        this.pauseTimer = 0;
+        return;
+      }
+    }
+    
+    // Calculate movement direction toward current waypoint
+    if (distance > 0) {
+      this.direction = {
+        x: distanceX / distance,
+        y: distanceY / distance
+      };
+    }
+    
+    // Apply velocity toward current waypoint
+    Matter.Body.setVelocity(body, {
+      x: this.direction.x * this.speed,
+      y: this.direction.y * this.speed
+    });
+  }
+  
+  /**
+   * Check if path has been fully traversed
+   * 
+   * @returns True if path following is complete
+   */
+  isFinished(): boolean {
+    return this.finished;
+  }
+  
+  /**
+   * Get current waypoint index
+   * 
+   * @returns The index of the current target waypoint
+   */
+  getCurrentWaypoint(): number {
+    return this.currentWaypoint;
+  }
+  
+  /**
+   * 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 = true): void {
+    this.waypoints = waypoints;
+    if (resetProgress) {
+      this.currentWaypoint = 0;
+    }
+    this.finished = waypoints.length === 0;
+  }
+}