@maka/maka-cli 5.386.0 → 5.388.0

package/bundle/typescript/package.json

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

@@ -6,10 +6,10 @@ 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 { 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, FACE_LABEL, allBreached, damageFace, pierces } 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,6 +91,11 @@ 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
@@ -99,6 +104,8 @@ export class CastCommand extends BypassCommand {
     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
@@ -520,9 +527,10 @@ export class CastCommand extends BypassCommand {
         }
         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` : ''),
-            pool: this.actor.getMagicPool() + this.actor.consumeEdgeBoost(),
+            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,
@@ -623,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).
@@ -980,13 +998,17 @@ export class CastCommand extends BypassCommand {
         this.scene.addWorldEvent(`${actor.name} ${flavor.act} ${aimedAt} in ${room.name}.`);
         const lines = [];
         const meta = [];
-        const pool = actor.getMagicPool() + actor.consumeEdgeBoost();
+        // 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)}`);
+            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);
@@ -994,7 +1016,12 @@ export class CastCommand extends BypassCommand {
                     return false;
                 // "...that you can see" (p.281): your own body counts; others must
                 // be perceived and in plain sight of you.
-                return a === actor || (actor.canPerceive(a) && this.inSight(plane, from, c));
+                // 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.`);

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

@@ -3380,5 +3380,14 @@
 // - 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).
-export const ENGINE_VERSION = '1.198.0';
+// 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,7 +706,7 @@ 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 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
@@ -708,7 +722,7 @@ export class CombatExchange {
         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/package.json

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