@maka/maka-cli 5.134.0 → 5.135.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.135.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.",