@nayan-ui/engine 0.0.0-stage → 1.0.0-beta.3

package/lib/module/render/responder.js

@@ -0,0 +1,4 @@
+"use strict";
+
+export { PanResponder } from 'react-native';
+//# sourceMappingURL=responder.js.map

package/lib/module/render/responder.web.js

@@ -0,0 +1,97 @@
+"use strict";
+
+/** Adapt DOM pointer capture to the gesture recognizer used on mobile. Coordinates stay in CSS pixels. */
+export const PanResponder = {
+  create(callbacks) {
+    const pointers = new Map();
+    let origin = {
+      x: 0,
+      y: 0
+    };
+    let last = {
+      nativeEvent: {
+        pageX: 0,
+        pageY: 0,
+        locationX: 0,
+        locationY: 0,
+        touches: []
+      }
+    };
+    let gesture = {
+      dx: 0,
+      dy: 0
+    };
+    let primary = -1;
+    const event = e => {
+      const rect = e.currentTarget.getBoundingClientRect();
+      const nativeEvent = {
+        pageX: e.clientX,
+        pageY: e.clientY,
+        locationX: e.clientX - rect.left,
+        locationY: e.clientY - rect.top,
+        touches: [...pointers.values()]
+      };
+      if (e.pointerId === primary) gesture = {
+        dx: e.clientX - origin.x,
+        dy: e.clientY - origin.y
+      };
+      return last = {
+        nativeEvent
+      };
+    };
+    const cancel = () => {
+      if (pointers.size) callbacks.onPanResponderTerminate(last, gesture);
+      pointers.clear();
+      primary = -1;
+    };
+    return {
+      cancel,
+      panHandlers: {
+        onPointerDown(e) {
+          if (e.button !== 0) return;
+          e.preventDefault();
+          // Keyboard pointers already retain their target; only physical pointers can be captured.
+          if (e.isTrusted) e.currentTarget.setPointerCapture(e.pointerId);
+          pointers.set(e.pointerId, {
+            pageX: e.clientX,
+            pageY: e.clientY
+          });
+          if (pointers.size === 1) {
+            primary = e.pointerId;
+            origin = {
+              x: e.clientX,
+              y: e.clientY
+            };
+            gesture = {
+              dx: 0,
+              dy: 0
+            };
+            callbacks.onPanResponderGrant(event(e));
+          } else callbacks.onPanResponderMove(event(e), gesture);
+        },
+        onPointerMove(e) {
+          if (!pointers.has(e.pointerId)) return;
+          pointers.set(e.pointerId, {
+            pageX: e.clientX,
+            pageY: e.clientY
+          });
+          callbacks.onPanResponderMove(event(e), gesture);
+        },
+        onPointerUp(e) {
+          if (!pointers.has(e.pointerId)) return;
+          const current = event(e);
+          if (e.pointerId === primary || pointers.size >= 2) {
+            callbacks.onPanResponderRelease(current, gesture);
+            pointers.clear();
+            primary = -1;
+          } else pointers.delete(e.pointerId);
+        },
+        onPointerCancel: cancel,
+        onLostPointerCapture(e) {
+          if (pointers.has(e.pointerId)) cancel();
+        }
+      }
+    };
+  }
+};
+//# sourceMappingURL=responder.web.js.map

package/lib/module/render/touch.js

@@ -0,0 +1,185 @@
+"use strict";
+
+// Gesture recognition for GameView: tap, swipe, drag, long press, pinch.
+import { PanResponder } from './responder';
+const TAP_SLOP = 10; // points a finger may wander and still tap
+const TAP_TIME = 300; // ms
+const SWIPE_DISTANCE = 30; // points
+const SWIPE_SPEED = 0.3; // points per ms
+const LONG_PRESS_TIME = 500; // ms
+
+/**
+ * Creates a PanResponder that recognizes taps, swipes, drags, long presses and pinches.
+ * `getHandlers` is called on each event so the caller can swap handlers without recreating the responder.
+ */
+export function createTouchResponder(getHandlers) {
+  let start = {
+    x: 0,
+    y: 0,
+    time: 0
+  };
+  let origin = {
+    x: 0,
+    y: 0
+  };
+  let mode = 'none';
+  let pinch0 = {
+    distance: 1,
+    angle: 0
+  };
+  let lastPinch = {
+    phase: 'end',
+    scale: 1,
+    rotation: 0,
+    x: 0,
+    y: 0
+  };
+  let longPress;
+  let longPressed = false;
+  const drag = (phase, x, y, cancelled) => getHandlers().onDrag?.({
+    phase,
+    x,
+    y,
+    dx: x - start.x,
+    dy: y - start.y,
+    ...(cancelled && {
+      cancelled
+    })
+  });
+  const twoFingers = (touches, phase) => {
+    const [a, b] = touches;
+    const distance = Math.max(1, Math.hypot(b.pageX - a.pageX, b.pageY - a.pageY));
+    const angle = Math.atan2(b.pageY - a.pageY, b.pageX - a.pageX);
+    if (phase === 'start') pinch0 = {
+      distance,
+      angle
+    };
+    lastPinch = {
+      phase,
+      scale: distance / pinch0.distance,
+      rotation: angle - pinch0.angle,
+      x: (a.pageX + b.pageX) / 2 - origin.x,
+      y: (a.pageY + b.pageY) / 2 - origin.y
+    };
+    getHandlers().onPinch?.(lastPinch);
+  };
+  const stopLongPress = () => {
+    clearTimeout(longPress);
+    longPress = undefined;
+  };
+  const responder = PanResponder.create({
+    onStartShouldSetPanResponder: () => true,
+    onMoveShouldSetPanResponder: () => true,
+    onPanResponderGrant: e => {
+      const {
+        locationX,
+        locationY,
+        pageX,
+        pageY
+      } = e.nativeEvent;
+      start = {
+        x: locationX,
+        y: locationY,
+        time: Date.now()
+      };
+      origin = {
+        x: pageX - locationX,
+        y: pageY - locationY
+      };
+      if (getHandlers().onOverlayTouch?.('start', start.x, start.y) === true) {
+        mode = 'overlay';
+        return;
+      }
+      mode = 'drag';
+      longPressed = false;
+      drag('start', start.x, start.y);
+      if (getHandlers().onLongPress) {
+        longPress = setTimeout(() => {
+          longPress = undefined;
+          if (mode !== 'drag') return;
+          longPressed = true;
+          getHandlers().onLongPress?.(start.x, start.y);
+        }, LONG_PRESS_TIME);
+      }
+    },
+    onPanResponderMove: (e, g) => {
+      if (mode === 'overlay') {
+        getHandlers().onOverlayTouch?.('move', start.x + g.dx, start.y + g.dy);
+        return;
+      }
+      const touches = e.nativeEvent.touches;
+      if (touches.length >= 2 && getHandlers().onPinch) {
+        if (mode === 'drag') {
+          stopLongPress();
+          drag('end', start.x + g.dx, start.y + g.dy, true);
+          mode = 'pinch';
+          twoFingers(touches, 'start');
+        } else if (mode === 'pinch') {
+          twoFingers(touches, 'move');
+        }
+        return;
+      }
+      if (mode !== 'drag') return;
+      if (Math.hypot(g.dx, g.dy) >= TAP_SLOP) stopLongPress();
+      drag('move', start.x + g.dx, start.y + g.dy);
+    },
+    onPanResponderRelease: (_, g) => {
+      stopLongPress();
+      const was = mode;
+      mode = 'none';
+      if (was === 'none') return;
+      if (was === 'overlay') {
+        getHandlers().onOverlayTouch?.('end', start.x + g.dx, start.y + g.dy);
+        return;
+      }
+      if (was === 'pinch') {
+        getHandlers().onPinch?.({
+          ...lastPinch,
+          phase: 'end'
+        });
+        return;
+      }
+      const x = start.x + g.dx;
+      const y = start.y + g.dy;
+      drag('end', x, y);
+      if (longPressed) return;
+      const {
+        onTap,
+        onSwipe
+      } = getHandlers();
+      const distance = Math.hypot(g.dx, g.dy);
+      const time = Date.now() - start.time;
+      if (distance < TAP_SLOP && time < TAP_TIME) onTap?.(start.x, start.y);else if (distance > SWIPE_DISTANCE && distance / Math.max(1, time) > SWIPE_SPEED) {
+        onSwipe?.(Math.abs(g.dx) > Math.abs(g.dy) ? g.dx > 0 ? 'right' : 'left' : g.dy > 0 ? 'down' : 'up');
+      }
+    },
+    onPanResponderTerminate: (_, g) => {
+      stopLongPress();
+      const was = mode;
+      mode = 'none';
+      if (was === 'overlay') getHandlers().onOverlayTouch?.('cancel', start.x + g.dx, start.y + g.dy);else if (was === 'pinch') getHandlers().onPinch?.({
+        ...lastPinch,
+        phase: 'end'
+      });else if (was === 'drag') drag('end', start.x + g.dx, start.y + g.dy, true);
+    }
+  });
+  const cancel = () => {
+    responder.cancel?.();
+    stopLongPress();
+    const was = mode;
+    mode = 'none';
+    if (was === 'overlay') getHandlers().onOverlayTouch?.('cancel', start.x, start.y);else if (was === 'pinch') getHandlers().onPinch?.({
+      ...lastPinch,
+      phase: 'end'
+    });else if (was === 'drag') drag('end', start.x, start.y, true);
+  };
+  return {
+    responder,
+    dispose: cancel,
+    cancel
+  };
+}
+
+// Re-export threshold constants for testing.
+export { TAP_SLOP, TAP_TIME, SWIPE_DISTANCE, SWIPE_SPEED, LONG_PRESS_TIME };
+//# sourceMappingURL=touch.js.map

package/lib/module/types.js

@@ -0,0 +1,30 @@
+"use strict";
+
+/** Number of mesh ids: built-in shapes (0..15), then loaded models, glyphs and textured variants. */
+export const MAX_MESHES = 4096;
+
+/** What the renderer draws. `World` implements it; so can any custom simulation. */
+
+/**
+ * Built-in shapes, each 1 unit across before scaling. "none" isn't drawn (groups, pivots, trigger zones).
+ * "puff" is a soft, round sprite that always faces the camera and is always see-through: overlapping
+ * puffs blend into smoke, dust, steam and clouds. "flame" is the same sprite drawn additively: it adds
+ * light to what's behind it, so overlapping flames build up to a hot white core and stay bright over
+ * smoke (fire, sparks, explosions, magic, glows). Use them as a burst's `mesh`.
+ */
+
+/** Mesh ids of the built-in shapes, as the core and renderer know them. */
+export const SHAPE_MESH = {
+  cube: 0,
+  sphere: 1,
+  plane: 2,
+  cylinder: 3,
+  cone: 4,
+  capsule: 5,
+  torus: 6,
+  roundedBox: 7,
+  puff: 8,
+  flame: 9,
+  none: 15
+};
+//# sourceMappingURL=types.js.map

package/lib/module/world/Scoreboard.js

@@ -0,0 +1,143 @@
+"use strict";
+
+import NativeEngine from '../native/NativeNayanEngine';
+const OP = {
+  addScore: 0,
+  setScore: 1,
+  addLives: 2,
+  setLives: 3,
+  startClock: 4,
+  stopClock: 5,
+  resumeClock: 6,
+  reset: 7,
+  addTime: 8,
+  timeBonus: 9
+};
+const S = {
+  score: 0,
+  lives: 1,
+  seconds: 2,
+  shown: 3,
+  flags: 4,
+  running: 5,
+  rate: 6,
+  best: 7
+};
+const FLAG = {
+  score: 1,
+  lives: 2,
+  second: 4,
+  timeUp: 8,
+  livesOut: 16
+};
+/**
+ * Score, lives and the game clock, kept and advanced in Rust by `world.update`: countdowns, elapsed
+ * time and time-based points (survival, distance) cost no JS per frame. Handlers run from `update`
+ * only when something they show changed.
+ *
+ * ```ts
+ * world.scoreboard.handlers = { onScore: setScore, onSecond: setTime, onTimeUp: () => end(true) };
+ * world.scoreboard.reset(3);
+ * world.scoreboard.startCountdown(60);
+ * world.scoreboard.add(10);
+ * ```
+ */
+export class Scoreboard {
+  handlers = {};
+  /** @internal */
+  constructor(world) {
+    this.world = world;
+    if (!NativeEngine || typeof NativeEngine.getScoreboard !== 'function') {
+      throw new Error("Scoreboard: this app's native core predates the scoreboard: rebuild it");
+    }
+    this.state = new Float64Array(NativeEngine.getScoreboard(world));
+  }
+  op(op, a = 0, b = 0) {
+    return NativeEngine.scoreboard(this.world, op, a, b);
+  }
+  get score() {
+    return this.state[S.score];
+  }
+  get best() {
+    return this.state[S.best];
+  }
+  get lives() {
+    return this.state[S.lives];
+  }
+  /** Seconds left (countdown) or elapsed, fractional. */
+  get seconds() {
+    return this.state[S.seconds];
+  }
+  /** Whole seconds as shown: rounded up while counting down, down while counting up. */
+  get shownSeconds() {
+    return this.state[S.shown];
+  }
+  get running() {
+    return this.state[S.running] !== 0;
+  }
+
+  /** Adds points (negative to take away). Returns the score. */
+  add(points) {
+    return this.op(OP.addScore, points);
+  }
+  set(score) {
+    return this.op(OP.setScore, score);
+  }
+  addLives(n) {
+    this.op(OP.addLives, n);
+    return this.lives;
+  }
+  setLives(n) {
+    this.op(OP.setLives, n);
+  }
+  /** Counts `seconds` down to 0 (then `onTimeUp`), earning `pointsPerSecond` meanwhile. */
+  startCountdown(seconds, pointsPerSecond = 0) {
+    this.op(OP.startClock, Math.max(1e-6, seconds), pointsPerSecond);
+  }
+  /** Counts up from 0, earning `pointsPerSecond` (survival and distance scores). */
+  startClock(pointsPerSecond = 0) {
+    this.op(OP.startClock, 0, pointsPerSecond);
+  }
+  stop() {
+    this.op(OP.stopClock);
+  }
+  resume() {
+    this.op(OP.resumeClock);
+  }
+  /** Time bonus (or penalty) on the clock. */
+  addTime(seconds) {
+    this.op(OP.addTime, seconds);
+  }
+  /**
+   * Adds `pointsPerSecond` for each whole second saved: the seconds left on a countdown, or
+   * `expectedSeconds` minus the seconds elapsed on a clock counting up. Returns the score.
+   */
+  awardTimeBonus(pointsPerSecond, expectedSeconds = 0) {
+    return this.op(OP.timeBonus, pointsPerSecond, expectedSeconds);
+  }
+  /**
+   * A new run: score 0, `lives`, clock stopped at 0. With `countdownSeconds`, the stopped clock shows
+   * that countdown in full (a ready screen); `resume()` starts it.
+   */
+  reset(lives = 0, countdownSeconds = 0) {
+    this.op(OP.reset, lives);
+    if (countdownSeconds > 0) {
+      this.startCountdown(countdownSeconds);
+      this.stop();
+    }
+  }
+
+  /** @internal Runs handlers for what changed since the last call. */
+  dispatch() {
+    const flags = this.state[S.flags];
+    if (flags === 0) return;
+    this.state[S.flags] = 0;
+    const h = this.handlers;
+    if (flags & FLAG.score) h.onScore?.(this.score);
+    if (flags & FLAG.lives) h.onLives?.(this.lives);
+    if (flags & FLAG.second) h.onSecond?.(this.shownSeconds);
+    if (flags & FLAG.timeUp) h.onTimeUp?.();
+    if (flags & FLAG.livesOut) h.onLivesOut?.();
+  }
+}
+//# sourceMappingURL=Scoreboard.js.map

package/lib/module/world/TransformBatch.js

@@ -0,0 +1,126 @@
+"use strict";
+
+export const TRANSFORM_STRIDE = 16;
+
+/**
+ * Explicit draw-only updates, applied in one native call by `flush()`. Flush before reading
+ * positions, animating, or stepping the world. Records and scratch storage are reused; values are
+ * copied when queued, never retained by reference. The scalar methods (`position`, `rotation`,
+ * `scale`, `color`, `transform`) allocate nothing; consecutive calls for the same entity share one
+ * record.
+ *
+ * ```ts
+ * const batch = world.transforms;
+ * for (const p of pieces) batch.transform(p.entity, p.x, 0, p.z, 0, p.qy, 0, p.qw);
+ * batch.flush();
+ * ```
+ */
+export class TransformBatch {
+  data = new Float64Array(TRANSFORM_STRIDE * 32);
+  count = 0;
+  constructor(commit) {
+    this.commit = commit;
+  }
+  record(entity, flags) {
+    // Merge into the previous record when it updates the same entity (the layout is fixed per field).
+    if (this.count > 0) {
+      const last = (this.count - 1) * TRANSFORM_STRIDE;
+      if (this.data[last] === entity) {
+        this.data[last + 1] = this.data[last + 1] | flags;
+        return last;
+      }
+    }
+    const offset = this.count * TRANSFORM_STRIDE;
+    if (offset + TRANSFORM_STRIDE > this.data.length) {
+      const grown = new Float64Array(this.data.length * 2);
+      grown.set(this.data);
+      this.data = grown;
+    }
+    this.count++;
+    this.data[offset] = entity;
+    this.data[offset + 1] = flags;
+    return offset;
+  }
+  position(entity, x, y, z) {
+    const offset = this.record(entity, 2);
+    this.data[offset + 2] = x;
+    this.data[offset + 3] = y;
+    this.data[offset + 4] = z;
+  }
+
+  /** Rotation quaternion [x, y, z, w]. */
+  rotation(entity, x, y, z, w) {
+    const offset = this.record(entity, 4);
+    this.data[offset + 5] = x;
+    this.data[offset + 6] = y;
+    this.data[offset + 7] = z;
+    this.data[offset + 8] = w;
+  }
+
+  /** Uniform scale, or per axis. */
+  scale(entity, x, y = x, z = x) {
+    const offset = this.record(entity, 8);
+    this.data[offset + 9] = x;
+    this.data[offset + 10] = y;
+    this.data[offset + 11] = z;
+  }
+
+  /** RGBA color; alpha defaults to 1. */
+  color(entity, r, g, b, a = 1) {
+    const offset = this.record(entity, 16);
+    this.data[offset + 12] = r;
+    this.data[offset + 13] = g;
+    this.data[offset + 14] = b;
+    this.data[offset + 15] = a;
+  }
+
+  /** Position and rotation together (the common per-frame update for a moving piece). */
+  transform(entity, x, y, z, qx, qy, qz, qw) {
+    const offset = this.record(entity, 6);
+    this.data[offset + 2] = x;
+    this.data[offset + 3] = y;
+    this.data[offset + 4] = z;
+    this.data[offset + 5] = qx;
+    this.data[offset + 6] = qy;
+    this.data[offset + 7] = qz;
+    this.data[offset + 8] = qw;
+  }
+
+  /** Queued records (merged per entity). */
+  get size() {
+    return this.count;
+  }
+  set(entity, options) {
+    const {
+      position,
+      rotation,
+      scale,
+      color
+    } = options;
+    const flags = (position ? 2 : 0) | (rotation ? 4 : 0) | (scale !== undefined ? 8 : 0) | (color ? 16 : 0);
+    if (!flags) return;
+    const offset = this.record(entity, flags);
+    if (position) this.data.set(position, offset + 2);
+    if (rotation) this.data.set(rotation, offset + 5);
+    if (typeof scale === 'number') this.data.fill(scale, offset + 9, offset + 12);else if (scale) this.data.set(scale, offset + 9);
+    if (color) this.writeColor(offset, color);
+  }
+  writeColor(offset, color) {
+    this.data[offset + 12] = color[0];
+    this.data[offset + 13] = color[1];
+    this.data[offset + 14] = color[2];
+    this.data[offset + 15] = color[3] ?? 1;
+  }
+  flush() {
+    if (!this.count) return 0;
+    try {
+      return this.commit(this.data, this.count);
+    } finally {
+      this.count = 0;
+    }
+  }
+  clear() {
+    this.count = 0;
+  }
+}
+//# sourceMappingURL=TransformBatch.js.map