@maka/maka-cli 5.134.0 → 5.136.0

package/bundle/typescript/src/commands/game/sideQuest/ui.js

@@ -26,6 +26,9 @@ const MENU_VERBS = new Set([
     // The sprite database reads like the spellbook, so it rides the same
     // panel -- reference you consult, not a menu you spend from.
     'sprites',
+    // The initiative tracker (commands/initiative.ts) is a reference
+    // panel too: who acts when, this Combat Turn.
+    'initiative', 'tracker', 'turn',
 ]);
 // Windows Terminal draws astral-plane emoji (📞 call icon, 📍 HUD pin,
 // 👥 companions, 💀) TWO columns wide, but blessed's 2015-era unicode
@@ -287,9 +290,10 @@ export async function main(playerName, sceneSeed, options) {
         game.updateInventory(game.player.inventory, capitalCase(game.scene.getCurrencyType()));
         game.updateExits(game.player.currentLocation);
         game.updateStatus();
-        // Tab cycles the fight autopilot: manual -> guarded -> aggressive (see
-        // utilities/auto-fight.ts; "stance" is the typed twin). Bound on the
-        // input box because that's where focus lives during play.
+        // Tab flips the stance: lethal <-> non-lethal in the meat, Brute
+        // Force <-> Hack on the Fly on the Matrix (models/player.ts; "stance"
+        // is the typed twin). Bound on the input box because that's where
+        // focus lives during play.
         game.inputBox.key(['tab'], () => {
             // Blessed's textarea reader appends the literal '\t' to the box
             // value on this same keypress (listener order isn't guaranteed
@@ -315,7 +319,7 @@ export async function main(playerName, sceneSeed, options) {
             // bar"). game.player here is the LOCAL HUB player -- in a shared
             // run the runner on the table is a different object in a
             // different process, so cycling this one moved nothing the
-            // autopilot reads and nothing the HUD paints (updateStatus
+            // engine reads and nothing the HUD paints (updateStatus
             // early-returns on remoteSession; the status box belongs to the
             // server's events). Send the typed twin instead and let the
             // engine cycle from the ACTOR's real stance.
@@ -323,10 +327,10 @@ export async function main(playerName, sceneSeed, options) {
                 const res = await game.handleInput('stance next');
                 if (!res)
                     return;
-                // white for manual, not gray -- gray is ANSI bright-black,
-                // illegible on stock dark palettes (same fix as the HUD stance
-                // in game.ts). The Matrix routes borrow the same temperature:
-                // Brute Force is the loud one, Hack on the Fly the careful one.
+                // Red for the lethal routes, yellow for the careful ones (same
+                // palette as the HUD stance in game.ts): Brute Force is the loud
+                // one, Hack on the Fly the careful one. Never gray -- ANSI
+                // bright-black is illegible on stock dark palettes.
                 const named = res.match(/(?:Matrix s|S)tance:\s*([\w-]+)/i)?.[1]?.toLowerCase();
                 const c = named === 'lethal' || named === 'brute' ? 'red'
                     : named === 'non-lethal' || named === 'non' || named === 'hack' ? 'yellow'
@@ -366,10 +370,6 @@ export async function main(playerName, sceneSeed, options) {
                 // still a command you typed and will want to edit and retry.
                 if (opts.recordHistory !== false)
                     history.remember(input);
-                // Typing takes over: any submitted command cancels a pending
-                // auto-fight action (the interruptible beat -- see
-                // utilities/auto-fight.ts). The next settled exchange re-arms it.
-                game.autoFight.cancelPending();
                 // Clear the box the moment the command is submitted, not after
                 // it resolves -- a slow command (combat narration beats, an AI
                 // round trip on a call) used to leave the typed text sitting in

package/bundle/typescript/src/commands/game/sideQuest/utilities/action-budget.js

@@ -0,0 +1,87 @@
+export class ActionBudget {
+    /** Free Actions left this phase (one, p.158). */
+    free = 1;
+    /** Simple Actions left. A Complex Action spends both at once. */
+    simple = 2;
+    /** Whether an attack action has been taken this phase (p.164). */
+    attackTaken = false;
+    /** Everything spent so far, in order, for the tracker. */
+    spent = [];
+    /** A Complex Action needs the whole phase: both Simples unspent. */
+    get complexAvailable() {
+        return this.simple === 2;
+    }
+    /** Nothing left but to end the turn. */
+    get exhausted() {
+        return this.simple === 0 && this.free === 0;
+    }
+    /** The Simple/Complex half is spent -- only a Free Action remains. */
+    get actionsExhausted() {
+        return this.simple === 0;
+    }
+    /**
+     * Why this spend would be refused, or undefined when it is affordable.
+     * Checking never spends; spend() calls this first.
+     */
+    refusalFor(kind, attack = false) {
+        if (kind === 'free') {
+            if (this.free <= 0)
+                return `You've already used your Free Action this Action Phase (SR5 p.158 -- one per phase).`;
+            return undefined;
+        }
+        if (attack && this.attackTaken) {
+            return `You've already attacked this Action Phase -- only one of its actions can be an attack (SR5 p.164). "end turn" and go again next pass.`;
+        }
+        if (kind === 'simple') {
+            if (this.simple <= 0) {
+                return `You've spent both Simple Actions this Action Phase (SR5 p.163)${this.spentComplex() ? ' -- a Complex Action takes the whole phase (p.167)' : ''}. "end turn" to let the next combatant act.`;
+            }
+            return undefined;
+        }
+        // complex
+        if (!this.complexAvailable) {
+            return this.simple === 0
+                ? `Nothing left this Action Phase -- a Complex Action needs the whole phase (SR5 p.167). "end turn".`
+                : `A Complex Action takes the WHOLE Action Phase (SR5 p.167), and you've already spent a Simple Action. Use the other Simple, or "end turn".`;
+        }
+        return undefined;
+    }
+    /** Spends the action; returns the refusal instead when it cannot be paid. */
+    spend(kind, label, attack = false) {
+        const refusal = this.refusalFor(kind, attack);
+        if (refusal)
+            return refusal;
+        if (kind === 'free')
+            this.free -= 1;
+        else if (kind === 'simple')
+            this.simple -= 1;
+        else
+            this.simple = 0;
+        if (attack)
+            this.attackTaken = true;
+        this.spent.push({ kind, label, attack: attack || undefined });
+        return undefined;
+    }
+    spentComplex() {
+        return this.spent.some(s => s.kind === 'complex');
+    }
+    /** One line for the HUD: what is still on the table. */
+    describe() {
+        const parts = [];
+        if (this.simple === 2)
+            parts.push('2 Simple (or 1 Complex)');
+        else if (this.simple === 1)
+            parts.push('1 Simple');
+        else
+            parts.push('no Simple/Complex left');
+        parts.push(this.free > 0 ? '1 Free' : 'no Free');
+        return parts.join(' · ');
+    }
+    /** The phase's ledger, e.g. "Ready Weapon (Simple), Fire (Simple, attack)". */
+    ledger() {
+        if (this.spent.length === 0)
+            return 'nothing yet';
+        return this.spent.map(s => `${s.label} (${s.kind === 'free' ? 'Free' : s.kind === 'simple' ? 'Simple' : 'Complex'}${s.attack ? ', attack' : ''})`).join(', ');
+    }
+}
+//# sourceMappingURL=action-budget.js.map

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

@@ -0,0 +1,66 @@
+import { hint } from './hints.js';
+/** The encounter this actor is fighting in, if any. */
+export function encounterOf(scene, actor) {
+    return scene.encounterFor?.(actor);
+}
+/**
+ * The refusal when it is not this actor's Action Phase -- the wording
+ * every verb shares, so a player learns one sentence.
+ */
+export function notYourPhase(enc, actor) {
+    const who = enc.phaseActor;
+    if (who && who !== actor) {
+        return `It's ${who.name}'s Action Phase -- yours comes round at Initiative ${enc.scoreOf(actor)}.${hint(` ("initiative" shows the order.)`)}`;
+    }
+    return `The pass is resolving -- your Action Phase comes round at Initiative ${enc.scoreOf(actor)}.`;
+}
+/**
+ * Pays for an action, or explains why it cannot be paid. Undefined means
+ * "go ahead" -- out of combat, or in combat with the action affordable
+ * and now spent.
+ */
+export function billAction(scene, actor, kind, label, opts = {}) {
+    const enc = encounterOf(scene, actor);
+    if (!enc || enc.ended)
+        return undefined;
+    if (!enc.isPhaseOf(actor))
+        return notYourPhase(enc, actor);
+    const budget = enc.budgetOf(actor);
+    if (!budget)
+        return notYourPhase(enc, actor);
+    const refusal = budget.spend(kind, label, opts.attack === true);
+    if (refusal)
+        return refusal;
+    // p.166: aiming is lost "if the character takes any other kind of
+    // action (including a Free Action) before attacking". An attack
+    // consumes the bonus at the roll (combat-exchange.ts), so it is left
+    // in place here for the strike to read.
+    if (!opts.aiming && !opts.attack)
+        actor.clearAim();
+    scene.updateStatus?.();
+    return undefined;
+}
+/**
+ * A verb that is refused outright mid-fight unless it is your phase --
+ * for things that are not actions at all but still cannot happen while
+ * someone else is acting (walking out of the room, say).
+ */
+export function requirePhase(scene, actor) {
+    const enc = encounterOf(scene, actor);
+    if (!enc || enc.ended)
+        return undefined;
+    if (!enc.isPhaseOf(actor))
+        return notYourPhase(enc, actor);
+    return undefined;
+}
+/** What is left this phase, for a verb's trailing hint. */
+export function phaseHint(scene, actor) {
+    const enc = encounterOf(scene, actor);
+    const budget = enc?.budgetOf(actor);
+    if (!enc || !budget)
+        return '';
+    return budget.actionsExhausted
+        ? hint(` (${budget.free > 0 ? 'A Free Action left, then ' : ''}"end turn".)`)
+        : hint(` (${budget.describe()} left.)`);
+}
+//# sourceMappingURL=action-cost.js.map

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

@@ -308,6 +308,8 @@ export class CombatExchange {
         if (lines.length > 0)
             this.logger.log(`\n${lines.join('\n')}`, fightScope);
         this.scene.updateStatus();
+        if (process.env.MAKA_NO_BEATS === '1')
+            return;
         await new Promise(resolve => setTimeout(resolve, CombatExchange.BEAT_MS));
     }
     /**
@@ -454,6 +456,94 @@ export class CombatExchange {
      * rebuild AI-history reports as [...world, ...meta] so an NPC's
      * memory of the fight keeps the dice.
      */
+    /**
+     * WHAT THE COMBAT TURN ADDS TO ONE STRIKE (RAG-checked 2026-09-06):
+     *   - TAKE AIM (p.166): +1 per aim on the shot it was for, capped at
+     *     half Willpower; consumed here whether or not it was for this
+     *     target (aiming at one person then shooting another wastes it).
+     *   - CHARGING (p.186): a running attacker closing into melee gets +4
+     *     -- net +2 with the -2 running penalty already in the pool.
+     *   - DEFENDER RUNNING (p.189 Defense Modifiers): +2 to defend
+     *     against a ranged attack.
+     *   - SURPRISE (p.192): a surprised defender gets no Defense Test at
+     *     all against someone who is not.
+     *   - FULL DEFENSE (p.191): +Willpower for the rest of the turn.
+     *   - DODGE / BLOCK / PARRY (p.168): -5 Initiative each, +Gymnastics /
+     *     +Unarmed / +weapon skill on this one test, by the defender's
+     *     standing policy (commands/defend.ts), and only when the score
+     *     can pay.
+     * Outside an encounter only the aim, charge and running lines apply --
+     * they are properties of the actors, not of the turn structure.
+     */
+    turnModifiers(attacker, defender, isMelee, strike, meta) {
+        let attack = 0;
+        let defense = 0;
+        if (attacker.aimBonus > 0 && !isMelee && !strike.isSpell) {
+            if (!attacker.aimTarget || attacker.aimTarget === defender.name) {
+                const aimed = Math.min(attacker.aimBonus, attacker.aimCap);
+                attack += aimed;
+                meta.push(`  Aimed: +${aimed} (Take Aim, p.166)`);
+            }
+            else {
+                meta.push(`  The aim on ${attacker.aimTarget} is wasted on ${defender.name}.`);
+            }
+            attacker.clearAim();
+        }
+        if (isMelee && !strike.isSpell && attacker.isRunningThisTurn) {
+            attack += 4;
+            meta.push(`  Charging: +4 (p.186; the -2 for running is already in the pool)`);
+        }
+        if (!isMelee && defender.isRunningThisTurn) {
+            defense += 2;
+            meta.push(`  ${defender.name} is running: +2 to defend (p.189)`);
+        }
+        const enc = this.scene.encounterFor?.(defender) ?? this.scene.encounterFor?.(attacker);
+        if (!enc)
+            return { attack, defense, noDefense: false };
+        if (enc.isSurprised(defender) && !enc.isSurprised(attacker)) {
+            meta.push(`  ${defender.name} is SURPRISED -- no Defense Test (p.192).`);
+            return { attack, defense, noDefense: true };
+        }
+        if (enc.fullDefenseActive(defender)) {
+            defense += defender.willpower;
+            meta.push(`  Full Defense: +${defender.willpower} Willpower (p.191)`);
+        }
+        const policy = defender.defensePolicy;
+        if (policy !== 'none' && (defender.plane === 'meat' || defender.plane === 'drone')) {
+            let skill = 0;
+            let label = '';
+            let source = '';
+            if (policy === 'dodge') {
+                skill = defender.skillRating('gymnastics');
+                label = 'Dodge';
+                source = 'Gymnastics';
+            }
+            else if (policy === 'block' && isMelee) {
+                skill = defender.skillRating('unarmed');
+                label = 'Block';
+                source = 'Unarmed Combat';
+            }
+            else if (policy === 'parry' && isMelee) {
+                const held = defender.weaponDrawn ? defender.getCarriedWeapon() : null;
+                if (held && !held.isFirearm()) {
+                    skill = defender.skillRating(defender.activeCombatSkill());
+                    label = 'Parry';
+                    source = 'weapon skill';
+                }
+            }
+            if (label && skill > 0) {
+                const refusal = enc.spendInterrupt(defender, 5, label);
+                if (refusal) {
+                    meta.push(`  ${label} not taken: ${refusal}`);
+                }
+                else {
+                    defense += skill;
+                    meta.push(`  ${label}: +${skill} (${source}, -5 Initiative, p.168)`);
+                }
+            }
+        }
+        return { attack, defense, noDefense: false };
+    }
     resolveStrike(attacker, defender, profile) {
         const strike = profile ?? this.weaponProfile(attacker, defender);
         const world = [];
@@ -564,10 +654,16 @@ export class CombatExchange {
         const attackLimit = strike.isSpell
             ? strike.limit
             : (strike.limit ?? attacker.getAttackLimit(strike.weaponItem));
-        const attack = rollPool(strike.pool + directed + rangeMod + attackerFloor + targetDown, attackLimit);
-        const defense = rollPool(defender.getDefensePool() + inspired + counterspell + coverDice + proneDefence);
         const header = `${attacker.name} attacks ${defender.name} ${strike.label}`;
         meta.push(`${header}:`);
+        // THE COMBAT TURN'S MODIFIERS (utilities/combat-turn.ts): Take Aim,
+        // 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, attackLimit);
+        const defense = turn.noDefense
+            ? rollPool(0)
+            : rollPool(defender.getDefensePool() + inspired + counterspell + coverDice + proneDefence + turn.defense);
         const rangeNote = weaponClass && spatial.meters > 0
             ? ` (${rangeMod !== 0 ? `${rangeMod} range` : `${rangeBracketName(spatial.meters, weaponClass)} range`} -- ~${Math.round(spatial.meters)} m)`
             : '';
@@ -899,8 +995,8 @@ export class CombatExchange {
         this.releasePlayerLocks();
         this.releaseExchange();
         this.scene.updateStatus();
-        // The fight autopilot's trigger: a settled exchange involving the
-        // player schedules their next auto action (see utilities/auto-fight.ts).
+        // A settled exchange: the scene lets a KO'd player's watch learn who
+        // is still fighting around them (Scene.notifyExchangeSettled).
         this.scene.notifyExchangeSettled(this._combatants);
         // A spirit whose services ran out departs once the dust settles
         // (RAW p.302: the bargain is spent).
@@ -908,7 +1004,7 @@ export class CombatExchange {
         if (this.scene.isHumanControlled(this.actor)) {
             return '';
         }
-        if (this.playerWitnesses()) {
+        if (this.playerWitnesses() && process.env.MAKA_NO_BEATS !== '1') {
             await new Promise(resolve => setTimeout(resolve, CombatExchange.NPC_FOLLOWUP_PAUSE_MS));
         }
         return report.join('\n');