@rpgjs/map-builder 0.0.0-stage → 5.0.0

package/LICENSE

@@ -0,0 +1,19 @@
+Copyright (C) 2026 by Samuel Ronce
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/README.md

@@ -1,3 +1,342 @@
-# Temporary Holding Version
+# `@rpgjs/map-builder`
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+> **Experimental, private.** The API changes until the Studio integration
+> validates it. See [`MAP_BUILDER.md`](../../MAP_BUILDER.md) for the design.
+
+A modifiable map: one model, changed only by patches, usable by a game, an
+editor or both.
+
+| Entry | What it gives | Needs PixiJS |
+| --- | --- | --- |
+| `@rpgjs/map-builder/model` | The model, patches, history, sources. Runs in plain Node, without a DOM. | no |
+| `@rpgjs/map-builder/renderer` | `createMapView`: draws a model with PixiJS, updates it patch by patch. | yes (peer dependency) |
+| `@rpgjs/map-builder/features` | `elements()`, `events()`, `selection()`, `placement()`, `history()`. | yes (through the skins) |
+| `@rpgjs/map-builder/interaction` | The headless layer: state, tools, intents, pipelines, catalog. Runs on a server, to validate with the same rules. | no |
+| `@rpgjs/map-builder/skins` | How the interaction looks: `defaultSkin`, `gameSkin`, and the contract to write your own. | yes |
+| `@rpgjs/map-builder/protocol` | The messages between a client and the authority of a map, validated. | no |
+| `@rpgjs/map-builder/authority` | The authority over a map: decides, tells everybody, catches clients up, persists. Runs on a server. | no |
+| `@rpgjs/map-builder/remote` | The client side: a model that asks the authority and follows everybody's changes. | no |
+| `@rpgjs/map-builder/server` | RPGJS: one authority per map, colliders, events. | no (needs `@rpgjs/server`) |
+| `@rpgjs/map-builder/client` | RPGJS: joins the map, view, prediction colliders. | yes (needs `@rpgjs/client`) |
+
+```ts
+import { createMapModel, defineAssets, defineMap, el } from "@rpgjs/map-builder/model";
+
+const assets = defineAssets({ "tree-oak": { src: "/img/tree-oak.png" } });
+
+// A map written in code. References to assets are checked by the compiler.
+const forest = defineMap(assets, {
+  id: "forest",
+  size: [2560, 1920], // pixels
+  elements: [el("tree-oak", { id: "t1", x: 128, y: 96, data: { hits: 5 } })],
+});
+
+const model = createMapModel(forest);
+
+model.subscribe(({ patches }) => console.log("changed", patches));
+
+model.apply({ type: "element.move", id: "t1", x: 160, y: 96 });
+
+// A batch is atomic and gets a single revision.
+model.apply([
+  { type: "element.remove", id: "t1" },
+  { type: "event.add", event: { id: "wood-1", kind: "loot", x: 160, y: 96 } },
+]);
+
+model.history.undo(); // restores the tree and removes the loot, in one step
+```
+
+## Drawing a map
+
+```ts
+import { createMapView } from "@rpgjs/map-builder/renderer";
+import { elements, events } from "@rpgjs/map-builder/features";
+
+const view = createMapView({
+  model,
+  assets,
+  features: [elements(), events()], // imported objects, so unused ones are tree-shaken
+});
+
+await view.mount(document.getElementById("game")!); // creates a PixiJS application…
+// …or host `view.root` in any PixiJS stage you already have:
+app.stage.addChild(view.root);
+
+model.apply({ type: "element.move", id: "t1", x: 160, y: 96 }); // only t1 is updated
+```
+
+The view follows the model whatever its committer: it listens to the changes
+that were applied, and describes again only the elements a patch touched.
+
+- **Depth.** Elements are drawn back to front by a sort key: the bottom of the
+  hitbox (or of the drawing without one) plus `depth.z`, as the Studio renderer
+  does. `depth.anchorY` replaces the bottom with an explicit offset.
+- **Assets.** `AssetDescriptor` has an optional `frame` (an asset cut out of a
+  tileset), a `size`, and a `hitbox` in source pixels. An asset that declares
+  neither `frame` nor `size` is measured once its image has loaded.
+- **Culling.** `view.setViewport(rect)` hides what is outside the camera, with a
+  margin (64 px by default). `null` shows everything.
+- **Hooks.** `resolveElementSprite` changes how an element is drawn (Studio uses
+  it for its drawing rules), `onBeforeRenderElement` adjusts the result,
+  `onMissingAsset` reports unknown assets.
+- **Effects.** Short visual changes that never touch the model, so they are not
+  saved, undoable nor replayed to late joiners:
+
+  ```ts
+  const handle = view.effects.play("t1", "shake", { intensity: 4 });
+  await handle.finished; // "completed" | "cancelled" | "target-removed" | …
+  ```
+
+  `shake` and `blink` are built in; add yours with `effects: { lift }` or
+  `view.effects.register`. Time only moves on `view.tick(deltaMs)`, which `mount`
+  calls every frame, so effects are deterministic.
+
+## Editing, and playing, on the same map
+
+The same view serves a game and an editor. What changes is the list of features,
+the active modes and the rules.
+
+```ts
+const catalog = defineCatalog([
+  { id: "oak", sprite: "tree-oak", pipeline: [/* rules of this item */] },
+]);
+
+const view = createMapView({
+  model,
+  assets,
+  features: [
+    elements({ pipeline: { move: [snapToGrid(16)] } }), // rules for every move, whoever asks
+    events(),
+    selection({ drag: { live: true }, remove: true }),
+    placement({ catalog, pipeline: [snapToGrid(32), withinMap(), requireFree()] }),
+    history(),
+  ],
+  modes: ["edit"],
+});
+
+view.placement.start("oak");          // a ghost follows the pointer; typed on the catalog ids
+view.selection.current;               // what is selected
+view.history.undo();
+view.submit({ type: "element.move", id: "t1", x: 160, y: 96 }); // an intent, not a patch
+```
+
+Features are imported objects, and each one that has an API exposes it on the view
+under its id: `view.placement`, `view.selection`, `view.history`. The view is typed
+by the list you give: without `placement()`, `view.placement` does not exist.
+
+### Intents, pipelines, rejections
+
+A user action is an **intent**. It goes through a **pipeline** of steps, then
+becomes patches, which the committer applies. A step may modify the intent, refuse it
+or pass it on, in the style of Koa:
+
+```ts
+const rules: PipelineStep<"element.place">[] = [
+  snapToGrid(32),
+  maxCount("tree-oak", 5),
+  (intent, ctx, next) => (ctx.actor.inventory.wood >= 2 ? next() : ctx.reject("not-enough-wood")),
+];
+```
+
+Steps are synchronous and pure, so **the same pipeline runs on the client**, to
+preview with the ghost, **and on a server**, to validate. A refusal is a value:
+`view.submit(...)` returns `{ ok: false, rejection: { code: "occupied", … } }` and
+`interaction.state.get().lastRejection` keeps it, so the UI can say why.
+
+Provided steps: `snapToGrid`, `withinMap`, `requireFree`, `maxCount`, `minDistance`.
+
+### Modes
+
+Tools belong to modes (`play`, `edit`, `inspect`). Several modes can be active at
+once, and a tool can be gated on a modifier key, which is how a player plays while
+Alt turns the same click into editing:
+
+```ts
+view.interaction.addTool(playTool({ types: ["event"], onInteract: (target) => talkTo(target) }));
+view.interaction.setModes(["play", "edit"]);
+```
+
+The interaction layer is **headless**: it publishes `interaction.state` (hovered,
+selection, drag, rubber band, ghost, last rejection) and draws nothing. Skins read
+that state:
+
+```ts
+selection({ skin: { selection: myGlow } });   // replace one part, keep the others
+placement({ catalog, skin: gameSkin({ ghost: { valid: 0x66ff66, invalid: 0xff5555 }, pulse: true }) });
+```
+
+Keyboard (Escape cancels, Delete removes) is opt-in: `view.mount(host, { keyboard: true })`
+or `bindKeyboard(view.interaction, window)`.
+
+### Adding an intent
+
+```ts
+declare module "@rpgjs/map-builder/interaction" {
+  interface IntentRegistry {
+    "tilling.till": { readonly x: number; readonly y: number };
+  }
+}
+```
+
+## Multiplayer
+
+One **authority** holds the truth of a map. Clients **ask** with intents, the authority
+decides with the same pipelines the clients use to preview, and **tells everybody** what
+became true, in the same order. None of this depends on a framework: connect it to
+whatever carries messages. (`@rpgjs/map-builder/server` and `/client` do it for RPGJS.)
+
+```ts
+// server
+const authority = createMapAuthority({
+  definition,
+  assets,                                               // sizes and hitboxes come from here
+  pipeline: { move: [ownerOnly({ actor: (who) => who.id }), protectedZone([square])] },
+  placement: { catalog, pipeline: [snapToGrid(32), requireFree(), rateLimit({ max: 5, windowMs: 1000 })], stamp: (who) => ({ owner: who.id }) },
+  persist: { store, id: "village" },                    // snapshots and a log; restoreMapAuthority brings it back
+});
+const connection = authority.connect({ id, actor: player, send: (message) => socket.send(message) });
+socket.onMessage((raw) => connection.receive(raw));     // anything invalid is ignored
+
+authority.apply({ type: "element.remove", id: "tree-3" });   // the game itself: a lever, a quest
+authority.effect("tree-3", "shake");                          // shown to everybody, never kept
+
+// client
+const remote = await joinRemoteMap({ transport });      // { send(message), onMessage(listener) }
+const view = createMapView({ model: remote.model, assets, features: [elements(), placement({ catalog })] });
+bindRemoteEffects(remote, view.effects);
+```
+
+- **The client never decides.** Its model changes when the authority says so. `submit`
+  and `placement` return a promise that resolves with the decision; a refusal carries the
+  reason (`"occupied"`, `"not-owner"`, `"rate-limit"`…). Patches are only accepted from
+  clients the authority trusts (`trustPatches`), which is what lets an editor undo.
+- **The authority gives the ids.** A client places something without an id and reads the one
+  it was given, so two players can never choose the same.
+- **Late clients catch up.** The authority keeps a log of recent changes: a client that is a
+  little behind gets just those, one that is too far behind gets the map. A hole in the
+  revisions makes a client ask again by itself.
+- **Persistence.** A `MapStore` keeps a snapshot, written every so many revisions or a
+  moment after the last change, and, if it can `append`, every change in between.
+  `restoreMapAuthority` loads the snapshot and replays the log, and refuses a log with a hole.
+- **Rules for a shared world.** `ownerOnly`, `rateLimit` (a preview does not count),
+  `protectedZone`, next to `snapToGrid`, `requireFree`, `maxCount`… The same steps run on
+  the client to preview and on the authority to decide.
+- `connectInMemory(authority)` links a client and an authority with no network: for tests,
+  demos, and single-player games that still want the rules.
+
+## In an RPGJS game
+
+```ts
+// server.ts
+import { createServer } from "@rpgjs/server";
+import { provideMapBuilder, getMapAuthority } from "@rpgjs/map-builder/server";
+
+export default createServer({
+  providers: [
+    provideMapBuilder({
+      assets,                                          // a server has no image to measure: declare `size` or `frame`
+      maps: { forest },                                // by RPGJS map id; a function or a MapSource work too
+      authority: { placement: { catalog, pipeline: [snapToGrid(32), requireFree()] } },
+      persist: (map) => ({ store: roomStorageMapStore(map) }),   // optional
+    }),
+  ],
+});
+
+// anywhere in game code: a lever
+getMapAuthority(player.getCurrentMap())?.apply([{ type: "element.remove", id: "gate" }]);
+
+// client.ts
+import { startGame } from "@rpgjs/client";
+import { provideMapBuilder, getMapBuilder } from "@rpgjs/map-builder/client";
+
+startGame({
+  providers: [
+    provideMapBuilder({
+      assets,
+      features: [elements(), selection(), placement({ catalog })],
+      onJoin: (handle) => onKey("b", () => handle.view.placement.start("oak")),
+    }),
+  ],
+});
+```
+
+- **One authority per map**, created when the map loads and restored from the store if there is
+  one. A player is connected to the map they are on and to no other; what they send is checked
+  against the map it is about.
+- **Colliders**: each element with a hitbox gets a static collider in the physics of the server
+  and of the client (prediction), one namespace per element, so building only touches the
+  collider that changed. They are put back whenever the physics is rebuilt.
+- **Events** of the map become RPGJS dynamic events (`builder:<id>`), drawn with their `graphic`.
+  Give them behaviour with `events: { define: (event) => ({ hooks: { onAction } }) }`. They are
+  recreated when RPGJS wipes them on a map update. The client does not use `events()` for them,
+  since RPGJS already draws events.
+- **Drawing**: pass the view to the event layer of the map, so elements and characters are sorted
+  in depth together: `<EventLayerComponent pixiChildren={getMapBuilder(engine).pixiChildren} />`.
+  `handle.attachTo(container)` adds it anywhere else, without that sorting.
+- Standalone and MMORPG work the same: only `socket.emit`, `player.on` and `map.broadcast` are used.
+
+### In a CanvasEngine scene
+
+The view is a PixiJS container, which is what CanvasEngine renders to. Host it
+the way other raw PixiJS objects are hosted:
+
+```ce
+<Container />
+
+<script>
+  import { mount, tick } from "canvasengine";
+  import { attachMapView } from "@rpgjs/map-builder/renderer";
+
+  mount((element) => attachMapView(element.componentInstance, view));
+  tick(({ deltaTime }) => view.tick(deltaTime));
+</script>
+```
+
+## What is in it
+
+| | |
+| --- | --- |
+| `defineAssets`, `defineMap`, `el`, `event` | Describe a map in code. The result is a plain, serializable `MapDefinition`. |
+| `parseMapDefinition` | Validates, migrates and copies raw JSON. Unknown fields are preserved. |
+| `MapSource`: `codeMapSource`, `jsonMapSource`, `httpMapSource` | Where maps come from. `loadRegion` streams large maps. |
+| `AssetResolver` | Turns `"tree-oak"` into an image descriptor. |
+| `createMapModel` | State, revisions, patches, batches, history, `subscribe`. |
+| Patches | `element.add/remove/move/update/data`, `event.add/remove/move`, `extension.set`. Serializable and invertible. |
+| `localCommitter` | Applies changes immediately, and saves them through `persist`. |
+| `createMapView`, `elements()`, `events()` | Draw the model with PixiJS, incrementally. |
+| `defineMapFeature` | Declares a feature with an id, its dependencies and what it draws. Built-in and third-party features use the same contract. |
+
+## Rejections are values
+
+```ts
+const result = model.apply({ type: "element.move", id: "nope", x: 1, y: 1 });
+if (!result.ok) result.rejection; // { code: "not-found", message, patchIndex: 0 }
+```
+
+## Adding a patch type
+
+A feature extends the registry, so its patches are checked everywhere:
+
+```ts
+declare module "@rpgjs/map-builder/model" {
+  interface PatchRegistry {
+    "tilling.till": { readonly x: number; readonly y: number };
+  }
+}
+
+createMapModel(definition, {
+  patchHandlers: [
+    definePatchHandlers({
+      "tilling.till": { apply: (state, patch) => patchOk(/* new state */ state, /* inverse patches */ []) },
+    }),
+  ],
+});
+```
+
+## Scripts
+
+```bash
+pnpm --filter @rpgjs/map-builder test        # unit tests, in Node
+pnpm --filter @rpgjs/map-builder test:types  # strict type check, including the type tests
+pnpm --filter @rpgjs/map-builder build
+```

package/dist/authority/authority.d.ts

@@ -0,0 +1,118 @@
+import { AssetResolver } from '../model/assets';
+import { MapDefinition } from '../model/definition';
+import { MapChange, MapModel } from '../model/model';
+import { PatchHandlers, MapPatch } from '../model/patches';
+import { ApplyFailure, ApplyResult } from '../model/result';
+import { Catalog } from '../interaction/catalog';
+import { InteractionController } from '../interaction/controller';
+import { MapIntent } from '../interaction/intents';
+import { PipelineStep } from '../interaction/pipeline';
+import { PlacementIntentOptions } from '../interaction/placement';
+import { EffectTargetMessage, ServerMessage } from '../protocol';
+import { MapViewHooks } from '../renderer/scene';
+import { MapStore, PatchEntry } from './store';
+/** A client connected to the authority. The authority does not care how: `send` is all it needs. */
+export interface AuthoritySession {
+    readonly id: string;
+    /** Who is acting: whatever the game decides, handed to the steps of the pipelines. */
+    readonly actor: unknown;
+    send(message: ServerMessage): void;
+}
+export interface AuthorityConnection {
+    readonly session: AuthoritySession;
+    /** Gives the authority what the client sent. Anything that is not a valid message is ignored. */
+    receive(raw: unknown): void;
+    disconnect(): void;
+}
+export interface PersistOptions {
+    readonly store: MapStore;
+    /** Key of the map in the store. */
+    readonly id: string;
+    /** Write a snapshot every this many revisions. Defaults to 50. */
+    readonly snapshotEvery?: number;
+    /** Write a snapshot this long after the last change. Defaults to 1000. */
+    readonly saveDelayMs?: number;
+    /** Replaces `setTimeout`, so tests control time. Returns the function that cancels it. */
+    readonly schedule?: (run: () => void, delayMs: number) => () => void;
+    /**
+     * The store already holds a snapshot of the state the authority starts from, so it does
+     * not write one first. `restoreMapAuthority` sets it. Otherwise the authority writes the
+     * starting snapshot itself, so that the changes it appends have something to follow.
+     */
+    readonly baseSaved?: boolean;
+}
+export interface MapAuthorityOptions<C extends Catalog<string> = Catalog<string>> {
+    readonly definition: MapDefinition;
+    /** Revision the map starts at. Defaults to 0. */
+    readonly revision?: number;
+    /**
+     * What the map is made of. Sizes and hitboxes come from here, so assets must declare
+     * a `size` or a `frame`: a server has no image to measure.
+     */
+    readonly assets: AssetResolver;
+    readonly hooks?: MapViewHooks;
+    /** Rules for every move and removal, whoever asks. The same steps the clients use to preview. */
+    readonly pipeline?: {
+        readonly move?: readonly PipelineStep<"element.move">[];
+        readonly remove?: readonly PipelineStep<"element.remove">[];
+    };
+    /** What can be placed, and the rules for it. */
+    readonly placement?: PlacementIntentOptions<C>;
+    /** Handlers of the patch types features add (`terrainPatchHandlers`): the authority must know them to apply them. */
+    readonly patchHandlers?: readonly PatchHandlers[];
+    /** Registers more intents and pipelines, e.g. those of a custom feature. */
+    readonly setup?: (controller: InteractionController) => void;
+    /**
+     * Whether this actor may send patches as they are (an editor, an undo). Never by default:
+     * a client asks with intents, and the authority decides.
+     */
+    readonly trustPatches?: (actor: unknown) => boolean;
+    /** Who made a change, in the words other players see. */
+    readonly author?: (actor: unknown) => string | undefined;
+    /** Changes kept to catch late clients up without sending the whole map. Defaults to 512. */
+    readonly log?: number;
+    readonly persist?: PersistOptions;
+    /** Called after every change, whoever made it: the place to keep a physics world in step. */
+    readonly onChange?: (change: MapChange) => void;
+    readonly onError?: (error: unknown) => void;
+    /** Changes to replay on top of `definition`, in order: what a store gives back after a restart. */
+    readonly replay?: readonly PatchEntry[];
+}
+export interface MapAuthority {
+    /** The truth. Never change it directly: use `apply`, so everybody hears about it. */
+    readonly model: MapModel<ApplyResult>;
+    readonly revision: number;
+    readonly interaction: InteractionController;
+    /** How many clients are connected. */
+    readonly connections: number;
+    connect(session: AuthoritySession): AuthorityConnection;
+    /**
+     * A change the game itself makes (a lever, a quest). It is trusted: no pipeline. Everybody
+     * connected hears about it.
+     */
+    apply(patches: MapPatch | readonly MapPatch[]): ApplyResult;
+    /** Runs intents through the pipelines on behalf of an actor, e.g. a non-player character. */
+    submit(intents: MapIntent | readonly MapIntent[], actor?: unknown): ApplyResult | ApplyFailure;
+    /** Shows a short effect to everybody connected. It is not kept. */
+    effect(target: EffectTargetMessage, name: string, params?: Readonly<Record<string, unknown>>): void;
+    /** The map as it is now, as a message. */
+    snapshot(): ServerMessage;
+    /** Writes what is pending to the store. */
+    flush(): Promise<void>;
+    /** Flushes, then stops. */
+    destroy(): Promise<void>;
+}
+/**
+ * The authority over one map: it holds the truth, decides what clients may do, tells
+ * everybody what became true, catches late clients up and keeps the map between
+ * restarts. It knows nothing of any framework: connect it to whatever carries messages.
+ */
+export declare function createMapAuthority<C extends Catalog<string> = Catalog<string>>(options: MapAuthorityOptions<C>): MapAuthority;
+/**
+ * Brings a map back from a store, or starts it from `definition` when the store has
+ * nothing yet. Changes written after the last snapshot are replayed.
+ */
+export declare function restoreMapAuthority<C extends Catalog<string> = Catalog<string>>(options: MapAuthorityOptions<C> & {
+    readonly persist: PersistOptions;
+}): Promise<MapAuthority>;
+//# sourceMappingURL=authority.d.ts.map

package/dist/authority/authority.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"authority.d.ts","sourceRoot":"","sources":["../../src/authority/authority.ts"],"names":[],"mappings":"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"}