Add PDC World Darts Championship simulator with Elo-based bracket (#248)
Fixes #123 * Add PDC World Darts Championship simulator (128-player bracket) - New DartsSimulator: 128-player single-elimination, 7 rounds with PDC-accurate best-of-sets formats (bo3/bo5/bo5/bo7/bo7/bo11/bo13). ELO_DIVISOR=500 via set-level Bernoulli model. Two simulation paths: Path A (bracket drawn) simulates from actual DB matches; Path B (pre-bracket) seeds top 32 by world ranking in fixed positions and randomly draws the remaining 96 per simulation run (50,000 iterations). - darts_bracket added to simulatorTypeEnum and simulator registry. - world_ranking nullable integer column added to participant_expected_values (migration 0067); batchSaveSourceElos now accepts and persists it. - Admin route /admin/sports-seasons/:id/darts-elo: bulk import with format "Player Name, 2099, 1" (name, Elo, optional world ranking), fuzzy name matching, auto-runs simulation and updates EV/snapshots on save. - DARTS_128 bracket template added (scoring starts at Quarterfinals). - 30 unit tests: math helpers, bracket seeding structure, Path A/B integration. https://claude.ai/code/session_01WZ6FjMmC2eBeZ1564M9Ruz * Review fixes: pre-compute hot-loop invariants, import normalizeName - Pre-compute seededSlots and getSeededMatchOrder(32) before the 50k simulation loop — was being recomputed every iteration - Pad unseeded pool to 96 once before the loop instead of inside it - Inline bracket-building in the hot loop using pre-computed seededSlots; removes the per-iteration call to buildR1Bracket/getSeededMatchOrder - Remove dead SEEDED_R1_PAIRS constant (was never referenced) - Import normalizeName from ~/lib/fuzzy-match instead of redefining it locally https://claude.ai/code/session_01WZ6FjMmC2eBeZ1564M9Ruz * Fix lint failures: unused vars, eqeqeq, toSorted - Remove unused seededSet/unseededSet variables in test - Replace != null with !== null && !== undefined (eqeqeq rule) - Replace .sort() with .toSorted() in simulator and route (unicorn/no-array-sort) https://claude.ai/code/session_01WZ6FjMmC2eBeZ1564M9Ruz * Fix TS2552: restore seededSet declaration removed during lint fix https://claude.ai/code/session_01WZ6FjMmC2eBeZ1564M9Ruz --------- Co-authored-by: Claude <noreply@anthropic.com>
This commit is contained in:
Chris Parsons
GitHub
parent
efbd28b446
commit
8c3663e01b
11 changed files with 5997 additions and 4 deletions
|
|
@ -302,6 +302,73 @@ export const SIMPLE_32: BracketTemplate = {
|
|||
],
|
||||
};
|
||||
|
||||
/**
|
||||
* PDC World Darts Championship (128 players)
|
||||
* R1 (128) → R2 (64) → R3 (32) → R4 (16) → Quarterfinals → Semifinals → Final
|
||||
* Only Quarterfinals and beyond score points.
|
||||
*
|
||||
* Match formats:
|
||||
* R1: best-of-3 sets (first to 2)
|
||||
* R2: best-of-5 sets (first to 3)
|
||||
* R3: best-of-5 sets (first to 3)
|
||||
* R4: best-of-7 sets (first to 4)
|
||||
* QF: best-of-7 sets (first to 4)
|
||||
* SF: best-of-11 sets (first to 6)
|
||||
* Final: best-of-13 sets (first to 7)
|
||||
*
|
||||
* Seeding: top 32 seeds placed in fixed positions; remaining 96 randomly drawn.
|
||||
*/
|
||||
export const DARTS_128: BracketTemplate = {
|
||||
id: "darts_128",
|
||||
name: "PDC World Darts Championship (128 Players)",
|
||||
totalTeams: 128,
|
||||
scoringStartsAtRound: "Quarterfinals",
|
||||
rounds: [
|
||||
{
|
||||
name: "Round 1",
|
||||
matchCount: 64,
|
||||
feedsInto: "Round 2",
|
||||
isScoring: false,
|
||||
},
|
||||
{
|
||||
name: "Round 2",
|
||||
matchCount: 32,
|
||||
feedsInto: "Round 3",
|
||||
isScoring: false,
|
||||
},
|
||||
{
|
||||
name: "Round 3",
|
||||
matchCount: 16,
|
||||
feedsInto: "Round 4",
|
||||
isScoring: false,
|
||||
},
|
||||
{
|
||||
name: "Round 4",
|
||||
matchCount: 8,
|
||||
feedsInto: "Quarterfinals",
|
||||
isScoring: false,
|
||||
},
|
||||
{
|
||||
name: "Quarterfinals",
|
||||
matchCount: 4,
|
||||
feedsInto: "Semi-Finals",
|
||||
isScoring: true, // QF losers share 5th–8th
|
||||
},
|
||||
{
|
||||
name: "Semi-Finals",
|
||||
matchCount: 2,
|
||||
feedsInto: "Final",
|
||||
isScoring: true, // SF losers share 3rd–4th
|
||||
},
|
||||
{
|
||||
name: "Final",
|
||||
matchCount: 1,
|
||||
feedsInto: null,
|
||||
isScoring: true, // Winner 1st, Loser 2nd
|
||||
},
|
||||
],
|
||||
};
|
||||
|
||||
/**
|
||||
* NCAA March Madness (68 teams)
|
||||
* First Four (play-in) → Round of 64 → Round of 32 → Sweet Sixteen → Elite Eight → Final Four → Championship
|
||||
|
|
@ -578,6 +645,7 @@ export const BRACKET_TEMPLATES: Record<string, BracketTemplate> = {
|
|||
nfl_14: NFL_14,
|
||||
afl_10: AFL_10,
|
||||
fifa_48: FIFA_48,
|
||||
darts_128: DARTS_128,
|
||||
};
|
||||
|
||||
/**
|
||||
|
|
|
|||
|
|
@ -29,6 +29,7 @@ export interface ParticipantEV {
|
|||
source: ProbabilitySource | null;
|
||||
sourceOdds: number | null;
|
||||
sourceElo?: number | null;
|
||||
worldRanking?: number | null;
|
||||
calculatedAt: Date;
|
||||
updatedAt: Date;
|
||||
}
|
||||
|
|
@ -362,12 +363,13 @@ export async function batchSaveSourceOdds(
|
|||
}
|
||||
|
||||
/**
|
||||
* Persist raw Elo ratings for a batch of participants (used by Elo-based simulators like snooker_bracket).
|
||||
* Persist raw Elo ratings (and optional world rankings) for a batch of participants.
|
||||
* Used by Elo-based simulators like snooker_bracket and darts_bracket.
|
||||
* Creates stub records if none exist; does not touch probabilities or EV.
|
||||
* Uses INSERT ... ON CONFLICT DO UPDATE to avoid N+1 queries.
|
||||
*/
|
||||
export async function batchSaveSourceElos(
|
||||
inputs: Array<{ participantId: string; sportsSeasonId: string; sourceElo: number }>
|
||||
inputs: Array<{ participantId: string; sportsSeasonId: string; sourceElo: number; worldRanking?: number | null }>
|
||||
): Promise<void> {
|
||||
if (inputs.length === 0) return;
|
||||
const db = database();
|
||||
|
|
@ -376,7 +378,7 @@ export async function batchSaveSourceElos(
|
|||
await db
|
||||
.insert(participantExpectedValues)
|
||||
.values(
|
||||
inputs.map(({ participantId, sportsSeasonId, sourceElo }) => ({
|
||||
inputs.map(({ participantId, sportsSeasonId, sourceElo, worldRanking }) => ({
|
||||
participantId,
|
||||
sportsSeasonId,
|
||||
probFirst: "0",
|
||||
|
|
@ -390,6 +392,7 @@ export async function batchSaveSourceElos(
|
|||
expectedValue: "0",
|
||||
source: "elo_simulation" as const,
|
||||
sourceElo,
|
||||
worldRanking: worldRanking ?? null,
|
||||
calculatedAt: now,
|
||||
updatedAt: now,
|
||||
}))
|
||||
|
|
@ -398,6 +401,7 @@ export async function batchSaveSourceElos(
|
|||
target: [participantExpectedValues.participantId, participantExpectedValues.sportsSeasonId],
|
||||
set: {
|
||||
sourceElo: sql`excluded.source_elo`,
|
||||
worldRanking: sql`excluded.world_ranking`,
|
||||
updatedAt: sql`excluded.updated_at`,
|
||||
},
|
||||
});
|
||||
|
|
|
|||
|
|
@ -95,6 +95,10 @@ export default [
|
|||
"sports-seasons/:id/surface-elo",
|
||||
"routes/admin.sports-seasons.$id.surface-elo.tsx"
|
||||
),
|
||||
route(
|
||||
"sports-seasons/:id/darts-elo",
|
||||
"routes/admin.sports-seasons.$id.darts-elo.tsx"
|
||||
),
|
||||
route(
|
||||
"sports-seasons/:id/golf-skills",
|
||||
"routes/admin.sports-seasons.$id.golf-skills.tsx"
|
||||
|
|
|
|||
470
app/routes/admin.sports-seasons.$id.darts-elo.tsx
Normal file
470
app/routes/admin.sports-seasons.$id.darts-elo.tsx
Normal file
|
|
@ -0,0 +1,470 @@
|
|||
import { Form, redirect, useLoaderData, useActionData, useNavigation } from 'react-router';
|
||||
import type { Route } from './+types/admin.sports-seasons.$id.darts-elo';
|
||||
|
||||
import { logger } from '~/lib/logger';
|
||||
import { findSportsSeasonById, updateSportsSeason } from '~/models/sports-season';
|
||||
import { findParticipantsBySportsSeasonId } from '~/models/participant';
|
||||
import {
|
||||
getAllParticipantEVsForSeason,
|
||||
batchSaveSourceElos,
|
||||
batchUpsertParticipantEVs,
|
||||
} from '~/models/participant-expected-value';
|
||||
import { batchUpsertParticipantEvSnapshots } from '~/models/ev-snapshot';
|
||||
import { getSimulator, type SimulatorType } from '~/services/simulations/registry';
|
||||
import { calculateEV } from '~/services/ev-calculator';
|
||||
import { DEFAULT_SCORING_RULES } from '~/lib/scoring-types';
|
||||
import { recalculateStandings } from '~/models/scoring-calculator';
|
||||
import { database } from '~/database/context';
|
||||
import * as schema from '~/database/schema';
|
||||
import { eq } from 'drizzle-orm';
|
||||
import { Button } from '~/components/ui/button';
|
||||
import { Input } from '~/components/ui/input';
|
||||
import { Label } from '~/components/ui/label';
|
||||
import { Textarea } from '~/components/ui/textarea';
|
||||
import {
|
||||
Card,
|
||||
CardContent,
|
||||
CardDescription,
|
||||
CardHeader,
|
||||
CardTitle,
|
||||
} from '~/components/ui/card';
|
||||
import { useState } from 'react';
|
||||
import { Loader2, CheckCircle2, AlertCircle } from 'lucide-react';
|
||||
import { normalizeName } from '~/lib/fuzzy-match';
|
||||
|
||||
export function meta({ data }: Route.MetaArgs): Route.MetaDescriptors {
|
||||
return [{ title: `Darts Elo & Rankings — ${data?.sportsSeason?.name ?? "Sports Season"} - Brackt Admin` }];
|
||||
}
|
||||
|
||||
export async function loader({ params }: Route.LoaderArgs) {
|
||||
const sportsSeasonId = params.id;
|
||||
|
||||
const sportsSeason = await findSportsSeasonById(sportsSeasonId);
|
||||
if (!sportsSeason) {
|
||||
throw new Response('Sports season not found', { status: 404 });
|
||||
}
|
||||
|
||||
const participants = await findParticipantsBySportsSeasonId(sportsSeasonId);
|
||||
const existingEVs = await getAllParticipantEVsForSeason(sportsSeasonId);
|
||||
|
||||
const existingData: Record<string, { elo: number | null; ranking: number | null }> = {};
|
||||
for (const ev of existingEVs) {
|
||||
existingData[ev.participantId] = {
|
||||
elo: ev.sourceElo ?? null,
|
||||
ranking: ev.worldRanking ?? null,
|
||||
};
|
||||
}
|
||||
|
||||
return { sportsSeason, participants, existingData };
|
||||
}
|
||||
|
||||
interface ActionData {
|
||||
success?: boolean;
|
||||
message?: string;
|
||||
}
|
||||
|
||||
export async function action({ request, params }: Route.ActionArgs) {
|
||||
const sportsSeasonId = params.id;
|
||||
const formData = await request.formData();
|
||||
|
||||
const sportsSeason = await findSportsSeasonById(sportsSeasonId);
|
||||
if (!sportsSeason) {
|
||||
return { success: false, message: 'Sports season not found' };
|
||||
}
|
||||
|
||||
const participants = await findParticipantsBySportsSeasonId(sportsSeasonId);
|
||||
|
||||
// Parse Elo ratings and world rankings from form
|
||||
const eloInputs: Array<{ participantId: string; sportsSeasonId: string; sourceElo: number; worldRanking?: number | null }> = [];
|
||||
for (const participant of participants) {
|
||||
const eloVal = formData.get(`elo_${participant.id}`) as string;
|
||||
const rankVal = formData.get(`rank_${participant.id}`) as string;
|
||||
|
||||
if (eloVal && eloVal.trim() !== '') {
|
||||
const elo = Number(eloVal);
|
||||
if (!isNaN(elo) && elo > 0) {
|
||||
const ranking = rankVal && rankVal.trim() !== '' ? Number(rankVal) : null;
|
||||
eloInputs.push({
|
||||
participantId: participant.id,
|
||||
sportsSeasonId,
|
||||
sourceElo: elo,
|
||||
worldRanking: ranking && !isNaN(ranking) && ranking > 0 ? ranking : null,
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (eloInputs.length === 0) {
|
||||
return { success: false, message: 'Please enter an Elo rating for at least one participant' };
|
||||
}
|
||||
|
||||
if (!sportsSeason.sport?.simulatorType) {
|
||||
return { success: false, message: 'This sport has no simulator type configured. Set one on the sport in the admin panel.' };
|
||||
}
|
||||
|
||||
if (sportsSeason.simulationStatus === 'running') {
|
||||
return { success: false, message: 'A simulation is already running. Please wait.' };
|
||||
}
|
||||
|
||||
// Persist Elo ratings and world rankings
|
||||
await batchSaveSourceElos(eloInputs);
|
||||
|
||||
// Auto-run simulation
|
||||
await updateSportsSeason(sportsSeasonId, { simulationStatus: 'running' });
|
||||
|
||||
try {
|
||||
const simulator = getSimulator(sportsSeason.sport.simulatorType as SimulatorType);
|
||||
const results = await simulator.simulate(sportsSeasonId);
|
||||
|
||||
if (results.length === 0) {
|
||||
throw new Error('Simulation returned no results.');
|
||||
}
|
||||
|
||||
// Zero out any participants not in simulation results
|
||||
const simulatedIds = new Set(results.map(r => r.participantId));
|
||||
const ZERO_PROBS = {
|
||||
probFirst: 0, probSecond: 0, probThird: 0, probFourth: 0,
|
||||
probFifth: 0, probSixth: 0, probSeventh: 0, probEighth: 0,
|
||||
};
|
||||
const evInputs = [
|
||||
...results.map(r => ({
|
||||
participantId: r.participantId,
|
||||
sportsSeasonId,
|
||||
probabilities: r.probabilities,
|
||||
scoringRules: DEFAULT_SCORING_RULES,
|
||||
source: 'elo_simulation' as const,
|
||||
})),
|
||||
...participants
|
||||
.filter(p => !simulatedIds.has(p.id))
|
||||
.map(p => ({
|
||||
participantId: p.id,
|
||||
sportsSeasonId,
|
||||
probabilities: ZERO_PROBS,
|
||||
scoringRules: DEFAULT_SCORING_RULES,
|
||||
source: 'elo_simulation' as const,
|
||||
})),
|
||||
];
|
||||
|
||||
await batchUpsertParticipantEVs(evInputs);
|
||||
|
||||
// Refresh projected points in team standings
|
||||
const seasonSports = await database().query.seasonSports.findMany({
|
||||
where: eq(schema.seasonSports.sportsSeasonId, sportsSeasonId),
|
||||
});
|
||||
await Promise.all(seasonSports.map(({ seasonId }) => recalculateStandings(seasonId)));
|
||||
|
||||
// EV snapshot
|
||||
const today = new Date().toISOString().slice(0, 10);
|
||||
await batchUpsertParticipantEvSnapshots(
|
||||
results.map(r => ({
|
||||
participantId: r.participantId,
|
||||
sportsSeasonId,
|
||||
snapshotDate: today,
|
||||
probFirst: r.probabilities.probFirst,
|
||||
probSecond: r.probabilities.probSecond,
|
||||
probThird: r.probabilities.probThird,
|
||||
probFourth: r.probabilities.probFourth,
|
||||
probFifth: r.probabilities.probFifth,
|
||||
probSixth: r.probabilities.probSixth,
|
||||
probSeventh: r.probabilities.probSeventh,
|
||||
probEighth: r.probabilities.probEighth,
|
||||
calculatedEV: calculateEV(r.probabilities, DEFAULT_SCORING_RULES),
|
||||
source: r.source,
|
||||
}))
|
||||
);
|
||||
|
||||
await updateSportsSeason(sportsSeasonId, { simulationStatus: 'idle' });
|
||||
} catch (error) {
|
||||
await updateSportsSeason(sportsSeasonId, { simulationStatus: 'failed' });
|
||||
logger.error('Error running darts simulation:', error);
|
||||
return {
|
||||
success: false,
|
||||
message: error instanceof Error ? error.message : 'Simulation failed',
|
||||
};
|
||||
}
|
||||
|
||||
return redirect(`/admin/sports-seasons/${sportsSeasonId}/expected-values`);
|
||||
}
|
||||
|
||||
export default function AdminSportsSeasonDartsElo() {
|
||||
const { sportsSeason, participants, existingData } = useLoaderData<typeof loader>();
|
||||
const actionData = useActionData<ActionData>();
|
||||
const navigation = useNavigation();
|
||||
|
||||
const [eloValues, setEloValues] = useState<Record<string, string>>(() => {
|
||||
const initial: Record<string, string> = {};
|
||||
participants.forEach(p => {
|
||||
const d = existingData[p.id];
|
||||
if (d?.elo !== null && d?.elo !== undefined) initial[p.id] = d.elo.toString();
|
||||
});
|
||||
return initial;
|
||||
});
|
||||
|
||||
const [rankValues, setRankValues] = useState<Record<string, string>>(() => {
|
||||
const initial: Record<string, string> = {};
|
||||
participants.forEach(p => {
|
||||
const d = existingData[p.id];
|
||||
if (d?.ranking !== null && d?.ranking !== undefined) initial[p.id] = d.ranking.toString();
|
||||
});
|
||||
return initial;
|
||||
});
|
||||
|
||||
// Bulk import state: "Player Name, 2099, 1" format (name, elo, optional world ranking)
|
||||
const [bulkText, setBulkText] = useState('');
|
||||
const [parseResults, setParseResults] = useState<{
|
||||
matched: Array<{ participantId: string; name: string; elo: number; ranking: number | null; inputName: string }>;
|
||||
unmatched: Array<{ inputName: string; elo: number; ranking: number | null }>;
|
||||
} | null>(null);
|
||||
|
||||
function findParticipantMatch(inputName: string) {
|
||||
const normalizedInput = normalizeName(inputName);
|
||||
const normalized = participants.map(p => ({ p, n: normalizeName(p.name) }));
|
||||
|
||||
const exact = normalized.find(({ n }) => n === normalizedInput);
|
||||
if (exact) return exact.p;
|
||||
|
||||
const contains = normalized.find(({ n }) => n.includes(normalizedInput) || normalizedInput.includes(n));
|
||||
if (contains) return contains.p;
|
||||
|
||||
const inputWords = normalizedInput.split(' ').filter(w => w.length > 2);
|
||||
const overlap = normalized.find(({ n }) => {
|
||||
const pWords = n.split(' ').filter(w => w.length > 2);
|
||||
const shared = inputWords.filter(w => pWords.includes(w));
|
||||
return shared.length > 0 && shared.length >= Math.min(inputWords.length, pWords.length) * 0.5;
|
||||
});
|
||||
|
||||
return overlap?.p ?? null;
|
||||
}
|
||||
|
||||
function parseBulkText() {
|
||||
// Formats supported:
|
||||
// "Player Name, 2099, 1" (name, elo, world ranking)
|
||||
// "Player Name, 2099" (name, elo — ranking omitted)
|
||||
// "Player Name: 2099: 1" (colon-separated)
|
||||
const lines = bulkText.split('\n');
|
||||
const matched: typeof parseResults extends null ? never : NonNullable<typeof parseResults>['matched'] = [];
|
||||
const unmatched: typeof parseResults extends null ? never : NonNullable<typeof parseResults>['unmatched'] = [];
|
||||
const seen = new Set<string>();
|
||||
|
||||
for (const line of lines) {
|
||||
const trimmed = line.trim();
|
||||
if (!trimmed) continue;
|
||||
|
||||
// Match "Name, Elo" or "Name, Elo, Ranking" (comma, colon, or tab separated)
|
||||
const match = /^(.+?)[\s,:\t]+(\d{3,5})(?:[\s,:\t]+(\d{1,3}))?\s*$/.exec(trimmed);
|
||||
if (!match) continue;
|
||||
|
||||
const inputName = match[1].trim();
|
||||
const elo = parseInt(match[2], 10);
|
||||
const ranking = match[3] ? parseInt(match[3], 10) : null;
|
||||
|
||||
if (isNaN(elo) || elo < 500 || elo > 5000) continue;
|
||||
if (ranking !== null && (isNaN(ranking) || ranking < 1 || ranking > 256)) continue;
|
||||
|
||||
const participant = findParticipantMatch(inputName);
|
||||
if (participant && !seen.has(participant.id)) {
|
||||
seen.add(participant.id);
|
||||
matched.push({ participantId: participant.id, name: participant.name, elo, ranking, inputName });
|
||||
} else if (!participant) {
|
||||
unmatched.push({ inputName, elo, ranking });
|
||||
}
|
||||
}
|
||||
|
||||
setParseResults({ matched, unmatched });
|
||||
}
|
||||
|
||||
function applyMatches() {
|
||||
if (!parseResults) return;
|
||||
const newElos = { ...eloValues };
|
||||
const newRanks = { ...rankValues };
|
||||
for (const m of parseResults.matched) {
|
||||
newElos[m.participantId] = m.elo.toString();
|
||||
if (m.ranking !== null) {
|
||||
newRanks[m.participantId] = m.ranking.toString();
|
||||
}
|
||||
}
|
||||
setEloValues(newElos);
|
||||
setRankValues(newRanks);
|
||||
setParseResults(null);
|
||||
setBulkText('');
|
||||
}
|
||||
|
||||
const isSubmitting = navigation.state === 'submitting';
|
||||
|
||||
// Sort participants for display: by current rank (ascending), then unranked alphabetically
|
||||
const sortedParticipants = [...participants].toSorted((a, b) => {
|
||||
const rankA = rankValues[a.id] ? parseInt(rankValues[a.id], 10) : null;
|
||||
const rankB = rankValues[b.id] ? parseInt(rankValues[b.id], 10) : null;
|
||||
if (rankA !== null && rankB !== null) return rankA - rankB;
|
||||
if (rankA !== null) return -1;
|
||||
if (rankB !== null) return 1;
|
||||
return a.name.localeCompare(b.name);
|
||||
});
|
||||
|
||||
return (
|
||||
<div className="container mx-auto py-8">
|
||||
<div className="mb-8">
|
||||
<h1 className="text-3xl font-bold mb-2">Darts Elo & World Rankings</h1>
|
||||
<p className="text-muted-foreground">
|
||||
{sportsSeason.sport.name} — {sportsSeason.name}
|
||||
</p>
|
||||
</div>
|
||||
|
||||
{/* Bulk Import */}
|
||||
<Card className="mb-6">
|
||||
<CardHeader>
|
||||
<CardTitle>Bulk Import</CardTitle>
|
||||
<CardDescription>
|
||||
Paste one player per line. Format:{' '}
|
||||
<code>Player Name, 2099, 1</code> (name, Elo, world ranking).
|
||||
World ranking is optional — omit it and the simulator will use Elo order for seeding.
|
||||
Player names are fuzzy-matched to participants.
|
||||
</CardDescription>
|
||||
</CardHeader>
|
||||
<CardContent className="space-y-4">
|
||||
<Textarea
|
||||
placeholder={`Luke Littler, 2099, 1\nMichael van Gerwen, 1950, 2\nLuke Humphries, 1947, 3`}
|
||||
value={bulkText}
|
||||
onChange={e => { setBulkText(e.target.value); setParseResults(null); }}
|
||||
rows={10}
|
||||
className="font-mono text-sm"
|
||||
/>
|
||||
<Button type="button" variant="outline" onClick={parseBulkText} disabled={!bulkText.trim()}>
|
||||
Parse
|
||||
</Button>
|
||||
|
||||
{parseResults && (
|
||||
<div className="space-y-3">
|
||||
{parseResults.matched.length > 0 && (
|
||||
<div>
|
||||
<div className="flex items-center gap-2 text-sm font-medium text-emerald-400 mb-2">
|
||||
<CheckCircle2 className="h-4 w-4" />
|
||||
Matched ({parseResults.matched.length})
|
||||
</div>
|
||||
<div className="rounded-md border border-emerald-500/30 bg-emerald-500/10 divide-y divide-emerald-500/20 text-sm">
|
||||
{parseResults.matched.map(m => (
|
||||
<div key={m.participantId} className="flex justify-between px-3 py-1.5">
|
||||
<span className="text-muted-foreground">{m.inputName}</span>
|
||||
<span className="font-medium">
|
||||
{m.name} → Elo {m.elo}{m.ranking !== null ? `, Rank #${m.ranking}` : ''}
|
||||
</span>
|
||||
</div>
|
||||
))}
|
||||
</div>
|
||||
</div>
|
||||
)}
|
||||
|
||||
{parseResults.unmatched.length > 0 && (
|
||||
<div>
|
||||
<div className="flex items-center gap-2 text-sm font-medium text-amber-700 mb-2">
|
||||
<AlertCircle className="h-4 w-4" />
|
||||
Not matched ({parseResults.unmatched.length}) — enter manually below
|
||||
</div>
|
||||
<div className="rounded-md border border-amber-200 bg-amber-50 divide-y divide-amber-100 text-sm">
|
||||
{parseResults.unmatched.map(u => (
|
||||
<div key={u.inputName} className="flex justify-between px-3 py-1.5">
|
||||
<span>{u.inputName}</span>
|
||||
<span className="font-medium">
|
||||
Elo {u.elo}{u.ranking !== null ? `, Rank #${u.ranking}` : ''}
|
||||
</span>
|
||||
</div>
|
||||
))}
|
||||
</div>
|
||||
</div>
|
||||
)}
|
||||
|
||||
{parseResults.matched.length > 0 && (
|
||||
<Button type="button" onClick={applyMatches}>
|
||||
Apply {parseResults.matched.length} matched entries to form
|
||||
</Button>
|
||||
)}
|
||||
</div>
|
||||
)}
|
||||
</CardContent>
|
||||
</Card>
|
||||
|
||||
<div className="grid gap-6 lg:grid-cols-2">
|
||||
<Card>
|
||||
<CardHeader>
|
||||
<CardTitle>Player Elo & Rankings</CardTitle>
|
||||
<CardDescription>
|
||||
Enter each player's Darts Elo and world ranking. World ranking determines bracket seeding
|
||||
(top 32 seeded, rest randomly drawn). Saving will automatically run the simulation and
|
||||
update expected values.
|
||||
</CardDescription>
|
||||
</CardHeader>
|
||||
<CardContent>
|
||||
<Form method="post" className="space-y-4">
|
||||
<div className="grid grid-cols-[1fr_100px_80px] gap-x-3 gap-y-2 items-center text-xs font-medium text-muted-foreground mb-1">
|
||||
<span>Player</span>
|
||||
<span>Elo</span>
|
||||
<span>Rank #</span>
|
||||
</div>
|
||||
<div className="space-y-2">
|
||||
{sortedParticipants.map(participant => (
|
||||
<div key={participant.id} className="grid grid-cols-[1fr_100px_80px] gap-x-3 items-center">
|
||||
<Label htmlFor={`elo_${participant.id}`} className="truncate text-sm">
|
||||
{participant.name}
|
||||
</Label>
|
||||
<Input
|
||||
type="number"
|
||||
id={`elo_${participant.id}`}
|
||||
name={`elo_${participant.id}`}
|
||||
placeholder="1800"
|
||||
value={eloValues[participant.id] ?? ''}
|
||||
onChange={e =>
|
||||
setEloValues(prev => ({ ...prev, [participant.id]: e.target.value }))
|
||||
}
|
||||
className="h-8 text-sm"
|
||||
/>
|
||||
<Input
|
||||
type="number"
|
||||
name={`rank_${participant.id}`}
|
||||
placeholder="—"
|
||||
value={rankValues[participant.id] ?? ''}
|
||||
onChange={e =>
|
||||
setRankValues(prev => ({ ...prev, [participant.id]: e.target.value }))
|
||||
}
|
||||
className="h-8 text-sm"
|
||||
/>
|
||||
</div>
|
||||
))}
|
||||
</div>
|
||||
|
||||
{actionData && !actionData.success && actionData.message && (
|
||||
<div className="text-sm text-destructive">{actionData.message}</div>
|
||||
)}
|
||||
|
||||
<Button type="submit" disabled={isSubmitting}>
|
||||
{isSubmitting && <Loader2 className="mr-2 h-4 w-4 animate-spin" />}
|
||||
{isSubmitting ? 'Saving & Running Simulation...' : 'Save & Run Simulation'}
|
||||
</Button>
|
||||
</Form>
|
||||
</CardContent>
|
||||
</Card>
|
||||
|
||||
<Card>
|
||||
<CardHeader>
|
||||
<CardTitle>How It Works</CardTitle>
|
||||
</CardHeader>
|
||||
<CardContent className="text-sm space-y-2">
|
||||
<ol className="list-decimal list-inside space-y-2">
|
||||
<li>Save Elo ratings and world rankings for all 128 players</li>
|
||||
<li>Top 32 seeds placed in fixed bracket positions; remaining 96 randomly drawn per simulation</li>
|
||||
<li>Per-set win probability: p = 1 / (1 + e^(−ΔElo/500))</li>
|
||||
<li>Match win probability via Bernoulli sets model for each round's best-of length</li>
|
||||
<li>Run 50,000 Monte Carlo simulations of the full bracket</li>
|
||||
<li>Distribute probabilities across 1st–8th place buckets</li>
|
||||
<li>Calculate expected fantasy value per player</li>
|
||||
</ol>
|
||||
<div className="mt-4 text-muted-foreground text-xs space-y-1">
|
||||
<div>Round formats: R1 bo3, R2/R3 bo5, R4/QF bo7, SF bo11, Final bo13</div>
|
||||
<div>If world ranking is omitted, players are seeded by Elo order.</div>
|
||||
<div>Once the bracket draw is announced, add players to the bracket event for live simulation.</div>
|
||||
</div>
|
||||
</CardContent>
|
||||
</Card>
|
||||
</div>
|
||||
</div>
|
||||
);
|
||||
}
|
||||
455
app/services/simulations/__tests__/darts-simulator.test.ts
Normal file
455
app/services/simulations/__tests__/darts-simulator.test.ts
Normal file
|
|
@ -0,0 +1,455 @@
|
|||
import { describe, it, expect, vi, beforeEach, type MockInstance } from "vitest";
|
||||
import {
|
||||
setWinProb,
|
||||
matchWinProb,
|
||||
getSeededMatchOrder,
|
||||
buildR1Bracket,
|
||||
DartsSimulator,
|
||||
} from "../darts-simulator";
|
||||
|
||||
// ─── Pure math: setWinProb ────────────────────────────────────────────────────
|
||||
|
||||
describe("setWinProb", () => {
|
||||
it("returns 0.5 for equal Elo", () => {
|
||||
expect(setWinProb(1800, 1800)).toBeCloseTo(0.5, 5);
|
||||
expect(setWinProb(2000, 2000)).toBeCloseTo(0.5, 5);
|
||||
});
|
||||
|
||||
it("returns > 0.5 for positive Elo advantage, < 0.5 for negative", () => {
|
||||
expect(setWinProb(2000, 1700)).toBeGreaterThan(0.5);
|
||||
expect(setWinProb(1700, 2000)).toBeLessThan(0.5);
|
||||
});
|
||||
|
||||
it("is symmetric: setWinProb(a, b) + setWinProb(b, a) = 1", () => {
|
||||
expect(setWinProb(2000, 1700) + setWinProb(1700, 2000)).toBeCloseTo(1.0, 5);
|
||||
expect(setWinProb(2099, 1952) + setWinProb(1952, 2099)).toBeCloseTo(1.0, 5);
|
||||
});
|
||||
|
||||
it("larger Elo gap → higher win probability (monotonic)", () => {
|
||||
const p100 = setWinProb(1900, 1800);
|
||||
const p300 = setWinProb(2100, 1800);
|
||||
const p500 = setWinProb(2300, 1800);
|
||||
expect(p300).toBeGreaterThan(p100);
|
||||
expect(p500).toBeGreaterThan(p300);
|
||||
});
|
||||
|
||||
it("returns value strictly in (0, 1) for any finite Elo", () => {
|
||||
expect(setWinProb(3000, 1000)).toBeLessThan(1);
|
||||
expect(setWinProb(3000, 1000)).toBeGreaterThan(0);
|
||||
expect(setWinProb(1000, 3000)).toBeLessThan(1);
|
||||
expect(setWinProb(1000, 3000)).toBeGreaterThan(0);
|
||||
});
|
||||
|
||||
it("calibration: 100-pt gap → ~55% per set (ELO_DIVISOR=500)", () => {
|
||||
// 1 / (1 + e^(-100/500)) ≈ 0.5499
|
||||
expect(setWinProb(1900, 1800)).toBeCloseTo(0.5499, 2);
|
||||
});
|
||||
});
|
||||
|
||||
// ─── Pure math: matchWinProb ──────────────────────────────────────────────────
|
||||
|
||||
describe("matchWinProb", () => {
|
||||
it("returns 0.5 for equal players (p=0.5) at any match length", () => {
|
||||
// PDC formats: bo3 (S=2), bo5 (S=3), bo7 (S=4), bo11 (S=6), bo13 (S=7)
|
||||
expect(matchWinProb(0.5, 2)).toBeCloseTo(0.5, 3);
|
||||
expect(matchWinProb(0.5, 3)).toBeCloseTo(0.5, 3);
|
||||
expect(matchWinProb(0.5, 4)).toBeCloseTo(0.5, 3);
|
||||
expect(matchWinProb(0.5, 6)).toBeCloseTo(0.5, 3);
|
||||
expect(matchWinProb(0.5, 7)).toBeCloseTo(0.5, 3);
|
||||
});
|
||||
|
||||
it("approaches 1.0 as p → 1.0", () => {
|
||||
expect(matchWinProb(0.9999, 2)).toBeCloseTo(1.0, 3);
|
||||
expect(matchWinProb(0.9999, 7)).toBeCloseTo(1.0, 3);
|
||||
});
|
||||
|
||||
it("approaches 0.0 as p → 0.0", () => {
|
||||
expect(matchWinProb(0.0001, 2)).toBeCloseTo(0.0, 3);
|
||||
expect(matchWinProb(0.0001, 7)).toBeCloseTo(0.0, 3);
|
||||
});
|
||||
|
||||
it("longer matches amplify stronger player's advantage", () => {
|
||||
// p=0.6: win prob should be higher in best-of-13 than best-of-3
|
||||
const bo3 = matchWinProb(0.6, 2);
|
||||
const bo13 = matchWinProb(0.6, 7);
|
||||
expect(bo13).toBeGreaterThan(bo3);
|
||||
});
|
||||
|
||||
it("match win prob + opponent win prob sums to 1.0", () => {
|
||||
const p = 0.63;
|
||||
expect(matchWinProb(p, 3) + matchWinProb(1 - p, 3)).toBeCloseTo(1.0, 5);
|
||||
expect(matchWinProb(p, 6) + matchWinProb(1 - p, 6)).toBeCloseTo(1.0, 5);
|
||||
});
|
||||
|
||||
it("best-of-3 (S=2): reference check for p=0.6 → ~0.648", () => {
|
||||
// P(2-0) = 0.6^2 = 0.36; P(2-1) = 2 * 0.6^2 * 0.4 = 0.288; total = 0.648
|
||||
expect(matchWinProb(0.6, 2)).toBeCloseTo(0.648, 3);
|
||||
});
|
||||
});
|
||||
|
||||
// ─── Bracket structure: getSeededMatchOrder ──────────────────────────────────
|
||||
|
||||
describe("getSeededMatchOrder", () => {
|
||||
it("for n=2, returns [1, 2]", () => {
|
||||
expect(getSeededMatchOrder(2)).toEqual([1, 2]);
|
||||
});
|
||||
|
||||
it("for n=4, seed 1 vs 4 in top half, seed 2 vs 3 in bottom half", () => {
|
||||
// Algorithm: start [1,2] → expand to [1,4,2,3]
|
||||
expect(getSeededMatchOrder(4)).toEqual([1, 4, 2, 3]);
|
||||
});
|
||||
|
||||
it("for n=8, seed 1 and seed 2 are in opposite halves", () => {
|
||||
const order = getSeededMatchOrder(8);
|
||||
expect(order).toHaveLength(8);
|
||||
const idx1 = order.indexOf(1);
|
||||
const idx2 = order.indexOf(2);
|
||||
// Seeds 1 and 2 should be in different halves (0-3 vs 4-7)
|
||||
expect(Math.floor(idx1 / 4)).not.toBe(Math.floor(idx2 / 4));
|
||||
});
|
||||
|
||||
it("for n=32, contains all seeds 1–32 exactly once", () => {
|
||||
const order = getSeededMatchOrder(32);
|
||||
expect(order).toHaveLength(32);
|
||||
const sorted = [...order].toSorted((a, b) => a - b);
|
||||
expect(sorted).toEqual(Array.from({ length: 32 }, (_, i) => i + 1));
|
||||
});
|
||||
|
||||
it("for n=32, seed 1 and seed 2 are in opposite halves", () => {
|
||||
const order = getSeededMatchOrder(32);
|
||||
const idx1 = order.indexOf(1);
|
||||
const idx2 = order.indexOf(2);
|
||||
// Opposite halves: one in [0,15], other in [16,31]
|
||||
expect(Math.floor(idx1 / 16)).not.toBe(Math.floor(idx2 / 16));
|
||||
});
|
||||
});
|
||||
|
||||
// ─── Bracket structure: buildR1Bracket ───────────────────────────────────────
|
||||
|
||||
describe("buildR1Bracket", () => {
|
||||
const seeded = Array.from({ length: 32 }, (_, i) => `seed-${i + 1}`);
|
||||
const unseeded = Array.from({ length: 96 }, (_, i) => `unseed-${i}`);
|
||||
|
||||
it("returns exactly 64 pairs", () => {
|
||||
const pairs = buildR1Bracket(seeded, unseeded);
|
||||
expect(pairs).toHaveLength(64);
|
||||
});
|
||||
|
||||
it("covers all 128 players (32 seeded + 96 unseeded)", () => {
|
||||
const pairs = buildR1Bracket(seeded, unseeded);
|
||||
const allPlayers = pairs.flat();
|
||||
expect(allPlayers).toHaveLength(128);
|
||||
|
||||
for (const [a, b] of pairs) {
|
||||
expect(a).toBeTruthy();
|
||||
expect(b).toBeTruthy();
|
||||
}
|
||||
|
||||
// All seeded players appear exactly once
|
||||
for (const s of seeded) {
|
||||
expect(allPlayers.filter(p => p === s)).toHaveLength(1);
|
||||
}
|
||||
|
||||
// All unseeded players appear exactly once
|
||||
for (const u of unseeded) {
|
||||
expect(allPlayers.filter(p => p === u)).toHaveLength(1);
|
||||
}
|
||||
});
|
||||
|
||||
it("each of the 32 seeded players faces an unseeded opponent in their R1 match", () => {
|
||||
const pairs = buildR1Bracket(seeded, unseeded);
|
||||
const seededSet = new Set(seeded);
|
||||
|
||||
// First 32 pairs: seeded vs unseeded
|
||||
for (let i = 0; i < 32; i++) {
|
||||
const [a, b] = pairs[i];
|
||||
const aSeeded = seededSet.has(a);
|
||||
const bSeeded = seededSet.has(b);
|
||||
// One must be seeded, the other unseeded
|
||||
expect(aSeeded !== bSeeded).toBe(true);
|
||||
}
|
||||
});
|
||||
|
||||
it("last 32 pairs: all unseeded vs unseeded", () => {
|
||||
const pairs = buildR1Bracket(seeded, unseeded);
|
||||
const seededSet = new Set(seeded);
|
||||
|
||||
for (let i = 32; i < 64; i++) {
|
||||
const [a, b] = pairs[i];
|
||||
expect(seededSet.has(a)).toBe(false);
|
||||
expect(seededSet.has(b)).toBe(false);
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
// ─── Integration tests with mocked DB ────────────────────────────────────────
|
||||
|
||||
const PARTICIPANT_IDS = Array.from({ length: 128 }, (_, i) => `player-${i + 1}`);
|
||||
const ELO_BASE = 1750;
|
||||
|
||||
function makeMatch(
|
||||
round: string,
|
||||
matchNumber: number,
|
||||
p1Index: number,
|
||||
p2Index: number,
|
||||
opts: { winnerId?: string; loserId?: string; isComplete?: boolean } = {}
|
||||
) {
|
||||
return {
|
||||
id: `${round}-match-${matchNumber}`,
|
||||
scoringEventId: "event-1",
|
||||
round,
|
||||
matchNumber,
|
||||
participant1Id: PARTICIPANT_IDS[p1Index],
|
||||
participant2Id: PARTICIPANT_IDS[p2Index],
|
||||
winnerId: opts.winnerId ?? null,
|
||||
loserId: opts.loserId ?? null,
|
||||
isComplete: opts.isComplete ?? false,
|
||||
isScoring: true,
|
||||
templateRound: round,
|
||||
seedInfo: null,
|
||||
participant1Score: null,
|
||||
participant2Score: null,
|
||||
createdAt: new Date(),
|
||||
updatedAt: new Date(),
|
||||
};
|
||||
}
|
||||
|
||||
/** Build a full 7-round bracket (128 players, 127 matches). */
|
||||
function makeFullBracket(): ReturnType<typeof makeMatch>[] {
|
||||
const matches: ReturnType<typeof makeMatch>[] = [];
|
||||
for (let i = 0; i < 64; i++) matches.push(makeMatch("Round 1", i + 1, i * 2, i * 2 + 1));
|
||||
for (let i = 0; i < 32; i++) matches.push(makeMatch("Round 2", i + 1, 0, 1));
|
||||
for (let i = 0; i < 16; i++) matches.push(makeMatch("Round 3", i + 1, 0, 1));
|
||||
for (let i = 0; i < 8; i++) matches.push(makeMatch("Round 4", i + 1, 0, 1));
|
||||
for (let i = 0; i < 4; i++) matches.push(makeMatch("Quarter-Finals", i + 1, 0, 1));
|
||||
for (let i = 0; i < 2; i++) matches.push(makeMatch("Semi-Finals", i + 1, 0, 1));
|
||||
matches.push(makeMatch("Final", 1, 0, 1));
|
||||
return matches;
|
||||
}
|
||||
|
||||
function makeEVRows(eloOverride?: Map<string, number>) {
|
||||
return PARTICIPANT_IDS.map((participantId) => ({
|
||||
participantId,
|
||||
sourceElo: eloOverride?.get(participantId) ?? ELO_BASE,
|
||||
worldRanking: null,
|
||||
}));
|
||||
}
|
||||
|
||||
vi.mock("~/database/context", () => ({
|
||||
database: vi.fn(),
|
||||
}));
|
||||
|
||||
describe("DartsSimulator.simulate() — Path A (bracket populated)", () => {
|
||||
let mockDb: {
|
||||
query: {
|
||||
scoringEvents: { findFirst: MockInstance };
|
||||
playoffMatches: { findMany: MockInstance };
|
||||
};
|
||||
select: MockInstance;
|
||||
};
|
||||
|
||||
beforeEach(async () => {
|
||||
const { database } = await import("~/database/context");
|
||||
|
||||
mockDb = {
|
||||
query: {
|
||||
scoringEvents: { findFirst: vi.fn() },
|
||||
playoffMatches: { findMany: vi.fn() },
|
||||
},
|
||||
select: vi.fn().mockReturnValue({
|
||||
from: vi.fn().mockReturnValue({
|
||||
where: vi.fn().mockResolvedValue(makeEVRows()),
|
||||
}),
|
||||
}),
|
||||
};
|
||||
|
||||
(database as unknown as MockInstance).mockReturnValue(mockDb);
|
||||
|
||||
mockDb.query.scoringEvents.findFirst.mockResolvedValue({
|
||||
id: "event-1",
|
||||
sportsSeasonId: "season-1",
|
||||
eventType: "playoff_game",
|
||||
});
|
||||
});
|
||||
|
||||
it("throws if bracket does not have exactly 7 rounds", async () => {
|
||||
// Only 6 rounds (missing Final)
|
||||
const matches = [
|
||||
...Array.from({ length: 64 }, (_, i) => makeMatch("Round 1", i + 1, i * 2, i * 2 + 1)),
|
||||
...Array.from({ length: 32 }, (_, i) => makeMatch("Round 2", i + 1, 0, 1)),
|
||||
...Array.from({ length: 16 }, (_, i) => makeMatch("Round 3", i + 1, 0, 1)),
|
||||
...Array.from({ length: 8 }, (_, i) => makeMatch("Round 4", i + 1, 0, 1)),
|
||||
...Array.from({ length: 4 }, (_, i) => makeMatch("Quarter-Finals", i + 1, 0, 1)),
|
||||
...Array.from({ length: 2 }, (_, i) => makeMatch("Semi-Finals", i + 1, 0, 1)),
|
||||
];
|
||||
mockDb.query.playoffMatches.findMany.mockResolvedValue(matches);
|
||||
|
||||
const sim = new DartsSimulator();
|
||||
await expect(sim.simulate("season-1")).rejects.toThrow(/Expected 7 rounds/);
|
||||
});
|
||||
|
||||
it("throws if R1 does not have 64 matches", async () => {
|
||||
const matches = [
|
||||
...Array.from({ length: 32 }, (_, i) => makeMatch("Round 1", i + 1, i * 2, i * 2 + 1)),
|
||||
...Array.from({ length: 32 }, (_, i) => makeMatch("Round 2", i + 1, 0, 1)),
|
||||
...Array.from({ length: 16 }, (_, i) => makeMatch("Round 3", i + 1, 0, 1)),
|
||||
...Array.from({ length: 8 }, (_, i) => makeMatch("Round 4", i + 1, 0, 1)),
|
||||
...Array.from({ length: 4 }, (_, i) => makeMatch("Quarter-Finals", i + 1, 0, 1)),
|
||||
...Array.from({ length: 2 }, (_, i) => makeMatch("Semi-Finals", i + 1, 0, 1)),
|
||||
makeMatch("Final", 1, 0, 1),
|
||||
];
|
||||
mockDb.query.playoffMatches.findMany.mockResolvedValue(matches);
|
||||
|
||||
const sim = new DartsSimulator();
|
||||
await expect(sim.simulate("season-1")).rejects.toThrow(/Expected 64 R1 matches/);
|
||||
});
|
||||
|
||||
it("returns 128 results with valid probability distributions", async () => {
|
||||
mockDb.query.playoffMatches.findMany.mockResolvedValue(makeFullBracket());
|
||||
|
||||
const sim = new DartsSimulator();
|
||||
const results = await sim.simulate("season-1");
|
||||
|
||||
expect(results).toHaveLength(128);
|
||||
for (const r of results) {
|
||||
const p = r.probabilities;
|
||||
expect(p.probFirst).toBeGreaterThanOrEqual(0);
|
||||
expect(p.probFirst).toBeLessThanOrEqual(1);
|
||||
const sum = p.probFirst + p.probSecond + p.probThird + p.probFourth +
|
||||
p.probFifth + p.probSixth + p.probSeventh + p.probEighth;
|
||||
expect(sum).toBeGreaterThanOrEqual(0);
|
||||
expect(sum).toBeLessThanOrEqual(1.001);
|
||||
}
|
||||
});
|
||||
|
||||
it("each probability column sums to 1.0 across all 128 participants", async () => {
|
||||
mockDb.query.playoffMatches.findMany.mockResolvedValue(makeFullBracket());
|
||||
|
||||
const sim = new DartsSimulator();
|
||||
const results = await sim.simulate("season-1");
|
||||
|
||||
const keys = [
|
||||
"probFirst", "probSecond", "probThird", "probFourth",
|
||||
"probFifth", "probSixth", "probSeventh", "probEighth",
|
||||
] as const;
|
||||
for (const key of keys) {
|
||||
const colSum = results.reduce((s, r) => s + r.probabilities[key], 0);
|
||||
expect(colSum).toBeCloseTo(1.0, 2);
|
||||
}
|
||||
});
|
||||
|
||||
it("labels results with darts_world_championship_monte_carlo source", async () => {
|
||||
mockDb.query.playoffMatches.findMany.mockResolvedValue(makeFullBracket());
|
||||
|
||||
const sim = new DartsSimulator();
|
||||
const results = await sim.simulate("season-1");
|
||||
|
||||
expect(results.every(r => r.source === "darts_world_championship_monte_carlo")).toBe(true);
|
||||
});
|
||||
});
|
||||
|
||||
// ─── Path B: pre-bracket simulation ──────────────────────────────────────────
|
||||
|
||||
describe("DartsSimulator.simulate() — Path B (pre-bracket)", () => {
|
||||
let mockDb: {
|
||||
query: {
|
||||
scoringEvents: { findFirst: MockInstance };
|
||||
playoffMatches: { findMany: MockInstance };
|
||||
};
|
||||
select: MockInstance;
|
||||
};
|
||||
|
||||
// 128 participants with world rankings
|
||||
const SEASON_PARTICIPANTS = Array.from({ length: 128 }, (_, i) => ({
|
||||
id: `player-${i + 1}`,
|
||||
name: `Player ${i + 1}`,
|
||||
}));
|
||||
|
||||
function makeEVRowsWithRankings() {
|
||||
return SEASON_PARTICIPANTS.map((p, i) => ({
|
||||
participantId: p.id,
|
||||
sourceElo: ELO_BASE - i * 2, // higher seed = higher Elo
|
||||
worldRanking: i + 1,
|
||||
}));
|
||||
}
|
||||
|
||||
beforeEach(async () => {
|
||||
const { database } = await import("~/database/context");
|
||||
|
||||
const eloRows = makeEVRowsWithRankings();
|
||||
const participantRows = SEASON_PARTICIPANTS;
|
||||
|
||||
mockDb = {
|
||||
query: {
|
||||
scoringEvents: { findFirst: vi.fn() },
|
||||
playoffMatches: { findMany: vi.fn() },
|
||||
},
|
||||
select: vi.fn()
|
||||
.mockReturnValueOnce({
|
||||
from: vi.fn().mockReturnValue({ where: vi.fn().mockResolvedValue(eloRows) }),
|
||||
})
|
||||
.mockReturnValueOnce({
|
||||
from: vi.fn().mockReturnValue({ where: vi.fn().mockResolvedValue(participantRows) }),
|
||||
}),
|
||||
};
|
||||
|
||||
(database as unknown as MockInstance).mockReturnValue(mockDb);
|
||||
|
||||
mockDb.query.scoringEvents.findFirst.mockResolvedValue(null);
|
||||
mockDb.query.playoffMatches.findMany.mockResolvedValue([]);
|
||||
});
|
||||
|
||||
it("returns 128 results when bracket is not yet populated", async () => {
|
||||
const sim = new DartsSimulator();
|
||||
const results = await sim.simulate("season-1");
|
||||
|
||||
expect(results).toHaveLength(128);
|
||||
});
|
||||
|
||||
it("each probability column sums to 1.0 across all 128 participants", async () => {
|
||||
const sim = new DartsSimulator();
|
||||
const results = await sim.simulate("season-1");
|
||||
|
||||
const keys = [
|
||||
"probFirst", "probSecond", "probThird", "probFourth",
|
||||
"probFifth", "probSixth", "probSeventh", "probEighth",
|
||||
] as const;
|
||||
for (const key of keys) {
|
||||
const colSum = results.reduce((s, r) => s + r.probabilities[key], 0);
|
||||
expect(colSum).toBeCloseTo(1.0, 2);
|
||||
}
|
||||
});
|
||||
|
||||
it("world #1 (highest Elo) has the highest probFirst", async () => {
|
||||
const sim = new DartsSimulator();
|
||||
const results = await sim.simulate("season-1");
|
||||
|
||||
const sorted = [...results].toSorted((a, b) => b.probabilities.probFirst - a.probabilities.probFirst);
|
||||
// player-1 is world #1 with the highest Elo — should have highest win probability
|
||||
expect(sorted[0].participantId).toBe("player-1");
|
||||
});
|
||||
|
||||
it("throws if fewer than 2 participants exist", async () => {
|
||||
const { database } = await import("~/database/context");
|
||||
const tooFew = [{ id: "player-1", name: "Solo" }];
|
||||
const eloRowsFew = [{ participantId: "player-1", sourceElo: ELO_BASE, worldRanking: 1 }];
|
||||
|
||||
(database as unknown as MockInstance).mockReturnValue({
|
||||
...mockDb,
|
||||
query: {
|
||||
scoringEvents: { findFirst: vi.fn().mockResolvedValue(null) },
|
||||
playoffMatches: { findMany: vi.fn().mockResolvedValue([]) },
|
||||
},
|
||||
select: vi.fn()
|
||||
.mockReturnValueOnce({
|
||||
from: vi.fn().mockReturnValue({ where: vi.fn().mockResolvedValue(eloRowsFew) }),
|
||||
})
|
||||
.mockReturnValueOnce({
|
||||
from: vi.fn().mockReturnValue({ where: vi.fn().mockResolvedValue(tooFew) }),
|
||||
}),
|
||||
});
|
||||
|
||||
const sim = new DartsSimulator();
|
||||
await expect(sim.simulate("season-1")).rejects.toThrow(/at least 2 participants/);
|
||||
});
|
||||
});
|
||||
629
app/services/simulations/darts-simulator.ts
Normal file
629
app/services/simulations/darts-simulator.ts
Normal file
|
|
@ -0,0 +1,629 @@
|
|||
/**
|
||||
* PDC World Darts Championship Simulator
|
||||
*
|
||||
* Monte Carlo simulation of the PDC World Darts Championship.
|
||||
* The tournament is a 128-player single-elimination bracket with 7 rounds,
|
||||
* using best-of-sets formats that increase in length each round.
|
||||
*
|
||||
* Algorithm:
|
||||
* 1. Load all participants and their Elo + world ranking from participantExpectedValues.
|
||||
* 2. Two simulation paths:
|
||||
* a. Bracket populated: simulate from actual draw, respecting completed matches.
|
||||
* b. Pre-bracket: top 32 seeds placed into fixed balanced bracket positions;
|
||||
* remaining 96 players randomly drawn into unseeded slots each simulation.
|
||||
* 3. Compute per-set win probability using the logistic sigmoid:
|
||||
* p_set = 1 / (1 + e^(-(Elo1 - Elo2) / ELO_DIVISOR))
|
||||
* 4. Compute match win probability using the Bernoulli sets model:
|
||||
* P(win) = sum_{w2=0}^{S-1} C(S-1+w2, w2) * p^S * (1-p)^w2
|
||||
* where S = sets to win, which varies by round.
|
||||
* 5. Track integer placement counts per tier across 50,000 simulations.
|
||||
* 6. Convert to probability distributions using exact denominators (column sums = 1.0).
|
||||
*
|
||||
* Round format (PDC World Championship):
|
||||
* R1 (R128): best-of-3 sets, first to 2
|
||||
* R2 (R64): best-of-5 sets, first to 3
|
||||
* R3 (R32): best-of-5 sets, first to 3
|
||||
* R4 (R16): best-of-7 sets, first to 4
|
||||
* QF: best-of-7 sets, first to 4
|
||||
* SF: best-of-11 sets, first to 6
|
||||
* Final: best-of-13 sets, first to 7
|
||||
*
|
||||
* Seeding (pre-bracket path):
|
||||
* Top 32 players (by world ranking) are seeded into fixed bracket positions
|
||||
* using the standard balanced bracket structure:
|
||||
* R1 seeds: 1v32, 16v17, 9v24, 8v25 (top half) + 5v28, 12v21, 13v20, 4v29
|
||||
* 3v30, 14v19, 11v22, 6v27 (bottom half) + 7v26, 10v23, 15v18, 2v31
|
||||
* Each seed's unseeded opponent slot is randomly filled from the 96 unseeded players
|
||||
* in each simulation run — spreading the draw uncertainty across all simulations.
|
||||
*
|
||||
* Placement bucketing (8-slot probability model):
|
||||
* probFirst → Champion
|
||||
* probSecond → Finalist
|
||||
* probThird/Fourth → SF losers (2/sim)
|
||||
* probFifth–Eighth → QF losers (4/sim)
|
||||
* Earlier rounds → all 0
|
||||
*/
|
||||
|
||||
import { database } from "~/database/context";
|
||||
import { eq, and } from "drizzle-orm";
|
||||
import * as schema from "~/database/schema";
|
||||
import type { Simulator, SimulationResult } from "./types";
|
||||
|
||||
// ─── Simulation parameters ────────────────────────────────────────────────────
|
||||
|
||||
const NUM_SIMULATIONS = 50000;
|
||||
|
||||
/**
|
||||
* Controls how much Elo gaps affect per-set win probability.
|
||||
* Higher = softer probabilities (more randomness).
|
||||
* Lower = sharper (Elo differences matter more).
|
||||
*
|
||||
* Standard chess uses 400. Snooker (more random than chess) uses 700.
|
||||
* Darts is moderately volatile; 500 gives:
|
||||
* 100-pt gap → ~55% per set
|
||||
* 300-pt gap → ~63% per set
|
||||
* 500-pt gap → ~73% per set
|
||||
*/
|
||||
const ELO_DIVISOR = 500;
|
||||
|
||||
/**
|
||||
* Sets needed to win per round, in bracket order (R1 first, Final last).
|
||||
* Index 0 = R1/R128 (64 matches, best-of-3, need 2)
|
||||
* Index 1 = R2/R64 (32 matches, best-of-5, need 3)
|
||||
* Index 2 = R3/R32 (16 matches, best-of-5, need 3)
|
||||
* Index 3 = R4/R16 (8 matches, best-of-7, need 4)
|
||||
* Index 4 = QF (4 matches, best-of-7, need 4)
|
||||
* Index 5 = SF (2 matches, best-of-11, need 6)
|
||||
* Index 6 = Final (1 match, best-of-13, need 7)
|
||||
*/
|
||||
const SETS_TO_WIN = [2, 3, 3, 4, 4, 6, 7] as const;
|
||||
|
||||
/**
|
||||
* Number of seeds that get fixed bracket positions.
|
||||
* The remaining (128 - TOP_SEEDS) players are randomly drawn.
|
||||
*/
|
||||
const TOP_SEEDS = 32;
|
||||
|
||||
// ─── Math helpers ──────────────────────────────────────────────────────────────
|
||||
|
||||
/**
|
||||
* Per-set win probability for player 1 vs player 2 based on Elo.
|
||||
* Exported for unit testing.
|
||||
*/
|
||||
export function setWinProb(elo1: number, elo2: number): number {
|
||||
return 1 / (1 + Math.exp(-(elo1 - elo2) / ELO_DIVISOR));
|
||||
}
|
||||
|
||||
/**
|
||||
* Match win probability for player 1 using the Bernoulli sets model.
|
||||
* For a best-of-(2S-1) match (first to S sets):
|
||||
* P(win) = sum_{w2=0}^{S-1} C(S-1+w2, w2) * p^S * (1-p)^w2
|
||||
* Exported for unit testing.
|
||||
*/
|
||||
export function matchWinProb(p: number, setsToWin: number): number {
|
||||
const S = setsToWin;
|
||||
let prob = 0;
|
||||
for (let w2 = 0; w2 < S; w2++) {
|
||||
prob += binomialCoeff(S - 1 + w2, w2) * Math.pow(p, S) * Math.pow(1 - p, w2);
|
||||
}
|
||||
return prob;
|
||||
}
|
||||
|
||||
/** Binomial coefficient C(n, k) via iterative multiplication. */
|
||||
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;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the 128-player seeded bracket R1 pair list.
|
||||
* Each entry is [participantIdA, participantIdB].
|
||||
* Top 32 seeded players fill fixed positions; 96 unseeded players are randomly
|
||||
* shuffled and assigned to the remaining slots.
|
||||
*
|
||||
* Structure:
|
||||
* - 32 seeded-vs-unseeded matches (seeds 1–32 each face a randomly drawn unseeded opponent)
|
||||
* - 32 unseeded-vs-unseeded matches (remaining 64 unseeded players paired randomly)
|
||||
* Total: 64 R1 matches ✓ (128 players)
|
||||
*
|
||||
* Note: in the hot simulation loop, seeded positions are pre-computed via getSeededMatchOrder
|
||||
* and inlined directly — this function is used for testing and bracket-draw path only.
|
||||
*
|
||||
* Exported for unit testing.
|
||||
*/
|
||||
export function buildR1Bracket(
|
||||
seededIds: string[], // exactly 32, index 0 = seed 1
|
||||
unseededIds: string[] // exactly 96, shuffled
|
||||
): Array<[string, string]> {
|
||||
// The 32 seeded players each face one of the first 32 unseeded opponents.
|
||||
// Seeds are arranged in bracket order using the standard balanced structure
|
||||
// for 32 seeds (same algorithm as snooker's R32_BRACKET but generalised).
|
||||
const seededMatchOrder = getSeededMatchOrder(32); // returns 32 seed positions in bracket order
|
||||
|
||||
const pairs: Array<[string, string]> = [];
|
||||
|
||||
// 32 seeded-vs-unseeded R1 matches
|
||||
for (let i = 0; i < 32; i++) {
|
||||
const seedPos = seededMatchOrder[i] - 1; // 0-indexed
|
||||
pairs.push([seededIds[seedPos], unseededIds[i]]);
|
||||
}
|
||||
|
||||
// 32 unseeded-vs-unseeded R1 matches (players 32–95)
|
||||
for (let i = 32; i < 96; i += 2) {
|
||||
pairs.push([unseededIds[i], unseededIds[i + 1]]);
|
||||
}
|
||||
|
||||
return pairs;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns seed positions in standard balanced bracket order for N seeds.
|
||||
* Guarantees seed 1 and seed 2 can only meet in the Final.
|
||||
* E.g. for N=4: [1, 4, 3, 2] → match order 1v4, 3v2 in the top/bottom halves.
|
||||
*
|
||||
* Algorithm: start with [1, 2], repeatedly interleave (n+1 - seed) complements.
|
||||
* Exported for unit testing.
|
||||
*/
|
||||
export function getSeededMatchOrder(n: number): number[] {
|
||||
let order = [1, 2];
|
||||
while (order.length < n) {
|
||||
const size = order.length;
|
||||
const newOrder: number[] = [];
|
||||
for (const seed of order) {
|
||||
newOrder.push(seed);
|
||||
newOrder.push(2 * size + 1 - seed);
|
||||
}
|
||||
order = newOrder;
|
||||
}
|
||||
return order;
|
||||
}
|
||||
|
||||
/** Fisher-Yates shuffle (in-place, returns array). */
|
||||
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;
|
||||
}
|
||||
|
||||
// ─── Simulator ────────────────────────────────────────────────────────────────
|
||||
|
||||
export class DartsSimulator implements Simulator {
|
||||
async simulate(sportsSeasonId: string): Promise<SimulationResult[]> {
|
||||
const db = database();
|
||||
|
||||
// 1. Find the bracket scoring event (if it exists).
|
||||
const bracketEvent = await db.query.scoringEvents.findFirst({
|
||||
where: and(
|
||||
eq(schema.scoringEvents.sportsSeasonId, sportsSeasonId),
|
||||
eq(schema.scoringEvents.eventType, "playoff_game")
|
||||
),
|
||||
});
|
||||
|
||||
// 2. Load playoff matches (empty if bracket hasn't been drawn yet).
|
||||
const allMatches = bracketEvent
|
||||
? await db.query.playoffMatches.findMany({
|
||||
where: eq(schema.playoffMatches.scoringEventId, bracketEvent.id),
|
||||
orderBy: (m, { asc }) => [asc(m.matchNumber)],
|
||||
})
|
||||
: [];
|
||||
|
||||
// 3. Load Elo ratings and world rankings.
|
||||
const evRows = await db
|
||||
.select({
|
||||
participantId: schema.participantExpectedValues.participantId,
|
||||
sourceElo: schema.participantExpectedValues.sourceElo,
|
||||
worldRanking: schema.participantExpectedValues.worldRanking,
|
||||
})
|
||||
.from(schema.participantExpectedValues)
|
||||
.where(eq(schema.participantExpectedValues.sportsSeasonId, sportsSeasonId));
|
||||
|
||||
const eloMap = new Map<string, number>();
|
||||
const rankingMap = new Map<string, number>();
|
||||
for (const r of evRows) {
|
||||
if (r.sourceElo !== null && r.sourceElo !== undefined) {
|
||||
eloMap.set(r.participantId, r.sourceElo);
|
||||
}
|
||||
if (r.worldRanking !== null && r.worldRanking !== undefined) {
|
||||
rankingMap.set(r.participantId, r.worldRanking);
|
||||
}
|
||||
}
|
||||
|
||||
// Determine simulation path.
|
||||
const bracketPopulated = allMatches.some((m) => m.participant1Id && m.participant2Id);
|
||||
|
||||
if (bracketPopulated) {
|
||||
return this.simulateBracket(allMatches, eloMap);
|
||||
} else {
|
||||
return this.simulatePreBracket(sportsSeasonId, eloMap, rankingMap, db);
|
||||
}
|
||||
}
|
||||
|
||||
// ─── Path A: Bracket drawn ────────────────────────────────────────────────
|
||||
|
||||
private async simulateBracket(
|
||||
allMatches: Awaited<ReturnType<ReturnType<typeof database>["query"]["playoffMatches"]["findMany"]>>,
|
||||
eloMap: Map<string, number>
|
||||
): Promise<SimulationResult[]> {
|
||||
// Group matches by round, sorted by match count descending (R1 first = most matches).
|
||||
const byRound = new Map<string, typeof allMatches>();
|
||||
for (const m of allMatches) {
|
||||
if (!byRound.has(m.round)) byRound.set(m.round, []);
|
||||
byRound.get(m.round)?.push(m);
|
||||
}
|
||||
|
||||
const sortedRounds = [...byRound.values()]
|
||||
.toSorted((a, b) => b.length - a.length)
|
||||
.map((matches) => matches.sort((a, b) => a.matchNumber - b.matchNumber));
|
||||
|
||||
if (sortedRounds.length !== 7) {
|
||||
throw new Error(
|
||||
`Expected 7 rounds for PDC World Darts Championship, found ${sortedRounds.length}. ` +
|
||||
`Rounds: ${[...byRound.keys()].join(", ")}`
|
||||
);
|
||||
}
|
||||
|
||||
const [r1Matches, r2Matches, r3Matches, r4Matches, qfMatches, sfMatches, finalMatches] = sortedRounds;
|
||||
|
||||
if (r1Matches.length !== 64) {
|
||||
throw new Error(
|
||||
`Expected 64 R1 matches (128-player bracket), found ${r1Matches.length}.`
|
||||
);
|
||||
}
|
||||
|
||||
// Collect all 128 participant IDs from R1.
|
||||
const participantIds: string[] = [];
|
||||
for (const m of r1Matches) {
|
||||
if (!m.participant1Id || !m.participant2Id) {
|
||||
throw new Error(
|
||||
`R1 match ${m.matchNumber} is missing participants. ` +
|
||||
`Assign all 128 players to the bracket before running simulation.`
|
||||
);
|
||||
}
|
||||
participantIds.push(m.participant1Id, m.participant2Id);
|
||||
}
|
||||
|
||||
const fallbackElo = 1600;
|
||||
|
||||
// Cache matchWinProb — Elo values are fixed across simulations.
|
||||
const matchProbCache = new Map<string, number>();
|
||||
const simMatch = (p1: string, p2: string, setsToWin: number): { winner: string; loser: string } => {
|
||||
const elo1 = eloMap.get(p1) ?? fallbackElo;
|
||||
const elo2 = eloMap.get(p2) ?? fallbackElo;
|
||||
const cacheKey = `${elo1},${elo2},${setsToWin}`;
|
||||
let winProb = matchProbCache.get(cacheKey);
|
||||
if (winProb === undefined) {
|
||||
winProb = matchWinProb(setWinProb(elo1, elo2), setsToWin);
|
||||
matchProbCache.set(cacheKey, winProb);
|
||||
}
|
||||
const winner = Math.random() < winProb ? p1 : p2;
|
||||
return { winner, loser: winner === p1 ? p2 : p1 };
|
||||
};
|
||||
|
||||
const r1ByNum = new Map(r1Matches.map((m) => [m.matchNumber, m]));
|
||||
const r2ByNum = new Map(r2Matches.map((m) => [m.matchNumber, m]));
|
||||
const r3ByNum = new Map(r3Matches.map((m) => [m.matchNumber, m]));
|
||||
const r4ByNum = new Map(r4Matches.map((m) => [m.matchNumber, m]));
|
||||
const qfByNum = new Map(qfMatches.map((m) => [m.matchNumber, m]));
|
||||
const sfByNum = new Map(sfMatches.map((m) => [m.matchNumber, m]));
|
||||
const finalMatch = finalMatches[0];
|
||||
|
||||
const championCounts = new Map<string, number>(participantIds.map((id) => [id, 0]));
|
||||
const finalistCounts = new Map<string, number>(participantIds.map((id) => [id, 0]));
|
||||
const sfLoserCounts = new Map<string, number>(participantIds.map((id) => [id, 0]));
|
||||
const qfLoserCounts = new Map<string, number>(participantIds.map((id) => [id, 0]));
|
||||
|
||||
for (let s = 0; s < NUM_SIMULATIONS; s++) {
|
||||
// R1 (64 matches)
|
||||
const r1Winners: string[] = [];
|
||||
for (let i = 1; i <= 64; i++) {
|
||||
const m = r1ByNum.get(i);
|
||||
if (!m) continue;
|
||||
if (m.isComplete && m.winnerId) {
|
||||
r1Winners.push(m.winnerId);
|
||||
} else {
|
||||
const { winner } = simMatch(m.participant1Id ?? "", m.participant2Id ?? "", SETS_TO_WIN[0]);
|
||||
r1Winners.push(winner);
|
||||
}
|
||||
}
|
||||
|
||||
// R2 (32 matches)
|
||||
const r2Winners: string[] = [];
|
||||
for (let i = 1; i <= 32; i++) {
|
||||
const dbMatch = r2ByNum.get(i);
|
||||
let winner: string;
|
||||
if (dbMatch?.isComplete && dbMatch.winnerId) {
|
||||
winner = dbMatch.winnerId;
|
||||
} else {
|
||||
const p1 = r1Winners[(i - 1) * 2];
|
||||
const p2 = r1Winners[(i - 1) * 2 + 1];
|
||||
({ winner } = simMatch(p1, p2, SETS_TO_WIN[1]));
|
||||
}
|
||||
r2Winners.push(winner);
|
||||
}
|
||||
|
||||
// R3 (16 matches)
|
||||
const r3Winners: string[] = [];
|
||||
for (let i = 1; i <= 16; i++) {
|
||||
const dbMatch = r3ByNum.get(i);
|
||||
let winner: string;
|
||||
if (dbMatch?.isComplete && dbMatch.winnerId) {
|
||||
winner = dbMatch.winnerId;
|
||||
} else {
|
||||
const p1 = r2Winners[(i - 1) * 2];
|
||||
const p2 = r2Winners[(i - 1) * 2 + 1];
|
||||
({ winner } = simMatch(p1, p2, SETS_TO_WIN[2]));
|
||||
}
|
||||
r3Winners.push(winner);
|
||||
}
|
||||
|
||||
// R4 (8 matches)
|
||||
const r4Winners: string[] = [];
|
||||
for (let i = 1; i <= 8; i++) {
|
||||
const dbMatch = r4ByNum.get(i);
|
||||
let winner: string;
|
||||
if (dbMatch?.isComplete && dbMatch.winnerId) {
|
||||
winner = dbMatch.winnerId;
|
||||
} else {
|
||||
const p1 = r3Winners[(i - 1) * 2];
|
||||
const p2 = r3Winners[(i - 1) * 2 + 1];
|
||||
({ winner } = simMatch(p1, p2, SETS_TO_WIN[3]));
|
||||
}
|
||||
r4Winners.push(winner);
|
||||
}
|
||||
|
||||
// QF (4 matches)
|
||||
const qfWinners: string[] = [];
|
||||
for (let i = 1; i <= 4; i++) {
|
||||
const dbMatch = qfByNum.get(i);
|
||||
let winner: string;
|
||||
let loser: string;
|
||||
if (dbMatch?.isComplete && dbMatch.winnerId && dbMatch.loserId) {
|
||||
winner = dbMatch.winnerId;
|
||||
loser = dbMatch.loserId;
|
||||
} else {
|
||||
const p1 = r4Winners[(i - 1) * 2];
|
||||
const p2 = r4Winners[(i - 1) * 2 + 1];
|
||||
({ winner, loser } = simMatch(p1, p2, SETS_TO_WIN[4]));
|
||||
}
|
||||
qfWinners.push(winner);
|
||||
qfLoserCounts.set(loser, (qfLoserCounts.get(loser) ?? 0) + 1);
|
||||
}
|
||||
|
||||
// SF (2 matches)
|
||||
const sfWinners: string[] = [];
|
||||
for (let i = 1; i <= 2; i++) {
|
||||
const dbMatch = sfByNum.get(i);
|
||||
let winner: string;
|
||||
let loser: string;
|
||||
if (dbMatch?.isComplete && dbMatch.winnerId && dbMatch.loserId) {
|
||||
winner = dbMatch.winnerId;
|
||||
loser = dbMatch.loserId;
|
||||
} else {
|
||||
const p1 = qfWinners[(i - 1) * 2];
|
||||
const p2 = qfWinners[(i - 1) * 2 + 1];
|
||||
({ winner, loser } = simMatch(p1, p2, SETS_TO_WIN[5]));
|
||||
}
|
||||
sfWinners.push(winner);
|
||||
sfLoserCounts.set(loser, (sfLoserCounts.get(loser) ?? 0) + 1);
|
||||
}
|
||||
|
||||
// Final
|
||||
let champion: string;
|
||||
let finalist: string;
|
||||
if (finalMatch?.isComplete && finalMatch.winnerId && finalMatch.loserId) {
|
||||
champion = finalMatch.winnerId;
|
||||
finalist = finalMatch.loserId;
|
||||
} else {
|
||||
({ winner: champion, loser: finalist } = simMatch(sfWinners[0], sfWinners[1], SETS_TO_WIN[6]));
|
||||
}
|
||||
championCounts.set(champion, (championCounts.get(champion) ?? 0) + 1);
|
||||
finalistCounts.set(finalist, (finalistCounts.get(finalist) ?? 0) + 1);
|
||||
}
|
||||
|
||||
return buildResults(participantIds, NUM_SIMULATIONS, {
|
||||
championCounts,
|
||||
finalistCounts,
|
||||
sfLoserCounts,
|
||||
qfLoserCounts,
|
||||
});
|
||||
}
|
||||
|
||||
// ─── Path B: Pre-bracket simulation ──────────────────────────────────────────
|
||||
// Top 32 seeds are placed into fixed bracket positions.
|
||||
// Remaining 96 players are randomly drawn into unseeded slots each simulation.
|
||||
|
||||
private async simulatePreBracket(
|
||||
sportsSeasonId: string,
|
||||
eloMap: Map<string, number>,
|
||||
rankingMap: Map<string, number>,
|
||||
db: ReturnType<typeof database>
|
||||
): Promise<SimulationResult[]> {
|
||||
const allParticipants = await db
|
||||
.select({ id: schema.participants.id, name: schema.participants.name })
|
||||
.from(schema.participants)
|
||||
.where(eq(schema.participants.sportsSeasonId, sportsSeasonId));
|
||||
|
||||
if (allParticipants.length < 2) {
|
||||
throw new Error(
|
||||
`Pre-bracket simulation requires at least 2 participants (got ${allParticipants.length}). ` +
|
||||
`Add players to this sports season first.`
|
||||
);
|
||||
}
|
||||
|
||||
const fallbackElo = 1600;
|
||||
|
||||
// Sort participants by world ranking (ascending). Fall back to Elo order (descending) for
|
||||
// any without a ranking, then alphabetical as a final tiebreak.
|
||||
const sorted = [...allParticipants].toSorted((a, b) => {
|
||||
const rankA = rankingMap.get(a.id);
|
||||
const rankB = rankingMap.get(b.id);
|
||||
if (rankA !== undefined && rankB !== undefined) return rankA - rankB;
|
||||
if (rankA !== undefined) return -1; // ranked before unranked
|
||||
if (rankB !== undefined) return 1;
|
||||
// Both unranked — sort by Elo descending
|
||||
return (eloMap.get(b.id) ?? fallbackElo) - (eloMap.get(a.id) ?? fallbackElo);
|
||||
});
|
||||
|
||||
const topSeeds = sorted.slice(0, TOP_SEEDS).map((p) => p.id); // seeds 1–32
|
||||
const unseeded = sorted.slice(TOP_SEEDS).map((p) => p.id); // remaining players
|
||||
|
||||
const allParticipantIds = allParticipants.map((p) => p.id);
|
||||
const championCounts = new Map<string, number>(allParticipantIds.map((id) => [id, 0]));
|
||||
const finalistCounts = new Map<string, number>(allParticipantIds.map((id) => [id, 0]));
|
||||
const sfLoserCounts = new Map<string, number>(allParticipantIds.map((id) => [id, 0]));
|
||||
const qfLoserCounts = new Map<string, number>(allParticipantIds.map((id) => [id, 0]));
|
||||
|
||||
// Cache set-level probabilities — fixed across all simulations.
|
||||
const matchProbCache = new Map<string, number>();
|
||||
const simMatch = (p1Id: string, p2Id: string, setsToWin: number): string => {
|
||||
const elo1 = eloMap.get(p1Id) ?? fallbackElo;
|
||||
const elo2 = eloMap.get(p2Id) ?? fallbackElo;
|
||||
const cacheKey = `${elo1},${elo2},${setsToWin}`;
|
||||
let winProb = matchProbCache.get(cacheKey);
|
||||
if (winProb === undefined) {
|
||||
winProb = matchWinProb(setWinProb(elo1, elo2), setsToWin);
|
||||
matchProbCache.set(cacheKey, winProb);
|
||||
}
|
||||
return Math.random() < winProb ? p1Id : p2Id;
|
||||
};
|
||||
|
||||
// Pre-compute fixed seeded bracket positions once — only the unseeded draw changes per sim.
|
||||
const seededMatchOrder = getSeededMatchOrder(TOP_SEEDS);
|
||||
const seededSlots = seededMatchOrder.map(seed => topSeeds[seed - 1]);
|
||||
|
||||
// Pad unseeded pool to 96 once before the loop.
|
||||
// In practice the admin should always load 128 players; this guards against edge cases.
|
||||
const unseededPool = [...unseeded];
|
||||
while (unseededPool.length + topSeeds.length < 128) {
|
||||
unseededPool.push(`__bye_${unseededPool.length}`);
|
||||
}
|
||||
|
||||
for (let s = 0; s < NUM_SIMULATIONS; s++) {
|
||||
// Draw: shuffle the unseeded pool — seeded positions are pre-computed.
|
||||
const drawnUnseeded = shuffle([...unseededPool]);
|
||||
|
||||
// Build R1 pairs inline using pre-computed seeded slots.
|
||||
const r1Pairs: Array<[string, string]> = [];
|
||||
for (let i = 0; i < TOP_SEEDS; i++) {
|
||||
r1Pairs.push([seededSlots[i], drawnUnseeded[i]]);
|
||||
}
|
||||
for (let i = TOP_SEEDS; i < drawnUnseeded.length; i += 2) {
|
||||
r1Pairs.push([drawnUnseeded[i], drawnUnseeded[i + 1]]);
|
||||
}
|
||||
|
||||
// R1 (64 matches)
|
||||
const r1Winners: string[] = [];
|
||||
for (const [p1, p2] of r1Pairs) {
|
||||
r1Winners.push(simMatch(p1, p2, SETS_TO_WIN[0]));
|
||||
}
|
||||
|
||||
// R2–R4 (32 / 16 / 8 matches)
|
||||
const r2Winners: string[] = [];
|
||||
for (let i = 0; i < r1Winners.length; i += 2) {
|
||||
r2Winners.push(simMatch(r1Winners[i], r1Winners[i + 1], SETS_TO_WIN[1]));
|
||||
}
|
||||
const r3Winners: string[] = [];
|
||||
for (let i = 0; i < r2Winners.length; i += 2) {
|
||||
r3Winners.push(simMatch(r2Winners[i], r2Winners[i + 1], SETS_TO_WIN[2]));
|
||||
}
|
||||
const r4Winners: string[] = [];
|
||||
for (let i = 0; i < r3Winners.length; i += 2) {
|
||||
r4Winners.push(simMatch(r3Winners[i], r3Winners[i + 1], SETS_TO_WIN[3]));
|
||||
}
|
||||
|
||||
// QF (4 matches)
|
||||
const qfWinners: string[] = [];
|
||||
for (let i = 0; i < r4Winners.length; i += 2) {
|
||||
const p1 = r4Winners[i], p2 = r4Winners[i + 1];
|
||||
const winner = simMatch(p1, p2, SETS_TO_WIN[4]);
|
||||
const loser = winner === p1 ? p2 : p1;
|
||||
qfWinners.push(winner);
|
||||
qfLoserCounts.set(loser, (qfLoserCounts.get(loser) ?? 0) + 1);
|
||||
}
|
||||
|
||||
// SF (2 matches)
|
||||
const sfWinners: string[] = [];
|
||||
for (let i = 0; i < qfWinners.length; i += 2) {
|
||||
const p1 = qfWinners[i], p2 = qfWinners[i + 1];
|
||||
const winner = simMatch(p1, p2, SETS_TO_WIN[5]);
|
||||
const loser = winner === p1 ? p2 : p1;
|
||||
sfWinners.push(winner);
|
||||
sfLoserCounts.set(loser, (sfLoserCounts.get(loser) ?? 0) + 1);
|
||||
}
|
||||
|
||||
// Final
|
||||
const champion = simMatch(sfWinners[0], sfWinners[1], SETS_TO_WIN[6]);
|
||||
const finalist = champion === sfWinners[0] ? sfWinners[1] : sfWinners[0];
|
||||
championCounts.set(champion, (championCounts.get(champion) ?? 0) + 1);
|
||||
finalistCounts.set(finalist, (finalistCounts.get(finalist) ?? 0) + 1);
|
||||
}
|
||||
|
||||
return buildResults(allParticipantIds, NUM_SIMULATIONS, {
|
||||
championCounts,
|
||||
finalistCounts,
|
||||
sfLoserCounts,
|
||||
qfLoserCounts,
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
// ─── Shared result builder ─────────────────────────────────────────────────────
|
||||
|
||||
function buildResults(
|
||||
participantIds: string[],
|
||||
N: number,
|
||||
counts: {
|
||||
championCounts: Map<string, number>;
|
||||
finalistCounts: Map<string, number>;
|
||||
sfLoserCounts: Map<string, number>;
|
||||
qfLoserCounts: Map<string, number>;
|
||||
}
|
||||
): SimulationResult[] {
|
||||
const { championCounts, finalistCounts, sfLoserCounts, qfLoserCounts } = counts;
|
||||
|
||||
const results: SimulationResult[] = participantIds.map((participantId) => {
|
||||
const c = championCounts.get(participantId) ?? 0;
|
||||
const f = finalistCounts.get(participantId) ?? 0;
|
||||
const sf = sfLoserCounts.get(participantId) ?? 0;
|
||||
const qf = qfLoserCounts.get(participantId) ?? 0;
|
||||
return {
|
||||
participantId,
|
||||
probabilities: {
|
||||
probFirst: c / N,
|
||||
probSecond: f / N,
|
||||
probThird: sf / (2 * N),
|
||||
probFourth: sf / (2 * N),
|
||||
probFifth: qf / (4 * N),
|
||||
probSixth: qf / (4 * N),
|
||||
probSeventh: qf / (4 * N),
|
||||
probEighth: qf / (4 * N),
|
||||
},
|
||||
source: "darts_world_championship_monte_carlo",
|
||||
};
|
||||
});
|
||||
|
||||
// Per-position column normalisation — ensures sums are exactly 1.0.
|
||||
const positionKeys: Array<keyof typeof results[0]["probabilities"]> = [
|
||||
"probFirst", "probSecond", "probThird", "probFourth",
|
||||
"probFifth", "probSixth", "probSeventh", "probEighth",
|
||||
];
|
||||
for (const key of positionKeys) {
|
||||
const colSum = results.reduce((s, r) => s + r.probabilities[key], 0);
|
||||
const residual = 1.0 - colSum;
|
||||
if (residual !== 0) {
|
||||
const maxResult = results.reduce((best, r) =>
|
||||
r.probabilities[key] > best.probabilities[key] ? r : best
|
||||
);
|
||||
maxResult.probabilities[key] += residual;
|
||||
}
|
||||
}
|
||||
|
||||
return results;
|
||||
}
|
||||
|
|
@ -18,6 +18,7 @@ import { NHLSimulator } from "./nhl-simulator";
|
|||
import { AFLSimulator } from "./afl-simulator";
|
||||
import { SnookerSimulator } from "./snooker-simulator";
|
||||
import { TennisSimulator } from "./tennis-simulator";
|
||||
import { DartsSimulator } from "./darts-simulator";
|
||||
import { MLBSimulator } from "./mlb-simulator";
|
||||
import { WNBASimulator } from "./wnba-simulator";
|
||||
import { WorldCupSimulator } from "./world-cup-simulator";
|
||||
|
|
@ -38,6 +39,7 @@ export const SIMULATOR_TYPES = [
|
|||
"mlb_bracket",
|
||||
"wnba_bracket",
|
||||
"world_cup",
|
||||
"darts_bracket",
|
||||
] as const;
|
||||
|
||||
export type SimulatorType = typeof SIMULATOR_TYPES[number];
|
||||
|
|
@ -122,6 +124,10 @@ const REGISTRY: Record<SimulatorType, { info: SimulatorInfo; create: () => Simul
|
|||
info: { name: "FIFA World Cup 2026 Monte Carlo", description: "Simulates the full 48-team World Cup: round-robin group stage (12 groups), best-8 third-place selection, R32→R16→QF→SF→3rd place game→Final. Uses blended Elo + futures odds." },
|
||||
create: () => new WorldCupSimulator(),
|
||||
},
|
||||
darts_bracket: {
|
||||
info: { name: "PDC World Darts Championship Monte Carlo", description: "Simulates the 128-player World Darts Championship bracket using set-level Bernoulli win probability and Elo ratings. Top 32 seeds placed in fixed positions; remaining 96 players randomly drawn per simulation." },
|
||||
create: () => new DartsSimulator(),
|
||||
},
|
||||
};
|
||||
|
||||
export function getSimulator(simulatorType: SimulatorType): Simulator {
|
||||
|
|
|
|||
|
|
@ -98,6 +98,7 @@ export const simulatorTypeEnum = pgEnum("simulator_type", [
|
|||
"mlb_bracket",
|
||||
"wnba_bracket",
|
||||
"world_cup",
|
||||
"darts_bracket",
|
||||
]);
|
||||
|
||||
export const playoffMatchGameStatusEnum = pgEnum("playoff_match_game_status", [
|
||||
|
|
@ -588,7 +589,8 @@ export const participantExpectedValues = pgTable("participant_expected_values",
|
|||
// Metadata
|
||||
source: probabilitySourceEnum("source").default("manual"), // How probabilities were generated
|
||||
sourceOdds: integer("source_odds"), // Original odds if source is futures_odds (American odds format)
|
||||
sourceElo: integer("source_elo"), // Raw Elo rating if source is elo-based simulator (e.g. snooker_bracket)
|
||||
sourceElo: integer("source_elo"), // Raw Elo rating if source is elo-based simulator (e.g. snooker_bracket, darts_bracket)
|
||||
worldRanking: integer("world_ranking"), // World ranking for sports that use it for bracket seeding (e.g. darts_bracket)
|
||||
calculatedAt: timestamp("calculated_at").defaultNow().notNull(),
|
||||
updatedAt: timestamp("updated_at").defaultNow().notNull(),
|
||||
}, (t) => ({
|
||||
|
|
|
|||
2
drizzle/0067_darts_bracket.sql
Normal file
2
drizzle/0067_darts_bracket.sql
Normal file
|
|
@ -0,0 +1,2 @@
|
|||
ALTER TYPE "public"."simulator_type" ADD VALUE 'darts_bracket';--> statement-breakpoint
|
||||
ALTER TABLE "participant_expected_values" ADD COLUMN "world_ranking" integer;
|
||||
4346
drizzle/meta/0067_snapshot.json
Normal file
4346
drizzle/meta/0067_snapshot.json
Normal file
File diff suppressed because it is too large
Load diff
|
|
@ -470,6 +470,13 @@
|
|||
"when": 1774802533652,
|
||||
"tag": "0066_stiff_siren",
|
||||
"breakpoints": true
|
||||
},
|
||||
{
|
||||
"idx": 67,
|
||||
"version": "7",
|
||||
"when": 1774900000000,
|
||||
"tag": "0067_darts_bracket",
|
||||
"breakpoints": true
|
||||
}
|
||||
]
|
||||
}
|
||||
Loading…
Add table
Reference in a new issue