@nayan-ui/games 1.20.0 → 1.21.0

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

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