@maka/maka-cli 5.383.0 → 5.385.0

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

@@ -0,0 +1,277 @@
+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));
+}
+/**
+ * THE LEAST FORCE THAT RAISES THIS WALL -- what a cast with no Force
+ * named is sized to (user 2026-10-05: "the force is auto calculated if
+ * omitted"). Length needs Force cells (Force x 2 m); every level past
+ * the first needs another 3 m of height, i.e. Force 3 a level.
+ */
+export function forceForWall(a, b) {
+    const length = Math.max(Math.abs(a.x - b.x), Math.abs(a.y - b.y)) + 1;
+    const levels = Math.abs(a.z - b.z) + 1;
+    return Math.max(1, Math.ceil(length * METERS_PER_CELL / 2), levels > 1 ? levels * METERS_PER_LEVEL : 1);
+}
+/** The directional wall is three cells across: Force 3. */
+export const DIRECTIONAL_WALL_FORCE = 3;
+/** A dome with no Force named rises one full 3 m storey: Force 3. */
+export const DOME_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);
+    return `a ${barrier.shape} over ${span} in ${barrier.roomName}, Force ${barrier.force}, ${barrierStats(barrier)}`;
+}
+/**
+ * Armor and every face's damage track, in one breath: "Armor 3,
+ * Structure 3 [N 0/3, E 1/3, S BREACHED, W 0/3]". The HUD's sustained
+ * line and the spells list both print it -- a barrier you hold is a
+ * thing being shot at, and the track is what tells you which side gives.
+ */
+export function barrierStats(barrier) {
+    const tracks = barrier.faces
+        .map(f => `${f.id === 'wall' ? 'wall' : f.id.toUpperCase()} ${f.breached ? 'BREACHED' : `${f.damage}/${barrier.structure}`}`)
+        .join(', ');
+    return `Armor ${barrier.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/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

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

@@ -1,7 +1,8 @@
 import { capitalCase } from 'change-case';
 import { Door } from '../models/door.js';
 import { Direction } from '../types/shared/direction-enum.js';
-import { FRONTIER_GLYPH, BLOCKED_GLYPH, UP_GLYPH, DOWN_GLYPH, PLAYER_GLYPH, WALL_GLYPH, DOOR_GLYPH, FLOOR_GLYPH, VOID_GLYPH, TERRAIN_GLYPH, OUTSIDE_GROUND_COLOR, GLYPH_RANK, OFF_EDGE_GLYPH, } from './map-glyphs.js';
+import { FRONTIER_GLYPH, BLOCKED_GLYPH, UP_GLYPH, DOWN_GLYPH, PLAYER_GLYPH, WALL_GLYPH, DOOR_GLYPH, FLOOR_GLYPH, VOID_GLYPH, TERRAIN_GLYPH, OUTSIDE_GROUND_COLOR, GLYPH_RANK, OFF_EDGE_GLYPH, BARRIER_GLYPH, BARRIER_COLOR, MANA_BARRIER_COLOR, } from './map-glyphs.js';
+import { xRulerLine, yRulerLabel } from './map-rulers.js';
 import { roomAtCell, isVoid, wallsBetween, districtBearing, isOpenAir } from './district-plane.js';
 import { distanceMeters, METERS_PER_LEVEL } from './room-grid.js';
 import { isOutdoorsPlace } from './outdoors.js';
@@ -713,8 +714,13 @@ function renderPlaneViewport(plane, rooms, here, eyes, viewW, viewH) {
      */
     const MARGIN = 2;
     const cam = eyes?.at;
-    const wantW = Math.max(1, viewW);
-    const wantH = Math.max(1, viewH);
+    // The rulers come out of the panel, not on top of it: a fixed gutter
+    // (three characters -- the plane is 60 rows deep -- and a space) and
+    // one row for the x labels.
+    const RULER_GUTTER = 3;
+    const rulers = eyes?.rulers === true;
+    const wantW = Math.max(1, viewW - (rulers ? RULER_GUTTER + 1 : 0));
+    const wantH = Math.max(1, viewH - (rulers ? 1 : 0));
     /**
      * ONE CELL, ONE DOT -- 2 m, the same as the room panel.
      *
@@ -1068,6 +1074,21 @@ function renderPlaneViewport(plane, rooms, here, eyes, viewW, viewH) {
                 labels.set(at2, ch);
         });
     }
+    // BARRIER SPELLS (barrier-geometry.ts): a Physical Barrier for every
+    // eye, a Mana Barrier only for its weaver or an eye on the astral.
+    const spellCells = new Map();
+    const seer = eyes?.viewer;
+    const seesAstral = !!seer && (seer.plane === 'astral' || seer.astralPerceiving);
+    for (const b of here.scene?.spellBarriers?.() ?? []) {
+        if (b.kind === 'mana' && !seesAstral && b.caster !== seer?.name)
+            continue;
+        for (const f of b.faces) {
+            if (f.breached)
+                continue;
+            for (const c of f.cells)
+                spellCells.set(`${c.x},${c.y},${c.z}`, b.kind);
+        }
+    }
     const out = [];
     let openStyle = '';
     for (let ry = 0; ry < rows; ry++) {
@@ -1195,6 +1216,9 @@ function renderPlaneViewport(plane, rooms, here, eyes, viewW, viewH) {
                      * not internal detail. The floorplan is what the Room panel
                      * is for, one zoom in.
                      */
+                    const spell = spellCells.get(key);
+                    if (spell)
+                        take(BARRIER_GLYPH, GLYPH_RANK.barrier, spell === 'mana' ? MANA_BARRIER_COLOR : BARRIER_COLOR);
                     const owner = roomAtCell(plane, { x, y, z });
                     const indoors = owner !== undefined && !plane.placements.get(owner).outdoors;
                     const ring = plane.walls.has(key) || (zoomedOut && plane.doorways.has(key) && wallOwner.has(key));
@@ -1300,8 +1324,10 @@ function renderPlaneViewport(plane, rooms, here, eyes, viewW, viewH) {
         openStyle = '';
         // NOT trimmed: a filled row is the point, and trailing ground is
         // still ground.
-        out.push(line);
+        out.push(rulers ? `${yRulerLabel(y0 + Math.floor((ry * spanY) / rows), RULER_GUTTER)} ${line}` : line);
     }
+    if (rulers)
+        out.unshift(`${' '.repeat(RULER_GUTTER + 1)}${xRulerLine(x0, cols, cellsPerDot)}`);
     return out;
 }
 /**

package/bundle/typescript/src/commands/game/sideQuest/utilities/room-grid.js

@@ -248,8 +248,23 @@ function cellExists(grid, c, levelCells) {
 export function cellOnGrid(grid, c) {
     return cellExists(grid, c, LEVEL_CELLS.get(grid) ?? new Map());
 }
-/** Whether `c` sits inside an uncleared BLOCKING terrain region. */
+/**
+ * SOMETHING ELSE THAT SEALS A CELL, asked live: a sustained Physical
+ * Barrier (Scene.physicalBarrierAtLocal, registered by Room.ensureGrid).
+ * A spell comes and goes many times over a grid's life, so it is a
+ * question the grid asks rather than terrain baked into it -- and a
+ * rebuilt grid cannot lose a wall that was never stored on it. Keyed by
+ * grid identity like LEVEL_CELLS: per room, never module-wide (several
+ * scenes share this process on the site).
+ */
+const CELL_BLOCKERS = new WeakMap();
+export function setCellBlocker(grid, blocked) {
+    CELL_BLOCKERS.set(grid, blocked);
+}
+/** Whether `c` sits inside an uncleared BLOCKING terrain region, or under a standing barrier spell. */
 function isBlocked(grid, c) {
+    if (CELL_BLOCKERS.get(grid)?.(c))
+        return true;
     const k = key(c);
     for (const region of grid.terrain.values()) {
         if (!region.blocking || region.cleared)
@@ -482,6 +497,9 @@ export function pathClearing(grid, from, to, region) {
     const trial = { ...grid, terrain: new Map(grid.terrain) };
     trial.terrain.set(region.id, { ...region, cleared: true });
     LEVEL_CELLS.set(trial, LEVEL_CELLS.get(grid) ?? new Map());
+    const blocker = CELL_BLOCKERS.get(grid);
+    if (blocker)
+        CELL_BLOCKERS.set(trial, blocker);
     return findPath(trial, from, to);
 }
 /**
@@ -503,6 +521,9 @@ export function pathWithRegionsCleared(grid, from, to, regionIds) {
             trial.terrain.set(id, { ...region, cleared: true });
     }
     LEVEL_CELLS.set(trial, LEVEL_CELLS.get(grid) ?? new Map());
+    const blocker = CELL_BLOCKERS.get(grid);
+    if (blocker)
+        CELL_BLOCKERS.set(trial, blocker);
     return findPath(trial, from, to);
 }
 /** SR5 p.172 (RAG-verified): DV = meters fallen, only beyond 3m; AP-4