@rpgjs/server 5.0.0-alpha.15 → 5.0.0-alpha.16

package/dist/index.js

@@ -12545,6 +12545,48 @@ class Entity {
     this.force.set(0, 0);
     this.torque = 0;
   }
+  /**
+   * Stops all movement immediately
+   * 
+   * Completely stops the entity's movement by:
+   * - Setting velocity to zero
+   * - Setting angular velocity to zero
+   * - Clearing accumulated forces and torques
+   * - Waking up the entity if it was sleeping
+   * - Notifying movement state change
+   * 
+   * Unlike `freeze()`, this method keeps the entity dynamic and does not
+   * change its state. It's useful for stopping movement when changing maps,
+   * teleporting, or when you need to halt an entity without making it static.
+   * 
+   * @returns This entity for chaining
+   * 
+   * @example
+   * ```ts
+   * // Stop movement when changing maps
+   * if (mapChanged) {
+   *   entity.stopMovement();
+   * }
+   * 
+   * // Stop movement after teleporting
+   * entity.position.set(100, 200);
+   * entity.stopMovement();
+   * 
+   * // Stop movement when player dies
+   * if (player.isDead()) {
+   *   playerEntity.stopMovement();
+   * }
+   * ```
+   */
+  stopMovement() {
+    this.velocity.set(0, 0);
+    this.angularVelocity = 0;
+    this.clearForces();
+    this.wakeUp();
+    this.notifyMovementChange();
+    this.notifyDirectionChange();
+    return this;
+  }
   /**
    * Clamps velocities to maximum values
    */
@@ -15404,6 +15446,47 @@ let MovementManager$1 = class MovementManager {
     const body = this.resolveTarget(target);
     this.entries.delete(body.id);
   }
+  /**
+   * Stops all movement for an entity immediately
+   * 
+   * This method completely stops an entity's movement by:
+   * - Removing all active movement strategies (dash, linear moves, etc.)
+   * - Stopping the entity's velocity and angular velocity
+   * - Clearing accumulated forces
+   * - Waking up the entity if it was sleeping
+   * 
+   * This is useful when changing maps, teleporting, or when you need
+   * to halt an entity's movement completely without making it static.
+   * 
+   * @param target - Entity, MovementBody, or identifier
+   * 
+   * @example
+   * ```ts
+   * // Stop movement when changing maps
+   * if (mapChanged) {
+   *   movement.stopMovement(playerEntity);
+   * }
+   * 
+   * // Stop movement after teleporting
+   * entity.position.set(100, 200);
+   * movement.stopMovement(entity);
+   * 
+   * // Stop movement when player dies
+   * if (player.isDead()) {
+   *   movement.stopMovement(playerEntity);
+   * }
+   * ```
+   */
+  stopMovement(target) {
+    const body = this.resolveTarget(target);
+    this.clear(target);
+    if ("getEntity" in body && typeof body.getEntity === "function") {
+      const entity = body.getEntity();
+      if (entity && typeof entity.stopMovement === "function") {
+        entity.stopMovement();
+      }
+    }
+  }
   /**
    * Checks if an entity has active strategies.
    *
@@ -17004,6 +17087,9 @@ class MovementManager {
   clear(id) {
     this.core.clear(id);
   }
+  stopMovement(id) {
+    this.core.stopMovement(id);
+  }
   hasActiveStrategies(id) {
     return this.core.hasActiveStrategies(id);
   }
@@ -17192,6 +17278,7 @@ class RpgCommonMap {
     if (typeof player.autoChangeMap === "function") {
       const mapChanged = await player.autoChangeMap({ x: nextX, y: nextY }, direction);
       if (mapChanged) {
+        this.stopMovement(player);
         return;
       }
     }
@@ -17564,11 +17651,12 @@ class RpgCommonMap {
     if (!options || typeof options.owner?.id !== "string") {
       throw new Error("Character requires an owner object with a string id");
     }
-    const id = options.owner.id;
-    const radius = options.radius ?? 25;
+    const owner = options.owner;
+    const id = owner.id;
+    const radius = owner.hitbox?.w ?? options.radius ?? 25;
     const diameter = radius * 2;
-    const topLeftX = options.x - radius;
-    const topLeftY = options.y - radius;
+    const topLeftX = owner.x() - radius;
+    const topLeftY = owner.y() - radius;
     const centerX = topLeftX + diameter / 2;
     const centerY = topLeftY + diameter / 2;
     const isStatic = !!options.isStatic;
@@ -17587,17 +17675,15 @@ class RpgCommonMap {
     } else {
       entity.unfreeze();
     }
-    entity.owner = options.owner;
+    entity.owner = owner;
     entity.onDirectionChange(({ cardinalDirection }) => {
       if (!("$send" in this)) return;
-      const owner = entity.owner;
-      if (!owner) return;
+      const owner2 = entity.owner;
+      if (!owner2) return;
       if (cardinalDirection === "idle") return;
-      owner.changeDirection(cardinalDirection);
+      owner2.changeDirection(cardinalDirection);
     });
     entity.onMovementChange(({ isMoving, intensity }) => {
-      const owner = entity.owner;
-      if (!owner) return;
       const LOW_INTENSITY_THRESHOLD = 10;
       if (isMoving && intensity > LOW_INTENSITY_THRESHOLD) {
         owner.animationName.set("walk");
@@ -17606,8 +17692,6 @@ class RpgCommonMap {
       }
     });
     entity.onPositionChange(({ x, y }) => {
-      const owner = entity.owner;
-      if (!owner) return;
       const width = entity.width || (entity.radius ? entity.radius * 2 : 32);
       const height = entity.height || (entity.radius ? entity.radius * 2 : 32);
       const topLeftX2 = x - width / 2;
@@ -17700,15 +17784,40 @@ class RpgCommonMap {
   }
   /**
    * Stop movement for a player
+   * 
+   * Completely stops all movement for a player, including:
+   * - Clearing all active movement strategies (dash, linear moves, etc.)
+   * - Setting velocity to zero
+   * - Resetting intended direction
+   * 
+   * This method is particularly useful when changing maps to ensure
+   * the player doesn't carry over movement from the previous map.
+   * 
+   * @param player - The player to stop
+   * @returns True if the player was found and movement was stopped
+   * 
+   * @example
+   * ```ts
+   * // Stop player movement when changing maps
+   * if (mapChanged) {
+   *   map.stopMovement(player);
+   * }
+   * 
+   * // Stop movement when player dies
+   * if (player.isDead()) {
+   *   map.stopMovement(player);
+   * }
+   * ```
    * @protected
    */
   stopMovement(player) {
     const entity = this.physic.getEntityByUUID(player.id);
     if (!entity) return false;
+    this.moveManager.stopMovement(player.id);
     if (typeof player.setIntendedDirection === "function") {
       player.setIntendedDirection(null);
     }
-    entity.setVelocity({ x: 0, y: 0 });
+    player.pendingInputs = [];
     return true;
   }
   /**
@@ -22376,7 +22485,10 @@ const _RpgPlayer = class _RpgPlayer extends BasicPlayerMixins(RpgCommonPlayer) {
   async teleport(positions) {
     if (!this.map) return false;
     if (this.map.physic) {
-      this.map.physic.updateHitbox(this.id, positions.x, positions.y, void 0, void 0, true);
+      const entity = this.map.physic.getEntityByUUID(this.id);
+      if (entity) {
+        this.map.physic.teleport(entity, { x: positions.x, y: positions.y });
+      }
     } else {
       this.x.set(positions.x);
       this.y.set(positions.y);