@maka/maka-cli 5.133.0 → 5.135.0

package/bundle/typescript/src/commands/game/sideQuest/utilities/movement-cost.js

@@ -0,0 +1,80 @@
+import { Player } from '../models/player.js';
+import { rollPool, formatRoll } from './dice.js';
+import { physicalLimit } from './grapple.js';
+import { hint } from './hints.js';
+import { billAction, encounterOf } from './action-cost.js';
+/**
+ * GROUND COSTS IN A FIGHT (SR5 p.161-162, RAG-checked 2026-09-06).
+ *
+ * The rates are the Player's (walkRateMeters, runRateMeters, the
+ * whole-turn movedMetersThisTurn); this is the one place a crossing is
+ * BILLED against them, shared by move.ts, the melee reach in attack.ts,
+ * and the NPC brain so the three cannot drift:
+ *
+ *   - Up to the Walk Rate, movement is free of actions.
+ *   - "As soon as a character exceeds their Walk Rate they are
+ *     considered Running until the end of the Combat Turn" -- and
+ *     "Running characters must use a Free Action in each Initiative
+ *     Pass they are considered running" (p.162). The first crossing
+ *     that breaks the Walk Rate spends the phase's Free Action; the
+ *     encounter charges it again at the start of every later phase in
+ *     the turn (combat-turn.ts beginPhase). No Free Action left means
+ *     no breaking into a run this phase.
+ *   - Past the Run Rate needs a SPRINT: a Complex Action, Running +
+ *     Strength [Physical], +2 m per hit (+1 for dwarfs and trolls,
+ *     which this engine has no character for -- Player.SPRINT_METERS_PER_HIT).
+ *
+ * Out of combat everything here is a no-op returning undefined: a walk
+ * across a bar is not a Combat Turn.
+ */
+export function spendMovementMeters(scene, actor, meters, mode, logger) {
+    const enc = encounterOf(scene, actor);
+    if (!enc || enc.ended)
+        return undefined;
+    if (meters <= 0)
+        return undefined;
+    if (!enc.isPhaseOf(actor)) {
+        return `It's not your Action Phase -- movement happens on your turn (SR5 p.161).`;
+    }
+    // THE SPRINT (p.162): Complex Action, rolled when asked for, never
+    // applied silently to cover a shortfall.
+    if (mode === 'sprint' && actor.sprintMetersThisTurn === 0) {
+        const bill = billAction(scene, actor, 'complex', 'Sprint');
+        if (bill)
+            return bill;
+        const skill = actor.skillRating('running');
+        const roll = rollPool(Math.max(1, skill + actor.strength + actor.bonus('athletics') + actor.woundModifier), physicalLimit(actor));
+        const bought = roll.hits * Player.SPRINT_METERS_PER_HIT;
+        actor.sprintMetersThisTurn = bought;
+        logger?.meta(`Sprint (Running + Strength [Physical]): ${formatRoll(roll)} -- +${bought} m this turn`);
+    }
+    const left = actor.movementLeftMeters;
+    if (meters > left) {
+        return left <= 0
+            ? `You've covered all your ground this Combat Turn (${actor.runRateMeters} m at a dead run). Nothing left in the legs until the next turn.`
+            : `That's ${meters.toFixed(1)} m and you have ${left.toFixed(1)} m left this turn (Run Rate ${actor.runRateMeters} m).${hint(` ("sprint" buys more ground -- a Complex Action, Running + Strength.)`)}`;
+    }
+    // BREAKING INTO A RUN costs the phase's Free Action (p.162).
+    const wasRunning = actor.isRunningThisTurn;
+    const willRun = actor.movedMetersThisTurn + meters > actor.walkRateMeters;
+    if (willRun && !wasRunning) {
+        const bill = billAction(scene, actor, 'free', 'Run');
+        if (bill) {
+            const walkLeft = Math.max(0, actor.walkRateMeters - actor.movedMetersThisTurn);
+            return `${bill} Running takes a Free Action (SR5 p.162) -- you can still walk ${walkLeft.toFixed(1)} m.`;
+        }
+    }
+    actor.movedMetersThisTurn += meters;
+    return undefined;
+}
+/** A line for the player after a crossing that changed their pace. */
+export function paceNote(scene, actor, wasRunning) {
+    const enc = encounterOf(scene, actor);
+    if (!enc || enc.ended)
+        return '';
+    if (actor.isRunningThisTurn && !wasRunning) {
+        return ` You're RUNNING now -- -2 dice on everything else this Combat Turn, harder to hit at range (SR5 p.162).`;
+    }
+    return '';
+}
+//# sourceMappingURL=movement-cost.js.map

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.133.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.",