@fluritheme/moon-explorer 0.0.0-stage → 0.1.0

package/dist/model.js

@@ -0,0 +1,429 @@
+export const clamp = (n, a, b) => Math.min(b, Math.max(a, n));
+export const lerp = (a, b, t) => a + (b - a) * t;
+export const ease = (t) => {
+    t = clamp(t, 0, 1);
+    return t * t * (3 - 2 * t);
+};
+export function random(seed) {
+    let s = seed >>> 0;
+    return () => {
+        s += 0x6d2b79f5;
+        let t = s;
+        t = Math.imul(t ^ (t >>> 15), t | 1);
+        t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+        return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+    };
+}
+export class Expedition {
+    world;
+    size;
+    auto;
+    rover;
+    maxFlags;
+    phase = "landing";
+    mission = null;
+    phaseTime = 0;
+    elapsed = 0;
+    x = 0;
+    y = 0;
+    startX = 0;
+    startY = 0;
+    targetX = 0;
+    targetY = 0;
+    facing = 1;
+    surface = { id: "floor", x: 0, y: 0, width: 0 };
+    distance = 0;
+    roverDistance = 0;
+    samples = 0;
+    missionsCompleted = 0;
+    dust = [];
+    footprints = [];
+    flags = [];
+    rocks = [];
+    stars = [];
+    queue = [];
+    roverX = 0;
+    roverY = 0;
+    landerX = 0;
+    landerY = 0;
+    landingStartY = 0;
+    sampled = false;
+    flagged = false;
+    lastStep = 0;
+    nextAuto = 0;
+    rng;
+    onEvent = () => { };
+    constructor(world, size = 1, auto = true, rover = true, maxFlags = 5, seed = 42) {
+        this.world = world;
+        this.size = size;
+        this.auto = auto;
+        this.rover = rover;
+        this.maxFlags = maxFlags;
+        this.rng = random(seed);
+        this.land();
+    }
+    event(event) {
+        this.onEvent(event, {
+            phase: this.phase,
+            mission: this.mission,
+            samples: this.samples,
+            flags: this.flags.length,
+            surface: this.surface.id,
+        });
+    }
+    choose(target) {
+        const options = this.world.surfaces.filter((s) => s.width > 100 * this.size &&
+            s.y >= this.world.view.y + 80 &&
+            s.y <= this.world.view.y + this.world.view.height - 20);
+        return (target ??
+            options[Math.floor(this.rng() * options.length)] ??
+            this.world.surfaces[0] ?? {
+            id: "floor",
+            x: this.world.bounds.x + 20,
+            y: this.world.bounds.y + this.world.bounds.height - 30,
+            width: Math.max(120, this.world.bounds.width - 40),
+        });
+    }
+    setPhase(phase) {
+        this.phase = phase;
+        this.phaseTime = 0;
+        this.startX = this.x;
+        this.startY = this.y;
+        this.event("phase");
+    }
+    land(target) {
+        this.surface = this.choose(target);
+        this.x =
+            this.surface.x +
+                clamp(this.surface.width * 0.55, 65 * this.size, this.surface.width - 55 * this.size);
+        this.y = this.surface.y;
+        this.landerX = this.x;
+        this.landerY = this.y;
+        this.landingStartY = Math.min(this.world.view.y - 160, this.y - 400);
+        this.roverX = this.x - 76 * this.size;
+        this.roverY = this.y;
+        this.queue = [];
+        this.rocks = [];
+        this.dust = [];
+        this.mission = null;
+        this.setPhase("landing");
+        this.populateRocks();
+    }
+    populateRocks() {
+        for (let i = 0; i < 3; i++)
+            if (this.rocks.length < 18)
+                this.rocks.push({
+                    x: this.surface.x +
+                        30 +
+                        this.rng() * Math.max(20, this.surface.width - 60),
+                    y: this.surface.y,
+                    size: (5 + this.rng() * 6) * this.size,
+                    collected: false,
+                    surface: this.surface.id,
+                    angle: this.rng() * 6,
+                });
+    }
+    enqueue(kind, target) {
+        if (this.queue.length >= 8)
+            return false;
+        if (kind === "rover" && !this.rover)
+            return false;
+        this.queue.push(target ? { kind, target } : { kind });
+        if (this.phase === "sleeping")
+            this.setPhase("idle");
+        return true;
+    }
+    startMission(kind, target) {
+        this.mission = kind;
+        this.event("mission");
+        this.sampled = false;
+        this.flagged = false;
+        if (kind === "explore") {
+            const s = this.choose(target);
+            if (s.id !== this.surface.id) {
+                this.surface = s;
+                this.targetX =
+                    s.x +
+                        clamp(s.width * 0.5, 35 * this.size, Math.max(40, s.width - 35 * this.size));
+                this.targetY = s.y;
+                this.setPhase("jumping");
+                this.populateRocks();
+            }
+            else {
+                this.targetX =
+                    s.x +
+                        35 * this.size +
+                        this.rng() * Math.max(1, s.width - 70 * this.size);
+                this.targetY = s.y;
+                this.setPhase("walking");
+            }
+        }
+        else if (kind === "rover") {
+            this.roverX = this.x - 45 * this.size;
+            this.roverY = this.y;
+            this.setPhase("boarding");
+        }
+        else if (kind === "jump") {
+            this.targetX = clamp(this.x + this.facing * 50 * this.size, this.surface.x + 30 * this.size, this.surface.x + this.surface.width - 30 * this.size);
+            this.targetY = this.surface.y;
+            this.setPhase("jumping");
+        }
+        else
+            this.setPhase(kind === "sample"
+                ? "sampling"
+                : kind === "flag"
+                    ? "planting"
+                    : kind === "observe"
+                        ? "observing"
+                        : kind === "rest"
+                            ? "sleeping"
+                            : "waving");
+    }
+    finish() {
+        if (this.mission)
+            this.missionsCompleted++;
+        this.mission = null;
+        this.setPhase("idle");
+        this.nextAuto = this.elapsed + 2.5 + this.rng() * 4;
+    }
+    burst(x = this.x, y = this.y, amount = 8, power = 1) {
+        for (let i = 0; i < amount && this.dust.length < 90; i++) {
+            const ttl = 0.5 + this.rng() * 0.7;
+            this.dust.push({
+                x,
+                y,
+                vx: (this.rng() - 0.5) * 65 * power,
+                vy: -this.rng() * 35 * power,
+                life: ttl,
+                ttl,
+                radius: (1 + this.rng() * 2.3) * this.size,
+            });
+        }
+    }
+    shootingStar() {
+        if (this.stars.length >= 5)
+            return;
+        const ttl = 1.1;
+        this.stars.push({
+            x: this.world.view.x + this.rng() * this.world.view.width * 0.7,
+            y: this.world.view.y + 30 + this.rng() * this.world.view.height * 0.25,
+            vx: 290 + this.rng() * 200,
+            vy: 100 + this.rng() * 90,
+            life: ttl,
+            ttl,
+        });
+    }
+    staticPose() {
+        this.phase = "idle";
+        this.phaseTime = 0;
+        this.mission = null;
+        this.x = this.landerX + 30 * this.size;
+        this.y = this.surface.y;
+    }
+    refresh(world) {
+        this.world = world;
+        const next = world.surfaces.find((s) => s.id === this.surface.id);
+        if (next) {
+            const delta = next.y - this.surface.y;
+            this.y += delta;
+            this.startY += delta;
+            this.targetY += delta;
+            this.landerY += delta;
+            this.roverY += delta;
+            for (const f of this.flags)
+                if (f.surface === next.id)
+                    f.y += delta;
+            for (const r of this.rocks)
+                if (r.surface === next.id)
+                    r.y += delta;
+            this.surface = next;
+            this.x = clamp(this.x, next.x + 22 * this.size, Math.max(next.x + 22 * this.size, next.x + next.width - 22 * this.size));
+        }
+        else {
+            this.surface = this.choose();
+            this.x = this.surface.x + this.surface.width * 0.5;
+            this.y = this.surface.y;
+            this.setPhase("idle");
+        }
+    }
+    step(dt) {
+        dt = clamp(dt, 0, 0.06);
+        this.elapsed += dt;
+        this.phaseTime += dt;
+        const t = this.phaseTime, s = this.size;
+        const before = this.x;
+        for (const d of this.dust) {
+            d.x += d.vx * dt;
+            d.y += d.vy * dt;
+            d.vy += 20 * dt;
+            d.life -= dt;
+        }
+        this.dust = this.dust.filter((d) => d.life > 0);
+        for (const f of this.footprints)
+            f.life -= dt;
+        this.footprints = this.footprints.filter((f) => f.life > 0).slice(-80);
+        for (const a of this.stars) {
+            a.x += a.vx * dt;
+            a.y += a.vy * dt;
+            a.life -= dt;
+        }
+        this.stars = this.stars.filter((a) => a.life > 0);
+        if (this.phase === "landing") {
+            this.landerY = lerp(this.landingStartY, this.surface.y, ease(t / 3.6));
+            this.y = this.landerY;
+            if (t > 2.4 && t < 3.6)
+                this.burst(this.x, this.surface.y, 2, 1 - t / 4);
+            if (t >= 3.6) {
+                this.burst(this.x, this.y, 24);
+                this.setPhase("egress");
+                this.event("landed");
+            }
+        }
+        else if (this.phase === "egress") {
+            this.x = lerp(this.startX, clamp(this.landerX + 65 * s, this.surface.x + 25 * s, this.surface.x + this.surface.width - 25 * s), ease(t / 1.9));
+            this.y =
+                this.surface.y - Math.sin(clamp(t / 1.9, 0, 1) * Math.PI) * 20 * s;
+            if (t >= 1.9) {
+                this.y = this.surface.y;
+                this.finish();
+            }
+        }
+        else if (this.phase === "idle") {
+            if (this.queue.length) {
+                const job = this.queue.shift();
+                this.startMission(job.kind, job.target);
+            }
+            else if (this.auto && this.elapsed >= this.nextAuto) {
+                const choices = [
+                    "explore",
+                    "sample",
+                    "wave",
+                    "observe",
+                    "jump",
+                    "flag",
+                    ...(this.rover ? ["rover"] : []),
+                ];
+                this.startMission(choices[Math.floor(this.rng() * choices.length)]);
+            }
+        }
+        else if (this.phase === "walking") {
+            const delta = this.targetX - this.x;
+            this.facing = delta >= 0 ? 1 : -1;
+            this.x += Math.sign(delta) * Math.min(Math.abs(delta), 23 * s * dt);
+            this.y = this.surface.y - Math.max(0, Math.sin(t * 5)) * 2 * s;
+            if (t - this.lastStep > 0.48) {
+                this.lastStep = t;
+                this.footprints.push({
+                    x: this.x,
+                    y: this.surface.y,
+                    facing: this.facing,
+                    side: Math.sin(t * 5) > 0 ? 1 : -1,
+                    life: 65,
+                });
+                this.burst(this.x, this.surface.y, 1, 0.3);
+            }
+            if (Math.abs(delta) < 1) {
+                this.y = this.surface.y;
+                this.finish();
+            }
+        }
+        else if (this.phase === "jumping") {
+            const u = clamp(t / 2.1, 0, 1);
+            this.facing = this.targetX >= this.startX ? 1 : -1;
+            this.x = lerp(this.startX, this.targetX, ease(u));
+            this.y =
+                lerp(this.startY, this.targetY, ease(u)) -
+                    Math.sin(u * Math.PI) *
+                        Math.min(115 * s, 65 + Math.abs(this.targetY - this.startY) * 0.25);
+            if (t >= 2.1) {
+                this.y = this.targetY;
+                this.burst(this.x, this.y, 14);
+                this.setPhase("celebrating");
+            }
+        }
+        else if (this.phase === "sampling") {
+            if (t > 2 && !this.sampled) {
+                this.sampled = true;
+                this.samples++;
+                const rock = this.rocks.find((r) => r.surface === this.surface.id && !r.collected);
+                if (rock)
+                    rock.collected = true;
+                this.burst(this.x + 20 * s, this.y, 5, 0.4);
+                this.event("sample");
+            }
+            if (t > 4.2)
+                this.setPhase("celebrating");
+        }
+        else if (this.phase === "planting") {
+            if (t > 1.8 && !this.flagged) {
+                this.flagged = true;
+                this.flags.push({
+                    x: this.x + 25 * s * this.facing,
+                    y: this.y,
+                    phase: this.rng() * 6,
+                    surface: this.surface.id,
+                });
+                this.flags = this.flags.slice(-this.maxFlags);
+                this.burst(this.x + 25 * s, this.y, 9, 0.4);
+                this.event("flag");
+            }
+            if (t > 3.6)
+                this.setPhase("celebrating");
+        }
+        else if (this.phase === "waving") {
+            if (t > 3.2)
+                this.finish();
+        }
+        else if (this.phase === "observing") {
+            if (t > 2.5 && t < 2.5 + dt)
+                this.shootingStar();
+            if (t > 5)
+                this.finish();
+        }
+        else if (this.phase === "boarding") {
+            this.x = lerp(this.startX, this.roverX, ease(t / 1.3));
+            this.y =
+                this.surface.y - Math.sin(clamp(t / 1.3, 0, 1) * Math.PI) * 20 * s;
+            if (t >= 1.3) {
+                this.targetX =
+                    this.surface.x +
+                        40 * s +
+                        this.rng() * Math.max(1, this.surface.width - 80 * s);
+                this.setPhase("driving");
+            }
+        }
+        else if (this.phase === "driving") {
+            const d = this.targetX - this.x;
+            this.facing = d >= 0 ? 1 : -1;
+            this.x += Math.sign(d) * Math.min(Math.abs(d), 38 * s * dt);
+            this.roverX = this.x;
+            this.y = this.surface.y - 3 * s + Math.sin(t * 9) * 1.2 * s;
+            this.roverDistance += Math.abs(this.x - before);
+            if (this.rng() < 0.4)
+                this.burst(this.x - 30 * s * this.facing, this.surface.y, 1, 0.35);
+            if (Math.abs(d) < 1) {
+                this.y = this.surface.y;
+                this.setPhase("dismounting");
+            }
+        }
+        else if (this.phase === "dismounting") {
+            this.x = lerp(this.startX, clamp(this.roverX + 55 * s * this.facing, this.surface.x + 25 * s, this.surface.x + this.surface.width - 25 * s), ease(t / 1.2));
+            this.y =
+                this.surface.y - Math.sin(clamp(t / 1.2, 0, 1) * Math.PI) * 18 * s;
+            if (t > 1.2) {
+                this.y = this.surface.y;
+                this.finish();
+            }
+        }
+        else if (this.phase === "celebrating") {
+            if (t > 1.4)
+                this.finish();
+        }
+        else if (this.phase === "sleeping") {
+            if (t > 7)
+                this.finish();
+        }
+        if (this.phase !== "driving")
+            this.distance += Math.abs(this.x - before);
+    }
+}

package/dist/render.d.ts

@@ -0,0 +1,13 @@
+import { type Expedition } from "./model.js";
+export interface PaintOptions {
+    accent: string;
+    lander: boolean;
+    rover: boolean;
+    pointer: {
+        x: number;
+        y: number;
+        active: boolean;
+    };
+    reduced: boolean;
+}
+export declare function paint(c: CanvasRenderingContext2D, m: Expedition, o: PaintOptions): void;