@maka/maka-cli 5.134.0 → 5.136.0

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

@@ -0,0 +1,122 @@
+import { Category } from '../types/shared/item-enum.js';
+import { spotOf, canReach, isInCover, coverAvailableFor, actorDistanceMeters } from './spots.js';
+import { Logger } from './logger.js';
+/**
+ * AN NPC'S ACTION PHASE, PLAYED BY RULE (SR5 p.163-167).
+ *
+ * The LLM reflect chain (models/npc.ts) is how NPCs live between fights
+ * -- talk, wander, react. It is the wrong instrument for a Combat Turn:
+ * it answers on its own clock, cannot be told "you have two Simple
+ * Actions and it is your phase now", and its grind-breaker stops after
+ * two refusals. So while an encounter runs, every participant NPC's
+ * chain is suspended (NPC.combatPhaseLocked) and this plays their
+ * phases instead, through the same verbs a player types, so every
+ * action pays the same cost through the same gate (action-cost.ts).
+ *
+ * The doctrine is a soldier's, not a genius's, and deliberately short:
+ *   1. A holstered weapon is readied first (Ready Weapon, Simple, p.165).
+ *   2. A dry gun is reloaded when there is ammunition to do it with
+ *      (the whole phase, p.163/167); otherwise the fists come up.
+ *   3. Melee closes the distance (movement, p.161) and swings (Complex,
+ *      p.167) -- or takes cover if it cannot reach this turn.
+ *   4. A shooter with a free Simple takes cover if there is any to take
+ *      (Simple, p.166), then fires (Simple, p.165). One attack per
+ *      phase (p.164), so the second Simple is never a second shot.
+ * Nothing here rolls a die of its own: the verbs do.
+ */
+export async function runNpcActionPhase(enc, npc) {
+    const logger = Logger.getInstance();
+    if (npc.isIncapacitated() || npc.surrendered)
+        return;
+    const enemies = enc.enemiesOf(npc);
+    if (enemies.length === 0) {
+        logger.write(`Brain: ${npc.name} has nobody to fight -- phase forfeited.`);
+        return;
+    }
+    const target = pickTarget(npc, enemies);
+    npc.combatOpponent = target;
+    npc.lastExchangeAt = Date.now();
+    let guard = 0;
+    while (guard++ < 6) {
+        const budget = enc.budgetOf(npc);
+        if (!budget || budget.actionsExhausted)
+            return;
+        if (target.isIncapacitated() || target.currentLocation !== npc.currentLocation)
+            return;
+        const weapon = npc.getCarriedWeapon();
+        const firearm = !!weapon?.isFirearm();
+        // 1. Ready Weapon.
+        if (weapon && !npc.weaponDrawn) {
+            const r = await npc.actInCombat('draw');
+            logger.write(`Brain: ${npc.name} draw -> ${r}`);
+            if (!npc.weaponDrawn)
+                return; // refused -- nothing else will go better
+            continue;
+        }
+        // 2. A dry gun: reload if the pack allows, else it is a club.
+        const dry = firearm && (weapon.ammo <= 0);
+        if (dry && !weapon.jammed && hasAmmo(npc)) {
+            const r = await npc.actInCombat('reload');
+            logger.write(`Brain: ${npc.name} reload -> ${r}`);
+            return; // a reload is the phase (p.163 Reloading Weapons)
+        }
+        const melee = !firearm || dry || weapon.jammed;
+        if (melee) {
+            const targetSpot = spotOf(target);
+            if (!canReach(npc, targetSpot)) {
+                const r = await npc.actInCombat(`move to ${targetSpot}`);
+                logger.write(`Brain: ${npc.name} move to ${targetSpot} -> ${r}`);
+                if (!canReach(npc, targetSpot)) {
+                    // Couldn't close this turn: get behind something and wait.
+                    if (!isInCover(npc) && coverAvailableFor(npc) && (enc.budgetOf(npc)?.simple ?? 0) > 0) {
+                        await npc.actInCombat('cover');
+                    }
+                    return;
+                }
+            }
+            const b = enc.budgetOf(npc);
+            if (b?.complexAvailable) {
+                const r = await npc.actInCombat(`attack ${target.name}`);
+                logger.write(`Brain: ${npc.name} attack ${target.name} -> ${r.split('\n')[0]}`);
+            }
+            return;
+        }
+        // Ranged: cover first when both Simples are still on the table.
+        if (!isInCover(npc) && coverAvailableFor(npc) && budget.simple >= 2) {
+            const r = await npc.actInCombat('cover');
+            logger.write(`Brain: ${npc.name} cover -> ${r}`);
+            if (!isInCover(npc))
+                return;
+            continue;
+        }
+        if (!budget.attackTaken && budget.simple >= 1) {
+            const r = await npc.actInCombat(`attack ${target.name}`);
+            logger.write(`Brain: ${npc.name} attack ${target.name} -> ${r.split('\n')[0]}`);
+            if (!enc.budgetOf(npc)?.attackTaken)
+                return; // refused: don't loop on it
+            continue;
+        }
+        return;
+    }
+}
+/** The opponent already engaged, else the nearest of the rest. */
+function pickTarget(npc, enemies) {
+    const engaged = npc.combatOpponent;
+    if (engaged && enemies.includes(engaged))
+        return engaged;
+    const room = npc.currentLocation;
+    let best = enemies[0];
+    let bestD = Number.POSITIVE_INFINITY;
+    for (const e of enemies) {
+        const d = actorDistanceMeters(room, npc, e);
+        if (d < bestD) {
+            best = e;
+            bestD = d;
+        }
+    }
+    return best;
+}
+function hasAmmo(npc) {
+    return npc.inventory.getAllItems().some(i => i.category === Category.Ammunition);
+}
+//# sourceMappingURL=npc-combat-brain.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@maka/maka-cli",
-  "version": "5.134.0",
+  "version": "5.136.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/utilities/auto-fight.js

@@ -1,182 +0,0 @@
-import { Logger } from './logger.js';
-/**
- * Fight-or-flight autopilot -- the FIGHT half. The player sets a
- * temperature (Tab in the UI, or the "stance" command) and the game keeps
- * swinging for them; flight stays manual, always, because stopping YOUR
- * swings never stops THEIRS -- the only real defense is the door, and
- * that's the player's call.
- *
- *   manual     -- counters only. Struck, you strike back (the exchange
- *                 engine answers every swing in EVERY stance -- see
- *                 CombatExchange.resolveStrike's two-way resolution);
- *                 but pressing the fight, chasing, or finishing is yours
- *                 to type. (A real session read "manual" as fully
- *                 passive, saw the built-in counters, and concluded the
- *                 stances were redundant -- they never were; the old
- *                 descriptions were wrong.)
- *   guarded    -- keeps swinging FOR you between exchanges, with a
- *                 conscience: switches to subdue when the target is
- *                 nearly down, and stands down the moment they surrender
- *   aggressive -- keeps swinging until they're dead; surrender means
- *                 nothing
- *
- * Wiring: CombatExchange.finishExchange() -> Scene.notifyExchangeSettled()
- * -> onExchangeSettled() here. If the player was a combatant and the
- * stance says fight, the next action is scheduled a short, interruptible
- * beat later (REENGAGE_DELAY_MS). Submitting ANY command in the UI cancels
- * the pending action and takes over (see ui.ts) -- the beat exists exactly
- * so fleeing and healing stay possible mid-autofight. Everything is
- * revalidated at fire time: the fight may have ended, moved, or been
- * surrendered out of during the delay.
- *
- * Auto actions lead with whatever hits hardest: a caster whose manabolt
- * out-damages their equipped weapon throws the bolt (and eats the drain);
- * everyone else uses the gun/blade/fists they're holding. A dry gun's
- * refusal (reload prompt) is surfaced to the player and auto simply waits
- * for them to deal with it -- reloading is a decision, not a reflex.
- */
-export class AutoFight {
-    game;
-    static REENGAGE_DELAY_MS = 2000;
-    // One pending timer per HUMAN player (symmetric MP: each human's
-    // autopilot runs independently).
-    pending = new Map();
-    constructor(game) {
-        this.game = game;
-    }
-    /** Pending auto actions, dropped. No name = all of them (the local
-     *  player typed, or the stance changed -- ui.ts's call). */
-    cancelPending(playerName) {
-        if (playerName === undefined) {
-            for (const t of this.pending.values())
-                clearTimeout(t);
-            this.pending.clear();
-            return;
-        }
-        const t = this.pending.get(playerName);
-        if (t) {
-            clearTimeout(t);
-            this.pending.delete(playerName);
-        }
-    }
-    /**
-     * Called after every combat exchange resolves (player-involved or not).
-     * Schedules the next action for every HUMAN combatant whose stance
-     * says fight.
-     */
-    onExchangeSettled(combatants) {
-        for (const player of this.game.scene.getPlayers()) {
-            if (!combatants.includes(player))
-                continue;
-            if (player.autoStance === 'manual')
-                continue;
-            const target = combatants.find(c => c !== player);
-            if (!target)
-                continue;
-            this.cancelPending(player.name);
-            const t = setTimeout(() => {
-                this.pending.delete(player.name);
-                void this.fire(player, target);
-            }, AutoFight.REENGAGE_DELAY_MS);
-            this.pending.set(player.name, t);
-        }
-    }
-    /**
-     * The beat elapsed uninterrupted -- act, if the fight still stands.
-     * Every guard here re-checks live state: the target may have died, fled,
-     * surrendered, or started another exchange during the delay.
-     */
-    async fire(player, target) {
-        const logger = Logger.getInstance();
-        if (player.autoStance === 'manual')
-            return;
-        if (player.isIncapacitated() || target.isIncapacitated())
-            return;
-        if (player.currentLocation !== target.currentLocation)
-            return;
-        // Cross-plane fights don't exist: a dump or a return mid-beat (see
-        // utilities/planes.ts) ends the engagement, autopilot included.
-        if (player.plane !== target.plane)
-            return;
-        // A fresh exchange is already in flight -- when IT settles,
-        // onExchangeSettled reschedules us. No waiting here.
-        if (player.inExchange || target.inExchange)
-            return;
-        // Guarded honors a surrender -- but doesn't trust it: the final
-        // action is a RESTRAIN (player request; SR5e Subduing p.195, the
-        // surrendered branch is an automatic no-roll hold). Hands-up
-        // prisoners get zip-tied, not taken at their word. One-shot: an
-        // already-held target (by anyone) means truly stand down, and off
-        // the meat plane there are no hands to hold with.
-        if (player.autoStance === 'non-lethal' && target.surrendered) {
-            if (player.plane === 'meat' && target.plane === 'meat'
-                && player.grappling !== target.name && !target.grappledBy) {
-                const cmd = `restrain ${target.name}`;
-                logger.meta(`⚔ [non-lethal] ${cmd}`, 'cyan');
-                const result = (await this.game.handleInputAs(player.name, cmd)).text;
-                if (result) {
-                    logger.log(result);
-                }
-                this.game.updateStatus();
-                return;
-            }
-            logger.logWithColor(`⚔ ${target.name} has surrendered -- you hold fire. (non-lethal)`, 'yellow');
-            this.game.updateStatus();
-            return;
-        }
-        const cmd = this.chooseAction(player, target);
-        // Cyan, not gray: the autopilot announcing it acted must be legible on
-        // stock dark palettes (gray = ANSI bright-black, near-invisible there).
-        // Mechanics ticker, not the narrative -- the strike it triggers tells
-        // the story in the world log (readability pass).
-        logger.meta(`⚔ [${player.autoStance}] ${cmd}`, 'cyan');
-        const result = (await this.game.handleInputAs(player.name, cmd)).text;
-        // Player-initiated exchanges self-announce ('' result); anything else
-        // (a dry-gun reload prompt, a refusal) is information the player needs.
-        if (result) {
-            logger.log(result);
-        }
-        this.game.updateStatus();
-    }
-    /**
-     * Lead with what hits hardest -- except Guarded near the end, which
-     * finishes non-lethally: when the target is within a few boxes of death,
-     * the next auto action is a subdue (stun damage, bare hands) instead of
-     * another killing blow.
-     */
-    chooseAction(player, target) {
-        // Subduing takes real hands (meat plane only); a guarded decker
-        // "killing" ice is just crashing a program, and astral entities go
-        // down by force -- no non-lethal switch off the meat plane.
-        if (player.autoStance === 'non-lethal' && player.plane === 'meat') {
-            if (target.maxConditionBoxes - target.damageTaken <= 3)
-                return `subdue ${target.name}`;
-            // A gun that can only kill is not what this stance reaches for:
-            // no stun rounds loaded means hands, not lead (p.434).
-            const gun = player.weaponDrawn ? player.getCarriedWeapon() : null;
-            if (gun?.isFirearm() && !gun.isStunWeapon() && !gun.stunAmmo())
-                return `subdue ${target.name}`;
-        }
-        // Magic doesn't compile in the Matrix (see cast.ts); everywhere else,
-        // lead with the harder hit. The autopilot casts at the mage's FULL
-        // safe Force (bolt damage = F - 2, drain billed, never overcast) --
-        // a bare "cast manabolt" would use the drain-neutral default (F3,
-        // damage 1: the Force pass silently gutted the old comparison).
-        // Same safe ceiling as cast.ts: a book-taught mundane works at 4.
-        const boltForce = player.magic > 0 ? player.magic : 4;
-        const boltDamage = Math.max(1, boltForce - 2);
-        if (player.plane !== 'matrix' && player.isCaster() && boltDamage > player.getWeaponProfile().damage) {
-            return `cast manabolt ${boltForce} at ${target.name}`;
-        }
-        return `attack ${target.name}`;
-    }
-    /** One-line HUD/announce description for a stance. */
-    static describe(stance) {
-        switch (stance) {
-            case 'manual': return 'counters when struck (every stance does) -- but pressing the fight is yours to type';
-            case 'non-lethal': return 'presses the fight for you with Stun wherever the gear allows (stun rounds, the flat of the blade, bare hands), subdues when they are nearly down, and RESTRAINS them when they surrender';
-            case 'lethal': return 'presses the fight to the death; surrender means nothing';
-        }
-    }
-}
-//# sourceMappingURL=auto-fight.js.map