@nayan-ui/games 1.20.0 → 1.21.0

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

@@ -1,286 +0,0 @@
-// 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;
-}