@react-shimeji/core 0.3.0 → 0.3.2

package/dist/index.cjs

@@ -701,21 +701,25 @@ var BehaviorController = class {
 };
 
 // src/physics.ts
-var BORDER_TOLERANCE = 0.999999;
+var BORDER_TOLERANCE = 1 - Number.EPSILON / 2;
+function isWithinSpan(value, minimum, maximum, tolerance) {
+  const distance = value < minimum ? minimum - value : value > maximum ? value - maximum : 0;
+  return distance <= tolerance;
+}
 function clamp(value, minimum, maximum) {
   return Math.min(Math.max(value, minimum), maximum);
 }
 function isOnTop(point, rectangle, tolerance = BORDER_TOLERANCE) {
-  return point.x >= rectangle.x - tolerance && point.x <= rectangle.x + rectangle.width + tolerance && Math.abs(point.y - rectangle.y) <= tolerance;
+  return isWithinSpan(point.x, rectangle.x, rectangle.x + rectangle.width, tolerance) && Math.abs(point.y - rectangle.y) <= tolerance;
 }
 function isOnBottom(point, rectangle, tolerance = BORDER_TOLERANCE) {
-  return point.x >= rectangle.x - tolerance && point.x <= rectangle.x + rectangle.width + tolerance && Math.abs(point.y - rectangle.y - rectangle.height) <= tolerance;
+  return isWithinSpan(point.x, rectangle.x, rectangle.x + rectangle.width, tolerance) && Math.abs(point.y - rectangle.y - rectangle.height) <= tolerance;
 }
 function isOnLeft(point, rectangle, tolerance = BORDER_TOLERANCE) {
-  return point.y >= rectangle.y - tolerance && point.y <= rectangle.y + rectangle.height + tolerance && Math.abs(point.x - rectangle.x) <= tolerance;
+  return isWithinSpan(point.y, rectangle.y, rectangle.y + rectangle.height, tolerance) && Math.abs(point.x - rectangle.x) <= tolerance;
 }
 function isOnRight(point, rectangle, tolerance = BORDER_TOLERANCE) {
-  return point.y >= rectangle.y - tolerance && point.y <= rectangle.y + rectangle.height + tolerance && Math.abs(point.x - rectangle.x - rectangle.width) <= tolerance;
+  return isWithinSpan(point.y, rectangle.y, rectangle.y + rectangle.height, tolerance) && Math.abs(point.x - rectangle.x - rectangle.width) <= tolerance;
 }
 function isOnBorder(state, bounds, border, platform) {
   if (!border) return true;
@@ -1633,6 +1637,7 @@ function environmentRectangle(bounds) {
   };
 }
 var PLATFORM_NEARBY_DISTANCE = 400;
+var PLATFORM_EDGE_TOLERANCE = 2;
 function distanceToRectangle(point, rectangle) {
   const dx = Math.max(rectangle.x - point.x, 0, point.x - rectangle.x - rectangle.width);
   const dy = Math.max(rectangle.y - point.y, 0, point.y - rectangle.y - rectangle.height);
@@ -1663,6 +1668,7 @@ var Mascot = class {
     this.domHandle = dom.createMascot(spec, id, options.mascotClassName || void 0);
     this.frameDuration = options.frameDuration;
     this.random = options.random ?? Math.random;
+    this.forceInitialFall = spawnOptions.behaviorName === void 0;
     this.behavior = new BehaviorController(spec, options.random);
     this.actions = new ActionExecutor(spec, this.state, options, {
       spawn: (position, characterId) => this.callbacks.spawn(characterId ?? this.spec.id, position),
@@ -1692,6 +1698,7 @@ var Mascot = class {
   accumulatedMs = 0;
   frameDuration;
   random;
+  forceInitialFall;
   /** Advances behavior, animation, physics, and rendering by one clock tick. */
   tick(deltaMs, bounds, platforms = []) {
     if (this.destroyed) return;
@@ -1731,7 +1738,7 @@ var Mascot = class {
     for (let guard = 0; guard < 32 && !this.destroyed; guard += 1) {
       const environment = this.createEnvironment(bounds, platforms);
       if (!this.currentBehavior) {
-        this.currentBehavior = initial ? this.behavior.selectInitial(environment, this.state.behaviorName) : this.selectNextBehavior(environment, bounds);
+        this.currentBehavior = initial ? this.forceInitialFall ? this.findFallBehavior() ?? this.behavior.selectInitial(environment) : this.behavior.selectInitial(environment, this.state.behaviorName) : this.selectNextBehavior(environment, bounds);
         initial = false;
         if (!this.currentBehavior) this.currentBehavior = this.findFallBehavior();
         if (!this.currentBehavior || !this.startBehavior(environment, bounds, platforms)) return;
@@ -1750,7 +1757,7 @@ var Mascot = class {
     if (result === "lost-ground") {
       this.state.dragging = false;
       this.actions.cancel();
-      this.currentBehavior = this.findFallBehavior();
+      this.currentBehavior = this.selectEdgeBehavior(bounds, platforms);
       if (this.currentBehavior) this.startBehavior(this.createEnvironment(bounds, platforms), bounds, platforms);
     } else if (result === "complete") {
       this.currentBehavior = this.selectNextBehavior(this.createEnvironment(bounds, platforms), bounds);
@@ -1776,14 +1783,37 @@ var Mascot = class {
   findFallBehavior() {
     return this.behavior.force("Fall") ?? this.behavior.force("\u843D\u4E0B\u3059\u308B");
   }
-  selectNextBehavior(environment, bounds) {
+  selectNextBehavior(environment, bounds, relocateOnFallback = true) {
     const selected = this.behavior.selectNext(environment);
-    if (this.behavior.usedFallback()) {
+    if (relocateOnFallback && this.behavior.usedFallback()) {
       this.state.x = Math.trunc(bounds.x + this.random() * bounds.width);
       this.state.y = bounds.y - 256;
     }
     return selected;
   }
+  selectEdgeBehavior(bounds, platforms) {
+    const original = { x: this.state.x, y: this.state.y };
+    const platform = platforms.find((candidate) => candidate.element === this.activePlatformElement);
+    if (platform) {
+      const left = platform.x;
+      const right = platform.x + platform.width;
+      const top = platform.y;
+      const bottom = platform.y + platform.height;
+      if (Math.abs(this.state.y - top) <= PLATFORM_EDGE_TOLERANCE || Math.abs(this.state.y - bottom) <= PLATFORM_EDGE_TOLERANCE) {
+        if (this.state.x < left) this.state.x = left;
+        else if (this.state.x > right) this.state.x = right;
+      } else if (Math.abs(this.state.x - left) <= PLATFORM_EDGE_TOLERANCE || Math.abs(this.state.x - right) <= PLATFORM_EDGE_TOLERANCE) {
+        if (this.state.y < top) this.state.y = top;
+        else if (this.state.y > bottom) this.state.y = bottom;
+      }
+    }
+    const selected = this.selectNextBehavior(this.createEnvironment(bounds, platforms), bounds, false);
+    if (this.behavior.usedFallback() || selected?.name === "Fall" || selected?.name === "\u843D\u4E0B\u3059\u308B") {
+      this.state.x = original.x;
+      this.state.y = original.y;
+    }
+    return selected ?? this.findFallBehavior();
+  }
   createEnvironment(bounds, platforms = this.platforms) {
     const workArea = environmentRectangle(bounds);
     const inactive = environmentRectangle({ x: -100, y: -100, width: 0, height: 0 });
@@ -1814,7 +1844,7 @@ var Mascot = class {
     }
     const anchor = this.state;
     const current = platforms.find((platform) => platform.element === this.activePlatformElement);
-    if (current && (isOnTop(anchor, current, 2) || isOnBottom(anchor, current, 2) || isOnLeft(anchor, current, 2) || isOnRight(anchor, current, 2))) return current;
+    if (current && (isOnTop(anchor, current, PLATFORM_EDGE_TOLERANCE) || isOnBottom(anchor, current, PLATFORM_EDGE_TOLERANCE) || isOnLeft(anchor, current, PLATFORM_EDGE_TOLERANCE) || isOnRight(anchor, current, PLATFORM_EDGE_TOLERANCE))) return current;
     if (this.state.vy >= 0) {
       const landingPlatform = platforms.filter((platform) => anchor.x >= platform.x && anchor.x <= platform.x + platform.width && platform.y >= anchor.y - 1).sort((left, right) => left.y - right.y)[0];
       if (landingPlatform) {
@@ -2067,9 +2097,13 @@ var ShimejiEngine = class {
     if (!spec) throw new Error(`Character '${characterId}' is not registered`);
     const { bounds, platforms } = this.readFrameGeometry();
     const random = this.options.random ?? Math.random;
+    const randomX = Math.trunc(bounds.x + random() * bounds.width);
+    const spawnInset = Math.min(2, bounds.width / 2);
     const spawnOptions = {
       ...position,
-      x: position.x ?? Math.trunc(bounds.x + random() * bounds.width),
+      // Fall treats the wall in the facing direction as ground. Keep implicit
+      // spawns clear of both side-wall tolerances so even random() === 0 falls.
+      x: position.x ?? Math.min(Math.max(randomX, bounds.x + spawnInset), bounds.x + bounds.width - spawnInset),
       y: position.y ?? bounds.y + 2
     };
     const id = `shimeji-${this.nextMascotId++}`;