@maka/maka-cli 5.200.0 → 5.202.0

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

@@ -174,9 +174,17 @@ function postSweepOfficer(game, room, band) {
         // not follow.
         until: 'exchange',
         room,
-        // A working rent-a-cop, not a boss fight. Deliberately ordinary:
-        // the player who decides to swing at security should be picking a
-        // fight with a person, not a set piece.
+        // PROFESSIONAL RATING 3, "Police Patrols" (SR5 p.383): the catalog's
+        // `police-patrol` npc-kit row -- armor jacket, Ares Predator V,
+        // Defiance EX Shocker, stun baton, Renraku Sensei, and a Biometric
+        // Reader (p.440), which is what the book has where this prose says
+        // "wand" -- SR5 prints no such item. factionOf() already read an
+        // 'authority' ephemeral as Knight Errant; the row says so too.
+        // A working beat cop, not a boss fight: the player who decides to
+        // swing at one is picking a fight with a person, not a set piece.
+        kit: SWEEP_OFFICER_KIT,
+        // A pre-v21 cache resolves to no kit and gets this instead: the old
+        // rent-a-cop numbers, exactly as before.
         combat: {
             body: 3, agility: 3, reaction: 3, strength: 3, willpower: 3,
             logic: 3, intuition: 3, charisma: 3, edge: 1, combatSkill: 3,
@@ -184,6 +192,8 @@ function postSweepOfficer(game, room, band) {
         },
     });
 }
+/** The sweep officer's npc-kit row (npc-kits.ts). */
+export const SWEEP_OFFICER_KIT = 'police-patrol';
 /**
  * THE OFFICERS, and there is more than one of them now.
  *

package/bundle/typescript/src/commands/game/sideQuest/utilities/sprite-power-actions.js

@@ -0,0 +1,270 @@
+import { rollPool, formatRoll } from './dice.js';
+import { hint } from './hints.js';
+import { hostLabel } from './grid-names.js';
+import { spriteMatrix, spritePower, powersForSprite } from '../sprite-powers.js';
+const refuse = (text) => ({ text, meta: [], spent: false });
+/** Every persona sharing this sprite's place on the grid or in a host. */
+function personasNear(ctx) {
+    const here = ctx.sprite.hostInside;
+    return ctx.scene.allActors.filter((a) => a !== ctx.sprite && a.plane === 'matrix'
+        && (here ? a.hostInside === here : a.currentGrid === ctx.sprite.currentGrid));
+}
+/** The host this sprite is standing inside, if any. */
+function hostOf(ctx) {
+    return ctx.sprite.hostInside?.over;
+}
+/** The sprite's pool for a skill, its Level standing in for the attribute
+ *  the book pairs it with (p.254: a sprite's ratings are all Level-derived). */
+function spritePool(ctx, skill) {
+    const rating = ctx.sprite.skillRating(skill);
+    return Math.max(1, (rating > 0 ? rating : -1) + ctx.level);
+}
+// ===================== THE FOUR ROLLED POWERS =====================
+/** COOKIE (p.256-257): Hacking + Resonance [Sleaze] v. Intuition + Firewall. */
+function cookie(ctx, targetName) {
+    const near = personasNear(ctx);
+    const target = near.find(p => p.name.toLowerCase() === targetName.toLowerCase())
+        ?? near.find(p => p.name.toLowerCase().includes(targetName.toLowerCase()));
+    if (!target) {
+        return refuse(`${ctx.sprite.name} finds no persona called "${targetName}" to tag.${near.length > 0 ? hint(` (Here: ${near.map(p => p.name).join(', ')}.)`) : ''}`);
+    }
+    const m = spriteMatrix(ctx.spriteKey, ctx.level);
+    const attack = rollPool(spritePool(ctx, 'hacking') + m.resonance, m.sleaze);
+    const defence = rollPool(Math.max(1, target.intuition + target.matrixAttribute('firewall')));
+    const net = attack.hits - defence.hits;
+    const meta = [
+        `${ctx.sprite.name} -- Cookie (Hacking + Resonance [Sleaze ${m.sleaze}]): ${formatRoll(attack)}`,
+        `  ${target.name} resists (Intuition + Firewall): ${formatRoll(defence)} -- net ${net >= 0 ? '+' : ''}${net}`,
+    ];
+    if (net <= 0) {
+        return { text: `The tag slides off ${target.name}'s icon and dissolves. Nothing stuck.`, meta, spent: true };
+    }
+    // Net hits set the DEPTH the report will carry (p.257: one hit a bare
+    // outline, four or more a detailed report).
+    target.cookiedBy.set(ctx.sprite.name, net);
+    const depth = net >= 4 ? 'a detailed report' : net >= 2 ? 'more than an outline' : 'a bare outline';
+    return {
+        text: `{light-blue-fg}${ctx.sprite.name} writes a silent file into ${target.name}'s persona, rated ${ctx.level} and running quiet. It is logging -- ${depth} when it ships home.{/light-blue-fg}${hint(` (${target.name} is carrying it and does not know. A Matrix Perception on them finds it.)`)}`,
+        meta,
+        spent: true,
+    };
+}
+/** DIAGNOSTICS (p.257): a Teamwork Test, Hardware + Level [Data Processing].
+ *  Any hits give +1 limit; each hit adds a die. */
+function diagnostics(ctx, targetName) {
+    const room = ctx.master.currentLocation;
+    const device = deviceNamed(room, targetName) ?? ctx.master.inventory.getAllItems()
+        .find(i => i.name.toLowerCase().includes(targetName.toLowerCase()));
+    if (!targetName || !device) {
+        return refuse(`${ctx.sprite.name} needs a device to read. "order ${ctx.sprite.name} diagnostics <device>".`);
+    }
+    const m = spriteMatrix(ctx.spriteKey, ctx.level);
+    const roll = rollPool(spritePool(ctx, 'hardware'), m.dataProcessing);
+    const meta = [`${ctx.sprite.name} -- Diagnostics (Hardware + Level [Data Processing ${m.dataProcessing}]): ${formatRoll(roll)}`];
+    if (roll.hits === 0) {
+        return { text: `${ctx.sprite.name} reads the ${name(device)} down to its seams and finds nothing useful to say.`, meta, spent: true };
+    }
+    // It takes the sprite's whole attention: one target at a time, and the
+    // bonus lasts until the sprite does anything else (dropped by the
+    // caller when the next power is used).
+    ctx.master.spriteAssist = { sprite: ctx.sprite.name, device: name(device), dice: roll.hits, limit: 1 };
+    return {
+        text: `{light-blue-fg}${ctx.sprite.name} folds itself around the ${name(device)} and starts narrating -- tolerances, wear, the one screw somebody cross-threaded. +${roll.hits} dice and +1 limit while you work it.{/light-blue-fg}${hint(` (It holds this until you give ${ctx.sprite.name} another order.)`)}`,
+        meta,
+        spent: true,
+    };
+}
+/** ELECTRON STORM (p.257): Cybercombat + Resonance [Attack] v. Intuition +
+ *  Firewall, sustained, (Resonance) DV Matrix damage and 2 noise. */
+function electronStorm(ctx, targetName) {
+    const near = personasNear(ctx);
+    const target = near.find(p => p.name.toLowerCase().includes(targetName.toLowerCase()));
+    if (!target) {
+        return refuse(`${ctx.sprite.name} finds no persona called "${targetName}" out here.${near.length > 0 ? hint(` (Here: ${near.map(p => p.name).join(', ')}.)`) : ''}`);
+    }
+    const m = spriteMatrix(ctx.spriteKey, ctx.level);
+    const attack = rollPool(spritePool(ctx, 'cybercombat') + m.resonance, m.attack);
+    const defence = rollPool(Math.max(1, target.intuition + target.matrixAttribute('firewall')));
+    const net = attack.hits - defence.hits;
+    const meta = [
+        `${ctx.sprite.name} -- Electron Storm (Cybercombat + Resonance [Attack ${m.attack}]): ${formatRoll(attack)}`,
+        `  ${target.name} resists (Intuition + Firewall): ${formatRoll(defence)} -- net ${net >= 0 ? '+' : ''}${net}`,
+    ];
+    if (net <= 0) {
+        return { text: `The datastorm breaks over ${target.name} and washes past. Nothing sticks to them.`, meta, spent: true };
+    }
+    const dv = m.resonance;
+    const soak = rollPool(Math.max(1, target.matrixAttribute('firewall') + target.logic));
+    const dealt = Math.max(0, dv - soak.hits);
+    meta.push(`  ${dv} DV Matrix, soaked (Firewall + Logic): ${formatRoll(soak)} -> ${dealt}`);
+    if (dealt > 0)
+        target.takeMatrixDamage(dealt);
+    // Sustained: it keeps burning until the sprite is hurt or redirected.
+    ctx.sprite.sustainedStorm = target.name;
+    return {
+        text: `{light-blue-fg}${ctx.sprite.name} tears open and ${target.name}'s icon is inside it -- corrupting datastreams sheeting off them, ${dealt} Matrix damage and their signal fraying (noise +2). It is holding the storm open.{/light-blue-fg}${hint(` (It burns again every action it sustains this -- and ends the moment ${ctx.sprite.name} takes Matrix damage of its own.)`)}`,
+        meta,
+        spent: true,
+    };
+}
+/** GREMLINS (p.257): Hardware + Level [Attack] v. Device Rating + Firewall.
+ *  Success is a glitch; 4+ net hits is a critical one. */
+function gremlins(ctx, targetName) {
+    const room = ctx.master.currentLocation;
+    const device = deviceNamed(room, targetName);
+    if (!device) {
+        return refuse(`${ctx.sprite.name} finds no device called "${targetName}" to sour.`);
+    }
+    const m = spriteMatrix(ctx.spriteKey, ctx.level);
+    const attack = rollPool(spritePool(ctx, 'hardware'), m.attack);
+    const defence = rollPool(Math.max(1, device.rating * 2));
+    const net = attack.hits - defence.hits;
+    const meta = [
+        `${ctx.sprite.name} -- Gremlins (Hardware + Level [Attack ${m.attack}]): ${formatRoll(attack)}`,
+        `  ${device.name} resists (Device Rating + Firewall): ${formatRoll(defence)} -- net ${net >= 0 ? '+' : ''}${net}`,
+    ];
+    if (net <= 0) {
+        return { text: `The ${device.name} hiccups once and carries on. Whatever ${ctx.sprite.name} whispered into it did not take.`, meta, spent: true };
+    }
+    // WHAT A GLITCH IS, ON A DEVICE -- an engine ruling, labelled. The book
+    // says "the GM chooses an appropriate malfunction" and at 4+ net hits
+    // "the device crashes, burns out, or jolts its user". This engine has
+    // exactly one model of a device that has stopped behaving: its Matrix
+    // condition monitor (Device.takeMatrixDamage, which is what Data Spike
+    // fills). So a glitch is damage scaled by how badly it landed, and a
+    // critical glitch fills the track -- the device is dead, which is the
+    // book's "crashes, burns out" in the vocabulary the engine already
+    // speaks. Inventing a separate "soured" flag would mean a state
+    // nothing else in the engine reads.
+    const critical = net >= 4;
+    const boxes = critical ? device.matrixMonitor : Math.max(1, Math.ceil(net / 2));
+    device.takeMatrixDamage(boxes);
+    meta.push(`  ${critical ? 'CRITICAL glitch' : 'glitch'}: ${boxes} Matrix damage to ${device.name}`);
+    return {
+        text: critical
+            ? `{light-blue-fg}${ctx.sprite.name} gets INTO the ${device.name} and something lets go -- a bang, a smell of hot resin, and the panel goes dark for good.{/light-blue-fg}`
+            : `{light-blue-fg}The ${device.name} starts lying. Readings drift, a control sticks, a signal loops back on itself -- ${ctx.sprite.name} has soured it.{/light-blue-fg}`,
+        meta,
+        spent: true,
+    };
+}
+// ===================== THE STATE POWERS =====================
+/** CAMOUFLAGE (p.256): hides a file inside another file, invisible to
+ *  Matrix searches -- only a Perception specifically hunting it finds it. */
+function camouflage(ctx, targetName) {
+    const room = hostOf(ctx);
+    const file = room && fileNamed(room, targetName);
+    if (!room || !file) {
+        return refuse(`${ctx.sprite.name} has no file called "${targetName}" to hide. It works inside a host, on what the archive holds.`);
+    }
+    file.concealedBy = ctx.sprite.name;
+    return {
+        text: `{light-blue-fg}${ctx.sprite.name} folds ${file.name} into the body of another file -- same checksum, same size, nothing out of place. A Matrix Search will walk straight past it now.{/light-blue-fg}${hint(` (Only a Matrix Perception hunting this file finds it -- ${ctx.sprite.name} included.)`)}`,
+        meta: [],
+        spent: true,
+    };
+}
+/** HASH (p.257): seals a file with a Resonance algorithm only this sprite
+ *  can undo, for up to (Level x 10) Combat Turns. */
+function hash(ctx, targetName) {
+    const room = hostOf(ctx);
+    const file = room && fileNamed(room, targetName);
+    if (!room || !file) {
+        return refuse(`${ctx.sprite.name} has no file called "${targetName}" to seal.`);
+    }
+    file.hashedBy = ctx.sprite.name;
+    file.hashTurns = ctx.level * 10;
+    return {
+        text: `{light-blue-fg}${ctx.sprite.name} wraps ${file.name} in an algorithm nothing else in the Matrix can read, and carries it. ${ctx.level * 10} Combat Turns.{/light-blue-fg}${hint(` (Nobody else edits or deletes it while the hash holds -- but kill ${ctx.sprite.name} while it carries this and the file is corrupted for good.)`)}`,
+        meta: [],
+        spent: true,
+    };
+}
+/** SUPPRESSION (p.257): a sprite in a host delays launched IC by
+ *  (Level / 2) Combat Turns; delayed IC can neither act nor be targeted. */
+function suppression(ctx) {
+    const room = hostOf(ctx);
+    if (!room?.host) {
+        return refuse(`Suppression baffles a HOST, and ${ctx.sprite.name} is not inside one.`);
+    }
+    const turns = Math.max(1, Math.floor(ctx.level / 2));
+    room.host.icLaunchDelay = turns;
+    return {
+        text: `{light-blue-fg}${ctx.sprite.name} spreads itself thin across ${hostLabel(room)}'s launch paths and starts arguing with them. Anything it tries to bring up comes up ${turns} Combat Turn${turns === 1 ? '' : 's'} late -- and comes up unable to act or be touched while it waits.{/light-blue-fg}`,
+        meta: [],
+        spent: true,
+    };
+}
+/** WATERMARK (p.257): an invisible tag only Resonance-driven things read. */
+function watermark(ctx, rest) {
+    const room = hostOf(ctx);
+    // LONGEST FILE NAME FIRST, then the rest is the message. Splitting on
+    // the first space would read "Client Ledger they know" as a file called
+    // "Client" -- and every file in this game has a two-word name.
+    const words = rest.split(/\s+/).filter(w => w.length > 0);
+    let file;
+    let note = '';
+    for (let i = words.length; i >= 1 && !file; i--) {
+        const candidate = room && fileNamed(room, words.slice(0, i).join(' '));
+        if (candidate) {
+            file = candidate;
+            note = words.slice(i).join(' ').trim();
+        }
+    }
+    if (!room || !file) {
+        return refuse(`${ctx.sprite.name} has no icon called "${words[0] ?? ''}" to mark. "order ${ctx.sprite.name} watermark <file> <message>".`);
+    }
+    file.watermark = { by: ctx.sprite.name, note: note || 'no message, just the mark' };
+    return {
+        text: `{light-blue-fg}${ctx.sprite.name} writes into ${file.name} something no eye and no program will ever render${note ? `: "${note}"` : ''}. It overwrites whatever was there before, and it lasts as long as the icon does.{/light-blue-fg}${hint(` (Only Resonance reads it -- a technomancer or another sprite.)`)}`,
+        meta: [],
+        spent: true,
+    };
+}
+// ===================== DISPATCH =====================
+function name(x) { return x.name; }
+function deviceNamed(room, query) {
+    if (!query)
+        return undefined;
+    const q = query.toLowerCase();
+    return room.allDevices().find(d => d.name.toLowerCase() === q)
+        ?? room.allDevices().find(d => d.name.toLowerCase().includes(q));
+}
+function fileNamed(room, query) {
+    if (!query)
+        return undefined;
+    const q = query.toLowerCase();
+    const files = room.inventory.getAllItems().filter(i => i.plane === 'matrix');
+    return files.find(f => f.name.toLowerCase() === q) ?? files.find(f => f.name.toLowerCase().includes(q));
+}
+/**
+ * Run one power. The caller has already established that this actor IS a
+ * sprite and has the power; this resolves it and reports whether a task
+ * was actually spent.
+ */
+export function runSpritePower(key, ctx, rest) {
+    const power = spritePower(key);
+    if (!power)
+        return refuse(`No such sprite power.`);
+    if (!power.runnable) {
+        // Said plainly rather than failing silently -- the catalogue's own
+        // rule (a wrong ability is worse than a missing one).
+        return refuse(`${power.name} (${power.page}) is canon this engine lists but does not yet resolve -- it wants the glitch contract changed in one place first. "sprites" says which powers are moves.`);
+    }
+    if (!powersForSprite(ctx.spriteKey).some(p => p.key === key)) {
+        return refuse(`A ${ctx.spriteKey} sprite has no ${power.name} (p.259). ${ctx.sprite.name} can do: ${powersForSprite(ctx.spriteKey).map(p => p.name).join(', ')}.`);
+    }
+    const target = rest.trim();
+    switch (key) {
+        case 'cookie': return cookie(ctx, target);
+        case 'diagnostics': return diagnostics(ctx, target);
+        case 'electron-storm': return electronStorm(ctx, target);
+        case 'gremlins': return gremlins(ctx, target);
+        case 'camouflage': return camouflage(ctx, target);
+        case 'hash': return hash(ctx, target);
+        case 'suppression': return suppression(ctx);
+        case 'watermark': return watermark(ctx, target);
+        default: return refuse(`${power.name} is not resolved here.`);
+    }
+}
+//# sourceMappingURL=sprite-power-actions.js.map

package/bundle/typescript/src/commands/game/sideQuest/utilities/street-gang.js

@@ -38,21 +38,32 @@ import { AI } from '../../../../tools/ai/ai.class.js';
  * the ephemeral never decides anything.
  */
 /**
- * PROFESSIONAL RATING 1 GANGER, canon stats (SR5 p.382, "Gangers &
- * Street Scum"): B/A/R/S 4, W/L/I/C 3, with Blades, Clubs,
- * Intimidation, Pistols and Unarmed Combat.
+ * PROFESSIONAL RATING 1 GANGER (SR5 p.382, "Gangers & Street Scum"):
+ * the catalog's `gangers` npc-kit row -- B/A 4, R 3, S 4, W/I/C 3, L 2,
+ * Blades 4 / Clubs 3 / Intimidation 4 / Pistols 4 / Unarmed 3,
+ * Toughness, an armor vest, a Browning Ultra-Power, a knife and a Meta
+ * Link (npc-kits.ts; the rows live on maka-cli.com, catalog v21).
  *
- * Copied rather than invented, and deliberately NOT scaled up. Canon's
- * own barrens encounter calls a gang ambush "a straightforward, quick,
- * and easy fight" for runners (Splintered State p.11). A mob that
- * threatened a professional crew would be a set piece, and a set piece
- * is a scene NPC's job, not a passing face's.
+ * THIS USED TO BE A CONSTANT HERE, and the constant was the bug. It
+ * said "canon stats" while giving them `firearms: 3` -- a skill that
+ * has not existed since stage 3 (skills.ts), written and never read --
+ * and no gun, so a "ganger with Pistols" always closed to punching
+ * range. The row carries the book's line, gear included, and a
+ * pre-v21 cache resolves to no kit, in which case the fallback block
+ * below is what they get: the old numbers, minus the dead key.
+ *
+ * Deliberately NOT scaled up. Canon's own barrens encounter calls a
+ * gang ambush "a straightforward, quick, and easy fight" for runners
+ * (Splintered State p.11). A mob that threatened a professional crew
+ * would be a set piece, and a set piece is a scene NPC's job, not a
+ * passing face's.
  */
-const GANGER_COMBAT = {
-    body: 4, agility: 4, reaction: 4, strength: 4,
-    willpower: 3, logic: 3, intuition: 3, charisma: 3,
+export const GANGER_KIT = 'gangers';
+const GANGER_FALLBACK_COMBAT = {
+    body: 4, agility: 4, reaction: 3, strength: 4,
+    willpower: 3, logic: 2, intuition: 3, charisma: 3,
     edge: 1, combatSkill: 3,
-    skills: { blades: 3, clubs: 3, intimidation: 3, firearms: 3, unarmed: 3, perception: 2 },
+    skills: { blades: 4, clubs: 3, intimidation: 4, pistols: 4, unarmed: 3, perception: 2 },
 };
 /** How often a street corner turns out to be somebody's corner. */
 const GANG_CHANCE = 0.08;
@@ -116,7 +127,8 @@ export function maybeStreetGang(host, actor, room) {
             // with it through the doorway.
             until: 'fight',
             room,
-            combat: GANGER_COMBAT,
+            kit: GANGER_KIT,
+            combat: GANGER_FALLBACK_COMBAT,
         });
         if (!npc)
             continue;

package/package.json

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