@maka/maka-cli 5.383.0 → 5.384.0

package/bundle/typescript/src/commands/game/sideQuest/commands/spells.js

@@ -4,6 +4,7 @@ import { Category } from '../types/shared/item-enum.js';
 import { hint } from '../utilities/hints.js';
 import { getAspect } from '../aspects.js';
 import { spellCreationCap } from '../spells.js';
+import { describeBarrier } from '../utilities/barrier-geometry.js';
 /**
  * The spellbook: how a player actually discovers what they can cast and
  * why. Especially load-bearing for INNATE casting -- an Awakened character
@@ -118,10 +119,10 @@ export class SpellsCommand extends Command {
             lines.push(`Sustaining on ${w.bearer}: ${w.key === 'reflexes' ? 'increase reflexes' : w.key} (${sustainBurden(w, ' to everything else')}).${hint(` Cast ${w.key} on ${w.bearer} again to release.`)}`);
         }
         if (actor.sustainedBarrier) {
-            lines.push(`Sustained: force barrier sealing ${actor.sustainedBarrier.direction} in ${actor.sustainedBarrier.roomName}, Force ${actor.sustainedBarrier.force} (${burden('barrier')}).${hint(' Cast barrier again to release.')}`);
+            lines.push(`Sustained: force barrier -- ${describeBarrier(actor.sustainedBarrier)} (${burden('barrier')}).${hint(' "cast barrier off" releases it.')}`);
         }
         if (actor.sustainedManaBarrier) {
-            lines.push(`Sustained: mana barrier sealing ${actor.sustainedManaBarrier.direction} in ${actor.sustainedManaBarrier.roomName}, Force ${actor.sustainedManaBarrier.force} (${burden('manabarrier')}).${hint(' Cast manabarrier again to release.')}`);
+            lines.push(`Sustained: mana barrier -- ${describeBarrier(actor.sustainedManaBarrier)} (${burden('manabarrier')}).${hint(' "cast manabarrier off" releases it.')}`);
         }
         if (actor.sustainedReflexes) {
             lines.push(`Sustained: increase reflexes, +2 initiative (${burden('reflexes')}).${hint(' Cast it again to release.')}`);
@@ -176,10 +177,10 @@ export class SpellsCommand extends Command {
                 line: 'sustained: light slides around the bearer, +3 on sneak contests at -2 dice. Drain F-4.' },
             { key: 'reflexes', cast: 'increase reflexes', how: 'cast increase reflexes [on <ally>]',
                 line: 'sustained: +2 initiative for the bearer at -2 dice. Drain F-3.' },
-            { key: 'barrier', cast: 'barrier', how: 'cast barrier <direction>; cast barrier again to release',
-                line: 'sustained: hardened air seals ONE exit of your room; nobody meat-side passes (you included) at -2 dice to you. Drain F-3.' },
-            { key: 'manabarrier', cast: 'manabarrier', how: 'cast manabarrier <direction>',
-                line: 'sustained: woven mana seals ONE exit against SPIRITS and astral forms; the living pass freely. Drain F-2.' },
+            { key: 'barrier', cast: 'barrier', how: 'cast barrier [F] <x,y> <x,y> (wall) | <x,y> (dome) | <direction> [cells] | at <someone> | (bare: a dome round you); cast barrier off',
+                line: 'sustained: hardened air -- a wall Force x 2 m long and Force m high, or a Force-metre dome. Armor/Structure = hits, a track per face; nobody meat-side passes (you included) at -2 dice to you. Drain F-1.' },
+            { key: 'manabarrier', cast: 'manabarrier', how: 'cast manabarrier [F] <x,y> <x,y> | <x,y> | <direction> [cells] | at <someone>; cast manabarrier off',
+                line: 'sustained: woven mana, same shapes -- stops SPIRITS and astral forms; the living pass freely, and so do you. Armor/Structure = Force. Drain F-2.' },
         ];
         for (const entry of book) {
             if (!actor.knowsSpell(entry.key))

package/bundle/typescript/src/commands/game/sideQuest/engine-version.js

@@ -3334,5 +3334,26 @@
 //   (nfrBW27eRRxstJ8uC).
 // - The HUD's holstered line drops its `-- "brandish"` tip
 //   (MkxamPxmsSyonR3wC).
-export const ENGINE_VERSION = '1.195.0';
+// 1.196.0 (2026-10-05): BARRIER SPELLS ON THE DISTRICT PLANE (SR5 p.294,
+//   p.197-198, p.315-316; utilities/barrier-geometry.ts).
+// - A barrier is cells, not a tag on an exit: `cast barrier [F] <x,y[,z]>
+//   [<x,y[,z]>]` (a wall between two points, or a Force-metre dome round
+//   one), `cast barrier [F] <dir> [cells]` (1x3 across the way), `cast
+//   barrier [F] at <someone>`, bare `cast barrier` (a dome round you),
+//   `cast barrier off`. Plane coordinates; LOS-gated; clipped by matter
+//   (physical) or by earth/wards/other weaves (mana).
+// - Physical Barrier rolls for real: Armor and Structure = hits [Force].
+//   Mana Barrier: Force. One damage track per FACE (a wall has one; a
+//   dome N/E/S/W, plus a crown past one level). `attack barrier [x,y]`
+//   breaks a face (p.197 text: DV must EXCEED Armor; guns do 1 box);
+//   a gun fired through one loses a box to it. Both regenerate at the
+//   Combat Turn boundary (mana at the end, physical at the start).
+// - Movement: findPath/stepFrom route round a physical barrier; astral
+//   `move` now stops at a mana barrier (it drifted through); astral `go`
+//   presses through on Magic + Charisma [Astral] v. Force x 2.
+// - Bare `cast <direction>` no longer unweaves a ward -- `dispel <dir>`.
+// - Wire: the room grid carries `barriers` (room-local cells; a mana
+//   barrier only for eyes that can see it). Docks draw x/y rulers in
+//   plane coordinates and the caption gives your x,y,z.
+export const ENGINE_VERSION = '1.196.0';
 //# sourceMappingURL=engine-version.js.map

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

@@ -149,6 +149,7 @@ import { ForceCommand } from './commands/force.js';
 import { CompleteCommand } from './commands/complete.js';
 import { DisableCommand, BrickCommand } from './commands/disable.js';
 import { CastCommand } from './commands/cast.js';
+import { barrierSpan } from './utilities/barrier-geometry.js';
 import { FollowCommand, UnfollowCommand } from './commands/follow.js';
 import { BringCommand } from './commands/bring.js';
 import { SurrenderCommand } from './commands/surrender.js';
@@ -9477,10 +9478,10 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
         // the one that strands the team -- and both of them seal an exit
         // that the caster cannot pass either.
         if (player.sustainedBarrier) {
-            heldSpells.push(`physical barrier (${player.sustainedBarrier.roomName} ${player.sustainedBarrier.direction})`);
+            heldSpells.push(`physical barrier (${player.sustainedBarrier.shape} ${barrierSpan(player.sustainedBarrier)}, ${player.sustainedBarrier.roomName})`);
         }
         if (player.sustainedManaBarrier) {
-            heldSpells.push(`mana barrier (${player.sustainedManaBarrier.roomName} ${player.sustainedManaBarrier.direction})`);
+            heldSpells.push(`mana barrier (${player.sustainedManaBarrier.shape} ${barrierSpan(player.sustainedManaBarrier)}, ${player.sustainedManaBarrier.roomName})`);
         }
         // What this character holds on OTHERS -- the caster's burden, named
         // by bearer so the mage knows whose armor is costing them two dice.
@@ -9721,6 +9722,7 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
                 // Whose eyes, and what counts as hostile -- so the district draws
                 // the same people, with the same marks, the room panel does.
                 viewer: this.player,
+                rulers: true,
                 isOtherPlayer: a => this.scene.isHumanControlled(a),
                 isTableAlly: crewOfTable(this.scene.getPlayers()),
                 isHostile: a => hostileByStance(a) || enemyInFight(this.scene, this.player, a),
@@ -9753,6 +9755,8 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
             const roomLines = renderRoomLayoutCompact(here, this.player, {
                 isTableAlly: crewOfTable(this.scene.getPlayers()),
                 boxWidth,
+                // Rulers in PLANE coordinates -- the numbers "cast barrier x,y" takes.
+                origin: here.planeFrame?.()?.origin,
                 isOtherPlayer: a => this.scene.isHumanControlled(a),
                 // Red is the stance flag OR whoever the Combat Turn says is
                 // fighting you (room-view.ts hostileByStance).
@@ -9767,7 +9771,7 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
                 // of its own. The GLYPHS moved to `map legend`, where there is
                 // room to say what they mean instead of abbreviating them into
                 // a strip nobody could read.
-                roomLines.push(rightAlign(dockScale(roomMetresPerDot(here, this.roomGridWidth() ?? Math.max(6, (boxWidth ?? 27) - 8), roomRasterRows())), boxWidth));
+                roomLines.push(rightAlign(dockScale(roomMetresPerDot(here, this.roomGridWidth() ?? Math.max(6, (boxWidth ?? 27) - 8), roomRasterRows(), here.planeFrame?.()?.origin)), boxWidth));
                 roomLines.push(caption(roomCaption(here, this.player), boxWidth));
             }
             this.setRoomOverlay(roomLines);

package/bundle/typescript/src/commands/game/sideQuest/headless.js

@@ -564,6 +564,7 @@ function wireHeadless(game, ctx, logger) {
                 arEyes: p.hasMatrixEyes(),
                 at: game.scene.worldCellOf(p),
                 viewer: p,
+                rulers: true,
                 isOtherPlayer: (a) => game.scene.isHumanControlled(a),
                 isTableAlly: crewOfTable(game.scene.getPlayers()),
                 isHostile: (a) => hostileByStance(a) || enemyInFight(game.scene, p, a),
@@ -651,6 +652,7 @@ function wireHeadless(game, ctx, logger) {
             try {
                 const roomLines = renderRoomLayoutCompact(here, p, {
                     isOtherPlayer: a => game.scene.isHumanControlled(a),
+                    origin: here.planeFrame?.()?.origin,
                     isHostile: a => hostileByStance(a) || enemyInFight(game.scene, p, a),
                     // The leader's crew are the TABLE's crew -- without this
                     // every non-leader saw them as neutral bystanders.
@@ -671,7 +673,7 @@ function wireHeadless(game, ctx, logger) {
                 // here anyway rather than asserted, since a decoration must
                 // never take down the room push (same reasoning as the
                 // try/catch this sits inside).
-                const grid = roomGridWire(here);
+                const grid = roomGridWire(here, p);
                 const data = grid ? { grid } : undefined;
                 logger.system(roomLines.join('\n'), { actor: p.name }, 'room', data);
             }

package/bundle/typescript/src/commands/game/sideQuest/models/player.js

@@ -5244,10 +5244,11 @@ export class Player extends AbstractPlayer {
             }
         }
     }
-    /** The sustained PHYSICAL BARRIER spell (ruling 2026-08-24): seals
-     *  one exit of one room while held -- go.ts and move refuse passage
-     *  for everyone (the caster included; walls don't play favorites).
-     *  Session-only, like every sustain. */
+    /** The sustained PHYSICAL BARRIER spell: cells on the district plane
+     *  (utilities/barrier-geometry.ts, 2026-10-05 -- it used to seal one
+     *  exit). Nothing physical crosses a standing face, the caster
+     *  included; walls don't play favorites. Session-only, like every
+     *  sustain. */
     _sustainedBarrier;
     get sustainedBarrier() { return this._sustainedBarrier; }
     set sustainedBarrier(v) {
@@ -5259,8 +5260,9 @@ export class Player extends AbstractPlayer {
         this.noteConditionChanged();
     }
     /** The MANA BARRIER twin (canon p.294, RAG-checked): blocks SPIRITS
-     *  and astral forms at the sealed exit; living mundanes and physical
-     *  objects pass freely. Same lifecycle as sustainedBarrier. */
+     *  and astral forms at its cells; living mundanes and physical
+     *  objects pass freely, and so does its creator (p.315). Same
+     *  lifecycle as sustainedBarrier. */
     _sustainedManaBarrier;
     get sustainedManaBarrier() { return this._sustainedManaBarrier; }
     set sustainedManaBarrier(v) {

package/bundle/typescript/src/commands/game/sideQuest/models/room.js

@@ -16,7 +16,7 @@ import { dwellingDims } from '../utilities/dwellings.js';
 import { spotsActive, isPerchSpot, actorDistanceMeters, voiceBandFor, voiceTag, doorwayKindOf, exitDoorwayKind } from '../utilities/spots.js';
 import { canHearSpeech, canHearShout } from '../utilities/earshot.js';
 import { freshCrowd, clampHeadcount, deriveOccupancy } from '../utilities/crowd.js';
-import { synthesizeGrid, attachExitCell, detachExitCell, hashFnv1a, mulberry32, } from '../utilities/room-grid.js';
+import { synthesizeGrid, attachExitCell, detachExitCell, hashFnv1a, mulberry32, setCellBlocker, } from '../utilities/room-grid.js';
 /**
  * A CAMERA'S DEVICE RATING when the scene does not say (p.356, which
  * lists "Camera" at 1 -- the same table that gives the door lock the 2
@@ -560,6 +560,9 @@ export class Room extends AbstractRoom {
             levels: this.levels,
             terrainHints: this.terrainHints,
         });
+        // A BARRIER SPELL IS ASKED, NOT STORED (room-grid.ts CELL_BLOCKERS):
+        // its cells come and go while the grid lives, and the scene owns them.
+        setCellBlocker(this._grid, c => this.scene?.physicalBarrierAtLocal?.(this, c) ?? false);
         return this._grid;
     }
     /**

package/bundle/typescript/src/commands/game/sideQuest/models/scene.js

@@ -8,6 +8,12 @@ import { Direction } from '../types/shared/direction-enum.js';
 import { Door } from './door.js';
 import { dwellingDims } from '../utilities/dwellings.js';
 import { actorCell } from '../utilities/spots.js';
+import { line3D } from '../utilities/room-grid.js';
+import { faceAt } from '../utilities/barrier-geometry.js';
+/** One step out through a doorway, per exit direction (north is -y). */
+const BARRIER_STEP = {
+    north: [0, -1], south: [0, 1], east: [1, 0], west: [-1, 0],
+};
 import { packDistrict, worldCell, buildAuthoredPlane, partyLayout, planeFaults } from '../utilities/district-plane.js';
 import { Category, Size, Rating } from '../types/shared/item-enum.js';
 import { AbstractScene } from '../types/shared/abstracts.js';
@@ -1222,30 +1228,93 @@ export class Scene extends AbstractScene {
         return this.characterLocations.get(character.name);
     }
     /**
-     * A sustained PHYSICAL BARRIER spell (Player.sustainedBarrier)
-     * sealing this room's exit in `direction` -- checked from BOTH sides
-     * of the doorway (the wall is in the frame, not painted on one face).
-     * go.ts refuses traversal for every meat-plane actor while it holds.
+     * EVERY BARRIER SPELL STANDING IN THIS SCENE (barrier-geometry.ts).
+     * They live on the casters -- one of each kind apiece -- so this is a
+     * walk of the players, the same place the old exit seal read them.
      */
-    barrierSealing(room, direction, kind = 'physical') {
+    spellBarriers(kind) {
+        const out = [];
+        for (const p of this.getPlayers()) {
+            if (p.sustainedBarrier && (!kind || kind === 'physical'))
+                out.push(p.sustainedBarrier);
+            if (p.sustainedManaBarrier && (!kind || kind === 'mana'))
+                out.push(p.sustainedManaBarrier);
+        }
+        return out;
+    }
+    /**
+     * The standing barrier face on this PLANE cell, if any. `passer` is
+     * who is asking to cross: a mana barrier "does not affect its
+     * creator, who can pass through at will" (p.315), so its own weaver
+     * gets undefined. A physical wall plays no favourites.
+     */
+    barrierAt(c, kind, passer) {
+        for (const barrier of this.spellBarriers(kind)) {
+            if (kind === 'mana' && passer !== undefined && barrier.caster === passer)
+                continue;
+            const face = faceAt(barrier, c);
+            if (face)
+                return { barrier, face };
+        }
+        return undefined;
+    }
+    /**
+     * The first standing barrier face a straight line crosses between two
+     * PLANE cells, endpoints excluded -- what a shot at someone behind a
+     * wall has to go through first (p.197-198).
+     */
+    barrierOnLine(a, b, kind) {
+        if (this.spellBarriers(kind).length === 0)
+            return undefined;
+        for (const c of line3D(a, b).slice(1, -1)) {
+            const hit = this.barrierAt(c, kind);
+            if (hit)
+                return hit;
+        }
+        return undefined;
+    }
+    /**
+     * A ROOM-LOCAL cell under a physical barrier -- what Room.ensureGrid
+     * registers with the grid, so findPath, stepFrom and seating all
+     * route round the wall without knowing spells exist.
+     */
+    physicalBarrierAtLocal(room, local) {
+        if (this.spellBarriers('physical').length === 0)
+            return false;
+        const c = worldCell(this.ensurePlane(), room.name, local);
+        return !!c && !!this.barrierAt(c, 'physical');
+    }
+    /**
+     * IS THIS EXIT WALLED OFF BY A BARRIER SPELL. Since 2026-10-05 a
+     * barrier is cells, not a tag on an exit, so the question is whether a
+     * standing face covers the doorway: the exit's own cell or the gap in
+     * the wall beyond it -- from either side, because the far room's
+     * doorway is the same hole.
+     */
+    barrierSealing(room, direction, kind = 'physical', passer) {
+        if (this.spellBarriers(kind).length === 0)
+            return undefined;
+        const plane = this.ensurePlane();
+        const cellsOf = (r, dir) => {
+            const local = r.ensureGrid()?.exitCells.get(dir.toLowerCase());
+            const at = local && worldCell(plane, r.name, local);
+            if (!at)
+                return [];
+            const step = BARRIER_STEP[dir.toLowerCase()];
+            return step ? [at, { x: at.x + step[0], y: at.y + step[1], z: at.z }] : [at];
+        };
         const exit = room.exits.get(direction);
         // getOtherSide (the Room), not getOtherSideToName (a "To X" display
         // string -- a probe caught the far-side check silently never
         // matching on it).
-        const destName = !exit ? undefined
-            : typeof exit === 'string' ? exit
-                : exit.getOtherSide?.(room)?.name;
+        const far = !exit || typeof exit === 'string' ? undefined
+            : exit.getOtherSide?.(room);
         const opposite = room.getOppositeDirection(direction);
-        for (const p of this.getPlayers()) {
-            const b = kind === 'physical' ? p.sustainedBarrier : p.sustainedManaBarrier;
-            if (!b)
-                continue;
-            if (b.roomName === room.name && b.direction.toLowerCase() === direction.toLowerCase()) {
-                return { caster: p.name, force: b.force };
-            }
-            if (destName && b.roomName === destName && opposite && b.direction.toLowerCase() === String(opposite).toLowerCase()) {
-                return { caster: p.name, force: b.force };
-            }
+        const cells = [...cellsOf(room, direction), ...(far && opposite ? cellsOf(far, String(opposite)) : [])];
+        for (const c of cells) {
+            const hit = this.barrierAt(c, kind, passer);
+            if (hit)
+                return { caster: hit.barrier.caster, force: hit.barrier.force };
         }
         return undefined;
     }

package/bundle/typescript/src/commands/game/sideQuest/utilities/astral-move.js

@@ -75,7 +75,7 @@ export function driftAstral(scene, actor, rooms, direction, count, untilOut = fa
     // the room it is trying to leave is large.
     const limit = untilOut ? 50 : count;
     while (taken < limit) {
-        const step = astralStepFrom(plane, cell, direction, 1, byKey);
+        const step = astralStepFrom(plane, cell, direction, 1, byKey, c => scene.barrierAt?.(c, 'mana', actor.name)?.barrier.caster);
         if (step.taken === 0) {
             blockedBy = step.blockedBy;
             ward = step.ward;
@@ -193,6 +193,9 @@ export function driftRefusal(d, direction) {
      * nearest outdoor room and simply goes. The only things that stop a
      * form are the two canon gives: solid earth and a ward.
      */
+    if (d.blockedBy === 'barrier') {
+        return `A mana barrier hangs across the way ${direction}${d.ward ? ` -- ${d.ward}'s working` : ''}: a hazy, solid sheet of woven mana. The astral does not pass (p.315-316).`;
+    }
     if (d.blockedBy === 'ward') {
         return `A lattice of woven mana stands across the way ${direction}${d.ward ? ` -- ${d.ward}'s` : ''}. The astral does not pass.`;
     }

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