f16b9de334
- Write placement in assignCs2EliminationQP so processQualifyingEvent
preserves progressive QP at event finalization instead of zeroing it.
Stage 1 exits get placement=25, Stage 2 exits get placement=17, Stage 3
exits get their W-L group start slot (9-16) so tie-split logic re-derives
the same averaged QP at finalization.
- Add clearCs2EliminationsAtStage model function and stage_displayed_{N}
hidden fields so unchecking a team in the admin form actually clears
their DB record (replacement semantics instead of additive).
- Add stageEliminated >= stageEntry validation in markCs2StageEliminations.
- Wrap mark-eliminations action handler in try/catch to surface errors.
- Switch serial recalculateParticipantQP loop to Promise.all.
- Remove duplicate calcStage3ExitQP from cs-major-simulator; import
computeStage3ExitQP from cs2-major-stage and re-export under the
original name so simulator tests remain unchanged.
https://claude.ai/code/session_013u6vbGHdppe88wQ95BLANw
728 lines
29 KiB
TypeScript
728 lines
29 KiB
TypeScript
/**
|
||
* CS2 Major Qualifying Points Simulator
|
||
*
|
||
* Monte Carlo simulation of the 2 CS2 Majors per year. Qualifying points (QP)
|
||
* accumulate across both majors; final QP totals determine fantasy placements (1st–8th).
|
||
*
|
||
* CS2 Major format (32 teams, 3 Swiss stages + playoffs):
|
||
* Stage 1 (Opening Stage): 16 teams, Swiss, all Bo1
|
||
* Stage 2 (Challengers Stage): 16 teams (8 Challengers + 8 from Stage 1), Swiss,
|
||
* Bo1 normally, Bo3 for decisive matches (either team
|
||
* can advance or be eliminated)
|
||
* Stage 3 (Legends Stage): 16 teams (8 Legends + 8 from Stage 2), Swiss, all Bo3
|
||
* Champions Stage: 8 teams, single-elimination (QF Bo3, SF Bo3, GF Bo5)
|
||
*
|
||
* Field selection (per iteration):
|
||
* - Top 12 participants by world ranking are always in the simulated field.
|
||
* - Remaining spots (up to 32 total) are sampled from the rest of the pool,
|
||
* weighted by 1/rank (lower rank = higher inclusion probability).
|
||
* - If cs2MajorStageResults records exist for an event, those explicit
|
||
* stage assignments are used instead of sampling/rank inference.
|
||
*
|
||
* Stage assignment within the 32-team field:
|
||
* - With explicit stage data: use stageEntry from cs2MajorStageResults
|
||
* - Without: top 8 by world ranking → Stage 3, next 8 → Stage 2, bottom 16 → Stage 1
|
||
*
|
||
* Champions Stage seeding:
|
||
* - Seeds are assigned by Stage 3 performance: fewer losses = higher seed.
|
||
* - World rank is used as tiebreaker within the same loss count.
|
||
* - When stage data is used (stage3Complete), losses are unknown and rank is used directly.
|
||
*
|
||
* QP for Stage 3 exits (placements 9–16) is sub-ranked by W-L record:
|
||
* - 2-3 teams → higher placements within 9–16
|
||
* - 1-3 teams → middle placements
|
||
* - 0-3 teams → lowest placements within 9–16
|
||
* QP is tie-split (averaged) within each W-L group.
|
||
*
|
||
* QP for Champions Stage:
|
||
* - QF losers (4 teams, placements 5–8): tie-split averaged across slots 5–8.
|
||
* - SF losers (2 teams, placements 3–4): tie-split averaged across slots 3–4.
|
||
* - Finalist and Champion earn their exact placement QP.
|
||
*
|
||
* Stages 1 and 2 exits (placements 17–32) earn 0 QP.
|
||
*/
|
||
|
||
import { database } from "~/database/context";
|
||
import { eq, and, inArray } from "drizzle-orm";
|
||
import * as schema from "~/database/schema";
|
||
import { getQPConfig } from "~/models/qualifying-points";
|
||
import { getCs2StageResultsMapForEvent, computeStage3ExitQP as calcStage3ExitQP } from "~/models/cs2-major-stage";
|
||
export { calcStage3ExitQP };
|
||
import { getExcludedByEventMap } from "~/models/event-result";
|
||
import type { Simulator, SimulationResult } from "./types";
|
||
|
||
// ─── Simulation parameters ────────────────────────────────────────────────────
|
||
|
||
const NUM_SIMULATIONS = 10_000;
|
||
|
||
/** Total field size per CS2 Major. */
|
||
const FIELD_SIZE = 32;
|
||
|
||
/** Number of teams guaranteed in the simulated field (always included). */
|
||
const GUARANTEED_COUNT = 12;
|
||
|
||
/**
|
||
* Elo divisor for per-game win probability.
|
||
* Standard chess Elo uses 400. CS2 maps well to single-game level.
|
||
* 200-pt gap ≈ 76% win probability; 400-pt gap ≈ 91%.
|
||
*/
|
||
const ELO_DIVISOR = 400;
|
||
|
||
/** Fallback Elo for teams with no stored rating. */
|
||
const FALLBACK_ELO = 1500;
|
||
|
||
// ─── Math helpers ─────────────────────────────────────────────────────────────
|
||
|
||
/**
|
||
* Per-game win probability for team 1 vs team 2.
|
||
* Exported for unit testing.
|
||
*/
|
||
export function gameWinProb(elo1: number, elo2: number): number {
|
||
return 1 / (1 + Math.pow(10, (elo2 - elo1) / ELO_DIVISOR));
|
||
}
|
||
|
||
/**
|
||
* Match win probability using the Bernoulli series model.
|
||
* For a best-of-(2S-1) match (first to S wins):
|
||
* P(win) = Σ_{k=0}^{S-1} C(S-1+k, k) × p^S × (1-p)^k
|
||
* Exported for unit testing.
|
||
*/
|
||
export function seriesWinProb(p: number, winsNeeded: number): number {
|
||
let prob = 0;
|
||
for (let k = 0; k < winsNeeded; k++) {
|
||
prob += binomialCoeff(winsNeeded - 1 + k, k) * Math.pow(p, winsNeeded) * Math.pow(1 - p, k);
|
||
}
|
||
return prob;
|
||
}
|
||
|
||
/** Binomial coefficient C(n, k). */
|
||
function binomialCoeff(n: number, k: number): number {
|
||
if (k === 0) return 1;
|
||
if (k > n - k) k = n - k;
|
||
let result = 1;
|
||
for (let i = 0; i < k; i++) {
|
||
result = (result * (n - i)) / (i + 1);
|
||
}
|
||
return result;
|
||
}
|
||
|
||
/** Fisher-Yates in-place shuffle. Returns the array for chaining. */
|
||
function shuffle<T>(arr: T[]): T[] {
|
||
for (let i = arr.length - 1; i > 0; i--) {
|
||
const j = Math.floor(Math.random() * (i + 1));
|
||
[arr[i], arr[j]] = [arr[j], arr[i]];
|
||
}
|
||
return arr;
|
||
}
|
||
|
||
// ─── Field selection ──────────────────────────────────────────────────────────
|
||
|
||
interface TeamWithElo {
|
||
id: string;
|
||
elo: number;
|
||
rank: number; // HLTV world ranking (lower = better)
|
||
}
|
||
|
||
/**
|
||
* A team that has advanced through a Swiss stage, with their loss count at advancement.
|
||
* Used for Champions Stage seeding: fewer losses = higher seed (better stage performance).
|
||
*/
|
||
export interface AdvancedTeam extends TeamWithElo {
|
||
/** Number of losses accumulated when advancing (0 = 3-0, 1 = 3-1, 2 = 3-2). */
|
||
losses: number;
|
||
}
|
||
|
||
/**
|
||
* Sample a 32-team field from the pool.
|
||
* - Top GUARANTEED_COUNT (12) by rank are always included.
|
||
* - Remaining spots are weighted-randomly sampled from the rest, weight = 1/rank.
|
||
* - If pool.length <= FIELD_SIZE, returns all teams.
|
||
* Exported for unit testing.
|
||
*/
|
||
export function sampleField(
|
||
pool: TeamWithElo[],
|
||
fieldSize: number = FIELD_SIZE
|
||
): TeamWithElo[] {
|
||
const sorted = [...pool].toSorted((a, b) => a.rank - b.rank);
|
||
|
||
if (sorted.length <= fieldSize) return sorted;
|
||
|
||
const guaranteed = sorted.slice(0, GUARANTEED_COUNT);
|
||
const rest = sorted.slice(GUARANTEED_COUNT);
|
||
const needed = fieldSize - guaranteed.length;
|
||
|
||
if (needed <= 0) return guaranteed;
|
||
if (rest.length <= needed) return [...guaranteed, ...rest];
|
||
|
||
// Weighted sample without replacement, weight = 1/rank
|
||
const weights = rest.map((t) => 1 / t.rank);
|
||
const sampled = weightedSampleWithoutReplacement(rest, weights, needed);
|
||
|
||
return [...guaranteed, ...sampled];
|
||
}
|
||
|
||
/** Weighted sampling without replacement using the Gumbel-max trick. */
|
||
function weightedSampleWithoutReplacement<T>(
|
||
items: T[],
|
||
weights: number[],
|
||
count: number
|
||
): T[] {
|
||
const keys = weights.map((w) => -Math.log(Math.random()) / w);
|
||
const indexed = items.map((item, i) => ({ item, key: keys[i] }));
|
||
const sortedIndexed = indexed.toSorted((a, b) => a.key - b.key);
|
||
return sortedIndexed.slice(0, count).map((x) => x.item);
|
||
}
|
||
|
||
// ─── Swiss stage simulation ───────────────────────────────────────────────────
|
||
|
||
interface SwissResult {
|
||
/** Teams that advanced (3 wins), with their loss count at advancement. */
|
||
advanced: AdvancedTeam[];
|
||
/** Teams eliminated, with their win count at time of elimination. */
|
||
eliminated: Array<{ id: string; elo: number; rank: number; wins: number }>;
|
||
}
|
||
|
||
/**
|
||
* Simulate one Swiss-format stage.
|
||
* Teams are grouped by their (wins, losses) record each round. Teams are paired
|
||
* randomly within each record group. First to 3 wins advances; first to 3 losses
|
||
* is eliminated.
|
||
*
|
||
* @param teams - Teams entering this stage (must be an even count).
|
||
* @param bo3 - If true, all matches are Bo3; otherwise Bo1.
|
||
* @param decisiveMatchesBo3 - If true, matches where either team can advance or
|
||
* be eliminated (≥2 wins or ≥2 losses) are promoted to
|
||
* Bo3 regardless of the `bo3` flag. Used for Stage 2.
|
||
* @returns advanced (with losses) and eliminated (with wins) arrays.
|
||
*
|
||
* Exported for unit testing.
|
||
*/
|
||
export function simulateSwiss(
|
||
teams: TeamWithElo[],
|
||
bo3: boolean,
|
||
decisiveMatchesBo3 = false
|
||
): SwissResult {
|
||
if (teams.length === 0) return { advanced: [], eliminated: [] };
|
||
if (teams.length % 2 !== 0) {
|
||
throw new Error(`simulateSwiss requires an even number of teams, got ${teams.length}`);
|
||
}
|
||
|
||
const wins = new Map<string, number>(teams.map((t) => [t.id, 0]));
|
||
const losses = new Map<string, number>(teams.map((t) => [t.id, 0]));
|
||
const eloMap = new Map<string, number>(teams.map((t) => [t.id, t.elo]));
|
||
|
||
const advanced: AdvancedTeam[] = [];
|
||
const eliminated: SwissResult["eliminated"] = [];
|
||
const advancedIds = new Set<string>();
|
||
const eliminatedIds = new Set<string>();
|
||
|
||
const teamById = new Map<string, TeamWithElo>(teams.map((t) => [t.id, t]));
|
||
|
||
// Run rounds until every team has reached 3W or 3L
|
||
while (advancedIds.size + eliminatedIds.size < teams.length) {
|
||
// Collect active teams grouped by (W, L) record
|
||
const active = teams.filter((t) => !advancedIds.has(t.id) && !eliminatedIds.has(t.id));
|
||
const groups = groupByRecord(active, wins, losses);
|
||
|
||
// If a group has an odd number, move one team to the nearest adjacent group
|
||
// (simplified: skip teams that can't be paired — they sit out this round)
|
||
const pairs = pairGroups(groups);
|
||
|
||
// Safety: if no pairs can be formed (shouldn't happen with even team counts
|
||
// but guards against an infinite loop if an odd active count somehow occurs)
|
||
if (pairs.length === 0) break;
|
||
|
||
for (const [t1, t2] of pairs) {
|
||
const e1 = eloMap.get(t1.id) ?? FALLBACK_ELO;
|
||
const e2 = eloMap.get(t2.id) ?? FALLBACK_ELO;
|
||
|
||
// A match is "decisive" if either team can advance (2W) or be eliminated (2L)
|
||
const w1 = wins.get(t1.id) ?? 0;
|
||
const l1 = losses.get(t1.id) ?? 0;
|
||
const w2 = wins.get(t2.id) ?? 0;
|
||
const l2 = losses.get(t2.id) ?? 0;
|
||
const isDecisive = decisiveMatchesBo3 && (w1 >= 2 || l1 >= 2 || w2 >= 2 || l2 >= 2);
|
||
|
||
const p = (bo3 || isDecisive)
|
||
? seriesWinProb(gameWinProb(e1, e2), 2) // Bo3: first to 2
|
||
: gameWinProb(e1, e2); // Bo1: single game
|
||
|
||
const t1Wins = Math.random() < p;
|
||
const winnerId = t1Wins ? t1.id : t2.id;
|
||
const loserId = t1Wins ? t2.id : t1.id;
|
||
|
||
wins.set(winnerId, (wins.get(winnerId) ?? 0) + 1);
|
||
losses.set(loserId, (losses.get(loserId) ?? 0) + 1);
|
||
|
||
if ((wins.get(winnerId) ?? 0) >= 3) {
|
||
advancedIds.add(winnerId);
|
||
const t = teamById.get(winnerId);
|
||
if (t) advanced.push({ id: t.id, elo: t.elo, rank: t.rank, losses: losses.get(winnerId) ?? 0 });
|
||
}
|
||
if ((losses.get(loserId) ?? 0) >= 3) {
|
||
eliminatedIds.add(loserId);
|
||
const t = teamById.get(loserId);
|
||
if (t) eliminated.push({ id: t.id, elo: t.elo, rank: t.rank, wins: wins.get(loserId) ?? 0 });
|
||
}
|
||
}
|
||
}
|
||
|
||
return { advanced, eliminated };
|
||
}
|
||
|
||
/** Group active teams by (wins, losses) record key. */
|
||
function groupByRecord(
|
||
active: TeamWithElo[],
|
||
wins: Map<string, number>,
|
||
losses: Map<string, number>
|
||
): Map<string, TeamWithElo[]> {
|
||
const groups = new Map<string, TeamWithElo[]>();
|
||
for (const t of active) {
|
||
const key = `${wins.get(t.id) ?? 0}-${losses.get(t.id) ?? 0}`;
|
||
if (!groups.has(key)) groups.set(key, []);
|
||
groups.get(key)?.push(t);
|
||
}
|
||
return groups;
|
||
}
|
||
|
||
/**
|
||
* Pair teams within each record group. Teams in groups with an odd count
|
||
* are handled by merging the leftover into an adjacent group (simpler: skip
|
||
* them for this round — they sit out and play next round).
|
||
*/
|
||
function pairGroups(groups: Map<string, TeamWithElo[]>): Array<[TeamWithElo, TeamWithElo]> {
|
||
const pairs: Array<[TeamWithElo, TeamWithElo]> = [];
|
||
const leftover: TeamWithElo[] = [];
|
||
|
||
for (const group of groups.values()) {
|
||
const shuffled = shuffle([...group]);
|
||
for (let i = 0; i + 1 < shuffled.length; i += 2) {
|
||
pairs.push([shuffled[i], shuffled[i + 1]]);
|
||
}
|
||
if (shuffled.length % 2 !== 0) {
|
||
leftover.push(shuffled[shuffled.length - 1]);
|
||
}
|
||
}
|
||
|
||
// Pair leftover teams with each other (different records, cross-group match)
|
||
for (let i = 0; i + 1 < leftover.length; i += 2) {
|
||
pairs.push([leftover[i], leftover[i + 1]]);
|
||
}
|
||
|
||
return pairs;
|
||
}
|
||
|
||
// ─── Champions Stage (8-team single-elimination bracket) ─────────────────────
|
||
|
||
interface ChampionsResult {
|
||
/**
|
||
* participantId → placement group:
|
||
* 1 = champion, 2 = finalist
|
||
* 3 = both SF losers (tie-split QP across slots 3–4 in the caller)
|
||
* 5 = all 4 QF losers (tie-split QP across slots 5–8 in the caller)
|
||
*/
|
||
placements: Map<string, number>;
|
||
}
|
||
|
||
/**
|
||
* Simulate the Champions Stage 8-team single-elimination bracket.
|
||
* Seeds are assigned by stage performance (losses ascending), with world rank
|
||
* as tiebreaker. Rounds: QF (Bo3), SF (Bo3), GF (Bo5).
|
||
*
|
||
* QF losers are all assigned placement 5 (tie-split across slots 5–8 by caller).
|
||
* SF losers are both assigned placement 3 (tie-split across slots 3–4 by caller).
|
||
* Exported for unit testing.
|
||
*/
|
||
export function simulateChampionsStage(teams: AdvancedTeam[]): ChampionsResult {
|
||
if (teams.length !== 8) {
|
||
throw new Error(`simulateChampionsStage expects exactly 8 teams, got ${teams.length}`);
|
||
}
|
||
|
||
// Seed by stage performance: fewer losses = higher seed; rank as tiebreaker
|
||
const seeded = [...teams].toSorted((a, b) =>
|
||
a.losses !== b.losses ? a.losses - b.losses : a.rank - b.rank
|
||
);
|
||
|
||
// Standard 8-team seeding: 1v8, 4v5, 3v6, 2v7
|
||
const bracket: [AdvancedTeam, AdvancedTeam][] = [
|
||
[seeded[0], seeded[7]],
|
||
[seeded[3], seeded[4]],
|
||
[seeded[2], seeded[5]],
|
||
[seeded[1], seeded[6]],
|
||
];
|
||
|
||
const placements = new Map<string, number>();
|
||
|
||
const simMatch = (t1: AdvancedTeam, t2: AdvancedTeam, winsNeeded: number): AdvancedTeam => {
|
||
const p = seriesWinProb(gameWinProb(t1.elo, t2.elo), winsNeeded);
|
||
return Math.random() < p ? t1 : t2;
|
||
};
|
||
|
||
// Quarterfinals (Bo3 = first to 2)
|
||
const sfTeams: AdvancedTeam[] = [];
|
||
for (const [t1, t2] of bracket) {
|
||
const winner = simMatch(t1, t2, 2);
|
||
const loser = winner.id === t1.id ? t2 : t1;
|
||
sfTeams.push(winner);
|
||
placements.set(loser.id, 5); // QF losers: all get placement 5 (tie-split 5–8 by caller)
|
||
}
|
||
|
||
// Semifinals (Bo3 = first to 2)
|
||
const finalTeams: AdvancedTeam[] = [];
|
||
const sfLosers: AdvancedTeam[] = [];
|
||
for (let i = 0; i < sfTeams.length; i += 2) {
|
||
const winner = simMatch(sfTeams[i], sfTeams[i + 1], 2);
|
||
const loser = winner.id === sfTeams[i].id ? sfTeams[i + 1] : sfTeams[i];
|
||
finalTeams.push(winner);
|
||
sfLosers.push(loser);
|
||
}
|
||
sfLosers.forEach((t) => placements.set(t.id, 3)); // SF losers: both get placement 3 (tie-split 3–4)
|
||
|
||
// Grand Final (Bo5 = first to 3)
|
||
const champion = simMatch(finalTeams[0], finalTeams[1], 3);
|
||
const finalist = champion.id === finalTeams[0].id ? finalTeams[1] : finalTeams[0];
|
||
placements.set(champion.id, 1);
|
||
placements.set(finalist.id, 2);
|
||
|
||
return { placements };
|
||
}
|
||
|
||
// ─── QP helpers ───────────────────────────────────────────────────────────────
|
||
|
||
// ─── Simulator ────────────────────────────────────────────────────────────────
|
||
|
||
export class CSMajorSimulator implements Simulator {
|
||
async simulate(sportsSeasonId: string): Promise<SimulationResult[]> {
|
||
const db = database();
|
||
|
||
// 1. Load all participants for this sports season.
|
||
const allParticipants = await db
|
||
.select({ id: schema.seasonParticipants.id })
|
||
.from(schema.seasonParticipants)
|
||
.where(eq(schema.seasonParticipants.sportsSeasonId, sportsSeasonId));
|
||
|
||
const participantIds = allParticipants.map((p) => p.id);
|
||
|
||
if (participantIds.length === 0) {
|
||
throw new Error(`No participants found for sports season ${sportsSeasonId}.`);
|
||
}
|
||
|
||
// 2. Load Elo ratings and world rankings from participantExpectedValues.
|
||
const evRows = await db
|
||
.select({
|
||
participantId: schema.seasonParticipantExpectedValues.participantId,
|
||
sourceElo: schema.seasonParticipantExpectedValues.sourceElo,
|
||
worldRanking: schema.seasonParticipantExpectedValues.worldRanking,
|
||
})
|
||
.from(schema.seasonParticipantExpectedValues)
|
||
.where(eq(schema.seasonParticipantExpectedValues.sportsSeasonId, sportsSeasonId));
|
||
|
||
const eloMap = new Map<string, { elo: number; rank: number }>();
|
||
for (const row of evRows) {
|
||
if (row.sourceElo !== null) {
|
||
eloMap.set(row.participantId, {
|
||
elo: row.sourceElo,
|
||
rank: row.worldRanking ?? 9999,
|
||
});
|
||
}
|
||
}
|
||
|
||
// Build pool: all participants, using FALLBACK_ELO for those without ratings, sorted by rank
|
||
const pool: TeamWithElo[] = participantIds
|
||
.map((id) => {
|
||
const e = eloMap.get(id);
|
||
return { id, elo: e?.elo ?? FALLBACK_ELO, rank: e?.rank ?? 9999 };
|
||
})
|
||
.toSorted((a, b) => a.rank - b.rank);
|
||
|
||
const hasAnyElo = participantIds.some((id) => eloMap.has(id));
|
||
if (!hasAnyElo) {
|
||
throw new Error(
|
||
`No participants with Elo ratings found for sports season ${sportsSeasonId}. ` +
|
||
`Enter Elo ratings via the CS Elo admin page before simulating.`
|
||
);
|
||
}
|
||
|
||
// 3. Load QP config (placements 1–16 earn QP; 17+ earn 0).
|
||
const qpConfigArray = await getQPConfig(sportsSeasonId);
|
||
const qpConfig = new Map<number, number>(
|
||
qpConfigArray.map((c) => [c.placement, parseFloat(c.points)])
|
||
);
|
||
|
||
// 4. Load all CS major scoring events for this sports season.
|
||
const events = await db.query.scoringEvents.findMany({
|
||
where: and(
|
||
eq(schema.scoringEvents.sportsSeasonId, sportsSeasonId),
|
||
eq(schema.scoringEvents.eventType, "major_tournament")
|
||
),
|
||
orderBy: (e, { asc }) => [asc(e.eventDate)],
|
||
});
|
||
|
||
if (events.length === 0) {
|
||
throw new Error(
|
||
`No major_tournament scoring events found for sports season ${sportsSeasonId}. ` +
|
||
`Create the CS Major scoring events first.`
|
||
);
|
||
}
|
||
|
||
// 5. For completed events, read actual QP from eventResults.
|
||
const completedEventIds = events.filter((e) => e.isComplete).map((e) => e.id);
|
||
const actualQPMap = new Map<string, number>(participantIds.map((id) => [id, 0]));
|
||
|
||
if (completedEventIds.length > 0) {
|
||
const actualResults = await db
|
||
.select({
|
||
participantId: schema.eventResults.seasonParticipantId,
|
||
qualifyingPointsAwarded: schema.eventResults.qualifyingPointsAwarded,
|
||
})
|
||
.from(schema.eventResults)
|
||
.where(inArray(schema.eventResults.scoringEventId, completedEventIds));
|
||
|
||
for (const r of actualResults) {
|
||
if (r.qualifyingPointsAwarded !== null) {
|
||
const prev = actualQPMap.get(r.participantId) ?? 0;
|
||
actualQPMap.set(r.participantId, prev + parseFloat(r.qualifyingPointsAwarded));
|
||
}
|
||
}
|
||
}
|
||
|
||
// 6. Load stage results for all events in parallel.
|
||
const stageResultEntries = await Promise.all(
|
||
events.map(async (event) => {
|
||
const results = await getCs2StageResultsMapForEvent(event.id);
|
||
return [event.id, results] as const;
|
||
})
|
||
);
|
||
const eventStageResults = new Map(
|
||
stageResultEntries.filter(([, r]) => r.size > 0)
|
||
);
|
||
|
||
const incompleteEvents = events.filter((e) => !e.isComplete);
|
||
|
||
// Load not-participating exclusions for each incomplete event.
|
||
const excludedByEvent = await getExcludedByEventMap(incompleteEvents.map((e) => e.id));
|
||
|
||
// 7. Short-circuit: if all events are complete, return deterministic probabilities
|
||
// based on actual QP totals — no simulation needed.
|
||
if (incompleteEvents.length === 0) {
|
||
const ranked = [...actualQPMap.entries()].toSorted((a, b) => b[1] - a[1]);
|
||
return participantIds.map((participantId) => {
|
||
const rank = ranked.findIndex(([id]) => id === participantId) + 1; // 1-indexed
|
||
return {
|
||
participantId,
|
||
probabilities: {
|
||
probFirst: rank === 1 ? 1.0 : 0.0,
|
||
probSecond: rank === 2 ? 1.0 : 0.0,
|
||
probThird: rank === 3 ? 1.0 : 0.0,
|
||
probFourth: rank === 4 ? 1.0 : 0.0,
|
||
probFifth: rank === 5 ? 1.0 : 0.0,
|
||
probSixth: rank === 6 ? 1.0 : 0.0,
|
||
probSeventh: rank === 7 ? 1.0 : 0.0,
|
||
probEighth: rank === 8 ? 1.0 : 0.0,
|
||
},
|
||
source: "cs2_major_qualifying_points_monte_carlo",
|
||
};
|
||
});
|
||
}
|
||
|
||
// 8. Monte Carlo loop.
|
||
const counts: number[][] = Array.from({ length: participantIds.length }, () => Array(8).fill(0));
|
||
const idToIndex = new Map<string, number>(participantIds.map((id, i) => [id, i]));
|
||
|
||
for (let sim = 0; sim < NUM_SIMULATIONS; sim++) {
|
||
const simQP = new Map<string, number>(actualQPMap);
|
||
|
||
for (const event of incompleteEvents) {
|
||
const excluded = excludedByEvent.get(event.id) ?? new Set<string>();
|
||
const eventPool = excluded.size > 0 ? pool.filter((t) => !excluded.has(t.id)) : pool;
|
||
const stageResultsForEvent = eventStageResults.get(event.id);
|
||
const eventQP = simulateOneMajor(eventPool, stageResultsForEvent, qpConfig);
|
||
for (const [pid, qp] of eventQP) {
|
||
simQP.set(pid, (simQP.get(pid) ?? 0) + qp);
|
||
}
|
||
}
|
||
|
||
// Rank all participants by total QP descending.
|
||
const ranked = [...simQP.entries()].toSorted((a, b) => b[1] - a[1]);
|
||
for (let rank = 0; rank < Math.min(8, ranked.length); rank++) {
|
||
const [pid] = ranked[rank];
|
||
const idx = idToIndex.get(pid);
|
||
if (idx !== undefined) counts[idx][rank]++;
|
||
}
|
||
}
|
||
|
||
// 9. Convert counts to probabilities.
|
||
return participantIds.map((participantId, i) => ({
|
||
participantId,
|
||
probabilities: {
|
||
probFirst: counts[i][0] / NUM_SIMULATIONS,
|
||
probSecond: counts[i][1] / NUM_SIMULATIONS,
|
||
probThird: counts[i][2] / NUM_SIMULATIONS,
|
||
probFourth: counts[i][3] / NUM_SIMULATIONS,
|
||
probFifth: counts[i][4] / NUM_SIMULATIONS,
|
||
probSixth: counts[i][5] / NUM_SIMULATIONS,
|
||
probSeventh: counts[i][6] / NUM_SIMULATIONS,
|
||
probEighth: counts[i][7] / NUM_SIMULATIONS,
|
||
},
|
||
source: "cs2_major_qualifying_points_monte_carlo",
|
||
}));
|
||
}
|
||
}
|
||
|
||
// ─── Single major simulation ───────────────────────────────────────────────────
|
||
|
||
/** Average QP across a range of placement slots (for tie-splitting). */
|
||
function avgSlotQP(slots: number[], qpConfig: Map<number, number>): number {
|
||
return slots.reduce((sum, s) => sum + (qpConfig.get(s) ?? 0), 0) / slots.length;
|
||
}
|
||
|
||
/**
|
||
* Simulate one CS2 Major and return QP earned per participant.
|
||
*
|
||
* If stage results are provided, uses them to determine field composition
|
||
* and to lock in results for any completed stages, only simulating the
|
||
* remaining stages. A stage is considered complete when at least 8
|
||
* eliminations for that stage have been recorded.
|
||
*
|
||
* Returns a Map from participantId → QP earned in this major.
|
||
* Exported for unit testing.
|
||
*/
|
||
export function simulateOneMajor(
|
||
pool: TeamWithElo[],
|
||
stageResults: Map<string, { stageEntry: number; stageEliminated: number | null; stageEliminatedWins: number | null }> | undefined,
|
||
qpConfig: Map<number, number>
|
||
): Map<string, number> {
|
||
const qpMap = new Map<string, number>();
|
||
const poolById = new Map<string, TeamWithElo>(pool.map((t) => [t.id, t]));
|
||
|
||
// ── Determine field and stage assignments ─────────────────────────────────
|
||
// stage2Direct / stage3Direct are AdvancedTeam[] (losses = 0: no prior Swiss stage)
|
||
let stage1Teams: TeamWithElo[];
|
||
let stage2Direct: AdvancedTeam[];
|
||
let stage3Direct: AdvancedTeam[];
|
||
|
||
if (stageResults && stageResults.size > 0) {
|
||
const s1: TeamWithElo[] = [];
|
||
const s2: AdvancedTeam[] = [];
|
||
const s3: AdvancedTeam[] = [];
|
||
for (const [participantId, result] of stageResults) {
|
||
const team = poolById.get(participantId);
|
||
if (!team) continue;
|
||
if (result.stageEntry === 1) s1.push(team);
|
||
else if (result.stageEntry === 2) s2.push({ ...team, losses: 0 });
|
||
else if (result.stageEntry === 3) s3.push({ ...team, losses: 0 });
|
||
}
|
||
stage1Teams = s1;
|
||
stage2Direct = s2;
|
||
stage3Direct = s3;
|
||
} else {
|
||
const field = sampleField(pool, FIELD_SIZE);
|
||
const sorted = field.toSorted((a, b) => a.rank - b.rank);
|
||
stage3Direct = sorted.slice(0, 8).map((t) => ({ ...t, losses: 0 }));
|
||
stage2Direct = sorted.slice(8, 16).map((t) => ({ ...t, losses: 0 }));
|
||
stage1Teams = sorted.slice(16, 32);
|
||
}
|
||
|
||
// ── Lock in known stage results ───────────────────────────────────────────
|
||
// A stage is "complete" when at least 8 teams have been eliminated at that stage.
|
||
const eliminatedAtStage = (stageNum: number) =>
|
||
stageResults
|
||
? [...stageResults.entries()]
|
||
.filter(([, r]) => r.stageEliminated === stageNum)
|
||
.map(([id, r]) => ({
|
||
id,
|
||
elo: poolById.get(id)?.elo ?? FALLBACK_ELO,
|
||
rank: poolById.get(id)?.rank ?? 9999,
|
||
wins: r.stageEliminatedWins ?? 0,
|
||
}))
|
||
: [];
|
||
|
||
const stage1Elim = eliminatedAtStage(1);
|
||
const stage2Elim = eliminatedAtStage(2);
|
||
const stage3Elim = eliminatedAtStage(3);
|
||
|
||
const stage1Complete = stage1Elim.length >= 8;
|
||
const stage2Complete = stage2Elim.length >= 8;
|
||
const stage3Complete = stage3Elim.length >= 8;
|
||
|
||
// ── Stage 1 (Opening) — all Bo1 ───────────────────────────────────────────
|
||
let stage1Advanced: AdvancedTeam[];
|
||
let stage1EliminatedFinal: Array<{ id: string; elo: number; rank: number; wins: number }>;
|
||
|
||
if (stage1Complete) {
|
||
const stage1EliminatedIds = new Set(stage1Elim.map((t) => t.id));
|
||
// Loss count from stage data is unknown; use 2 as conservative fallback
|
||
stage1Advanced = stage1Teams
|
||
.filter((t) => !stage1EliminatedIds.has(t.id))
|
||
.map((t): AdvancedTeam => ({ ...t, losses: 2 }));
|
||
stage1EliminatedFinal = stage1Elim;
|
||
} else {
|
||
const result = simulateSwiss(stage1Teams, false);
|
||
stage1Advanced = result.advanced;
|
||
stage1EliminatedFinal = result.eliminated;
|
||
}
|
||
|
||
// ── Stage 2 (Challengers) — Bo1, Bo3 for decisive matches ────────────────
|
||
const stage2Teams: AdvancedTeam[] = [...stage2Direct, ...stage1Advanced];
|
||
let stage2Advanced: AdvancedTeam[];
|
||
let stage2EliminatedFinal: Array<{ id: string; elo: number; rank: number; wins: number }>;
|
||
|
||
if (stage2Complete) {
|
||
const stage2EliminatedIds = new Set(stage2Elim.map((t) => t.id));
|
||
stage2Advanced = stage2Teams
|
||
.filter((t) => !stage2EliminatedIds.has(t.id))
|
||
.map((t): AdvancedTeam => ({ ...t, losses: 2 }));
|
||
stage2EliminatedFinal = stage2Elim;
|
||
} else {
|
||
const result = simulateSwiss(stage2Teams, false, true); // decisive matches → Bo3
|
||
stage2Advanced = result.advanced;
|
||
stage2EliminatedFinal = result.eliminated;
|
||
}
|
||
|
||
// ── Stage 3 (Legends) — all Bo3 ──────────────────────────────────────────
|
||
const stage3Teams: AdvancedTeam[] = [...stage3Direct, ...stage2Advanced];
|
||
let champTeams: AdvancedTeam[];
|
||
let stage3EliminatedFinal: Array<{ id: string; elo: number; rank: number; wins: number }>;
|
||
|
||
if (stage3Complete) {
|
||
const stage3EliminatedIds = new Set(stage3Elim.map((t) => t.id));
|
||
// Stage 3 loss counts are not available from stage data; fall back to rank-based seeding
|
||
champTeams = stage3Teams
|
||
.filter((t) => !stage3EliminatedIds.has(t.id))
|
||
.map((t): AdvancedTeam => ({ ...t, losses: 2 }));
|
||
stage3EliminatedFinal = stage3Elim;
|
||
} else {
|
||
const result = simulateSwiss(stage3Teams, true); // all Bo3
|
||
champTeams = result.advanced;
|
||
stage3EliminatedFinal = result.eliminated;
|
||
}
|
||
|
||
// ── Champions Stage ───────────────────────────────────────────────────────
|
||
const champResult = simulateChampionsStage(champTeams);
|
||
|
||
// ── Assign QP — tie-split QF losers (5–8) and SF losers (3–4) ────────────
|
||
// Group placements: placement 5 = QF losers, placement 3 = SF losers
|
||
const byPlacement = new Map<number, string[]>();
|
||
for (const [pid, placement] of champResult.placements) {
|
||
if (!byPlacement.has(placement)) byPlacement.set(placement, []);
|
||
const group = byPlacement.get(placement);
|
||
if (group) group.push(pid);
|
||
}
|
||
for (const [placement, pids] of byPlacement) {
|
||
const slots = Array.from({ length: pids.length }, (_, i) => placement + i);
|
||
const avgQP = avgSlotQP(slots, qpConfig);
|
||
for (const pid of pids) {
|
||
qpMap.set(pid, avgQP);
|
||
}
|
||
}
|
||
|
||
const stage3ExitQP = calcStage3ExitQP(stage3EliminatedFinal, qpConfig);
|
||
for (const [pid, qp] of stage3ExitQP) {
|
||
qpMap.set(pid, qp);
|
||
}
|
||
|
||
for (const t of stage1EliminatedFinal) qpMap.set(t.id, 0);
|
||
for (const t of stage2EliminatedFinal) qpMap.set(t.id, 0);
|
||
|
||
return qpMap;
|
||
}
|