@ludra/cli 0.4.0 → 0.7.0

package/templates/topdown/scripts/night.ts

@@ -0,0 +1,67 @@
+import type { Script } from "@ludra/core";
+
+/** A stable pseudo-random number per index, so fireflies keep their paths. */
+function hash(n: number): number {
+  const x = Math.sin(n * 91.7 + 47.3) * 43758.5453;
+  return x - Math.floor(x);
+}
+
+/**
+ * Moonlit night over the grove: darkness everywhere except the hero's lantern,
+ * then colored light from glowing things (params.lights maps an id prefix to a
+ * color), and fireflies. Presentation only: the darkness never hides a hazard
+ * completely (params.darkness stays well below 1).
+ */
+export default {
+  drawUI({ g, world, view, time }) {
+    const toScreen = (x: number, y: number) => [(x - view.cameraX) * view.zoom, (y - view.cameraY) * view.zoom] as const;
+    const hero = world.player();
+    const darkness = 0.62;
+
+    // Darkness with a soft hole where the lantern shines.
+    const [hx, hy] = hero ? toScreen(hero.x, hero.y) : [view.width / 2, view.height / 2];
+    const flicker = 1 + Math.sin(time * 11) * 0.015 + Math.sin(time * 7.3) * 0.02;
+    const night = g.createRadialGradient(hx, hy, 30 * flicker, hx, hy, 210 * flicker);
+    night.addColorStop(0, "rgba(6, 10, 30, 0)");
+    night.addColorStop(1, `rgba(6, 10, 30, ${darkness})`);
+    g.fillStyle = night;
+    g.fillRect(0, 0, view.width, view.height);
+
+    // Light from glowing things, added on top of the darkness.
+    g.globalCompositeOperation = "lighter";
+    const lights: Record<string, string> = { "gem-": "#2fb8ff", portal: "#b25cff", "slime-": "#8a3cff", thorns: "#ff3355" };
+    for (const e of world.all()) {
+      const prefix = Object.keys(lights).find((p) => e.id.startsWith(p));
+      if (!prefix) continue;
+      const [x, y] = toScreen(e.x, e.y);
+      const radius = (prefix === "portal" ? 110 : 60) * (0.85 + 0.15 * Math.sin(time * 2.4 + e.x));
+      const light = g.createRadialGradient(x, y, 0, x, y, radius);
+      light.addColorStop(0, `${lights[prefix]}66`);
+      light.addColorStop(1, `${lights[prefix]}00`);
+      g.fillStyle = light;
+      g.fillRect(x - radius, y - radius, radius * 2, radius * 2);
+    }
+    if (hero) {
+      const lantern = g.createRadialGradient(hx, hy, 0, hx, hy, 120 * flicker);
+      lantern.addColorStop(0, "rgba(255, 190, 110, 0.32)");
+      lantern.addColorStop(1, "rgba(255, 190, 110, 0)");
+      g.fillStyle = lantern;
+      g.fillRect(hx - 130, hy - 130, 260, 260);
+    }
+
+    // Fireflies drifting on their own little loops.
+    for (let i = 0; i < 36; i++) {
+      const [x, y] = toScreen(
+        hash(i) * world.width + Math.sin(time * (0.3 + hash(i + 50) * 0.5) + i) * 40,
+        hash(i + 100) * world.height + Math.cos(time * (0.25 + hash(i + 80) * 0.4) + i * 2) * 30,
+      );
+      const blink = Math.max(0, Math.sin(time * (1.5 + hash(i + 7) * 2) + i * 3));
+      g.fillStyle = `rgba(220, 255, 140, ${0.75 * blink})`;
+      g.shadowColor = "#d4ff6b";
+      g.shadowBlur = 10;
+      g.beginPath();
+      g.arc(x, y, 1.6, 0, Math.PI * 2);
+      g.fill();
+    }
+  },
+} satisfies Script;

package/templates/topdown/scripts/portal.ts

@@ -0,0 +1,34 @@
+import type { Script } from "@ludra/core";
+
+/**
+ * A vortex of light over the portal sprite. It spins slowly while the portal
+ * is asleep and wakes up (faster, brighter) once params.need crystals are found.
+ */
+export default {
+  draw({ g, self, world, params, time }) {
+    const awake = world.score >= (params.need as number);
+    const spin = time * (awake ? 3.2 : 0.9);
+    g.globalCompositeOperation = "lighter";
+    g.lineCap = "round";
+    for (let i = 0; i < 5; i++) {
+      const radius = 8 + i * 4.5;
+      const start = spin * (i % 2 === 0 ? 1 : -1.3) + i;
+      g.strokeStyle = i % 2 === 0 ? "#d8a6ff" : "#6be4ff";
+      g.globalAlpha = awake ? 0.9 : 0.35;
+      g.lineWidth = awake ? 2.5 : 1.5;
+      g.shadowColor = g.strokeStyle;
+      g.shadowBlur = awake ? 14 : 6;
+      g.beginPath();
+      g.arc(self.x, self.y, radius, start, start + Math.PI * 1.1);
+      g.stroke();
+    }
+    if (awake) {
+      const core = g.createRadialGradient(self.x, self.y, 0, self.x, self.y, 26);
+      core.addColorStop(0, "rgba(255, 255, 255, 0.9)");
+      core.addColorStop(1, "rgba(178, 92, 255, 0)");
+      g.globalAlpha = 0.7 + 0.3 * Math.sin(time * 6);
+      g.fillStyle = core;
+      g.fillRect(self.x - 26, self.y - 26, 52, 52);
+    }
+  },
+} satisfies Script;

package/templates/topdown/shaders/dream.frag

@@ -0,0 +1,31 @@
+// A soft, dreamy finish: bloom that makes the lights bleed, a cool-shadow and
+// warm-highlight grade, and a vignette.
+// The engine declares u_image, u_resolution, u_time and v_uv, plus every
+// uniform listed under "postfx.uniforms" in the scene.
+
+void main() {
+  vec2 pixel = 1.0 / u_resolution;
+  vec3 color = texture2D(u_image, v_uv).rgb;
+
+  // Gaussian-weighted taps: far taps count less, so thin bright text doesn't leave a dotted grid.
+  vec3 glow = vec3(0.0);
+  float total = 0.0;
+  for (int i = -5; i <= 5; i++) {
+    for (int j = -5; j <= 5; j++) {
+      float weight = exp(-float(i * i + j * j) / 12.0);
+      vec2 offset = vec2(float(i), float(j)) * pixel * 2.0;
+      glow += max(texture2D(u_image, v_uv + offset).rgb - 0.35, 0.0) * weight;
+      total += weight;
+    }
+  }
+  color += glow / total * bloom;
+
+  // Shadows lean blue, highlights lean gold.
+  float luma = dot(color, vec3(0.299, 0.587, 0.114));
+  color = mix(color * vec3(0.9, 0.97, 1.12), color * vec3(1.08, 1.0, 0.88), smoothstep(0.2, 0.8, luma) * warmth);
+
+  vec2 centered = v_uv - 0.5;
+  color *= 1.0 - vignette * dot(centered, centered) * 1.6;
+
+  gl_FragColor = vec4(color, 1.0);
+}

package/templates/topdown/tests/gameplay.test.json

@@ -0,0 +1,30 @@
+{
+  "tests": [
+    {
+      "name": "the hero stays put without input (no gravity in a top-down game)",
+      "duration": "1s",
+      "assert": ["hero.x == 80", "hero.y == 270", "deaths == 0"]
+    },
+    {
+      "name": "the hero moves diagonally",
+      "inputs": "right+down:0.5s",
+      "duration": "0.5s",
+      "assert": ["hero.x > 130", "hero.y > 320"]
+    },
+    {
+      "name": "hedges block the hero",
+      "inputs": "right:3s",
+      "assert": ["hero.x < 270", "deaths == 0"]
+    },
+    {
+      "name": "rushing through the middle corridor gets the hero caught by the slime",
+      "inputs": "up:1s, right:0.39s, down:2s, right:0.17s, right:1.61s, left:0.5s, wait:0.1s, up:1.95s",
+      "assert": ["deaths == 1", "events.die == 1"]
+    },
+    {
+      "name": "the grove can be cleared without dying",
+      "inputs": "up:1s, right:0.39s, down:2s, right:0.17s, right:1.61s, left:0.5s, wait:1.5s, up:1.95s, right:0.5s, right:1.94s, right:0.44s, wait:1.2s, down:2s",
+      "assert": ["won == true", "deaths == 0", "score == 5"]
+    }
+  ]
+}