@maka/maka-cli 5.384.0 → 5.385.0

package/bundle/typescript/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@maka/maka-cli",
-  "version": "5.384.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.",

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

@@ -7,9 +7,9 @@ import { fuzzyPickName } from '../utilities/fuzzy-match.js';
 import { describeFledTarget } from '../utilities/pursuit.js';
 import { crossPlaneRefusal } from '../utilities/planes.js';
 import { spotOf, ensureAtSpot, furnitureCells, standingOccupants } from '../utilities/spots.js';
-import { key as gridKey } from '../utilities/room-grid.js';
+import { key as gridKey, METERS_PER_CELL } from '../utilities/room-grid.js';
 import { isSolid, isVoid, roomAtCell, wallsBetween } from '../utilities/district-plane.js';
-import { buildBarrier, clipFaces, formatCoord, isCoordToken, parseCoord, planDirectionalWall, planDome, planWall } from '../utilities/barrier-geometry.js';
+import { DIRECTIONAL_WALL_FORCE, DOME_FORCE, forceForWall, buildBarrier, clipFaces, formatCoord, isCoordToken, parseCoord, planDirectionalWall, planDome, planWall } from '../utilities/barrier-geometry.js';
 import { NPC } from '../models/npc.js';
 import { spellFor, catalogSpells } from '../utilities/catalog.js';
 import { getAspect } from '../aspects.js';
@@ -307,6 +307,7 @@ export class CastCommand extends BypassCommand {
         const spellDef = spellFor(spellName);
         const safeForce = this.actor.magic > 0 ? this.actor.magic : 4;
         let force = Math.max(1, -(spellDef?.drainOffset ?? -3));
+        let forceGiven = true;
         if (rest[0]?.toLowerCase() === 'force' && /^\d+$/.test(rest[1] ?? '')) {
             force = parseInt(rest[1], 10);
             rest = rest.slice(2);
@@ -315,6 +316,9 @@ export class CastCommand extends BypassCommand {
             force = parseInt(rest[0], 10);
             rest = rest.slice(1);
         }
+        else {
+            forceGiven = false;
+        }
         if (force < 1) {
             return `Force below 1 isn't a spell, it's a wish.`;
         }
@@ -335,7 +339,7 @@ export class CastCommand extends BypassCommand {
             case 'heal': return this.castHeal(force, overcast, rest);
             case 'armor': return this.castArmor(force, overcast, rest);
             case 'sustained-utility': return this.castSustainedUtility(spellName, force, overcast, rest);
-            case 'barrier': return this.castBarrier(spellName, force, overcast, rest);
+            case 'barrier': return this.castBarrier(spellName, force, overcast, rest, forceGiven ? undefined : safeForce);
         }
     }
     /**
@@ -980,7 +984,8 @@ export class CastCommand extends BypassCommand {
      *   cast barrier [F] <x,y[,z]> <x,y[,z]>   a wall between two points
      *   cast barrier [F] <x,y[,z]>             a dome around one point
      *   cast barrier [F] <direction> [n]       a 1x3 wall n cells that way
-     *   cast barrier [F] at <someone>          a dome around them
+     *   cast barrier [F] at <someone> [size]   a dome around them ("me"/"self": you);
+   *                                          size = radius in cells = Force / 2
      *   cast barrier [F]                       a dome around yourself
      *   cast barrier off                       let it go (free)
      *
@@ -993,7 +998,9 @@ export class CastCommand extends BypassCommand {
      * Bare "cast north" no longer reaches a ward from here -- that is
      * "dispel north" (user ruling 2026-10-05).
      */
-    async castBarrier(spellKey, force, overcast, rest) {
+    async castBarrier(spellKey, force, overcast, rest, 
+    /** Set when no Force was named: the talent a sized cast may reach. */
+    autoUpTo) {
         const actor = this.actor;
         const mana = spellKey === 'manabarrier';
         const kind = mana ? 'mana' : 'physical';
@@ -1028,11 +1035,12 @@ export class CastCommand extends BypassCommand {
         let plan;
         let around;
         let center;
-        const usage = `"cast ${spellKey} [force] <x,y> <x,y>" (a wall), "cast ${spellKey} [force] <x,y>" (a dome), "cast ${spellKey} [force] <direction> [cells]", or "cast ${spellKey} at <someone>". The map rulers give x and y; you're at ${formatCoord(from)}.`;
+        const usage = `"cast ${spellKey} [force] <x,y> <x,y>" (a wall), "cast ${spellKey} [force] <x,y>" (a dome), "cast ${spellKey} [force] <direction> [cells]", or "cast ${spellKey} at <someone|me> [radius in cells]". Leave the Force off and it is sized for you. The map rulers give x and y; you're at ${formatCoord(from)}.`;
         const unseen = (what) => `You can't see ${what} from here -- a barrier is cast at what you can see (LOS, p.294).`;
         if (words.length === 0) {
             center = from;
             around = 'you';
+            force = this.domeForce(force, autoUpTo);
             plan = planDome(from, force);
         }
         else if (isCoordToken(words[0])) {
@@ -1041,6 +1049,10 @@ export class CastCommand extends BypassCommand {
             const a = parseCoord(words[0], from.z);
             if (words.length === 2) {
                 const b = parseCoord(words[1], from.z);
+                const sized = this.sizeForce(spellKey, force, forceForWall(a, b), autoUpTo);
+                if (typeof sized === 'string')
+                    return sized;
+                force = sized;
                 plan = planWall(a, b, force);
                 if (plan.error)
                     return plan.error;
@@ -1050,6 +1062,7 @@ export class CastCommand extends BypassCommand {
             }
             else {
                 center = a;
+                force = this.domeForce(force, autoUpTo);
                 plan = planDome(a, force);
                 if (!this.inSight(plane, from, a))
                     return unseen(formatCoord(a));
@@ -1060,6 +1073,10 @@ export class CastCommand extends BypassCommand {
                 return `"cast ${spellKey} ${words[0]} [cells]" -- the distance is a whole number of cells.`;
             }
             const distance = words.length === 2 ? parseInt(words[1], 10) : 1;
+            const sized = this.sizeForce(spellKey, force, DIRECTIONAL_WALL_FORCE, autoUpTo);
+            if (typeof sized === 'string')
+                return sized;
+            force = sized;
             plan = planDirectionalWall(from, words[0].toLowerCase(), distance, force);
             if (plan.error)
                 return plan.error;
@@ -1070,12 +1087,22 @@ export class CastCommand extends BypassCommand {
         }
         else {
             const lead = words[0].toLowerCase();
-            const nameWords = lead === 'at' || lead === 'on' || lead === 'around' ? words.slice(1) : words;
+            let nameWords = lead === 'at' || lead === 'on' || lead === 'around' ? words.slice(1) : words;
+            // "at <someone> [size]" (user 2026-10-05): a trailing number is the
+            // dome's RADIUS in map cells. p.294 makes the radius the Force in
+            // metres, so the size IS a Force -- two cells is Force 4.
+            let size;
+            if (nameWords.length > 1 && /^\d+$/.test(nameWords[nameWords.length - 1])) {
+                size = parseInt(nameWords[nameWords.length - 1], 10);
+                nameWords = nameWords.slice(0, -1);
+            }
             if (nameWords.length === 0)
                 return usage;
+            // "me" / "self" / "myself" are the caster (user 2026-10-05).
+            const selfWord = nameWords.length === 1 && /^(me|self|myself|yourself)$/i.test(nameWords[0]);
             const candidates = this.scene.getActorsInRoom(room).filter(a => a === actor || ((a.plane === 'meat' || a.plane === actor.plane) && actor.canPerceive(a)));
-            const picked = fuzzyPickName(nameWords.join(' '), candidates.map(a => a.name));
-            const target = picked ? candidates.find(a => a.name === picked) : undefined;
+            const picked = selfWord ? actor.name : fuzzyPickName(nameWords.join(' '), candidates.map(a => a.name));
+            const target = selfWord ? actor : picked ? candidates.find(a => a.name === picked) : undefined;
             if (!target)
                 return `You don't see "${nameWords.join(' ')}" here. ${usage}`;
             const at = this.scene.worldCellOf?.(target);
@@ -1085,6 +1112,21 @@ export class CastCommand extends BypassCommand {
                 return unseen(target.name);
             center = at;
             around = target === actor ? 'you' : target.name;
+            if (size !== undefined) {
+                if (size < 1)
+                    return `A dome's size is its radius in cells, 1 or more.`;
+                const needed = Math.ceil(size * METERS_PER_CELL);
+                if (autoUpTo === undefined && needed !== force) {
+                    return `A dome's radius IS its Force in metres (p.294): ${size} cell${size === 1 ? '' : 's'} is Force ${needed}, not ${force}. Name one or the other.`;
+                }
+                const sized = this.sizeForce(spellKey, force, needed, autoUpTo, 'dome');
+                if (typeof sized === 'string')
+                    return sized;
+                force = sized;
+            }
+            else {
+                force = this.domeForce(force, autoUpTo);
+            }
             plan = planDome(at, force);
         }
         if (plan.error)
@@ -1156,6 +1198,32 @@ export class CastCommand extends BypassCommand {
         lines.push(...await this.drainCollapse(new CombatExchange(this.scene, this.logger, this.actor)));
         return this.finishSpell(lines);
     }
+    /**
+     * NO FORCE NAMED: SIZE IT TO THE SHAPE (user 2026-10-05). A wall gets
+     * the least Force that raises it -- never less than the default, and
+     * never past your talent: overcasting turns the drain PHYSICAL (p.281),
+     * and that is a choice to make out loud, not one made for you.
+     */
+    sizeForce(spellKey, force, needed, autoUpTo, what = 'wall') {
+        // A wall only ever grows to fit; a sized dome IS its size.
+        if (autoUpTo === undefined || (what === 'wall' && needed <= force))
+            return force;
+        if (needed > autoUpTo) {
+            return `That ${what} needs Force ${needed}, past your talent (${autoUpTo}) -- name the Force to overcast it on purpose ("cast ${spellKey} ${needed} ..."; the drain lands PHYSICAL, p.281).`;
+        }
+        return needed;
+    }
+    /**
+     * A DOME WITH NO FORCE NAMED stands one storey: Force 3, a dome 3 m
+     * high (p.294: height = radius = Force m). Anything lower would not
+     * cover the person it is raised around. Never past your talent -- a
+     * caster with less Magic gets the tallest dome they can hold safely.
+     */
+    domeForce(force, autoUpTo) {
+        if (autoUpTo === undefined)
+            return force;
+        return Math.max(force, Math.min(DOME_FORCE, autoUpTo));
+    }
     /** LINE OF SIGHT for an area spell's point (p.281): no wall between. */
     inSight(plane, from, to) {
         return wallsBetween(plane, from, to) === 0;

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

@@ -177,9 +177,9 @@ 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 [F] <x,y> <x,y> (wall) | <x,y> (dome) | <direction> [cells] | at <someone> | (bare: a dome round you); cast barrier off',
+            { key: 'barrier', cast: 'barrier', how: 'cast barrier [F] <x,y> <x,y> (wall) | <x,y> (dome) | <direction> [cells] | at <someone|me> [radius] | (bare: a dome round you); Force optional -- sized to fit; 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',
+            { key: 'manabarrier', cast: 'manabarrier', how: 'cast manabarrier [F] <x,y> <x,y> | <x,y> | <direction> [cells] | at <someone|me> [radius]; 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) {

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

@@ -3355,5 +3355,14 @@
 // - 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';
+// 1.197.0 (2026-10-05): BARRIERS SIZE THEMSELVES. With no Force named, a
+//   wall is cast at the least Force that raises it (a cell of length per
+//   Force, Force 3 a level), the directional wall at Force 3, and a dome
+//   at Force 3 (one storey) -- never past the caster's talent; an
+//   overcast must be named. `cast barrier [F] at <someone> [size]` takes
+//   a radius in cells (size x 2 = Force; a Force and size that disagree
+//   are refused), and "me"/"self" name the caster.
+//   The HUD's sustained line and `spells` show the barrier's Armor,
+//   Structure and every face's damage track.
+export const ENGINE_VERSION = '1.197.0';
 //# sourceMappingURL=engine-version.js.map

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

@@ -149,7 +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 { barrierSpan, barrierStats } from './utilities/barrier-geometry.js';
 import { FollowCommand, UnfollowCommand } from './commands/follow.js';
 import { BringCommand } from './commands/bring.js';
 import { SurrenderCommand } from './commands/surrender.js';
@@ -9478,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.shape} ${barrierSpan(player.sustainedBarrier)}, ${player.sustainedBarrier.roomName})`);
+            heldSpells.push(`physical barrier (${player.sustainedBarrier.shape} ${barrierSpan(player.sustainedBarrier)}, ${player.sustainedBarrier.roomName}; ${barrierStats(player.sustainedBarrier)})`);
         }
         if (player.sustainedManaBarrier) {
-            heldSpells.push(`mana barrier (${player.sustainedManaBarrier.shape} ${barrierSpan(player.sustainedManaBarrier)}, ${player.sustainedManaBarrier.roomName})`);
+            heldSpells.push(`mana barrier (${player.sustainedManaBarrier.shape} ${barrierSpan(player.sustainedManaBarrier)}, ${player.sustainedManaBarrier.roomName}; ${barrierStats(player.sustainedManaBarrier)})`);
         }
         // What this character holds on OTHERS -- the caster's burden, named
         // by bearer so the mage knows whose armor is costing them two dice.

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

@@ -22,6 +22,21 @@ export function maxWallCells(force) {
 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
@@ -191,10 +206,19 @@ export function barrierSpan(barrier) {
 }
 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 `a ${barrier.shape} over ${span} in ${barrier.roomName}, Force ${barrier.force}, Armor/Structure ${barrier.structure} [${tracks}]`;
+    return `Armor ${barrier.armor}, Structure ${barrier.structure} [${tracks}]`;
 }
 export function allBreached(barrier) {
     return barrier.faces.every(f => f.breached);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@maka/maka-cli",
-  "version": "5.384.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.",