@maka/maka-cli 5.382.0 → 5.384.0

package/bundle/typescript/src/commands/game/sideQuest/utilities/barrier-combat.js

@@ -1,6 +1,7 @@
 import { stillWatching } from './surveillance.js';
 import { rollPool, formatRoll } from './dice.js';
 import { applyDeviceOpened } from './devices.js';
+import { FACE_LABEL, allBreached, damageFace, penetrationBoxes, pierces } from './barrier-geometry.js';
 export function resolveBarrierStrike(scene, logger, attacker, device, room, opts = {}) {
     const world = [];
     const meta = [];
@@ -148,4 +149,105 @@ export function resolveCameraStrike(scene, logger, attacker, camera, room, opts
         return result;
     }
 }
+/**
+ * HITTING A BARRIER SPELL (SR5 p.197-198 with p.294 / p.316; user
+ * rulings 2026-10-05). Same unopposed shape as a door, against ONE FACE:
+ *
+ *  - The attack test is unopposed; its hits add to the DV.
+ *  - p.197's text, not p.198's example: a DV that does not EXCEED the
+ *    AP-modified Armor does nothing at all.
+ *  - A gun is a PENETRATION weapon (p.198): the barrier takes 1 box,
+ *    unresisted, and the rest of the shot is spent on the far side.
+ *    It takes a lot of bullets to bring down a wall, which is the point.
+ *  - Anything else resists with Structure + Armor; what gets through
+ *    fills the face's track. Barriers ignore Stun.
+ *  - A face whose track reaches Structure is breached: it stops
+ *    blocking. Every face breached and the spell is over (p.294).
+ *  - A mana barrier's caster knows at once it is under attack (p.316).
+ *
+ * The caller has already chosen the cell (and so the face) and checked
+ * the plane: a Physical Barrier is hit from the meat, a Mana Barrier
+ * only from the astral -- bullets go through a weave as if it were not
+ * there, because to them it is not.
+ */
+export function resolveSpellBarrierStrike(scene, logger, attacker, barrier, face, room, opts = {}) {
+    const world = [];
+    const meta = [];
+    const done = (opened = false, collapsed = false) => ({ world, meta, opened, collapsed });
+    const what = `${barrier.caster}'s ${barrier.kind === 'mana' ? 'mana barrier' : 'barrier'} (${FACE_LABEL[face.id]})`;
+    const weaponItem = attacker.weaponDrawn ? attacker.getCarriedWeapon() : null;
+    const profile = attacker.getWeaponProfile();
+    if (weaponItem?.isFirearm() && (weaponItem.ammo <= 0 || weaponItem.jammed)) {
+        world.push(`${weaponItem.name} is ${weaponItem.jammed ? 'locked up' : 'dry'} -- nothing to put into ${what}.`);
+        return done();
+    }
+    const stun = weaponItem ? weaponItem.isStunWeapon() : !(attacker.hasAug('bone-lacing') || attacker.adept || attacker.hasKillingHands());
+    if (stun && attacker.plane === 'meat') {
+        world.push(`${weaponItem ? weaponItem.name : 'Your fists'} deal${weaponItem ? 's' : ''} Stun, and ${what} has nothing to stun -- barriers ignore it (p.198).`);
+        return done();
+    }
+    const firearm = attacker.plane === 'meat' && !!weaponItem?.isFirearm();
+    if (firearm)
+        weaponItem.fireRound();
+    attacker.sneaking = false;
+    const roll = rollPool(attacker.getAttackPool(), attacker.getAttackLimit(weaponItem));
+    meta.push(`Attack on ${what} (unopposed, p.197): ${formatRoll(roll)}`);
+    if (roll.criticalGlitch) {
+        world.push(`${attacker.name} goes for ${what} -- and it goes catastrophically wrong.`);
+        return noise(done());
+    }
+    const dv = profile.damage + roll.hits;
+    const ap = profile.armorPen ?? 0;
+    const modifiedArmor = Math.max(0, barrier.armor + ap);
+    const how = profile.name === 'bare fists' ? 'with bare fists' : `with ${profile.name}`;
+    meta.push(`  DV ${profile.damage} + ${roll.hits} hit${roll.hits === 1 ? '' : 's'} = ${dv} v. Armor ${barrier.armor}${ap !== 0 ? ` (AP ${ap} -> ${modifiedArmor})` : ''}`);
+    if (!pierces(dv, barrier.armor, ap)) {
+        world.push(`${attacker.name} hits ${what} ${how} -- the shimmer swallows it. Too weak to break through (DV ${dv} against Armor ${modifiedArmor}, p.197).`);
+        return noise(done());
+    }
+    let dealt;
+    if (firearm) {
+        dealt = penetrationBoxes(1);
+        meta.push(`  Penetration weapon (p.198): ${dealt} box to the barrier, unresisted -- the rest of the round is spent beyond it`);
+    }
+    else {
+        const soak = rollPool(barrier.structure + modifiedArmor);
+        dealt = Math.max(0, dv - soak.hits);
+        meta.push(`  Resist: Structure ${barrier.structure} + Armor ${modifiedArmor}: ${formatRoll(soak)} -- ${dealt} box${dealt === 1 ? '' : 'es'} through`);
+    }
+    const breached = damageFace(barrier, face, dealt);
+    logger.write(`${attacker.name} dealt ${dealt} boxes to ${what} (${face.damage}/${barrier.structure}${face.breached ? ', breached' : ''}).`);
+    if (barrier.kind === 'mana') {
+        const caster = scene.getPlayers().find(p => p.name === barrier.caster);
+        if (caster && caster !== attacker)
+            logger.log(`Something is hammering your mana barrier in ${barrier.roomName} -- ${FACE_LABEL[face.id]}, ${face.breached ? 'breached' : `${face.damage}/${barrier.structure}`} (p.316).`, { actor: caster.name });
+    }
+    if (!breached) {
+        world.push(`${attacker.name} hits ${what} ${how} -- ${dealt > 0 ? `${dealt} box${dealt === 1 ? '' : 'es'}` : 'it holds, unmarked'}. (${face.damage}/${barrier.structure})`);
+        return noise(done());
+    }
+    world.push(`${attacker.name} breaks ${what} ${how} -- that face ${barrier.kind === 'mana' ? 'frays to nothing' : 'shatters like heat-haze'}, and the way through it is open.`);
+    if (allBreached(barrier)) {
+        const caster = scene.getPlayers().find(p => p.name === barrier.caster);
+        if (caster) {
+            if (barrier.kind === 'mana')
+                caster.sustainedManaBarrier = undefined;
+            else
+                caster.sustainedBarrier = undefined;
+        }
+        world.push(`  The whole ${barrier.kind === 'mana' ? 'weave' : 'barrier'} collapses -- ${barrier.caster}'s spell is over (p.294).`);
+        scene.addWorldEvent(`${attacker.name} brought down ${barrier.caster}'s ${barrier.kind === 'mana' ? 'mana barrier' : 'force barrier'} in ${room.name}.`);
+        scene.updateStatus();
+        return noise(done(true, true));
+    }
+    scene.updateStatus();
+    return noise(done(true));
+    function noise(result) {
+        if (firearm) {
+            scene.addWorldEvent(`${attacker.name} opened fire on a force barrier in ${room.name} -- the shots carried.`);
+            opts.heat?.(1, 'shot at a force barrier');
+        }
+        return result;
+    }
+}
 //# sourceMappingURL=barrier-combat.js.map

package/bundle/typescript/src/commands/game/sideQuest/utilities/barrier-geometry.js

@@ -0,0 +1,253 @@
+import { METERS_PER_CELL, METERS_PER_LEVEL, key } from './room-grid.js';
+import { Direction } from '../types/shared/direction-enum.js';
+export const FACE_LABEL = {
+    wall: 'the wall', n: 'the north face', s: 'the south face', e: 'the east face', w: 'the west face', top: 'the crown',
+};
+/** "3,4" or "3,4,1" (negative allowed: the plane's edges are open). */
+export function parseCoord(token, defaultZ) {
+    const m = /^(-?\d+),(-?\d+)(?:,(-?\d+))?$/.exec(token.trim());
+    if (!m)
+        return undefined;
+    return { x: parseInt(m[1], 10), y: parseInt(m[2], 10), z: m[3] !== undefined ? parseInt(m[3], 10) : defaultZ };
+}
+export function isCoordToken(token) {
+    return token !== undefined && /^-?\d+,-?\d+(?:,-?\d+)?$/.test(token.trim());
+}
+export const formatCoord = (c) => `${c.x},${c.y},${c.z}`;
+/** Force x 2 metres of wall, in 2 m cells. */
+export function maxWallCells(force) {
+    return Math.max(1, Math.floor((force * 2) / METERS_PER_CELL));
+}
+/** Force metres of wall, in whole 3 m levels -- never less than one. */
+export function maxWallLevels(force) {
+    return Math.max(1, Math.floor(force / METERS_PER_LEVEL));
+}
+/**
+ * A WALL BETWEEN TWO POINTS, ends included. Straight along an axis only:
+ * a diagonal run of cells leaves corner gaps an 8-way walker slips
+ * through, so it would not be a wall.
+ *
+ * Height: the two points' z values give the span (both default to the
+ * caster's level, which is one level of wall -- 3 m, the user's "default
+ * z to 1 unit up").
+ */
+export function planWall(a, b, force) {
+    const fail = (error) => ({ shape: 'wall', faces: [], error });
+    if (a.x !== b.x && a.y !== b.y) {
+        return fail(`A barrier wall runs straight along one axis -- ${a.x},${a.y} to ${b.x},${b.y} is a diagonal. Keep x the same (a north-south wall) or y the same (an east-west one).`);
+    }
+    const length = Math.max(Math.abs(a.x - b.x), Math.abs(a.y - b.y)) + 1;
+    const most = maxWallCells(force);
+    if (length > most) {
+        return fail(`At Force ${force} the wall runs ${force * 2} m -- ${most} cell${most === 1 ? '' : 's'} (SR5 p.294). ${length} cells needs Force ${Math.ceil(length * METERS_PER_CELL / 2)}.`);
+    }
+    const zLo = Math.min(a.z, b.z);
+    const zHi = Math.max(a.z, b.z);
+    const levels = zHi - zLo + 1;
+    const tallest = maxWallLevels(force);
+    if (levels > tallest) {
+        return fail(`At Force ${force} the wall stands ${force} m -- ${tallest} level${tallest === 1 ? '' : 's'} of ${METERS_PER_LEVEL} m (SR5 p.294). ${levels} levels needs Force ${levels * METERS_PER_LEVEL}.`);
+    }
+    const cells = [];
+    const sx = Math.sign(b.x - a.x);
+    const sy = Math.sign(b.y - a.y);
+    for (let z = zLo; z <= zHi; z++) {
+        for (let i = 0; i < length; i++)
+            cells.push({ x: a.x + sx * i, y: a.y + sy * i, z });
+    }
+    return { shape: 'wall', faces: [{ id: 'wall', cells }] };
+}
+const LATERAL = {
+    [Direction.NORTH]: [0, -1], [Direction.SOUTH]: [0, 1],
+    [Direction.EAST]: [1, 0], [Direction.WEST]: [-1, 0],
+};
+/**
+ * "cast barrier east 3": a 1x3 wall square across the way east, three
+ * cells out (user 2026-10-05). No distance puts it in the very next cell.
+ * Three cells is 6 m, which is Force 3's wall; below that it is as long
+ * as the Force allows and the note says so.
+ */
+export function planDirectionalWall(from, direction, distance, force) {
+    const step = LATERAL[direction];
+    if (!step) {
+        return { shape: 'wall', faces: [], error: `A barrier stands across a way, not over or under you -- north, south, east or west. For a roof, raise a dome ("cast barrier" around yourself).` };
+    }
+    if (!Number.isInteger(distance) || distance < 1) {
+        return { shape: 'wall', faces: [], error: `The distance is in cells out from you, 1 or more -- "cast barrier ${direction} 3".` };
+    }
+    const width = Math.min(3, maxWallCells(force));
+    const across = [step[1] === 0 ? 0 : 1, step[0] === 0 ? 0 : 1];
+    const base = { x: from.x + step[0] * distance, y: from.y + step[1] * distance, z: from.z };
+    const offsets = width === 3 ? [-1, 0, 1] : width === 2 ? [0, 1] : [0];
+    const cells = offsets.map(o => ({ x: base.x + across[0] * o, y: base.y + across[1] * o, z: base.z }));
+    const note = width < 3 ? `At Force ${force} the wall runs only ${force * 2} m -- ${width} cell${width === 1 ? '' : 's'}, not three.` : undefined;
+    return { shape: 'wall', faces: [{ id: 'wall', cells }], note };
+}
+/**
+ * A DOME OF RADIUS FORCE METRES around a centre cell (p.294: "a dome
+ * with a radius and height equal to the spell's normal radius" -- the
+ * normal radius of an area spell is Force metres, p.281). Canon dome,
+ * not a sphere (user ruling 2026-10-05).
+ *
+ * Each level k up is a horizontal slice of the hemisphere, radius
+ * sqrt(R^2 - (3k)^2). The SHELL on a level is every cell 8-adjacent to
+ * that slice's interior and not in it -- which is a 4-connected ring, so
+ * the 8-way walk in findPath cannot slip out across a corner. The centre
+ * is always interior: the one the dome is raised around is inside it.
+ *
+ * The highest level of a dome that rises past its first is a filled cap
+ * -- the 'top' face. A one-level dome's roof is its height, which the
+ * engine cannot draw shorter than a storey; it has no crown to shoot.
+ */
+export function planDome(center, force) {
+    const R = force;
+    const levels = [];
+    for (let k = 0; k * METERS_PER_LEVEL < R; k++)
+        levels.push(k);
+    if (levels.length === 0)
+        levels.push(0);
+    const faces = { wall: [], n: [], s: [], e: [], w: [], top: [] };
+    const reach = Math.ceil(R / METERS_PER_CELL) + 1;
+    for (const k of levels) {
+        const rk = Math.sqrt(Math.max(0, R * R - (k * METERS_PER_LEVEL) ** 2));
+        const inside = (dx, dy) => (dx === 0 && dy === 0) || Math.hypot(dx * METERS_PER_CELL, dy * METERS_PER_CELL) < rk;
+        const z = center.z + k;
+        const capped = levels.length > 1 && k === levels[levels.length - 1];
+        for (let dx = -reach; dx <= reach; dx++) {
+            for (let dy = -reach; dy <= reach; dy++) {
+                const c = { x: center.x + dx, y: center.y + dy, z };
+                if (inside(dx, dy)) {
+                    if (capped)
+                        faces.top.push(c);
+                    continue;
+                }
+                let rim = false;
+                for (let ox = -1; ox <= 1 && !rim; ox++) {
+                    for (let oy = -1; oy <= 1 && !rim; oy++) {
+                        if ((ox || oy) && inside(dx + ox, dy + oy))
+                            rim = true;
+                    }
+                }
+                if (!rim)
+                    continue;
+                if (capped) {
+                    faces.top.push(c);
+                    continue;
+                }
+                // North is -y. A corner (|dx| === |dy|) goes to the east/west face.
+                const id = Math.abs(dx) >= Math.abs(dy) ? (dx > 0 ? 'e' : 'w') : (dy < 0 ? 'n' : 's');
+                faces[id].push(c);
+            }
+        }
+    }
+    const order = ['n', 'e', 's', 'w', 'top'];
+    return { shape: 'dome', faces: order.filter(id => faces[id].length > 0).map(id => ({ id, cells: faces[id] })) };
+}
+/**
+ * WHAT THE BARRIER CANNOT STAND IN. Physical: walls, void, furniture and
+ * bodies -- matter is already there. Mana: only earth, a ward's edge, and
+ * another mana barrier -- the astral is unimpeded by everything else
+ * (p.313). The caller supplies the test; this drops the cells and counts
+ * them so the cast can say "the weave stops at the wall".
+ */
+export function clipFaces(faces, open) {
+    let dropped = 0;
+    const kept = faces.map(f => {
+        const cells = f.cells.filter(c => {
+            const ok = open(c);
+            if (!ok)
+                dropped++;
+            return ok;
+        });
+        return { id: f.id, cells };
+    }).filter(f => f.cells.length > 0);
+    return { faces: kept, dropped };
+}
+export function buildBarrier(kind, caster, force, structure, roomName, shape, faces) {
+    return {
+        kind, caster, force, structure, armor: structure, shape, roomName,
+        faces: faces.map(f => ({ id: f.id, cells: f.cells, damage: 0, breached: false })),
+    };
+}
+/** The standing face holding this plane cell, if any. */
+export function faceAt(barrier, c) {
+    const k = key(c);
+    return barrier.faces.find(f => !f.breached && f.cells.some(fc => key(fc) === k));
+}
+export function standingCells(barrier) {
+    return barrier.faces.filter(f => !f.breached).flatMap(f => f.cells);
+}
+/**
+ * One line for the spells list and the HUD: shape, place, rating, and
+ * every face's track -- a face is a testable claim, so it is printed.
+ */
+/** Where it stands, in the rulers' numbers: "3,4,0 to 3,6,0". */
+export function barrierSpan(barrier) {
+    const cells = barrier.faces.flatMap(f => f.cells);
+    if (cells.length === 0)
+        return 'nowhere';
+    const xs = cells.map(c => c.x), ys = cells.map(c => c.y), zs = cells.map(c => c.z);
+    return `${Math.min(...xs)},${Math.min(...ys)},${Math.min(...zs)} to ${Math.max(...xs)},${Math.max(...ys)},${Math.max(...zs)}`;
+}
+export function describeBarrier(barrier) {
+    const span = barrierSpan(barrier);
+    const tracks = barrier.faces
+        .map(f => `${f.id === 'wall' ? 'wall' : f.id.toUpperCase()} ${f.breached ? 'BREACHED' : `${f.damage}/${barrier.structure}`}`)
+        .join(', ');
+    return `a ${barrier.shape} over ${span} in ${barrier.roomName}, Force ${barrier.force}, Armor/Structure ${barrier.structure} [${tracks}]`;
+}
+export function allBreached(barrier) {
+    return barrier.faces.every(f => f.breached);
+}
+// ---------------------------------------------------------------------------
+// THE DAMAGE TRACK (SR5 p.197-198, p.294, p.316; RAG-checked 2026-10-05)
+// ---------------------------------------------------------------------------
+/**
+ * Boxes on one face. Reaching Structure breaches it -- that side of the
+ * dome, or the whole wall, stops blocking. Returns whether this blow
+ * breached it.
+ */
+export function damageFace(barrier, face, boxes) {
+    if (face.breached || boxes <= 0)
+        return false;
+    face.damage += boxes;
+    if (face.damage >= barrier.structure) {
+        face.breached = true;
+        return true;
+    }
+    return false;
+}
+/**
+ * Sustained, it comes back whole: Physical regains all Structure at the
+ * START of each Combat Turn (p.294), Mana at the END (p.316). A breached
+ * face re-forms with it.
+ */
+export function regenerate(barrier) {
+    let changed = false;
+    for (const f of barrier.faces) {
+        if (f.damage > 0 || f.breached)
+            changed = true;
+        f.damage = 0;
+        f.breached = false;
+    }
+    return changed;
+}
+/**
+ * The PENETRATION rule (p.198): a firearm or a pointed blade does the
+ * barrier 1 box, and the rest goes on to whoever is behind it -- 2 boxes
+ * for 3 rounds, 3 for 6, 4 for 10.
+ */
+export function penetrationBoxes(rounds) {
+    return rounds >= 10 ? 4 : rounds >= 6 ? 3 : rounds >= 3 ? 2 : 1;
+}
+/**
+ * Does the blow get through the barrier at all? p.197: "If the weapon's
+ * modified Damage Value does not exceed the barrier's Armor rating
+ * (modified by the weapon's AP) ... the attack automatically fails."
+ * The text, not the p.198 example that lets an equal DV through (user
+ * ruling 2026-10-05).
+ */
+export function pierces(dv, armor, ap) {
+    return dv > Math.max(0, armor + ap);
+}
+//# sourceMappingURL=barrier-geometry.js.map

package/bundle/typescript/src/commands/game/sideQuest/utilities/combat-exchange.js

@@ -1,3 +1,4 @@
+import { allBreached, damageFace, penetrationBoxes, pierces } from './barrier-geometry.js';
 import { recoilCompensation, recoilPenalty } from './recoil.js';
 import { Category } from '../types/shared/item-enum.js';
 import { crashIC } from './ic-actors.js';
@@ -716,7 +717,37 @@ export class CombatExchange {
             world.push(`${header} -- ${defender.name} evades.`);
             return { world: [...world, ...dryWarning], meta };
         }
-        const incoming = strike.damageBase + netHits;
+        let incoming = strike.damageBase + netHits;
+        // SHOOTING THROUGH A BARRIER SPELL (p.197-198): a round fired at
+        // someone behind a standing Physical Barrier meets the barrier first.
+        // A DV that does not EXCEED its AP-modified Armor stops dead (p.197's
+        // text); one that does is a penetration weapon's: the barrier takes
+        // 1 box and the target takes the rest. It is translucent (p.294,
+        // Light Fog), so there is no cover in it -- only the wall to get past.
+        if (strike.weaponItem?.isFirearm()) {
+            const from = this.scene.worldCellOf?.(attacker);
+            const to = this.scene.worldCellOf?.(defender);
+            const wall = from && to ? this.scene.barrierOnLine?.(from, to, 'physical') : undefined;
+            if (wall) {
+                const ap = attacker.getWeaponProfile().armorPen ?? 0;
+                const armor = Math.max(0, wall.barrier.armor + ap);
+                if (!pierces(incoming, wall.barrier.armor, ap)) {
+                    meta.push(`  Barrier: DV ${incoming} against ${wall.barrier.caster}'s barrier, Armor ${armor} -- stopped dead (p.197)`);
+                    world.push(`${header} -- the round flattens against ${wall.barrier.caster}'s shimmer-wall and never reaches ${defender.name}.`);
+                    return { world: [...world, ...dryWarning], meta };
+                }
+                const boxes = penetrationBoxes(1);
+                const fell = damageFace(wall.barrier, wall.face, boxes);
+                incoming -= boxes;
+                meta.push(`  Barrier: through ${wall.barrier.caster}'s barrier (Armor ${armor}) -- it takes ${boxes} box (${wall.face.breached ? 'BREACHED' : `${wall.face.damage}/${wall.barrier.structure}`}), DV ${incoming} goes on (p.198)`);
+                if (fell && allBreached(wall.barrier)) {
+                    const caster = this.scene.getPlayers().find(p => p.name === wall.barrier.caster);
+                    if (caster)
+                        caster.sustainedBarrier = undefined;
+                    world.push(`  ${wall.barrier.caster}'s barrier gives way entirely -- the spell is over (p.294).`);
+                }
+            }
+        }
         // p.168 (RAG-checked 2026-09-03): a Physical hit whose modified DV is
         // LESS THAN the modified Armor rating turns to Stun -- the plate holds
         // and the round still knocks the wind out of you. Strictly less-than.

package/bundle/typescript/src/commands/game/sideQuest/utilities/combat-turn.js

@@ -1,3 +1,4 @@
+import { regenerate } from './barrier-geometry.js';
 import { rollInitiativeScore, formatInitiative, INITIATIVE_PASS_DROP, rollPool, formatRoll } from './dice.js';
 import { ActionBudget } from './action-budget.js';
 import { runNpcActionPhase } from './npc-combat-brain.js';
@@ -772,8 +773,13 @@ export class CombatEncounter {
             await this.end('burnout');
             return;
         }
+        // BARRIER SPELLS COME BACK WHOLE while sustained: a Mana Barrier at
+        // the END of every Combat Turn (p.316), a Physical Barrier at the
+        // START of the next (p.294) -- one boundary, two sides of it.
+        this.regenerateBarriers('mana');
         this.turn += 1;
         this.pass = 1;
+        this.regenerateBarriers('physical');
         // The host launches at the START of the turn (p.247), before the
         // roll, so a fresh program rolls initiative with everyone else.
         await this.onNewTurn?.(this);
@@ -803,6 +809,25 @@ export class CombatEncounter {
         }
         await this.announce([`Combat Turn ${this.turn} -- ${this.orderLine()}.`], metaLines);
     }
+    /** The barriers this fight can see: cast from its room, or held by
+     *  someone in it. A fight across town does not mend this one's wall. */
+    regenerateBarriers(kind) {
+        const here = this.room?.name;
+        const names = new Set(this.participants.map(p => p.actor.name));
+        let mended = false;
+        for (const barrier of this.scene.spellBarriers?.(kind) ?? []) {
+            if (barrier.roomName !== here && !names.has(barrier.caster))
+                continue;
+            if (!regenerate(barrier))
+                continue;
+            mended = true;
+            this.logger.log(`{cyan-fg}${barrier.caster}'s ${kind === 'mana' ? 'mana barrier' : 'barrier'} knits itself whole again -- Structure ${barrier.structure} (${kind === 'mana' ? 'p.316' : 'p.294'}).{/cyan-fg}`, { room: barrier.roomName });
+        }
+        if (mended) {
+            this.scene.updateStatus?.();
+            this.scene.updateExits?.(this.room);
+        }
+    }
     // ------------------------------------------------- score adjustments ----
     /**
      * p.160: wound modifiers hit the Initiative Score the moment the wound

package/bundle/typescript/src/commands/game/sideQuest/utilities/condition-report.js

@@ -113,7 +113,7 @@ function roomGridFor(player) {
     if (!room || player.plane === 'matrix')
         return undefined;
     try {
-        return roomGridWire(room);
+        return roomGridWire(room, player);
     }
     catch {
         return undefined;

package/bundle/typescript/src/commands/game/sideQuest/utilities/earshot.js

@@ -1,4 +1,4 @@
-import { sameSpot, spotOf, spotsActive, isPerchSpot, OPEN_FLOOR, CONVERSATION_M, actorDistanceMeters } from './spots.js';
+import { sameSpot, spotOf, spotsActive, isPerchSpot, OPEN_FLOOR, CONVERSATION_M, actorDistanceMeters, onTheFloor } from './spots.js';
 /**
  * WHO CAN OVERHEAR A MURMUR (playtest, Deditri: "a private place for
  * calls"). A call is audible to the room, and that is correct and
@@ -123,6 +123,28 @@ export function hearingRangeMeters(listener) {
     const bonus = listener.augBonus('hearing') + listener.qualityBonus('perception');
     return Math.max(SPEECH_METERS, SPEECH_METERS + bonus);
 }
+/**
+ * HAS A PLACE IN THE ROOM: a named spot, OR an exact cell on the floor.
+ *
+ * THE SECOND HALF IS THE FIX (xurFSiqNtRNbXA88A: "I'm getting 'Nobody's
+ * close enough to catch that', but I'm right next to Mr. Vellum"). The
+ * runner stepped into Vellum's square; the excuse-me rule (spots.ts
+ * shoulderAside) moved him one cell over and, as it and yieldDoorway both
+ * do on purpose, left him on that EXACT cell with no spot name. This
+ * module read "no spot name" as "circulating", and a circulating listener
+ * is passing through and hears no murmur -- so a Johnson drawn one square
+ * from the runner was deaf to everything said to him for the rest of the
+ * meet. An exact cell is the most precise position the engine has
+ * (seatingIn seats it first), and distance is measured from it.
+ *
+ * A DRIFT SEAT IS STILL NOT A PLACE: a circulating runner's derived seat
+ * is pinned to atCell only so it is drawn in one spot (Player.
+ * pinDerivedSeat), and placedOnCell says no to it -- the Kessler rule
+ * below stands (speech-range.test.ts).
+ */
+function standsSomewhere(actor) {
+    return spotOf(actor) !== undefined || (onTheFloor(actor) && actor.placedOnCell);
+}
 /**
  * CAN THIS LISTENER HEAR ORDINARY SPEECH FROM THERE -- the whole of the
  * `say` rule, in one place so the verb, the NPC fan-out and any future
@@ -176,7 +198,7 @@ export function canHearShout(speaker, listener) {
     const room = speaker.currentLocation;
     if (!spotsActive(room))
         return true;
-    if (spotOf(speaker) === undefined || spotOf(listener) === undefined)
+    if (!standsSomewhere(speaker) || !standsSomewhere(listener))
         return true;
     const reach = SHOUT_METERS + (hearingRangeMeters(listener) - SPEECH_METERS);
     return actorDistanceMeters(room, speaker, listener) <= reach;
@@ -186,10 +208,10 @@ export function canHearSpeech(speaker, listener) {
     if (!spotsActive(room))
         return true;
     // The speaker is unplaced: they are moving among everyone.
-    if (spotOf(speaker) === undefined)
+    if (!standsSomewhere(speaker))
         return true;
     // The listener is unplaced: they are passing through, not standing here.
-    if (spotOf(listener) === undefined)
+    if (!standsSomewhere(listener))
         return false;
     return actorDistanceMeters(room, speaker, listener) <= hearingRangeMeters(listener);
 }

package/bundle/typescript/src/commands/game/sideQuest/utilities/map-glyphs.js

@@ -129,6 +129,17 @@ export const FLOOR_GLYPH = '·';
  *  stack of crates. The room panel draws cover as the same shade one
  *  zoom in (room-view.ts), so the two agree. */
 export const TERRAIN_GLYPH = '▒';
+/**
+ * A BARRIER SPELL'S CELL (barrier-geometry.ts, 2026-10-05). Plain ASCII
+ * on purpose -- one column on every terminal, no ambiguous-width risk --
+ * and coloured by kind: cyan for a Physical Barrier's heat-shimmer,
+ * magenta for a Mana Barrier, because magenta is the astral's colour on
+ * this map (overlay-fill.ts) and a mana barrier is only drawn for eyes
+ * that can see it.
+ */
+export const BARRIER_GLYPH = '#';
+export const BARRIER_COLOR = 'cyan';
+export const MANA_BARRIER_COLOR = 'magenta';
 export const VOID_GLYPH = ' ';
 /**
  * SOMEONE OUT THAT WAY -- a body inside the 100 m band but outside the
@@ -234,6 +245,10 @@ export const GLYPH_RANK = {
      *  only the way up TO the camera, and the camera is what the cell is
      *  about -- and below every body. */
     camera: 72,
+    /** A barrier spell standing in the cell: above a doorway it seals and
+     *  the floor it walls off, below every body (a dome's centre holds
+     *  whoever it was raised around). */
+    barrier: 75,
     vertical: 70,
     exit: 65,
     /**

package/bundle/typescript/src/commands/game/sideQuest/utilities/map-rulers.js

@@ -0,0 +1,58 @@
+/**
+ * AXIS RULERS IN DISTRICT-PLANE COORDINATES (user 2026-10-05: "the map
+ * may need to be adjusted to show x,y numbers on the axes" -- so that
+ * "cast barrier 3 3,4 3,6" can be read straight off the screen).
+ *
+ * ONE COORDINATE SYSTEM EVERYWHERE (user ruling 2026-10-05): the numbers
+ * are plane cells -- a room's origin plus its local cell -- on the room
+ * panel, the full `map`, and the district viewport alike, so a wall
+ * drawn across a doorway reads the same from either side of it.
+ *
+ * Labels live in the MARGINS and are plain ASCII digits: one map dot is
+ * exactly one terminal column (map-view.ts:65-94), so a number written
+ * over the cells would shear the row. Dim, because a ruler is reference,
+ * not news.
+ */
+export const RULER_COLOR = 'gray';
+const dim = (s) => (s.trim().length === 0 ? s : `{${RULER_COLOR}-fg}${s}{/${RULER_COLOR}-fg}`);
+/**
+ * The x ruler over a run of columns. Column i covers plane x from
+ * `start + i*scale` to `start + (i+1)*scale - 1`; a column is labelled
+ * with the multiple of `every * scale` it contains, when the label fits
+ * without running into the previous one.
+ */
+export function xRulerLine(start, columns, scale = 1, every = 5) {
+    const step = every * scale;
+    const out = new Array(columns).fill(' ');
+    let free = 0;
+    for (let i = 0; i < columns; i++) {
+        const lo = start + i * scale;
+        const hi = lo + scale - 1;
+        const mult = Math.ceil(lo / step) * step;
+        if (mult > hi || i < free)
+            continue;
+        const label = String(mult);
+        if (i + label.length > columns)
+            break;
+        for (let j = 0; j < label.length; j++)
+            out[i + j] = label[j];
+        free = i + label.length + 1;
+    }
+    return dim(out.join('').trimEnd());
+}
+/** The y label for a row (plane y of its first cell), right-aligned. */
+export function yRulerLabel(y, width) {
+    return dim(String(y).padStart(width));
+}
+/** How wide the y gutter must be to hold every row label. */
+export function yGutterWidth(start, rows, scale = 1) {
+    let w = 1;
+    for (let i = 0; i < rows; i++)
+        w = Math.max(w, String(start + i * scale).length);
+    return w;
+}
+/** "@ 12,7,0" -- where you are, in the rulers' numbers. */
+export function whereLabel(c) {
+    return c ? dim(`@ ${c.x},${c.y},${c.z}`) : '';
+}
+//# sourceMappingURL=map-rulers.js.map