@datamoc/mw_games 0.5.4 → 0.7.0

package/dist/mwl/runtime.d.ts

@@ -0,0 +1,169 @@
+import type { MwlCompiledGame } from './compiler.ts';
+import type { AiHook, CommandHook, GeneratorHook, MigrationHook, ModifierHook, PredicateHook } from './hooks.ts';
+import { type MwlPersistenceOptions } from './persistence.ts';
+export interface MwlMapStart {
+    readonly x: number;
+    readonly y: number;
+}
+export interface MwlMap {
+    readonly id: string;
+    readonly width: number;
+    readonly height: number;
+    /** row-major terrain codes, keep markers stripped */
+    readonly codes: readonly string[];
+    /** side number -> keep/start positions */
+    readonly starts: Readonly<Record<number, readonly MwlMapStart[]>>;
+}
+export interface MwlWorld {
+    readonly variables: Record<string, string | number | boolean>;
+    readonly units: Record<string, {
+        hp: number;
+        x: number;
+        y: number;
+        alive: boolean;
+        type?: string;
+        side?: number;
+        moves?: number;
+    }>;
+    readonly sides: Record<string, {
+        gold: number;
+        income: number;
+        leader?: string;
+        controller?: string;
+        recruit?: string;
+    }>;
+    readonly maps: Record<string, {
+        terrain: string;
+        file?: string;
+    }>;
+    gold: Record<string, number>;
+    turn: number;
+    status: 'playing' | 'won' | 'lost';
+    /** the primary map, when the content declares one */
+    map?: MwlMap | null;
+    /** the current schedule entry, by id */
+    timeOfDay?: string;
+    scheduleIndex?: number;
+}
+/** The hook implementations a game provides to the runtime. */
+export interface MwlHookRegistry {
+    readonly predicate?: Readonly<Record<string, PredicateHook>>;
+    readonly modifier?: Readonly<Record<string, ModifierHook>>;
+    readonly generator?: Readonly<Record<string, GeneratorHook>>;
+    readonly command?: Readonly<Record<string, CommandHook>>;
+    readonly ai?: Readonly<Record<string, AiHook>>;
+    readonly migration?: Readonly<Record<string, MigrationHook>>;
+}
+export interface MwlRuntimeOptions {
+    readonly world?: MwlWorld;
+    readonly onMessage?: (text: string) => void;
+    /** resolve a `[map] file=` reference to its text */
+    readonly resolveMap?: (file: string) => string;
+    readonly hooks?: MwlHookRegistry;
+    /** schema version and migrations used by save/restore; defaults to version 1 */
+    readonly persistence?: MwlPersistenceOptions;
+}
+export type MwlCommand = {
+    readonly name: 'set_variable';
+    readonly target: string;
+    readonly value: string | number | boolean;
+} | {
+    readonly name: 'modify_gold';
+    readonly target: string;
+    readonly amount: number;
+} | {
+    readonly name: 'move';
+    readonly target: string;
+    readonly x: number;
+    readonly y: number;
+} | {
+    readonly name: 'spawn';
+    readonly target: string;
+    readonly x: number;
+    readonly y: number;
+    readonly hp: number;
+} | {
+    readonly name: 'kill';
+    readonly target: string;
+} | {
+    readonly name: 'attack';
+    readonly target: string;
+    readonly amount: number;
+} | {
+    readonly name: 'end_turn';
+} | {
+    readonly name: 'win';
+} | {
+    readonly name: 'lose';
+};
+export declare function createWorld(): MwlWorld;
+/**
+ * Parse map text: one row per line, comma-separated codes. A token may be
+ * `<side> <code>` to mark that side's keep/start, which is how a leader knows
+ * where to appear.
+ */
+export declare function parseTerrain(text: string): {
+    width: number;
+    height: number;
+    codes: string[];
+    starts: Record<number, {
+        x: number;
+        y: number;
+    }[]>;
+};
+/**
+ * Runtime for compiled MWL content. It never parses source text during play.
+ *
+ * The framework runtime owns what is game-agnostic: maps, sides, units, turn
+ * order, the schedule, objectives, events, and save/load. Game rules that need
+ * real data (pathfinding costs, combat formulas) stay in the engine adapter;
+ * this runtime's `move` is a bounds and occupancy check, and `attack` applies
+ * the amount the content asks for.
+ */
+export declare class MwlRuntime {
+    readonly game: MwlCompiledGame;
+    readonly world: MwlWorld;
+    private readonly onMessage?;
+    private readonly resolveMap?;
+    private readonly hooks?;
+    private readonly persistence;
+    private readonly unitTypes;
+    private schedule;
+    constructor(game: MwlCompiledGame, options?: MwlRuntimeOptions);
+    run(trigger: string): void;
+    /**
+     * Evaluate `[objectives]` now and return the resulting status. A game whose
+     * own engine resolved the actions (real movement, combat) calls this after
+     * writing the results into `world`; `run` already calls it itself.
+     */
+    evaluate(): MwlWorld['status'];
+    save(): string;
+    snapshot(): string;
+    restore(snapshot: string): void;
+    private loadUnitTypes;
+    private loadSchedule;
+    private loadInitialContent;
+    private buildMap;
+    private loadInitialUnits;
+    private loadLeaders;
+    private unitAt;
+    private executeNode;
+    private runHook;
+    private applyMove;
+    private spawnUnit;
+    private killUnit;
+    private addGold;
+    private endTurn;
+    private advanceSchedule;
+    private resetMoves;
+    private filterMatches;
+    private conditionMatches;
+    private conditionMet;
+    private checkObjectives;
+    private worldView;
+    private emit;
+    private attack;
+    private nodes;
+}
+export declare function execute(world: MwlWorld, command: MwlCommand): void;
+//# sourceMappingURL=runtime.d.ts.map

package/dist/mwl/runtime.d.ts.map

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

package/dist/mwl/runtime.js

@@ -0,0 +1,519 @@
+import { decodeSave, encodeSave } from './persistence.js';
+export function createWorld() {
+    return {
+        variables: {},
+        units: {},
+        sides: {},
+        maps: {},
+        gold: {},
+        turn: 1,
+        status: 'playing',
+        map: null,
+        timeOfDay: '',
+        scheduleIndex: 0,
+    };
+}
+/**
+ * Parse map text: one row per line, comma-separated codes. A token may be
+ * `<side> <code>` to mark that side's keep/start, which is how a leader knows
+ * where to appear.
+ */
+export function parseTerrain(text) {
+    const rows = text
+        .split(/\r?\n/)
+        .filter((line) => line.trim() !== '')
+        .map((line) => line.split(',').map((token) => token.trim()));
+    const height = rows.length;
+    const width = rows.length ? Math.max(...rows.map((row) => row.length)) : 0;
+    const codes = [];
+    const starts = {};
+    for (let y = 0; y < height; y++) {
+        for (let x = 0; x < width; x++) {
+            const token = rows[y]?.[x] ?? '_off^_usr';
+            const keep = /^([0-9]+)\s+(.+)$/.exec(token);
+            if (keep) {
+                codes.push(keep[2]);
+                (starts[Number(keep[1])] ??= []).push({ x, y });
+            }
+            else
+                codes.push(token);
+        }
+    }
+    return { width, height, codes, starts };
+}
+/**
+ * Runtime for compiled MWL content. It never parses source text during play.
+ *
+ * The framework runtime owns what is game-agnostic: maps, sides, units, turn
+ * order, the schedule, objectives, events, and save/load. Game rules that need
+ * real data (pathfinding costs, combat formulas) stay in the engine adapter;
+ * this runtime's `move` is a bounds and occupancy check, and `attack` applies
+ * the amount the content asks for.
+ */
+export class MwlRuntime {
+    constructor(game, options = {}) {
+        this.unitTypes = new Map();
+        this.schedule = [];
+        this.game = game;
+        this.world = options.world ?? createWorld();
+        this.onMessage = options.onMessage;
+        this.resolveMap = options.resolveMap;
+        this.hooks = options.hooks;
+        this.persistence = options.persistence ?? { version: 1 };
+        this.loadUnitTypes();
+        this.loadSchedule();
+        this.loadInitialContent();
+        this.loadInitialUnits();
+        this.loadLeaders();
+    }
+    run(trigger) {
+        for (const event of this.nodes('event')) {
+            if ((event.attributes.on ?? event.attributes.trigger) !== trigger)
+                continue;
+            const condition = event.children.find((child) => child.tag === 'condition');
+            if (condition && this.world.variables[condition.attributes.variable] !== condition.attributes.equals)
+                continue;
+            const filter = event.children.find((child) => child.tag === 'filter');
+            if (filter && !this.filterMatches(filter))
+                continue;
+            for (const command of event.children.filter((child) => child.tag !== 'condition' &&
+                child.tag !== 'filter' &&
+                child.tag !== 'dialogue' &&
+                child.tag !== 'say'))
+                this.executeNode(command);
+        }
+        this.checkObjectives();
+    }
+    /**
+     * Evaluate `[objectives]` now and return the resulting status. A game whose
+     * own engine resolved the actions (real movement, combat) calls this after
+     * writing the results into `world`; `run` already calls it itself.
+     */
+    evaluate() {
+        this.checkObjectives();
+        return this.world.status;
+    }
+    save() {
+        return encodeSave(this.world, this.persistence);
+    }
+    snapshot() {
+        return JSON.stringify(this.world);
+    }
+    restore(snapshot) {
+        const restored = decodeSave(snapshot, this.persistence);
+        Object.assign(this.world.variables, restored.variables);
+        Object.assign(this.world.units, restored.units);
+        Object.assign(this.world.sides, restored.sides ?? {});
+        Object.assign(this.world.maps, restored.maps ?? {});
+        Object.assign(this.world.gold, restored.gold ?? {});
+        this.world.turn = restored.turn;
+        this.world.status = restored.status;
+        this.world.map = restored.map ?? null;
+        this.world.timeOfDay = restored.timeOfDay ?? this.schedule[0] ?? '';
+        this.world.scheduleIndex = restored.scheduleIndex ?? 0;
+    }
+    loadUnitTypes() {
+        for (const node of this.nodes('unit_type')) {
+            const id = node.attributes.id;
+            if (id)
+                this.unitTypes.set(id, {
+                    hitpoints: integer(node, 'hitpoints', 1),
+                    movement: integer(node, 'movement', 0),
+                });
+        }
+    }
+    loadSchedule() {
+        this.schedule = this.nodes('schedule').flatMap((schedule) => schedule.children
+            .filter((child) => child.tag === 'time')
+            .map((child) => child.attributes.id)
+            .filter((id) => Boolean(id)));
+        this.world.scheduleIndex = 0;
+        this.world.timeOfDay = this.schedule[0] ?? '';
+    }
+    loadInitialContent() {
+        for (const side of this.nodes('side')) {
+            const entry = {
+                gold: integer(side, 'gold', 0),
+                income: integer(side, 'income', 0),
+            };
+            if (side.attributes.leader !== undefined)
+                entry.leader = side.attributes.leader;
+            if (side.attributes.controller !== undefined)
+                entry.controller = side.attributes.controller;
+            if (side.attributes.recruit !== undefined)
+                entry.recruit = side.attributes.recruit;
+            this.world.sides[required(side, 'id')] = entry;
+        }
+        for (const map of this.nodes('map')) {
+            const id = map.attributes.id ?? map.attributes.name ?? 'map';
+            this.world.maps[id] = { terrain: map.attributes.terrain ?? '', file: map.attributes.file };
+            if (!this.world.map)
+                this.world.map = this.buildMap(id, map);
+        }
+    }
+    buildMap(id, node) {
+        let text = node.attributes.terrain;
+        if (!text && node.attributes.file && this.resolveMap)
+            text = this.resolveMap(node.attributes.file);
+        if (!text)
+            return null;
+        const parsed = parseTerrain(text);
+        for (const start of node.children) {
+            if (start.tag !== 'start')
+                continue;
+            const side = optionalInteger(start, 'side');
+            const x = optionalInteger(start, 'x');
+            const y = optionalInteger(start, 'y');
+            if (side !== undefined && x !== undefined && y !== undefined)
+                (parsed.starts[side] ??= []).push({ x, y });
+        }
+        return { id, ...parsed };
+    }
+    loadInitialUnits() {
+        for (const unit of this.nodes('unit')) {
+            const id = required(unit, 'id');
+            const entry = {
+                hp: integer(unit, 'hp', 1),
+                x: integer(unit, 'x', 0),
+                y: integer(unit, 'y', 0),
+                alive: true,
+            };
+            if (unit.attributes.type !== undefined) {
+                entry.type = unit.attributes.type;
+                const stats = this.unitTypes.get(unit.attributes.type);
+                if (stats)
+                    entry.moves = stats.movement;
+            }
+            if (unit.attributes.side !== undefined)
+                entry.side = integer(unit, 'side', 0);
+            this.world.units[id] = entry;
+        }
+    }
+    loadLeaders() {
+        for (const side of this.nodes('side')) {
+            const leader = side.attributes.leader;
+            if (!leader)
+                continue;
+            const sideNumber = optionalInteger(side, 'id');
+            if (sideNumber === undefined)
+                continue;
+            const starts = this.world.map?.starts[sideNumber];
+            if (!starts?.length)
+                continue;
+            const stats = this.unitTypes.get(leader);
+            for (const start of starts) {
+                if (this.unitAt(start.x, start.y))
+                    continue;
+                const id = `${leader} ${sideNumber} (${start.x},${start.y})`;
+                this.world.units[id] = {
+                    hp: stats?.hitpoints ?? 1,
+                    x: start.x,
+                    y: start.y,
+                    alive: true,
+                    type: leader,
+                    side: sideNumber,
+                    moves: stats?.movement ?? 0,
+                };
+            }
+        }
+    }
+    unitAt(x, y) {
+        return Object.values(this.world.units).find((unit) => unit.alive && unit.x === x && unit.y === y);
+    }
+    executeNode(node) {
+        const name = node.tag === 'command' ? node.attributes.name : node.tag;
+        if (!name)
+            throw new Error('MWL command is missing name');
+        switch (name) {
+            case 'message':
+                this.onMessage?.(node.attributes.text ?? node.attributes.value ?? '');
+                break;
+            case 'spawn':
+                this.spawnUnit(node.attributes.type ?? '', node.attributes.side === undefined ? undefined : integer(node, 'side', 0), integer(node, 'x', 0), integer(node, 'y', 0), node.attributes.id ?? node.attributes.target, node.attributes.hp === undefined ? undefined : integer(node, 'hp', 1));
+                break;
+            case 'move':
+                this.applyMove(node.attributes.unit ?? required(node, 'target'), integer(node, 'x', 0), integer(node, 'y', 0));
+                break;
+            case 'kill':
+                this.killUnit(node.attributes.unit ?? required(node, 'target'));
+                break;
+            case 'attack':
+                this.attack(node.attributes.defender ?? node.attributes.target ?? required(node, 'target'), integer(node, 'amount', 0));
+                break;
+            case 'modify_gold':
+                this.addGold(node.attributes.side ?? required(node, 'target'), integer(node, 'delta', integer(node, 'amount', 0)));
+                break;
+            case 'gold':
+                this.addGold(required(node, 'side'), integer(node, 'delta', integer(node, 'amount', 0)));
+                break;
+            case 'set_variable':
+                this.world.variables[node.tag === 'command' ? required(node, 'target') : required(node, 'name')] =
+                    node.attributes.value ?? '';
+                break;
+            case 'end_turn':
+                this.endTurn();
+                break;
+            case 'win':
+                this.world.status = 'won';
+                break;
+            case 'lose':
+                this.world.status = 'lost';
+                break;
+            case 'if':
+                if (!this.conditionMatches(node))
+                    break;
+                for (const child of node.children)
+                    this.executeNode(child);
+                break;
+            case 'else':
+                for (const child of node.children)
+                    this.executeNode(child);
+                break;
+            case 'hook':
+                this.runHook(node);
+                break;
+            default:
+                throw new Error(`unknown MWL command: ${name}`);
+        }
+    }
+    runHook(node) {
+        const reference = node.attributes.name ?? '';
+        const hook = this.hooks?.command?.[reference];
+        if (!hook)
+            throw new Error(`MWL hook ${reference} is not implemented`);
+        const { name: _name, ...context } = node.attributes;
+        hook(this.worldView(), this.emit(), context);
+    }
+    applyMove(id, x, y) {
+        const unit = this.world.units[id];
+        if (!unit || !unit.alive)
+            throw new Error(`MWL unit is not alive: ${id}`);
+        const map = this.world.map ?? null;
+        if (map) {
+            if (x < 0 || y < 0 || x >= map.width || y >= map.height)
+                throw new Error(`MWL move out of bounds: ${x},${y}`);
+            const occupant = this.unitAt(x, y);
+            if (occupant && occupant !== unit)
+                throw new Error(`MWL move onto an occupied cell: ${x},${y}`);
+        }
+        if (typeof unit.moves === 'number') {
+            if (unit.moves <= 0)
+                throw new Error(`MWL unit has no moves left: ${id}`);
+            unit.moves -= 1;
+        }
+        unit.x = x;
+        unit.y = y;
+    }
+    spawnUnit(type, side, x, y, id, hp) {
+        const stats = type ? this.unitTypes.get(type) : undefined;
+        const key = id ?? `${type || 'unit'}#${side ?? 0}@${x},${y}`;
+        this.world.units[key] = {
+            hp: hp ?? stats?.hitpoints ?? 1,
+            x,
+            y,
+            alive: true,
+            ...(type ? { type } : {}),
+            ...(side === undefined ? {} : { side }),
+            ...(stats ? { moves: stats.movement } : {}),
+        };
+    }
+    killUnit(id) {
+        const unit = this.world.units[id];
+        if (!unit || !unit.alive)
+            throw new Error(`MWL unit is not alive: ${id}`);
+        unit.alive = false;
+    }
+    addGold(side, delta) {
+        this.world.gold[side] = (this.world.gold[side] ?? 0) + delta;
+    }
+    endTurn() {
+        this.world.turn += 1;
+        this.advanceSchedule();
+        this.resetMoves();
+        this.run('turn');
+    }
+    advanceSchedule() {
+        if (!this.schedule.length)
+            return;
+        const index = ((this.world.scheduleIndex ?? 0) + 1) % this.schedule.length;
+        this.world.scheduleIndex = index;
+        this.world.timeOfDay = this.schedule[index];
+    }
+    resetMoves() {
+        for (const unit of Object.values(this.world.units)) {
+            if (!unit.alive)
+                continue;
+            const stats = unit.type ? this.unitTypes.get(unit.type) : undefined;
+            if (stats)
+                unit.moves = stats.movement;
+        }
+    }
+    filterMatches(node) {
+        const candidates = Object.values(this.world.units).filter((unit) => unit.alive);
+        return candidates.some((unit) => (node.attributes.side === undefined || unit.side === Number(node.attributes.side)) &&
+            (node.attributes.type === undefined || unit.type === node.attributes.type) &&
+            (node.attributes.x === undefined || unit.x === Number(node.attributes.x)) &&
+            (node.attributes.y === undefined || unit.y === Number(node.attributes.y)));
+    }
+    conditionMatches(node) {
+        const condition = node.children.find((child) => child.tag === 'condition');
+        return !condition || this.world.variables[condition.attributes.variable] === condition.attributes.equals;
+    }
+    conditionMet(node) {
+        const condition = node.attributes.condition ?? '';
+        const side = optionalInteger(node, 'side');
+        switch (condition) {
+            case 'units_dead': {
+                const target = optionalInteger(node, 'side_filter') ?? side;
+                if (target === undefined)
+                    return false;
+                return !Object.values(this.world.units).some((unit) => unit.alive && unit.side === target);
+            }
+            case 'turns_elapsed': {
+                const turns = optionalInteger(node, 'turns');
+                return turns !== undefined && this.world.turn >= turns;
+            }
+            case 'gold_at_least': {
+                const gold = optionalInteger(node, 'gold');
+                return (gold !== undefined &&
+                    node.attributes.side !== undefined &&
+                    (this.world.gold[node.attributes.side] ?? 0) >= gold);
+            }
+            case 'unit_at': {
+                const x = optionalInteger(node, 'x');
+                const y = optionalInteger(node, 'y');
+                return Object.values(this.world.units).some((unit) => unit.alive &&
+                    (node.attributes.type === undefined || unit.type === node.attributes.type) &&
+                    unit.x === x &&
+                    unit.y === y);
+            }
+            case 'hook': {
+                const reference = node.attributes.hook ?? '';
+                const hook = this.hooks?.predicate?.[reference];
+                if (!hook)
+                    throw new Error(`MWL hook ${reference} is not implemented`);
+                // The predicate receives the objective's other attributes as its
+                // context, so content can parameterize an engine predicate.
+                const { hook: _hook, condition: _condition, ...context } = node.attributes;
+                return Boolean(hook(this.worldView(), context));
+            }
+            default:
+                return false;
+        }
+    }
+    checkObjectives() {
+        if (this.world.status !== 'playing')
+            return;
+        if (this.nodes('victory').some((node) => this.conditionMet(node))) {
+            this.world.status = 'won';
+            return;
+        }
+        if (this.nodes('defeat').some((node) => this.conditionMet(node)))
+            this.world.status = 'lost';
+    }
+    worldView() {
+        return {
+            variables: this.world.variables,
+            units: this.world.units,
+            sides: this.world.sides,
+            turn: this.world.turn,
+        };
+    }
+    emit() {
+        return {
+            move: (unit, x, y) => this.applyMove(unit, x, y),
+            attack: (_attacker, _defender, _weapon) => {
+                throw new Error('MWL hook attack is not available in the framework runtime; the engine adapter owns combat');
+            },
+            spawn: (type, side, x, y) => this.spawnUnit(type, side, x, y),
+            kill: (unit) => this.killUnit(unit),
+            gold: (side, delta) => this.addGold(String(side), delta),
+            setVariable: (name, value) => {
+                this.world.variables[name] = value;
+            },
+            message: (_speaker, text) => this.onMessage?.(text),
+            endTurn: () => this.endTurn(),
+            win: (_side) => {
+                this.world.status = 'won';
+            },
+            lose: (_side) => {
+                this.world.status = 'lost';
+            },
+        };
+    }
+    attack(target, amount) {
+        const unit = this.world.units[target];
+        if (!unit || !unit.alive)
+            throw new Error(`MWL unit is not alive: ${target}`);
+        unit.hp = Math.max(0, unit.hp - amount);
+        if (unit.hp === 0)
+            unit.alive = false;
+    }
+    nodes(tag) {
+        const result = [];
+        const visit = (node) => {
+            if (node.tag === tag)
+                result.push(node);
+            node.children.forEach(visit);
+        };
+        this.game.roots.forEach(visit);
+        return result;
+    }
+}
+export function execute(world, command) {
+    if (world.status !== 'playing' && command.name !== 'win' && command.name !== 'lose')
+        return;
+    switch (command.name) {
+        case 'set_variable':
+            world.variables[command.target] = command.value;
+            break;
+        case 'modify_gold':
+            world.gold[command.target] = (world.gold[command.target] ?? 0) + command.amount;
+            break;
+        case 'move': {
+            const unit = requireUnit(world, command.target);
+            unit.x = command.x;
+            unit.y = command.y;
+            break;
+        }
+        case 'spawn':
+            world.units[command.target] = { hp: command.hp, x: command.x, y: command.y, alive: true };
+            break;
+        case 'kill':
+            requireUnit(world, command.target).alive = false;
+            break;
+        case 'end_turn':
+            world.turn++;
+            break;
+        case 'win':
+            world.status = 'won';
+            break;
+        case 'lose':
+            world.status = 'lost';
+            break;
+    }
+}
+function requireUnit(world, id) {
+    const unit = world.units[id];
+    if (!unit || !unit.alive)
+        throw new Error(`MWL unit is not alive: ${id}`);
+    return unit;
+}
+function required(node, attribute) {
+    const value = node.attributes[attribute];
+    if (!value)
+        throw new Error(`MWL ${node.tag} is missing ${attribute}`);
+    return value;
+}
+function integer(node, attribute, fallback) {
+    const value = node.attributes[attribute];
+    return value === undefined ? fallback : Number.parseInt(value, 10);
+}
+function optionalInteger(node, attribute) {
+    const value = node.attributes[attribute];
+    if (value === undefined || value === '')
+        return undefined;
+    const parsed = Number.parseInt(value, 10);
+    return Number.isFinite(parsed) ? parsed : undefined;
+}
+//# sourceMappingURL=runtime.js.map