@nayan-ui/games 1.19.0 → 1.20.0

package/src/games/fruit-merger/FruitMergerRules.ts

@@ -0,0 +1,286 @@
+// Fruit Merger's physics, with no React or engine: gravity, the walls, fruit against fruit (several
+// weighted passes a step, so piles stack without sinking), merges, the danger line and the win /
+// overflow checks, in fixed 60 Hz steps.
+import {
+  BOUNCE,
+  COLLISION_SCALE,
+  CORNER,
+  DANGER_SETTLE_MS,
+  DANGER_START_Y,
+  FRICTION,
+  FRUIT_TYPES,
+  GRAVITY,
+  LAST_TYPE,
+  MERGE_DISTANCE,
+  OVERFLOW_STEPS,
+  OVERFLOW_Y,
+  PLAY_HEIGHT,
+  PLAY_WIDTH,
+  SOLVER_PASSES
+} from './FruitMergerConstants';
+
+export type Body = {
+  id: string;
+  typeId: number;
+  r: number;
+  /** Collision radius. */
+  cr: number;
+  x: number;
+  y: number;
+  vx: number;
+  vy: number;
+  /** Rolling angle (radians, clockwise on screen). */
+  angle: number;
+  /** x at the start of the step, for the roll. */
+  px: number;
+  /** When it entered the glass (ms on the game's clock): one still falling in isn't the pile. */
+  born: number;
+};
+
+export type Merge = { a: Body; b: Body; made: Body };
+
+/**
+ * A push on a fruit against the glass, with the part driving it into the glass taken off (so it slides
+ * along a wall, the floor or a rounded corner instead): returns what's left of the push.
+ */
+function slide(b: Body, cx: number, cy: number, result: [number, number]): [number, number] {
+  const r = b.cr;
+  const e = 0.5;
+  if (cx < 0 && b.x - r <= e) cx = 0;
+  if (cx > 0 && b.x + r >= PLAY_WIDTH - e) cx = 0;
+  if (cy > 0 && b.y + r >= PLAY_HEIGHT - e) cy = 0;
+  if (r < CORNER && b.y >= PLAY_HEIGHT - CORNER) {
+    const kx = b.x < CORNER ? CORNER : b.x > PLAY_WIDTH - CORNER ? PLAY_WIDTH - CORNER : -1;
+    if (kx >= 0) {
+      const ox = b.x - kx;
+      const oy = b.y - (PLAY_HEIGHT - CORNER);
+      const d = Math.hypot(ox, oy) || 1;
+      const out = (cx * ox + cy * oy) / d;
+      if (d >= CORNER - r - e && out > 0) {
+        cx -= (ox / d) * out;
+        cy -= (oy / d) * out;
+      }
+    }
+  }
+  result[0] = cx;
+  result[1] = cy;
+  return result;
+}
+
+/**
+ * Holds a fruit inside the glass: between the walls, above the floor, and round the rounded bottom
+ * corners (a fruit in a corner stays within the curve, its speed into the glass taken away).
+ */
+function keepInside(b: Body) {
+  const r = b.cr;
+  b.x = Math.max(r, Math.min(PLAY_WIDTH - r, b.x));
+  if (b.y + r > PLAY_HEIGHT) b.y = PLAY_HEIGHT - r;
+  if (r >= CORNER || b.y < PLAY_HEIGHT - CORNER) return;
+  const cx = b.x < CORNER ? CORNER : b.x > PLAY_WIDTH - CORNER ? PLAY_WIDTH - CORNER : -1;
+  if (cx < 0) return;
+  const cy = PLAY_HEIGHT - CORNER;
+  const dx = b.x - cx;
+  const dy = b.y - cy;
+  const d = Math.hypot(dx, dy);
+  const max = CORNER - r;
+  if (d <= max || d === 0) return;
+  const nx = dx / d;
+  const ny = dy / d;
+  b.x = cx + nx * max;
+  b.y = cy + ny * max;
+  const into = b.vx * nx + b.vy * ny;
+  if (into > 0) {
+    b.vx -= nx * into * (1 + BOUNCE);
+    b.vy -= ny * into * (1 + BOUNCE);
+  }
+}
+
+export const radiusOf = (typeId: number) => (FRUIT_TYPES[typeId]?.size ?? 40) / 2;
+
+export function makeBody(id: string, typeId: number, x: number, y: number, vy: number, born: number): Body {
+  const r = radiusOf(typeId);
+  return { id, typeId, r, cr: r * COLLISION_SCALE, x, y, vx: 0, vy, angle: 0, px: x, born };
+}
+
+const MAX_SPEED = 18;
+
+/** The fruits' moves this step, in sub-steps short enough that none can pass into another between checks. */
+function move(list: Body[]) {
+  const n = list.length;
+  let fastest = 0;
+  let smallest = Infinity;
+  for (let i = 0; i < n; i++) {
+    const b = list[i]!;
+    fastest = Math.max(fastest, Math.abs(b.vx), Math.abs(b.vy));
+    smallest = Math.min(smallest, b.cr);
+  }
+  const subs = Math.max(1, Math.min(6, Math.ceil(fastest / (smallest * 0.4))));
+  for (let k = 0; k < subs; k++) {
+    for (let i = 0; i < n; i++) {
+      const b = list[i]!;
+      b.x += b.vx / subs;
+      b.y += b.vy / subs;
+    }
+    solve(list, Math.ceil(SOLVER_PASSES / subs) + 2);
+  }
+}
+
+/**
+ * Pushes overlapping fruits apart over `passes` passes (so a stack holds), and keeps every fruit inside
+ * the glass after each pass.
+ */
+const slideA: [number, number] = [0, 0];
+const slideB: [number, number] = [0, 0];
+function solve(list: Body[], passes: number) {
+  const n = list.length;
+  // Fruit against fruit: overlaps pushed apart over several passes (so a stack holds)
+  for (let pass = 0; pass < passes; pass++) {
+    for (let i = 0; i < n; i++) {
+      const p1 = list[i]!;
+      for (let j = i + 1; j < n; j++) {
+        const p2 = list[j]!;
+        const dx = p2.x - p1.x;
+        const dy = p2.y - p1.y;
+        const distSq = dx * dx + dy * dy;
+        const minDist = p1.cr + p2.cr;
+        if (distSq >= minDist * minDist || distSq === 0) continue;
+        const distance = Math.sqrt(distSq);
+        const nx = dx / distance;
+        const ny = dy / distance;
+        const m1 = p1.cr * p1.cr;
+        const m2 = p2.cr * p2.cr;
+        const w1 = m2 / (m1 + m2);
+        const w2 = m1 / (m1 + m2);
+        // Overlap shared by weight (a big fruit gives way less than a small one); a fruit against the glass
+        // slides along it instead of into it, and the other takes up whatever part of the push it couldn't
+        const overlap = minDist - distance;
+        const [a1x, a1y] = slide(p1, -nx * overlap * w1, -ny * overlap * w1, slideA);
+        const [a2x, a2y] = slide(p2, nx * overlap * w2, ny * overlap * w2, slideB);
+        const lost1x = -nx * overlap * w1 - a1x;
+        const lost1y = -ny * overlap * w1 - a1y;
+        const lost2x = nx * overlap * w2 - a2x;
+        const lost2y = ny * overlap * w2 - a2y;
+        p1.x += a1x - lost2x;
+        p1.y += a1y - lost2y;
+        p2.x += a2x - lost1x;
+        p2.y += a2y - lost1y;
+      }
+    }
+    // Back inside the glass after each pass
+    for (let i = 0; i < n; i++) keepInside(list[i]!);
+  }
+}
+
+/** What a step left behind: the overflow count carried between steps, and how close the pile is to the top. */
+export type StepState = { overflowSteps: number; danger: number; merges: number; generation: number };
+
+/**
+ * One 60 Hz step. Returns a merge if one happened (at most one a step: the step ends there, as before)
+ * and sets `out.outcome` on a win or an overflow. Merged fruits leave `list` at once (the original list kept
+ * them, out of the simulation, until their node unmounted: they changed nothing).
+ */
+export function step(list: Body[], now: number, st: StepState, out: { outcome: 'win' | 'lose' | null }): Merge | null {
+  const n = list.length;
+  for (let i = 0; i < n; i++) {
+    const b = list[i]!;
+    b.px = b.x;
+    b.vy += GRAVITY;
+    b.vx *= FRICTION;
+    b.vy *= FRICTION;
+    // Never faster than a falling fruit gets (a squeezed pile can't fling one)
+    const speed = Math.hypot(b.vx, b.vy);
+    if (speed > MAX_SPEED) {
+      b.vx *= MAX_SPEED / speed;
+      b.vy *= MAX_SPEED / speed;
+    }
+    if (b.x - b.cr < 0) {
+      b.x = b.cr;
+      b.vx *= -BOUNCE;
+    }
+    if (b.x + b.cr > PLAY_WIDTH) {
+      b.x = PLAY_WIDTH - b.cr;
+      b.vx *= -BOUNCE;
+    }
+    if (b.y + b.cr >= PLAY_HEIGHT) {
+      b.y = PLAY_HEIGHT - b.cr;
+      b.vy *= -BOUNCE;
+      b.vx *= FRICTION;
+      if (Math.abs(b.vy) < 0.5) b.vy = 0;
+    }
+    if (b.y - b.r < 0) {
+      b.y = b.r;
+      b.vy = Math.abs(b.vy) * 0.5;
+    }
+    keepInside(b);
+  }
+
+  // Where each fruit starts the step: its speed afterwards is how far it really went (pushes included),
+  // so a squeezed pile loses its energy and settles instead of jittering
+  const ox = list.map((b) => b.x);
+  const oy = list.map((b) => b.y);
+  move(list);
+  for (let i = 0; i < n; i++) {
+    const b = list[i]!;
+    b.vx = b.x - ox[i]!;
+    b.vy = b.y - oy[i]!;
+  }
+
+  // Roll, and the top of the settled pile
+  let highest = Infinity;
+  for (let i = 0; i < n; i++) {
+    const b = list[i]!;
+    b.angle += (b.x - b.px) / b.r;
+    if (Math.abs(b.vy) < 1.5 && now - b.born > DANGER_SETTLE_MS && b.y - b.r < highest) highest = b.y - b.r;
+  }
+  const d = highest === Infinity ? 0 : Math.max(0, Math.min(1, (DANGER_START_Y - highest) / (DANGER_START_Y - OVERFLOW_Y)));
+  if (Math.abs(d - st.danger) > 0.02 || (d === 0) !== (st.danger === 0)) st.danger = d;
+
+  // The first touching same-kind pair (one of them nearly still) merges, and the step ends there
+  for (let i = 0; i < n; i++) {
+    const f1 = list[i]!;
+    if (f1.y < 0) continue;
+    for (let j = i + 1; j < n; j++) {
+      const f2 = list[j]!;
+      if (f2.y < 0 || f1.typeId !== f2.typeId) continue;
+      const dx = f2.x - f1.x;
+      const dy = f2.y - f1.y;
+      if (Math.sqrt(dx * dx + dy * dy) > f1.cr + f2.cr + MERGE_DISTANCE) continue;
+      const speed1 = Math.sqrt(f1.vx * f1.vx + f1.vy * f1.vy);
+      const speed2 = Math.sqrt(f2.vx * f2.vx + f2.vy * f2.vy);
+      if (speed1 >= 5 && speed2 >= 5) continue;
+      const typeId = f1.typeId + 1;
+      if (typeId > LAST_TYPE) return null;
+      st.merges += 1;
+      const made = makeBody(`fruit-m${st.generation}-${st.merges}`, typeId, (f1.x + f2.x) / 2, (f1.y + f2.y) / 2, -2, now);
+      list.splice(j, 1);
+      list.splice(i, 1);
+      list.push(made);
+      // The new fruit is bigger than either: push its neighbours clear of it at once
+      solve(list, SOLVER_PASSES);
+      return { a: f1, b: f2, made };
+    }
+  }
+
+  // Win: the pumpkin
+  for (let i = 0; i < n; i++) {
+    if (list[i]!.typeId === LAST_TYPE) {
+      out.outcome = 'win';
+      return null;
+    }
+  }
+
+  // Overflow: a settled fruit above the line, step after step
+  let over = false;
+  for (let i = 0; i < n; i++) {
+    const b = list[i]!;
+    if (b.y - b.r < OVERFLOW_Y && Math.abs(b.vy) < 1.5) {
+      over = true;
+      break;
+    }
+  }
+  if (over) {
+    st.overflowSteps += 1;
+    if (st.overflowSteps >= OVERFLOW_STEPS) out.outcome = 'lose';
+  } else st.overflowSteps = 0;
+  return null;
+}