@nayan-ui/games 1.19.0 → 1.20.0

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

@@ -0,0 +1,506 @@
+// Treasure Hunt: one native skeletal explorer, procedural robots and contact shadows.
+import {
+  type Color,
+  type Entity,
+  type GeometryPart,
+  lathe,
+  type LoadedModel,
+  loadModel,
+  loadTexture,
+  merge,
+  type Model,
+  type Quat,
+  quat,
+  shapeGeometry,
+  type Texture,
+  type TransformBatch,
+  tube,
+  type Vec3,
+  type World
+} from '@nayan-ui/engine';
+import source from '../../assets/models/explorer/source.json';
+import { cacheGameAsset, createGameMesh as createShape } from '../shared/EngineMeshes';
+import { HUMAN_CLIPS, HUMAN_HEIGHT, HUMAN_LOOPS, type HumanAnimation, locomotionRate, type Point } from './TreasureHuntConstants';
+import { contactShadowGeometry, type HumanSoles, humanSupportHeight } from './TreasureHuntMeshes';
+import { groundHeight, groundTilt, type NatureMap, toWorld } from './TreasureHuntRules';
+
+export interface HumanAssets {
+  model: LoadedModel;
+  atlas: Texture;
+  soleIndices: Uint32Array;
+  supportIndices: Uint32Array;
+  leftCount: number;
+}
+let humanAssetsLoading: Promise<HumanAssets> | undefined;
+/** Native GLB skinning shares one mesh and clips across every explorer instance. */
+export function loadHumanAssets(): Promise<HumanAssets> {
+  humanAssetsLoading ??= (async () => {
+    const [model, atlas] = await Promise.all([
+      loadModel(require('../../assets/models/explorer/explorer.glb'), { center: false, fit: HUMAN_HEIGHT, shine: 0.055 }),
+      loadTexture(require('../../assets/textures/explorer-atlas.png'))
+    ]);
+    if (!model.jointCount || Object.keys(HUMAN_CLIPS).some((name) => !model.animations.some((clip) => clip.name === name)))
+      throw Error('The explorer is missing its native skeletal animation clips');
+    return {
+      model,
+      atlas,
+      soleIndices: new Uint32Array(source.soleVertices.flat()),
+      supportIndices: new Uint32Array([...source.soleVertices.flat(), ...source.bodyContactVertices]),
+      leftCount: source.soleVertices[0]!.length
+    };
+  })().catch((error: unknown) => {
+    humanAssetsLoading = undefined;
+    throw error;
+  });
+  return humanAssetsLoading;
+}
+export interface Human {
+  root: Entity;
+  body: Entity;
+  animation: HumanAnimation | null;
+  rate: number;
+  strikes: number;
+  phase: number;
+  indices: Uint32Array;
+  supportIndices: Uint32Array;
+  samples: Float32Array;
+  leftCount: number;
+  soles: [[number, number, number], [number, number, number]];
+  shadows: [Entity[], Entity[]];
+}
+export function spawnHuman(world: World, position: Vec3, assets: HumanAssets): Human {
+  const root = world.spawn({ mesh: 'none', position, pickable: false });
+  const body = world.spawn({ mesh: assets.model, texture: assets.atlas, parent: root, pickable: false });
+  return {
+    root,
+    body,
+    animation: null,
+    rate: 1,
+    strikes: 0,
+    phase: 0,
+    indices: assets.soleIndices,
+    supportIndices: assets.supportIndices,
+    samples: new Float32Array(assets.supportIndices.length * 3),
+    leftCount: assets.leftCount,
+    soles: [
+      [0, 0, 0],
+      [0, 0, 0]
+    ],
+    shadows: [spawnContactShadow(world, root), spawnContactShadow(world, root)]
+  };
+}
+/** Query only boot vertices; full-body skinning and clip blending stay on the native GPU path. */
+export function placeHuman(world: World, human: Human, map: NatureMap, point: Point, yaw: number, dt = 0, updates?: TransformBatch) {
+  const falling = human.animation === 'fall';
+  if (!world.sampleSkinnedVertices(human.body, falling ? human.supportIndices : human.indices, human.samples, dt)) return;
+  for (let side = 0; side < 2; side++) {
+    const first = side === 0 ? 0 : human.leftCount,
+      end = side === 0 ? human.leftCount : human.indices.length;
+    let lowest = Infinity,
+      x = 0,
+      z = 0,
+      count = 0;
+    for (let i = first; i < end; i++) lowest = Math.min(lowest, human.samples[i * 3 + 1]!);
+    for (let i = first; i < end; i++)
+      if (human.samples[i * 3 + 1]! <= lowest + 0.008) {
+        x += human.samples[i * 3]!;
+        z += human.samples[i * 3 + 2]!;
+        count++;
+      }
+    human.soles[side]![0] = x / count;
+    human.soles[side]![1] = lowest;
+    human.soles[side]![2] = z / count;
+  }
+  const feet: HumanSoles = human.soles;
+  const ground = feet.map((foot) => {
+    const p = toWorld({ rotation: yaw }, foot[0], foot[2]);
+    return groundHeight(map, point.x + p.x, point.z + p.z);
+  });
+  let y = humanSupportHeight(feet, [ground[0]!, ground[1]!], human.animation === 'run');
+  if (falling) {
+    for (let i = human.indices.length; i < human.supportIndices.length; i++) {
+      const at = i * 3,
+        p = toWorld({ rotation: yaw }, human.samples[at]!, human.samples[at + 2]!);
+      y = Math.max(y, groundHeight(map, point.x + p.x, point.z + p.z) - human.samples[at + 1]!);
+    }
+  }
+  (updates ?? world).set(human.root, { position: [point.x, y, point.z], rotation: quat.y(yaw) });
+  feet.forEach((foot, index) => {
+    const p = toWorld({ rotation: yaw }, foot[0], foot[2]),
+      lift = Math.max(0, y + foot[1] - ground[index]!);
+    placeContactShadow(
+      world,
+      human.shadows[index]!,
+      [foot[0], ground[index]! - y + 0.006, foot[2]],
+      groundTilt(map, point.x + p.x, point.z + p.z, yaw),
+      0.11 + lift * 0.08,
+      0.19 + lift * 0.1,
+      0.09 * Math.exp(-lift * 6),
+      updates
+    );
+  });
+}
+export function playHuman(world: World, human: Human, animation: HumanAnimation, speed = 1) {
+  const sameLoop = human.animation === animation && HUMAN_LOOPS.has(animation),
+    rate = locomotionRate(speed, sameLoop ? human.rate : undefined);
+  if (sameLoop && human.rate === rate) return;
+  if (!sameLoop) human.phase = 0;
+  human.animation = animation;
+  human.rate = rate;
+  world.playClip(human.body, animation, {
+    loop: HUMAN_CLIPS[animation].loop,
+    speed: rate,
+    fade: animation === 'hit' ? 0.04 : 0.08,
+    ...(!sameLoop ? { time: 0 } : {})
+  });
+}
+export function resetHuman(world: World, human: Human) {
+  human.animation = 'idle';
+  human.rate = 0;
+  human.strikes = 0;
+  human.phase = 0;
+  world.playClip(human.body, 'idle', { loop: true, speed: 0, time: 0, fade: 0 });
+}
+export function advanceHuman(human: Human, dt: number) {
+  if (!human.animation) return;
+  const clip = HUMAN_CLIPS[human.animation],
+    next = human.phase + (dt * human.rate) / clip.duration;
+  human.phase = clip.loop ? next % 1 : Math.min(1, next);
+}
+// Robot models and animation.
+
+const STEEL: Color = [0.48, 0.56, 0.59],
+  ARMOR: Color = [0.31, 0.39, 0.42],
+  DARK: Color = [0.065, 0.09, 0.105],
+  CHROME: Color = [0.72, 0.76, 0.74],
+  AMBER: Color = [0.9, 0.43, 0.11];
+
+const part = (
+  shape: 'cube' | 'roundedBox' | 'sphere' | 'cylinder' | 'torus',
+  position: Vec3,
+  scale: Vec3,
+  color: Color,
+  rotation?: Quat
+): GeometryPart => ({
+  geometry: shapeGeometry(shape),
+  position,
+  scale,
+  color,
+  rotation
+});
+
+const box = (position: Vec3, scale: Vec3, color: Color) => part('roundedBox', position, scale, color);
+
+const bolt = (x: number, y: number, z: number) => part('sphere', [x, y, z], [0.035, 0.035, 0.025], CHROME);
+
+const make = (parts: GeometryPart[], shine = 0.45) => createShape(merge(parts), { center: false, shine });
+
+interface RobotMeshes {
+  chassis: Model;
+  head: Model;
+  arm: Model;
+  forearm: Model;
+  thigh: Model;
+  shin: Model;
+}
+
+let cached: RobotMeshes | undefined;
+
+function prepareRobot(): RobotMeshes {
+  return cacheGameAsset('treasure-hunt/TreasureHuntModel:prepareRobot', () => prepareRobotUncached());
+}
+
+function prepareRobotUncached(): RobotMeshes {
+  if (cached) return cached;
+  const chassis: GeometryPart[] = [
+    {
+      geometry: lathe(
+        [
+          [0.21, 0.88],
+          [0.29, 0.94],
+          [0.36, 1.22],
+          [0.32, 1.38],
+          [0.19, 1.43]
+        ],
+        { segments: 12, color: ARMOR }
+      ),
+      scale: [1, 1, 0.62]
+    },
+    part('cylinder', [0, 1.06, 0], [0.22, 0.7, 0.22], DARK),
+    box([0, 1.23, 0.21], [0.46, 0.3, 0.065], STEEL),
+    box([0, 0.97, 0.15], [0.37, 0.16, 0.055], ARMOR),
+    box([0, 1.18, -0.21], [0.38, 0.4, 0.18], DARK),
+    part('cylinder', [0, 1.49, 0], [0.17, 0.15, 0.17], CHROME),
+    part('torus', [0, 1.27, 0.255], [0.17, 0.17, 0.05], CHROME, quat.x(Math.PI / 2)),
+    part('sphere', [0, 1.27, 0.28], [0.105, 0.105, 0.035], [2, 0.52, 0.12])
+  ];
+  for (const side of [-1, 1]) {
+    chassis.push(
+      part('sphere', [side * 0.37, 1.36, 0], [0.21, 0.23, 0.24], DARK),
+      part('cylinder', [side * 0.22, 1.25, -0.27], [0.105, 0.44, 0.105], STEEL)
+    );
+    chassis.push({
+      geometry: tube(
+        [
+          [side * 0.26, 0.94, 0.12],
+          [side * 0.31, 1.03, 0.15],
+          [side * 0.35, 1.24, 0.1]
+        ],
+        { radius: 0.018, sides: 6, color: AMBER }
+      )
+    });
+    for (const y of [1.11, 1.34]) chassis.push(bolt(side * 0.195, y, 0.255));
+    for (let i = 0; i < 4; i++) chassis.push(box([side * 0.15, 1.13 + i * 0.035, 0.249], [0.095, 0.012, 0.018], DARK));
+  }
+  const head: GeometryPart[] = [
+    box([0, 1.7, 0], [0.45, 0.31, 0.35], STEEL),
+    box([0, 1.52, 0.025], [0.36, 0.1, 0.29], ARMOR),
+    box([0, 1.7, 0.178], [0.34, 0.175, 0.028], DARK),
+    box([0, 1.845, 0], [0.28, 0.035, 0.2], ARMOR),
+    box([0, 1.58, 0.17], [0.17, 0.025, 0.025], DARK)
+  ];
+  for (const side of [-1, 1]) {
+    head.push(
+      part('sphere', [side * 0.084, 1.718, 0.202], [0.072, 0.065, 0.036], [2, 0.17, 0.07]),
+      part('torus', [side * 0.084, 1.718, 0.195], [0.095, 0.095, 0.035], CHROME, quat.x(Math.PI / 2)),
+      bolt(side * 0.18, 1.79, 0.172),
+      bolt(side * 0.18, 1.6, 0.172)
+    );
+    head.push(part('cylinder', [side * 0.24, 1.7, 0], [0.06, 0.14, 0.13], DARK));
+  }
+  head.push(
+    {
+      geometry: tube(
+        [
+          [0.18, 1.82, -0.03],
+          [0.21, 1.99, -0.05],
+          [0.18, 2.05, -0.05]
+        ],
+        { radius: 0.012, sides: 6, color: STEEL }
+      )
+    },
+    part('sphere', [0.18, 2.05, -0.05], [0.035, 0.035, 0.035], [1.7, 0.18, 0.1])
+  );
+  const arm: GeometryPart[] = [
+    part('sphere', [0, 0, 0], [0.2, 0.2, 0.21], CHROME),
+    part('cylinder', [0, -0.17, 0], [0.11, 0.31, 0.12], DARK),
+    box([0, -0.15, 0.045], [0.18, 0.26, 0.16], ARMOR),
+    part('cylinder', [0, -0.29, 0], [0.14, 0.1, 0.15], CHROME)
+  ];
+  for (const side of [-1, 1]) arm.push(part('cylinder', [side * 0.06, -0.16, -0.05], [0.025, 0.25, 0.025], CHROME), bolt(side * 0.055, -0.09, 0.128));
+  const forearm: GeometryPart[] = [
+    part('sphere', [0, 0, 0], [0.13, 0.13, 0.14], DARK),
+    box([0, -0.16, 0.015], [0.17, 0.28, 0.19], STEEL),
+    box([0, -0.2, 0.12], [0.1, 0.12, 0.025], ARMOR),
+    part('cylinder', [0, -0.31, 0], [0.09, 0.06, 0.1], CHROME),
+    box([0, -0.36, 0.02], [0.16, 0.1, 0.14], DARK)
+  ];
+  for (const side of [-1, 1])
+    forearm.push(
+      box([side * 0.063, -0.42, 0.045], [0.043, 0.12, 0.07], STEEL),
+      box([side * 0.063, -0.47, 0.08], [0.044, 0.05, 0.1], CHROME),
+      bolt(side * 0.053, -0.1, 0.12)
+    );
+  const thigh: GeometryPart[] = [
+    part('sphere', [0, 0, 0], [0.19, 0.2, 0.19], DARK),
+    part('cylinder', [0, -0.18, 0], [0.115, 0.34, 0.12], CHROME),
+    box([0, -0.17, 0.045], [0.19, 0.26, 0.16], ARMOR),
+    box([0, -0.13, 0.13], [0.085, 0.11, 0.025], AMBER),
+    part('sphere', [0, -0.34, 0.01], [0.19, 0.17, 0.2], DARK)
+  ];
+  const shin: GeometryPart[] = [
+    part('sphere', [0, 0, 0], [0.16, 0.16, 0.17], CHROME),
+    box([0, -0.16, 0.02], [0.17, 0.29, 0.17], ARMOR),
+    part('cylinder', [0, -0.2, -0.055], [0.075, 0.33, 0.075], DARK),
+    box([0, -0.405, 0.075], [0.23, 0.12, 0.35], DARK),
+    box([0, -0.365, 0.12], [0.23, 0.07, 0.24], STEEL)
+  ];
+  for (const side of [-1, 1])
+    shin.push(
+      part('cylinder', [side * 0.083, -0.16, 0.015], [0.026, 0.28, 0.026], CHROME),
+      bolt(side * 0.075, -0.04, 0.1),
+      bolt(side * 0.08, -0.36, 0.24)
+    );
+  cached = { chassis: make(chassis), head: make(head, 0.6), arm: make(arm), forearm: make(forearm, 0.6), thigh: make(thigh), shin: make(shin, 0.6) };
+  return cached;
+}
+
+export interface RobotVisual {
+  root: Entity;
+  warning: Entity;
+  chassis: Entity;
+  head: Entity;
+  armL: Entity;
+  armR: Entity;
+  elbowL: Entity;
+  elbowR: Entity;
+  legL: Entity;
+  legR: Entity;
+  kneeL: Entity;
+  kneeR: Entity;
+  motion: 'idle' | 'walk' | 'attack' | 'stagger' | null;
+  colorState: number | null;
+  warningVisible: boolean;
+  pose: [number, number, number, number];
+}
+
+export function spawnRobot(world: World, x: number, y: number, z: number): RobotVisual {
+  const meshes = prepareRobot(),
+    root = world.spawn({ mesh: 'none', position: [x, y, z], pickable: false });
+  const add = (mesh: Model, parent: Entity, position: Vec3) => world.spawn({ mesh, parent, position, pickable: false });
+  const chassis = add(meshes.chassis, root, [0, 0, 0]),
+    head = add(meshes.head, root, [0, 0, 0]);
+  const armL = add(meshes.arm, root, [-0.41, 1.38, 0]),
+    armR = add(meshes.arm, root, [0.41, 1.38, 0]);
+  const elbowL = add(meshes.forearm, armL, [0, -0.31, 0]),
+    elbowR = add(meshes.forearm, armR, [0, -0.31, 0]);
+  const legL = add(meshes.thigh, root, [-0.2, 0.86, 0]),
+    legR = add(meshes.thigh, root, [0.2, 0.86, 0]);
+  const kneeL = add(meshes.shin, legL, [0, -0.34, 0]),
+    kneeR = add(meshes.shin, legR, [0, -0.34, 0]);
+  const warning = world.spawn({ mesh: 'torus', parent: root, position: [0, 0.04, 0], scale: 0, color: [2, 0.24, 0.12, 1], pickable: false });
+  return {
+    root,
+    warning,
+    chassis,
+    head,
+    armL,
+    armR,
+    elbowL,
+    elbowR,
+    legL,
+    legR,
+    kneeL,
+    kneeR,
+    motion: null,
+    colorState: null,
+    warningVisible: false,
+    pose: [NaN, NaN, NaN, NaN]
+  };
+}
+
+function animateRobot(world: World, visual: RobotVisual, motion: NonNullable<RobotVisual['motion']>) {
+  if (visual.motion === motion) return;
+  visual.motion = motion;
+  const joints = [visual.armL, visual.armR, visual.elbowL, visual.elbowR, visual.legL, visual.legR, visual.kneeL, visual.kneeR];
+  for (const joint of joints) world.stopAnimation(joint);
+  if (motion === 'walk') {
+    for (const [hip, knee, arm, elbow, side] of [
+      [visual.legL, visual.kneeL, visual.armL, visual.elbowL, 1],
+      [visual.legR, visual.kneeR, visual.armR, visual.elbowR, -1]
+    ] as const) {
+      const times = [0, 0.25, 0.5, 0.75, 1];
+      world.animate(
+        hip,
+        times.map((at) => ({ at, rotation: quat.x(Math.sin(at * Math.PI * 2) * side * 0.3) })),
+        { duration: 0.85, repeat: 'forever', easing: 'linear' }
+      );
+      world.animate(
+        knee,
+        times.map((at) => ({ at, rotation: quat.x(Math.max(0, Math.sin(at * Math.PI * 2) * side) * 0.46) })),
+        { duration: 0.85, repeat: 'forever', easing: 'linear' }
+      );
+      world.animate(
+        arm,
+        times.map((at) => ({ at, rotation: quat.x(-Math.sin(at * Math.PI * 2) * side * 0.25) })),
+        { duration: 0.85, repeat: 'forever', easing: 'linear' }
+      );
+      world.animate(elbow, { rotation: quat.x(-0.16) }, { duration: 0.12 });
+    }
+  } else {
+    for (const joint of joints)
+      world.animate(
+        joint,
+        {
+          rotation: quat.x(
+            motion === 'attack'
+              ? joint === visual.armL || joint === visual.armR
+                ? -0.9
+                : joint === visual.elbowL || joint === visual.elbowR
+                  ? -0.8
+                  : 0
+              : motion === 'stagger'
+                ? 0.12
+                : 0
+          )
+        },
+        { duration: 0.15, easing: 'easeOut' }
+      );
+  }
+}
+
+export function placeRobot(
+  world: World,
+  visual: RobotVisual,
+  x: number,
+  z: number,
+  y: number,
+  yaw: number,
+  windup: number,
+  stagger: number,
+  moving: boolean,
+  _time: number,
+  updates?: TransformBatch
+) {
+  const transforms = updates ?? world;
+  const pose = visual.pose;
+  if (pose[0] !== x || pose[1] !== y || pose[2] !== z || pose[3] !== yaw) {
+    transforms.set(visual.root, { position: [x, y, z], rotation: quat.y(yaw) });
+    pose[0] = x;
+    pose[1] = y;
+    pose[2] = z;
+    pose[3] = yaw;
+  }
+  const colorState = stagger > 0 ? 2 : windup > 0 ? 1 : 0;
+  if (visual.colorState !== colorState) {
+    const color: Color = colorState === 2 ? [1.8, 1.8, 1.8, 1] : colorState === 1 ? [1.25, 1.05, 0.9, 1] : [1, 1, 1, 1];
+    transforms.set(visual.chassis, { color });
+    transforms.set(visual.head, { color });
+    visual.colorState = colorState;
+  }
+  if (visual.warningVisible !== windup > 0) {
+    transforms.set(visual.warning, { scale: windup > 0 ? [3.5, 0.04, 3.5] : 0 });
+    visual.warningVisible = windup > 0;
+  }
+  animateRobot(world, visual, stagger > 0 ? 'stagger' : windup > 0 ? 'attack' : moving ? 'walk' : 'idle');
+}
+// Shared contact shadows.
+
+let disc: Model | undefined;
+const shadowMesh = () =>
+  cacheGameAsset('treasure-hunt/TreasureHuntModel:shadowMesh', () => (disc ??= createShape(contactShadowGeometry(), { center: false })));
+
+const SPREAD = [1.8, 1.3, 0.85];
+
+/** One cached mesh for all foot and trunk contact shadows, owned by their actor/scenery root. */
+export function spawnContactShadow(world: World, parent: Entity): Entity[] {
+  disc = shadowMesh();
+  return SPREAD.map(() => world.spawn({ mesh: disc!, parent, scale: 0, color: [0, 0, 0, 0], pickable: false }));
+}
+
+export function placeContactShadow(
+  world: World,
+  layers: Entity[],
+  position: Vec3,
+  rotation: Quat,
+  width: number,
+  depth: number,
+  opacity: number,
+  updates?: TransformBatch
+) {
+  layers.forEach((entity, index) =>
+    (updates ?? world).set(entity, {
+      position: [position[0], position[1] + index * 0.001, position[2]],
+      rotation,
+      scale: [width * SPREAD[index]!, 1, depth * SPREAD[index]!],
+      color: [0, 0, 0, opacity]
+    })
+  );
+}
+
+/** The explorer loader and robot caches are shared with the actual game. */
+export function* warmAssets(): Iterable<() => unknown> {
+  yield loadHumanAssets;
+  yield prepareRobot;
+  yield shadowMesh;
+}