@rpgjs/server 5.0.0-alpha.2 → 5.0.0-alpha.21

package/src/Player/MoveManager.ts

@@ -1,7 +1,6 @@
-import { type Constructor } from "@rpgjs/common";
-import { RpgCommonPlayer, Matter, Direction } from "@rpgjs/common";
-import { 
-  MovementManager, 
+import { PlayerCtor, ProjectileType } from "@rpgjs/common";
+import { RpgCommonPlayer, Direction, Entity } from "@rpgjs/common";
+import {
   MovementStrategy,
   LinearMove,
   Dash,
@@ -13,7 +12,6 @@ import {
   LinearRepulsion,
   IceMovement,
   ProjectileMovement,
-  ProjectileType,
   random,
   isFunction,
   capitalize
@@ -34,31 +32,10 @@ interface PlayerWithMixins extends RpgCommonPlayer {
   changeDirection: (direction: Direction) => boolean;
 }
 
-export interface IMoveManager {
-  addMovement(strategy: MovementStrategy): void;
-  removeMovement(strategy: MovementStrategy): boolean;
-  clearMovements(): void;
-  hasActiveMovements(): boolean;
-  getActiveMovements(): MovementStrategy[];
-  
-  moveTo(target: RpgCommonPlayer | { x: number, y: number }): void;
-  stopMoveTo(): void;
-  dash(direction: { x: number, y: number }, speed?: number, duration?: number): void;
-  knockback(direction: { x: number, y: number }, force?: number, duration?: number): void;
-  followPath(waypoints: Array<{ x: number, y: number }>, speed?: number, loop?: boolean): void;
-  oscillate(direction: { x: number, y: number }, amplitude?: number, period?: number): void;
-  applyIceMovement(direction: { x: number, y: number }, maxSpeed?: number): void;
-  shootProjectile(type: ProjectileType, direction: { x: number, y: number }, speed?: number): void;
-  moveRoutes(routes: Routes): Promise<boolean>;
-  infiniteMoveRoute(routes: Routes): void;
-  breakRoutes(force?: boolean): void;
-  replayRoutes(): void;
-}
-
 
 function wait(sec: number) {
   return new Promise((resolve) => {
-      setTimeout(resolve, sec * 1000)
+    setTimeout(resolve, sec * 1000)
   })
 }
 
@@ -116,297 +93,297 @@ export enum Speed {
 class MoveList {
 
   repeatMove(direction: Direction, repeat: number): Direction[] {
-      // Safety check for valid repeat value
-      if (!Number.isFinite(repeat) || repeat < 0 || repeat > 10000) {
-          console.warn('Invalid repeat value:', repeat, 'using default value 1');
-          repeat = 1;
+    // Safety check for valid repeat value
+    if (!Number.isFinite(repeat) || repeat < 0 || repeat > 10000) {
+      console.warn('Invalid repeat value:', repeat, 'using default value 1');
+      repeat = 1;
+    }
+
+    // Ensure repeat is an integer
+    repeat = Math.floor(repeat);
+
+    // Additional safety check - ensure repeat is a safe integer
+    if (repeat < 0 || repeat > Number.MAX_SAFE_INTEGER || !Number.isSafeInteger(repeat)) {
+      console.warn('Unsafe repeat value:', repeat, 'using default value 1');
+      repeat = 1;
+    }
+
+    try {
+      return new Array(repeat).fill(direction);
+    } catch (error) {
+      console.error('Error creating array with repeat:', repeat, error);
+      return [direction]; // Return single direction as fallback
+    }
+  }
+
+  private repeatTileMove(direction: string, repeat: number, propMap: string): CallbackTileMove {
+    return (player: RpgPlayer, map): Direction[] => {
+      const playerSpeed = typeof player.speed === 'function' ? player.speed() : player.speed;
+
+      // Safety checks
+      if (!playerSpeed || playerSpeed <= 0) {
+        console.warn('Invalid player speed:', playerSpeed, 'using default speed 3');
+        return this[direction](repeat);
       }
-      
-      // Ensure repeat is an integer
-      repeat = Math.floor(repeat);
-      
-      // Additional safety check - ensure repeat is a safe integer
-      if (repeat < 0 || repeat > Number.MAX_SAFE_INTEGER || !Number.isSafeInteger(repeat)) {
-          console.warn('Unsafe repeat value:', repeat, 'using default value 1');
-          repeat = 1;
+
+      const repeatTile = Math.floor((map[propMap] || 32) / playerSpeed) * repeat;
+
+      // Additional safety check for the calculated repeat value
+      if (!Number.isFinite(repeatTile) || repeatTile < 0 || repeatTile > 10000) {
+        console.warn('Calculated repeatTile is invalid:', repeatTile, 'using original repeat:', repeat);
+        return this[direction](repeat);
       }
-      
-      try {
-          return new Array(repeat).fill(direction);
-      } catch (error) {
-          console.error('Error creating array with repeat:', repeat, error);
-          return [direction]; // Return single direction as fallback
+
+      // Final safety check before calling the method
+      if (!Number.isSafeInteger(repeatTile)) {
+        console.warn('repeatTile is not a safe integer:', repeatTile, 'using original repeat:', repeat);
+        return this[direction](repeat);
       }
-  }
 
-  private repeatTileMove(direction: string, repeat: number, propMap: string): CallbackTileMove {
-      return (player: RpgPlayer, map): Direction[] => {
-          const playerSpeed = typeof player.speed === 'function' ? player.speed() : player.speed;
-          
-          // Safety checks
-          if (!playerSpeed || playerSpeed <= 0) {
-              console.warn('Invalid player speed:', playerSpeed, 'using default speed 3');
-              return this[direction](repeat);
-          }
-          
-          const repeatTile = Math.floor((map[propMap] || 32) / playerSpeed) * repeat;
-          
-          // Additional safety check for the calculated repeat value
-          if (!Number.isFinite(repeatTile) || repeatTile < 0 || repeatTile > 10000) {
-              console.warn('Calculated repeatTile is invalid:', repeatTile, 'using original repeat:', repeat);
-              return this[direction](repeat);
-          }
-          
-          // Final safety check before calling the method
-          if (!Number.isSafeInteger(repeatTile)) {
-              console.warn('repeatTile is not a safe integer:', repeatTile, 'using original repeat:', repeat);
-              return this[direction](repeat);
-          }
-          
-          try {
-              return this[direction](repeatTile);
-          } catch (error) {
-              console.error('Error calling direction method with repeatTile:', repeatTile, error);
-              return this[direction](repeat); // Fallback to original repeat
-          }
+      try {
+        return this[direction](repeatTile);
+      } catch (error) {
+        console.error('Error calling direction method with repeatTile:', repeatTile, error);
+        return this[direction](repeat); // Fallback to original repeat
       }
+    }
   }
 
   right(repeat: number = 1): Direction[] {
-      return this.repeatMove(Direction.Right, repeat)
+    return this.repeatMove(Direction.Right, repeat)
   }
 
   left(repeat: number = 1): Direction[] {
-      return this.repeatMove(Direction.Left, repeat)
+    return this.repeatMove(Direction.Left, repeat)
   }
 
   up(repeat: number = 1): Direction[] {
-      return this.repeatMove(Direction.Up, repeat)
+    return this.repeatMove(Direction.Up, repeat)
   }
 
   down(repeat: number = 1): Direction[] {
-      return this.repeatMove(Direction.Down, repeat)
+    return this.repeatMove(Direction.Down, repeat)
   }
 
   wait(sec: number): Promise<unknown> {
-      return wait(sec)
+    return wait(sec)
   }
 
   random(repeat: number = 1): Direction[] {
-      // Safety check for valid repeat value
-      if (!Number.isFinite(repeat) || repeat < 0 || repeat > 10000) {
-          console.warn('Invalid repeat value in random:', repeat, 'using default value 1');
-          repeat = 1;
-      }
-      
-      // Ensure repeat is an integer
-      repeat = Math.floor(repeat);
-      
-      // Additional safety check - ensure repeat is a safe integer
-      if (repeat < 0 || repeat > Number.MAX_SAFE_INTEGER || !Number.isSafeInteger(repeat)) {
-          console.warn('Unsafe repeat value in random:', repeat, 'using default value 1');
-          repeat = 1;
-      }
-      
-      try {
-          return new Array(repeat).fill(null).map(() => [
-              Direction.Right,
-              Direction.Left,
-              Direction.Up,
-              Direction.Down
-          ][random(0, 3)]);
-      } catch (error) {
-          console.error('Error creating random array with repeat:', repeat, error);
-          return [Direction.Down]; // Return single direction as fallback
-      }
+    // Safety check for valid repeat value
+    if (!Number.isFinite(repeat) || repeat < 0 || repeat > 10000) {
+      console.warn('Invalid repeat value in random:', repeat, 'using default value 1');
+      repeat = 1;
+    }
+
+    // Ensure repeat is an integer
+    repeat = Math.floor(repeat);
+
+    // Additional safety check - ensure repeat is a safe integer
+    if (repeat < 0 || repeat > Number.MAX_SAFE_INTEGER || !Number.isSafeInteger(repeat)) {
+      console.warn('Unsafe repeat value in random:', repeat, 'using default value 1');
+      repeat = 1;
+    }
+
+    try {
+      return new Array(repeat).fill(null).map(() => [
+        Direction.Right,
+        Direction.Left,
+        Direction.Up,
+        Direction.Down
+      ][random(0, 3)]);
+    } catch (error) {
+      console.error('Error creating random array with repeat:', repeat, error);
+      return [Direction.Down]; // Return single direction as fallback
+    }
   }
 
   tileRight(repeat: number = 1): CallbackTileMove {
-      return this.repeatTileMove('right', repeat, 'tileWidth')
+    return this.repeatTileMove('right', repeat, 'tileWidth')
   }
 
   tileLeft(repeat: number = 1): CallbackTileMove {
-      return this.repeatTileMove('left', repeat, 'tileWidth')
+    return this.repeatTileMove('left', repeat, 'tileWidth')
   }
 
   tileUp(repeat: number = 1): CallbackTileMove {
-      return this.repeatTileMove('up', repeat, 'tileHeight')
+    return this.repeatTileMove('up', repeat, 'tileHeight')
   }
 
   tileDown(repeat: number = 1): CallbackTileMove {
-      return this.repeatTileMove('down', repeat, 'tileHeight')
+    return this.repeatTileMove('down', repeat, 'tileHeight')
   }
 
   tileRandom(repeat: number = 1): CallbackTileMove {
-      return (player: RpgPlayer, map): Direction[] => {
-          // Safety check for valid repeat value
-          if (!Number.isFinite(repeat) || repeat < 0 || repeat > 1000) {
-              console.warn('Invalid repeat value in tileRandom:', repeat, 'using default value 1');
-              repeat = 1;
-          }
-          
-          // Ensure repeat is an integer
-          repeat = Math.floor(repeat);
-          
-          let directions: Direction[] = []
-          for (let i = 0; i < repeat; i++) {
-              const randFn: CallbackTileMove = [
-                  this.tileRight(),
-                  this.tileLeft(),
-                  this.tileUp(),
-                  this.tileDown()
-              ][random(0, 3)]
-              
-              try {
-                  const newDirections = randFn(player, map);
-                  if (Array.isArray(newDirections)) {
-                      directions = [...directions, ...newDirections];
-                  }
-              } catch (error) {
-                  console.warn('Error in tileRandom iteration:', error);
-                  // Continue with next iteration instead of breaking
-              }
-              
-              // Safety check to prevent excessive array growth
-              if (directions.length > 10000) {
-                  console.warn('tileRandom generated too many directions, truncating');
-                  break;
-              }
+    return (player: RpgPlayer, map): Direction[] => {
+      // Safety check for valid repeat value
+      if (!Number.isFinite(repeat) || repeat < 0 || repeat > 1000) {
+        console.warn('Invalid repeat value in tileRandom:', repeat, 'using default value 1');
+        repeat = 1;
+      }
+
+      // Ensure repeat is an integer
+      repeat = Math.floor(repeat);
+
+      let directions: Direction[] = []
+      for (let i = 0; i < repeat; i++) {
+        const randFn: CallbackTileMove = [
+          this.tileRight(),
+          this.tileLeft(),
+          this.tileUp(),
+          this.tileDown()
+        ][random(0, 3)]
+
+        try {
+          const newDirections = randFn(player, map);
+          if (Array.isArray(newDirections)) {
+            directions = [...directions, ...newDirections];
           }
-          return directions
+        } catch (error) {
+          console.warn('Error in tileRandom iteration:', error);
+          // Continue with next iteration instead of breaking
+        }
+
+        // Safety check to prevent excessive array growth
+        if (directions.length > 10000) {
+          console.warn('tileRandom generated too many directions, truncating');
+          break;
+        }
       }
+      return directions
+    }
   }
 
   private _awayFromPlayerDirection(player: RpgPlayer, otherPlayer: RpgPlayer): Direction {
-      const directionOtherPlayer = otherPlayer.getDirection()
-      let newDirection: Direction = Direction.Down
+    const directionOtherPlayer = otherPlayer.getDirection()
+    let newDirection: Direction = Direction.Down
 
-      switch (directionOtherPlayer) {
-          case Direction.Left:
-          case Direction.Right:
-              if (otherPlayer.x() > player.x()) {
-                  newDirection = Direction.Left
-              }
-              else {
-                  newDirection = Direction.Right
-              }
-              break
-          case Direction.Up:
-          case Direction.Down:
-              if (otherPlayer.y() > player.y()) {
-                  newDirection = Direction.Up
-              }
-              else {
-                  newDirection = Direction.Down
-              }
-              break
-      }
-      return newDirection
+    switch (directionOtherPlayer) {
+      case Direction.Left:
+      case Direction.Right:
+        if (otherPlayer.x() > player.x()) {
+          newDirection = Direction.Left
+        }
+        else {
+          newDirection = Direction.Right
+        }
+        break
+      case Direction.Up:
+      case Direction.Down:
+        if (otherPlayer.y() > player.y()) {
+          newDirection = Direction.Up
+        }
+        else {
+          newDirection = Direction.Down
+        }
+        break
+    }
+    return newDirection
   }
 
   private _towardPlayerDirection(player: RpgPlayer, otherPlayer: RpgPlayer): Direction {
-      const directionOtherPlayer = otherPlayer.getDirection()
-      let newDirection: Direction = Direction.Down
- 
-      switch (directionOtherPlayer) {
-          case Direction.Left:
-          case Direction.Right:
-              if (otherPlayer.x() > player.x()) {
-                  newDirection = Direction.Right
-              }
-              else {
-                  newDirection = Direction.Left
-              }
-              break
-          case Direction.Up:
-          case Direction.Down:
-              if (otherPlayer.y() > player.y()) {
-                  newDirection = Direction.Down
-              }
-              else {
-                  newDirection = Direction.Up
-              }
-              break
-      }
-      return newDirection
+    const directionOtherPlayer = otherPlayer.getDirection()
+    let newDirection: Direction = Direction.Down
+
+    switch (directionOtherPlayer) {
+      case Direction.Left:
+      case Direction.Right:
+        if (otherPlayer.x() > player.x()) {
+          newDirection = Direction.Right
+        }
+        else {
+          newDirection = Direction.Left
+        }
+        break
+      case Direction.Up:
+      case Direction.Down:
+        if (otherPlayer.y() > player.y()) {
+          newDirection = Direction.Down
+        }
+        else {
+          newDirection = Direction.Up
+        }
+        break
+    }
+    return newDirection
   }
 
   private _awayFromPlayer({ isTile, typeMov }: { isTile: boolean, typeMov: string }, otherPlayer: RpgPlayer, repeat: number = 1) {
-      const method = (dir: Direction) => {
-          const direction: string = DirectionNames[dir as any] || 'down'
-          return this[isTile ? 'tile' + capitalize(direction) : direction](repeat)
+    const method = (dir: Direction) => {
+      const direction: string = DirectionNames[dir as any] || 'down'
+      return this[isTile ? 'tile' + capitalize(direction) : direction](repeat)
+    }
+    return (player: RpgPlayer, map) => {
+      let newDirection: Direction = Direction.Down
+      switch (typeMov) {
+        case 'away':
+          newDirection = this._awayFromPlayerDirection(player, otherPlayer)
+          break;
+        case 'toward':
+          newDirection = this._towardPlayerDirection(player, otherPlayer)
+          break
       }
-      return (player: RpgPlayer, map) => {
-          let newDirection: Direction = Direction.Down
-          switch (typeMov) {
-              case 'away':
-                  newDirection = this._awayFromPlayerDirection(player, otherPlayer)
-                  break;
-              case 'toward':
-                  newDirection = this._towardPlayerDirection(player, otherPlayer)
-                  break
-          }
-          let direction: any = method(newDirection)
-          if (isFunction(direction)) {
-              direction = direction(player, map)
-          }
-          return direction
+      let direction: any = method(newDirection)
+      if (isFunction(direction)) {
+        direction = direction(player, map)
       }
+      return direction
+    }
   }
 
   towardPlayer(player: RpgPlayer, repeat: number = 1) {
-      return this._awayFromPlayer({ isTile: false, typeMov: 'toward' }, player, repeat)
+    return this._awayFromPlayer({ isTile: false, typeMov: 'toward' }, player, repeat)
   }
 
   tileTowardPlayer(player: RpgPlayer, repeat: number = 1) {
-      return this._awayFromPlayer({ isTile: true, typeMov: 'toward' }, player, repeat)
+    return this._awayFromPlayer({ isTile: true, typeMov: 'toward' }, player, repeat)
   }
 
   awayFromPlayer(player: RpgPlayer, repeat: number = 1): CallbackTileMove {
-      return this._awayFromPlayer({ isTile: false, typeMov: 'away' }, player, repeat)
+    return this._awayFromPlayer({ isTile: false, typeMov: 'away' }, player, repeat)
   }
 
   tileAwayFromPlayer(player: RpgPlayer, repeat: number = 1): CallbackTileMove {
-      return this._awayFromPlayer({ isTile: true, typeMov: 'away' }, player, repeat)
+    return this._awayFromPlayer({ isTile: true, typeMov: 'away' }, player, repeat)
   }
 
   turnLeft(): string {
-      return 'turn-' + Direction.Left
+    return 'turn-' + Direction.Left
   }
 
   turnRight(): string {
-      return 'turn-' + Direction.Right
+    return 'turn-' + Direction.Right
   }
 
   turnUp(): string {
-      return 'turn-' + Direction.Up
+    return 'turn-' + Direction.Up
   }
 
   turnDown(): string {
-      return 'turn-' + Direction.Down
+    return 'turn-' + Direction.Down
   }
 
   turnRandom(): string {
-      return [
-          this.turnRight(),
-          this.turnLeft(),
-          this.turnUp(),
-          this.turnDown()
-      ][random(0, 3)]
+    return [
+      this.turnRight(),
+      this.turnLeft(),
+      this.turnUp(),
+      this.turnDown()
+    ][random(0, 3)]
   }
 
   turnAwayFromPlayer(otherPlayer: RpgPlayer): CallbackTurnMove {
-      return (player: RpgPlayer) => {
-          const direction = this._awayFromPlayerDirection(player, otherPlayer)
-          return 'turn-' + direction
-      }
+    return (player: RpgPlayer) => {
+      const direction = this._awayFromPlayerDirection(player, otherPlayer)
+      return 'turn-' + direction
+    }
   }
 
   turnTowardPlayer(otherPlayer: RpgPlayer): CallbackTurnMove {
-      return (player: RpgPlayer) => {
-          const direction = this._towardPlayerDirection(player, otherPlayer)
-          return 'turn-' + direction
-      }
+    return (player: RpgPlayer) => {
+      const direction = this._towardPlayerDirection(player, otherPlayer)
+      return 'turn-' + direction
+    }
   }
 }
 
@@ -431,7 +408,7 @@ export const Move = new MoveList();
  * - **Strategy Management**: Add, remove, and query movement strategies
  * - **Predefined Movements**: Quick access to common movement patterns
  * - **Composite Movements**: Combine multiple strategies
- * - **Physics Integration**: Seamless integration with Matter.js physics
+ * - **Physics Integration**: Seamless integration with the deterministic @rpgjs/physic engine
  * 
  * ## Available Movement Strategies
  * - `LinearMove`: Constant velocity movement
@@ -475,15 +452,49 @@ export const Move = new MoveList();
  * }
  * ```
  */
-export function WithMoveManager<TBase extends Constructor<RpgCommonPlayer>>(
-  Base: TBase
-): Constructor<IMoveManager> & TBase {
-  return class extends Base implements IMoveManager {
-    
-    // Private properties for infinite route management
-    private _infiniteRoutes: Routes | null = null;
-    private _finishRoute: ((value: boolean) => void) | null = null;
-    private _isInfiniteRouteActive: boolean = false;
+/**
+ * Move Manager Mixin
+ * 
+ * Provides comprehensive movement management capabilities to any class. This mixin handles
+ * various types of movement including pathfinding, physics-based movement, route following,
+ * and advanced movement strategies like dashing, knockback, and projectile movement.
+ * 
+ * @param Base - The base class to extend with movement management
+ * @returns Extended class with movement management methods
+ * 
+ * @example
+ * ```ts
+ * class MyPlayer extends WithMoveManager(BasePlayer) {
+ *   constructor() {
+ *     super();
+ *     this.frequency = Frequency.High;
+ *   }
+ * }
+ * 
+ * const player = new MyPlayer();
+ * player.moveTo({ x: 100, y: 100 });
+ * player.dash({ x: 1, y: 0 }, 8, 200);
+ * ```
+ */
+export function WithMoveManager<TBase extends PlayerCtor>(Base: TBase) {
+  const baseProto = Base.prototype as any;
+  class WithMoveManagerClass extends Base {
+    setAnimation(animationName: string, nbTimes: number): void {
+      if (typeof baseProto.setAnimation === 'function') {
+        baseProto.setAnimation.call(this, animationName, nbTimes);
+      }
+    }
+
+    showComponentAnimation(id: string, params: any): void {
+      if (typeof baseProto.showComponentAnimation === 'function') {
+        baseProto.showComponentAnimation.call(this, id, params);
+      }
+    }
+
+    // Properties for infinite route management
+    _infiniteRoutes: Routes | null = null;
+    _finishRoute: ((value: boolean) => void) | null = null;
+    _isInfiniteRouteActive: boolean = false;
 
     /** 
     * The player passes through the other players (or vice versa). But the player does not go through the events.
@@ -520,7 +531,7 @@ export function WithMoveManager<TBase extends Constructor<RpgCommonPlayer>>(
     set through(value: boolean) {
       this._through.set(value);
     }
-    
+
     get through(): boolean {
       return this._through();
     }
@@ -561,7 +572,7 @@ export function WithMoveManager<TBase extends Constructor<RpgCommonPlayer>>(
     get frequency(): number {
       return this._frequency();
     }
-    
+
     /**
      * Add a custom movement strategy to this entity
      * 
@@ -582,9 +593,9 @@ export function WithMoveManager<TBase extends Constructor<RpgCommonPlayer>>(
      * ```
      */
     addMovement(strategy: MovementStrategy): void {
-      const map = (this as unknown as PlayerWithMixins).getCurrentMap();
+      const map = (this as unknown as PlayerWithMixins).getCurrentMap() as any;
       if (!map) return;
-      
+
       map.moveManager.add((this as unknown as PlayerWithMixins).id, strategy);
     }
 
@@ -605,9 +616,9 @@ export function WithMoveManager<TBase extends Constructor<RpgCommonPlayer>>(
      * ```
      */
     removeMovement(strategy: MovementStrategy): boolean {
-      const map = (this as unknown as PlayerWithMixins).getCurrentMap();
+      const map = (this as unknown as PlayerWithMixins).getCurrentMap() as any;
       if (!map) return false;
-      
+
       return map.moveManager.remove((this as unknown as PlayerWithMixins).id, strategy);
     }
 
@@ -627,9 +638,9 @@ export function WithMoveManager<TBase extends Constructor<RpgCommonPlayer>>(
      * ```
      */
     clearMovements(): void {
-      const map = (this as unknown as PlayerWithMixins).getCurrentMap();
+      const map = (this as unknown as PlayerWithMixins).getCurrentMap() as any;
       if (!map) return;
-      
+
       map.moveManager.clear((this as unknown as PlayerWithMixins).id);
     }
 
@@ -652,9 +663,9 @@ export function WithMoveManager<TBase extends Constructor<RpgCommonPlayer>>(
      * ```
      */
     hasActiveMovements(): boolean {
-      const map = (this as unknown as PlayerWithMixins).getCurrentMap();
+      const map = (this as unknown as PlayerWithMixins).getCurrentMap() as any;
       if (!map) return false;
-      
+
       return map.moveManager.hasActiveStrategies((this as unknown as PlayerWithMixins).id);
     }
 
@@ -674,9 +685,9 @@ export function WithMoveManager<TBase extends Constructor<RpgCommonPlayer>>(
      * ```
      */
     getActiveMovements(): MovementStrategy[] {
-      const map = (this as unknown as PlayerWithMixins).getCurrentMap();
+      const map = (this as unknown as PlayerWithMixins).getCurrentMap() as any;
       if (!map) return [];
-      
+
       return map.moveManager.getStrategies((this as unknown as PlayerWithMixins).id);
     }
 
@@ -702,30 +713,30 @@ export function WithMoveManager<TBase extends Constructor<RpgCommonPlayer>>(
      * ```
      */
     moveTo(target: RpgCommonPlayer | { x: number, y: number }): void {
-      const map = (this as unknown as PlayerWithMixins).getCurrentMap();
+      const map = (this as unknown as PlayerWithMixins).getCurrentMap() as any;
       if (!map) return;
-      
-      let targetBody: Matter.Body | null = null;
-      
+
+      const engine = map.physic;
+
       if ('id' in target) {
-        // Target is a player
-        targetBody = map.physic.getBody(target.id);
-      } else {
-        // Target is a position - create a temporary target function
-        const getTargetPos = () => Matter.Vector.create(target.x, target.y);
+        const targetProvider = () => (map as any).getBody(target.id) ?? null;
         map.moveManager.add(
-          (this as unknown as PlayerWithMixins).id, 
-          new SeekAvoid(map.physic, getTargetPos, 3, 50, 5)
+          (this as unknown as PlayerWithMixins).id,
+          new SeekAvoid(engine, targetProvider, 180, 140, 80, 48)
         );
         return;
       }
-      
-      if (targetBody) {
-        map.moveManager.add(
-          (this as unknown as PlayerWithMixins).id, 
-          new SeekAvoid(map.physic, targetBody, 3, 50, 5)
-        );
-      }
+
+      const staticTarget = new Entity({
+        position: { x: target.x, y: target.y },
+        mass: Infinity,
+      });
+      staticTarget.freeze();
+
+      map.moveManager.add(
+        (this as unknown as PlayerWithMixins).id,
+        new SeekAvoid(engine, () => staticTarget, 80, 140, 80, 48)
+      );
     }
 
     /**
@@ -745,9 +756,9 @@ export function WithMoveManager<TBase extends Constructor<RpgCommonPlayer>>(
      * ```
      */
     stopMoveTo(): void {
-      const map = (this as unknown as PlayerWithMixins).getCurrentMap();
+      const map = (this as unknown as PlayerWithMixins).getCurrentMap() as any;
       if (!map) return;
-      
+
       const strategies = this.getActiveMovements();
       strategies.forEach(strategy => {
         if (strategy instanceof SeekAvoid || strategy instanceof LinearRepulsion) {
@@ -912,7 +923,7 @@ export function WithMoveManager<TBase extends Constructor<RpgCommonPlayer>>(
         maxBounces: type === ProjectileType.Bounce ? 3 : undefined,
         bounciness: type === ProjectileType.Bounce ? 0.6 : undefined
       };
-      
+
       this.addMovement(new ProjectileMovement(type, config));
     }
 
@@ -963,18 +974,18 @@ export function WithMoveManager<TBase extends Constructor<RpgCommonPlayer>>(
       let count = 0;
       let frequence = 0;
       const player = this as unknown as PlayerWithMixins;
-      
+
       // Break any existing route movement
       this.clearMovements();
-      
+
       return new Promise(async (resolve) => {
         // Store the resolve function for potential breaking
         this._finishRoute = resolve;
-        
+
         // Process function routes first
         const processedRoutes = routes.map((route: any) => {
           if (typeof route === 'function') {
-            const map = player.getCurrentMap();
+            const map = player.getCurrentMap() as any;
             if (!map) {
               return undefined;
             }
@@ -982,11 +993,11 @@ export function WithMoveManager<TBase extends Constructor<RpgCommonPlayer>>(
           }
           return route;
         });
-        
+
         // Flatten nested arrays
         const flatRoutes = this.flattenRoutes(processedRoutes);
         let routeIndex = 0;
-        
+
         const executeNextRoute = async (): Promise<void> => {
           // Check if player still exists and is on a map
           if (!player || !player.getCurrentMap()) {
@@ -994,7 +1005,7 @@ export function WithMoveManager<TBase extends Constructor<RpgCommonPlayer>>(
             resolve(false);
             return;
           }
-          
+
           // Handle frequency timing
           if (count >= (player.nbPixelInTile || 32)) {
             if (frequence < (player.frequency || 0)) {
@@ -1003,25 +1014,25 @@ export function WithMoveManager<TBase extends Constructor<RpgCommonPlayer>>(
               return;
             }
           }
-          
+
           frequence = 0;
           count++;
-          
+
           // Check if we've completed all routes
           if (routeIndex >= flatRoutes.length) {
             this._finishRoute = null;
             resolve(true);
             return;
           }
-          
+
           const currentRoute = flatRoutes[routeIndex];
           routeIndex++;
-          
+
           if (currentRoute === undefined) {
             executeNextRoute();
             return;
           }
-          
+
           try {
             // Handle different route types
             if (typeof currentRoute === 'object' && 'then' in currentRoute) {
@@ -1032,7 +1043,7 @@ export function WithMoveManager<TBase extends Constructor<RpgCommonPlayer>>(
               // Handle turn commands
               const directionStr = currentRoute.replace('turn-', '');
               let direction: Direction = Direction.Down;
-              
+
               // Convert string direction to Direction enum
               switch (directionStr) {
                 case 'up':
@@ -1052,7 +1063,7 @@ export function WithMoveManager<TBase extends Constructor<RpgCommonPlayer>>(
                   direction = Direction.Right;
                   break;
               }
-              
+
               if (player.changeDirection) {
                 player.changeDirection(direction);
               }
@@ -1071,7 +1082,8 @@ export function WithMoveManager<TBase extends Constructor<RpgCommonPlayer>>(
                   case Direction.Down: vy = 1; break;
                   case Direction.Up: vy = -1; break;
                 }
-                this.addMovement(new LinearMove(vx * (player.speed?.() || 3), vy * (player.speed?.() || 3), 100));
+                const speed = player.speed?.() ?? 3;
+                this.addMovement(new LinearMove({ x: vx * speed, y: vy * speed }, 0.1));
                 setTimeout(executeNextRoute, 100);
                 return;
               }
@@ -1085,11 +1097,11 @@ export function WithMoveManager<TBase extends Constructor<RpgCommonPlayer>>(
             executeNextRoute();
           }
         };
-        
+
         executeNextRoute();
       });
     }
-    
+
     /**
      * Utility method to flatten nested route arrays
      * 
@@ -1097,18 +1109,13 @@ export function WithMoveManager<TBase extends Constructor<RpgCommonPlayer>>(
      * @param routes - Routes array that may contain nested arrays
      * @returns Flattened array of routes
      */
-    private flattenRoutes(routes: any[]): any[] {
-      const result: any[] = [];
-      
-      for (const route of routes) {
-        if (Array.isArray(route)) {
-          result.push(...this.flattenRoutes(route));
-        } else {
-          result.push(route);
+    private flattenRoutes(routes: Routes): Routes {
+      return routes.reduce((acc: Routes, item) => {
+        if (Array.isArray(item)) {
+          return acc.concat(this.flattenRoutes(item));
         }
-      }
-      
-      return result;
+        return acc.concat(item);
+      }, []);
     }
 
     /**
@@ -1154,7 +1161,7 @@ export function WithMoveManager<TBase extends Constructor<RpgCommonPlayer>>(
 
       const executeInfiniteRoute = (isBreaking: boolean = false) => {
         if (isBreaking || !this._isInfiniteRouteActive) return;
-        
+
         this.moveRoutes(routes).then((completed) => {
           // Only continue if the route completed successfully and we're still active
           if (completed && this._isInfiniteRouteActive) {
@@ -1197,12 +1204,12 @@ export function WithMoveManager<TBase extends Constructor<RpgCommonPlayer>>(
      */
     breakRoutes(force: boolean = false): void {
       this._isInfiniteRouteActive = false;
-      
+
       if (force) {
         // Force stop by clearing all movements immediately
         this.clearMovements();
       }
-      
+
       // If there's an active route promise, resolve it
       if (this._finishRoute) {
         this._finishRoute(force);
@@ -1241,5 +1248,13 @@ export function WithMoveManager<TBase extends Constructor<RpgCommonPlayer>>(
         this.infiniteMoveRoute(this._infiniteRoutes);
       }
     }
-  };
+  }
+
+  return WithMoveManagerClass as unknown as PlayerCtor;
 }
+
+/**
+ * Type helper to extract the interface from the WithMoveManager mixin
+ * This provides the type without duplicating method signatures
+ */
+export type IMoveManager = InstanceType<ReturnType<typeof WithMoveManager>>;