@datamoc/mw_games 0.7.6 → 0.7.7

package/dist/mwl/runtime.js

@@ -1,7 +1,8 @@
 import { decodeSave, encodeSave } from './persistence.js';
 import { evaluateCondition } from './conditions.js';
 import { evaluateExpression } from './expression.js';
-import { integerAttribute, requiredAttribute } from './utils.js';
+import { booleanAttribute, integerAttribute, numberAttribute, requiredAttribute } from './utils.js';
+import { endLevelCarryover } from './carryover.js';
 const required = requiredAttribute;
 const integer = (node, attribute, fallback) => integerAttribute(node, attribute, fallback) ?? fallback;
 export function createWorld() {
@@ -13,6 +14,7 @@ export function createWorld() {
         gold: {},
         turn: 1,
         status: 'playing',
+        sideStatus: {},
         map: null,
         timeOfDay: '',
         scheduleIndex: 0,
@@ -35,10 +37,11 @@ export function parseTerrain(text) {
     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);
+            //`<side> <code>`: the side is the id `[side]` declares, so a named side works here too
+            const keep = /^([A-Za-z0-9_][\w.-]*)\s+(\S.*)$/.exec(token);
             if (keep) {
                 codes.push(keep[2]);
-                (starts[Number(keep[1])] ??= []).push({ x, y });
+                (starts[keep[1]] ??= []).push({ x, y });
             }
             else
                 codes.push(token);
@@ -73,6 +76,8 @@ export class MwlRuntime {
         this.loadInitialContent();
         this.loadInitialUnits();
         this.loadLeaders();
+        //roles filter over the units, so this runs once they and the leaders are in the world
+        this.loadScenarioExtras();
     }
     run(trigger) {
         for (const event of this.nodes('event')) {
@@ -118,7 +123,7 @@ export class MwlRuntime {
                 continue;
             if (event.attributes.unit !== undefined && event.attributes.unit !== id)
                 continue;
-            if (event.attributes.side !== undefined && integer(event, 'side', Number.NaN) !== unit.side)
+            if (event.attributes.side !== undefined && event.attributes.side !== unit.side)
                 continue;
             if (!this.eventFiltersMatch(event))
                 continue;
@@ -188,12 +193,13 @@ export class MwlRuntime {
         for (const child of node.children) {
             if (child.tag === 'message') {
                 this.showMessage(child.attributes);
-                const side = Number.parseInt(child.attributes.side ?? '', 10);
                 last = {
                     text: child.attributes.text ?? child.attributes.value ?? '',
                     ...(child.attributes.speaker === undefined ? {} : { speaker: child.attributes.speaker }),
                     ...(child.attributes.portrait === undefined ? {} : { portrait: child.attributes.portrait }),
-                    ...(Number.isFinite(side) ? { side } : {}),
+                    ...(child.attributes.side === undefined || child.attributes.side === ''
+                        ? {}
+                        : { side: child.attributes.side }),
                 };
             }
             else if (child.tag === 'say') {
@@ -294,11 +300,19 @@ export class MwlRuntime {
         Object.assign(this.world.gold, restored.gold ?? {});
         this.world.turn = restored.turn;
         this.world.status = restored.status;
+        this.world.sideStatus = { ...(restored.sideStatus ?? {}) };
         this.world.map = restored.map ?? null;
         this.world.timeOfDay = restored.timeOfDay ?? this.schedule[0] ?? '';
         this.world.scheduleIndex = restored.scheduleIndex ?? 0;
         // One-shot events stay spent across a load.
         this.world.firedEvents = [...(restored.firedEvents ?? [])];
+        // Scenario data a command may have changed, restored wholesale rather than merged: a load
+        // is that save's world, not this scenario's with a few fields over it.
+        this.world.villages = restored.villages ? structuredClone(restored.villages) : undefined;
+        this.world.clearedShroud = restored.clearedShroud ? structuredClone(restored.clearedShroud) : undefined;
+        this.world.roles = restored.roles ? structuredClone(restored.roles) : undefined;
+        this.world.objects = restored.objects ? structuredClone(restored.objects) : undefined;
+        this.world.story = restored.story ? structuredClone(restored.story) : undefined;
         this.world.pendingDialogue = restored.pendingDialogue;
         this.pendingDialogue = restored.pendingDialogue
             ? { id: restored.pendingDialogue.id, choices: [...restored.pendingDialogue.choices] }
@@ -337,6 +351,22 @@ export class MwlRuntime {
                 entry.controller = side.attributes.controller;
             if (side.attributes.recruit !== undefined)
                 entry.recruit = side.attributes.recruit;
+            //only what was written, so a world stays as small as the content that made it
+            if (side.attributes.team_name !== undefined)
+                entry.teamName = side.attributes.team_name;
+            if (side.attributes.user_team_name !== undefined)
+                entry.userTeamName = side.attributes.user_team_name;
+            if (side.attributes.share_vision !== undefined)
+                entry.shareVision = side.attributes.share_vision;
+            if (side.attributes.flag !== undefined)
+                entry.flag = side.attributes.flag;
+            if (side.attributes.village_gold !== undefined)
+                entry.villageGold = integer(side, 'village_gold', 0);
+            for (const key of ['heal', 'fog', 'shroud', 'hidden']) {
+                const written = side.attributes[key];
+                if (written !== undefined)
+                    entry[key] = written === 'yes' || written === 'true';
+            }
             this.world.sides[required(side, 'id')] = entry;
         }
         for (const map of this.nodes('map')) {
@@ -346,6 +376,54 @@ export class MwlRuntime {
                 this.world.map = this.buildMap(id, map);
         }
     }
+    /** Direct children of `[game]` with a tag, as opposed to `nodes` which searches the whole tree. */
+    topLevelNodes(tag) {
+        const game = this.game.roots.find((root) => root.tag === 'game');
+        return (game?.children ?? this.game.roots).filter((root) => root.tag === tag);
+    }
+    /**
+     * Scenario-level data that is not a side, a map or a unit: `[object]` placements, the `[story]`
+     * beats, and the `[role]` table. Kept as plain data on the world - the framework sequences and
+     * serialises it, and the game decides what an object does, what a story beat looks like, and
+     * what a role is for.
+     */
+    loadScenarioExtras() {
+        for (const object of this.topLevelNodes('object')) {
+            const x = integer(object, 'x', 0);
+            const y = integer(object, 'y', 0);
+            const entry = { x, y };
+            if (object.attributes.id !== undefined)
+                entry.id = object.attributes.id;
+            if (object.attributes.name !== undefined)
+                entry.name = object.attributes.name;
+            if (object.attributes.image !== undefined)
+                entry.image = object.attributes.image;
+            if (object.attributes.side !== undefined)
+                entry.side = object.attributes.side;
+            (this.world.objects ??= []).push(entry);
+        }
+        for (const story of this.topLevelNodes('story')) {
+            const text = story.attributes.text ?? story.attributes.value;
+            if (text === undefined)
+                continue;
+            const entry = { text };
+            if (story.attributes.title !== undefined)
+                entry.title = story.attributes.title;
+            if (story.attributes.image !== undefined)
+                entry.image = story.attributes.image;
+            if (story.attributes.music !== undefined)
+                entry.music = story.attributes.music;
+            (this.world.story ??= []).push(entry);
+        }
+        for (const role of this.topLevelNodes('role')) {
+            const name = role.attributes.role ?? role.attributes.name;
+            if (name === undefined)
+                continue;
+            (this.world.roles ??= {})[name] = Object.entries(this.world.units)
+                .filter(([id, unit]) => unit.alive && unitMatchesFilter(unit, id, role.attributes))
+                .map(([id]) => id);
+        }
+    }
     buildMap(id, node) {
         let text = node.attributes.terrain;
         if (!text && node.attributes.file && this.resolveMap)
@@ -356,7 +434,7 @@ export class MwlRuntime {
         for (const start of node.children) {
             if (start.tag !== 'start')
                 continue;
-            const side = optionalInteger(start, 'side');
+            const side = start.attributes.side;
             const x = optionalInteger(start, 'x');
             const y = optionalInteger(start, 'y');
             if (side !== undefined && x !== undefined && y !== undefined)
@@ -380,7 +458,7 @@ export class MwlRuntime {
                     entry.moves = stats.movement;
             }
             if (unit.attributes.side !== undefined)
-                entry.side = integer(unit, 'side', 0);
+                entry.side = unit.attributes.side;
             this.world.units[id] = entry;
         }
     }
@@ -389,24 +467,24 @@ export class MwlRuntime {
             const leader = side.attributes.leader;
             if (!leader)
                 continue;
-            const sideNumber = optionalInteger(side, 'id');
-            if (sideNumber === undefined)
+            const sideId = side.attributes.id;
+            if (!sideId)
                 continue;
-            const starts = this.world.map?.starts[sideNumber];
+            const starts = this.world.map?.starts[sideId];
             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})`;
+                const id = `${leader} ${sideId} (${start.x},${start.y})`;
                 this.world.units[id] = {
                     hp: stats?.hitpoints ?? 1,
                     x: start.x,
                     y: start.y,
                     alive: true,
                     type: leader,
-                    side: sideNumber,
+                    side: sideId,
                     moves: stats?.movement ?? 0,
                 };
             }
@@ -425,14 +503,104 @@ export class MwlRuntime {
                 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));
+                this.spawnUnit(node.attributes.type ?? '', node.attributes.side, 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'));
+            case 'kill': {
+                //a named unit that is not there is a content error; a filter that matches nobody is not,
+                //which is what WML's own `[kill]` does. An empty filter matches every unit, there as
+                //here, which is worth knowing before writing one.
+                const named = node.attributes.unit ?? node.attributes.target;
+                if (named === undefined)
+                    killMatching(this.world, node.attributes);
+                else
+                    this.killUnit(named);
                 break;
+            }
+            case 'fire_event': {
+                const id = node.attributes.id ?? node.attributes.name;
+                if (!id)
+                    throw new Error('[fire_event] requires id');
+                this.fireEvent(id);
+                break;
+            }
+            case 'store_unit': {
+                const variable = node.attributes.variable ?? node.attributes.name ?? required(node, 'variable');
+                this.setVariableAt(variable, this.matchingUnits(node).map(([id, unit]) => ({ id, ...unitSnapshot(unit) })));
+                break;
+            }
+            case 'unstore_unit': {
+                const variable = required(node, 'variable');
+                for (const entry of this.storedUnits(variable))
+                    this.restoreUnit(entry, {});
+                break;
+            }
+            case 'recall': {
+                const stored = this.storedUnits(required(node, 'variable'));
+                const wanted = node.attributes.id ?? node.attributes.unit;
+                const entry = wanted === undefined ? stored[0] : stored.find((candidate) => candidate.id === wanted);
+                if (!entry)
+                    throw new Error(`[recall] found no stored unit${wanted === undefined ? '' : ` named ${wanted}`}`);
+                const placement = {};
+                if (node.attributes.x !== undefined)
+                    placement.x = integer(node, 'x', 0);
+                if (node.attributes.y !== undefined)
+                    placement.y = integer(node, 'y', 0);
+                if (node.attributes.side !== undefined)
+                    placement.side = node.attributes.side;
+                this.restoreUnit(entry, placement);
+                break;
+            }
+            case 'modify_unit': {
+                //WML separates which units (`[filter]`) from what changes (`[set]`); a bare
+                //`[modify_unit] hp=5` with no `[set]` changes every unit it matches
+                const changes = node.children.find((child) => child.tag === 'set')?.attributes ?? node.attributes;
+                for (const [, unit] of this.matchingUnits(node))
+                    applyUnitChanges(unit, changes);
+                break;
+            }
+            case 'heal_unit': {
+                const amount = optionalInteger(node, 'amount');
+                const absolute = optionalInteger(node, 'hp');
+                if (amount === undefined && absolute === undefined)
+                    throw new Error('[heal_unit] requires amount or hp');
+                for (const [, unit] of this.matchingUnits(node))
+                    unit.hp = absolute ?? unit.hp + (amount ?? 0);
+                break;
+            }
+            case 'set_terrain':
+                this.setTerrain(integer(node, 'x', 0), integer(node, 'y', 0), required(node, 'terrain'));
+                break;
+            case 'capture_village': {
+                const x = integer(node, 'x', 0);
+                const y = integer(node, 'y', 0);
+                const entry = { x, y, side: required(node, 'side') };
+                if (node.attributes.name !== undefined)
+                    entry.name = node.attributes.name;
+                (this.world.villages ??= {})[`${x},${y}`] = entry;
+                break;
+            }
+            case 'clear_shroud': {
+                const side = required(node, 'side');
+                const x = integer(node, 'x', 0);
+                const y = integer(node, 'y', 0);
+                const radius = integer(node, 'radius', 1);
+                const cleared = new Set(this.world.clearedShroud?.[side] ?? []);
+                for (let dy = -radius; dy <= radius; dy++)
+                    for (let dx = -radius; dx <= radius; dx++)
+                        cleared.add(`${x + dx},${y + dy}`);
+                (this.world.clearedShroud ??= {})[side] = [...cleared];
+                break;
+            }
+            case 'role': {
+                const name = node.attributes.role ?? node.attributes.name;
+                if (!name)
+                    throw new Error('[role] requires role');
+                (this.world.roles ??= {})[name] = this.matchingUnits(node).map(([id]) => id);
+                break;
+            }
             case 'attack':
                 this.attack(node.attributes.defender ?? node.attributes.target ?? required(node, 'target'), integer(node, 'amount', 0));
                 break;
@@ -490,11 +658,25 @@ export class MwlRuntime {
                 this.endTurn();
                 break;
             case 'win':
+                this.markSideResult(node.attributes.side, 'won');
                 this.world.status = 'won';
                 break;
             case 'lose':
+                this.markSideResult(node.attributes.side, 'lost');
                 this.world.status = 'lost';
                 break;
+            case 'endlevel': {
+                const result = node.attributes.result === 'defeat' ? 'defeat' : 'victory';
+                this.world.status = result === 'defeat' ? 'lost' : 'won';
+                this.world.carryover = endLevelCarryover(this.world, endLevelSide(this.world, node.attributes.side), {
+                    result,
+                    bonus: integerAttribute(node, 'bonus'),
+                    carryoverPercentage: numberAttribute(node, 'carryover_percentage'),
+                    carryoverAdd: booleanAttribute(node, 'carryover_add'),
+                    nextScenario: node.attributes.next_scenario ?? null,
+                });
+                break;
+            }
             case 'if':
                 if (!this.nodeConditionMatches(node))
                     break;
@@ -545,12 +727,11 @@ export class MwlRuntime {
     showMessage(attributes) {
         if (!this.onMessage)
             return;
-        const side = Number.parseInt(attributes.side ?? '', 10);
         const message = {
             text: this.interpolate(attributes.text ?? attributes.value ?? ''),
             ...(attributes.speaker === undefined ? {} : { speaker: attributes.speaker }),
             ...(attributes.portrait === undefined ? {} : { portrait: attributes.portrait }),
-            ...(Number.isFinite(side) ? { side } : {}),
+            ...(attributes.side === undefined || attributes.side === '' ? {} : { side: attributes.side }),
         };
         this.onMessage(message);
     }
@@ -625,7 +806,7 @@ export class MwlRuntime {
     }
     spawnUnit(type, side, x, y, id, hp) {
         const stats = type ? this.unitTypes.get(type) : undefined;
-        const key = id ?? `${type || 'unit'}#${side ?? 0}@${x},${y}`;
+        const key = id ?? `${type || 'unit'}#${side ?? ''}@${x},${y}`;
         this.world.units[key] = {
             hp: hp ?? stats?.hitpoints ?? 1,
             x,
@@ -642,6 +823,54 @@ export class MwlRuntime {
             throw new Error(`MWL unit is not alive: ${id}`);
         unit.alive = false;
     }
+    /**
+     * Live units a command's filter selects: its `[filter]` child when it has one, otherwise its
+     * own attributes, read by the same `unitMatchesFilter` an event filter and `[kill]` use. An
+     * empty filter matches every live unit, the rule `[kill]` already documents.
+     */
+    matchingUnits(node) {
+        const filter = node.children.find((child) => child.tag === 'filter');
+        const attributes = filter?.attributes ?? node.attributes;
+        return Object.entries(this.world.units).filter(([id, unit]) => unit.alive && unitMatchesFilter(unit, id, attributes));
+    }
+    /** The unit snapshots `[store_unit]` wrote into a world variable, or a named content error. */
+    storedUnits(variable) {
+        const stored = this.world.variables[variable];
+        if (!Array.isArray(stored))
+            throw new Error(`MWL variable ${variable} is not a stored unit list; store one first`);
+        return stored.filter((entry) => !!entry && typeof entry === 'object' && !Array.isArray(entry));
+    }
+    /** Writes a stored snapshot back into the world, applying any placement overrides. */
+    restoreUnit(entry, placement) {
+        const id = typeof entry.id === 'string' ? entry.id : undefined;
+        if (!id)
+            throw new Error('a stored unit snapshot is missing its id');
+        const unit = {
+            hp: typeof entry.hp === 'number' ? entry.hp : 1,
+            x: placement.x ?? (typeof entry.x === 'number' ? entry.x : 0),
+            y: placement.y ?? (typeof entry.y === 'number' ? entry.y : 0),
+            alive: entry.alive !== false,
+        };
+        if (typeof entry.type === 'string')
+            unit.type = entry.type;
+        const side = placement.side ?? (typeof entry.side === 'string' ? entry.side : undefined);
+        if (side !== undefined)
+            unit.side = side;
+        if (typeof entry.moves === 'number')
+            unit.moves = entry.moves;
+        this.world.units[id] = unit;
+    }
+    /** Changes one cell of the primary map, keeping the parsed grid and its size in step. */
+    setTerrain(x, y, terrain) {
+        const map = this.world.map;
+        if (!map)
+            throw new Error('[set_terrain] needs a loaded map');
+        if (x < 0 || y < 0 || x >= map.width || y >= map.height)
+            throw new Error(`[set_terrain] is outside the map: ${x},${y}`);
+        const codes = [...map.codes];
+        codes[y * map.width + x] = terrain;
+        this.world.map = { ...map, codes };
+    }
     addGold(side, delta) {
         this.world.gold[side] = (this.world.gold[side] ?? 0) + delta;
     }
@@ -650,6 +879,22 @@ export class MwlRuntime {
         this.advanceSchedule();
         this.resetMoves();
         this.run('turn');
+        this.checkTimeOver();
+    }
+    /**
+     * Wesnoth's "time over", as a framework native: once the scenario's `turn_limit` has passed,
+     * `time_over` becomes a variable content can test and an event trigger it can answer. The
+     * framework reports it rather than ending anything, because a turn limit is usually a defeat and
+     * occasionally the whole point of the scenario ("hold out until then"), so what it means is
+     * content's business - `[endlevel]` is right there for it. Fired once, and derived from the turn
+     * counter rather than kept in step with it.
+     */
+    checkTimeOver() {
+        const limit = integerAttribute(this.game.roots[0], 'turn_limit');
+        if (limit === undefined || this.world.turn <= limit || this.world.variables.time_over === 'yes')
+            return;
+        this.world.variables.time_over = 'yes';
+        this.run('time_over');
     }
     advanceSchedule() {
         if (!this.schedule.length)
@@ -721,12 +966,17 @@ export class MwlRuntime {
             return true;
         });
     }
-    conditionMet(node) {
+    /**
+     * Whether one objective's condition holds. `defaultSide` is the side whose own
+     * `[victory]`/`[defeat]` node this is, so a condition that names no side (a side losing
+     * when its own units are gone) reads as that side rather than as nobody.
+     */
+    conditionMet(node, defaultSide) {
         const condition = node.attributes.condition ?? '';
-        const side = optionalInteger(node, 'side');
+        const side = node.attributes.side ?? defaultSide;
         switch (condition) {
             case 'units_dead': {
-                const target = optionalInteger(node, 'side_filter') ?? side;
+                const target = node.attributes.side_filter ?? side;
                 if (target === undefined)
                     return false;
                 return !Object.values(this.world.units).some((unit) => unit.alive && unit.side === target);
@@ -737,14 +987,13 @@ export class MwlRuntime {
             }
             case 'gold_at_least': {
                 const gold = optionalInteger(node, 'gold');
-                return (gold !== undefined &&
-                    node.attributes.side !== undefined &&
-                    (this.world.gold[node.attributes.side] ?? 0) >= gold);
+                const goldSide = node.attributes.side ?? defaultSide;
+                return gold !== undefined && goldSide !== undefined && (this.world.gold[goldSide] ?? 0) >= gold;
             }
             case 'unit_at': {
                 const x = optionalInteger(node, 'x');
                 const y = optionalInteger(node, 'y');
-                const targetSide = optionalInteger(node, 'side_filter') ?? side;
+                const targetSide = node.attributes.side_filter ?? side;
                 return Object.values(this.world.units).some((unit) => unit.alive &&
                     (targetSide === undefined || unit.side === targetSide) &&
                     (node.attributes.type === undefined || unit.type === node.attributes.type) &&
@@ -765,15 +1014,60 @@ export class MwlRuntime {
                 return false;
         }
     }
+    /**
+     * Evaluates the scenario-wide `[objectives]` conditions first, exactly as before, then each
+     * side's own `[victory]`/`[defeat]` children. The scenario ends on the first side whose own
+     * condition fires, recording that side in `world.sideStatus`; a side's victory outranks
+     * another side's defeat when both fire in the same evaluation, which is the same precedence
+     * the scenario-wide pair has always had. A side condition with no `side`/`side_filter` reads
+     * as that side's own, so "this side loses when it has no units left" is written without
+     * repeating the id.
+     */
     checkObjectives() {
         if (this.world.status !== 'playing')
             return;
-        if (this.nodes('victory').some((node) => this.conditionMet(node))) {
+        // a `[victory]`/`[defeat]` under a `[side]` is that side's own, never the scenario's
+        const sideConditions = new Set();
+        const sides = this.nodes('side');
+        for (const side of sides) {
+            for (const child of side.children) {
+                if (child.tag === 'victory' || child.tag === 'defeat')
+                    sideConditions.add(child);
+            }
+        }
+        if (this.nodes('victory').some((node) => !sideConditions.has(node) && this.conditionMet(node))) {
             this.world.status = 'won';
             return;
         }
-        if (this.nodes('defeat').some((node) => this.conditionMet(node)))
+        if (this.nodes('defeat').some((node) => !sideConditions.has(node) && this.conditionMet(node))) {
             this.world.status = 'lost';
+            return;
+        }
+        let sideWon = false;
+        let sideLost = false;
+        for (const side of sides) {
+            const id = side.attributes.id;
+            if (!id || (this.world.sideStatus?.[id] ?? 'playing') !== 'playing')
+                continue;
+            if (side.children.some((child) => child.tag === 'victory' && this.conditionMet(child, id))) {
+                this.markSideResult(id, 'won');
+                sideWon = true;
+            }
+            else if (side.children.some((child) => child.tag === 'defeat' && this.conditionMet(child, id))) {
+                this.markSideResult(id, 'lost');
+                sideLost = true;
+            }
+        }
+        if (sideWon)
+            this.world.status = 'won';
+        else if (sideLost)
+            this.world.status = 'lost';
+    }
+    /** Records one side's own result; the scenario status is set by whichever side fired first. */
+    markSideResult(side, result) {
+        if (side === undefined || side === '')
+            return;
+        (this.world.sideStatus ??= {})[side] = result;
     }
     worldView() {
         return {
@@ -791,16 +1085,18 @@ export class MwlRuntime {
             },
             spawn: (type, side, x, y) => this.spawnUnit(type, side, x, y),
             kill: (unit) => this.killUnit(unit),
-            gold: (side, delta) => this.addGold(String(side), delta),
+            gold: (side, delta) => this.addGold(side, delta),
             setVariable: (name, value) => {
                 this.world.variables[name] = value;
             },
             message: (speaker, text) => this.onMessage?.({ text, ...(speaker ? { speaker } : {}) }),
             endTurn: () => this.endTurn(),
-            win: (_side) => {
+            win: (side) => {
+                this.markSideResult(side, 'won');
                 this.world.status = 'won';
             },
-            lose: (_side) => {
+            lose: (side) => {
+                this.markSideResult(side, 'lost');
                 this.world.status = 'lost';
             },
         };
@@ -844,25 +1140,123 @@ export function execute(world, command) {
             world.units[command.target] = { hp: command.hp, x: command.x, y: command.y, alive: true };
             break;
         case 'kill':
-            requireUnit(world, command.target).alive = false;
+            if (command.target !== undefined)
+                requireUnit(world, command.target).alive = false;
+            else
+                killMatching(world, command.filter ?? {});
             break;
         case 'end_turn':
             world.turn++;
             break;
         case 'win':
+            if (command.side !== undefined && command.side !== '')
+                (world.sideStatus ??= {})[command.side] = 'won';
             world.status = 'won';
             break;
         case 'lose':
+            if (command.side !== undefined && command.side !== '')
+                (world.sideStatus ??= {})[command.side] = 'lost';
             world.status = 'lost';
             break;
+        case 'endlevel':
+            world.status = command.result === 'defeat' ? 'lost' : 'won';
+            world.carryover = endLevelCarryover(world, command.side ?? null, command);
+            break;
     }
 }
+/**
+ * Which side an `[endlevel]` carries: the one it names, or the human-controlled side when it names
+ * none. `null` when there is no such side, which is not an error - a scenario can end with nobody
+ * to carry.
+ */
+function endLevelSide(world, named) {
+    const id = named ?? Object.entries(world.sides).find(([, side]) => side.controller === 'human')?.[0];
+    if (!id || !(id in world.sides))
+        return null;
+    return { id };
+}
+/**
+ * The sides a scenario's content says see together, as groups ready for `FactionFog.share`.
+ *
+ * Wesnoth groups sides into teams with `[side] team_name`, and `share_vision` says whether a side
+ * shares what it sees with its team. `none` does not; `all` and `shroud` are treated alike here
+ * because `FactionFog` shares sight and memory as one thing rather than keeping them apart, and a
+ * fog that separated them would be the place to tell the two apart. A side with no `team_name`
+ * shares with nobody, and a team of one is not returned, since sharing with nobody is what it
+ * already does.
+ *
+ * @example
+ * ```ts
+ * import { sideVisionGroups, type MwlWorld } from '@datamoc/mw_games/mwl';
+ *
+ * declare const world: MwlWorld;
+ *
+ * // sides 1 and 2 both wrote team_name=north, and side 3 asked for share_vision=none
+ * console.log(sideVisionGroups(world)); // [['1', '2']]
+ * ```
+ */
+export function sideVisionGroups(world) {
+    const teams = new Map();
+    for (const [id, side] of Object.entries(world.sides)) {
+        if (!side.teamName || side.shareVision === 'none')
+            continue;
+        const group = teams.get(side.teamName);
+        if (group)
+            group.push(id);
+        else
+            teams.set(side.teamName, [id]);
+    }
+    return [...teams.values()].filter((group) => group.length > 1);
+}
 function requireUnit(world, id) {
     const unit = world.units[id];
     if (!unit || !unit.alive)
         throw new Error(`MWL unit is not alive: ${id}`);
     return unit;
 }
+/** Kills every alive unit a `[kill]` filter matches, and says how many it killed. */
+function killMatching(world, attributes) {
+    let killed = 0;
+    for (const [id, unit] of Object.entries(world.units)) {
+        if (!unit.alive || !unitMatchesFilter(unit, id, attributes))
+            continue;
+        unit.alive = false;
+        killed++;
+    }
+    return killed;
+}
+/** One unit as `[store_unit]` writes it: only the fields it has, so a variable stays small. */
+function unitSnapshot(unit) {
+    const snapshot = { hp: unit.hp, x: unit.x, y: unit.y, alive: unit.alive };
+    if (unit.type !== undefined)
+        snapshot.type = unit.type;
+    if (unit.side !== undefined)
+        snapshot.side = unit.side;
+    if (unit.moves !== undefined)
+        snapshot.moves = unit.moves;
+    return snapshot;
+}
+/** Applies `[modify_unit]`'s chosen attributes to one unit, ignoring anything it did not name. */
+function applyUnitChanges(unit, changes) {
+    const hp = finiteNumber(changes.hp);
+    if (hp !== undefined)
+        unit.hp = hp;
+    const moves = finiteNumber(changes.moves);
+    if (moves !== undefined)
+        unit.moves = moves;
+    if (changes.type !== undefined)
+        unit.type = changes.type;
+    if (changes.side !== undefined)
+        unit.side = changes.side;
+    if (changes.alive !== undefined)
+        unit.alive = changes.alive === 'yes' || changes.alive === 'true';
+}
+function finiteNumber(value) {
+    if (value === undefined || value === '')
+        return undefined;
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : undefined;
+}
 function optionalInteger(node, attribute) {
     const value = node.attributes[attribute];
     if (value === undefined || value === '')
@@ -922,7 +1316,7 @@ function unitMatchesFilter(unit, id, attributes) {
         .filter(Boolean);
     const key = attributes.unit ?? attributes.id;
     return ((key === undefined || id === key) &&
-        (attributes.side === undefined || unit.side === Number(attributes.side)) &&
+        (attributes.side === undefined || unit.side === attributes.side) &&
         (attributes.type === undefined || unit.type === attributes.type) &&
         (excluded.length === 0 || !excluded.includes(unit.type ?? '')) &&
         (attributes.x === undefined || unit.x === Number(attributes.x)) &&