// Guildlings — Manager Entity — Letters of Importance integrated // Owns all campaign state. Processes player actions via onInteract. // Phase order: intake → planning → operations → reports → review → (next day) intake // 28-day campaign. var C = require('lib/constants.js'); var DATA = require('lib/content.js'); var NAMES = require('lib/names.js'); var RISK = require('lib/risk.js'); var BOARD = require('lib/board-review.js'); var RENOWN = require('lib/renown.js'); var EFFECT_ENGINE = require('lib/effect-engine.js'); var TDATA = require('lib/traits-data.js'); var QDATA = require('lib/quirks-data.js'); var SKEYS = require('lib/storage-keys.js'); var FAC = require('lib/factions.js'); var INTEL = require('lib/intel.js'); var LETTERS = require('lib/letters-actions.js'); var SEASON = require('lib/season.js'); // SFX helper — scales volume by player's sfxVolume setting (0-100) function sfx(api, clip, baseVol, audience) { // Read sfxVolume from the target player var vol = 50; // default var pid = null; if (audience && audience.kind === 'player' && audience.id) { pid = audience.id; } if (pid) { var ps = api.getObjectState(pid); if (ps && ps.sfxVolume != null) vol = ps.sfxVolume; } if (vol <= 0) return; // muted — skip entirely var finalVol = baseVol * (vol / 50); var opts = { volume: finalVol }; if (audience) opts.audience = audience; api.playSound(clip, opts); } // ─── THEME HELPERS ────────────────────────────────────────────── var DWARVEN = null; function getDwarven() { if (!DWARVEN) DWARVEN = require('lib/dwarven-content.js'); return DWARVEN; } function getActiveTheme(api) { var players = api.query({ tags: ['player'] }); if (players.length > 0) { var ps = api.getObjectState(players[0].id); if (ps && ps.cosmetics && ps.cosmetics.activeTheme) return ps.cosmetics.activeTheme; } return 'none'; } function getThemedContracts(theme) { if (theme === 'dwarven_undermountain') { var dw = getDwarven(); return dw.DWARVEN_CONTRACTS || DATA.contracts; } return DATA.contracts; } function getThemedRaces(theme) { if (theme === 'dwarven_undermountain') { var dw = getDwarven(); return dw.DWARVEN_RACES || DATA.RACES; } return DATA.RACES; } function generateThemedName(api, usedNames, theme, race) { if (theme !== 'dwarven_undermountain') return NAMES.generateName(api, usedNames); var dw = getDwarven(); var firsts, lasts; if (race === 'undermountain_human' || race === 'delveborn_human') { firsts = dw.DWARVEN_HUMAN_FIRST || []; lasts = dw.DWARVEN_HUMAN_LAST || []; } else if (race === 'stone_gnome' || race === 'tinker_gnome') { firsts = dw.DWARVEN_GNOME_FIRST || []; lasts = dw.DWARVEN_GNOME_LAST || []; } else if (race === 'forge_halfling' || race === 'tunnel_halfling') { firsts = dw.DWARVEN_HALFLING_FIRST || []; lasts = dw.DWARVEN_HALFLING_LAST || []; } else if (race === 'cave_goblin' || race === 'soot_goblin') { firsts = dw.DWARVEN_GOBLIN_FIRST || []; lasts = dw.DWARVEN_GOBLIN_LAST || []; } else { firsts = dw.DWARVEN_FIRST_NAMES || []; lasts = dw.DWARVEN_LAST_NAMES || []; } if (firsts.length === 0 || lasts.length === 0) return NAMES.generateName(api, usedNames); var attempts = 0; while (attempts < 50) { var first = firsts[Math.floor(api.random() * firsts.length)]; var last = lasts[Math.floor(api.random() * lasts.length)]; var name = first + ' ' + last; if (!usedNames[name] && name.length <= 18) { usedNames[name] = true; return name; } attempts++; } return firsts[0] + ' ' + lasts[0]; } var PHASE_ORDER = ['intake', 'planning', 'operations', 'reports']; // ─── ECONOMY EFFECT HELPERS ───────────────────────────────────── // Evaluates economy/admin effects from a guildling's traits and quirks // using the data tables. The effect engine's evaluateEffects() already // captures weekly_trigger and weekly_passive types in ledger.weeklyPassives, // but flat_bonus / conditional_bonus with targetKind:'economy' are not // routed to any output bucket. This helper reads both paths and returns // a unified modifier map keyed by economy target. // // Returns: { onboarding_fee: N, weekly_payroll: N, reputation: N, // gold_per_tier: N, onboarding_cost: N, payroll_cost: N } function getEconomyModifiers(guildling, context) { var mods = {}; // 1. Read weeklyPassives from the effect engine ledger var ledger = EFFECT_ENGINE.evaluateEffects(guildling, context); if (ledger && ledger.weeklyPassives) { for (var i = 0; i < ledger.weeklyPassives.length; i++) { var wp = ledger.weeklyPassives[i]; var tgt = wp.target || ''; mods[tgt] = (mods[tgt] || 0) + (wp.value || 0); } } // 2. Scan trait definitions for flat_bonus/conditional_bonus with // targetKind:'economy' — these are NOT captured by the effect engine. if (guildling.traits) { for (var t = 0; t < guildling.traits.length; t++) { var traitDef = TDATA.TRAITS_MASTER[guildling.traits[t]]; if (!traitDef || !traitDef.effects) continue; for (var e = 0; e < traitDef.effects.length; e++) { var eff = traitDef.effects[e]; if (eff.targetKind !== 'economy') continue; if (eff.type !== 'flat_bonus' && eff.type !== 'conditional_bonus') continue; // Evaluate condition via the engine if (!EFFECT_ENGINE.evaluateCondition(eff.when, context, guildling)) continue; var tgt2 = eff.target || ''; mods[tgt2] = (mods[tgt2] || 0) + (eff.value || 0); } } } // 3. Scan quirk definition for the same pattern if (guildling.quirk) { var quirkDef = QDATA.QUIRKS_MASTER[guildling.quirk]; if (quirkDef && quirkDef.effects) { for (var q = 0; q < quirkDef.effects.length; q++) { var qeff = quirkDef.effects[q]; if (qeff.targetKind !== 'economy') continue; if (qeff.type !== 'flat_bonus' && qeff.type !== 'conditional_bonus') continue; if (!EFFECT_ENGINE.evaluateCondition(qeff.when, context, guildling)) continue; var tgt3 = qeff.target || ''; mods[tgt3] = (mods[tgt3] || 0) + (qeff.value || 0); } } } return mods; } // ─── PAYROLL CALCULATION ──────────────────────────────────────── function calculatePayroll(roster, state) { var total = 0; for (var i = 0; i < roster.length; i++) { var g = roster[i]; var gPay = g.payrollCost || 0; // ── Phase 17D: Trait/quirk payroll modifiers via effect engine ── // Build a minimal context for economy evaluation (no active contract) var econCtx = EFFECT_ENGINE.buildContext(null, [g], [], 'standard', g.weekly || {}); var econMods = getEconomyModifiers(g, econCtx); // Apply weekly_payroll modifier (from traits like Modest Expectations -2g). // Exclude low_maintenance's -1g here — its weekly_trigger with next_cycle flag // means the discount is gated by the lowMaintenanceNextCycle flag set during // week rollover, not by realtime evaluation. getEconomyModifiers includes it // because evaluateCondition('weekly_no_injury') defaults true, so we subtract // it back out and apply via the flag below. var payrollMod = econMods.weekly_payroll || 0; // Check if low_maintenance contributed and back it out if (g.traits) { for (var lci = 0; lci < g.traits.length; lci++) { var lcDef = TDATA.TRAITS_MASTER[g.traits[lci]]; if (lcDef && lcDef.effects) { for (var lce = 0; lce < lcDef.effects.length; lce++) { var lcEff = lcDef.effects[lce]; if (lcEff.type === 'weekly_trigger' && lcEff.targetKind === 'economy' && lcEff.target === 'weekly_payroll' && lcEff.flags && lcEff.flags.next_cycle) { payrollMod -= (lcEff.value || 0); // subtract the -1 back out } } } } } gPay += payrollMod; // Apply payroll_cost modifier (from quirks like Expensive Tastes +2g) if (econMods.payroll_cost) { gPay += econMods.payroll_cost; } // Low Maintenance: -1g payroll if lowMaintenanceNextCycle flag was set at week rollover if (g.weekly && g.weekly.lowMaintenanceNextCycle) { gPay -= 1; } // Floor at 1g per guildling if (gPay < 1) gPay = 1; total += gPay; } // Deferred debt surcharge: +20% of outstanding debt var deferredDebt = (state && state.deferredDebt) ? state.deferredDebt : 0; if (deferredDebt > 0) { total += Math.ceil(deferredDebt * 0.2); } return total; } // ─── CONTRACT GENERATION ──────────────────────────────────────── function generateContracts(api) { var state = api.getState(); var renown = RENOWN.calculateRenown(state.reputation || 0); var boardSize = RENOWN.getContractBoardSize(renown); var tierBand = RENOWN.getContractTierBand(renown); // Resolve active theme for contract pool var _theme = getActiveTheme(api); var _contractSource = getThemedContracts(_theme); // Pool all contracts within the tier band var pool = []; for (var i = 0; i < _contractSource.length; i++) { var c = _contractSource[i]; if (c.tier >= tierBand.min && c.tier <= tierBand.max) { pool.push(c); } } // Shuffle helper using api.random() function shuffle(arr) { var a = arr.slice(); for (var j = a.length - 1; j > 0; j--) { var k = Math.floor(api.random() * (j + 1)); var tmp = a[j]; a[j] = a[k]; a[k] = tmp; } return a; } pool = shuffle(pool); // Try to avoid repeating last day's contracts var lastIds = {}; if (state.lastDayContractIds) { for (var g = 0; g < state.lastDayContractIds.length; g++) { lastIds[state.lastDayContractIds[g]] = true; } } // Partition: non-repeats first, then repeats var fresh = []; var repeats = []; for (var p = 0; p < pool.length; p++) { if (lastIds[pool[p].id]) { repeats.push(pool[p]); } else { fresh.push(pool[p]); } } var orderedPool = fresh.concat(repeats); // Variety rules tracking var picks = []; var hazardTagCount = {}; var vectorsRepresented = {}; var hasSafe = false; // at least 1 lowest-tier contract var lowestTier = tierBand.min; // Day 1: always include the tutorial contract as the first pick if (state.day === 1) { var tutorialContract = null; for (var tc = 0; tc < _contractSource.length; tc++) { if (_contractSource[tc].id === 'c-tutorial') { tutorialContract = _contractSource[tc]; break; } } if (tutorialContract) { picks.push(tutorialContract); // Record it so variety tracking stays consistent var tutTags = tutorialContract.hazardTags || []; for (var tt = 0; tt < tutTags.length; tt++) { hazardTagCount[tutTags[tt]] = (hazardTagCount[tutTags[tt]] || 0) + 1; } hasSafe = true; var tutTop = null; var tutBestVal = -1; var tutInt = tutorialContract.intensities; var tutKeys = Object.keys(tutInt); for (var tk = 0; tk < tutKeys.length; tk++) { if (tutInt[tutKeys[tk]] > tutBestVal) { tutBestVal = tutInt[tutKeys[tk]]; tutTop = tutKeys[tk]; } } if (tutTop) vectorsRepresented[tutTop] = true; // Remove tutorial from ordered pool so it doesn't get picked again for (var tr = orderedPool.length - 1; tr >= 0; tr--) { if (orderedPool[tr].id === 'c-tutorial') { orderedPool.splice(tr, 1); break; } } } } function getTopVector(contract) { var best = null; var bestVal = -1; var intensities = contract.intensities; var keys = Object.keys(intensities); for (var v = 0; v < keys.length; v++) { if (intensities[keys[v]] > bestVal) { bestVal = intensities[keys[v]]; best = keys[v]; } } return best; } function canPick(contract) { // Max 2 contracts sharing same hazard tag var tags = contract.hazardTags || []; for (var t = 0; t < tags.length; t++) { if ((hazardTagCount[tags[t]] || 0) >= 2) return false; } return true; } function recordPick(contract) { var tags = contract.hazardTags || []; for (var t = 0; t < tags.length; t++) { hazardTagCount[tags[t]] = (hazardTagCount[tags[t]] || 0) + 1; } var top = getTopVector(contract); if (top) vectorsRepresented[top] = true; if (contract.tier === lowestTier) hasSafe = true; } // First pass: ensure at least 1 safe (lowest tier) for (var s = 0; s < orderedPool.length; s++) { if (orderedPool[s].tier === lowestTier && canPick(orderedPool[s])) { picks.push(orderedPool[s]); recordPick(orderedPool[s]); orderedPool.splice(s, 1); break; } } // Fill remaining slots for (var q = 0; q < orderedPool.length && picks.length < boardSize; q++) { if (canPick(orderedPool[q])) { picks.push(orderedPool[q]); recordPick(orderedPool[q]); } } // Check vector variety: need at least 2 different top vectors // If not met, try swapping in contracts with different vectors var vectorCount = Object.keys(vectorsRepresented).length; if (vectorCount < 2 && pool.length > picks.length) { for (var vc = 0; vc < pool.length && vectorCount < 2; vc++) { var cv = getTopVector(pool[vc]); if (cv && !vectorsRepresented[cv]) { // Try to replace the last pick that shares an existing vector for (var rp = picks.length - 1; rp >= 1; rp--) { var rpv = getTopVector(picks[rp]); if (rpv && vectorsRepresented[rpv] && Object.keys(vectorsRepresented).length >= 1) { picks[rp] = pool[vc]; vectorsRepresented[cv] = true; vectorCount = Object.keys(vectorsRepresented).length; break; } } } } } // Deep copy the picks var result = []; for (var m = 0; m < picks.length; m++) { result.push(JSON.parse(JSON.stringify(picks[m]))); } // ── Guaranteed routine contract when safety is low (Doc S §Negative Spiral Protection) ── // If safety is critical or poor and no tier 1 contract is on the board, inject one. var currentSafety = state.safety != null ? state.safety : C.startingSafety; if (currentSafety <= C.safetyRoutineContractThreshold) { var hasRoutine = false; for (var rt = 0; rt < result.length; rt++) { if (result[rt].tier === 1) { hasRoutine = true; break; } } if (!hasRoutine) { // Find a tier 1 contract from the full contract list var routinePool = []; for (var rp2 = 0; rp2 < _contractSource.length; rp2++) { if (_contractSource[rp2].tier === 1) { routinePool.push(_contractSource[rp2]); } } if (routinePool.length > 0) { var routinePick = routinePool[Math.floor(api.random() * routinePool.length)]; // Replace the last slot (preserving the safe/lowest-tier pick at front) result[result.length - 1] = JSON.parse(JSON.stringify(routinePick)); } } } // ── Letters of Importance: assign factions + hydrate intel ── if (isLettersEnabled(api)) { var loiStandings = state.factionStandings || FAC.getDefaultFactionStandings(); result = assignFactions(result, loiStandings, function() { return api.random(); }); for (var li = 0; li < result.length; li++) { var liCert = INTEL.assignCertainty(function() { return api.random(); }); result[li].intel = INTEL.hydrateContractIntel( result[li], result[li].factionId, liCert, function() { return api.random(); } ); } // ── Anti-spiral board guarantees ── // 1) At least 1 routine (safe) contract on every board var hasRoutine = false; for (var aspi = 0; aspi < result.length; aspi++) { if (result[aspi].intel && result[aspi].intel.certainty === 'routine') { hasRoutine = true; break; } } if (!hasRoutine && result.length > 0) { result[0].intel.certainty = 'routine'; result[0].intel.hiddenFields = {}; } // 2) At least 2 contracts with hidden fields (inspection vectors) var inspectableCount = 0; for (var aspi2 = 0; aspi2 < result.length; aspi2++) { if (result[aspi2].intel && result[aspi2].intel.hiddenFields && Object.keys(result[aspi2].intel.hiddenFields).length > 0) inspectableCount++; } while (inspectableCount < 2 && result.length >= 3) { for (var aspi3 = 1; aspi3 < result.length; aspi3++) { if (result[aspi3].intel && result[aspi3].intel.certainty === 'routine' && (!result[aspi3].intel.hiddenFields || Object.keys(result[aspi3].intel.hiddenFields).length === 0)) { result[aspi3].intel = INTEL.hydrateContractIntel(result[aspi3], result[aspi3].factionId, 'variable', function() { return api.random(); }); inspectableCount++; break; } } if (inspectableCount < 2) break; } // ── Goodwill catch-up: inject low-risk offers from hostile/cold factions ── result = injectGoodwillContracts(result, loiStandings, state, api); } return result; } var STAT_KEYS = ['might', 'guard', 'focus', 'wit', 'charm', 'luck']; var CLASS_IDS = Object.keys(DATA.classes); function nextPhase(current) { // boardReview and campaignEnd are handled specially in advancePhase, not in PHASE_ORDER if (current === 'boardReview' || current === 'campaignEnd') return null; var idx = PHASE_ORDER.indexOf(current); if (idx < 0) return 'intake'; if (idx >= PHASE_ORDER.length - 1) return null; // end of day return PHASE_ORDER[idx + 1]; } // ─── CLAMP HELPER ─────────────────────────────────────────────── function clamp(v, lo, hi) { return v < lo ? lo : (v > hi ? hi : v); } // ─── LETTERS OF IMPORTANCE CHECK ──────────────────────────────── function isLettersEnabled(api) { var state = api.getState(); return !!(state.lettersEnabled); } // ─── GOODWILL CATCH-UP CONTRACTS ──────────────────────────────── // When a faction's standing is hostile or cold, occasionally inject // a low-risk, low-tier contract from them as an olive branch. // This gives the player a way to recover standing through gameplay. function injectGoodwillContracts(contracts, standings, state, api) { if (!contracts || contracts.length === 0) return contracts; var hostileFactions = []; var coldFactions = []; for (var i = 0; i < FAC.FACTION_IDS.length; i++) { var fid = FAC.FACTION_IDS[i]; var val = (standings && standings[fid]) || 0; var band = FAC.getStandingBand(val); if (band === 'hostile') hostileFactions.push(fid); else if (band === 'cold') coldFactions.push(fid); } // No damaged relations → nothing to inject if (hostileFactions.length === 0 && coldFactions.length === 0) return contracts; // Chance per hostile: 40%; per cold: 20%. Only one goodwill contract per board. var candidate = null; for (var h = 0; h < hostileFactions.length; h++) { if (api.random() < 0.40) { candidate = hostileFactions[h]; break; } } if (!candidate) { for (var c = 0; c < coldFactions.length; c++) { if (api.random() < 0.20) { candidate = coldFactions[c]; break; } } } if (!candidate) return contracts; // Find a tier-1 contract to use as the goodwill base // (already on the board — we'll re-tag it as a goodwill offer from the candidate faction) var slotIdx = -1; for (var s = contracts.length - 1; s >= 0; s--) { if (contracts[s].tier <= 2) { slotIdx = s; break; } } if (slotIdx < 0) slotIdx = contracts.length - 1; // fallback: last slot // Tag the contract as a goodwill offer contracts[slotIdx].factionId = candidate; contracts[slotIdx].isGoodwill = true; // Goodwill contracts get 'routine' certainty — no hidden surprises if (contracts[slotIdx].intel) { contracts[slotIdx].intel.certainty = 'routine'; contracts[slotIdx].intel.hiddenFields = {}; contracts[slotIdx].intel.complications = []; } // Hydrate fresh intel for the goodwill slot (will be overwritten as routine below) contracts[slotIdx].intel = INTEL.hydrateContractIntel( contracts[slotIdx], candidate, 'routine', function() { return api.random(); } ); // Force routine — goodwill contracts are transparent contracts[slotIdx].intel.certainty = 'routine'; contracts[slotIdx].intel.hiddenFields = {}; contracts[slotIdx].intel.complications = []; return contracts; } // ─── FACTION ASSIGNMENT FOR BOARD ─────────────────────────────── // Assigns a factionId to each contract on the board, // respecting standing weights and board variety rules. function assignFactions(contracts, standings, random) { if (!contracts || contracts.length === 0) return contracts; var boardRules = FAC.BOARD_RULES; var maxPerFaction = Math.max(1, Math.ceil(contracts.length * boardRules.maxFactionPercent)); var factionCounts = {}; // Build weighted faction list based on standings var factionWeights = []; var totalWeight = 0; for (var fi = 0; fi < FAC.FACTION_IDS.length; fi++) { var fid = FAC.FACTION_IDS[fi]; var standing = (standings && standings[fid]) || 0; var band = FAC.getStandingBand(standing); var w = FAC.OFFER_WEIGHTS[band] || 1.0; factionWeights.push({ id: fid, weight: w }); totalWeight += w; factionCounts[fid] = 0; } // Weighted random pick respecting caps function pickFaction() { // Try weighted pick var roll = random() * totalWeight; var cumulative = 0; for (var j = 0; j < factionWeights.length; j++) { cumulative += factionWeights[j].weight; if (roll < cumulative) { if (factionCounts[factionWeights[j].id] < maxPerFaction) { return factionWeights[j].id; } break; } } // Fallback: pick any faction under cap for (var k = 0; k < factionWeights.length; k++) { if (factionCounts[factionWeights[k].id] < maxPerFaction) { return factionWeights[k].id; } } // Last resort: round-robin return FAC.FACTION_IDS[Math.floor(random() * FAC.FACTION_IDS.length)]; } // Ensure minimum faction diversity var uniqueFactions = {}; for (var ci = 0; ci < contracts.length; ci++) { var chosenFaction = pickFaction(); contracts[ci].factionId = chosenFaction; factionCounts[chosenFaction]++; uniqueFactions[chosenFaction] = true; } // If below minimum faction count and board is big enough, swap duplicates var uniqueCount = Object.keys(uniqueFactions).length; if (uniqueCount < boardRules.minFactions && contracts.length >= boardRules.minFactions) { var missing = []; for (var mi = 0; mi < FAC.FACTION_IDS.length; mi++) { if (!uniqueFactions[FAC.FACTION_IDS[mi]]) missing.push(FAC.FACTION_IDS[mi]); } // Find contracts from over-represented factions and reassign for (var si = contracts.length - 1; si >= 0 && missing.length > 0 && uniqueCount < boardRules.minFactions; si--) { var currentFac = contracts[si].factionId; if (factionCounts[currentFac] > 1) { var newFac = missing.pop(); contracts[si].factionId = newFac; factionCounts[currentFac]--; factionCounts[newFac] = (factionCounts[newFac] || 0) + 1; uniqueFactions[newFac] = true; uniqueCount++; } } } return contracts; } // ─── APPLICANT GENERATION ─────────────────────────────────────── // Helper: weighted severity pick from { mild: N, medium: N, spicy: N } function weightedSeverityPick(weights, rng) { var total = (weights.mild || 0) + (weights.medium || 0) + (weights.spicy || 0); if (total <= 0) return 'mild'; // guard against degenerate zero-total weights var roll = rng() * total; if (roll < weights.mild) return 'mild'; if (roll < weights.mild + weights.medium) return 'medium'; return 'spicy'; } // Helper: check if adding traitId conflicts with already-selected traits function isTraitBannedByTraits(traitId, selectedTraits) { var traitDef = TDATA.TRAITS_MASTER[traitId]; if (!traitDef) return false; for (var i = 0; i < selectedTraits.length; i++) { var selId = selectedTraits[i]; // Check the candidate's own bannedWithTraits list if (traitDef.bannedWithTraits && traitDef.bannedWithTraits.indexOf(selId) !== -1) return true; // Check the already-selected trait's bannedWithTraits list var selDef = TDATA.TRAITS_MASTER[selId]; if (selDef && selDef.bannedWithTraits && selDef.bannedWithTraits.indexOf(traitId) !== -1) return true; } // Check global BANNED_PAIRS (trait-to-trait) for (var j = 0; j < TDATA.BANNED_PAIRS.length; j++) { var pair = TDATA.BANNED_PAIRS[j]; for (var k = 0; k < selectedTraits.length; k++) { if ((pair.traitA === traitId && pair.traitB === selectedTraits[k]) || (pair.traitB === traitId && pair.traitA === selectedTraits[k])) { return true; } } } return false; } // Helper: check if quirkId conflicts with selected traits function isQuirkBannedByTraits(quirkId, selectedTraits) { var quirkDef = QDATA.QUIRKS_MASTER[quirkId]; if (!quirkDef) return false; // Check quirk's own bannedWithTraits list if (quirkDef.bannedWithTraits) { for (var i = 0; i < quirkDef.bannedWithTraits.length; i++) { if (selectedTraits.indexOf(quirkDef.bannedWithTraits[i]) !== -1) return true; } } // Check each selected trait's bannedWithQuirks list for (var j = 0; j < selectedTraits.length; j++) { var tDef = TDATA.TRAITS_MASTER[selectedTraits[j]]; if (tDef && tDef.bannedWithQuirks && tDef.bannedWithQuirks.indexOf(quirkId) !== -1) return true; } // Check global quirk BANNED_PAIRS (trait-to-quirk) for (var k = 0; k < QDATA.BANNED_PAIRS.length; k++) { var qp = QDATA.BANNED_PAIRS[k]; if (qp.quirkId === quirkId && selectedTraits.indexOf(qp.traitId) !== -1) return true; } return false; } function generateApplicants(api) { var state = api.getState(); var renown = RENOWN.calculateRenown(state.reputation || 0); var count = (state.day === 1) ? C.day1ApplicantCount : RENOWN.getApplicantCount(renown, function() { return api.random(); }); var usedNames = {}; // Mark existing roster names to avoid collisions if (state.roster) { for (var r = 0; r < state.roster.length; r++) { usedNames[state.roster[r].name] = true; } } var applicants = []; var t4Count = 0; var hasT3Plus = false; // Pity timer: force a T3+ if renown >= R2 and pityTimer >= 4 var pityActive = renown >= 2 && (state.pityTimer || 0) >= 4; var pityUsed = false; for (var i = 0; i < count; i++) { var applicantCounter = (api.getState().applicantCounter || 0) + 1; api.patchState({ applicantCounter: applicantCounter }); // Pick tier var tier; if (pityActive && !pityUsed && i === 0) { // Force T3+ for pity tier = api.random() < 0.7 ? 3 : 4; pityUsed = true; } else { tier = RENOWN.pickApplicantTier(renown, function() { return api.random(); }); } // Enforce max 1 T4 per day if (tier === 4) { if (t4Count >= 1) tier = 3; else t4Count++; } if (tier >= 3) hasT3Plus = true; var pkg = RENOWN.TIER_STAT_PACKAGES[tier] || RENOWN.TIER_STAT_PACKAGES[1]; var classId = CLASS_IDS[Math.floor(api.random() * CLASS_IDS.length)]; var classDef = DATA.classes[classId]; var bias = classDef.statBias; // Generate stats within tier's statRange + class bias, clamped 1-10 var stats = {}; var statMin = pkg.statRange[0]; var statMax = pkg.statRange[1]; for (var s = 0; s < STAT_KEYS.length; s++) { var key = STAT_KEYS[s]; var base = statMin + Math.floor(api.random() * (statMax - statMin + 1)); var biased = base + (bias[key] || 0); stats[key] = clamp(biased, 1, 10); } // Determine trait count from tier package var traitCountSpec = pkg.traitCount; var traitCount; if (typeof traitCountSpec === 'number') { traitCount = traitCountSpec; } else { // Array [min, max] traitCount = traitCountSpec[0] + Math.floor(api.random() * (traitCountSpec[1] - traitCountSpec[0] + 1)); } // Pick unique traits var traits = []; var usedCategories = {}; var SEVERITY_CYCLE = ['mild', 'medium', 'spicy']; // Build eligible trait pool: filter by tierMin and classRestrictions var eligibleTraitIds = []; var allTraitIds = TDATA.TRAIT_IDS; for (var et = 0; et < allTraitIds.length; et++) { var etId = allTraitIds[et]; var etDef = TDATA.TRAITS_MASTER[etId]; if (!etDef) continue; if (etDef.tierMin > tier) continue; if (etDef.classRestrictions && etDef.classRestrictions.length > 0 && etDef.classRestrictions.indexOf(classId) === -1) continue; eligibleTraitIds.push(etId); } for (var t = 0; t < traitCount; t++) { // Class-locked trait bonus: 40% chance on FIRST slot for T2+ if (t === 0 && tier >= 2 && api.random() < 0.4) { var classTraits = []; for (var ct = 0; ct < eligibleTraitIds.length; ct++) { var ctDef = TDATA.TRAITS_MASTER[eligibleTraitIds[ct]]; if (ctDef && ctDef.classRestrictions && ctDef.classRestrictions.length > 0 && ctDef.classRestrictions.indexOf(classId) !== -1) { classTraits.push(eligibleTraitIds[ct]); } } if (classTraits.length > 0) { var ctPick = classTraits[Math.floor(api.random() * classTraits.length)]; traits.push(ctPick); usedCategories[TDATA.TRAITS_MASTER[ctPick].category] = true; // Remove from eligible pool var ctIdx = eligibleTraitIds.indexOf(ctPick); if (ctIdx !== -1) eligibleTraitIds.splice(ctIdx, 1); continue; } // Fall through to normal pick if no class trait available } // Roll severity using weighted distribution for this tier var traitWeights = TDATA.TRAIT_GENERATION_WEIGHTS[tier] || TDATA.TRAIT_GENERATION_WEIGHTS[1]; var rolledSeverity = weightedSeverityPick(traitWeights, function() { return api.random(); }); var picked = false; for (var attempt = 0; attempt < 3; attempt++) { var sevIdx = (SEVERITY_CYCLE.indexOf(rolledSeverity) + attempt) % 3; var trySeverity = SEVERITY_CYCLE[sevIdx]; // Filter eligible pool to matching severity, not banned var candidates = []; for (var c = 0; c < eligibleTraitIds.length; c++) { var cId = eligibleTraitIds[c]; var cDef = TDATA.TRAITS_MASTER[cId]; if (!cDef || cDef.severity !== trySeverity) continue; if (isTraitBannedByTraits(cId, traits)) continue; candidates.push(cId); } // Soft category dedup: prefer traits from unused categories if (candidates.length > 0) { var freshCategory = []; for (var fc = 0; fc < candidates.length; fc++) { var fcDef = TDATA.TRAITS_MASTER[candidates[fc]]; if (fcDef && !usedCategories[fcDef.category]) { freshCategory.push(candidates[fc]); } } if (freshCategory.length > 0) candidates = freshCategory; } if (candidates.length > 0) { var pickIdx = Math.floor(api.random() * candidates.length); var pickedTrait = candidates[pickIdx]; traits.push(pickedTrait); var ptDef = TDATA.TRAITS_MASTER[pickedTrait]; if (ptDef) usedCategories[ptDef.category] = true; // Remove from eligible pool (no duplicates) var rmIdx = eligibleTraitIds.indexOf(pickedTrait); if (rmIdx !== -1) eligibleTraitIds.splice(rmIdx, 1); picked = true; break; } } // If all 3 severity attempts failed, skip this trait slot } // 1 quirk always — weighted severity with ban checks var quirkId = null; var quirkWeights = QDATA.QUIRK_GENERATION_WEIGHTS[tier] || QDATA.QUIRK_GENERATION_WEIGHTS[1]; var quirkSeverity = weightedSeverityPick(quirkWeights, function() { return api.random(); }); for (var qa = 0; qa < 3; qa++) { var qSevIdx = (SEVERITY_CYCLE.indexOf(quirkSeverity) + qa) % 3; var qTrySev = SEVERITY_CYCLE[qSevIdx]; var quirkCandidates = []; var allQuirkIds = QDATA.QUIRK_IDS; for (var q = 0; q < allQuirkIds.length; q++) { var qId = allQuirkIds[q]; var qDef = QDATA.QUIRKS_MASTER[qId]; if (!qDef) continue; if (qDef.tierMin > tier) continue; if (qDef.severity !== qTrySev) continue; if (qDef.classRestrictions && qDef.classRestrictions.length > 0 && qDef.classRestrictions.indexOf(classId) === -1) continue; if (isQuirkBannedByTraits(qId, traits)) continue; quirkCandidates.push(qId); } if (quirkCandidates.length > 0) { quirkId = quirkCandidates[Math.floor(api.random() * quirkCandidates.length)]; break; } } // Absolute fallback: if no quirk passed all filters, pick any eligible quirk ignoring severity if (!quirkId) { var fallbackQuirks = []; var fbQuirkIds = QDATA.QUIRK_IDS; for (var fb = 0; fb < fbQuirkIds.length; fb++) { var fbDef = QDATA.QUIRKS_MASTER[fbQuirkIds[fb]]; if (!fbDef) continue; if (fbDef.tierMin > tier) continue; if (fbDef.classRestrictions && fbDef.classRestrictions.length > 0 && fbDef.classRestrictions.indexOf(classId) === -1) continue; if (!isQuirkBannedByTraits(fbQuirkIds[fb], traits)) { fallbackQuirks.push(fbQuirkIds[fb]); } } if (fallbackQuirks.length > 0) { quirkId = fallbackQuirks[Math.floor(api.random() * fallbackQuirks.length)]; } else { // Ultimate fallback — should never happen with 40 quirks quirkId = QDATA.QUIRK_IDS[Math.floor(api.random() * QDATA.QUIRK_IDS.length)]; } } // ── Identity: race, gender, skin tone, portrait ── var _appTheme = getActiveTheme(api); var _racePool = getThemedRaces(_appTheme); var race = _racePool[Math.floor(api.random() * _racePool.length)]; var name = generateThemedName(api, usedNames, _appTheme, race); var gender = DATA.GENDERS[Math.floor(api.random() * DATA.GENDERS.length)]; // Race-specific skin tones and features for undermountain theme var skinTone, earTag; if (_appTheme === 'dwarven_undermountain') { var GOBLIN_SKINS = ['pale-green', 'olive-green', 'dark-green']; var GNOME_SKINS = ['grey', 'tan', 'ashen-grey']; var DEFAULT_SKINS = ['light', 'medium', 'dark']; if (race === 'cave_goblin' || race === 'soot_goblin') { skinTone = GOBLIN_SKINS[Math.floor(api.random() * GOBLIN_SKINS.length)]; earTag = '-pointed-ears'; } else if (race === 'stone_gnome' || race === 'tinker_gnome') { skinTone = GNOME_SKINS[Math.floor(api.random() * GNOME_SKINS.length)]; earTag = '-round-ears'; } else if (race === 'forge_halfling' || race === 'tunnel_halfling') { skinTone = DEFAULT_SKINS[Math.floor(api.random() * DEFAULT_SKINS.length)]; earTag = '-pointed-ears'; } else { // dwarves and humans — standard skin, round ears skinTone = DEFAULT_SKINS[Math.floor(api.random() * DEFAULT_SKINS.length)]; earTag = '-round-ears'; } } else { skinTone = DATA.SKIN_TONES[Math.floor(api.random() * DATA.SKIN_TONES.length)]; // Standard theme: explicit ear tags so CDN doesn't guess if (race === 'elf') { earTag = '-pointed-ears'; } else if (race === 'halfling') { earTag = '-pointed-ears'; } else { earTag = '-round-ears'; } } // Use the full race name for portraits — replace underscores with hyphens for CDN var portraitRace = race.replace(/_/g, '-'); var portrait = DATA.buildPortraitUrl(portraitRace, gender, skinTone, classId, traits, quirkId, earTag); applicants.push({ id: 'applicant-' + applicantCounter, name: name, classId: classId, level: pkg.level, tier: tier, stats: stats, traits: traits, quirk: quirkId, payrollCost: RENOWN.TIER_PAYROLL_COST[tier] || 6, state: 'available', race: race, gender: gender, skinTone: skinTone, portrait: portrait, weekly: { contractsCompleted: 0, contractIndex: 0, contractTypes: [], lastContractType: null, prevContractType: null, consecutiveLongContracts: 0, outcomes: [], injuredThisWeek: false, fatigueIgnoredThisWeek: false, lowMaintenanceNextCycle: false, lastAssignmentDay: null } }); } // Update pity timer if (hasT3Plus) { api.patchState({ pityTimer: 0 }); } else { api.patchState({ pityTimer: (state.pityTimer || 0) + 1 }); } return applicants; } // ─── SPAWNING ─────────────────────────────────────────────────── export function onSpawn(api) { api.log('[MANAGER] onSpawn fired, id=' + api.id); // Listen for cosmetics save events from any entity (god mode or player) api.on('saveCosmetics', function(payload) { if (payload && payload.cosmetics && payload.playerId) { api.log('[MANAGER] saveCosmetics event received for ' + payload.playerId); savePlayerCosmetics(api, payload.playerId, payload.cosmetics); } }); // ALWAYS set loading=true and attempt storage:get FIRST, regardless of current state. api.patchState({ loading: true, saveChecked: {} }); // Boot — initialize manager state and mark ready api.log('[MANAGER] booting...'); api.patchState({ loading: false, waiting: true, day: 0, phase: 'menu', gold: 0, reputation: 0, safety: 0, compliance: 0, roster: [], availableContracts: [], activeAssignments: [], completedResults: [], applicants: [], hiredToday: 0, facilities: {}, log: [], gameOver: false, dayResults: null, initialSynced: false, saveChecked: {}, autoLoaded: false, pityTimer: 0, deferredDebt: 0, boardLoanAmount: 0 }); api.log('[MANAGER] onSpawn complete — ready'); // Check season state on boot + every 5 minutes checkSeason(api); api.runInSeconds(300, function seasonLoop() { checkSeason(api); api.runInSeconds(300, seasonLoop); }); } // Ensure players who join get save-check and initial sync export function update(dt, api) { var state = api.getState(); // Don't run any game logic while waiting for storage load if (state.loading) return; var players = api.query({ tags: ['player'] }); if (players.length === 0) return; // ── Poll for pending player actions every frame ── for (var p = 0; p < players.length; p++) { var ps = api.getObjectState(players[p].id); if (ps && ps.pendingAction) { api.log('[MANAGER] found pendingAction on ' + players[p].id + ': ' + JSON.stringify(ps.pendingAction)); var pending = ps.pendingAction; // Clear immediately so we don't re-process api.patchObjectState(players[p].id, { pendingAction: null }); handlePlayerAction(api, players[p].id, pending); } } // Re-read state after potential action processing state = api.getState(); // For newly joined players, check if a save exists so menu can show Continue button var saveChecked = state.saveChecked || {}; for (var i = 0; i < players.length; i++) { var pid = players[i].id; if (!saveChecked[pid]) { // Mark as done immediately — onSpawn already handled the actual load var patch = {}; patch['saveChecked'] = JSON.parse(JSON.stringify(saveChecked)); patch['saveChecked'][pid] = 'done'; api.patchState(patch); // Player loads its own cosmetics/settings in onSpawn — just check for save existence api.log('[MANAGER] new joiner: ' + pid); // Auto-unlock all packs for the creator (can't self-purchase via Spoins) var _creatorProfile = api.getProfile(pid); if (_creatorProfile && _creatorProfile.userId === 'a39dfbb6-0cee-48ad-937f-1c9570cd6a49') { api.log('[MANAGER] creator detected — auto-granting all packs'); api.patchObjectState(pid, { hasTipped: true, scholarlyRaven: true, extraSlotsUnlocked: true, dwarfPackOwned: true }); } // If game is already active (not waiting/menu), put them right into playing mode if (!state.waiting && state.phase !== 'menu' && state.phase !== undefined && state.day > 0) { api.patchObjectState(pid, { gameMode: 'playing', hasSave: true }); syncPlayerHud(api); } else { // Otherwise check if save exists so menu shows correct buttons checkSaveExistsForMenu(api, pid); } } } // If game is active (not waiting/menu), sync newly joined players who chose to play if (!state.waiting && state.phase !== 'menu' && state.day > 0) { for (var k = 0; k < players.length; k++) { var psk = api.getObjectState(players[k].id); // Only sync players who are already in playing mode but missing HUD data if (psk && psk.gameMode === 'playing' && (!psk.day || psk.day === 0)) { syncPlayerHud(api); break; } } } // If game is active (not waiting), sync HUD to players that don't have data yet if (!state.waiting && state.phase !== 'menu') { for (var j = 0; j < players.length; j++) { var ps = api.getObjectState(players[j].id); if (ps && ps.gameMode === 'playing' && (!ps.day || ps.day === 0)) { syncPlayerHud(api); break; } } } } // ─── SAVE KEY HELPER ──────────────────────────────────────────── var MAX_SLOTS = 3; function getPlayerSlotKey(api, playerId, slot) { return SKEYS.saveSlotKey(api, playerId, slot); } function getSaveKey(api, playerId) { var playerState = api.getObjectState(playerId) || {}; var activeSlot = playerState.activeSlot != null ? playerState.activeSlot : 0; return getPlayerSlotKey(api, playerId, activeSlot); } // Player-state persistence helpers removed — storage is the sole save channel // ─── SAVE EXISTS CHECK (menu only — sets hasSave for UI, no load) ── function checkSaveExistsForMenu(api, playerId) { api.log('[MANAGER] checking all slots for save-exists, player=' + playerId); var checked = 0; var anySave = false; function finishCheck() { checked++; if (checked < MAX_SLOTS) return; var currentPs = api.getObjectState(playerId); var currentMode = currentPs ? currentPs.gameMode : null; var patch = { hasSave: anySave }; if (!currentMode || currentMode === 'menu' || currentMode === 'settings') { patch.gameMode = 'menu'; } api.patchObjectState(playerId, patch); loadPlayerSettings(api, playerId); loadLeaderboard(api, playerId); // Push season info to this player var mgrState = api.getState(); if (mgrState.currentSeason) { api.patchObjectState(playerId, { currentSeason: mgrState.currentSeason, seasonEndMs: mgrState.seasonEndMs, seasonNowMs: mgrState.seasonNowMs }); } // NOTE: cosmetics load removed from here — handled by new-joiner path only api.log('[MANAGER] save-exists check done: hasSave=' + anySave); } for (var i = 0; i < MAX_SLOTS; i++) { (function(idx) { api.job('storage:get', { key: getPlayerSlotKey(api, playerId, idx) }, function(result) { if (result.ok && result.data && result.data.value) { anySave = true; } finishCheck(); }); })(i); } } // ─── LOAD PLAYER SETTINGS ─────────────────────────────────────── // ─── AUTO-LOAD ON RECONNECT (manager at day 0 + player joins) ── function checkAndAutoLoad(api, playerId) { api.log('[MANAGER] reconnect check: scanning slots for auto-load, player=' + playerId); var checked = 0; var bestSlot = -1; var bestDay = 0; function finishSlotCheck() { checked++; if (checked < MAX_SLOTS) return; if (bestSlot >= 0) { api.log('[MANAGER] reconnect: auto-loading slot ' + bestSlot + ' (day ' + bestDay + ') for ' + playerId); api.patchObjectState(playerId, { activeSlot: bestSlot }); loadGame(api, playerId); } else { api.log('[MANAGER] reconnect: no saves found — falling back to menu'); checkSaveExistsForMenu(api, playerId); } } for (var i = 0; i < MAX_SLOTS; i++) { (function(idx) { api.job('storage:get', { key: getPlayerSlotKey(api, playerId, idx) }, function(result) { if (result.ok && result.data && result.data.value) { var sd = result.data.value; var d = sd.day || 0; if (d > bestDay) { bestDay = d; bestSlot = idx; } } finishSlotCheck(); }); })(i); } } function loadPlayerSettings(api, playerId) { var key = SKEYS.settingsKey(api, playerId); api.job('storage:get', { key: key }, function(result) { if (result.ok && result.data && result.data.value) { var settings = result.data.value; api.log('[MANAGER] loaded settings for ' + playerId); api.patchObjectState(playerId, { musicVolume: settings.musicVolume != null ? settings.musicVolume : 50, sfxVolume: settings.sfxVolume != null ? settings.sfxVolume : 50 }); } }); } // ─── LOAD LEADERBOARD ─────────────────────────────────────────── var LEADERBOARD_KEY = 'leaderboard:global'; function loadLeaderboard(api, playerId) { api.job('storage:get', { key: LEADERBOARD_KEY }, function(result) { if (result.ok && result.data && result.data.value && result.data.value.length > 0) { api.log('[MANAGER] loaded leaderboard (' + result.data.value.length + ' entries)'); api.patchObjectState(playerId, { leaderboardData: result.data.value }); } else { // No real runs yet — UI will show hardcoded placeholders api.patchObjectState(playerId, { leaderboardData: [] }); } }); } function seedLeaderboard() { var gp = ['Iron','Silver','Golden','Shadow','Storm','Fire','Frost','Thunder','Crystal','Emerald', 'Crimson','Azure','Onyx','Jade','Amber','Violet','Cobalt','Obsidian','Ivory','Scarlet']; var gs = ['Shield','Hammer','Blade','Torch','Crown','Anvil','Banner','Keep','Forge','Watch', 'Hart','Wolf','Oath','Dawn','Peak','Stone','Crest','Gate','Vale','Spire']; var fn = ['Aldric','Brynn','Cedric','Elara','Finn','Greta','Hamund','Isolde','Jareth','Kira', 'Loric','Maren','Nolan','Orin','Petra','Quinn','Rhea','Soren','Thea','Ulric', 'Vanya','Wren','Xander','Yvaine','Zara','Tormund','Lyra','Cassius','Dagna','Elowen']; var ln = ['Blackwood','Thornwall','Ashford','Windmere','Stonehelm','Ravencroft','Dunbar','Fairhaven', 'Goldmane','Heartstone','Ironside','Kettleburn','Longshore','Moorfield','Nighthollow', 'Oakshade','Pennywhistle','Redmantle','Silvervein','Thistledown']; var gr = ['C','C','C','C','C','B','B','B','B','B','B','B','C','C','C','A','A','A','D','S']; var entries = []; for (var i = 0; i < 100; i++) { entries.push({ guildName: gp[i % 20] + ' ' + gs[Math.floor(i / 20) % 20], playerName: fn[i % 30] + ' ' + ln[Math.floor(i / 30) % 20], totalGold: 300 + ((i * 37 + 13) % 301), totalRep: 50 + ((i * 23 + 7) % 101), finalSafety: 40 + ((i * 41 + 3) % 41), finalCompliance: 40 + ((i * 29 + 11) % 41), overallGrade: gr[i % 20], campaignScore: 1000, timestamp: i }); } return entries; } function submitToLeaderboard(api, entry) { api.job('storage:get', { key: LEADERBOARD_KEY }, function(result) { var board = []; if (result.ok && result.data && result.data.value) { board = result.data.value; } board.push(entry); board.sort(function(a, b) { return (b.campaignScore || 0) - (a.campaignScore || 0); }); if (board.length > 100) board = board.slice(0, 100); api.job('storage:set', { key: LEADERBOARD_KEY, value: board }, function(setResult) { if (setResult.ok) { api.log('[MANAGER] leaderboard updated, now ' + board.length + ' entries'); // Push updated leaderboard to all players on menu var players = api.query({ tags: ['player'] }); for (var i = 0; i < players.length; i++) { api.patchObjectState(players[i].id, { leaderboardData: board }); } } }); }); } // ─── SEASON CHECK — biweekly leaderboard seasons ──────────────── function checkSeason(api) { // Use a storage job to get real server time via the timestamp on a meta key // Then compute season from SEASON constants api.job('storage:get', { key: 'leaderboard:season-meta' }, function(result) { if (!result.ok) { api.log('[MANAGER] season meta read failed'); return; } var meta = (result.data && result.data.value) || { lastResolvedSeason: 0, winners: {} }; // Get real time via a timestamped write — write a heartbeat key api.job('storage:set', { key: 'season:heartbeat', value: true }, function(hbResult) { if (!hbResult.ok) { api.log('[MANAGER] season heartbeat failed'); return; } // Use getWallClockTimestamp as fallback — it's deterministic but close enough // for season boundaries that last 14 days var nowMs = api.getWallClockTimestamp(); var currentSeason = SEASON.getSeasonNumber(nowMs); api.log('[MANAGER] season check: current=' + currentSeason + ' lastResolved=' + meta.lastResolvedSeason); // Store current season info on manager state for UI api.patchState({ currentSeason: currentSeason, seasonEndMs: SEASON.getSeasonEndMs(currentSeason), seasonNowMs: nowMs }); // Push season info to all connected players var players = api.query({ tags: ['player'] }); for (var i = 0; i < players.length; i++) { api.patchObjectState(players[i].id, { currentSeason: currentSeason, seasonEndMs: SEASON.getSeasonEndMs(currentSeason), seasonNowMs: nowMs }); } // Check if any seasons need resolving if (currentSeason <= meta.lastResolvedSeason + 1) { // Still in current season, no resolution needed // Initialize meta if first time if (meta.lastResolvedSeason === 0) { meta.lastResolvedSeason = currentSeason - 1; api.job('storage:set', { key: 'leaderboard:season-meta', value: meta }, function() {}); } return; } // Season(s) ended — resolve them api.job('storage:get', { key: 'leaderboard:global' }, function(lbResult) { var board = (lbResult.ok && lbResult.data && lbResult.data.value) || []; var newWinners = {}; for (var s = meta.lastResolvedSeason + 1; s < currentSeason; s++) { var top10 = []; for (var b = 0; b < board.length && top10.length < 10; b++) { if (board[b] && !board[b].placeholder && board[b].userId) { top10.push({ userId: board[b].userId, playerName: board[b].playerName, guildName: board[b].guildName, campaignScore: board[b].campaignScore, rank: top10.length + 1 }); } } newWinners[s] = top10; } // Clear leaderboard for new season api.job('storage:set', { key: 'leaderboard:global', value: [] }, function() { // Update meta for (var ws in newWinners) { meta.winners[ws] = newWinners[ws]; } meta.lastResolvedSeason = currentSeason - 1; api.job('storage:set', { key: 'leaderboard:season-meta', value: meta }, function() { api.log('[MANAGER] season resolved: awarded seasons up to ' + (currentSeason - 1)); }); // Award cosmetics to winners for (var sn in newWinners) { var prize = SEASON.getSeasonPrize(parseInt(sn, 10)); var winners = newWinners[sn]; for (var w = 0; w < winners.length; w++) { awardSeasonPet(api, winners[w].userId, prize.petId); } } // Push cleared leaderboard to all players for (var pi = 0; pi < players.length; pi++) { api.patchObjectState(players[pi].id, { leaderboardData: [] }); } }); }); }); }); } function awardSeasonPet(api, userId, petId) { if (!userId) return; var cosKey = 'guildlings-cosmetics-' + userId; api.job('storage:get', { key: cosKey }, function(result) { var cosmetics = {}; if (result.ok && result.data && result.data.value) { cosmetics = result.data.value; } var unlocked = cosmetics.unlockedPets || []; if (unlocked.indexOf(petId) === -1) { unlocked.push(petId); cosmetics.unlockedPets = unlocked; api.job('storage:set', { key: cosKey, value: cosmetics }, function(setResult) { if (setResult.ok) { api.log('[MANAGER] awarded pet ' + petId + ' to user ' + userId); // If that user is online, refresh their cosmetics var players = api.query({ tags: ['player'] }); for (var i = 0; i < players.length; i++) { var prof = api.getProfile(players[i].id); if (prof && prof.userId === userId) { api.patchObjectState(players[i].id, { cosmetics: cosmetics }); } } } }); } }); } // ─── SAVE SLOT SUMMARIES ──────────────────────────────────────── function loadSlotSummaries(api, playerId) { api.log('[MANAGER] loadSlotSummaries for player=' + playerId); var summaries = [null, null, null]; var checked = 0; function finishSummaryCheck() { checked++; if (checked < MAX_SLOTS) return; // Also check if extra slots are unlocked api.job('storage:get', { key: SKEYS.saveMetaKey(api, playerId) }, function(metaResult) { var extraUnlocked = false; var tipped = false; var raven = false; var dwarfPackOwned = false; if (metaResult.ok && metaResult.data && metaResult.data.value) { var meta = metaResult.data.value; extraUnlocked = !!meta.extraSlotsUnlocked; tipped = !!meta.hasTipped; raven = !!meta.scholarlyRaven; dwarfPackOwned = !!meta.dwarfPackOwned; } api.patchObjectState(playerId, { saveSlots: summaries, extraSlotsUnlocked: extraUnlocked, hasTipped: tipped, scholarlyRaven: raven, dwarfPackOwned: dwarfPackOwned, saveSlotsLoading: false }); api.log('[MANAGER] slot summaries sent to player: ' + JSON.stringify(summaries.map(function(s) { return s ? 'day' + s.day : 'empty'; })) + ' extra=' + extraUnlocked); }); } for (var i = 0; i < MAX_SLOTS; i++) { (function(idx) { api.job('storage:get', { key: getPlayerSlotKey(api, playerId, idx) }, function(result) { if (result.ok && result.data && result.data.value) { var save = result.data.value; summaries[idx] = { day: save.day || 1, phase: save.phase || 'intake', gold: save.gold != null ? save.gold : 0, rosterCount: save.roster ? save.roster.length : 0, guildName: save.guildName || null }; } finishSummaryCheck(); }); })(i); } } // ─── INTERACT ─────────────────────────────────────────────────── // Called by the event listener in onSpawn function handlePlayerAction(api, playerId, pending) { // Build a lightweight 'other' object matching what the dispatch code expects var other = { id: playerId }; // ── Save Slots: Load slot summaries ── if (pending.action === 'loadSlotSummaries') { loadSlotSummaries(api, playerId); return; } // ── Save Slots: Load a specific slot ── if (pending.action === 'loadSlot') { var loadSlotIdx = pending.slot != null ? pending.slot : 0; api.patchObjectState(playerId, { pendingAction: null, activeSlot: loadSlotIdx }); loadGame(api, playerId); return; } // ── Save Slots: New game in a specific slot ── if (pending.action === 'newGameSlot') { var newSlotIdx = pending.slot != null ? pending.slot : 0; api.patchObjectState(playerId, { pendingAction: null, activeSlot: newSlotIdx }); startNewGame(api, playerId); return; } // ── Menu: Continue Game (quick-resume last slot — legacy compat) ── if (pending.action === 'continueGame') { api.patchObjectState(playerId, { pendingAction: null }); loadGame(api, playerId); return; } // ── Menu: New Game (legacy — uses active slot) ── if (pending.action === 'newGame') { api.patchObjectState(playerId, { pendingAction: null }); startNewGame(api, playerId); return; } // ── Settings: Save settings to storage ── if (pending.action === 'saveSettings') { api.patchObjectState(playerId, { pendingAction: null }); savePlayerSettings(api, playerId, pending); return; } // ── Cosmetics: Save cosmetics to storage ── if (pending.action === 'saveCosmetics') { api.patchObjectState(playerId, { pendingAction: null }); savePlayerCosmetics(api, playerId, pending.cosmetics); return; } if (pending.action === 'morningDone') { api.patchState({ morningAnimDone: true }); api.patchObjectState(playerId, { pendingAction: null, morningAnimDone: true }); syncPlayerHud(api); return; } if (pending.action === 'planningDone') { api.patchState({ planningAnimDone: true }); api.patchObjectState(playerId, { pendingAction: null, planningAnimDone: true }); syncPlayerHud(api); return; } if (pending.action === 'reportsDone') { api.patchState({ reportsAnimDone: true }); api.patchObjectState(playerId, { pendingAction: null, reportsAnimDone: true }); syncPlayerHud(api); return; } if (pending.action === 'boardReviewDone') { api.patchState({ boardReviewAnimDone: true }); api.patchObjectState(playerId, { pendingAction: null, boardReviewAnimDone: true }); syncPlayerHud(api); return; } if (pending.action === 'hireApplicant') { processHire(api, other, pending.applicantId); api.patchObjectState(playerId, { pendingAction: null }); syncPlayerHud(api); return; } if (pending.action === 'rejectApplicant') { processReject(api, other, pending.applicantId); api.patchObjectState(playerId, { pendingAction: null }); syncPlayerHud(api); return; } if (pending.action === 'advancePhase') { api.patchObjectState(playerId, { pendingAction: null }); advancePhase(api, other); return; } if (pending.action === 'dismissHint') { api.patchObjectState(playerId, { pendingAction: null }); var currentDismissed = api.getObjectState(playerId).dismissedHints || {}; currentDismissed[pending.hintId] = true; api.patchObjectState(playerId, { dismissedHints: currentDismissed }); return; } if (pending.action === 'acceptContract') { processAcceptContract(api, other, pending.contractId); api.patchObjectState(playerId, { pendingAction: null }); syncPlayerHud(api); return; } if (pending.action === 'dismissContract') { var latestPlayerState = api.getObjectState(playerId) || {}; var dismissSyncPatch = {}; var hasDismissSyncPatch = false; if (Array.isArray(latestPlayerState.activeAssignments)) { dismissSyncPatch.activeAssignments = latestPlayerState.activeAssignments; hasDismissSyncPatch = true; } if (latestPlayerState.gold != null) { dismissSyncPatch.gold = latestPlayerState.gold; hasDismissSyncPatch = true; } if (hasDismissSyncPatch) api.patchState(dismissSyncPatch); processDismissContract(api, other, pending.contractId); api.patchObjectState(playerId, { pendingAction: null }); syncPlayerHud(api); return; } // ── Letters: Inspect contract category ── if (pending.action === 'inspectContract') { api.patchObjectState(playerId, { pendingAction: null }); if (isLettersEnabled(api)) LETTERS.handleInspectContract(api, playerId, pending, api.getObject(playerId)); syncPlayerHud(api); return; } // ── Letters: Upgrade admin level ── if (pending.action === 'upgradeAdmin') { api.patchObjectState(playerId, { pendingAction: null }); if (isLettersEnabled(api)) LETTERS.handleUpgradeAdmin(api, playerId, api.getObject(playerId)); syncPlayerHud(api); return; } if (pending.action === 'syncAssignments') { api.patchState({ activeAssignments: pending.activeAssignments || [], gold: pending.gold != null ? pending.gold : api.getState().gold }); api.patchObjectState(playerId, { pendingAction: null }); syncPlayerHud(api); return; } if (pending.action === 'removeContract') { processRemoveContract(api, other, pending.contractId); api.patchObjectState(playerId, { pendingAction: null }); syncPlayerHud(api); return; } if (pending.action === 'assignGuildling') { processAssignGuildling(api, other, pending.contractId, pending.slotIndex, pending.guildlingId); api.patchObjectState(playerId, { pendingAction: null }); syncPlayerHud(api); return; } if (pending.action === 'unassignGuildling') { processUnassignGuildling(api, other, pending.contractId, pending.slotIndex); api.patchObjectState(playerId, { pendingAction: null }); syncPlayerHud(api); return; } if (pending.action === 'toggleMitigation') { processToggleMitigation(api, other, pending.contractId, pending.mitigationId); api.patchObjectState(playerId, { pendingAction: null }); syncPlayerHud(api); return; } if (pending.action === 'resolveInterrupt') { api.patchObjectState(playerId, { pendingAction: null }); var state = api.getState(); var pi = state.pendingInterrupt; if (!pi || pi.resolved) { api.toast('No pending situation to resolve.', { duration: 2, color: 'oklch(0.6 0.15 30)', audience: { kind: 'player', id: playerId } }); return; } var choiceIndex = pending.choiceIndex; var choice = pi.event.choices[choiceIndex]; if (!choice) { api.log('[MANAGER] invalid choice index: ' + choiceIndex); return; } var outcome = choice.outcome || {}; // Apply global effects immediately var goldDelta = outcome.goldDelta || 0; var repDelta = outcome.repDelta || 0; var safetyDelta = outcome.safetyDelta || 0; var patchFields = {}; if (goldDelta !== 0) patchFields.gold = (state.gold || 0) + goldDelta; if (repDelta !== 0) patchFields.reputation = (state.reputation || 0) + repDelta; if (safetyDelta !== 0) patchFields.safety = clamp((state.safety || 0) + safetyDelta, 0, 100); if (Object.keys(patchFields).length > 0) api.patchState(patchFields); // Store assignment-specific effects on the target assignment var allAssign = JSON.parse(JSON.stringify(pi.allAssignments)); var targetAssign = allAssign[pi.assignmentIdx]; if (targetAssign) { targetAssign.interruptEffects = { durationDelta: outcome.durationDelta || 0, contractFails: outcome.contractFails || false, goldMult: outcome.goldMult != null ? outcome.goldMult : null, injuryRiskDelta: outcome.injuryRiskDelta || 0, logisticsCapDelta: outcome.logisticsCapDelta || 0, magicCapDelta: outcome.magicCapDelta || 0, description: outcome.description || '' }; // Apply durationDelta if (outcome.durationDelta) { targetAssign.daysRemaining = (targetAssign.daysRemaining || 0) + outcome.durationDelta; } allAssign[pi.assignmentIdx] = targetAssign; } // Mark interrupt as resolved var updatedInterrupt = JSON.parse(JSON.stringify(pi)); updatedInterrupt.resolved = true; updatedInterrupt.choiceLabel = choice.label; updatedInterrupt.outcomeDescription = outcome.description || ''; updatedInterrupt.allAssignments = allAssign; api.patchState({ pendingInterrupt: updatedInterrupt }); sfx(api, 'cdn/sfx-stamp-paper-thud.mp3', 0.4, { kind: 'player', id: playerId }); api.toast(outcome.description || 'Decision made.', { duration: 2.5, color: 'oklch(0.65 0.12 80)', audience: { kind: 'player', id: playerId } }); // Now resolve all assignments with the updated data resolveAllAssignments(api, allAssign, null, other); return; } // ── Facility: Upgrade ── if (pending.action === 'upgradeFacility') { api.patchObjectState(playerId, { pendingAction: null }); processUpgradeFacility(api, { id: playerId }, pending.facilityId, pending.useVoucher || false); syncPlayerHud(api); return; } // ── Facility: Assign guildling ── if (pending.action === 'assignToFacility') { api.patchObjectState(playerId, { pendingAction: null }); processAssignToFacility(api, { id: playerId }, pending.facilityId, pending.guildlingId, pending.stat, pending.forceAssign || pending.confirmedOverwork); syncPlayerHud(api); return; } // ── Facility: Unassign guildling ── if (pending.action === 'unassignFromFacility') { api.patchObjectState(playerId, { pendingAction: null }); processUnassignFromFacility(api, { id: playerId }, pending.facilityId, pending.guildlingId); syncPlayerHud(api); return; } // ── Board Review: Pay payroll ── if (pending.action === 'payPayroll') { api.patchObjectState(playerId, { pendingAction: null }); var ppState = api.getState(); var ppReview = ppState.currentBoardReview; if (!ppReview || ppState.phase !== 'boardReview') { api.log('[MANAGER] payPayroll called outside boardReview phase'); return; } var ppDue = ppReview.payrollDue || 0; if (ppState.gold < ppDue) { api.toast('Not enough gold to pay payroll!', { duration: 2, color: 'oklch(0.6 0.15 30)', audience: { kind: 'player', id: playerId } }); return; } // Deduct payroll var ppNewGold = ppState.gold - ppDue; var ppWeeklySpent = (ppState.weeklyGoldSpent || 0) + ppDue; var ppAts = JSON.parse(JSON.stringify(ppState.allTimeStats || { totalGoldEarned: 0, totalGoldSpent: 0, totalReputationDelta: 0, totalInjuries: { light: 0, moderate: 0, severe: 0 }, totalComplianceIncidents: 0, totalOutcomes: { clean: 0, cost: 0, fail: 0, salvage: 0 }, totalContractsCompleted: 0, weekReviews: [] })); ppAts.totalGoldSpent += ppDue; var ppUpdatedReview = JSON.parse(JSON.stringify(ppReview)); ppUpdatedReview.payrollPaid = true; api.patchState({ gold: ppNewGold, weeklyGoldSpent: ppWeeklySpent, allTimeStats: ppAts, currentBoardReview: ppUpdatedReview, deferredDebt: 0 }); logEntry(api, 'Payroll paid: ' + ppDue + 'g deducted.'); sfx(api, 'cdn/sfx-coin-collect-chime-pickup.mp3', 0.4, { kind: 'player', id: playerId }); api.toast('Payroll paid: ' + ppDue + 'g', { duration: 2, color: 'oklch(0.65 0.18 140)', audience: { kind: 'player', id: playerId } }); syncPlayerHud(api); autoSave(api, playerId); return; } // ── Board Review: Payroll relief ── if (pending.action === 'payPayrollRelief') { api.patchObjectState(playerId, { pendingAction: null }); var prState = api.getState(); var prReview = prState.currentBoardReview; if (!prReview || prState.phase !== 'boardReview') { api.log('[MANAGER] payPayrollRelief called outside boardReview phase'); return; } var prChoice = pending.reliefChoice; var prShortfall = prReview.payrollShortfall || (prReview.payrollDue - prState.gold); var prUpdatedReview = JSON.parse(JSON.stringify(prReview)); prUpdatedReview.payrollPaid = true; if (prChoice === 'loan') { // Board Loan: give gold to cover shortfall, set loan amount var loanGold = prState.gold + prShortfall; api.patchState({ gold: loanGold - prReview.payrollDue, boardLoanAmount: prShortfall, weeklyGoldSpent: (prState.weeklyGoldSpent || 0) + prReview.payrollDue, currentBoardReview: prUpdatedReview, deferredDebt: 0 }); logEntry(api, 'Board loan taken: ' + prShortfall + 'g. Compliance penalty next review.'); api.toast('Board loan: ' + prShortfall + 'g (penalty next week)', { duration: 3, color: 'oklch(0.65 0.16 60)', audience: { kind: 'player', id: playerId } }); } else if (prChoice === 'reputation') { // Pay in Reputation: 3 rep per 10g shortfall, rounded up var repCost = Math.ceil(prShortfall / 10) * 3; var newRep = Math.max(0, (prState.reputation || 0) - repCost); api.patchState({ reputation: newRep, weeklyReputationDelta: (prState.weeklyReputationDelta || 0) - repCost, currentBoardReview: prUpdatedReview, deferredDebt: 0 }); logEntry(api, 'Payroll paid via reputation: -' + repCost + ' rep for ' + prShortfall + 'g shortfall.'); api.toast('Reputation cost: -' + repCost + ' rep', { duration: 3, color: 'oklch(0.6 0.15 30)', audience: { kind: 'player', id: playerId } }); } else if (prChoice === 'deferred') { // Deferred: pay what they have, debt = remaining var canPay = prState.gold; var remaining = prReview.payrollDue - canPay; var prAts = JSON.parse(JSON.stringify(prState.allTimeStats || { totalGoldEarned: 0, totalGoldSpent: 0, totalReputationDelta: 0, totalInjuries: { light: 0, moderate: 0, severe: 0 }, totalComplianceIncidents: 0, totalOutcomes: { clean: 0, cost: 0, fail: 0, salvage: 0 }, totalContractsCompleted: 0, weekReviews: [] })); prAts.totalGoldSpent += canPay; api.patchState({ gold: 0, deferredDebt: (prState.deferredDebt || 0) + remaining, weeklyGoldSpent: (prState.weeklyGoldSpent || 0) + canPay, allTimeStats: prAts, currentBoardReview: prUpdatedReview }); logEntry(api, 'Deferred payroll: paid ' + canPay + 'g, ' + remaining + 'g deferred (+20% surcharge next week).'); api.toast('Deferred: ' + remaining + 'g owed (+20% next week)', { duration: 3, color: 'oklch(0.65 0.16 60)', audience: { kind: 'player', id: playerId } }); } sfx(api, 'cdn/sfx-stamp-paper-thud.mp3', 0.4, { kind: 'player', id: playerId }); syncPlayerHud(api); autoSave(api, playerId); return; } // ── Fire guildling ── if (pending.action === 'fireGuildling') { api.patchObjectState(playerId, { pendingAction: null }); var fgState = api.getState(); var fgRoster = (fgState.roster || []).slice(); var fgIdx = -1; var fgGuildling = null; for (var fgi = 0; fgi < fgRoster.length; fgi++) { if (fgRoster[fgi].id === pending.guildlingId) { fgIdx = fgi; fgGuildling = fgRoster[fgi]; break; } } if (fgIdx < 0) { api.toast('Guildling not found!', { duration: 2, color: 'oklch(0.6 0.15 30)', audience: { kind: 'player', id: playerId } }); return; } var severance = Math.floor((fgGuildling.payrollCost || 0) * 0.5); if (fgState.gold < severance) { api.toast('Not enough gold for severance (' + severance + 'g required)', { duration: 2.5, color: 'oklch(0.6 0.15 30)', audience: { kind: 'player', id: playerId } }); return; } // Remove from roster and deduct severance var fgName = fgGuildling.name; fgRoster.splice(fgIdx, 1); var fgNewGold = fgState.gold - severance; // Clean fired guildling from any active assignment parties (ghost party fix) var fgAssignments = (fgState.activeAssignments || []).slice(); for (var fga = 0; fga < fgAssignments.length; fga++) { var fgParty = fgAssignments[fga].party || []; for (var fgp = 0; fgp < fgParty.length; fgp++) { if (fgParty[fgp] === pending.guildlingId) { fgAssignments[fga] = JSON.parse(JSON.stringify(fgAssignments[fga])); fgAssignments[fga].party[fgp] = null; } } } var fgInProgress = (fgState.inProgressAssignments || []).slice(); for (var fgip = 0; fgip < fgInProgress.length; fgip++) { var fgipParty = fgInProgress[fgip].party || []; for (var fgipp = 0; fgipp < fgipParty.length; fgipp++) { if (fgipParty[fgipp] === pending.guildlingId) { fgInProgress[fgip] = JSON.parse(JSON.stringify(fgInProgress[fgip])); fgInProgress[fgip].party[fgipp] = null; } } } var fgAts = JSON.parse(JSON.stringify(fgState.allTimeStats || { totalGoldEarned: 0, totalGoldSpent: 0, totalReputationDelta: 0, totalInjuries: { light: 0, moderate: 0, severe: 0 }, totalComplianceIncidents: 0, totalOutcomes: { clean: 0, cost: 0, fail: 0, salvage: 0 }, totalContractsCompleted: 0, weekReviews: [] })); fgAts.totalGoldSpent += severance; api.patchState({ roster: fgRoster, gold: fgNewGold, activeAssignments: fgAssignments, inProgressAssignments: fgInProgress, weeklyGoldSpent: (fgState.weeklyGoldSpent || 0) + severance, allTimeStats: fgAts }); logEntry(api, 'Fired ' + fgName + '. Severance: ' + severance + 'g.'); sfx(api, 'cdn/sfx-paper-shuffle.mp3', 0.4, { kind: 'player', id: playerId }); api.toast('Fired ' + fgName + ' (severance: ' + severance + 'g)', { duration: 2.5, color: 'oklch(0.55 0.1 30)', audience: { kind: 'player', id: playerId } }); syncPlayerHud(api); autoSave(api, playerId); return; } // ── Board Review: Select reward ── if (pending.action === 'selectBoardReward') { api.patchObjectState(playerId, { pendingAction: null }); var brState = api.getState(); var review = brState.currentBoardReview; if (!review || brState.phase !== 'boardReview') { api.log('[MANAGER] selectBoardReward called outside boardReview phase'); return; } var rewardIdx = pending.rewardIndex; if (rewardIdx == null || rewardIdx < 0 || rewardIdx >= (review.rewards || []).length) { api.log('[MANAGER] invalid rewardIndex: ' + rewardIdx); return; } var chosenReward = review.rewards[rewardIdx]; // Apply the chosen reward var rewardPatch = {}; if (chosenReward.id === 'funding') { rewardPatch.gold = (brState.gold || 0) + C.boardRewardAmounts.funding; logEntry(api, 'Board reward: +' + C.boardRewardAmounts.funding + 'g emergency funding.'); } else if (chosenReward.id === 'premium_funding') { rewardPatch.gold = (brState.gold || 0) + C.boardRewardAmounts.premiumFunding; logEntry(api, 'Board reward: +' + C.boardRewardAmounts.premiumFunding + 'g premium funding.'); } else if (chosenReward.id === 'facility_voucher') { rewardPatch.facilityVouchers = (brState.facilityVouchers || 0) + 1; logEntry(api, 'Board reward: Facility voucher received.'); } else if (chosenReward.id === 'exemption_tokens') { rewardPatch.exemptionTokens = (brState.exemptionTokens || 0) + C.boardRewardAmounts.exemptionTokens; logEntry(api, 'Board reward: +' + C.boardRewardAmounts.exemptionTokens + ' exemption tokens.'); } else if (chosenReward.id === 'exemption_tokens_3') { rewardPatch.exemptionTokens = (brState.exemptionTokens || 0) + C.boardRewardAmounts.exemptionTokensLarge; logEntry(api, 'Board reward: +' + C.boardRewardAmounts.exemptionTokensLarge + ' exemption tokens.'); } else if (chosenReward.id === 'safety_boost_minor') { var curSafety = brState.safety != null ? brState.safety : C.startingSafety; rewardPatch.safety = Math.min(100, Math.max(0, curSafety + C.safetyBoardReward.minor)); logEntry(api, 'Board reward: +' + C.safetyBoardReward.minor + ' safety boost.'); } else if (chosenReward.id === 'safety_boost_major') { var curSafety2 = brState.safety != null ? brState.safety : C.startingSafety; rewardPatch.safety = Math.min(100, Math.max(0, curSafety2 + C.safetyBoardReward.major)); logEntry(api, 'Board reward: +' + C.safetyBoardReward.major + ' safety investment.'); } else if (chosenReward.id === 'medical_supplies') { var msRoster = JSON.parse(JSON.stringify(brState.roster || [])); var healed = false; for (var msi = 0; msi < msRoster.length; msi++) { if (msRoster[msi].state === 'injured' && (msRoster[msi].recoveryDaysLeft || 0) > 0) { msRoster[msi].recoveryDaysLeft = Math.max(0, msRoster[msi].recoveryDaysLeft - C.boardRewardAmounts.medicalSuppliesHealDays); if (msRoster[msi].recoveryDaysLeft <= 0) { var fatigueDays = C.postRecoveryFatigueDays[msRoster[msi].injurySeverity] || 0; if (fatigueDays > 0) { msRoster[msi].state = 'fatigued'; msRoster[msi].fatigueDaysLeft = fatigueDays; } else { msRoster[msi].state = 'idle'; } delete msRoster[msi].injurySeverity; delete msRoster[msi].recoveryDaysLeft; logEntry(api, 'Board reward: Medical supplies — ' + msRoster[msi].name + ' fully recovered!'); } else { logEntry(api, 'Board reward: Medical supplies — ' + msRoster[msi].name + ' heals ' + C.boardRewardAmounts.medicalSuppliesHealDays + ' day faster.'); } healed = true; break; } } if (healed) { rewardPatch.roster = msRoster; } else { logEntry(api, 'Board reward: Medical supplies — no injured guildlings to treat.'); } } else if (chosenReward.id === 'reputation_boost') { rewardPatch.reputation = (brState.reputation || 0) + C.boardRewardAmounts.reputationBoost; logEntry(api, 'Board reward: +' + C.boardRewardAmounts.reputationBoost + ' reputation boost.'); } // Update review with selected reward var updatedReview = JSON.parse(JSON.stringify(review)); updatedReview.selectedReward = chosenReward.id; // Store this week's review in allTimeStats.weekReviews var atsReview = JSON.parse(JSON.stringify(brState.allTimeStats || { totalGoldEarned: 0, totalGoldSpent: 0, totalReputationDelta: 0, totalInjuries: { light: 0, moderate: 0, severe: 0 }, totalComplianceIncidents: 0, totalOutcomes: { clean: 0, cost: 0, fail: 0, salvage: 0 }, totalContractsCompleted: 0, weekReviews: [] })); atsReview.weekReviews.push({ weekNum: updatedReview.weekNum, overallGrade: updatedReview.overallGrade, kpis: updatedReview.kpis, selectedReward: chosenReward.id, completedResults: brState.completedResults || [] }); rewardPatch.allTimeStats = atsReview; rewardPatch.currentBoardReview = updatedReview; api.patchState(rewardPatch); sfx(api, 'cdn/sfx-coin-collect-chime-pickup.mp3', 0.5, { kind: 'player', id: playerId }); api.toast('Reward selected: ' + chosenReward.label, { duration: 2.5, color: 'oklch(0.65 0.18 140)', audience: { kind: 'player', id: playerId } }); // Determine next step: campaign end or next day var isFinalReview = updatedReview.isFinalReview; if (isFinalReview) { // Calculate campaign summary and transition to campaignEnd var endState = api.getState(); var summary = BOARD.calculateCampaignSummary(endState); api.patchState({ phase: 'campaignEnd', campaignSummary: summary, gameOver: true }); logEntry(api, 'Campaign complete! Final grade: ' + summary.campaignGrade); // ── Submit to global leaderboard ── var lbPlayerName = 'Anonymous'; var lbGuildName = 'Unknown Guild'; var lbProfile = api.getProfile(playerId); if (lbProfile && lbProfile.displayName) lbPlayerName = lbProfile.displayName; var lbPs = api.getObjectState(playerId); if (lbPs && lbPs.guildName) lbGuildName = lbPs.guildName; // Compute a campaign score from the summary var lbGold = endState.gold || 0; var lbRep = endState.reputation || 0; var lbSafety = endState.safety != null ? endState.safety : 0; var lbCompliance = endState.compliance != null ? endState.compliance : 0; var lbGradeVal = { 'S': 5, 'A': 4, 'B': 3, 'C': 2, 'D': 1, 'F': 0 }; var lbGradeScore = (lbGradeVal[summary.campaignGrade] || 2) * 100; var lbFactionScore = summary.factionStandingScore || 0; var lbCampaignScore = Math.round(lbGold + (lbRep * 5) + (lbSafety * 2) + (lbCompliance * 2) + lbGradeScore + lbFactionScore); submitToLeaderboard(api, { guildName: lbGuildName, playerName: lbPlayerName, userId: (lbProfile && lbProfile.userId) ? lbProfile.userId : null, totalGold: lbGold, totalRep: lbRep, finalSafety: lbSafety, finalCompliance: lbCompliance, overallGrade: summary.campaignGrade, campaignScore: lbCampaignScore, timestamp: api.getTick() }); } else { // Re-read state AFTER reward patch so weekStart snapshots include board rewards (Doc S §Board Rewards) var postRewardState = api.getState(); // Reset weekly counters and advance to next day var freshWeekly = BOARD.freshWeeklyStats(); var nextDay = postRewardState.day + 1; var dayApplicants = generateApplicants(api); // ── Phase 17D: Week rollover — evaluate weekly economy triggers, then reset guildling weekly blocks ── var wkRoster = postRewardState.roster ? postRewardState.roster.map(function(g) { return JSON.parse(JSON.stringify(g)); }) : []; var wkRepBonus = 0; for (var wki = 0; wki < wkRoster.length; wki++) { var wkg = wkRoster[wki]; var wkWeekly = wkg.weekly || {}; var wkOutcomes = wkWeekly.outcomes || []; var wkTraits = wkg.traits || []; // Evaluate economy weekly_triggers from effect engine ledger. // Board-Friendly: weekly_trigger, target 'reputation', when 'weekly_successes:2+', once_per_week // Low Maintenance: weekly_trigger, target 'weekly_payroll', when 'weekly_no_injury', next_cycle var wkCtx = EFFECT_ENGINE.buildContext(null, [wkg], [], 'standard', wkWeekly); var wkLedger = EFFECT_ENGINE.evaluateEffects(wkg, wkCtx); var wkPassives = (wkLedger && wkLedger.weeklyPassives) ? wkLedger.weeklyPassives : []; for (var wpi = 0; wpi < wkPassives.length; wpi++) { var wpe = wkPassives[wpi]; // Handle reputation weekly triggers (e.g. Board-Friendly) if (wpe.target === 'reputation' && wpe.flags && wpe.flags.once_per_week) { // Evaluate the 'weekly_successes:N+' condition manually var requiredSuccesses = 2; // default if (typeof wpe.when === 'string') { var wsMatch = wpe.when.match(/weekly_successes:(\d+)/); if (wsMatch) requiredSuccesses = parseInt(wsMatch[1], 10); } var wkSuccessCount = 0; for (var bfo = 0; bfo < wkOutcomes.length; bfo++) { if (wkOutcomes[bfo] === 'clean' || wkOutcomes[bfo] === 'cost') wkSuccessCount++; } if (wkSuccessCount >= requiredSuccesses) { wkRepBonus += (wpe.value || 0); logEntry(api, wkg.name + '\'s ' + wpe.source + ' trait earns +' + (wpe.value || 0) + ' reputation.'); } } } // Low Maintenance: if not injured this week, flag for next cycle payroll discount. // Scan trait data for weekly_trigger with target 'weekly_payroll' and next_cycle flag. var lowMaintNext = false; for (var lmt = 0; lmt < wkTraits.length; lmt++) { var lmDef = TDATA.TRAITS_MASTER[wkTraits[lmt]]; if (!lmDef || !lmDef.effects) continue; for (var lme = 0; lme < lmDef.effects.length; lme++) { var lmEff = lmDef.effects[lme]; if (lmEff.type === 'weekly_trigger' && lmEff.targetKind === 'economy' && lmEff.flags && lmEff.flags.next_cycle) { // Check 'weekly_no_injury' condition if (!wkWeekly.injuredThisWeek) { lowMaintNext = true; } } } } // Reset weekly block to fresh defaults wkRoster[wki].weekly = { contractsCompleted: 0, contractIndex: 0, contractTypes: [], lastContractType: null, prevContractType: null, consecutiveLongContracts: 0, outcomes: [], injuredThisWeek: false, fatigueIgnoredThisWeek: false, lowMaintenanceNextCycle: lowMaintNext, lastAssignmentDay: null }; } // Apply Board-Friendly rep bonus var wkNewRep = (postRewardState.reputation || 0) + wkRepBonus; api.patchState({ day: nextDay, phase: 'intake', morningAnimDone: false, completedResults: [], activeAssignments: [], availableContracts: [], applicants: dayApplicants, hiredToday: 0, dayResults: null, roster: wkRoster, reputation: wkNewRep, weekStartSafety: postRewardState.safety != null ? postRewardState.safety : C.startingSafety, weekStartCompliance: postRewardState.compliance != null ? postRewardState.compliance : C.startingCompliance, safetyDeltaToday: 0, safetyDeltaSources: null, safetyFacilityGainToday: 0, weeklyGoldEarned: freshWeekly.weeklyGoldEarned, weeklyGoldSpent: freshWeekly.weeklyGoldSpent, weeklyReputationDelta: freshWeekly.weeklyReputationDelta, weeklyInjuries: freshWeekly.weeklyInjuries, weeklyComplianceIncidents: freshWeekly.weeklyComplianceIncidents, weeklyOutcomes: freshWeekly.weeklyOutcomes, weeklyContractsCompleted: freshWeekly.weeklyContractsCompleted }); tickRecovery(api); // Clear facility assignments var brFacState = api.getState(); var brFacCopy = ensureFacilities(brFacState); var brFacIds = Object.keys(brFacCopy); for (var bfi = 0; bfi < brFacIds.length; bfi++) { brFacCopy[brFacIds[bfi]].assigned = []; } api.patchState({ facilities: brFacCopy }); logEntry(api, 'Day ' + nextDay + ' begins. New week!'); } syncPlayerHud(api); autoSaveWithToast(api, playerId); return; } // ── Campaign End: Play again ── if (pending.action === 'playAgain') { api.patchObjectState(playerId, { pendingAction: null }); startNewGame(api, playerId); return; } // ── Campaign End: View (no-op for UI) ── if (pending.action === 'viewCampaignEnd') { api.patchObjectState(playerId, { pendingAction: null }); syncPlayerHud(api); return; } // Unknown action — clear it api.patchObjectState(playerId, { pendingAction: null }); syncPlayerHud(api); } // Legacy onInteract kept for backwards compatibility export function onInteract(other, api) { api.log('[MANAGER] onInteract from ' + other.id); var playerState = api.getObjectState(other.id); var pending = playerState ? playerState.pendingAction : null; if (pending) { handlePlayerAction(api, other.id, pending); } else { advancePhase(api, other); } } // ─── SAVE MIGRATION: normalizeGuildling ───────────────────────── function normalizeGuildling(g, api) { if (!g) return g; var changed = false; var oldTraits = g.traits ? g.traits.slice() : []; var oldQuirk = g.quirk; // 1. Trait ID migration if (g.traits && g.traits.length > 0) { var newTraits = []; for (var ti = 0; ti < g.traits.length; ti++) { var tId = g.traits[ti]; if (TDATA.TRAITS_MASTER[tId]) { // Valid in new system newTraits.push(tId); } else if (TDATA.LEGACY_TRAIT_MAP[tId]) { // Old ID → mapped to new newTrait