@nayan-ui/games 1.18.0 → 1.20.0

package/src/games/treasure-hunt/TreasureHuntMeshes.ts

@@ -0,0 +1,422 @@
+// Treasure Hunt: Procedural geometry and foot support.
+import { type Color, type Geometry, type Vec3 } from '@nayan-ui/engine';
+import {
+  CAVE_INNER_HEIGHT,
+  CAVE_INNER_WIDTH,
+  caveClearance,
+  hillRise,
+  type Landscape,
+  landscapeFor,
+  random,
+  riverWidth,
+  riverX,
+  ROCK_RINGS,
+  ROCK_SIDES,
+  rockSurface,
+  TERRAIN_EDGE,
+  TERRAIN_GRID,
+  terrainHeight,
+  terrainMeshHeight,
+  terrainSurface,
+  waterLevel
+} from './TreasureHuntRules';
+
+export type HumanSoles = readonly [Vec3, Vec3];
+/** Keep the support foot planted; retain airborne height only for running. */
+export function humanSupportHeight(feet: HumanSoles, ground: readonly [number, number], airborne = true): number {
+  const flight = airborne ? Math.max(0, Math.min(feet[0][1], feet[1][1])) : 0;
+  return Math.max(ground[0] - feet[0][1], ground[1] - feet[1][1]) + flight;
+}
+
+// Procedural scenery meshes.
+
+/** Native-independent geometry builders keep collision and visible ground in the same coordinates. */
+class Mesh {
+  vertices: number[] = [];
+  indices: number[] = [];
+  vertex(p: Vec3, n: Vec3, uv: readonly [number, number], color: Color = [1, 1, 1]): number {
+    const index = this.vertices.length / 11;
+    this.vertices.push(...p, ...n, color[0], color[1], color[2], ...uv);
+    return index;
+  }
+  quad(a: number, b: number, c: number, d: number, double = false) {
+    this.indices.push(a, b, c, a, c, d);
+    if (double) this.indices.push(c, b, a, d, c, a);
+  }
+  geometry(): Geometry {
+    return { vertices: new Float32Array(this.vertices), indices: new Uint32Array(this.indices) };
+  }
+}
+
+/** A shared horizontal disc; layered at low alpha for a soft contact shadow. */
+export function contactShadowGeometry(): Geometry {
+  const mesh = new Mesh();
+  const center = mesh.vertex([0, 0, 0], [0, 1, 0], [0.5, 0.5]);
+  for (let i = 0; i <= 32; i++) {
+    const a = (i / 32) * Math.PI * 2;
+    mesh.vertex([Math.cos(a), 0, Math.sin(a)], [0, 1, 0], [(Math.cos(a) + 1) / 2, (Math.sin(a) + 1) / 2]);
+    if (i > 0) mesh.indices.push(center, i + 1, i);
+  }
+  return mesh.geometry();
+}
+
+/** A brilliant cut: table, star/bezel crown, thin girdle and pointed pavilion.
+ * Each facet owns flat normals and a cool reflected-light tint, so cuts stay crisp while spinning. */
+export function diamondGeometry(): Geometry {
+  const mesh = new Mesh();
+  const ring = (count: number, radius: number, y: number, offset = 0): Vec3[] =>
+    Array.from({ length: count }, (_, i) => {
+      const angle = (i / count) * Math.PI * 2 + offset;
+      return [Math.cos(angle) * radius, y, Math.sin(angle) * radius];
+    });
+  const table = ring(8, 0.25, 0.34),
+    stars = ring(8, 0.365, 0.245, Math.PI / 8);
+  const upper = ring(16, 0.52, 0.085),
+    lower = ring(16, 0.52, 0.055);
+  const pavilion = ring(8, 0.3, -0.23, Math.PI / 8),
+    point: Vec3 = [0, -0.6, 0];
+  const crown: Color[] = [
+    [0.88, 0.97, 1.08],
+    [0.55, 0.75, 0.89],
+    [1.12, 1.17, 1.2],
+    [0.74, 0.86, 0.98]
+  ];
+  const base: Color[] = [
+    [0.46, 0.64, 0.81],
+    [0.98, 1.08, 1.17],
+    [0.7, 0.87, 1.03],
+    [1.16, 1.2, 1.24]
+  ];
+  const facet = (points: Vec3[], color: Color) => {
+    const a = points[0]!,
+      b = points[1]!,
+      c = points[2]!;
+    const ab = [b[0] - a[0], b[1] - a[1], b[2] - a[2]],
+      ac = [c[0] - a[0], c[1] - a[1], c[2] - a[2]];
+    const normal: [number, number, number] = [
+      ab[1]! * ac[2]! - ab[2]! * ac[1]!,
+      ab[2]! * ac[0]! - ab[0]! * ac[2]!,
+      ab[0]! * ac[1]! - ab[1]! * ac[0]!
+    ];
+    const center = points.reduce(
+      (sum, p) => [sum[0]! + p[0] / points.length, sum[1]! + p[1] / points.length, sum[2]! + p[2] / points.length],
+      [0, 0, 0]
+    );
+    const inward = normal[0] * center[0]! + normal[1] * (center[1]! + 0.1) + normal[2] * center[2]! < 0;
+    const length = Math.hypot(...normal) * (inward ? -1 : 1);
+    normal[0] /= length;
+    normal[1] /= length;
+    normal[2] /= length;
+    const indices = points.map((p) => mesh.vertex(p, normal, [p[0] + 0.5, p[2] + 0.5], color));
+    for (let i = 1; i < indices.length - 1; i++) mesh.indices.push(indices[0]!, indices[inward ? i + 1 : i]!, indices[inward ? i : i + 1]!);
+  };
+  facet(table, [1.03, 1.1, 1.16]);
+  for (let i = 0; i < 8; i++) {
+    const next = (i + 1) % 8,
+      previous = (i + 7) % 8,
+      even = i * 2,
+      odd = even + 1,
+      after = (even + 2) % 16;
+    facet([table[i]!, table[next]!, stars[i]!], crown[i % 4]!);
+    facet([table[i]!, stars[i]!, upper[even]!, stars[previous]!], crown[(i + 2) % 4]!);
+    facet([stars[i]!, upper[even]!, upper[odd]!], crown[(i + 1) % 4]!);
+    facet([stars[i]!, upper[odd]!, upper[after]!], crown[(i + 3) % 4]!);
+    facet([point, pavilion[previous]!, lower[even]!, pavilion[i]!], base[i % 4]!);
+    facet([pavilion[i]!, lower[even]!, lower[odd]!], base[(i + 2) % 4]!);
+    facet([pavilion[i]!, lower[odd]!, lower[after]!], base[(i + 1) % 4]!);
+  }
+  for (let i = 0; i < 16; i++) facet([upper[i]!, lower[i]!, lower[(i + 1) % 16]!, upper[(i + 1) % 16]!], [0.83, 0.94, 1.04]);
+  return mesh.geometry();
+}
+
+export interface TerrainGeometry {
+  meadow: Geometry;
+  stone: Geometry;
+  shore: Geometry;
+}
+
+export function terrainGeometry(profile: number): TerrainGeometry {
+  const builder = terrainGeometrySteps(profile);
+  let next = builder.next();
+  while (!next.done) next = builder.next();
+  return next.value;
+}
+
+/** The same vertices and contours, yielded in row batches so preparation cannot monopolize JS. */
+export function* terrainGeometrySteps(profile: number): Generator<void, TerrainGeometry> {
+  const land = landscapeFor(profile),
+    mesh = new Mesh();
+  const surfaces = { meadow: [] as number[], stone: [] as number[], shore: [] as number[] };
+  const divisions = TERRAIN_GRID.length - 1;
+  interface TerrainPoint {
+    x: number;
+    z: number;
+    index?: number;
+  }
+  const vertex = (p: TerrainPoint): number => {
+    if (p.index !== undefined) return p.index;
+    const { x, z } = p,
+      y = terrainMeshHeight(land, x, z);
+    const dx = (terrainHeight(land, x + 0.15, z) - terrainHeight(land, x - 0.15, z)) / 0.3;
+    const dz = (terrainHeight(land, x, z + 0.15) - terrainHeight(land, x, z - 0.15)) / 0.3;
+    const length = Math.hypot(dx, 1, dz),
+      variation = 0.87 + 0.09 * Math.sin(x * 0.13 + Math.sin(z * 0.1));
+    p.index = mesh.vertex([x, y, z], [-dx / length, 1 / length, -dz / length], [x / 3, z / 3], [variation, variation, variation * 0.95]);
+    return p.index;
+  };
+  const points: TerrainPoint[] = [];
+  for (let row = 0; row <= divisions; row++) {
+    for (let col = 0; col <= divisions; col++) {
+      const p = { x: TERRAIN_GRID[col]!, z: TERRAIN_GRID[row]! };
+      vertex(p);
+      points.push(p);
+    }
+    if (row % 2 === 1) yield;
+  }
+  const append = (polygon: TerrainPoint[], target: number[]) => {
+    if (polygon.length < 3) return;
+    const ids = polygon.map(vertex);
+    for (let i = 1; i < ids.length - 1; i++) {
+      const a = polygon[0]!,
+        b = polygon[i]!,
+        c = polygon[i + 1]!;
+      if (Math.abs((b.x - a.x) * (c.z - a.z) - (b.z - a.z) * (c.x - a.x)) > 1e-8) target.push(ids[0]!, ids[i]!, ids[i + 1]!);
+    }
+  };
+  // Split boundary triangles along actual contours, so material edges are curved rather than grid-shaped.
+  const split = (polygon: TerrainPoint[], field: (p: TerrainPoint) => number): [TerrainPoint[], TerrainPoint[]] => {
+    const inside: TerrainPoint[] = [],
+      outside: TerrainPoint[] = [];
+    for (let i = 0; i < polygon.length; i++) {
+      const a = polygon[i]!,
+        b = polygon[(i + 1) % polygon.length]!,
+        fa = field(a),
+        fb = field(b);
+      (fa <= 0 ? inside : outside).push(a);
+      if (fa <= 0 !== fb <= 0) {
+        let low = 0,
+          high = 1;
+        for (let step = 0; step < 10; step++) {
+          const t = (low + high) / 2;
+          const value = field({ x: a.x + (b.x - a.x) * t, z: a.z + (b.z - a.z) * t });
+          if (value <= 0 === fa <= 0) low = t;
+          else high = t;
+        }
+        const t = (low + high) / 2,
+          cut = { x: a.x + (b.x - a.x) * t, z: a.z + (b.z - a.z) * t };
+        inside.push(cut);
+        outside.push(cut);
+      }
+    }
+    return [inside, outside];
+  };
+  const target = (surface: ReturnType<typeof terrainSurface>) =>
+    surface === 'grass' ? surfaces.meadow : surface === 'hill' || surface === 'cave' ? surfaces.stone : surfaces.shore;
+  const triangle = (ids: number[]) => {
+    const polygon = ids.map((id) => points[id]!);
+    const kinds = polygon.map((p) => terrainSurface(land, p.x, p.z));
+    if (kinds.every((kind) => kind === kinds[0])) {
+      append(polygon, target(kinds[0]!));
+      return;
+    }
+    const bank = (p: TerrainPoint) => Math.abs(p.x - riverX(land, p.z)) - riverWidth(land, p.z);
+    const [river, dry] = split(polygon, bank);
+    append(river, surfaces.shore);
+    const [shore, inland] = split(dry, (p) => bank(p) - 1.4);
+    append(shore, surfaces.shore);
+    const [cave, open] = split(inland, (p) => caveClearance(land, p.x, p.z));
+    append(cave, surfaces.stone);
+    const [grass, hill] = split(open, (p) => hillRise(land, p.x, p.z) - 0.35);
+    append(grass, surfaces.meadow);
+    append(hill, surfaces.stone);
+  };
+  for (let row = 0; row < divisions; row++) {
+    for (let col = 0; col < divisions; col++) {
+      const a = row * (divisions + 1) + col,
+        b = a + divisions + 1;
+      triangle([a, b, a + 1]);
+      triangle([a + 1, b, b + 1]);
+    }
+    if (row % 2 === 1) yield;
+  }
+  const vertices = new Float32Array(mesh.vertices);
+  const material = (indices: number[]): Geometry => {
+    // Each material needs only its referenced vertices, not three copies of the entire landscape.
+    const remap = new Int32Array(vertices.length / 11).fill(-1),
+      compact: number[] = [];
+    const mapped = new Uint32Array(indices.length);
+    for (let i = 0; i < indices.length; i++) {
+      const old = indices[i]!;
+      let index = remap[old]!;
+      if (index < 0) {
+        index = compact.length / 11;
+        remap[old] = index;
+        for (let axis = 0; axis < 11; axis++) compact.push(vertices[old * 11 + axis]!);
+      }
+      mapped[i] = index;
+    }
+    return { vertices: new Float32Array(compact), indices: mapped };
+  };
+  const meadow = material(surfaces.meadow);
+  yield;
+  const stone = material(surfaces.stone);
+  yield;
+  const shore = material(surfaces.shore);
+  return {
+    meadow,
+    stone,
+    shore
+  };
+}
+
+export function riverGeometry(land: Landscape): Geometry {
+  const mesh = new Mesh(),
+    rows = 512,
+    cols = 8;
+  for (let row = 0; row <= rows; row++) {
+    const z = -TERRAIN_EDGE + (row * TERRAIN_EDGE * 2) / rows;
+    for (let col = 0; col <= cols; col++) {
+      const across = (col / cols) * 2 - 1;
+      const x = riverX(land, z) + across * riverWidth(land, z);
+      const y = waterLevel(land, z) + 0.04;
+      const edge = Math.abs(across),
+        ripple = Math.sin(z * 4.7 + across * 8) * 0.015;
+      const shade = 0.86 + 0.12 * Math.sin(z * 2.2 + across * 17);
+      mesh.vertex(
+        [x, y + ripple * (1 - edge), z],
+        [0, 1, 0],
+        [col / cols, z * 0.3],
+        [0.18 * shade + edge * 0.15, 0.48 * shade + edge * 0.2, 0.49 * shade + edge * 0.2]
+      );
+    }
+  }
+  for (let row = 0; row < rows; row++)
+    for (let col = 0; col < cols; col++) {
+      const a = row * (cols + 1) + col,
+        b = a + cols + 1;
+      mesh.quad(a, b, b + 1, a + 1, true);
+    }
+  return mesh.geometry();
+}
+
+/** Hollow stone tunnel: both exterior and interior faces, open portals at either end. */
+export function caveGeometry(): Geometry {
+  const mesh = new Mesh(),
+    rings = 12,
+    sides = 28;
+  const surface = (outer: boolean) => {
+    const first = mesh.vertices.length / 11;
+    for (let ring = 0; ring <= rings; ring++)
+      for (let side = 0; side <= sides; side++) {
+        const angle = (side / sides) * Math.PI,
+          z = -10 + (ring / rings) * 20;
+        const crag = outer ? 1 + Math.sin(side * 2.1 + ring * 1.7) * 0.045 : 1 + Math.sin(side * 1.6 + ring * 2) * 0.025;
+        const width = outer ? 5.8 : CAVE_INNER_WIDTH,
+          height = outer ? 7 : CAVE_INNER_HEIGHT;
+        const direction = outer ? 1 : -1;
+        mesh.vertex(
+          [Math.cos(angle) * width * crag, Math.sin(angle) * height * crag - 0.12, z],
+          [Math.cos(angle) * direction, Math.sin(angle) * direction, 0],
+          [(side / sides) * 4, z / 3],
+          outer ? [0.9, 0.92, 0.86] : [0.48, 0.54, 0.49]
+        );
+      }
+    for (let ring = 0; ring < rings; ring++)
+      for (let side = 0; side < sides; side++) {
+        const a = first + ring * (sides + 1) + side,
+          b = a + sides + 1;
+        mesh.quad(a, a + 1, b + 1, b, true);
+      }
+    return first;
+  };
+  const outer = surface(true),
+    inner = surface(false);
+  for (const end of [0, rings])
+    for (let side = 0; side < sides; side++) {
+      const a = outer + end * (sides + 1) + side,
+        b = inner + end * (sides + 1) + side;
+      // End faces need planar UVs and their own normals, or stone collapses into stretched stripes.
+      const cap = [a, a + 1, b + 1, b].map((index) => {
+        const at = index * 11,
+          x = mesh.vertices[at]!,
+          y = mesh.vertices[at + 1]!,
+          z = mesh.vertices[at + 2]!;
+        return mesh.vertex([x, y, z], [0, 0, end === 0 ? -1 : 1], [x / 3, y / 3], [0.78, 0.82, 0.76]);
+      });
+      mesh.quad(cap[0]!, cap[1]!, cap[2]!, cap[3]!, true);
+    }
+  return mesh.geometry();
+}
+
+/** Irregular stratified boulders, with smooth normals and repeatable UVs rather than scaled cubes. */
+export function boulderGeometry(style: number): Geometry {
+  const mesh = new Mesh(),
+    rings = ROCK_RINGS,
+    sides = ROCK_SIDES;
+  for (let ring = 0; ring <= rings; ring++)
+    for (let side = 0; side <= sides; side++) {
+      const { position, normal } = rockSurface(style, (side / sides) * Math.PI * 2, (ring / rings) * Math.PI);
+      mesh.vertex(position, normal, [(side / sides) * 2, ring / rings], [0.86, 0.89, 0.82]);
+    }
+  for (let ring = 0; ring < rings; ring++)
+    for (let side = 0; side < sides; side++) {
+      const a = ring * (sides + 1) + side,
+        b = a + sides + 1;
+      mesh.quad(a, a + 1, b + 1, b, true);
+    }
+  return mesh.geometry();
+}
+
+export function foliageGeometry(pine: boolean, style: number): Geometry {
+  const rng = random(173 + style * 67 + (pine ? 3 : 0)),
+    mesh = new Mesh();
+  const cards = pine ? 74 : 56;
+  for (let i = 0; i < cards; i++) {
+    const angle = i * 2.399 + rng(),
+      level = i / cards;
+    const y = pine ? 4.8 + level * 4.5 : 5.3 + rng() * 2.7;
+    const reach = pine ? (1 - level * 0.83) * 2.6 : 0.5 + rng() * 2;
+    const center: Vec3 = [Math.cos(angle) * reach * 0.7, y, Math.sin(angle) * reach * 0.7];
+    const width = pine ? reach * 1.6 : 1.8 + rng(),
+      depth = pine ? 1.2 : 1.6 + rng();
+    const tilt = pine ? 0.3 + rng() * 0.3 : -0.8 + rng() * 1.6;
+    const right: Vec3 = [(Math.cos(angle) * width) / 2, 0, (Math.sin(angle) * width) / 2];
+    const up: Vec3 = [(-Math.sin(angle) * depth * Math.cos(tilt)) / 2, (Math.sin(tilt) * depth) / 2, (Math.cos(angle) * depth * Math.cos(tilt)) / 2];
+    const shade = 0.7 + rng() * 0.32;
+    const ids = [
+      [-1, -1, 0, 1],
+      [1, -1, 1, 1],
+      [1, 1, 1, 0],
+      [-1, 1, 0, 0]
+    ].map(([r, u, tx, ty]) =>
+      mesh.vertex(
+        [center[0] + right[0] * r! + up[0] * u!, center[1] + up[1] * u!, center[2] + right[2] * r! + up[2] * u!],
+        [0, 0.9, 0.25],
+        [tx!, ty!],
+        [shade, shade, shade]
+      )
+    );
+    mesh.quad(ids[0]!, ids[1]!, ids[2]!, ids[3]!, true);
+  }
+  return mesh.geometry();
+}
+
+/** Tiny bent blades, distributed in shared clumps; actual grass rather than an entirely flat field. */
+export function grassGeometry(style: number): Geometry {
+  const rng = random(style + 543),
+    mesh = new Mesh();
+  for (let i = 0; i < 24; i++) {
+    const x = (rng() - 0.5) * 1.8,
+      z = (rng() - 0.5) * 1.8,
+      height = 0.12 + rng() * 0.26,
+      angle = rng() * Math.PI * 2;
+    const dx = Math.cos(angle) * 0.008,
+      dz = Math.sin(angle) * 0.008;
+    const color: Color = [0.3 + rng() * 0.16, 0.4 + rng() * 0.2, 0.12 + rng() * 0.1];
+    const a = mesh.vertex([x - dx, 0, z - dz], [0, 1, 0], [0, 0], color),
+      b = mesh.vertex([x + dx, 0, z + dz], [0, 1, 0], [1, 0], color),
+      c = mesh.vertex([x + 0.06, height, z + 0.025], [0, 1, 0], [0.5, 1], color);
+    mesh.indices.push(a, b, c, c, b, a);
+  }
+  return mesh.geometry();
+}