@maka/maka-cli 5.385.0 → 5.388.0

package/bundle/typescript/package.json

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

@@ -2,14 +2,14 @@ import { sustainBurden } from '../utilities/sustaining.js';
 import { BypassCommand } from './bypass-command.js';
 import { hint } from '../utilities/hints.js';
 import { CombatExchange } from '../utilities/combat-exchange.js';
-import { rollPool, formatRoll } from '../utilities/dice.js';
+import { rollPool, formatRoll, rollD6Total } from '../utilities/dice.js';
 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, METERS_PER_CELL } from '../utilities/room-grid.js';
+import { spotOf, ensureAtSpot, furnitureCells, standingOccupants, visibleActorsIn, concealedFrom } from '../utilities/spots.js';
+import { key as gridKey, METERS_PER_CELL, distanceMeters, line3D } from '../utilities/room-grid.js';
 import { isSolid, isVoid, roomAtCell, wallsBetween } from '../utilities/district-plane.js';
-import { DIRECTIONAL_WALL_FORCE, DOME_FORCE, forceForWall, 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, FACE_LABEL, BARRIER_FOG, allBreached, damageFace, pierces } from '../utilities/barrier-geometry.js';
 import { NPC } from '../models/npc.js';
 import { spellFor, catalogSpells } from '../utilities/catalog.js';
 import { getAspect } from '../aspects.js';
@@ -91,14 +91,21 @@ const COMBAT_SPELL_FLAVOR = {
  * inherited from BypassCommand -- now gated on actually having magic gear,
  * instead of being a free-floating coin flip anyone could attempt.
  */
+/**
+ * BLIND FIRE (p.178): "the same as the Total Darkness modifier", -6 -- the
+ * number p.197 gives for a target completely hidden from the attacker.
+ */
+const BLIND_FIRE = -6;
 export class CastCommand extends BypassCommand {
     static verb = 'cast';
     /** Touches another actor: authorized per-act for AI-driven actors
      *  (utilities/npc-authorization.ts, aCErAfvEW7G23FWDM). */
     static npcPolicy = 'authorized';
-    static description = 'Cast a spell you know, at a FORCE you choose: "cast manabolt 8 at <target>" (default Force = your Magic; drain scales with it, and OVERCASTING past your talent makes the drain PHYSICAL). "spells" lists what you know. Barriers take map coordinates: "cast barrier 3 3,4 3,6" (a wall), "cast barrier 3 5,5" (a dome), "cast barrier east 2". A ward is "dispel <direction>".';
+    static description = 'Cast a spell you know, at a FORCE you choose: "cast manabolt 8 at <target>" (default Force = your Magic; drain scales with it, and OVERCASTING past your talent makes the drain PHYSICAL). "spells" lists what you know. Barriers take map coordinates: "cast barrier 3 3,4 3,6" (a wall), "cast barrier 3 5,5" (a dome), "cast barrier east 2". Area spells too: "cast fireball 4 at 12,7" (a point) or "cast fireball 4 at <someone>" -- Force m around it, friend and foe. A ward is "dispel <direction>".';
     deviceKind = 'ward';
     verbName = 'cast';
+    /** The bolt in flight is at someone the caster cannot see (castCombatSpell). */
+    unseenTarget = false;
     noDeviceMessage = "There's nothing here to cast at.";
     /** Backlash drain when a ward-bypass fails -- resisted with Willpower,
      * like any drain. The nastiest drain in the game: forcing a hostile
@@ -335,7 +342,10 @@ export class CastCommand extends BypassCommand {
         if (!def)
             return `You don't know "${spellName}".`;
         switch (def.cast) {
-            case 'combat': return this.castCombatSpell(spellName, force, overcast, rest);
+            // An AREA combat spell is aimed at a point (castAreaSpell); a bolt at a person.
+            case 'combat': return def.area
+                ? this.castAreaSpell(spellName, force, overcast, rest)
+                : this.castCombatSpell(spellName, force, overcast, rest);
             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);
@@ -479,6 +489,101 @@ export class CastCommand extends BypassCommand {
         }
         return [];
     }
+    /**
+     * ONE COMBAT SPELL'S NUMBERS AGAINST ONE TARGET, canon (SR5 p.283,
+     * RAG-checked 2026-10-05; user ruling: "fix all of it now").
+     *
+     *  - DIRECT (soak 'willpower' / 'body': manabolt, stunball, powerball):
+     *    the target opposes the casting test with Willpower (mana) or Body
+     *    (physical), plus Magic Resistance (p.76). The damage is the NET
+     *    HITS, and nothing soaks it -- "the target does not get to resist
+     *    the damage, only the Spellcasting test".
+     *  - INDIRECT (soak 'armor': fireball, clout, blast): dodged like a
+     *    bullet with Reaction + Intuition; DV is Force + net hits, AP is
+     *    -Force, resisted with Body + Armor.
+     *
+     * This replaced F-2 + net hits soaked by Willpower/Body for the direct
+     * family and AP floor(F/3) for the indirect one.
+     *
+     * A MANA BARRIER between caster and target (p.316) adds its Force to
+     * the defence (direct) or the resistance (indirect) pool.
+     */
+    spellStrikeProfile(spell, spellKey, force, overcast, target, extraResist = 0) {
+        const label = (ap) => `with a Force ${force} ${spellKey}${overcast ? ' (OVERCAST)' : ''}, ${this.castingLabel()}${ap !== 0 ? ` (AP -${ap})` : ''}`;
+        const weave = this.manaBarrierBetween(target);
+        const through = (weave ?? 0) + extraResist;
+        if (spell.soak !== 'armor') {
+            const resist = (spell.soak === 'willpower' ? target.willpower : target.body) + target.qualityRating('magic-resistance');
+            return {
+                label: label(0) + (weave ? ` -- through a Force ${weave} mana barrier` : ''),
+                pool: this.actor.getMagicPool() + this.actor.consumeEdgeBoost(),
+                damageBase: 0,
+                soakPool: 0,
+                defensePool: resist + through,
+                dealStun: spell.stun,
+                isSpell: true,
+                limit: force,
+            };
+        }
+        const armor = target.plane === 'meat' ? target.getArmorValue() : 0;
+        const modifiedArmor = Math.max(0, armor - force);
+        const blind = this.unseenTarget ? BLIND_FIRE : 0;
+        return {
+            label: label(force) + (weave ? ` -- through a Force ${weave} mana barrier` : '') + (blind ? ` -- thrown BLIND (${blind}, p.178)` : ''),
+            pool: Math.max(0, this.actor.getMagicPool() + this.actor.consumeEdgeBoost() + blind),
+            damageBase: force,
+            soakPool: Math.max(0, target.getSoakPool() - armor + modifiedArmor) + through,
+            modifiedArmor: target.plane === 'meat' ? modifiedArmor : undefined,
+            dealStun: spell.stun,
+            isSpell: true,
+            limit: force,
+        };
+    }
+    /** The Force of a MANA BARRIER (not the caster's own) standing between
+     *  the caster and someone -- what a spell has to get through (p.316). */
+    manaBarrierBetween(target) {
+        const from = this.scene.worldCellOf?.(this.actor);
+        const to = this.scene.worldCellOf?.(target);
+        if (!from || !to)
+            return undefined;
+        const hit = this.scene.barrierOnLine?.(from, to, 'mana');
+        return hit && hit.barrier.caster !== this.actor.name ? hit.barrier.force : undefined;
+    }
+    /**
+     * AN INDIRECT SPELL IS A THING THAT FLIES (p.283: "a clear line of
+     * fire"), and a Physical Barrier stops it: the bolt hits the wall
+     * instead. Direct spells pass -- the barrier "does not impede
+     * spellcasting" save for indirect ones (p.294). The face takes the
+     * spell's DV (Force + hits, combat spells unchanged against barriers,
+     * p.197) if it beats the Armor.
+     */
+    indirectWallBetween(from, to) {
+        if (!from || !to)
+            return undefined;
+        return this.scene.barrierOnLine?.(from, to, 'physical');
+    }
+    strikeWall(wall, force, spellKey, rolledHits) {
+        const { barrier, face } = wall;
+        // A barrier does not dodge (p.197): the casting test is unopposed
+        // and its hits add to the DV.
+        const hits = rolledHits ?? rollPool(this.actor.getMagicPool(), force).hits;
+        const dv = force + hits;
+        if (!pierces(dv, barrier.armor, 0)) {
+            return [`  The ${spellKey} breaks against ${barrier.caster}'s shimmer-wall -- DV ${dv} against Armor ${barrier.armor} (p.197); nothing gets past it.`];
+        }
+        const soak = rollPool(barrier.structure + barrier.armor);
+        const dealt = Math.max(0, dv - soak.hits);
+        const breached = damageFace(barrier, face, dealt);
+        const out = [`  The ${spellKey} slams into ${barrier.caster}'s barrier instead -- ${dealt} box${dealt === 1 ? '' : 'es'} to ${FACE_LABEL[face.id]} (${face.breached ? 'BREACHED' : `${face.damage}/${barrier.structure}`}).`];
+        if (breached && allBreached(barrier)) {
+            const caster = this.scene.getPlayers().find(p => p.name === barrier.caster);
+            if (caster)
+                caster.sustainedBarrier = undefined;
+            out.push(`  The barrier comes down entirely -- ${barrier.caster}'s spell is over (p.294).`);
+        }
+        this.scene.updateExits?.(this.actor.currentLocation);
+        return out;
+    }
     /**
      * The shared combat-spell engine (manabolt/stunbolt/powerbolt/
      * fireball): one exchange flow, parameterized by what SOAKS the hit
@@ -526,6 +631,16 @@ export class CastCommand extends BypassCommand {
         if (target.isIncapacitated()) {
             return `${target.name} is already down. The fight is over.`;
         }
+        // LINE OF SIGHT (p.281, p.283). Seeing them is the one question
+        // visibleActorsIn answers for the map and `look`: on a plane you
+        // perceive and not hidden in cover. A DIRECT spell needs it -- it
+        // reaches through your own sight, with nothing to aim but that. An
+        // INDIRECT one only needs "a clear line of fire": you can throw it
+        // blind, at the Blind Fire penalty (p.178; -6, p.197).
+        this.unseenTarget = !visibleActorsIn(room, this.actor).includes(target);
+        if (this.unseenTarget && spellFor(spellKey)?.soak !== 'armor') {
+            return `You can't see ${target.name} -- a ${spellKey} reaches through your own eyes, and they have nothing to fix on (LOS, p.281).${hint(' (An indirect spell can be thrown blind, at -6.)')}`;
+        }
         // One exchange at a time per combatant, same as attack.ts: the player
         // is refused cleanly, an NPC caster waits out the exchange and re-runs
         // (see CombatExchange.waitForLull and the rationale in attack.ts).
@@ -609,55 +724,28 @@ export class CastCommand extends BypassCommand {
                 if (defender.isIncapacitated())
                     break;
                 if (striker === this.actor) {
-                    // ---- The spell: casting pool vs defense, soaked per its type
-                    // (direct mana = Willpower; direct physical = Body; indirect
-                    // elemental = the full soak pool minus AP floor(F/3)). The
-                    // FORCE dial sets the damage: bolts hit at F-2, the elemental
-                    // hits at full F for letting armor matter. ----
-                    const spellAp = spell.soak === 'armor' ? Math.floor(force / 3) : 0;
-                    const armorEaten = spellAp > 0
-                        ? Math.min(spellAp, target.plane === 'meat' ? target.getArmorValue() : 0)
-                        : 0;
-                    // MAGIC RESISTANCE (p.76): +1 die per rating on the Spell
-                    // Resistance test -- the Willpower or Body roll a mana or
-                    // physical spell is resisted with. Not on the armor soak of an
-                    // elemental effect, which is damage resistance, not spell.
-                    const magicResistance = spell.soak === 'armor' ? 0 : target.qualityRating('magic-resistance');
-                    const soakPool = (spell.soak === 'willpower' ? target.willpower
-                        : spell.soak === 'body' ? target.body
-                            : Math.max(0, target.getSoakPool() - armorEaten)) + magicResistance;
-                    const damageBase = spell.soak === 'armor' ? force : Math.max(1, force - 2);
-                    const strike = exchange.resolveStrike(this.actor, target, {
-                        label: `with a Force ${force} ${spellKey}${overcast ? ' (OVERCAST)' : ''}, ${this.castingLabel()}${armorEaten > 0 ? ` (AP -${armorEaten})` : ''}`,
-                        // An armed edge boost (see edge.ts) supercharges the bolt.
-                        pool: this.actor.getMagicPool() + this.actor.consumeEdgeBoost(),
-                        damageBase,
-                        soakPool,
-                        dealStun: spell.stun,
-                        // Lets an Awakened defender's counterspelling answer it.
-                        isSpell: true,
-                        // Spellcasting + Magic [FORCE] (p.281): the Force you chose
-                        // is the ceiling on the hits it can buy. Overcasting for
-                        // reach costs drain AND raises this cap, which is the whole
-                        // shape of the Force dial -- without it, a Force 1 bolt
-                        // could land as hard as a Force 8 one on a lucky roll.
-                        limit: force,
-                    });
-                    report.push('', ...strike.world, ...strike.meta);
-                    await exchange.announce(strike.world, strike.meta);
+                    // ---- The spell, canon (spellStrikeProfile, p.283): direct is
+                    // opposed by Willpower/Body and does its net hits; indirect is
+                    // dodged, Force + net hits at AP -Force, soaked by Body + Armor.
+                    // An indirect bolt meets a Physical Barrier first. ----
+                    const wall = spell.soak === 'armor'
+                        ? this.indirectWallBetween(this.scene.worldCellOf?.(this.actor), this.scene.worldCellOf?.(target))
+                        : undefined;
+                    if (wall) {
+                        const hit = this.strikeWall(wall, force, spellKey);
+                        report.push('', ...hit);
+                        await exchange.announce(hit);
+                    }
+                    else {
+                        const strike = exchange.resolveStrike(this.actor, target, this.spellStrikeProfile(spell, spellKey, force, overcast, target));
+                        report.push('', ...strike.world, ...strike.meta);
+                        await exchange.announce(strike.world, strike.meta);
+                    }
                     if (target.isDown()) {
                         report.push(...await exchange.resolveDeath(target, this.actor, {
                             fallLine: `${target.name} ${flavor.fall} Their gear scatters across ${room.name}.`,
                         }));
                     }
-                    // AREA (p.284): the blast doesn't stop at the person you aimed
-                    // at. Everyone else hostile in the room resists the same
-                    // damage with the same soak -- no defense roll, there's nothing
-                    // to dodge -- and anyone it drops falls here too.
-                    if (spell.area) {
-                        const splash = await this.splashArea(exchange, spellKey, spell, force, target, damageBase, spellAp);
-                        report.push(...splash);
-                    }
                     // Drain comes due the moment the bolt flies, kill or not.
                     const drain = this.applyDrain(spell, force, overcast);
                     report.push('', ...drain);
@@ -769,27 +857,21 @@ export class CastCommand extends BypassCommand {
         target.combatOpponent = target.combatOpponent ?? actor;
         target.lastExchangeAt = now;
         actor.surrendered = false;
-        // The spell's own numbers -- identical to the exchange path below.
-        const spellAp = spell.soak === 'armor' ? Math.floor(force / 3) : 0;
-        const armorEaten = spellAp > 0
-            ? Math.min(spellAp, target.plane === 'meat' ? target.getArmorValue() : 0)
-            : 0;
-        const magicResistance = spell.soak === 'armor' ? 0 : target.qualityRating('magic-resistance');
-        const soakPool = (spell.soak === 'willpower' ? target.willpower
-            : spell.soak === 'body' ? target.body
-                : Math.max(0, target.getSoakPool() - armorEaten)) + magicResistance;
-        const damageBase = spell.soak === 'armor' ? force : Math.max(1, force - 2);
-        const strike = exchange.resolveStrike(actor, target, {
-            label: `with a Force ${force} ${spellKey}${overcast ? ' (OVERCAST)' : ''}, ${this.castingLabel()}${armorEaten > 0 ? ` (AP -${armorEaten})` : ''}`,
-            pool: actor.getMagicPool() + actor.consumeEdgeBoost(),
-            damageBase,
-            soakPool,
-            dealStun: spell.stun,
-            isSpell: true,
-            limit: force,
-        });
-        report.push('', ...strike.world, ...strike.meta);
-        await exchange.announce(strike.world, strike.meta);
+        // The spell's own numbers -- identical to the exchange path above
+        // (spellStrikeProfile), and an indirect bolt meets a barrier first.
+        const wall = spell.soak === 'armor'
+            ? this.indirectWallBetween(this.scene.worldCellOf?.(actor), this.scene.worldCellOf?.(target))
+            : undefined;
+        if (wall) {
+            const hit = this.strikeWall(wall, force, spellKey);
+            report.push('', ...hit);
+            await exchange.announce(hit);
+        }
+        else {
+            const strike = exchange.resolveStrike(actor, target, this.spellStrikeProfile(spell, spellKey, force, overcast, target));
+            report.push('', ...strike.world, ...strike.meta);
+            await exchange.announce(strike.world, strike.meta);
+        }
         enc.syncWounds();
         if (target.isDown()) {
             report.push(...await exchange.resolveDeath(target, actor, {
@@ -804,10 +886,6 @@ export class CastCommand extends BypassCommand {
                     fallLine: `${target.name} sags and drops -- out cold, breathing. Their gear scatters across ${room.name}.`,
                 })));
         }
-        if (spell.area) {
-            report.push(...await this.splashArea(exchange, spellKey, spell, force, target, damageBase, spellAp));
-            enc.syncWounds();
-        }
         const drain = this.applyDrain(spell, force, overcast);
         report.push('', ...drain);
         await exchange.announce(drain);
@@ -818,61 +896,261 @@ export class CastCommand extends BypassCommand {
         return human ? phaseHint(this.scene, actor).trim() : report.join('\n');
     }
     /**
-     * The rest of the room, for an AREA spell: every other hostile takes
-     * the same damage, resisted with the same soak the primary target
-     * used (minus the spell's AP against armor-soaked elementals). No
-     * attack roll and no defense roll -- a blast doesn't aim and can't be
-     * dodged; the drain the ball spells charge is what pays for it.
+     * AN AREA COMBAT SPELL, CAST AT A POINT (SR5 p.281-284; RAG-checked
+     * 2026-10-05; user spec: "cast at a coordinate").
+     *
+     *   cast <ball> [F] at <x,y[,z]>     the point, in the map rulers' numbers
+     *   cast <ball> [F] at <someone>     the cell they stand in
+     *
+     * "Area spells can be cast on a specific target or a point in space that
+     * you can see ... a sphere centered on the target with a radius in
+     * meters equal to the Force" (p.281). "All targets in the area of effect
+     * that you can see, friend and foe alike, are valid targets" -- the
+     * caster included when they stand in it (user ruling 2026-10-05). This
+     * replaced "everyone hostile in the room, allies spared".
+     *
+     *  - DIRECT balls (manaball, stunball, powerball): ONE casting test,
+     *    opposed by each target's Willpower/Body (+ counterspelling, Magic
+     *    Resistance, a mana barrier's Force); each takes their own net hits.
+     *    Only targets the caster can SEE are touched (p.281).
+     *  - INDIRECT balls (fireball, ball lightning, toxic wave, blast) fly
+     *    and go boom like a grenade (p.283, p.181): Spellcasting + Magic
+     *    [Force] (3). Beat the threshold and it lands where you aimed, its
+     *    net hits on the DV; miss and it SCATTERS 2D6 m, less a metre per
+     *    hit. DV is Force (+ net hits), AP -Force, soaked with Body + Armor
+     *    by everyone the blast reaches -- no dodge. A Physical Barrier in
+     *    its path is where it goes off.
+     *
+     * The area is measured on the district PLANE, so it does not stop at a
+     * room's edge; walls stop the blast and the caster's sight.
      */
-    async splashArea(exchange, spellKey, spell, force, primary, damageBase, spellAp) {
-        const room = this.actor.currentLocation;
-        // Who the blast catches: everyone else standing on this plane --
-        // EXCEPT the caster's own crew and any other player. Canon area
-        // spells don't discriminate, but a shell that murders your companion
-        // because you aimed past them reads as a bug, not a rule (ruling
-        // 2026-08-25); the mage's own people get the benefit of the doubt.
-        const caught = this.scene.getActorsInRoom(room).filter(a => a !== this.actor && a !== primary
-            && a.plane === this.actor.plane
-            && !a.isIncapacitated()
-            && !this.scene.isHumanControlled(a)
-            && !(a instanceof NPC && a.allyOf === this.actor.name));
-        if (caught.length === 0)
-            return [];
-        const lines = ['', `The blast washes over the rest of the room.`];
-        for (const bystander of caught) {
-            const armorEaten = spellAp > 0
-                ? Math.min(spellAp, bystander.plane === 'meat' ? bystander.getArmorValue() : 0)
-                : 0;
-            const soakPool = spell.soak === 'willpower' ? bystander.willpower
-                : spell.soak === 'body' ? bystander.body
-                    : Math.max(0, bystander.getSoakPool() - armorEaten);
-            const soak = rollPool(Math.max(1, soakPool));
-            const dealt = Math.max(0, damageBase - soak.hits);
-            this.logger.meta(`${spellKey} splash on ${bystander.name}: soak ${formatRoll(soak)} vs ${damageBase}`);
-            if (dealt === 0) {
-                lines.push(`  ${bystander.name} rides it out -- shaken, still standing.`);
-                continue;
+    async castAreaSpell(spellKey, force, overcast, rest) {
+        const actor = this.actor;
+        const spell = spellFor(spellKey);
+        const flavor = COMBAT_SPELL_FLAVOR[spellKey] ?? { act: `cast ${spellKey} at`, fall: 'goes down.' };
+        const room = actor.currentLocation;
+        const words = (rest[0]?.toLowerCase() === 'at' ? rest.slice(1) : rest).filter(w => w.trim().length > 0);
+        const plane = this.scene.ensurePlane?.();
+        const from = this.scene.worldCellOf?.(actor);
+        if (!plane || !from)
+            return `There's nowhere here to aim a ${spellKey}.`;
+        const usage = `"cast ${spellKey} [force] at <x,y>" or "cast ${spellKey} [force] at <someone>" -- a ${force} m radius around that point. You're at ${formatCoord(from)}.`;
+        if (words.length === 0)
+            return `Cast it where? ${usage}`;
+        // WHERE IT IS AIMED.
+        let aim;
+        let aimedAt;
+        if (isCoordToken(words[0]) && words.length === 1) {
+            aim = parseCoord(words[0], from.z);
+            aimedAt = formatCoord(aim);
+            if (!this.inSight(plane, from, aim))
+                return `You can't see ${aimedAt} from here -- an area spell is cast at a point you can see (p.281).`;
+        }
+        else {
+            const selfWord = words.length === 1 && /^(me|self|myself)$/i.test(words[0]);
+            const visible = this.scene.getActorsInRoom(room).filter(a => a === actor || (a.plane === actor.plane && actor.canPerceive(a)));
+            const picked = selfWord ? actor.name : fuzzyPickName(words.join(' '), visible.map(a => a.name));
+            const target = picked ? visible.find(a => a.name === picked) : undefined;
+            if (!target) {
+                const cross = crossPlaneRefusal(this.scene, actor, room, words.join(' '), 'spell');
+                if (cross)
+                    return cross;
+                return `You don't see "${words.join(' ')}" here. ${usage}`;
             }
-            if (spell.stun)
-                bystander.takeStun(dealt);
-            else
-                bystander.takeDamage(dealt);
-            this.logger.write(`${this.actor.name}'s ${spellKey} splashed ${dealt} onto ${bystander.name}.`);
-            lines.push(`  ${bystander.name} is caught in it -- ${dealt} ${spell.stun ? 'stun' : 'damage'}.`);
-            if (bystander.isDown()) {
-                lines.push(...await exchange.resolveDeath(bystander, this.actor, {
-                    fallLine: `${bystander.name} goes down in the blast.`,
-                }));
+            aim = this.scene.worldCellOf?.(target);
+            aimedAt = target === actor ? 'yourself' : target.name;
+            if (!aim)
+                return `${target.name} isn't standing anywhere a ${spellKey} could find.`;
+            if (target !== actor && !this.inSight(plane, from, aim))
+                return `You can't see ${target.name} clearly enough to aim at them (p.281).`;
+        }
+        // WHO COULD BE CAUGHT: everyone on the caster's plane with a cell.
+        const sameSide = (a) => a.plane === actor.plane || (actor.plane === 'meat' && a.plane === 'drone') || (actor.plane === 'drone' && a.plane === 'meat');
+        const everyone = this.scene.allActors.filter(a => sameSide(a) && !a.isIncapacitated());
+        // THE COMBAT TURN: a Complex Action and the phase's attack (p.167).
+        const physical = actor.plane === 'meat' || actor.plane === 'drone';
+        const human = this.scene.isHumanControlled(actor);
+        if (physical) {
+            let enc = this.scene.encounterFor?.(actor);
+            const opener = everyone.find(a => a !== actor && a.currentLocation === room && a instanceof NPC);
+            if (!enc && opener) {
+                enc = await this.scene.startEncounter(room, { aggressor: actor, target: opener, ambush: false });
+                if (enc.ended)
+                    return human ? '' : `The fight was over before ${actor.name} could cast.`;
+                if (actor.isIncapacitated())
+                    return human ? `You're down before you can cast.` : `${actor.name} went down before casting.`;
+                if (!enc.isPhaseOf(actor)) {
+                    const who = enc.phaseActor?.name ?? 'the others';
+                    return human
+                        ? `Initiative rolled -- ${who} ${enc.phaseActor ? 'acts' : 'act'} first. Your ${spellKey} waits for your Action Phase.${hint(` ("initiative" shows the order.)`)}`
+                        : `${actor.name} gathers mana -- initiative rolled; ${who} first.`;
+                }
             }
-            else if (bystander.isUnconscious()) {
-                lines.push(...await exchange.resolveDeath(bystander, this.actor, {
-                    fatal: false,
-                    fallLine: `${bystander.name} drops where the blast found them -- out cold, breathing.`,
+            else if (enc && !enc.isPhaseOf(actor)) {
+                return notYourPhase(enc, actor);
+            }
+            const bill = billAction(this.scene, actor, 'complex', `Cast ${spellKey}`, { attack: true });
+            if (bill)
+                return bill;
+        }
+        const exchange = new CombatExchange(this.scene, this.logger, actor);
+        actor.performAction(`casts ${spellKey} at`, aimedAt);
+        this.scene.addWorldEvent(`${actor.name} ${flavor.act} ${aimedAt} in ${room.name}.`);
+        const lines = [];
+        const meta = [];
+        // Seen through a Physical Barrier, the point is in Light Fog: -1 on
+        // the casting test (p.294, p.175). An indirect ball meets the barrier
+        // itself, below, so only a direct one pays this.
+        const fog = spell.soak !== 'armor' && this.scene.barrierOnLine?.(from, aim, 'physical') ? BARRIER_FOG : 0;
+        const pool = Math.max(0, actor.getMagicPool() + actor.consumeEdgeBoost() + fog);
+        const roll = rollPool(pool, force);
+        const header = `${actor.name} casts ${spellKey} at Force ${force}${overcast ? ' (OVERCAST)' : ''}, ${this.castingLabel()}, at ${aimedAt}`;
+        const hurt = [];
+        if (spell.soak !== 'armor') {
+            // ---- DIRECT: one test, opposed by each target it can see. ----
+            meta.push(`${header}: casting ${formatRoll(roll)}${fog ? ` (${fog} through a force barrier, Light Fog p.175)` : ''}`);
+            lines.push(`${header} -- ${force} m of ${spell.type === 'mana' ? 'raw mana' : 'force'} around ${aimedAt}.`);
+            const caught = everyone.filter(a => {
+                const c = this.scene.worldCellOf?.(a);
+                if (!c || distanceMeters(aim, c) > force)
+                    return false;
+                // "...that you can see" (p.281): your own body counts; others must
+                // be perceived and in plain sight of you.
+                // Hidden in cover is not seen either (visibleActorsIn's rule).
+                if (a === actor)
+                    return true;
+                if (!actor.canPerceive(a) || !this.inSight(plane, from, c))
+                    return false;
+                return a.currentLocation !== room || !concealedFrom(room, actor, a);
+            });
+            if (caught.length === 0)
+                lines.push(`  The spell washes over empty ground.`);
+            for (const victim of caught) {
+                // Mana touches only the living and the magical (p.284).
+                if (spell.type === 'mana' && victim.plane === 'drone') {
+                    lines.push(`  ${victim.name}'s frame has no aura for mana to bite -- untouched.`);
+                    continue;
+                }
+                const weave = victim === actor ? undefined : this.manaBarrierBetween(victim);
+                const counter = typeof victim.isCaster === 'function' && victim.isCaster() ? victim.skillRating('counterspelling') : 0;
+                const resist = (spell.soak === 'willpower' ? victim.willpower : victim.body)
+                    + victim.qualityRating('magic-resistance') + counter + (weave ?? 0);
+                const defense = rollPool(resist);
+                const net = roll.hits - defense.hits;
+                meta.push(`  ${victim.name}: resists ${formatRoll(defense)}${weave ? ` (+${weave} mana barrier)` : ''}${counter ? ` (+${counter} counterspelling)` : ''} -- ${Math.max(0, net)} net`);
+                if (net <= 0) {
+                    lines.push(`  ${victim.name} holds against it.`);
+                    continue;
+                }
+                lines.push(...this.landAreaDamage(victim, net, !!spell.stun));
+                hurt.push(victim);
+            }
+        }
+        else {
+            // ---- INDIRECT: it flies, and goes off like a grenade. ----
+            const hits = roll.hits;
+            let at = aim;
+            let dv = force;
+            if (hits >= 3) {
+                dv = force + (hits - 3);
+                meta.push(`${header}: Spellcasting + Magic [${force}] (3) ${formatRoll(roll)} -- on target, +${hits - 3} DV (p.283)`);
+            }
+            else {
+                const metres = Math.max(0, rollD6Total(2) - hits);
+                const angle = Math.random() * Math.PI * 2;
+                at = {
+                    x: aim.x + Math.round(Math.cos(angle) * metres / METERS_PER_CELL),
+                    y: aim.y + Math.round(Math.sin(angle) * metres / METERS_PER_CELL),
+                    z: aim.z,
+                };
+                meta.push(`${header}: Spellcasting + Magic [${force}] (3) ${formatRoll(roll)} -- misses the threshold, scatters ${metres} m (p.181)`);
+            }
+            // What it meets on the way: a wall stops it short; so does a barrier.
+            let blocked = false;
+            const path = line3D(from, at);
+            for (let i = 1; i < path.length; i++) {
+                const c = path[i];
+                const wall = this.scene.barrierAt(c, 'physical');
+                if (wall) {
+                    lines.push(`${header} -- it bursts against ${wall.barrier.caster}'s barrier at ${formatCoord(c)}.`);
+                    lines.push(...this.strikeWall(wall, force, spellKey, dv - force));
+                    at = path[i - 1];
+                    blocked = true;
+                    break;
+                }
+                if (isSolid(plane, c)) {
+                    at = path[i - 1];
+                    break;
+                }
+            }
+            if (!blocked)
+                lines.push(`${header} -- it bursts at ${formatCoord(at)}${at.x !== aim.x || at.y !== aim.y ? `, wide of the mark` : ''}: DV ${dv}, AP -${force}, ${force} m.`);
+            const weave = this.scene.barrierOnLine?.(from, at, 'mana');
+            const through = weave && weave.barrier.caster !== actor.name ? weave.barrier.force : 0;
+            const caught = everyone.filter(a => {
+                const c = this.scene.worldCellOf?.(a);
+                if (!c || distanceMeters(at, c) > force)
+                    return false;
+                // The blast reaches what nothing solid shields.
+                return wallsBetween(plane, at, c) === 0 && !this.scene.barrierOnLine?.(at, c, 'physical');
+            });
+            if (caught.length === 0)
+                lines.push(`  The blast catches nobody.`);
+            for (const victim of caught) {
+                const armor = victim.plane === 'meat' ? victim.getArmorValue() : 0;
+                const modified = Math.max(0, armor - force);
+                const soak = rollPool(Math.max(0, victim.getSoakPool() - armor + modified) + through);
+                const dealt = Math.max(0, dv - soak.hits);
+                // p.168: a Physical hit under the modified Armor turns to Stun.
+                const stun = !!spell.stun || (victim.plane === 'meat' && dv < modified);
+                meta.push(`  ${victim.name}: soak ${formatRoll(soak)} v. DV ${dv} (Armor ${armor} -> ${modified})${through ? ` (+${through} mana barrier)` : ''} -- ${dealt}`);
+                if (dealt === 0) {
+                    lines.push(`  ${victim.name} rides it out.`);
+                    continue;
+                }
+                lines.push(...this.landAreaDamage(victim, dealt, stun));
+                hurt.push(victim);
+            }
+        }
+        await exchange.announce(lines, meta);
+        const report = [...lines, ...(human ? [] : meta)];
+        for (const victim of hurt) {
+            if (victim.isDown()) {
+                report.push(...await exchange.resolveDeath(victim, actor, {
+                    fallLine: `${victim.name} ${flavor.fall} Their gear scatters across ${victim.currentLocation.name}.`,
                 }));
             }
+            else if (victim.isUnconscious()) {
+                report.push(...(this.scene.isHumanControlled(victim)
+                    ? await exchange.resolvePlayerKnockout(actor, victim)
+                    : await exchange.resolveDeath(victim, actor, {
+                        fatal: false,
+                        fallLine: `${victim.name} drops where the spell found them -- out cold, breathing.`,
+                    })));
+            }
         }
-        await exchange.announce(lines);
-        return lines;
+        this.scene.encounterFor?.(actor)?.syncWounds();
+        if (!actor.isIncapacitated()) {
+            const drain = this.applyDrain(spell, force, overcast);
+            report.push('', ...drain);
+            await exchange.announce(drain);
+            report.push(...await this.drainCollapse(exchange));
+        }
+        this.scene.encounterFor?.(actor)?.syncWounds();
+        this.scene.updateStatus();
+        return human ? (physical ? phaseHint(this.scene, actor).trim() : '') : report.join('\n');
+    }
+    /** A box count landing on one body caught in an area spell. */
+    landAreaDamage(victim, boxes, stun) {
+        if (stun) {
+            const { stun: s, overflow } = victim.takeStun(boxes);
+            this.logger.write(`${this.actor.name}'s area spell dealt ${boxes} STUN to ${victim.name}.`);
+            return [`  ${victim.name} is caught -- ${s} stun: ${victim.stunSummary()}`,
+                ...(overflow > 0 ? [`  It spills past consciousness -- ${overflow} box${overflow === 1 ? '' : 'es'} physical: ${victim.conditionSummary()}`] : [])];
+        }
+        victim.takeDamage(boxes);
+        this.logger.write(`${this.actor.name}'s area spell dealt ${boxes} to ${victim.name}.`);
+        return [`  ${victim.name} is caught -- ${boxes} box${boxes === 1 ? '' : 'es'}: ${victim.conditionSummary()}`];
     }
     async castHeal(force, overcast, rest = []) {
         const { target, error } = this.resolveAllyTarget(rest);

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

@@ -140,35 +140,35 @@ export class SpellsCommand extends Command {
         // health and manipulation work.
         const book = [
             { key: 'manabolt', cast: 'manabolt', how: 'cast manabolt [force] at <target>',
-                line: 'direct mana: resisted by WILLPOWER alone; armor and muscle mean nothing. Damage F-2, drain F-3.' },
+                line: 'direct mana: they oppose your casting test with WILLPOWER; every net hit is a box, and nothing soaks it. Drain F-3.' },
             { key: 'stunbolt', cast: 'stunbolt', how: 'cast stunbolt at <target>',
-                line: 'direct mana, merciful: same reach as manabolt but the damage is STUN. Damage F-2, drain F-3.' },
+                line: 'direct mana, merciful: as manabolt (Willpower opposes, net hits are boxes), but STUN. Drain F-3.' },
             { key: 'powerbolt', cast: 'powerbolt', how: 'cast powerbolt at <target>',
-                line: 'direct physical: resisted by BODY alone; armor still means nothing. Damage F-2, drain F-3.' },
-            { key: 'fireball', cast: 'fireball', how: 'cast fireball at <target>',
-                line: 'indirect elemental: soaked like a gunshot (Body + armor, AP F/3) but it hits at FULL Force. Drain F-2.' },
+                line: 'direct physical: they oppose your casting test with BODY; net hits are boxes, armor means nothing. Drain F-3.' },
+            { key: 'fireball', cast: 'fireball', how: 'cast fireball [force] at <x,y | someone>',
+                line: 'AREA indirect elemental: Force m of fire. Thrown like a grenade (threshold 3, or it scatters 2D6 m); DV Force + net hits, AP -Force, soaked with Body + armor -- everyone in it, you too. Drain F-1.' },
             { key: 'lightning-bolt', cast: 'lightning-bolt', how: 'cast lightning-bolt at <target>',
-                line: 'indirect elemental: full-Force damage, soaked like a gunshot. Cheaper than fire -- drain F-3.' },
+                line: 'indirect elemental: dodged like a bullet (Reaction + Intuition); DV Force + net hits, AP -Force, Body + armor soaks. Drain F-3.' },
             { key: 'acid-stream', cast: 'acid-stream', how: 'cast acid-stream at <target>',
-                line: 'indirect elemental: full-Force damage that eats armor on the way in. Drain F-3.' },
+                line: 'indirect elemental: dodged like a bullet; DV Force + net hits, AP -Force -- acid eats armor. Drain F-3.' },
             { key: 'flamethrower', cast: 'flamethrower', how: 'cast flamethrower at <target>',
-                line: 'indirect elemental: a washing sheet of flame at full Force, soaked like a gunshot. Drain F-3.' },
+                line: 'indirect elemental: a sheet of flame, dodged like a bullet; DV Force + net hits, AP -Force. Drain F-3.' },
             { key: 'clout', cast: 'clout', how: 'cast clout at <target>',
-                line: 'indirect force: an invisible fist, full Force, damage lands STUN. Drain F-3.' },
+                line: 'indirect force: an invisible fist, dodged like a bullet; DV Force + net hits, AP -Force, STUN. Drain F-3.' },
             { key: 'death-touch', cast: 'death-touch', how: 'cast death-touch at <target>',
-                line: 'direct mana at TOUCH range -- you close first, then they resist with Willpower. Damage F-2, drain F-6.' },
+                line: 'direct mana at TOUCH range -- you close first; Willpower opposes, net hits are boxes. Drain F-6.' },
             { key: 'knockout', cast: 'knockout', how: 'cast knockout at <target>',
-                line: 'direct mana at TOUCH range, STUN damage: the quiet way to take one alive. Damage F-2, drain F-6.' },
+                line: 'direct mana at TOUCH range, STUN: the quiet way to take one alive. Willpower opposes. Drain F-6.' },
             { key: 'shatter', cast: 'shatter', how: 'cast shatter at <target>',
-                line: 'direct physical at TOUCH range -- BODY resists, bone gives. Damage F-2, drain F-6.' },
-            { key: 'manaball', cast: 'manaball', how: 'cast manaball at <target>',
-                line: 'AREA direct mana: your target takes the exchange, everyone else in the room eats the blast. Damage F-2, drain F.' },
-            { key: 'stunball', cast: 'stunball', how: 'cast stunball at <target>',
-                line: 'AREA direct mana, STUN: the room-clearing knockout. Damage F-2, drain F.' },
-            { key: 'powerball', cast: 'powerball', how: 'cast powerball at <target>',
-                line: 'AREA direct physical: BODY resists, armor does not. Damage F-2, drain F.' },
-            { key: 'ball-lightning', cast: 'ball-lightning', how: 'cast ball-lightning at <target>',
-                line: 'AREA indirect elemental: full-Force damage across the room, soaked with armor. Drain F-1.' },
+                line: 'direct physical at TOUCH range -- Body opposes, net hits are boxes, bone gives. Drain F-6.' },
+            { key: 'manaball', cast: 'manaball', how: 'cast manaball [force] at <x,y | someone>',
+                line: 'AREA direct mana: Force m around the point; everyone in it you can SEE, friend or foe (you too), opposes with Willpower and takes their own net hits. Drain F.' },
+            { key: 'stunball', cast: 'stunball', how: 'cast stunball [force] at <x,y | someone>',
+                line: 'AREA direct mana, STUN: as manaball, but the knockout. Drain F.' },
+            { key: 'powerball', cast: 'powerball', how: 'cast powerball [force] at <x,y | someone>',
+                line: 'AREA direct physical: as manaball, Body opposes, armor does not help. Drain F.' },
+            { key: 'ball-lightning', cast: 'ball-lightning', how: 'cast ball-lightning [force] at <x,y | someone>',
+                line: 'AREA indirect elemental: as fireball, in lightning. Drain F-1.' },
             { key: 'heal', cast: 'heal', how: 'cast heal [on <ally>]',
                 line: "knit physical wounds closed, yours or an ally's (touch range); Force caps the boxes. Drain F-4." },
             { key: 'armor', cast: 'armor', how: 'cast armor [on <ally>]',

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

@@ -3364,5 +3364,30 @@
 //   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';
+// 1.198.0 (2026-10-05): COMBAT SPELLS, CANON (SR5 p.281-284, p.316).
+// - Direct spells (manabolt, stunbolt, powerbolt, the touch three, the
+//   balls) are opposed by Willpower/Body (+ Magic Resistance, counter-
+//   spelling) and do their NET HITS, unsoaked -- not F-2 + net soaked.
+// - Indirect spells are dodged (Reaction + Intuition): DV Force + net
+//   hits, AP -Force, Body + Armor soaks -- not AP floor(F/3).
+// - Area spells are aimed at a point: `cast <ball> [F] at <x,y[,z]>` or
+//   `at <someone>`; everyone within Force metres on the district plane
+//   is caught, friend and foe, the caster too (user ruling). Direct balls
+//   touch only who the caster can see, each opposing one casting test.
+//   Indirect balls fly like a grenade: threshold 3 (hits are capped at
+//   Force), net hits on the DV, else scatter 2D6 m less a metre a hit;
+//   walls shield. Replaces "the room splashes, allies spared".
+// - A mana barrier between adds its Force to defence/soak; a physical
+//   barrier stops an indirect spell, which hits the face instead.
+// - Fireball drains F - 1 (catalog v36).
+// 1.199.0 (2026-10-05): SPELLS NEED SIGHT (p.281, p.283, p.178). A
+//   direct bolt at someone the caster cannot see -- off their plane or
+//   hidden in cover (visibleActorsIn) -- is refused before any drain; an
+//   indirect one flies blind at -6 (Blind Fire). Direct area spells pass
+//   over anyone hidden in cover inside them.
+// 1.200.0 (2026-10-05): A PHYSICAL BARRIER IS LIGHT FOG (p.294): a spell
+//   or ranged attack whose line crosses a standing face is at -1, the
+//   Light Fog row of the Environmental Modifiers table (p.175; confirmed
+//   against the rules index and SR5 references online). Melee is exempt.
+export const ENGINE_VERSION = '1.200.0';
 //# sourceMappingURL=engine-version.js.map

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

@@ -35,6 +35,11 @@ export function forceForWall(a, b) {
 }
 /** The directional wall is three cells across: Force 3. */
 export const DIRECTIONAL_WALL_FORCE = 3;
+/**
+ * Seeing through a Physical Barrier: "equivalent to Light Fog" (p.294),
+ * the Light Fog row of the Environmental Modifiers table -- -1 (p.175).
+ */
+export const BARRIER_FOG = -1;
 /** A dome with no Force named rises one full 3 m storey: Force 3. */
 export const DOME_FORCE = METERS_PER_LEVEL;
 /**

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

@@ -1,4 +1,4 @@
-import { allBreached, damageFace, penetrationBoxes, pierces } from './barrier-geometry.js';
+import { allBreached, damageFace, penetrationBoxes, pierces, BARRIER_FOG } from './barrier-geometry.js';
 import { recoilCompensation, recoilPenalty } from './recoil.js';
 import { Category } from '../types/shared/item-enum.js';
 import { crashIC } from './ic-actors.js';
@@ -648,6 +648,20 @@ export class CombatExchange {
         const spatial = isMelee ? { meters: 0 } : this.spatialContext(attacker, defender);
         const weaponClass = strike.weaponItem?.isFirearm() ? classifyWeapon(strike.weaponItem) : undefined;
         const range = weaponClass ? rangePenalty(spatial.meters, weaponClass) : 0;
+        // THROUGH A PHYSICAL BARRIER (p.294: it is "equivalent to Light Fog"
+        // and impedes spellcasting only by visibility): the Light Fog row of
+        // the Environmental Modifiers table, -1 (p.175), on a ranged attack or
+        // a spell whose line crosses a standing face. Melee never reaches
+        // through one. Only the worst condition counts (p.173), and this is
+        // the only environmental condition the engine models, so it stands
+        // alone.
+        let fog = 0;
+        if (!isMelee) {
+            const a = this.scene.worldCellOf?.(attacker);
+            const d = this.scene.worldCellOf?.(defender);
+            if (a && d && this.scene.barrierOnLine?.(a, d, 'physical'))
+                fog = BARRIER_FOG;
+        }
         const rangeMod = range === 'out-of-range' ? -6 : range;
         // p.190 grants the bonus to a defender who "uses a Take Cover
         // action" -- so the dice follow the ACTION, not the address.
@@ -692,17 +706,23 @@ export class CombatExchange {
         // charging, a running defender, surprise, Full Defense and the
         // dodge/block/parry interrupts -- see turnModifiers below.
         const turn = this.turnModifiers(attacker, defender, isMelee, strike, meta);
-        const attack = rollPool(strike.pool + directed + rangeMod + attackerFloor + targetDown + turn.attack + recoil, attackLimit);
-        const defense = turn.noDefense
-            ? rollPool(0)
-            : rollPool(defender.getDefensePool() + inspired + counterspell + coverDice + proneDefence + turn.defense);
+        const attack = rollPool(strike.pool + directed + rangeMod + attackerFloor + targetDown + turn.attack + recoil + fog, attackLimit);
+        // A DIRECT SPELL IS NOT DODGED (p.283): the target opposes the
+        // casting test with Body or Willpower, and only counterspelling (and
+        // a teammate's inspiration) helps -- not cover, posture, surprise or
+        // a dodge. The profile carries that pool when it applies.
+        const defense = strike.defensePool !== undefined
+            ? rollPool(Math.max(0, strike.defensePool) + inspired + counterspell)
+            : turn.noDefense
+                ? rollPool(0)
+                : rollPool(defender.getDefensePool() + inspired + counterspell + coverDice + proneDefence + turn.defense);
         const rangeNote = weaponClass && spatial.meters > 0
             ? ` (${rangeMod !== 0 ? `${rangeMod} range` : `${rangeBracketName(spatial.meters, weaponClass)} range`} -- ~${Math.round(spatial.meters)} m)`
             : '';
         const recoilNote = recoil < 0 && strike.weaponItem
             ? ` (${recoil} recoil -- round ${attacker.recoilRoundsFired} against RC ${recoilCompensation(attacker, strike.weaponItem)})`
             : '';
-        meta.push(`  Attack:  ${formatRoll(attack)}${directed > 0 ? ` (+${directed} directed)` : ''}${rangeNote}${recoilNote}`);
+        meta.push(`  Attack:  ${formatRoll(attack)}${directed > 0 ? ` (+${directed} directed)` : ''}${rangeNote}${recoilNote}${fog ? ` (${fog} through a force barrier, Light Fog p.175)` : ''}`);
         const coverNote = coverDice > 0 ? ` (+${coverDice} cover -- the ${spotOf(defender)})` : '';
         meta.push(`  Defense: ${formatRoll(defense)}${inspired > 0 ? ` (+${inspired} inspired)` : ''}${counterspell > 0 ? ` (+${counterspell} counterspell${counterspellSource ? ` -- ${counterspellSource}'s cover` : ''})` : ''}${coverNote}`);
         const dryWarning = strike.weaponItem?.isFirearm() && strike.weaponItem.ammo === 0

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

@@ -46,6 +46,24 @@ let scriptedInitiative;
 export function scriptInitiative(totals) {
     scriptedInitiative = totals ? [...totals] : undefined;
 }
+/**
+ * A SUM OF D6s, not a hit count -- scatter distance (p.181: 2D6 metres)
+ * and anything else the book measures in pips. Scriptable like the
+ * other seams: each scripted entry is the TOTAL the next call shows.
+ */
+let scriptedTotals;
+export function scriptTotals(totals) {
+    scriptedTotals = totals ? [...totals] : undefined;
+}
+export function rollD6Total(count) {
+    const scripted = scriptedTotals && scriptedTotals.length > 0 ? scriptedTotals.shift() : undefined;
+    if (scripted !== undefined)
+        return scripted;
+    let total = 0;
+    for (let i = 0; i < count; i++)
+        total += 1 + Math.floor(Math.random() * 6);
+    return total;
+}
 export function rollPool(pool, limit, opts = {}) {
     const size = Math.max(0, Math.floor(pool));
     const scripted = scriptedHits && scriptedHits.length > 0 ? scriptedHits.shift() : undefined;

package/package.json

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