@nayan-ui/games 1.18.0 → 1.20.0

package/src/games/penguin-run/PenguinMeshes.ts

@@ -0,0 +1,269 @@
+// The cartoon penguin's meshes: a glossy navy body and big round head (one mesh, with the heart-shaped
+// white face, oval belly, huge shiny eyes, rosy cheeks, orange beak, head tufts and tail all baked
+// in), paddle flippers and chunky orange feet on short legs. Model units: the bird is about 1 tall,
+// the body's origin is the pelvis (0.36 above the ground).
+import { type Color, type GeometryPart, lathe, merge, type Model, shapeGeometry, tube, type Vec3 } from '@nayan-ui/engine';
+import { cacheGameAsset, createGameMesh as createShape } from '../shared/EngineMeshes';
+
+type RGB = [number, number, number];
+const NAVY: RGB = [0.06, 0.08, 0.14];
+const NAVY_SHEEN: RGB = [0.16, 0.2, 0.32];
+const CREAM: RGB = [1, 0.98, 0.93];
+const CREAM_SHADE: RGB = [0.88, 0.9, 0.95];
+const ORANGE: RGB = [1, 0.62, 0.12];
+const ORANGE_DARK: RGB = [0.92, 0.42, 0.08];
+const IRIS: RGB = [0.18, 0.5, 0.95];
+const IRIS_DARK: RGB = [0.06, 0.2, 0.55];
+const rgba = (c: RGB, a = 1): Color => [c[0], c[1], c[2], a];
+
+const mix = (a: RGB, b: RGB, t: number): RGB => {
+  const k = Math.min(1, Math.max(0, t));
+  return [a[0] + (b[0] - a[0]) * k, a[1] + (b[1] - a[1]) * k, a[2] + (b[2] - a[2]) * k];
+};
+/** 1 inside `edge`, 0 outside, blended over `soft`. */
+const inside = (d: number, edge: number, soft: number) => Math.min(1, Math.max(0, (edge - d) / soft + 0.5));
+
+/** An ellipse profile (rx across, ry tall, centred at cy), top to bottom, for `lathe`. */
+const ellipse = (rx: number, ry: number, cy: number, n = 28): [number, number][] =>
+  Array.from({ length: n + 1 }, (_, i) => {
+    const a = Math.PI / 2 - (i / n) * Math.PI;
+    return [Math.max(0.001, Math.cos(a) * rx), cy + Math.sin(a) * ry];
+  });
+
+// Head: an ellipsoid sitting on the body
+const HEAD_Y = 0.49;
+const HEAD_RX = 0.25;
+const HEAD_RY = 0.225;
+/** Depth of the head's front surface at (x, y), for placing features on it. */
+const headZ = (x: number, y: number) => HEAD_RX * Math.sqrt(Math.max(0, 1 - (x / HEAD_RX) ** 2 - ((y - HEAD_Y) / HEAD_RY) ** 2));
+
+/** Body: navy with a sheen up the back, and a cream oval belly in front. */
+function bodyColor({ position: [x, y, z] }: { position: Vec3 }): Color {
+  const base = mix(NAVY, NAVY_SHEEN, (y + 0.3) * 0.6 * Math.max(0, -z / 0.3 + 0.3));
+  const e = Math.sqrt((x / 0.235) ** 2 + ((y + 0.04) / 0.255) ** 2);
+  const belly = inside(e, 1, 0.06) * inside(-z, -0.04, 0.04);
+  return rgba(mix(base, mix(CREAM_SHADE, CREAM, (y + 0.25) * 2), belly));
+}
+
+/** Head: navy, with a heart-shaped white face (two rounded lobes over the eyes, a round chin). */
+function headColor({ position: [x, y, z] }: { position: Vec3 }): Color {
+  const base = mix(NAVY, NAVY_SHEEN, Math.max(0, (y - HEAD_Y) / HEAD_RY) * 0.5);
+  const lobe = Math.min(Math.hypot(x - 0.072, y - 0.53) / 0.1, Math.hypot(x + 0.072, y - 0.53) / 0.1);
+  const chin = Math.hypot(x / 1.15, y - 0.44) / 0.115;
+  const face = inside(Math.min(lobe, chin), 1, 0.08) * inside(-z, -0.06, 0.04);
+  return rgba(mix(base, CREAM, face));
+}
+
+/** A feature on the face: an ellipsoid at (x, y), pushed `out` from the head's surface. */
+const onFace = (x: number, y: number, scale: Vec3 | number, out: number, color: Color): GeometryPart => ({
+  geometry: shapeGeometry('sphere'),
+  position: [x, y, headZ(x, y) + out],
+  scale,
+  color
+});
+
+function eye(side: number): GeometryPart[] {
+  const x = side * 0.074;
+  const y = 0.525;
+  return [
+    // Sclera, iris (lighter toward the bottom), pupil, a big and a small highlight
+    onFace(x, y, [0.1, 0.122, 0.05], -0.012, rgba([1, 1, 1])),
+    onFace(x + side * 0.004, y - 0.006, [0.07, 0.08, 0.03], 0.004, rgba(IRIS_DARK)),
+    onFace(x + side * 0.004, y - 0.012, [0.058, 0.06, 0.03], 0.008, rgba(IRIS)),
+    onFace(x + side * 0.004, y - 0.006, [0.036, 0.042, 0.03], 0.013, rgba([0.02, 0.02, 0.04])),
+    onFace(x - 0.014, y + 0.014, 0.024, 0.024, [1.8, 1.8, 1.8, 1]),
+    onFace(x + 0.016, y - 0.022, 0.011, 0.022, [1.6, 1.6, 1.6, 1]),
+    // A soft brow arching over each eye
+    {
+      geometry: tube(
+        [
+          [x + side * 0.05, y + 0.068, headZ(x + side * 0.05, y + 0.068) + 0.004],
+          [x, y + 0.085, headZ(x, y + 0.085) + 0.006],
+          [x - side * 0.045, y + 0.075, headZ(x - side * 0.045, y + 0.075) + 0.004]
+        ],
+        { radius: (t) => 0.009 + Math.sin(t * Math.PI) * 0.005, sides: 6, color: rgba(NAVY) }
+      )
+    }
+  ];
+}
+
+/** The beak: a rounded upper bill with a curved tip, a smaller lower bill and a dark mouth line. */
+function beak(): GeometryPart[] {
+  const z = headZ(0, 0.46);
+  const wide = (a: number) => 1 + 0.45 * Math.abs(Math.cos(a * Math.PI * 2));
+  return [
+    {
+      geometry: tube(
+        [
+          [0, 0.468, z - 0.03],
+          [0, 0.464, z + 0.03],
+          [0, 0.452, z + 0.075],
+          [0, 0.44, z + 0.09]
+        ],
+        { radius: (t) => 0.048 * (1 - t * 0.85), shape: wide, sides: 16, color: ({ v }) => rgba(mix(ORANGE, ORANGE_DARK, v * 0.6)) }
+      )
+    },
+    {
+      geometry: tube(
+        [
+          [0, 0.436, z - 0.03],
+          [0, 0.434, z + 0.02],
+          [0, 0.432, z + 0.05]
+        ],
+        { radius: (t) => 0.03 * (1 - t * 0.8), shape: wide, sides: 14, color: rgba(ORANGE_DARK) }
+      )
+    }
+  ];
+}
+
+/** Three little feather tufts curling forward off the top of the head. */
+const tufts = (): GeometryPart[] =>
+  [-1, 0, 1].map((i) => ({
+    geometry: tube(
+      [
+        [i * 0.035, HEAD_Y + HEAD_RY - 0.03, -0.02],
+        [i * 0.05, HEAD_Y + HEAD_RY + 0.04, 0.0 - Math.abs(i) * 0.01],
+        [i * 0.065, HEAD_Y + HEAD_RY + 0.07, 0.05]
+      ],
+      { radius: (t) => 0.022 * (1 - t * 0.85) * (i === 0 ? 1.15 : 0.9), sides: 8, color: rgba(NAVY) }
+    )
+  }));
+
+/** A stubby tail at the back. */
+const tail = (): GeometryPart => ({
+  geometry: tube(
+    [
+      [0, -0.2, -0.26],
+      [0, -0.27, -0.33],
+      [0, -0.3, -0.38]
+    ],
+    { radius: (t) => 0.07 * (1 - t * 0.8), shape: (a) => 0.4 + 0.6 * Math.abs(Math.cos(a * Math.PI * 2)), sides: 12, color: rgba(NAVY) }
+  )
+});
+
+let bodyModel: Model | null = null;
+/** The one-piece body: torso, head and every face detail in a single mesh. */
+export function bodyMesh(): Model {
+  return cacheGameAsset('penguin-run/PenguinMeshes:bodyMesh', () => bodyMeshUncached());
+}
+
+function bodyMeshUncached(): Model {
+  if (bodyModel) return bodyModel;
+  // A pear-shaped torso, widest low down
+  const torso = lathe(
+    [
+      [0.001, 0.42],
+      [0.14, 0.4],
+      [0.18, 0.34],
+      [0.2, 0.29],
+      [0.225, 0.24],
+      [0.258, 0.17],
+      [0.284, 0.09],
+      [0.302, 0.0],
+      [0.306, -0.08],
+      [0.296, -0.16],
+      [0.268, -0.24],
+      [0.215, -0.3],
+      [0.13, -0.33],
+      [0.001, -0.338]
+    ],
+    { segments: 64, color: bodyColor }
+  );
+  const head = lathe(ellipse(HEAD_RX, HEAD_RY, HEAD_Y, 32), { segments: 64, color: headColor });
+  bodyModel = createShape(merge([{ geometry: torso }, { geometry: head }, ...eye(-1), ...eye(1), ...beak(), ...tufts(), tail()]), {
+    center: false,
+    shine: 0.55
+  });
+  return bodyModel;
+}
+
+const flipperModels: Partial<Record<-1 | 1, Model>> = {};
+/** A paddle flipper hanging from its shoulder (origin): glossy navy outside, cream inside; `side` -1 is the left. */
+export function flipperMesh(side: -1 | 1): Model {
+  return cacheGameAsset('penguin-run/PenguinMeshes:flipperMesh' + JSON.stringify([side]), () => flipperMeshUncached(side));
+}
+
+function flipperMeshUncached(side: -1 | 1): Model {
+  const cached = flipperModels[side];
+  if (cached) return cached;
+  const g = tube(
+    [
+      [-side * 0.07, 0.05, 0],
+      [-side * 0.01, 0.02, 0],
+      [side * 0.02, -0.08, 0.01],
+      [side * 0.022, -0.17, 0.005],
+      [side * 0.01, -0.24, -0.01],
+      [-side * 0.006, -0.27, -0.015]
+    ],
+    {
+      radius: (t) => 0.06 * Math.sin(0.6 + t * 2.2) + 0.012,
+      shape: (a) => 0.32 + 0.68 * Math.abs(Math.cos(a * Math.PI * 2)),
+      sides: 18,
+      smoothness: 10,
+      color: ({ normal }) => rgba(normal[0] * side < -0.25 ? CREAM_SHADE : NAVY)
+    }
+  );
+  const model = createShape(g, { center: false, shine: 0.5 });
+  flipperModels[side] = model;
+  return model;
+}
+
+let footModel: Model | null = null;
+/** A chunky orange foot from its heel (origin) forward: a rounded pad and three plump toes. */
+export function footMesh(): Model {
+  return cacheGameAsset('penguin-run/PenguinMeshes:footMesh', () => footMeshUncached());
+}
+
+function footMeshUncached(): Model {
+  if (footModel) return footModel;
+  const sphere = shapeGeometry('sphere');
+  const toes: GeometryPart[] = [-0.42, 0, 0.42].map((a) => ({
+    geometry: tube(
+      [
+        [0, 0.03, 0.04],
+        [Math.sin(a) * 0.05, 0.026, 0.09],
+        [Math.sin(a) * 0.08, 0.022, 0.135]
+      ],
+      { radius: (t) => 0.032 - t * 0.008, sides: 10, color: rgba(ORANGE) }
+    )
+  }));
+  const tips: GeometryPart[] = [-0.42, 0, 0.42].map((a) => ({
+    geometry: sphere,
+    position: [Math.sin(a) * 0.08, 0.022, 0.135],
+    scale: 0.048,
+    color: rgba(ORANGE)
+  }));
+  // A short, stout leg from the heel up into the body (its top hidden inside it): orange at the ankle,
+  // feathered navy above, so the foot always reads as joined on, even mid-step
+  const leg: GeometryPart = {
+    geometry: tube(
+      [
+        [0, 0.04, 0.02],
+        [0, 0.12, 0.0],
+        [0, 0.22, -0.01]
+      ],
+      { radius: (t) => 0.045 + t * 0.04, sides: 12, color: ({ v }) => rgba(v < 0.35 ? mix(ORANGE_DARK, ORANGE, v * 2) : NAVY) }
+    )
+  };
+  footModel = createShape(
+    merge([
+      leg,
+      { geometry: sphere, position: [0, 0.03, 0.05], scale: [0.15, 0.06, 0.16], color: rgba(mix(ORANGE, ORANGE_DARK, 0.3)) },
+      ...toes,
+      ...tips
+    ]),
+    {
+      center: false,
+      shine: 0.35
+    }
+  );
+  return footModel;
+}
+
+/** Reusable assets; the game loader advances one builder per frame. */
+export function* warmAssets(): Iterable<() => unknown> {
+  yield bodyMesh;
+  yield footMesh;
+  yield () => flipperMesh(-1);
+  yield () => flipperMesh(1);
+}