@ludra/core 0.5.0 → 0.8.0

package/src/world.ts

@@ -10,11 +10,13 @@ import {
   type Platformer,
   type ScriptComponent,
   type Sprite,
+  type Topdown,
   type Transform,
 } from "./components.ts";
 import {
   getScript,
   ScriptError,
+  type DrawContext,
   type Script,
   type ScriptContext,
   type ScriptEntity,
@@ -25,7 +27,7 @@ import {
 } from "./script.ts";
 import { FIXED_DT } from "./time.ts";
 import { EVENT_TYPES, type Action, type Diagnostic, type EntityDef, type SceneDef } from "./types.ts";
-import { validateScene } from "./validate.ts";
+import { mergeComponents, validateScene } from "./validate.ts";
 
 export interface BodyState extends Body {
   grounded: boolean;
@@ -38,8 +40,6 @@ export interface PlatformerState extends Platformer {
   /** True from a player-initiated jump until the apex, so only those jumps are cut short on release. */
   jumping: boolean;
   bufferTimer: number;
-  spawnX: number;
-  spawnY: number;
 }
 
 export interface PatrolState extends Patrol {
@@ -65,10 +65,14 @@ export interface Entity {
   body?: BodyState;
   sprite?: Sprite;
   platformer?: PlatformerState;
+  topdown?: Topdown;
+  /** Where a player respawns after dying. */
+  spawn?: { x: number; y: number };
   collectible?: Collectible;
   patrol?: PatrolState;
   hazard?: Hazard;
   goal?: Goal;
+  checkpoint?: Record<string, never>;
   emitter?: Emitter;
   camera?: Camera;
 }
@@ -81,6 +85,10 @@ export type GameEvent = { frame: number; time: number; x: number; y: number } &
   | { type: "die"; entity: string; cause: string }
   | { type: "stomp"; entity: string; enemy: string; score: number }
   | { type: "win"; entity: string; goal: string }
+  | { type: "bounce"; entity: string; other: string }
+  | { type: "checkpoint"; entity: string; checkpoint: string }
+  | { type: "gameover"; entity: string; cause: string }
+  | { type: "goto"; entity: string; scene: string }
   /** Fired by a script with world.emit(name, data). */
   | { type: "custom"; name: string; entity: string; data?: unknown }
 );
@@ -100,6 +108,8 @@ export interface EntitySnapshot {
 export interface WorldOptions {
   /** Loaded script modules, keyed by the `src` path used in the scene. */
   scripts?: ScriptModules;
+  /** Values carried over from the previous scene, so a run keeps its score and lives. */
+  carry?: { score?: number; deaths?: number; lives?: number };
 }
 
 export interface WorldSnapshot {
@@ -108,6 +118,9 @@ export interface WorldSnapshot {
   score: number;
   deaths: number;
   won: boolean;
+  lost: boolean;
+  /** Lives left; undefined when the scene has unlimited retries. */
+  lives?: number;
   entities: Record<string, EntitySnapshot>;
 }
 
@@ -133,6 +146,8 @@ const STOMP_TOLERANCE = 8;
 const FALL_MARGIN = 100;
 /** Bodies this close count as touching for `touch` hooks, so solids (doors, walls) can be touched too. */
 const TOUCH_MARGIN = 1;
+/** Impacts slower than this (px/s, after bounce) stop instead of bouncing. */
+const MIN_BOUNCE_SPEED = 40;
 const EPSILON = 1e-4;
 
 /**
@@ -152,6 +167,14 @@ export class World {
   deaths = 0;
   /** Set when a player reaches a goal. The simulation stops changing after that. */
   won = false;
+  /** Set when the game is over: out of lives, or a script called world.lose(). */
+  lost = false;
+  /** Lives left, or undefined for unlimited retries. */
+  lives: number | undefined;
+  /** The scene to play next (a won goal's `next`, or world.goto). Hosts that can load scenes move on to it. */
+  exit: string | undefined;
+  private readonly prefabs: Record<string, { components: Record<string, Record<string, unknown>> }>;
+  private readonly reached = new Set<string>();
   private previousInput: ReadonlySet<Action> = new Set();
   private readonly scripts: ScriptModules | undefined;
   private seed: number;
@@ -161,6 +184,8 @@ export class World {
   private scriptInput: ScriptInput = { held: () => false, pressed: () => false };
   /** The script hook currently running, for error messages and event attribution. */
   private current: { entity: Entity; hook: string } | undefined;
+  /** True while a draw hook runs: the game can't be changed then. */
+  private drawing = false;
 
   constructor(scene: SceneDef, options: WorldOptions = {}) {
     this.width = scene.world?.width ?? 960;
@@ -169,6 +194,10 @@ export class World {
     this.background = scene.world?.background ?? "#1d2333";
     this.seed = scene.world?.seed ?? 1;
     this.scripts = options.scripts;
+    this.prefabs = scene.prefabs ?? {};
+    this.score = options.carry?.score ?? 0;
+    this.deaths = options.carry?.deaths ?? 0;
+    this.lives = options.carry?.lives ?? scene.world?.lives;
     this.entities = scene.entities.map((def) => this.createEntity(def));
   }
 
@@ -183,6 +212,11 @@ export class World {
     return this.frame * FIXED_DT;
   }
 
+  /** True once nothing more happens in this scene: won, lost, or moving on to another scene. */
+  get over(): boolean {
+    return this.won || this.lost || this.exit !== undefined;
+  }
+
   get(id: string): Entity | undefined {
     return this.entities.find((e) => e.id === id);
   }
@@ -192,17 +226,20 @@ export class World {
     const pressed = new Set([...input].filter((action) => !this.previousInput.has(action)));
     this.previousInput = new Set(input);
     this.frame++;
-    if (this.won) return;
+    if (this.over) return;
 
     this.updatePlatformers(input, pressed);
+    this.updateTopdown(input);
     this.updateScripts(input, pressed);
-    if (this.won) return;
+    if (this.over) return;
     this.updatePatrols();
     this.updateBodies();
     this.updateTouches();
-    if (this.won) return;
+    if (this.over) return;
     this.updateCollectibles();
+    this.updateCheckpoints();
     this.updateHazards();
+    if (this.over) return;
     this.updateGoals();
   }
 
@@ -219,7 +256,7 @@ export class World {
       // A JSON copy, so later frames can't change an earlier snapshot.
       if (Object.keys(e.state).length > 0) entities[e.id]!.state = JSON.parse(JSON.stringify(e.state));
     }
-    return { frame: this.frame, time: this.time, score: this.score, deaths: this.deaths, won: this.won, entities };
+    return { frame: this.frame, time: this.time, score: this.score, deaths: this.deaths, won: this.won, lost: this.lost, lives: this.lives, entities };
   }
 
   private emit(event: EventPayload): void {
@@ -260,8 +297,8 @@ export class World {
         e.script.started = true;
         this.callHook(e, "start");
       }
-      if (!e.removed && !this.won) this.callHook(e, "update");
-      if (this.won) return;
+      if (!e.removed && !this.over) this.callHook(e, "update");
+      if (this.over) return;
     }
   }
 
@@ -286,9 +323,36 @@ export class World {
     const fn = script.module[hook];
     if (!fn) return;
     const ctx: ScriptContext = { self: this.handle(entity), world: this.api(), input: this.scriptInput, params: script.params, dt: FIXED_DT };
+    this.run(entity, hook, () => (fn as (ctx: ScriptContext, other?: ScriptEntity) => void).call(script.module, ctx, other));
+  }
+
+  /**
+   * Runs an entity's `draw` or `drawUI` hook. Called by the renderer, never by the
+   * simulation. `self` and `world` are read-only for the duration.
+   */
+  callDrawHook(entity: Entity, hook: "draw" | "drawUI", extras: Omit<DrawContext, "self" | "world" | "params">): void {
+    const script = entity.script;
+    const fn = script?.module[hook];
+    if (!script || !fn || entity.removed) return;
+    const ctx: DrawContext = { ...extras, self: this.handle(entity), world: this.api(), params: script.params };
+    this.drawing = true;
+    try {
+      this.run(entity, hook, () => fn.call(script.module, ctx));
+    } finally {
+      this.drawing = false;
+    }
+  }
+
+  /** True when any live entity's script has the given hook. */
+  hasHook(hook: "draw" | "drawUI"): boolean {
+    return this.entities.some((e) => !e.removed && typeof e.script?.module[hook] === "function");
+  }
+
+  private run(entity: Entity, hook: string, call: () => void): void {
+    const script = entity.script!;
     this.current = { entity, hook };
     try {
-      (fn as (ctx: ScriptContext, other?: ScriptEntity) => void).call(script.module, ctx, other);
+      call();
     } catch (err) {
       if (err instanceof ScriptError) throw err;
       const message = err instanceof Error ? err.message : String(err);
@@ -298,6 +362,13 @@ export class World {
     }
   }
 
+  /** Draw hooks only paint, so the browser can't drift from what tests verified. */
+  private guard(what: string): void {
+    if (this.drawing) {
+      throw this.misuse(`${what} changes the game, which a draw hook can't do. Change the game in update or touch, and keep visual memory in ctx.local.`);
+    }
+  }
+
   /** An error caused by how a script used the API, reported against the running script. */
   private misuse(message: string): ScriptError {
     const running = this.current;
@@ -320,24 +391,28 @@ export class World {
         return e.transform.x;
       },
       set x(value: number) {
+        world.guard("Setting x");
         e.transform.x = value;
       },
       get y() {
         return e.transform.y;
       },
       set y(value: number) {
+        world.guard("Setting y");
         e.transform.y = value;
       },
       get vx() {
         return e.body?.vx ?? 0;
       },
       set vx(value: number) {
+        world.guard("Setting vx");
         if (e.body) e.body.vx = value;
       },
       get vy() {
         return e.body?.vy ?? 0;
       },
       set vy(value: number) {
+        world.guard("Setting vy");
         if (e.body) e.body.vy = value;
       },
       get grounded() {
@@ -353,7 +428,8 @@ export class World {
         return !e.removed;
       },
       get state() {
-        return e.state;
+        // A frozen copy while drawing, so a draw hook can't write game state by accident.
+        return world.drawing ? Object.freeze({ ...e.state }) : e.state;
       },
       has(component: string) {
         return component === "transform" || (component in e && (e as unknown as Record<string, unknown>)[component] !== undefined);
@@ -391,7 +467,29 @@ export class World {
       get score() {
         return world.score;
       },
+      get deaths() {
+        return world.deaths;
+      },
+      get won() {
+        return world.won;
+      },
+      get lost() {
+        return world.lost;
+      },
+      get exit() {
+        return world.exit;
+      },
+      get lives() {
+        return world.lives;
+      },
+      set lives(value: number | undefined) {
+        world.guard("Setting lives");
+        if (value !== undefined && (typeof value !== "number" || !Number.isFinite(value))) throw world.misuse("world.lives must be a number.");
+        world.lives = value;
+        if (value !== undefined && value <= 0) world.gameOver(world.current?.entity.id ?? "script", "script");
+      },
       set score(value: number) {
+        world.guard("Setting score");
         world.score = value;
       },
       get: (id) => {
@@ -401,27 +499,46 @@ export class World {
       all: (component) =>
         world.entities.filter((e) => !component || world.handle(e).has(component)).map((e) => world.handle(e)),
       player: () => {
-        const e = world.entities.find((candidate) => candidate.platformer);
+        const e = world.entities.find(isPlayer);
         return e ? world.handle(e) : undefined;
       },
-      spawn: (def) => world.spawn(def),
+      spawn: (def) => {
+        world.guard("world.spawn");
+        return world.spawn(def);
+      },
       destroy: (target) => {
+        world.guard("world.destroy");
         const e = world.resolve(target);
         if (e) world.remove(e);
       },
       kill: (target) => {
+        world.guard("world.kill");
         const e = world.resolve(target);
         if (!e) return;
-        if (e.platformer && e.body) world.kill(e, world.current?.entity.id ?? "script");
+        if (isPlayer(e)) world.kill(e, world.current?.entity.id ?? "script");
         else world.remove(e);
       },
       win: () => {
+        world.guard("world.win");
         if (world.won) return;
         const by = world.current?.entity;
         world.won = true;
         world.emit({ type: "win", entity: by?.id ?? "script", goal: by?.id ?? "script", x: by?.transform.x ?? 0, y: by?.transform.y ?? 0 });
       },
+      lose: () => {
+        world.guard("world.lose");
+        world.gameOver(world.current?.entity.id ?? "script", "script");
+      },
+      goto: (scene) => {
+        world.guard("world.goto");
+        if (typeof scene !== "string" || scene === "") throw world.misuse('world.goto needs a scene path, e.g. "scenes/level-1.scene.json".');
+        if (world.exit !== undefined) return;
+        world.exit = scene;
+        const by = world.current?.entity;
+        world.emit({ type: "goto", entity: by?.id ?? "script", scene, x: by?.transform.x ?? 0, y: by?.transform.y ?? 0 });
+      },
       emit: (name, data) => {
+        world.guard("world.emit");
         if (typeof name !== "string" || name === "") throw world.misuse("world.emit needs a non-empty event name.");
         if ((EVENT_TYPES as readonly string[]).includes(name)) {
           throw world.misuse(`"${name}" is a built-in event and can't be emitted by scripts. Pick another name, e.g. "${name}-custom".`);
@@ -429,24 +546,36 @@ export class World {
         const by = world.current?.entity;
         world.emit({ type: "custom", name, entity: by?.id ?? "script", data, x: by?.transform.x ?? 0, y: by?.transform.y ?? 0 });
       },
-      random: () => world.random(),
+      random: () => {
+        world.guard("world.random (it advances the game's seed; use ctx.random in draw hooks)");
+        return world.random();
+      },
     };
     return this.scriptApi;
   }
 
   private spawn(def: SpawnDef): ScriptEntity {
-    if (typeof def !== "object" || def === null || typeof def.components !== "object") {
-      throw this.misuse('world.spawn needs { components: { ... } }, e.g. { components: { transform: { x: 0, y: 0 } } }.');
+    if (typeof def !== "object" || def === null || (def.prefab === undefined && typeof def.components !== "object")) {
+      throw this.misuse('world.spawn needs { components: { ... } } or { prefab: "name" }, e.g. { prefab: "bullet", components: { transform: { x: 0, y: 0 } } }.');
+    }
+    let components = def.components ?? {};
+    if (def.prefab !== undefined) {
+      const prefab = this.prefabs[def.prefab];
+      if (!prefab) {
+        const names = Object.keys(this.prefabs);
+        throw this.misuse(`world.spawn: prefab "${def.prefab}" does not exist.${names.length > 0 ? ` Prefabs: ${names.join(", ")}.` : " Create prefabs/<name>.prefab.json."}`);
+      }
+      components = mergeComponents(prefab.components, components);
     }
     const id = def.id ?? `${this.current?.entity.id ?? "spawned"}-${++this.spawnCount}`;
     if (this.get(id)) throw this.misuse(`world.spawn: an entity with id "${id}" already exists. Leave id out to get a unique one.`);
-    const { diagnostics } = validateScene({ entities: [{ id, components: def.components }] });
+    const { diagnostics } = validateScene({ entities: [{ id, components }] });
     const errors = diagnostics.filter((d) => d.severity === "error" && d.code !== "E_GOAL_UNREACHABLE");
     if (errors.length > 0) {
       const details = errors.map((d) => `${d.path.replace("entities[0]", id)}: ${d.message}${d.fix ? ` Fix: ${d.fix}` : ""}`);
       throw this.misuse(`world.spawn got an invalid entity. ${details.join(" ")}`);
     }
-    const entity = this.createEntity({ id, components: def.components });
+    const entity = this.createEntity({ id, components });
     this.entities.push(entity);
     return this.handle(entity);
   }
@@ -462,14 +591,33 @@ export class World {
 
   // ------------------------------------------------------------ built-ins
 
+  /** Entities the player controls: platformers and topdown movers. */
   private players(): Entity[] {
-    return this.entities.filter((e) => e.platformer && e.body);
+    return this.entities.filter(isPlayer);
+  }
+
+  private updateTopdown(held: ReadonlySet<Action>): void {
+    for (const e of this.entities) {
+      const t = e.topdown;
+      const b = e.body;
+      if (!t || !b) continue;
+      let dx = (held.has("right") ? 1 : 0) - (held.has("left") ? 1 : 0);
+      let dy = (held.has("down") ? 1 : 0) - (held.has("up") ? 1 : 0);
+      if (t.directions === "x") dy = 0;
+      if (t.directions === "y") dx = 0;
+      if (t.directions === "4" && dx !== 0) dy = 0;
+      // Diagonals move at the same speed as straight lines.
+      const length = Math.hypot(dx, dy) || 1;
+      b.vx = (dx / length) * t.speed;
+      b.vy = (dy / length) * t.speed;
+    }
   }
 
   private updatePlatformers(held: ReadonlySet<Action>, pressed: ReadonlySet<Action>): void {
-    for (const e of this.players()) {
-      const p = e.platformer!;
-      const b = e.body!;
+    for (const e of this.entities) {
+      const p = e.platformer;
+      const b = e.body;
+      if (!p || !b) continue;
 
       const direction = (held.has("right") ? 1 : 0) - (held.has("left") ? 1 : 0);
       b.vx = direction * p.speed;
@@ -517,13 +665,18 @@ export class World {
   private updateBodies(): void {
     // Kinematic bodies move first, so anything standing on them can follow.
     const moved = new Map<Entity, { dx: number; dy: number }>();
+    const walls = this.entities.filter((e) => e.body?.type === "static" && !e.body.sensor);
     for (const e of this.entities) {
       const b = e.body;
       if (!b || b.type !== "kinematic") continue;
       const { x, y } = e.transform;
       e.transform.x += b.vx * FIXED_DT;
+      // A player-steered kinematic body (a paddle) stops at walls; scripted movers pass through.
+      if (e.topdown) for (const wall of walls) if (overlaps(e, wall)) e.transform.x = wall.transform.x + (Math.sign(e.transform.x - wall.transform.x) * (wall.body!.width + b.width)) / 2;
       e.transform.y += b.vy * FIXED_DT;
+      if (e.topdown) for (const wall of walls) if (overlaps(e, wall)) e.transform.y = wall.transform.y + (Math.sign(e.transform.y - wall.transform.y) * (wall.body!.height + b.height)) / 2;
       if (e.patrol) clampToPatrol(e, e.patrol);
+      if (e.topdown?.clampToWorld) this.clampToWorld(e);
       moved.set(e, { dx: e.transform.x - x, dy: e.transform.y - y });
     }
 
@@ -539,7 +692,8 @@ export class World {
         e.transform.y += carried.dy;
       }
 
-      b.vy = Math.min(b.vy + this.gravity * b.gravityScale * FIXED_DT, MAX_FALL_SPEED);
+      // Top-down movers ignore gravity; everything else falls.
+      if (!e.topdown) b.vy = Math.min(b.vy + this.gravity * b.gravityScale * FIXED_DT, MAX_FALL_SPEED);
       const wasGrounded = b.grounded;
       b.grounded = false;
       b.standingOn = undefined;
@@ -551,27 +705,47 @@ export class World {
         const half = (solid.body!.width + b.width) / 2;
         if (b.vx > 0) e.transform.x = solid.transform.x - half;
         else if (b.vx < 0) e.transform.x = solid.transform.x + half;
-        b.vx = 0;
+        b.vx = this.rebound(e, solid, b.vx);
       }
 
       e.transform.y += b.vy * FIXED_DT;
       for (const solid of solids) {
         if (!overlaps(e, solid)) continue;
         const half = (solid.body!.height + b.height) / 2;
-        if (b.vy > 0) {
-          e.transform.y = solid.transform.y - half;
+        const falling = b.vy > 0;
+        if (b.vy > 0) e.transform.y = solid.transform.y - half;
+        else if (b.vy < 0) e.transform.y = solid.transform.y + half;
+        b.vy = this.rebound(e, solid, b.vy);
+        // A body that stopped on top of something is standing on it; one that bounced off is airborne.
+        if (falling && b.vy === 0) {
           b.grounded = true;
           b.standingOn = solid;
-        } else if (b.vy < 0) {
-          e.transform.y = solid.transform.y + half;
         }
-        b.vy = 0;
       }
 
+      if (e.topdown?.clampToWorld) this.clampToWorld(e);
       if (b.grounded && !wasGrounded) this.emit({ type: "land", entity: e.id, ...feet(e) });
     }
   }
 
+  /**
+   * The velocity along one axis after hitting `solid`: 0, or reversed and scaled by `bounce`.
+   * Slow impacts stop instead, so resting bodies don't jitter.
+   */
+  private rebound(e: Entity, solid: Entity, velocity: number): number {
+    const bounce = e.body!.bounce;
+    if (bounce <= 0 || Math.abs(velocity) * bounce < MIN_BOUNCE_SPEED) return 0;
+    this.emit({ type: "bounce", entity: e.id, other: solid.id, ...e.transform });
+    return -velocity * bounce;
+  }
+
+  private clampToWorld(e: Entity): void {
+    const halfWidth = (e.body?.width ?? 0) / 2;
+    const halfHeight = (e.body?.height ?? 0) / 2;
+    e.transform.x = Math.min(this.width - halfWidth, Math.max(halfWidth, e.transform.x));
+    e.transform.y = Math.min(this.height - halfHeight, Math.max(halfHeight, e.transform.y));
+  }
+
   private updateCollectibles(): void {
     const players = this.players();
     for (const item of this.entities.filter((e) => e.collectible && e.body)) {
@@ -592,7 +766,7 @@ export class World {
       }
       for (const hazard of this.entities.filter((e) => e.hazard && e.body)) {
         if (!overlaps(player, hazard)) continue;
-        if (hazard.hazard!.stompable && isStomp(player, hazard)) {
+        if (hazard.hazard!.stompable && player.platformer && isStomp(player, hazard)) {
           this.remove(hazard);
           b.vy = -player.platformer!.jumpSpeed * STOMP_BOUNCE;
           this.score += hazard.hazard!.score;
@@ -611,26 +785,55 @@ export class World {
       const player = this.players().find((p) => overlaps(p, goal));
       if (!player) continue;
       this.won = true;
+      if (goal.goal!.next) this.exit = goal.goal!.next;
       this.emit({ type: "win", entity: player.id, goal: goal.id, ...goal.transform });
       return;
     }
   }
 
+  /** A touched checkpoint becomes the player's respawn point, standing on the checkpoint's bottom edge. */
+  private updateCheckpoints(): void {
+    for (const checkpoint of this.entities.filter((e) => e.checkpoint && e.body)) {
+      for (const player of this.players()) {
+        const key = `${player.id}>${checkpoint.id}`;
+        if (this.reached.has(key) || !overlaps(player, checkpoint)) continue;
+        this.reached.add(key);
+        const bottom = checkpoint.transform.y + checkpoint.body!.height / 2;
+        player.spawn = { x: checkpoint.transform.x, y: player.platformer ? bottom - player.body!.height / 2 : checkpoint.transform.y };
+        this.emit({ type: "checkpoint", entity: player.id, checkpoint: checkpoint.id, ...checkpoint.transform });
+      }
+    }
+  }
+
+  private gameOver(entity: string, cause: string): void {
+    if (this.lost) return;
+    this.lost = true;
+    const e = this.get(entity);
+    this.emit({ type: "gameover", entity, cause, x: e?.transform.x ?? 0, y: e?.transform.y ?? 0 });
+  }
+
   /** Sends a player back to where it started. Collected items stay collected. */
   private kill(player: Entity, cause: string): void {
     const b = player.body!;
-    const p = player.platformer!;
     this.deaths++;
     this.emit({ type: "die", entity: player.id, cause, ...player.transform });
-    player.transform.x = p.spawnX;
-    player.transform.y = p.spawnY;
+    if (this.lives !== undefined) {
+      this.lives--;
+      // Out of lives: the player stays where it fell and the game is over.
+      if (this.lives <= 0) return this.gameOver(player.id, cause);
+    }
+    player.transform.x = player.spawn?.x ?? player.transform.x;
+    player.transform.y = player.spawn?.y ?? player.transform.y;
     b.vx = 0;
     b.vy = 0;
     b.grounded = false;
     b.standingOn = undefined;
-    p.coyoteTimer = 0;
-    p.bufferTimer = 0;
-    p.jumping = false;
+    const p = player.platformer;
+    if (p) {
+      p.coyoteTimer = 0;
+      p.bufferTimer = 0;
+      p.jumping = false;
+    }
   }
 }
 
@@ -646,19 +849,24 @@ function createEntity(def: EntityDef): Entity {
       coyoteTimer: 0,
       bufferTimer: 0,
       jumping: false,
-      spawnX: transform.x,
-      spawnY: transform.y,
     };
   }
+  if (c.topdown) entity.topdown = resolveComponent<Topdown>("topdown", c.topdown);
+  if (entity.platformer || entity.topdown) entity.spawn = { x: transform.x, y: transform.y };
   if (c.collectible) entity.collectible = resolveComponent<Collectible>("collectible", c.collectible);
   if (c.patrol) entity.patrol = { ...resolveComponent<Patrol>("patrol", c.patrol), originX: transform.x, originY: transform.y };
   if (c.hazard) entity.hazard = resolveComponent<Hazard>("hazard", c.hazard);
   if (c.goal) entity.goal = resolveComponent<Goal>("goal", c.goal);
+  if (c.checkpoint) entity.checkpoint = {};
   if (c.emitter) entity.emitter = resolveComponent<Emitter>("emitter", c.emitter);
   if (c.camera) entity.camera = resolveComponent<Camera>("camera", c.camera);
   return entity;
 }
 
+function isPlayer(e: Entity): boolean {
+  return !!(e.platformer || e.topdown) && !!e.body;
+}
+
 function feet(e: Entity): { x: number; y: number } {
   return { x: e.transform.x, y: e.transform.y + (e.body?.height ?? 0) / 2 };
 }