539 lines
23 KiB
TypeScript
539 lines
23 KiB
TypeScript
/**
|
||
* MLS Season + Playoffs Simulator
|
||
*
|
||
* Monte Carlo simulation of the MLS regular season and MLS Cup Playoffs.
|
||
*
|
||
* Two modes, auto-detected at runtime:
|
||
*
|
||
* ── Mode 1: Known-Seed ────────────────────────────────────────────────────────
|
||
* Used when all 18 playoff seeds (1–9 East, 1–9 West) are set via the `seed`
|
||
* input and a `region` ("Eastern"/"Western") is present for every playoff team.
|
||
* Simulates the playoff bracket directly from those seeds.
|
||
*
|
||
* ── Mode 2: Regular-Season Projection (default) ───────────────────────────────
|
||
* Simulates remaining regular-season games per team using Elo vs the average
|
||
* opponent (1500), per conference. Top 9 teams per conference qualify.
|
||
* Then simulates the MLS Cup Playoffs bracket.
|
||
*
|
||
* Conference assignment resolution order:
|
||
* 1. regularSeasonStandings.conference (populated by standings sync)
|
||
* 2. seasonParticipantSimulatorInputs.region ("Eastern" or "Western")
|
||
* 3. seasonParticipant.externalId set to "Eastern" or "Western" (pre-sync bootstrap;
|
||
* note: this prevents externalId-based matching in future syncs for that participant,
|
||
* which falls back to slower name-matching — acceptable tradeoff for bootstrapping)
|
||
* 4. Error — conference must be known for all teams
|
||
*
|
||
* MLS Cup Playoffs format (18 teams: 9 East + 9 West):
|
||
* Wild Card : E8 vs E9, W8 vs W9 — single game (no draws; PKs if tied)
|
||
* Round 1 (Conf Quarters): best-of-3 — E1 vs WC winner, E2 vs E7, E3 vs E6, E4 vs E5
|
||
* (same structure West)
|
||
* Conference Semifinals : single game — 4 per conference → 2 per conference
|
||
* Conference Finals : single game — 2 per conference → 1 per conference
|
||
* MLS Cup : single game — East champion vs West champion
|
||
*
|
||
* Probability mapping:
|
||
* probFirst = MLS Cup champion (1 per sim)
|
||
* probSecond = MLS Cup finalist (1 per sim)
|
||
* probThird/Fourth = Conference Finals losers (2 per sim — split evenly)
|
||
* probFifth–Eighth = Conference Semifinals losers (4 per sim — split evenly)
|
||
* Wild Card losers, Round 1 losers, non-qualifiers → all 0
|
||
*/
|
||
|
||
import { database } from "~/database/context";
|
||
import { eq } from "drizzle-orm";
|
||
import * as schema from "~/database/schema";
|
||
import type { Simulator, SimulationResult } from "./types";
|
||
import { eloWinProbabilityWithParity, convertFuturesToElo } from "~/services/probability-engine";
|
||
import { getRegularSeasonStandings } from "~/models/regular-season-standings";
|
||
import { getParticipantSimulatorInputs, getSportsSeasonSimulatorConfig } from "~/models/simulator";
|
||
import { simulateEloSoccerMatch, simulateSimpleSoccerGoals } from "./soccer-helpers";
|
||
import type { EloSoccerMatchOptions } from "./soccer-helpers";
|
||
import { normalizeSimulationResultColumns } from "./simulation-probabilities";
|
||
import { logger } from "~/lib/logger";
|
||
import { configNumber } from "./config-access";
|
||
|
||
// ─── Default constants (overridable via season simulator config) ───────────────
|
||
|
||
const DEFAULT_NUM_SIMULATIONS = 50_000;
|
||
const DEFAULT_SEASON_GAMES = 34;
|
||
const DEFAULT_PARITY_FACTOR = 400;
|
||
const DEFAULT_AVERAGE_OPPONENT_ELO = 1500;
|
||
const DEFAULT_BASE_DRAW_RATE = 0.26;
|
||
const DEFAULT_DRAW_DECAY = 0.002;
|
||
|
||
const MLS_PLAYOFF_TEAMS_PER_CONF = 9;
|
||
|
||
|
||
/**
|
||
* Infer MLS conference from seasonParticipant.externalId.
|
||
* Admins can set externalId to "Eastern" or "Western" before the first standings
|
||
* sync, mirroring how LLWS uses externalId to encode pool assignment.
|
||
*
|
||
* Side-effect: once externalId holds a conference name instead of an ESPN team ID,
|
||
* the standings-sync write-back won't overwrite it (write-back only fires when
|
||
* externalId is null). That participant will always match by name, never by ID.
|
||
*/
|
||
export function parseConferenceFromExternalId(externalId: string | null | undefined): MlsConference | null {
|
||
if (!externalId) return null;
|
||
const upper = externalId.toUpperCase();
|
||
if (upper === "EASTERN") return "Eastern";
|
||
if (upper === "WESTERN") return "Western";
|
||
return null;
|
||
}
|
||
|
||
// ─── Public types ─────────────────────────────────────────────────────────────
|
||
|
||
export type MlsConference = "Eastern" | "Western";
|
||
|
||
export interface MlsTeamEntry {
|
||
participantId: string;
|
||
elo: number;
|
||
conference: MlsConference;
|
||
currentPoints: number;
|
||
currentGoalsFor: number;
|
||
currentGoalDifference: number;
|
||
remainingGames: number;
|
||
}
|
||
|
||
export interface MlsConferenceSeed {
|
||
participantId: string;
|
||
elo: number;
|
||
conference: MlsConference;
|
||
seed: number; // 1–9 within conference
|
||
}
|
||
|
||
export interface MlsPlayoffResult {
|
||
champion: string;
|
||
finalist: string;
|
||
confFinalsLosers: [string, string];
|
||
confSemiLosers: [string, string, string, string];
|
||
}
|
||
|
||
// ─── Match helpers ────────────────────────────────────────────────────────────
|
||
|
||
export function mlsWinProbability(eloA: number, eloB: number, parityFactor = DEFAULT_PARITY_FACTOR): number {
|
||
return eloWinProbabilityWithParity(eloA, eloB, parityFactor);
|
||
}
|
||
|
||
const DEFAULT_MATCH_OPTIONS: EloSoccerMatchOptions = {
|
||
baseDrawRate: DEFAULT_BASE_DRAW_RATE,
|
||
drawDecay: DEFAULT_DRAW_DECAY,
|
||
parityFactor: DEFAULT_PARITY_FACTOR,
|
||
};
|
||
|
||
/**
|
||
* Simulate a single MLS knockout game (no draws allowed in result).
|
||
* If the Elo match produces a draw, a penalty shootout is simulated
|
||
* using the same Elo win probability.
|
||
*/
|
||
export function simulateMlsKnockoutGame(
|
||
teamA: MlsConferenceSeed,
|
||
teamB: MlsConferenceSeed,
|
||
matchOptions: EloSoccerMatchOptions = DEFAULT_MATCH_OPTIONS
|
||
): { winner: MlsConferenceSeed; loser: MlsConferenceSeed } {
|
||
const result = simulateEloSoccerMatch(teamA.elo, teamB.elo, matchOptions);
|
||
if (result === "win") return { winner: teamA, loser: teamB };
|
||
if (result === "loss") return { winner: teamB, loser: teamA };
|
||
// Draw → penalty shootout (Elo-biased coin flip)
|
||
const pA = mlsWinProbability(teamA.elo, teamB.elo, matchOptions.parityFactor ?? DEFAULT_PARITY_FACTOR);
|
||
return Math.random() < pA
|
||
? { winner: teamA, loser: teamB }
|
||
: { winner: teamB, loser: teamA };
|
||
}
|
||
|
||
/**
|
||
* Simulate a best-of-3 MLS Round 1 series.
|
||
* Individual games use knockout rules (no draws; PKs decide ties).
|
||
* Higher seed is home for games 1 and 3.
|
||
*/
|
||
export function simulateMlsBestOfThree(
|
||
higherSeed: MlsConferenceSeed,
|
||
lowerSeed: MlsConferenceSeed,
|
||
matchOptions: EloSoccerMatchOptions = DEFAULT_MATCH_OPTIONS,
|
||
existing: { winsHigher: number; winsLower: number } = { winsHigher: 0, winsLower: 0 }
|
||
): { winner: MlsConferenceSeed; loser: MlsConferenceSeed; gamesPlayed: number } {
|
||
let wH = existing.winsHigher;
|
||
let wL = existing.winsLower;
|
||
let gamesPlayed = 0;
|
||
while (wH < 2 && wL < 2) {
|
||
const { winner } = simulateMlsKnockoutGame(higherSeed, lowerSeed, matchOptions);
|
||
if (winner.participantId === higherSeed.participantId) wH++; else wL++;
|
||
gamesPlayed++;
|
||
}
|
||
return wH === 2
|
||
? { winner: higherSeed, loser: lowerSeed, gamesPlayed }
|
||
: { winner: lowerSeed, loser: higherSeed, gamesPlayed };
|
||
}
|
||
|
||
// ─── Regular-season simulation ────────────────────────────────────────────────
|
||
|
||
/**
|
||
* Simulate remaining regular season games per conference and return the
|
||
* top-9 seeds for each conference sorted by points → GD → GF → random tiebreak.
|
||
*/
|
||
export function simulateMlsRegularSeason(
|
||
teams: MlsTeamEntry[],
|
||
matchOptions: EloSoccerMatchOptions = DEFAULT_MATCH_OPTIONS,
|
||
averageOpponentElo = DEFAULT_AVERAGE_OPPONENT_ELO
|
||
): { east: MlsConferenceSeed[]; west: MlsConferenceSeed[] } {
|
||
const jitter = new Map(teams.map((t) => [t.participantId, Math.random()]));
|
||
|
||
const rows = teams.map((t) => {
|
||
let points = t.currentPoints;
|
||
let gd = t.currentGoalDifference;
|
||
let gf = t.currentGoalsFor;
|
||
|
||
for (let g = 0; g < t.remainingGames; g++) {
|
||
const result = simulateEloSoccerMatch(t.elo, averageOpponentElo, matchOptions);
|
||
const goals = simulateSimpleSoccerGoals(result);
|
||
gf += goals.gf;
|
||
gd += goals.gf - goals.ga;
|
||
if (result === "win") points += 3;
|
||
else if (result === "draw") points += 1;
|
||
}
|
||
|
||
return { participantId: t.participantId, elo: t.elo, conference: t.conference, points, gd, gf };
|
||
});
|
||
|
||
function seedConference(conf: MlsConference): MlsConferenceSeed[] {
|
||
const confRows = rows.filter((r) => r.conference === conf);
|
||
const sorted = confRows.toSorted(
|
||
(a, b) =>
|
||
b.points - a.points ||
|
||
b.gd - a.gd ||
|
||
b.gf - a.gf ||
|
||
(jitter.get(b.participantId) ?? 0) - (jitter.get(a.participantId) ?? 0)
|
||
);
|
||
return sorted.slice(0, MLS_PLAYOFF_TEAMS_PER_CONF).map((r, i) => ({
|
||
participantId: r.participantId,
|
||
elo: r.elo,
|
||
conference: conf,
|
||
seed: i + 1,
|
||
}));
|
||
}
|
||
|
||
return { east: seedConference("Eastern"), west: seedConference("Western") };
|
||
}
|
||
|
||
// ─── Playoff simulation ────────────────────────────────────────────────────────
|
||
|
||
function getBySeeds(
|
||
seeds: MlsConferenceSeed[],
|
||
...seedNums: number[]
|
||
): MlsConferenceSeed[] {
|
||
const byNum = new Map(seeds.map((s) => [s.seed, s]));
|
||
return seedNums.map((n) => {
|
||
const entry = byNum.get(n);
|
||
if (!entry) throw new Error(`MLS playoff seed ${n} not found in conference bracket.`);
|
||
return entry;
|
||
});
|
||
}
|
||
|
||
/**
|
||
* Simulate the full MLS Cup Playoffs from 9+9 conference seeds.
|
||
*/
|
||
export function simulateMlsPlayoffs(
|
||
east: MlsConferenceSeed[],
|
||
west: MlsConferenceSeed[],
|
||
matchOptions: EloSoccerMatchOptions = DEFAULT_MATCH_OPTIONS
|
||
): MlsPlayoffResult {
|
||
function simConference(seeds: MlsConferenceSeed[]): {
|
||
champion: MlsConferenceSeed;
|
||
finalist: MlsConferenceSeed;
|
||
confSemiLosers: [string, string];
|
||
} {
|
||
const [s1, s2, s3, s4, s5, s6, s7, s8, s9] = getBySeeds(seeds, 1, 2, 3, 4, 5, 6, 7, 8, 9);
|
||
|
||
// Wild Card: 8 vs 9
|
||
const wc = simulateMlsKnockoutGame(s8, s9, matchOptions);
|
||
|
||
// Round 1 (best-of-3): 1 vs WC winner, 2 vs 7, 3 vs 6, 4 vs 5
|
||
const r1a = simulateMlsBestOfThree(s1, wc.winner, matchOptions);
|
||
const r1b = simulateMlsBestOfThree(s2, s7, matchOptions);
|
||
const r1c = simulateMlsBestOfThree(s3, s6, matchOptions);
|
||
const r1d = simulateMlsBestOfThree(s4, s5, matchOptions);
|
||
|
||
// Conference Semifinals: single game
|
||
// Arm A: r1a winner vs r1d winner; Arm B: r1b winner vs r1c winner
|
||
const sfA = simulateMlsKnockoutGame(r1a.winner, r1d.winner, matchOptions);
|
||
const sfB = simulateMlsKnockoutGame(r1b.winner, r1c.winner, matchOptions);
|
||
|
||
// Conference Finals: single game
|
||
const confFinal = simulateMlsKnockoutGame(sfA.winner, sfB.winner, matchOptions);
|
||
|
||
return {
|
||
champion: confFinal.winner,
|
||
finalist: confFinal.loser,
|
||
confSemiLosers: [sfA.loser.participantId, sfB.loser.participantId],
|
||
};
|
||
}
|
||
|
||
const eastResult = simConference(east);
|
||
const westResult = simConference(west);
|
||
|
||
// MLS Cup: East champion vs West champion
|
||
const cup = simulateMlsKnockoutGame(eastResult.champion, westResult.champion, matchOptions);
|
||
|
||
return {
|
||
champion: cup.winner.participantId,
|
||
finalist: cup.loser.participantId,
|
||
confFinalsLosers: [eastResult.finalist.participantId, westResult.finalist.participantId],
|
||
confSemiLosers: [
|
||
...eastResult.confSemiLosers,
|
||
...westResult.confSemiLosers,
|
||
] as [string, string, string, string],
|
||
};
|
||
}
|
||
|
||
// ─── Simulator class ──────────────────────────────────────────────────────────
|
||
|
||
export class MLSSimulator implements Simulator {
|
||
async simulate(sportsSeasonId: string): Promise<SimulationResult[]> {
|
||
const db = database();
|
||
|
||
const [participants, evRows, standingsRows, simInputs, simulatorConfig] = await Promise.all([
|
||
db.query.seasonParticipants.findMany({
|
||
where: eq(schema.seasonParticipants.sportsSeasonId, sportsSeasonId),
|
||
}),
|
||
db
|
||
.select({
|
||
participantId: schema.seasonParticipantExpectedValues.participantId,
|
||
sourceElo: schema.seasonParticipantExpectedValues.sourceElo,
|
||
sourceOdds: schema.seasonParticipantExpectedValues.sourceOdds,
|
||
})
|
||
.from(schema.seasonParticipantExpectedValues)
|
||
.where(eq(schema.seasonParticipantExpectedValues.sportsSeasonId, sportsSeasonId)),
|
||
getRegularSeasonStandings(sportsSeasonId),
|
||
getParticipantSimulatorInputs(sportsSeasonId),
|
||
getSportsSeasonSimulatorConfig(sportsSeasonId),
|
||
]);
|
||
|
||
if (participants.length === 0) {
|
||
throw new Error(`No participants found for sports season ${sportsSeasonId}.`);
|
||
}
|
||
|
||
// Extract config values (admin-overridable; fall back to defaults)
|
||
const config = simulatorConfig?.config;
|
||
const numSimulations = Math.round(configNumber(config, "iterations", DEFAULT_NUM_SIMULATIONS));
|
||
const seasonGames = Math.round(configNumber(config, "seasonGames", DEFAULT_SEASON_GAMES));
|
||
const averageOpponentElo = configNumber(config, "averageOpponentElo", DEFAULT_AVERAGE_OPPONENT_ELO);
|
||
const matchOptions: EloSoccerMatchOptions = {
|
||
baseDrawRate: configNumber(config, "baseDrawRate", DEFAULT_BASE_DRAW_RATE),
|
||
drawDecay: configNumber(config, "drawDecay", DEFAULT_DRAW_DECAY),
|
||
parityFactor: configNumber(config, "matchParityFactor", DEFAULT_PARITY_FACTOR),
|
||
};
|
||
|
||
// Build Elo map: prefer sourceElo; fall back to converting sourceOdds
|
||
const eloMap = new Map<string, number>();
|
||
const hasSourceElo = evRows.some((r) => r.sourceElo !== null);
|
||
if (hasSourceElo) {
|
||
for (const r of evRows) {
|
||
if (r.sourceElo !== null) eloMap.set(r.participantId, r.sourceElo);
|
||
}
|
||
} else {
|
||
const hasOdds = evRows.some((r) => r.sourceOdds !== null);
|
||
if (!hasOdds) {
|
||
throw new Error(
|
||
`No Elo ratings or futures odds found for sports season ${sportsSeasonId}. ` +
|
||
`Enter sourceElo, projectedTablePoints, or sourceOdds via Admin → Elo Ratings before simulating.`
|
||
);
|
||
}
|
||
const oddsInput = evRows
|
||
.filter((r) => r.sourceOdds !== null)
|
||
.map((r) => ({ participantId: r.participantId, odds: r.sourceOdds as number }));
|
||
const converted = convertFuturesToElo(oddsInput);
|
||
for (const [id, elo] of converted) eloMap.set(id, elo);
|
||
}
|
||
|
||
// Build simulator input maps (seed + region)
|
||
const seedMap = new Map<string, number>();
|
||
const regionMap = new Map<string, string>();
|
||
for (const input of simInputs) {
|
||
if (input.seed !== null && input.seed !== undefined) {
|
||
seedMap.set(input.participantId, input.seed);
|
||
}
|
||
if (input.region !== null && input.region !== undefined) {
|
||
regionMap.set(input.participantId, input.region);
|
||
}
|
||
}
|
||
|
||
// Resolve conference for every participant.
|
||
// Priority: (1) regularSeasonStandings.conference, (2) simulatorInputs.region,
|
||
// (3) seasonParticipant.externalId set to "Eastern"/"Western" (pre-sync bootstrap).
|
||
const standingsMap = new Map(standingsRows.map((r) => [r.participantId, r]));
|
||
const conferenceMap = new Map<string, MlsConference>();
|
||
for (const p of participants) {
|
||
const standing = standingsMap.get(p.id);
|
||
const raw =
|
||
(standing?.conference as string | null | undefined) ??
|
||
regionMap.get(p.id) ??
|
||
parseConferenceFromExternalId(p.externalId) ??
|
||
null;
|
||
if (raw === "Eastern" || raw === "Western") {
|
||
conferenceMap.set(p.id, raw);
|
||
}
|
||
}
|
||
|
||
const missingConf = participants.filter((p) => !conferenceMap.has(p.id));
|
||
if (missingConf.length > 0) {
|
||
throw new Error(
|
||
`MLSSimulator: Conference assignment missing for ${missingConf.length} team(s): ` +
|
||
`${missingConf.map((p) => p.name).join(", ")}. ` +
|
||
`Options: sync standings (populates conference automatically), set region to "Eastern"/"Western" ` +
|
||
`via Admin → Simulator Inputs, or set externalId to "Eastern"/"Western" on the participant.`
|
||
);
|
||
}
|
||
|
||
const allIds = participants.map((p) => p.id);
|
||
|
||
// ── Mode detection ─────────────────────────────────────────────────────────
|
||
|
||
// Mode 1: Known-seed — all 18 playoff seeds (1-9 East, 1-9 West) are explicitly set
|
||
const eastSeeds: MlsConferenceSeed[] = [];
|
||
const westSeeds: MlsConferenceSeed[] = [];
|
||
|
||
for (const p of participants) {
|
||
const seed = seedMap.get(p.id);
|
||
const elo = eloMap.get(p.id);
|
||
const conf = conferenceMap.get(p.id);
|
||
if (seed === undefined || elo === undefined || conf === undefined) continue;
|
||
if (seed < 1 || seed > MLS_PLAYOFF_TEAMS_PER_CONF) continue;
|
||
if (conf === "Eastern") eastSeeds.push({ participantId: p.id, elo, conference: conf, seed });
|
||
else westSeeds.push({ participantId: p.id, elo, conference: conf, seed });
|
||
}
|
||
|
||
const eastSeedSet = new Set(eastSeeds.map((s) => s.seed));
|
||
const westSeedSet = new Set(westSeeds.map((s) => s.seed));
|
||
const isKnownSeed =
|
||
eastSeeds.length === MLS_PLAYOFF_TEAMS_PER_CONF &&
|
||
westSeeds.length === MLS_PLAYOFF_TEAMS_PER_CONF &&
|
||
eastSeedSet.size === MLS_PLAYOFF_TEAMS_PER_CONF &&
|
||
westSeedSet.size === MLS_PLAYOFF_TEAMS_PER_CONF;
|
||
|
||
if (isKnownSeed) {
|
||
return this.simulateKnownSeeds(allIds, eastSeeds, westSeeds, numSimulations, matchOptions);
|
||
}
|
||
|
||
// Mode 2: Regular-season projection (default, including preseason)
|
||
const teamsWithElo = participants.flatMap((p): MlsTeamEntry[] => {
|
||
const elo = eloMap.get(p.id);
|
||
const conf = conferenceMap.get(p.id);
|
||
if (elo === undefined || conf === undefined) {
|
||
logger.warn(
|
||
`MLSSimulator: no Elo rating for participant "${p.name}" (${p.id}). ` +
|
||
`They will be excluded from simulation. Enter sourceElo or projectedTablePoints via Admin → Elo Ratings.`
|
||
);
|
||
return [];
|
||
}
|
||
const standing = standingsMap.get(p.id);
|
||
const wins = standing?.wins ?? 0;
|
||
const draws = standing?.ties ?? 0;
|
||
const gamesPlayed = standing?.gamesPlayed ?? wins + draws + (standing?.losses ?? 0);
|
||
return [{
|
||
participantId: p.id,
|
||
elo,
|
||
conference: conf,
|
||
currentPoints: standing?.tablePoints ?? wins * 3 + draws,
|
||
currentGoalsFor: standing?.goalsFor ?? 0,
|
||
currentGoalDifference: standing?.goalDifference ?? 0,
|
||
remainingGames: Math.max(0, seasonGames - gamesPlayed),
|
||
}];
|
||
});
|
||
|
||
if (teamsWithElo.length === 0) {
|
||
throw new Error(`No participants with Elo ratings found for season ${sportsSeasonId}.`);
|
||
}
|
||
|
||
return this.simulateRegularSeason(allIds, teamsWithElo, numSimulations, matchOptions, averageOpponentElo);
|
||
}
|
||
|
||
// ── Mode 1: Known-Seed ──────────────────────────────────────────────────────
|
||
|
||
private simulateKnownSeeds(
|
||
allIds: string[],
|
||
east: MlsConferenceSeed[],
|
||
west: MlsConferenceSeed[],
|
||
numSimulations: number,
|
||
matchOptions: EloSoccerMatchOptions
|
||
): SimulationResult[] {
|
||
const counts = this.zeroCounts(allIds);
|
||
for (let s = 0; s < numSimulations; s++) {
|
||
const result = simulateMlsPlayoffs(east, west, matchOptions);
|
||
this.recordResult(counts, result);
|
||
}
|
||
return this.buildResults(allIds, counts, numSimulations);
|
||
}
|
||
|
||
// ── Mode 2: Regular-Season Projection ──────────────────────────────────────
|
||
|
||
private simulateRegularSeason(
|
||
allIds: string[],
|
||
teams: MlsTeamEntry[],
|
||
numSimulations: number,
|
||
matchOptions: EloSoccerMatchOptions,
|
||
averageOpponentElo: number
|
||
): SimulationResult[] {
|
||
const counts = this.zeroCounts(allIds);
|
||
for (let s = 0; s < numSimulations; s++) {
|
||
const { east, west } = simulateMlsRegularSeason(teams, matchOptions, averageOpponentElo);
|
||
if (east.length < MLS_PLAYOFF_TEAMS_PER_CONF || west.length < MLS_PLAYOFF_TEAMS_PER_CONF) {
|
||
// Not enough teams in a conference — skip this iteration
|
||
continue;
|
||
}
|
||
const result = simulateMlsPlayoffs(east, west, matchOptions);
|
||
this.recordResult(counts, result);
|
||
}
|
||
return this.buildResults(allIds, counts, numSimulations);
|
||
}
|
||
|
||
// ── Helpers ─────────────────────────────────────────────────────────────────
|
||
|
||
private zeroCounts(allIds: string[]) {
|
||
return {
|
||
champion: new Map(allIds.map((id) => [id, 0])),
|
||
finalist: new Map(allIds.map((id) => [id, 0])),
|
||
confFinalsLoser: new Map(allIds.map((id) => [id, 0])),
|
||
confSemiLoser: new Map(allIds.map((id) => [id, 0])),
|
||
};
|
||
}
|
||
|
||
private recordResult(
|
||
counts: ReturnType<MLSSimulator["zeroCounts"]>,
|
||
result: MlsPlayoffResult
|
||
) {
|
||
counts.champion.set(result.champion, (counts.champion.get(result.champion) ?? 0) + 1);
|
||
counts.finalist.set(result.finalist, (counts.finalist.get(result.finalist) ?? 0) + 1);
|
||
for (const id of result.confFinalsLosers) {
|
||
counts.confFinalsLoser.set(id, (counts.confFinalsLoser.get(id) ?? 0) + 1);
|
||
}
|
||
for (const id of result.confSemiLosers) {
|
||
counts.confSemiLoser.set(id, (counts.confSemiLoser.get(id) ?? 0) + 1);
|
||
}
|
||
}
|
||
|
||
private buildResults(
|
||
allIds: string[],
|
||
counts: ReturnType<MLSSimulator["zeroCounts"]>,
|
||
numSimulations: number
|
||
): SimulationResult[] {
|
||
const N = numSimulations;
|
||
const results: SimulationResult[] = allIds.map((id) => ({
|
||
participantId: id,
|
||
probabilities: {
|
||
probFirst: (counts.champion.get(id) ?? 0) / N,
|
||
probSecond: (counts.finalist.get(id) ?? 0) / N,
|
||
// 2 conf finals losers per sim — split evenly across 3rd/4th
|
||
probThird: (counts.confFinalsLoser.get(id) ?? 0) / N / 2,
|
||
probFourth: (counts.confFinalsLoser.get(id) ?? 0) / N / 2,
|
||
// 4 conf semi losers per sim — split evenly across 5th–8th
|
||
probFifth: (counts.confSemiLoser.get(id) ?? 0) / N / 4,
|
||
probSixth: (counts.confSemiLoser.get(id) ?? 0) / N / 4,
|
||
probSeventh: (counts.confSemiLoser.get(id) ?? 0) / N / 4,
|
||
probEighth: (counts.confSemiLoser.get(id) ?? 0) / N / 4,
|
||
},
|
||
source: "mls_bracket_monte_carlo",
|
||
}));
|
||
normalizeSimulationResultColumns(results);
|
||
return results;
|
||
}
|
||
}
|