@netforge/engine 0.0.0-stage → 0.1.0

package/dist/api/cards.js

@@ -0,0 +1,133 @@
+/**
+ * Card battler declarations (game({ template: "cards" })). The template
+ * already runs the duel (heroes, mana, draws, a board of units, spells,
+ * guards, the turn timer), the gauntlet of duels with a draft between
+ * them, the server-side shuffle, hidden hands, the AI opponents and the
+ * referee. A game declares its table rules and its cards.
+ *
+ *   cardTable({ health: 20, duels: 4, starter: ["blot_imp", "blot_imp", ...], ai: [{ health: 14, smart: 0.3 }] });
+ *   card("ink_frog", { model: "style.lowpoly.frog", kind: "unit", cost: 2, attack: 2, health: 3 });
+ *   card("splash", { model: "style.lowpoly.crystal", kind: "spell", cost: 1, effect: { kind: "damage", amount: 2, target: "enemy" } });
+ */
+import { z } from "zod";
+import { contentOf, declareContent } from "./registry.js";
+import { assetIdSchema, GameDefinitionError, idSchema, parseOrThrow } from "./schemas.js";
+export const EFFECT_KINDS = ["damage", "heal", "draw", "buff"];
+/**
+ * Who an effect hits. "enemy": the player picks an enemy unit or the enemy
+ * hero; "enemy_hero"; "all_enemies": every enemy unit; "own_hero";
+ * "own_unit": the player picks one of their units; "all_own": every unit
+ * they have. draw ignores the target.
+ */
+export const EFFECT_TARGETS = ["enemy", "enemy_hero", "all_enemies", "own_hero", "own_unit", "all_own"];
+export const cardEffectSchema = z
+    .object({
+    kind: z.enum(EFFECT_KINDS, { error: `effect kinds are: ${EFFECT_KINDS.join(", ")}` }),
+    /** Damage, healing, cards drawn, or attack and health added (buff). */
+    amount: z.number().int().min(1).max(30),
+    target: z.enum(EFFECT_TARGETS, { error: `effect targets are: ${EFFECT_TARGETS.join(", ")}` }).default("enemy"),
+})
+    .strict();
+/**
+ * A card. A "unit" stands on the board with attack and health; `guard`
+ * units must be attacked first; `rush` units may attack the turn they are
+ * played. A unit's `effect` happens when it is played. A "spell" is only
+ * its effect. cost is mana (0 to 10).
+ */
+export const cardSchema = z
+    .object({
+    model: assetIdSchema,
+    kind: z.enum(["unit", "spell"]),
+    cost: z.number().int().min(0).max(10),
+    attack: z.number().int().min(0).max(30).default(0),
+    health: z.number().int().min(0).max(60).default(0),
+    guard: z.boolean().default(false),
+    rush: z.boolean().default(false),
+    effect: cardEffectSchema.optional(),
+})
+    .strict()
+    .refine((c) => c.kind === "spell" || c.health >= 1, "a unit needs health of at least 1")
+    .refine((c) => c.kind === "unit" || c.effect !== undefined, "a spell needs an effect");
+export const cardTableSchema = z
+    .object({
+    /** Each hero's health at the start of a duel. */
+    health: z.number().int().min(5).max(100).default(20),
+    /** Cards in hand at the start of a duel (the second player draws one more). */
+    startHand: z.number().int().min(1).max(7).default(3),
+    handMax: z.number().int().min(3).max(10).default(7),
+    boardMax: z.number().int().min(1).max(7).default(5),
+    /** Mana rises by one a turn up to this. */
+    manaMax: z.number().int().min(1).max(10).default(10),
+    /** Seconds a turn lasts before it ends by itself. */
+    turnSeconds: z.number().min(10).max(120).default(30),
+    /** Seconds to pick a card between duels (the best card is picked for a player who does not). */
+    draftSeconds: z.number().min(5).max(60).default(15),
+    /** Duels in a run (the gauntlet). A draft follows every duel but the last. */
+    duels: z.number().int().min(1).max(12).default(4),
+    /** Each player's starting deck: declared card ids, 8 to 30 cards. */
+    starter: z.array(idSchema).min(8).max(30),
+    /** Cards the draft offers (default: every declared card). */
+    pool: z.array(idSchema).max(60).optional(),
+    /**
+     * The AI opponents of the gauntlet, in order: duel n against the AI uses
+     * tier n (the last tier repeats). health is the AI hero's health; smart
+     * (0 to 1) how often it plays its best move.
+     */
+    ai: z
+        .array(z.object({ health: z.number().int().min(5).max(100), smart: z.number().min(0).max(1) }).strict())
+        .min(1)
+        .max(12),
+    /** Turns a duel may last before it ends in a draw. */
+    turnCap: z.number().int().min(10).max(200).default(40),
+})
+    .strict();
+/** The table: hero health, hand and board sizes, the gauntlet, the starter deck and the AI tiers (one per game). */
+export function cardTable(def) {
+    const parsed = parseOrThrow(cardTableSchema, def, "cardTable()");
+    declareContent("cardTable", "table", parsed);
+    return parsed;
+}
+/** A card (at most 40). */
+export function card(id, def) {
+    parseOrThrow(idSchema, id, "card id");
+    const parsed = parseOrThrow(cardSchema, def, `card("${id}")`);
+    declareContent("card", id, parsed);
+    return parsed;
+}
+/** Store upgrade stats a card battler reads: hero health, unit attack, starting mana, starting hand. */
+export const CARD_STATS = ["maxHealth", "might", "haste", "amount"];
+/** The card battler content of a manifest, cross-checked (one line per issue). */
+export function cardsContent(m) {
+    const issues = [];
+    const table = contentOf(m, "cardTable")[0]?.[1];
+    const cards = contentOf(m, "card");
+    if (!table)
+        issues.push("declare the table: cardTable({ health, duels, starter: [...], ai: [{ health, smart }] })");
+    if (cards.length < 4)
+        issues.push('declare at least 4 cards: card("ink_frog", { model, kind: "unit", cost, attack, health })');
+    if (cards.length > 40)
+        issues.push("at most 40 cards per game");
+    if (m.weapons.size > 0)
+        issues.push("weapon(...) is for the survivor and arena templates; a card battler declares card(...)");
+    if (m.game.players.max > 2)
+        issues.push("players.max is at most 2: a duel is one against one");
+    for (const [id, u] of m.upgrades)
+        if (!CARD_STATS.includes(u.stat))
+            issues.push(`upgrade("${id}") raises ${u.stat}; a card battler reads ${CARD_STATS.join(", ")} (hero health, unit attack, starting mana, starting hand)`);
+    const ids = new Set(cards.map(([id]) => id));
+    if (table) {
+        for (const id of table.starter)
+            if (!ids.has(id))
+                issues.push(`cardTable starter has "${id}", which is not a declared card`);
+        for (const id of table.pool ?? [])
+            if (!ids.has(id))
+                issues.push(`cardTable pool has "${id}", which is not a declared card`);
+        if (!table.starter.some((id) => cards.find(([c]) => c === id)?.[1].kind === "unit"))
+            issues.push("the starter deck needs at least one unit card");
+        if (!table.starter.some((id) => (cards.find(([c]) => c === id)?.[1].cost ?? 99) <= 2))
+            issues.push("the starter deck needs cards costing 2 or less, or the first turns have nothing to play");
+    }
+    if (issues.length > 0 || !table)
+        throw new GameDefinitionError("card battler", issues);
+    return { table, cards };
+}

package/dist/api/collector.d.ts

@@ -0,0 +1,114 @@
+/**
+ * Monster collector declarations (game({ template: "collector" })). The
+ * template already runs the walkable marsh, encounters in tall grass,
+ * turn-based battles, catching, a team of three, XP and levels, the shared
+ * warden fight, the dusk clock and the referee; a game declares its marsh,
+ * its creatures and their moves.
+ *
+ *   marsh({ size: [28, 18], camp: [2, 9], starters: ["mossling", "cindertail", "puddlewump"],
+ *     warden: { creature: "fenwarden", at: [25, 9], level: 12, hp: 900 },
+ *     grass: [{ at: [6, 3, 5, 4], rate: 0.2, pool: [{ creature: "sporecap", weight: 2, level: [2, 4] }] }] });
+ *   creature("mossling", { model: "style.lowpoly.frog", element: "root", hp: 46, atk: 48, def: 50, spd: 44, moves: ["leaf_lash", "sap_drink"] });
+ *   move("leaf_lash", { element: "root", power: 40 });
+ */
+import { z } from "zod";
+import type { GameManifest } from "./registry.js";
+/**
+ * The four elements, a cycle: each one is strong against the next and weak
+ * against the one before (root soaks tide, tide shorts spark, spark cracks
+ * stone, stone crushes root). Strong hits deal 1.5x, weak ones 0.67x.
+ */
+export declare const ELEMENTS: readonly ["root", "tide", "spark", "stone"];
+export type Element = (typeof ELEMENTS)[number];
+export declare const marshSchema: z.ZodObject<{
+    size: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+    camp: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+    starters: z.ZodArray<z.ZodString>;
+    starterLevel: z.ZodDefault<z.ZodNumber>;
+    blocked: z.ZodDefault<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>>;
+    water: z.ZodDefault<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>>;
+    grass: z.ZodArray<z.ZodObject<{
+        at: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+        rate: z.ZodDefault<z.ZodNumber>;
+        pool: z.ZodArray<z.ZodObject<{
+            creature: z.ZodString;
+            weight: z.ZodDefault<z.ZodNumber>;
+            level: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    warden: z.ZodObject<{
+        creature: z.ZodString;
+        at: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+        level: z.ZodNumber;
+        hp: z.ZodNumber;
+    }, z.core.$strict>;
+    dusk: z.ZodDefault<z.ZodNumber>;
+    snares: z.ZodDefault<z.ZodNumber>;
+    walk: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strict>;
+export declare const MOVE_EFFECTS: readonly ["none", "drain", "heal", "guard"];
+/**
+ * A move. power 0 to 200 (40 is a plain hit), accuracy 0.3 to 1. effect:
+ * "drain" heals the user half the damage dealt, "heal" (power 0 allowed)
+ * heals the user `amount` of its max health, "guard" halves the next hit
+ * it takes.
+ */
+export declare const moveSchema: z.ZodObject<{
+    element: z.ZodEnum<{
+        root: "root";
+        tide: "tide";
+        spark: "spark";
+        stone: "stone";
+    }>;
+    power: z.ZodNumber;
+    accuracy: z.ZodDefault<z.ZodNumber>;
+    effect: z.ZodDefault<z.ZodEnum<{
+        none: "none";
+        heal: "heal";
+        drain: "drain";
+        guard: "guard";
+    }>>;
+    amount: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strict>;
+/**
+ * A creature. Base stats at level 1 (each grows 12% a level): hp, atk,
+ * def, spd (who strikes first). catchRate 0.05 to 1 scales every snare.
+ * boss: the warden kind (never caught, never met in grass).
+ */
+export declare const creatureSchema: z.ZodObject<{
+    model: z.ZodString;
+    element: z.ZodEnum<{
+        root: "root";
+        tide: "tide";
+        spark: "spark";
+        stone: "stone";
+    }>;
+    hp: z.ZodNumber;
+    atk: z.ZodNumber;
+    def: z.ZodNumber;
+    spd: z.ZodNumber;
+    moves: z.ZodArray<z.ZodString>;
+    catchRate: z.ZodDefault<z.ZodNumber>;
+    boss: z.ZodDefault<z.ZodBoolean>;
+    size: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strict>;
+export type MarshInput = z.input<typeof marshSchema>;
+export type MarshDef = z.output<typeof marshSchema>;
+export type MoveInput = z.input<typeof moveSchema>;
+export type MoveDef = z.output<typeof moveSchema>;
+export type CreatureInput = z.input<typeof creatureSchema>;
+export type CreatureDef = z.output<typeof creatureSchema>;
+/** The marsh: its size, camp, starters, grass, blocked tiles and warden (one per game). */
+export declare function marsh(def: MarshInput): MarshDef;
+/** A creature players meet, fight and catch (at most 24). */
+export declare function creature(id: string, def: CreatureInput): CreatureDef;
+/** A move creatures use in battle (at most 48). */
+export declare function move(id: string, def: MoveInput): MoveDef;
+/** Store upgrade stats a collector game reads: team attack, team health, team defence, extra snares, healing between battles. */
+export declare const COLLECTOR_STATS: readonly ["might", "maxHealth", "armor", "amount", "regen"];
+/** The collector content of a manifest, cross-checked (one line per issue). */
+export declare function collectorContent(m: GameManifest): {
+    marsh: MarshDef;
+    creatures: [string, CreatureDef][];
+    moves: [string, MoveDef][];
+};

package/dist/api/collector.js

@@ -0,0 +1,204 @@
+/**
+ * Monster collector declarations (game({ template: "collector" })). The
+ * template already runs the walkable marsh, encounters in tall grass,
+ * turn-based battles, catching, a team of three, XP and levels, the shared
+ * warden fight, the dusk clock and the referee; a game declares its marsh,
+ * its creatures and their moves.
+ *
+ *   marsh({ size: [28, 18], camp: [2, 9], starters: ["mossling", "cindertail", "puddlewump"],
+ *     warden: { creature: "fenwarden", at: [25, 9], level: 12, hp: 900 },
+ *     grass: [{ at: [6, 3, 5, 4], rate: 0.2, pool: [{ creature: "sporecap", weight: 2, level: [2, 4] }] }] });
+ *   creature("mossling", { model: "style.lowpoly.frog", element: "root", hp: 46, atk: 48, def: 50, spd: 44, moves: ["leaf_lash", "sap_drink"] });
+ *   move("leaf_lash", { element: "root", power: 40 });
+ */
+import { z } from "zod";
+import { contentOf, declareContent } from "./registry.js";
+import { assetIdSchema, GameDefinitionError, idSchema, parseOrThrow } from "./schemas.js";
+/**
+ * The four elements, a cycle: each one is strong against the next and weak
+ * against the one before (root soaks tide, tide shorts spark, spark cracks
+ * stone, stone crushes root). Strong hits deal 1.5x, weak ones 0.67x.
+ */
+export const ELEMENTS = ["root", "tide", "spark", "stone"];
+const rect = z.tuple([z.number().int().min(0).max(63), z.number().int().min(0).max(63), z.number().int().min(1).max(64), z.number().int().min(1).max(64)]);
+const cell = z.tuple([z.number().int().min(0).max(63), z.number().int().min(0).max(63)]);
+export const marshSchema = z
+    .object({
+    /** Tiles across and down. Each tile is 2 m. */
+    size: z.tuple([z.number().int().min(10).max(64), z.number().int().min(8).max(64)]),
+    /** The camp tile: everyone starts here, and a team that faints comes back here. Standing on it heals. */
+    camp: cell,
+    /** Creatures a new player picks one of to start (declared creatures, 1 to 4). */
+    starters: z.array(idSchema).min(1).max(4),
+    /** Level the starter begins at. */
+    starterLevel: z.number().int().min(1).max(30).default(3),
+    /** Rocks, water and thickets nobody walks through: [x, y, width, height] in tiles. */
+    blocked: z.array(rect).max(64).default([]),
+    /** Water among the blocked rects is drawn as water: [x, y, width, height]. */
+    water: z.array(rect).max(32).default([]),
+    /** Tall grass: where wild creatures are met. `rate` is the chance a step into a new grass tile starts a battle. */
+    grass: z
+        .array(z
+        .object({
+        at: rect,
+        rate: z.number().min(0.01).max(0.6).default(0.15),
+        pool: z
+            .array(z.object({ creature: idSchema, weight: z.number().min(0.01).max(100).default(1), level: z.tuple([z.number().int().min(1).max(50), z.number().int().min(1).max(50)]) }).strict())
+            .min(1)
+            .max(12),
+    })
+        .strict())
+        .min(1)
+        .max(24),
+    /**
+     * The warden: one creature everyone fights together. Its health is one
+     * pool for the whole marsh (more players, more health). Beating it wins
+     * the run for everyone who hurt it.
+     */
+    warden: z
+        .object({
+        creature: idSchema,
+        at: cell,
+        level: z.number().int().min(1).max(50),
+        /** Health of the shared pool for one player; +50% a player past the first. */
+        hp: z.number().int().min(10).max(1_000_000),
+    })
+        .strict(),
+    /** Seconds until dusk: the run ends then, lost unless the warden fell. */
+    dusk: z.number().min(120).max(3600).default(600),
+    /** Snares each player starts a run with. */
+    snares: z.number().int().min(0).max(50).default(6),
+    /** Walking speed, metres a second. */
+    walk: z.number().min(1).max(12).default(4.5),
+})
+    .strict();
+export const MOVE_EFFECTS = ["none", "drain", "heal", "guard"];
+/**
+ * A move. power 0 to 200 (40 is a plain hit), accuracy 0.3 to 1. effect:
+ * "drain" heals the user half the damage dealt, "heal" (power 0 allowed)
+ * heals the user `amount` of its max health, "guard" halves the next hit
+ * it takes.
+ */
+export const moveSchema = z
+    .object({
+    element: z.enum(ELEMENTS, { error: `elements are: ${ELEMENTS.join(", ")}` }),
+    power: z.number().int().min(0).max(200),
+    accuracy: z.number().min(0.3).max(1).default(1),
+    effect: z.enum(MOVE_EFFECTS).default("none"),
+    /** "heal": share of max health restored. */
+    amount: z.number().min(0).max(1).default(0.3),
+})
+    .strict();
+/**
+ * A creature. Base stats at level 1 (each grows 12% a level): hp, atk,
+ * def, spd (who strikes first). catchRate 0.05 to 1 scales every snare.
+ * boss: the warden kind (never caught, never met in grass).
+ */
+export const creatureSchema = z
+    .object({
+    model: assetIdSchema,
+    element: z.enum(ELEMENTS, { error: `elements are: ${ELEMENTS.join(", ")}` }),
+    hp: z.number().int().min(5).max(999),
+    atk: z.number().int().min(5).max(999),
+    def: z.number().int().min(5).max(999),
+    spd: z.number().int().min(5).max(999),
+    moves: z.array(idSchema).min(1).max(4),
+    catchRate: z.number().min(0.05).max(1).default(0.8),
+    boss: z.boolean().default(false),
+    /** Height of the model, metres. */
+    size: z.number().min(0.3).max(6).default(1),
+})
+    .strict();
+/** The marsh: its size, camp, starters, grass, blocked tiles and warden (one per game). */
+export function marsh(def) {
+    const parsed = parseOrThrow(marshSchema, def, "marsh()");
+    declareContent("marsh", "marsh", parsed);
+    return parsed;
+}
+/** A creature players meet, fight and catch (at most 24). */
+export function creature(id, def) {
+    parseOrThrow(idSchema, id, "creature id");
+    const parsed = parseOrThrow(creatureSchema, def, `creature("${id}")`);
+    declareContent("creature", id, parsed);
+    return parsed;
+}
+/** A move creatures use in battle (at most 48). */
+export function move(id, def) {
+    parseOrThrow(idSchema, id, "move id");
+    const parsed = parseOrThrow(moveSchema, def, `move("${id}")`);
+    declareContent("move", id, parsed);
+    return parsed;
+}
+/** Store upgrade stats a collector game reads: team attack, team health, team defence, extra snares, healing between battles. */
+export const COLLECTOR_STATS = ["might", "maxHealth", "armor", "amount", "regen"];
+/** The collector content of a manifest, cross-checked (one line per issue). */
+export function collectorContent(m) {
+    const issues = [];
+    const mm = contentOf(m, "marsh")[0]?.[1];
+    const creatures = contentOf(m, "creature");
+    const moves = contentOf(m, "move");
+    const cs = new Map(creatures);
+    const ms = new Map(moves);
+    if (!mm)
+        issues.push('declare the marsh: marsh({ size, camp, starters, grass, warden })');
+    if (creatures.length === 0)
+        issues.push('declare at least one creature: creature("mossling", { model, element, hp, atk, def, spd, moves })');
+    if (creatures.length > 24)
+        issues.push("at most 24 creatures per game");
+    if (moves.length > 48)
+        issues.push("at most 48 moves per game");
+    if (m.weapons.size > 0)
+        issues.push("weapon(...) is for the survivor and arena templates; a collector game declares creature(...) and move(...)");
+    for (const [id, u] of m.upgrades)
+        if (!COLLECTOR_STATS.includes(u.stat))
+            issues.push(`upgrade("${id}") raises ${u.stat}; a collector reads ${COLLECTOR_STATS.join(", ")} (team attack, team health, team defence, extra snares, healing between battles)`);
+    for (const [id, c] of creatures)
+        for (const mv of c.moves)
+            if (!ms.has(mv))
+                issues.push(`creature("${id}") knows "${mv}", which is not a declared move`);
+    if (mm) {
+        const [w, h] = mm.size;
+        const inside = (x, y) => x >= 0 && y >= 0 && x < w && y < h;
+        const blocked = (x, y) => mm.blocked.some(([bx, by, bw, bh]) => x >= bx && y >= by && x < bx + bw && y < by + bh);
+        if (!inside(mm.camp[0], mm.camp[1]))
+            issues.push(`marsh camp [${mm.camp[0]}, ${mm.camp[1]}] is off the ${w} x ${h} marsh`);
+        else if (blocked(mm.camp[0], mm.camp[1]))
+            issues.push("marsh camp stands on a blocked tile");
+        if (!inside(mm.warden.at[0], mm.warden.at[1]))
+            issues.push(`marsh warden at [${mm.warden.at[0]}, ${mm.warden.at[1]}] is off the marsh`);
+        else if (blocked(mm.warden.at[0], mm.warden.at[1]))
+            issues.push("the warden stands on a blocked tile");
+        const wc = cs.get(mm.warden.creature);
+        if (!wc)
+            issues.push(`marsh warden "${mm.warden.creature}" is not a declared creature`);
+        else if (!wc.boss)
+            issues.push(`the warden "${mm.warden.creature}" needs boss: true`);
+        for (const s of mm.starters) {
+            const c = cs.get(s);
+            if (!c)
+                issues.push(`marsh starter "${s}" is not a declared creature`);
+            else if (c.boss)
+                issues.push(`marsh starter "${s}" is a boss`);
+        }
+        for (const g of mm.grass) {
+            const [gx, gy, gw, gh] = g.at;
+            if (!inside(gx, gy) || !inside(gx + gw - 1, gy + gh - 1))
+                issues.push(`grass at [${g.at.join(", ")}] runs off the marsh`);
+            for (const p of g.pool) {
+                const c = cs.get(p.creature);
+                if (!c)
+                    issues.push(`grass pool "${p.creature}" is not a declared creature`);
+                else if (c.boss)
+                    issues.push(`grass pool "${p.creature}" is a boss; bosses are never met in grass`);
+                if (p.level[0] > p.level[1])
+                    issues.push(`grass pool "${p.creature}": level [min, max] needs min <= max`);
+            }
+        }
+        for (const [bx, by, bw, bh] of mm.blocked)
+            if (!inside(bx, by) || !inside(bx + bw - 1, by + bh - 1))
+                issues.push(`blocked [${bx}, ${by}, ${bw}, ${bh}] runs off the marsh`);
+    }
+    if (issues.length > 0 || !mm)
+        throw new GameDefinitionError("collector", issues);
+    return { marsh: mm, creatures, moves };
+}

package/dist/api/dungeon.d.ts

@@ -0,0 +1,58 @@
+/**
+ * dungeon(...): a procedural dungeon floor from a seed
+ * ("dungeon layouts can be generated from a seed on both sides").
+ *
+ * Rooms sit on a grid of cells, grown from the start room as a random
+ * tree, with a few extra doors that make loops. Neighbouring rooms are
+ * joined by straight corridors. The result is the `field` a dungeon game
+ * passes to game({ field }) (walls and floors as boxes, the start room at
+ * [0, 0] where players spawn) and the rooms with their depth from the
+ * start, so a system can wake encounters room by room.
+ *
+ * Pure and deterministic: the same spec gives the same dungeon on the room
+ * server, in the client and in the playtest, with nothing downloaded.
+ */
+import { z } from "zod";
+export declare const dungeonSchema: z.ZodObject<{
+    seed: z.ZodNumber;
+    rooms: z.ZodNumber;
+    cell: z.ZodDefault<z.ZodNumber>;
+    size: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+    corridor: z.ZodDefault<z.ZodNumber>;
+    loops: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strict>;
+export type DungeonSpec = z.input<typeof dungeonSchema>;
+/** A box on the ground: [x, z, halfX, halfZ], m. */
+export type Box = [x: number, z: number, hx: number, hz: number];
+export interface DungeonRoom {
+    /** 0 is the start room. */
+    readonly id: number;
+    /** Centre, m. */
+    readonly x: number;
+    readonly z: number;
+    /** Half sizes, m. */
+    readonly hx: number;
+    readonly hz: number;
+    /** Doors from the start room (0 for the start). */
+    readonly depth: number;
+    /** Rooms this one has a corridor to. */
+    readonly links: readonly number[];
+}
+export interface DungeonLayout {
+    /** Pass to game({ field }). */
+    readonly field: {
+        readonly halfSize: number;
+        readonly pillars: [number, number, number][];
+        readonly walls: Box[];
+        readonly floors: Box[];
+    };
+    readonly rooms: readonly DungeonRoom[];
+    /** The start room (id 0, centred on [0, 0]). */
+    readonly start: DungeonRoom;
+    /** The deepest room: where the boss waits. */
+    readonly boss: DungeonRoom;
+    /** The room holding (x, z), or -1 in a corridor. */
+    roomAt(x: number, z: number): number;
+}
+/** Build a dungeon floor from a spec. Throws GameDefinitionError with readable lines on a bad spec. */
+export declare function dungeon(spec: DungeonSpec): DungeonLayout;