@maka/maka-cli 5.13.0 → 5.14.1

package/bundle/typescript/src/commands/game/sideQuest/models/scene.js

@@ -7,7 +7,15 @@ import { AbstractScene } from '../types/shared/abstracts.js';
 import { rollPool, formatRoll } from '../utilities/dice.js';
 export class Scene extends AbstractScene {
     story;
-    player;
+    // SYMMETRIC PLAYERS: the scene holds a LIST of human players --
+    // players[0] is the primary (the solo game's one human; the leader's
+    // character in shared runs). The `player` getter keeps the historical
+    // singular reads pointed at players[0]; code that can act for ANY
+    // human should take an explicit actor instead of reaching for it.
+    players;
+    get player() {
+        return this.players[0];
+    }
     logger;
     actors;
     game;
@@ -33,7 +41,7 @@ export class Scene extends AbstractScene {
     currency;
     constructor(config) {
         super();
-        this.player = config.player;
+        this.players = [config.player];
         this.logger = Logger.getInstance();
         this.actors = new Map();
         this.currency = config.currency ?? {
@@ -84,15 +92,22 @@ export class Scene extends AbstractScene {
     // room between an NPC attack's narration beats, mid-exchange. Cleared
     // BEFORE the between-exchanges pause, which stays the legitimate window
     // to flee or heal. NPC-vs-NPC fights elsewhere never set this.
-    _playerExchangeActive = false;
-    beginPlayerExchange() {
-        this._playerExchangeActive = true;
-    }
-    endPlayerExchange() {
-        this._playerExchangeActive = false;
-    }
-    isPlayerExchangeActive() {
-        return this._playerExchangeActive;
+    // Per-player (symmetric multiplayer: two humans can be in two
+    // different fights): the set holds the NAMES of human players whose
+    // exchange is mid-resolution. No-arg calls keep the historical solo
+    // meaning -- begin/end act on the primary player, the query asks
+    // "is ANY human's exchange live".
+    _playerExchangesActive = new Set();
+    beginPlayerExchange(playerName) {
+        this._playerExchangesActive.add(playerName ?? this.player.name);
+    }
+    endPlayerExchange(playerName) {
+        this._playerExchangesActive.delete(playerName ?? this.player.name);
+    }
+    isPlayerExchangeActive(playerName) {
+        if (playerName !== undefined)
+            return this._playerExchangesActive.has(playerName);
+        return this._playerExchangesActive.size > 0;
     }
     /**
      * CombatExchange.finishExchange() -> here -> the fight autopilot (see
@@ -102,13 +117,18 @@ export class Scene extends AbstractScene {
      */
     notifyExchangeSettled(combatants) {
         this.game?.autoFight?.onExchangeSettled?.(combatants);
-        // While the player lies KO'd, every settling exchange is a beat of
+        // While a player lies KO'd, every settling exchange is a beat of
         // the fight still raging around them: learn its hostiles, then see
         // whether the room has settled (see maybeResolvePlayerKnockout).
-        if (this.playerKnockout) {
-            for (const c of combatants) {
-                if (c !== this.player && c.allyOf !== this.player.name) {
-                    this.playerKnockout.hostiles.add(c.name);
+        if (this.playerKnockouts.size > 0) {
+            for (const [name, ko] of this.playerKnockouts) {
+                const p = this.getPlayerByName(name);
+                if (!p)
+                    continue;
+                for (const c of combatants) {
+                    if (c !== p && c.allyOf !== p.name) {
+                        ko.hostiles.add(c.name);
+                    }
                 }
             }
             this.maybeResolvePlayerKnockout();
@@ -126,40 +146,64 @@ export class Scene extends AbstractScene {
     // player comes to with a recovery test; a conscious hostile left
     // standing over them with nobody fighting for them -> the street
     // decides, same as ever.
-    playerKnockout;
-    /** Fight-side entry: the player just dropped from stun. Hostile names
+    /** One pending knockout per HUMAN player, keyed by player name --
+     *  two humans can be down in two different rooms (symmetric MP). */
+    playerKnockouts = new Map();
+    /** Solo-compat view: the PRIMARY player's pending knockout, in the
+     *  historical single-record shape. Multiplayer-aware code should ask
+     *  getKnockout(name) instead. */
+    get playerKnockout() {
+        return this.playerKnockouts.get(this.player.name);
+    }
+    getKnockout(playerName) {
+        return this.playerKnockouts.get(playerName);
+    }
+    /** Fight-side entry: a player just dropped from stun. Hostile names
      *  seed the watch list (grows via notifyExchangeSettled); empty means a
      *  self-inflicted collapse (drain, backlash) with nobody to fear. */
-    beginPlayerKnockout(hostileNames) {
-        if (this.playerKnockout) {
+    beginPlayerKnockout(hostileNames, player = this.player) {
+        const existing = this.playerKnockouts.get(player.name);
+        if (existing) {
             for (const n of hostileNames)
-                this.playerKnockout.hostiles.add(n);
+                existing.hostiles.add(n);
             return;
         }
-        this.playerKnockout = { hostiles: new Set(hostileNames), spurs: 0 };
-        this.addWorldEvent(`${this.player.name} is DOWN -- out cold on the floor of ${this.player.currentLocation.name}.`);
-        this.spurCompanionsForFallenMaster();
+        this.playerKnockouts.set(player.name, { hostiles: new Set(hostileNames), spurs: 0 });
+        this.addWorldEvent(`${player.name} is DOWN -- out cold on the floor of ${player.currentLocation.name}.`);
+        this.spurCompanionsForFallenMaster(player);
         // First reckoning comes after the collapse narration has landed --
         // synchronous evaluation here would print "you come to" (or the
         // game-over) BEFORE the knockout line the caller is still announcing.
-        this.armKnockoutTimer(1500);
+        this.armKnockoutTimer(1500, player);
     }
-    armKnockoutTimer(delayMs) {
-        if (!this.playerKnockout)
+    armKnockoutTimer(delayMs, player) {
+        const ko = this.playerKnockouts.get(player.name);
+        if (!ko)
             return;
-        if (this.playerKnockout.timer)
-            clearTimeout(this.playerKnockout.timer);
-        const t = setTimeout(() => this.maybeResolvePlayerKnockout(true), delayMs);
+        if (ko.timer)
+            clearTimeout(ko.timer);
+        // The reckoning is engine mutation -- with a second human's commands
+        // in flight it must take its turn in the queue like everything else
+        // (M1's deferral, landed here in M2). Solo: the queue is empty and
+        // this is effectively immediate.
+        const t = setTimeout(() => {
+            const q = this.game?.commandQueue;
+            const run = () => this.maybeResolvePlayerKnockout(true, player);
+            if (q)
+                void q.enqueue(run);
+            else
+                run();
+        }, delayMs);
         t.unref?.();
-        this.playerKnockout.timer = t;
+        ko.timer = t;
     }
     /** Hostiles from the watch list still on their feet in the player's
      *  room: present, conscious, and not surrendered. */
-    standingHostiles() {
-        const ko = this.playerKnockout;
+    standingHostiles(player) {
+        const ko = this.playerKnockouts.get(player.name);
         if (!ko)
             return [];
-        const room = this.player.currentLocation;
+        const room = player.currentLocation;
         const out = [];
         for (const name of ko.hostiles) {
             const a = this.getActor(name);
@@ -170,8 +214,8 @@ export class Scene extends AbstractScene {
         return out;
     }
     /** Conscious companions in the player's room -- the reason judgment waits. */
-    consciousAlliesInRoom() {
-        const room = this.player.currentLocation;
+    consciousAlliesInRoom(player) {
+        const room = player.currentLocation;
         return (this.game?.companions ?? [])
             .map(c => c.npc)
             .filter(n => n.currentLocation === room && !n.isIncapacitated());
@@ -179,30 +223,40 @@ export class Scene extends AbstractScene {
     /**
      * The reckoning. Runs on every settled exchange, every surrender, and a
      * heartbeat timer (fights can stall on an idle AI). Quiet no-op unless a
-     * knockout is actually pending and the player is still merely stunned.
+     * knockout is actually pending and that player is still merely stunned.
+     * With no `player` given, sweeps every pending knockout (settled
+     * exchanges and surrenders don't know whose fight just ended).
      */
-    maybeResolvePlayerKnockout(fromTimer = false) {
-        const ko = this.playerKnockout;
+    maybeResolvePlayerKnockout(fromTimer = false, player) {
+        if (!player) {
+            for (const name of [...this.playerKnockouts.keys()]) {
+                const p = this.getPlayerByName(name);
+                if (p)
+                    this.maybeResolvePlayerKnockout(fromTimer, p);
+            }
+            return;
+        }
+        const ko = this.playerKnockouts.get(player.name);
         if (!ko)
             return;
-        if (this.player.isDown()) {
+        if (player.isDown()) {
             // Died for real since the KO (overflow) -- the death flow owns this.
-            this.clearPlayerKnockout();
+            this.clearPlayerKnockout(player);
             return;
         }
-        if (!this.player.isUnconscious()) {
+        if (!player.isUnconscious()) {
             // Something else woke them (a companion's medkit, say).
-            this.clearPlayerKnockout();
+            this.clearPlayerKnockout(player);
             return;
         }
-        const standing = this.standingHostiles();
+        const standing = this.standingHostiles(player);
         if (standing.length === 0) {
-            void this.recoverFromKnockout();
+            void this.recoverFromKnockout(player);
             return;
         }
-        const allies = this.consciousAlliesInRoom();
+        const allies = this.consciousAlliesInRoom(player);
         if (allies.length === 0) {
-            this.streetDecidesKnockout(standing.map(s => s.name));
+            this.streetDecidesKnockout(standing.map(s => s.name), player);
             return;
         }
         // Allies still stand for the player -- the fight goes on. On timer
@@ -211,22 +265,23 @@ export class Scene extends AbstractScene {
         if (fromTimer) {
             ko.spurs += 1;
             if (ko.spurs > 3) {
-                this.streetDecidesKnockout(standing.map(s => s.name));
+                this.streetDecidesKnockout(standing.map(s => s.name), player);
                 return;
             }
-            this.spurCompanionsForFallenMaster();
+            this.spurCompanionsForFallenMaster(player);
         }
-        this.armKnockoutTimer(10000);
+        this.armKnockoutTimer(10000, player);
     }
-    clearPlayerKnockout() {
-        if (this.playerKnockout?.timer)
-            clearTimeout(this.playerKnockout.timer);
-        this.playerKnockout = undefined;
+    clearPlayerKnockout(player) {
+        const ko = this.playerKnockouts.get(player.name);
+        if (ko?.timer)
+            clearTimeout(ko.timer);
+        this.playerKnockouts.delete(player.name);
     }
-    spurCompanionsForFallenMaster() {
-        const standing = this.standingHostiles().map(s => s.name).join(', ');
-        for (const ally of this.consciousAlliesInRoom()) {
-            void Promise.resolve(ally.hear(this.player, `[System note: your master ${this.player.name} is DOWN -- out cold on the floor, still breathing. END the threat NOW${standing ? `: ${standing} still stand${standing.includes(',') ? '' : 's'}` : ''}. Attack with [COMMAND] attack <name> and do not stop until every hostile is down, surrendered, or gone. Do NOT surrender, do NOT wander off.]`, { viaLink: true })).catch(err => {
+    spurCompanionsForFallenMaster(player) {
+        const standing = this.standingHostiles(player).map(s => s.name).join(', ');
+        for (const ally of this.consciousAlliesInRoom(player)) {
+            void Promise.resolve(ally.hear(player, `[System note: your master ${player.name} is DOWN -- out cold on the floor, still breathing. END the threat NOW${standing ? `: ${standing} still stand${standing.includes(',') ? '' : 's'}` : ''}. Attack with [COMMAND] attack <name> and do not stop until every hostile is down, surrendered, or gone. Do NOT surrender, do NOT wander off.]`, { viaLink: true })).catch(err => {
                 this.logger.error(`spurCompanionsForFallenMaster: ${ally.name} failed to hear: ${err}`);
             });
         }
@@ -234,35 +289,47 @@ export class Scene extends AbstractScene {
     /** The room settled with the player's side upright: RAW natural
      *  recovery (p.207), abstracted to the game's job-scale clock the same
      *  way rest is -- unconsciousness itself counted as the rest. */
-    async recoverFromKnockout() {
-        const p = this.player;
-        this.clearPlayerKnockout();
+    async recoverFromKnockout(player) {
+        const p = player;
+        this.clearPlayerKnockout(p);
         const pool = Math.max(1, p.body + p.willpower);
         const roll = rollPool(pool);
         const healed = p.healStun(Math.max(1, roll.hits));
         if (p.isUnconscious()) {
             // Locked fatigue holds the track full -- the body has nothing left.
-            this.streetDecidesKnockout([]);
+            this.streetDecidesKnockout([], p);
             return;
         }
         this.logger.meta(`Recovery (Body ${p.body} + Willpower ${p.willpower}): ${formatRoll(roll)} -- ${healed} stun healed (unconsciousness counts as rest, p.207)`);
-        const allies = this.consciousAlliesInRoom();
+        const allies = this.consciousAlliesInRoom(p);
         const watch = allies.length > 0 ? ` ${allies.map(a => a.name).join(' and ')} stand${allies.length === 1 ? 's' : ''} watch over you.` : '';
         this.logger.logWithColor(`\nTime blurs past on the cold floor... then the world seeps back in. You come to -- the fight is over.${watch}`, 'green');
         this.logger.logWithColor(`You're battered but breathing: ${healed} stun recovered. ${p.stunSummary()}`, 'yellow');
         this.addWorldEvent(`${p.name} came to in ${p.currentLocation.name} after the fight.`);
         this.updateStatus();
     }
-    streetDecidesKnockout(standingNames) {
-        const p = this.player;
-        this.clearPlayerKnockout();
+    streetDecidesKnockout(standingNames, player) {
+        const p = player;
+        this.clearPlayerKnockout(p);
         // DOCWAGON (SR5e p.450, Game.tryDocwagonRescue): a contract's
         // wristband reads the flatline before the street gets its say --
-        // the HTR team extracts the sleeping runner instead.
-        if (this.game?.tryDocwagonRescue?.('htr', { standingHostiles: standingNames })) {
+        // the HTR team extracts the sleeping runner instead. The contract is
+        // the LOCAL save's (primary player); a partied guest's own DocWagon
+        // rides their own session (M3 settles this server-side).
+        if (p === this.players[0] && this.game?.tryDocwagonRescue?.('htr', { standingHostiles: standingNames })) {
             return;
         }
         const who = standingNames.length > 0 ? `with ${standingNames.join(', ')} still standing over you` : `and this time nobody is coming`;
+        this.markPlayerDead(p);
+        // The primary player's death ends the session (permadeath, the solo
+        // path). A non-primary human in a shared run dies for real too --
+        // their save burns via Game.onPlayerDeath -- but the run continues
+        // while any human still stands.
+        if (p !== this.players[0]) {
+            this.game?.onPlayerDeath?.(p);
+            this.logger.logWithColor(`💀 ${p.name} is out cold ${who} -- the street decides what happens to sleeping runners.`, 'red');
+            return;
+        }
         void this.endGame().then(() => {
             this.logger.logWithColor(`💀 GAME OVER: ${p.name} is out cold ${who} -- the street decides what happens to sleeping runners.`, 'red');
             this.logger.logWithColor(`Press ctrl-c to quit.`, 'red');
@@ -340,11 +407,17 @@ export class Scene extends AbstractScene {
         // PLAIN SIGHT (see Room.plainSightItems): the player just watched it
         // scatter, so "take all" must not demand a "search" to sweep it.
         const dropped = [];
+        // Spilled gear lands where the BODY fell -- an item's stale atSpot
+        // from wherever it was last shelved sent a real session hunting a
+        // "counter" that didn't exist in the room (the note had ridden a
+        // crew member's pack from a different scene entirely).
+        const fallSpot = actor.atSpot;
         if (room && actor.inventory) {
             const items = actor.inventory.getAllItems();
             for (const item of items) {
                 const didDrop = actor.inventory.transferItemTo(item.name, room.inventory);
                 if (didDrop) {
+                    item.atSpot = fallSpot;
                     this.logger.write(`${actor.name} dropped ${item.name} into ${room.name} upon removal.`);
                     room.plainSightItems.add(item.name.toLowerCase());
                     dropped.push(item.name);
@@ -362,6 +435,7 @@ export class Scene extends AbstractScene {
                     continue;
                 for (const [slot, item] of Object.entries(group)) {
                     if (item) {
+                        item.atSpot = fallSpot;
                         room.inventory.addItem(item);
                         group[slot] = null;
                         this.logger.write(`${actor.name} dropped equipped ${item.name} into ${room.name} upon removal.`);
@@ -509,7 +583,39 @@ export class Scene extends AbstractScene {
         return this.getRoom(roomNames[0]);
     }
     getPlayer() {
-        return this.player;
+        return this.players[0];
+    }
+    getPlayers() {
+        return this.players;
+    }
+    getPlayerByName(name) {
+        const n = name.toLowerCase();
+        return this.players.find(p => p.name.toLowerCase() === n);
+    }
+    /**
+     * True when `actor` is one of the scene's HUMAN players (vs an NPC or
+     * companion shell). The multiplayer-aware replacement for the old
+     * `actor === scene.getPlayer()` identity checks -- use this wherever
+     * the question is "is this a human" rather than "is this the local
+     * terminal's player".
+     */
+    isHumanControlled(actor) {
+        return this.players.includes(actor);
+    }
+    /** A second human joins the live scene (shared runs, late join):
+     *  spawn them into `room` and register them like any actor. */
+    addPlayer(player, room) {
+        this.players.push(player);
+        player.currentLocation = room;
+        this.addActor(player);
+        room.addActor(player);
+    }
+    /** Human players who died in THIS scene. Solo play ends the game on
+     *  the primary's death before this matters; shared runs continue
+     *  while any human still stands. */
+    deadPlayers = new Set();
+    markPlayerDead(player) {
+        this.deadPlayers.add(player.name);
     }
     isCompleted() {
         return this._completed;
@@ -559,52 +665,34 @@ export class Scene extends AbstractScene {
         if (condition.item.toLowerCase() !== itemName.toLowerCase()) {
             return null;
         }
+        // 'possess' completes when ANY human player ends up holding the
+        // macguffin (symmetric MP: a partied runner's grab counts for the
+        // team); the reward lands in the hands that did the holding.
+        const possessorPlayer = this.getPlayerByName(possessorName);
         const satisfied = condition.type === 'give'
             ? condition.toNpc?.toLowerCase() === possessorName.toLowerCase()
-            : possessorName.toLowerCase() === this.player.name.toLowerCase();
+            : possessorPlayer !== undefined;
         if (!satisfied)
             return null;
         this._completed = true;
         if (condition.rewardItem) {
-            this.player.addInventory(condition.rewardItem);
+            const rewardee = possessorPlayer ?? this.player;
+            rewardee.addInventory(condition.rewardItem);
             this.updateInventory(this.player.inventory);
         }
-        // The agreed pay actually lands -- what the fixer promised (his AI
-        // prompt is told this exact figure, see npc.ts) is what gets paid.
-        // Payments accumulate on ONE certified credstick across jobs: minting
-        // a same-named stick per job would silently overwrite the previous one
-        // in the name-keyed inventory.
+        // THE PAY (canon split, p.28-29): with a CLIENT in the scene, money
+        // moves at the MEET (advance) and the WRAP-UP (remainder) -- see
+        // Game.onClientInteraction -- so completion itself pays nothing
+        // here. Legacy/classic scenes (no client on the seed) keep the
+        // original instant payout.
         let paymentNote = '';
-        if (condition.payout && condition.payout > 0) {
-            const PAYSTICK_NAME = 'Certified Credstick (job payments)';
-            let paystick = this.player.inventory.getAllItems().find(i => i.name === PAYSTICK_NAME);
-            if (!paystick) {
-                paystick = new Item({
-                    name: PAYSTICK_NAME,
-                    description: 'A matte-black certified credstick. Every job that pays out lands here, clean.',
-                    size: Size.Tiny, category: Category.Credstick,
-                    shape: 'Rectangle', color: 'Matte Black', texture: 'Smooth',
-                    rating: Rating.Standard, weight: 0.05, transferable: true,
-                });
-                try {
-                    this.player.addInventory(paystick);
-                }
-                catch {
-                    paystick = undefined; // over the carry cap somehow -- log, don't crash the win
-                    this.logger.error(`Could not hand the player their payment credstick (carry weight).`);
-                }
-            }
-            if (paystick) {
-                // SINner (p.84-85): a certified payment to a SIN on file gets its
-                // cut skimmed before it ever lands -- the drain that makes the
-                // negative quality's karma refund an honest trade.
-                const taxRate = this.player.sinTaxRate;
-                const tax = Math.floor(condition.payout * taxRate);
-                const netPay = condition.payout - tax;
-                paystick.addCurrency(netPay);
-                this.updateInventory(this.player.inventory);
-                this.logger.write(`Job payout: ${netPay} nuyen credited to "${PAYSTICK_NAME}"${tax > 0 ? ` (${tax} withheld: SIN tax ${Math.round(taxRate * 100)}%)` : ''}.`);
-                paymentNote = `\nPayment received: ${netPay}¥, certified. It's on your stick.${tax > 0 ? `\nSIN on file: ${tax}¥ withheld at source (${Math.round(taxRate * 100)}% -- the system never forgets your number).` : ''}`;
+        const clientHandlesPay = !!this.game?.currentClient;
+        if (!clientHandlesPay && condition.payout && condition.payout > 0) {
+            // Legacy instant path still splits with the crew (canon team take).
+            const split = this.game?.applyCrewCut(condition.payout) ?? { share: condition.payout, line: '' };
+            const paid = this.payRunner(split.share, 'job payout');
+            if (paid) {
+                paymentNote = `\nPayment received: ${paid.net}¥, certified. It's on your stick.${split.line ? `\n${split.line}` : ''}${paid.tax > 0 ? `\nSIN on file: ${paid.tax}¥ withheld at source (${Math.round(this.player.sinTaxRate * 100)}% -- the system never forgets your number).` : ''}`;
             }
         }
         this.addWorldEvent(`${possessorName} ended up with ${itemName} -- the job is done.`);
@@ -626,14 +714,78 @@ export class Scene extends AbstractScene {
         const karmaNote = `\nKarma earned: ${karmaEarned} (${this.player.karma} banked${hint(` -- "advance" at your hideout to train`)}).${credNote}`;
         // Hub sessions go HOME between jobs (walking into the hideout takes
         // you back -- see go.ts); classic sessions get the next job from the
-        // fixer over comms. No system verbs in either path.
+        // fixer over comms. No system verbs in either path. With a client
+        // holding the purse, the banner points at the WRAP-UP instead of the
+        // curb -- the remainder is theirs to hand over (p.29: "deliver...
+        // collect the remainder of your pay").
+        const client = this.game?.currentClient;
+        const settleLine = clientHandlesPay && client && !client.reported
+            ? `\nThe balance is with ${client.name} -- settle up before you skip town (talk to them, or call).`
+            : '';
         const nextStep = this.game?.hasHub
             ? hint(`"call taxi" from the curb when you're ready to head home.`)
             : hint(`Call your Johnson when you're ready for more work, or "quit" to stop here.`);
-        const banner = `${condition.completionMessage}${paymentNote}${karmaNote}\n\n=== JOB COMPLETE ===\n${nextStep}`;
+        const banner = `${condition.completionMessage}${paymentNote}${karmaNote}${settleLine}\n\n=== ${clientHandlesPay ? 'OBJECTIVE COMPLETE' : 'JOB COMPLETE'} ===\n${nextStep}`;
         this.logger.logWithColor(banner, 'green');
         return banner;
     }
+    /**
+     * Money actually landing in the runner's hands: accumulates on ONE
+     * certified credstick across jobs (minting a same-named stick per job
+     * would silently overwrite in the name-keyed inventory), with the
+     * SINner tax (p.84-85) skimmed at source. Shared by the meet advance,
+     * the wrap-up remainder (Game.onClientInteraction), and the legacy
+     * instant payout above. Returns what moved, or undefined when the
+     * stick couldn't be handed over.
+     */
+    payRunner(amount, label) {
+        if (!amount || amount <= 0)
+            return undefined;
+        // CANON TEAM SPLIT (symmetric MP): the take divides evenly among the
+        // living human players -- each runner's share lands on their OWN
+        // certified stick, taxed at their own SIN rate. Solo: one human,
+        // whole take, byte-identical to the historical path. The return is
+        // the PRIMARY's movement (what the existing solo call sites print).
+        const humans = this.players.filter(p => !this.deadPlayers.has(p.name));
+        if (humans.length <= 1) {
+            return this.payOne(humans[0] ?? this.player, amount, label);
+        }
+        const share = Math.floor(amount / humans.length);
+        let primaryResult;
+        for (const p of humans) {
+            const paid = this.payOne(p, share, `${label} (team split, 1/${humans.length})`);
+            if (p === this.player)
+                primaryResult = paid;
+        }
+        return primaryResult;
+    }
+    payOne(player, amount, label) {
+        const PAYSTICK_NAME = 'Certified Credstick (job payments)';
+        let paystick = player.inventory.getAllItems().find(i => i.name === PAYSTICK_NAME);
+        if (!paystick) {
+            paystick = new Item({
+                name: PAYSTICK_NAME,
+                description: 'A matte-black certified credstick. Every job that pays out lands here, clean.',
+                size: Size.Tiny, category: Category.Credstick,
+                shape: 'Rectangle', color: 'Matte Black', texture: 'Smooth',
+                rating: Rating.Standard, weight: 0.05, transferable: true,
+            });
+            try {
+                player.addInventory(paystick);
+            }
+            catch {
+                this.logger.error(`Could not hand ${player.name} their payment credstick (carry weight).`);
+                return undefined;
+            }
+        }
+        const taxRate = player.sinTaxRate;
+        const tax = Math.floor(amount * taxRate);
+        const net = amount - tax;
+        paystick.addCurrency(net);
+        this.updateInventory(this.player.inventory);
+        this.logger.write(`${label}: ${net} nuyen credited to "${PAYSTICK_NAME}" (${player.name})${tax > 0 ? ` (${tax} withheld: SIN tax ${Math.round(taxRate * 100)}%)` : ''}.`);
+        return { net, tax };
+    }
     addWorldEvent(event) {
         this._worldEvents.push(event);
         if (this._worldEvents.length > this._maxWorldEvents) {
@@ -682,7 +834,7 @@ export class Scene extends AbstractScene {
         return Object.values(this.rooms).some(room => room.inventory.getAllItems().some(item => item.satisfiesLifestyle?.addictionTypes?.includes(addiction)));
     }
     validateLifestyleSupport() {
-        const allActors = [this.player, ...this.allActors];
+        const allActors = [...this.players, ...this.allActors];
         for (const actor of allActors) {
             const lifestyle = actor.lifestyleChoices ?? [];
             const name = actor.name;