@maka/maka-cli 5.383.0 → 5.385.0

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

@@ -4,7 +4,9 @@ import { Direction } from '../types/shared/direction-enum.js';
 import { OPEN_FLOOR, spotOf, visibleActorsIn, exitSpot, seatingIn, theSpot, isPerchSpot } from './spots.js';
 import { placeName } from './log-style.js';
 import { DRONE_COLOUR } from './drone-prose.js';
-import { PLAYER_GLYPH, OTHER_PLAYER_GLYPH, OTHER_PLAYER_COLOR, NEUTRAL_GLYPH, HOSTILE_GLYPH, CREW_GLYPH, DEAD_GLYPH, DOWNED_GLYPH, SPOT_GLYPH, RIGGED_GLYPH, UP_GLYPH, CAMERA_GLYPH, CAMERA_COLOR, CAMERA_DEAD_COLOR, exitGlyph, GLYPH_RANK, } from './map-glyphs.js';
+import { PLAYER_GLYPH, OTHER_PLAYER_GLYPH, OTHER_PLAYER_COLOR, NEUTRAL_GLYPH, HOSTILE_GLYPH, CREW_GLYPH, DEAD_GLYPH, DOWNED_GLYPH, SPOT_GLYPH, RIGGED_GLYPH, UP_GLYPH, CAMERA_GLYPH, CAMERA_COLOR, CAMERA_DEAD_COLOR, BARRIER_GLYPH, BARRIER_COLOR, MANA_BARRIER_COLOR, exitGlyph, GLYPH_RANK, } from './map-glyphs.js';
+import { barriersWire } from './ways-out.js';
+import { xRulerLine, yRulerLabel, yGutterWidth } from './map-rulers.js';
 import { key, levelFootprint, dimsForSize, roomRasterRows, METERS_PER_LEVEL, METERS_PER_CELL, } from './room-grid.js';
 /**
  * WHO THIS PANEL DRAWS: everyone you can see, plus every ARO your AR is
@@ -276,7 +278,16 @@ function buildRenderMaps(grid, room, viewer) {
         if (c)
             cameraAt.set(`${c.x},${c.y}`, { cam, z: c.z });
     }
-    return { cellToSpot, cellToExit, verticalAt, cellTerrain, occupants, corpses, slumpedBody, cameraAt };
+    const barrierAt = new Map();
+    for (const b of barriersWire(room, viewer)) {
+        for (const f of b.faces) {
+            if (f.breached)
+                continue;
+            for (const c of f.cells)
+                barrierAt.set(key(c), b.kind);
+        }
+    }
+    return { cellToSpot, cellToExit, verticalAt, cellTerrain, occupants, corpses, slumpedBody, cameraAt, barrierAt };
 }
 function paint(g) {
     const body = g.inverse ? `{inverse}${g.ch}{/inverse}` : g.ch;
@@ -484,6 +495,9 @@ function glyphAt(c, maps, viewer, isOtherPlayer, isTableAlly, isHostile) {
     const lens = maps.cameraAt.get(`${c.x},${c.y}`);
     if (lens && lens.z >= c.z)
         return cameraGlyph(lens.cam);
+    const wall = maps.barrierAt.get(k);
+    if (wall)
+        return { ch: BARRIER_GLYPH, color: wall === 'mana' ? MANA_BARRIER_COLOR : BARRIER_COLOR, rank: GLYPH_RANK.barrier };
     const terrain = maps.cellTerrain.get(k);
     if (terrain)
         return terrain.blocking ? { ch: '▓', color: 'red', rank: GLYPH_RANK.terrainBlocking } : { ch: '▒', color: 'yellow', rank: GLYPH_RANK.terrainCover };
@@ -552,7 +566,9 @@ function levelPlansFor(room) {
  * glyph used. Returns [] for a spotless room (no grid ever synthesizes
  * -- see Room.ensureGrid).
  */
-export function renderRoomLayout(room, viewer, isOtherPlayer, isTableAlly, isHostile) {
+export function renderRoomLayout(room, viewer, isOtherPlayer, isTableAlly, isHostile, 
+/** The room's PLANE origin: rulers in plane coordinates (map-rulers.ts). */
+origin) {
     const grid = room.ensureGrid();
     if (!grid)
         return [];
@@ -569,8 +585,11 @@ export function renderRoomLayout(room, viewer, isOtherPlayer, isTableAlly, isHos
         const exists = new Set(footprint.map(key));
         if (levelPlans.length > 1)
             rows.push(`{bold}${lvl.label}{/bold}`);
+        const gutter = origin ? yGutterWidth(origin.y + y0, y1 - y0 + 1) + 1 : 0;
+        if (origin)
+            rows.push(`${' '.repeat(gutter)}${xRulerLine(origin.x + x0, x1 - x0 + 1)}`);
         for (let y = y0; y <= y1; y++) {
-            let row = '';
+            let row = origin ? `${yRulerLabel(origin.y + y, gutter - 1)} ` : '';
             for (let x = x0; x <= x1; x++) {
                 const c = { x, y, z: lvl.z };
                 row += exists.has(key(c)) ? cell(glyphAt(c, maps, viewer, isOtherPlayer, isTableAlly, isHostile)) : ' ';
@@ -589,6 +608,11 @@ export function renderRoomLayout(room, viewer, isOtherPlayer, isTableAlly, isHos
         // that reads as a keyword in the description must read as one here.
         legend.push(`{yellow-fg}${SPOT_GLYPH}{/yellow-fg} places: ${places.map(placeName).join(', ')}`);
     }
+    const kinds = new Set(maps.barrierAt.values());
+    if (kinds.has('physical'))
+        legend.push(`{${BARRIER_COLOR}-fg}${BARRIER_GLYPH}{/${BARRIER_COLOR}-fg} force barrier -- nothing physical passes; "attack barrier" to break a face`);
+    if (kinds.has('mana'))
+        legend.push(`{${MANA_BARRIER_COLOR}-fg}${BARRIER_GLYPH}{/${MANA_BARRIER_COLOR}-fg} mana barrier -- stops the astral and spirits; the living walk through`);
     for (const dir of grid.exitCells.keys()) {
         // Name the spot you actually stand in to leave this way -- read
         // from the same resolver movement uses, not from cell coincidence:
@@ -716,10 +740,13 @@ export function rightAlign(text, width) {
     const pad = Math.max(0, width - visibleWidth(text));
     return `${' '.repeat(pad)}${text}`;
 }
-export function roomMetresPerDot(room, availW, viewH) {
+export function roomMetresPerDot(room, availW, viewH, origin) {
     const grid = room.ensureGrid();
     const dims = grid ? { x: grid.dims.x, y: grid.dims.y } : dimsForSize(room.size);
-    return frameScale(dims.x, dims.y, availW, viewH) * METERS_PER_CELL;
+    // The rulers come out of the same raster (frameCells), so the scale
+    // read-out has to subtract them too or it would claim a finer dot.
+    const gutter = origin ? yGutterWidth(origin.y, dims.y) + 1 : 0;
+    return frameScale(dims.x, dims.y, availW - gutter, origin ? viewH - 1 : viewH) * METERS_PER_CELL;
 }
 export function frameScale(width, height, availW, viewH) {
     // One column a dot -- see cell(). The /2 this used to carry was the
@@ -758,15 +785,22 @@ export function frameScale(width, height, availW, viewH) {
  * The block is centred inside a fixed `viewH` rows so the box height
  * never jumps between rooms either.
  */
-function frameCells(cells, availW, viewH) {
+function frameCells(cells, availW, viewH, 
+/** PLANE coordinates of cells[0][0]: draw the x ruler above and the y
+ *  gutter beside (map-rulers.ts). Both come out of the same raster, so
+ *  the box never grows -- the room scales a little harder instead. */
+axes) {
     const height = cells.length;
     const width = Math.max(...cells.map(r => r.length), 0);
-    const scale = frameScale(width, height, availW, viewH);
+    const gutter = axes ? yGutterWidth(axes.y, height) + 1 : 0;
+    const cols = availW - gutter;
+    const rows = axes ? viewH - 1 : viewH;
+    const scale = frameScale(width, height, cols, rows);
     const outW = Math.ceil(width / scale);
     const outH = Math.ceil(height / scale);
     const body = [];
     for (let ry = 0; ry < outH; ry++) {
-        let line = '';
+        let line = axes ? `${yRulerLabel(axes.y + ry * scale, gutter - 1)} ` : '';
         for (let rx = 0; rx < outW; rx++) {
             // The highest-ranked thing in the block wins the dot -- see
             // IGlyph.rank. At scale 1 this is exactly the old behaviour,
@@ -783,6 +817,8 @@ function frameCells(cells, availW, viewH) {
         }
         body.push(line.trimEnd());
     }
+    if (axes)
+        body.unshift(`${' '.repeat(gutter)}${xRulerLine(axes.x, outW, scale)}`);
     // Vertically centre into a fixed height: a short room shouldn't sit
     // jammed against the top while a tall one fills the box.
     const pad = Math.max(0, viewH - body.length);
@@ -968,7 +1004,7 @@ export function renderRoomLayoutCompact(room, viewer, opts = {}) {
     // room is SCALED onto it (frameCells), so this bounds the picture
     // rather than the room: an outdoor room takes its extent from the
     // district plane and can be far deeper than any size class.
-    const { viewH = roomRasterRows(), boxWidth, isOtherPlayer, isTableAlly, isHostile } = opts;
+    const { viewH = roomRasterRows(), boxWidth, isOtherPlayer, isTableAlly, isHostile, origin } = opts;
     // Width left for the grid once the right-justified elevation bar and
     // its gap are reserved.
     const availW = Math.max(6, (boxWidth ?? 27) - ELEVATION_WIDTH - 1);
@@ -1023,7 +1059,7 @@ export function renderRoomLayoutCompact(room, viewer, opts = {}) {
     const lenses = new Map();
     for (const { cam, z: lz } of maps.cameraAt.values())
         lenses.set(lz, [...(lenses.get(lz) ?? []), cam]);
-    return withElevation(frameCells(cells, availW, viewH), 
+    return withElevation(frameCells(cells, availW, viewH, origin ? { x: origin.x + x0, y: origin.y + y0 } : undefined), 
     // Circulating has no level to claim, same as it has no cell.
     elevationColumn(grid, viewerCell ? z : undefined, viewH, partialMeters, lenses), boxWidth);
 }
@@ -1099,6 +1135,10 @@ export function roomCaption(room, viewer) {
     const base = spot ? `at ${spot}` : '(moving through)';
     const { above, below } = actorsOnOtherLevels(room, viewer);
     const notes = [];
+    // WHERE, IN THE RULERS' NUMBERS -- what "cast barrier x,y" is aimed with.
+    const here = room.scene?.worldCellOf?.(viewer);
+    if (here)
+        notes.push(`${here.x},${here.y},${here.z}`);
     if (above > 0)
         notes.push(`+${above} above`);
     if (below > 0)

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

@@ -1,6 +1,6 @@
 import { droneImmobile } from './drone-prose.js';
 import { Direction } from '../types/shared/direction-enum.js';
-import { isOpenGround, isVoid, roomAtCell, streetDoors } from './district-plane.js';
+import { isOpenGround, isVoid, roomAtCell, streetDoors, worldCell } from './district-plane.js';
 import { isOutdoorsPlace } from './outdoors.js';
 import { wayOut } from './ways-out.js';
 import { significantWords, wordsAreCloseEnough } from './fuzzy-match.js';
@@ -889,11 +889,24 @@ export function stepFrom(room, mover, direction, count) {
     const openOutside = openGroundBeyond(room);
     const furniture = furnitureCells(room);
     const bodies = standingOccupants(room, mover);
+    // A BARRIER SPELL is its own word (barrier-geometry.ts): it is drawn,
+    // it shimmers, and "the way is blocked" would hide whose working it is.
+    // Asked on the plane, so it stops a step off an outdoor room's edge too.
+    const scenePlane = room.scene?.spellBarriers?.('physical').length ? room.scene.ensurePlane() : undefined;
+    const barrierHere = (local) => {
+        if (!scenePlane || !room.scene)
+            return undefined;
+        const world = worldCell(scenePlane, room.name, local);
+        return world ? room.scene.barrierAt(world, 'physical')?.barrier.caster : undefined;
+    };
     let cur = start;
     let taken = 0;
     for (let i = 0; i < count; i++) {
         const next = { x: cur.x + step[0], y: cur.y + step[1], z: cur.z };
         const k = key(next);
+        const walledBy = barrierHere(next);
+        if (walledBy !== undefined)
+            return { cell: cur, taken, blockedBy: 'barrier', blocker: walledBy };
         if (!standable.has(k)) {
             const inBounds = next.x >= 0 && next.y >= 0 && next.x < grid.dims.x && next.y < grid.dims.y;
             // Off the edge of an OUTDOOR room is just more street, unless the
@@ -2526,7 +2539,10 @@ export function describeSpotRoster(room, viewer) {
  * district, and the room it happens to be over is a label the caller
  * re-derives.
  */
-export function astralStepFrom(plane, from, direction, count, roomAt) {
+export function astralStepFrom(plane, from, direction, count, roomAt, 
+/** Whose MANA BARRIER stands on a cell, if any (Scene.barrierAt --
+ *  the creator's own weave already excluded, p.315). */
+manaBarrierAt) {
     /**
      * UP AND DOWN ARE DIRECTIONS OUT HERE (p.313-314: an astral form
      * "can move in any direction" and is "not limited by gravity").
@@ -2564,6 +2580,12 @@ export function astralStepFrom(plane, from, direction, count, roomAt) {
         if (here !== there) {
             return { cell: cur, taken, blockedBy: 'ward', ward: (there ?? here)?.name };
         }
+        // A MANA BARRIER SPELL: "solid, hazily opaque walls that stop astral
+        // movement" (p.315-316). `go` always refused one; a `move` drift
+        // used to float straight through it, because this walk never asked.
+        const weaver = manaBarrierAt?.(next);
+        if (weaver !== undefined)
+            return { cell: cur, taken, blockedBy: 'barrier', ward: weaver };
         cur = next;
         taken++;
     }

package/bundle/typescript/src/commands/game/sideQuest/utilities/ways-out.js

@@ -71,7 +71,7 @@ export function wayOut(room, direction, from) {
  * (map-view.ts serializePlane); here a street keeps only what the plane
  * could not place.
  */
-export function roomGridWire(room) {
+export function roomGridWire(room, viewer) {
     const grid = room.ensureGrid();
     if (!grid)
         return undefined;
@@ -83,9 +83,41 @@ export function roomGridWire(room) {
                 damage: cam.damage, structure: cam.structure, destroyed: cam.destroyed,
             }] : [];
     });
-    const wire = cameras.length > 0 ? { ...base, cameras } : base;
+    const withCams = cameras.length > 0 ? { ...base, cameras } : base;
+    const barriers = barriersWire(room, viewer);
+    const wire = barriers.length > 0 ? { ...withCams, barriers } : withCams;
     if (!isOutdoorsPlace(room))
         return wire;
     return { ...wire, doors: wire.doors.filter(d => wayOut(room, d.dir)?.kind === 'grid') };
 }
+/**
+ * The barrier spells a viewer can see around this room, in its local
+ * cells: every standing Physical Barrier with a cell within one of the
+ * footprint (its wall ring included), and a Mana Barrier only for its
+ * weaver or an eye on the astral (p.294: "invisible to the physical
+ * plane"). Breached faces ride along marked, so a client can draw the
+ * gap rather than lose the face.
+ */
+export function barriersWire(room, viewer) {
+    const scene = room.scene;
+    const all = scene?.spellBarriers?.() ?? [];
+    if (!scene || all.length === 0)
+        return [];
+    const frame = scene.ensurePlane().placements.get(roomKey(room.name));
+    if (!frame)
+        return [];
+    const seesAstral = !!viewer && (viewer.plane === 'astral' || viewer.astralPerceiving);
+    const near = (c) => c.x >= frame.origin.x - 1 && c.x <= frame.origin.x + frame.dims.x
+        && c.y >= frame.origin.y - 1 && c.y <= frame.origin.y + frame.dims.y;
+    return all
+        .filter(b => b.kind === 'physical' || seesAstral || b.caster === viewer?.name)
+        .filter(b => b.faces.some(f => f.cells.some(near)))
+        .map(b => ({
+        kind: b.kind, caster: b.caster, shape: b.shape, force: b.force, structure: b.structure,
+        faces: b.faces.map(f => ({
+            id: f.id, damage: f.damage, breached: f.breached,
+            cells: f.cells.map(c => ({ x: c.x - frame.origin.x, y: c.y - frame.origin.y, z: c.z - frame.origin.z })),
+        })),
+    }));
+}
 //# sourceMappingURL=ways-out.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@maka/maka-cli",
-  "version": "5.383.0",
+  "version": "5.385.0",
   "type": "module",
   "summary": "A command line tool for scaffolding Meteor 3.x applications using either React.",
   "description": "A command line tool for scaffolding Meteor 3.x applications using React.",