Merge wl-CG-0MMLR38NJ1N11DOS-reputation-coin-multiplier: Reputation-based coin multiplier and positive-incident-multiplier

Author: Sorra

docs/main-street/prd-milestone-2.md

@@ -612,7 +612,7 @@ loadCampaignProgress(store) -> campaign (or createDefaultCampaignProgress())
     |
     v
 createBusinessDeck(3, campaign.unlockedCardIds)
-createEventDeck(3, campaign.unlockedCardIds)
+createEventDeck(3, campaign.unlockedCardIds, createSeededRng(42) /* rng is required for deterministic fractional allocation; use createSeededRng(seed) in tests/runtime */)
 createUpgradeDeck(2, campaign.unlockedCardIds)
     |
     v

example-games/main-street/MainStreetAdjacency.ts

@@ -12,6 +12,7 @@ import type { BusinessCard, SynergyType } from './MainStreetCards';
 import { GRID_SIZE, SYNERGY_BONUS_PER_NEIGHBOR } from './MainStreetCards';
 import type { MainStreetState } from './MainStreetState';
 import { addLog } from './MainStreetState';
+import { applyReputationMultiplier } from './MainStreetDifficulty';
 
 // ── Adjacency Resolver ──────────────────────────────────────
 
@@ -142,14 +143,23 @@ export function computeIncome(
  * Mutates state in-place. Uses config.synergyBonusPerNeighbor from the
  * active difficulty preset.
  *
+ * Income is scaled by the reputation coin multiplier (CG-0MMLR38NJ1N11DOS)
+ * so that higher reputation yields proportionally more income.
+ *
  * @param state  Current game state (mutated).
- * @returns The IncomeResult for UI display.
+ * @returns The IncomeResult for UI display (pre-multiplier breakdown,
+ *          but total reflects the multiplied amount actually credited).
  */
 export function applyIncome(state: MainStreetState): IncomeResult {
   const result = computeIncome(state.streetGrid, state.config.synergyBonusPerNeighbor);
-  state.resourceBank.coins += result.total;
-  if (result.total > 0) {
-    addLog(state, `Income: +${result.total} coins`, 'gain');
+  const multiplied = applyReputationMultiplier(
+    result.total,
+    state.resourceBank.reputation,
+    state.config,
+  );
+  state.resourceBank.coins += multiplied;
+  if (multiplied > 0) {
+    addLog(state, `Income: +${multiplied} coins`, 'gain');
   } else {
     addLog(state, `Income: +0 coins`, 'neutral');
   }

example-games/main-street/MainStreetCards.ts

@@ -887,20 +887,90 @@ export function createBusinessDeck(
  *                        When provided, only templates whose ID is in this list
  *                        are included. When omitted, the full pool is used.
  */
+/**
+ * Creates the full Event deck for a game.
+ *
+ * Supports an optional `positiveIncidentMultiplier` to increase the
+ * relative frequency of positive Incident events by duplicating positive
+ * Incident templates before deck assembly. This keeps selection deterministic
+ * under the seeded RNG used throughout Main Street while allowing tuning
+ * without changing core selection logic.
+ *
+ * @param copies          Number of copies per template (default 3).
+ * @param unlockedCardIds Optional list of unlocked card IDs for tier filtering.
+ * @param positiveIncidentMultiplier Multiplier applied to positive Incident templates (>=1).
+ */
 export function createEventDeck(
   copies: number = 3,
-  unlockedCardIds?: string[],
+  unlockedCardIds: string[] | undefined,
+  rng: () => number,
+  positiveIncidentMultiplier: number = 1,
 ): EventCard[] {
   const templates = unlockedCardIds
     ? EVENT_TEMPLATES.filter((t) => unlockedCardIds.includes(t.id))
     : EVENT_TEMPLATES;
 
+  // If multiplier > 1, positive Incident templates should appear more often.
+  // Implement fractional multipliers deterministically without introducing
+  // a seeded RNG dependency: we give every positive Incident template
+  // `baseDup = floor(multiplier)` repeats, then distribute the fractional
+  // remainder by granting one extra repeat to `extraCount` templates. The
+  // selection is deterministic (first N positive templates in template
+  // order) so behavior is stable across runs.
   const deck: EventCard[] = [];
-  for (let c = 0; c < copies; c++) {
-    for (const template of templates) {
-      deck.push({ ...template, id: `${template.id}-${c}` });
+  let serial = 0;
+
+  const mult = Math.max(1, positiveIncidentMultiplier);
+  const baseDup = Math.floor(mult);
+  const fraction = mult - baseDup;
+
+  // Identify positions (indices) of positive Incident templates in the
+  // `templates` array so we can select which ones receive the fractional
+  // extra duplicates.
+  const positiveIndices: number[] = [];
+  for (let i = 0; i < templates.length; i++) {
+    const t = templates[i];
+    if (t.trigger === 'Incident' && (t.coinDelta + t.reputationDelta) > 0) {
+      positiveIndices.push(i);
+    }
+  }
+
+  const positiveCount = positiveIndices.length;
+  const extraCount = Math.round(fraction * positiveCount);
+
+  // Decide which positive template indices receive the extra +1 duplicate.
+  // Always use the provided seeded RNG to shuffle and choose extraCount
+  // indices. This makes the fractional distribution deterministic per-game
+  // seed and removes order bias.
+  const extraSet = new Set<number>();
+  if (extraCount > 0 && positiveCount > 0) {
+    // Shuffle a copy of positiveIndices using Fisher-Yates with provided RNG
+    const idxs = positiveIndices.slice();
+    for (let i = idxs.length - 1; i > 0; i--) {
+      const j = Math.floor(rng() * (i + 1));
+      const tmp = idxs[i]; idxs[i] = idxs[j]; idxs[j] = tmp;
     }
+    for (let k = 0; k < extraCount; k++) extraSet.add(idxs[k]);
   }
+
+  // Iterate templates and assign duplicates. For positive templates, add
+  // `baseDup` plus 1 if the template's index is in extraSet. For all others, use 1.
+  for (let i = 0; i < templates.length; i++) {
+    const template = templates[i];
+    const net = template.coinDelta + template.reputationDelta;
+    const isPositiveIncident = template.trigger === 'Incident' && net > 0;
+    let dupCount = 1;
+    if (isPositiveIncident) {
+      dupCount = baseDup + (extraSet.has(i) ? 1 : 0);
+    }
+
+    const repeat = copies * dupCount;
+    for (let r = 0; r < repeat; r++) {
+      deck.push({ ...template, id: `${template.id}-${serial}` });
+      serial += 1;
+    }
+  }
+
   return deck;
 }
 

example-games/main-street/MainStreetDifficulty.ts

@@ -78,6 +78,24 @@ export interface GameConfig extends DifficultyConfig {
   // ── Challenges ──────────────────────────────────────────
   /** Number of challenges selected per run. */
   readonly challengesPerRun: number;
+  /** Multiplier to increase positive Incident frequency (1.0 = baseline). */
+  readonly positiveIncidentMultiplier: number;
+
+  // ── Reputation-based Coin Multiplier ───────────────────
+  /**
+   * Divisor used in the reputation coin multiplier formula:
+   *   multiplier = 1 + (reputation / reputationCoinDivisor)
+   *
+   * Higher values make reputation less impactful on coin rewards.
+   * Default 20 means rep=20 yields a 2x multiplier.
+   */
+  readonly reputationCoinDivisor: number;
+  /**
+   * Maximum value the reputation coin multiplier can reach.
+   * Prevents runaway scaling in long or lucky games.
+   * Default 3.0 means coin rewards can at most triple.
+   */
+  readonly maxReputationCoinMultiplier: number;
 }
 
 // ── Preset Definitions ──────────────────────────────────────
@@ -96,6 +114,9 @@ export const EASY_PRESET: Readonly<GameConfig> = {
   challengeBonusPoints: 15,
   synergyBonusPerNeighbor: 2,
   challengesPerRun: 2,
+  positiveIncidentMultiplier: 1.2,
+  reputationCoinDivisor: 20,
+  maxReputationCoinMultiplier: 3.0,
 };
 
 /**
@@ -112,6 +133,11 @@ export const MEDIUM_PRESET: Readonly<GameConfig> = {
   challengeBonusPoints: 10,
   synergyBonusPerNeighbor: 1,
   challengesPerRun: 3,
+  // Increase positive incident frequency by 50% for the Medium baseline
+  // as requested by work item CG-0MMLR20XP1IPPD03.
+  positiveIncidentMultiplier: 1.5,
+  reputationCoinDivisor: 20,
+  maxReputationCoinMultiplier: 3.0,
 };
 
 /**
@@ -128,6 +154,9 @@ export const HARD_PRESET: Readonly<GameConfig> = {
   challengeBonusPoints: 8,
   synergyBonusPerNeighbor: 1,
   challengesPerRun: 4,
+  positiveIncidentMultiplier: 1,
+  reputationCoinDivisor: 20,
+  maxReputationCoinMultiplier: 3.0,
 };
 
 // ── Preset Registry ─────────────────────────────────────────
@@ -156,3 +185,57 @@ export function getPreset(name: DifficultyName | undefined): Readonly<GameConfig
 
 /** All available difficulty names in display order. */
 export const DIFFICULTY_NAMES: readonly DifficultyName[] = ['Easy', 'Medium', 'Hard'];
+
+// ── Reputation-based Coin Multiplier ────────────────────────
+
+/**
+ * Computes the reputation-based coin multiplier.
+ *
+ * Formula: min(1 + reputation / divisor, cap)
+ *
+ * Uses the additive formula so that reputation=0 still yields a 1x
+ * baseline (no reward lost). The multiplier is capped to prevent
+ * runaway scaling in long or lucky games.
+ *
+ * - reputation=0  -> 1.0x (baseline preserved)
+ * - reputation=10 -> 1.5x (with divisor=20)
+ * - reputation=20 -> 2.0x
+ * - reputation=40 -> 3.0x (capped at maxMultiplier=3.0)
+ * - reputation=60 -> 3.0x (capped)
+ *
+ * Negative reputation clamps the multiplier at 1.0 (no penalty via
+ * this channel -- reputation collapse is handled elsewhere).
+ *
+ * @param reputation  Current player reputation.
+ * @param config      Game config with reputationCoinDivisor and maxReputationCoinMultiplier.
+ * @returns The multiplier to apply to coin rewards (always >= 1.0).
+ */
+export function reputationCoinMultiplier(
+  reputation: number,
+  config: Pick<GameConfig, 'reputationCoinDivisor' | 'maxReputationCoinMultiplier'>,
+): number {
+  if (!Number.isFinite(reputation) || reputation <= 0) return 1.0;
+  const raw = 1 + reputation / config.reputationCoinDivisor;
+  return Math.min(raw, config.maxReputationCoinMultiplier);
+}
+
+/**
+ * Applies the reputation coin multiplier to a raw coin delta.
+ *
+ * Only positive coin deltas are scaled -- negative deltas (penalties)
+ * pass through unchanged so that reputation does not amplify losses.
+ * The result is rounded down (floored) to keep coin amounts integral.
+ *
+ * @param rawCoinDelta  The base coin amount (positive = gain, negative = penalty).
+ * @param reputation    Current player reputation.
+ * @param config        Game config with multiplier tuning constants.
+ * @returns The adjusted coin delta.
+ */
+export function applyReputationMultiplier(
+  rawCoinDelta: number,
+  reputation: number,
+  config: Pick<GameConfig, 'reputationCoinDivisor' | 'maxReputationCoinMultiplier'>,
+): number {
+  if (rawCoinDelta <= 0) return rawCoinDelta;
+  return Math.floor(rawCoinDelta * reputationCoinMultiplier(reputation, config));
+}

example-games/main-street/MainStreetEngine.ts

@@ -28,6 +28,10 @@ import {
   type PurchaseResult,
 } from './MainStreetMarket';
 import { evaluateChallenges } from './MainStreetChallenges';
+import { applyReputationMultiplier, reputationCoinMultiplier } from './MainStreetDifficulty';
+
+// Re-export for convenience (tests import from the engine module).
+export { reputationCoinMultiplier, applyReputationMultiplier };
 
 // ── Action Types ────────────────────────────────────────────
 
@@ -199,21 +203,29 @@ function classifyEffect(coinChange: number, repChange: number): 'gain' | 'loss'
  * SpecificSynergy events apply their coinDelta to each matching business
  * (simplified: apply delta once per matching placed business).
  * All/other events apply the delta directly to the resource bank.
+ *
+ * Positive coin deltas are scaled by the reputation coin multiplier
+ * (CG-0MMLR38NJ1N11DOS). Negative deltas (penalties) pass through
+ * unchanged.
  */
 export function resolveEvent(state: MainStreetState, event: EventCard): void {
+  const rep = state.resourceBank.reputation;
+  const cfg = state.config;
+
   switch (event.target) {
     case 'SpecificSynergy': {
       // Count matching businesses and apply coinDelta per match
       const matchCount = state.streetGrid.filter(
         b => b !== null && b.synergyTypes.includes(event.targetSynergy as SynergyType),
       ).length;
-      state.resourceBank.coins += event.coinDelta * matchCount;
+      const rawDelta = event.coinDelta * matchCount;
+      state.resourceBank.coins += applyReputationMultiplier(rawDelta, rep, cfg);
       state.resourceBank.reputation += event.reputationDelta;
       break;
     }
     case 'All': {
       // Apply to all -- direct delta on resource bank
-      state.resourceBank.coins += event.coinDelta;
+      state.resourceBank.coins += applyReputationMultiplier(event.coinDelta, rep, cfg);
       state.resourceBank.reputation += event.reputationDelta;
       break;
     }
@@ -225,7 +237,7 @@ export function resolveEvent(state: MainStreetState, event: EventCard): void {
         // Consume RNG for deterministic selection (used in future milestones)
         const _targetIdx = Math.floor(state.rng() * placed.length);
         void _targetIdx;
-        state.resourceBank.coins += event.coinDelta;
+        state.resourceBank.coins += applyReputationMultiplier(event.coinDelta, rep, cfg);
       }
       state.resourceBank.reputation += event.reputationDelta;
       break;

example-games/main-street/MainStreetState.ts

@@ -345,7 +345,10 @@ export function setupMainStreetGame(options: MainStreetSetupOptions = {}): MainS
 
   // Create and shuffle decks
   const businessDeck = createBusinessDeck(3, options.unlockedCardIds);
-  const eventDeck = createEventDeck(3, options.unlockedCardIds);
+  // Apply positive-incident weighting from the runtime difficulty config.
+  // Pass the game's seeded RNG into createEventDeck so fractional duplicates
+  // are selected deterministically per-game-seed rather than by template order.
+  const eventDeck = createEventDeck(3, options.unlockedCardIds, rng, config.positiveIncidentMultiplier);
   const upgradeDeck = createUpgradeDeck(2, options.unlockedCardIds);
 
   shuffleArray(businessDeck, rng);

tests/golf/__screenshots__/GolfEvents.browser.test.ts/GolfScene-event-integration-should-emit-correct-event-sequence-for-human---AI-turn-cycle-and-game-ended-on-end-1.png

@@ -277,7 +277,9 @@ describe('MainStreetAdjacency', () => {
       // food-1: 3 + 1 synergy = 4
       // food-2: 2 + 1 synergy = 3
       expect(result.total).toBe(7);
-      expect(state.resourceBank.coins).toBe(coinsBefore + 7);
+      // Reputation multiplier: rep=3 (Medium default), divisor=20 → 1 + 3/20 = 1.15
+      // floor(7 * 1.15) = floor(8.05) = 8
+      expect(state.resourceBank.coins).toBe(coinsBefore + 8);
     });
 
     it('should not change coins for empty grid', () => {

tests/main-street/adjacency.test.ts

@@ -21,6 +21,7 @@ import {
   type BusinessCard,
   type SynergyType,
 } from '../../example-games/main-street/MainStreetCards';
+import { getPreset } from '../../example-games/main-street/MainStreetDifficulty';
 import { computeSynergyBonus, computeBusinessIncome } from '../../example-games/main-street/MainStreetAdjacency';
 import { setupMainStreetGame } from '../../example-games/main-street/MainStreetState';
 import { GRID_SIZE } from '../../example-games/main-street/MainStreetCards';
@@ -44,9 +45,11 @@ function makeBiz(overrides: Partial<BusinessCard> & { name: string; synergyTypes
   };
 }
 
-// Build decks once for template validation
+// Build decks once for template validation (use multiplier=1 to test raw templates)
+import { createSeededRng } from '../../src/core-engine';
+const _rng = createSeededRng(42);
 const businessDeck = createBusinessDeck(1); // 1 copy = template count
-const eventDeck = createEventDeck(1);
+const eventDeck = createEventDeck(1, undefined, _rng, 1); // template-only view
 const upgradeDeck = createUpgradeDeck(1);
 
 // ── Template Completeness ───────────────────────────────────
@@ -417,8 +420,8 @@ describe('Expanded Card Pool: Deck Building', () => {
     expect(createBusinessDeck(3)).toHaveLength(51);
   });
 
-  it('event deck with 3 copies should have 51 cards', () => {
-    expect(createEventDeck(3)).toHaveLength(51);
+    it('event deck with 3 copies should have 51 cards', () => {
+    expect(createEventDeck(3, undefined, _rng, 1)).toHaveLength(51);
   });
 
   it('upgrade deck with 2 copies should have 50 cards', () => {
@@ -509,7 +512,8 @@ describe('Expanded Card Pool: Seeded Deck Resolution', () => {
       + state.decks.event.length
       + state.incidentQueue.length
       + (state.heldEvent ? 1 : 0);
-    expect(eventTotal).toBe(createEventDeck().length);
+    const multiplier = getPreset(undefined).positiveIncidentMultiplier;
+    expect(eventTotal).toBe(createEventDeck(3, undefined, _rng, multiplier).length);
 
     const upgTotal = state.market.investments.filter(c => c.family === 'upgrade').length
       + state.decks.upgrade.length;