b566c5f1a5
The two Wildcard Round winners were crossed into the Elimination Finals by which game they came out of — the 7v10 winner always met 6th and the 8v9 winner always met 5th. The AFL pairs those games by ladder position, as the classic final eight pairs 5v8 and 6v7: the higher host draws the lower-ranked survivor. So when 10th wins through, 5th should meet 10th, not the 8v9 winner. Placement now resolves both games together. A 7v10 winner is placed as soon as it is decided (7th outranks either possible opponent, 10th is outranked by both), while an 8v9 winner is held until the other game is decided rather than being placed and later moved, so results can be entered in either order. The simulator paired the Elimination Finals the same fixed way, which biased every projection that ran off an undecided Wildcard Round; it now re-seeds too. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01VDbHrCce1UhahbkwKkc7hK
1330 lines
41 KiB
TypeScript
1330 lines
41 KiB
TypeScript
/**
|
||
* Bracket Template System
|
||
*
|
||
* Defines pre-configured tournament bracket structures for various sports.
|
||
* Templates specify rounds, match counts, and which rounds contribute to fantasy scoring.
|
||
*/
|
||
|
||
export interface BracketRound {
|
||
/** Display name for this round (e.g., "First Four", "Elite Eight") */
|
||
name: string;
|
||
/** Number of matches in this round */
|
||
matchCount: number;
|
||
/** Name of the round that winners advance to (null for championship) */
|
||
feedsInto: string | null;
|
||
/** Whether this round affects fantasy points (false = 0 points per Q20) */
|
||
isScoring: boolean;
|
||
/**
|
||
* Name of the round that *losers* advance to (e.g., "Third Place Game" for SF losers).
|
||
* When set, the loser of each match in this round is placed into the target round.
|
||
*/
|
||
loserFeedsInto?: string | null;
|
||
/**
|
||
* Floor position banked by the WINNER of a *non-scoring* round.
|
||
*
|
||
* Omit for the default behavior: winners entering the first scoring round bank a
|
||
* T5–T8 floor (position 5), everyone else banks nothing. Set an explicit number when
|
||
* that default is wrong — in a double-elimination losers bracket a win can guarantee
|
||
* a worse finish than 5th (llws_20 "Elimination Round 3" → 7). Set null to bank no
|
||
* floor even though the next round scores.
|
||
*
|
||
* Has no effect on scoring rounds, which use RoundScoringConfig.winnerFloor instead.
|
||
*/
|
||
nonScoringWinnerFloor?: number | null;
|
||
/**
|
||
* Floor position every team is guaranteed simply by being *seeded into* this
|
||
* round when the bracket is generated — before a single match is played.
|
||
*
|
||
* Omit (the default) for rounds where entering guarantees nothing: a team that
|
||
* loses its first match earns 0. Set a number when the bracket structure locks
|
||
* in a scoring tier on entry — e.g. afl_10's Qualifying Finals, where the loser
|
||
* still gets a Semi-Final and so cannot finish worse than the 5th-6th tier.
|
||
*
|
||
* Only teams actually assigned to a match slot at generation receive this floor;
|
||
* TBD slots filled later by advancing winners get their floor from the round they
|
||
* won (nonScoringWinnerFloor / RoundScoringConfig.winnerFloor) instead.
|
||
*/
|
||
entryFloor?: number | null;
|
||
}
|
||
|
||
export interface GroupStageConfig {
|
||
/** Number of groups */
|
||
groupCount: number;
|
||
/** Teams per group */
|
||
teamsPerGroup: number;
|
||
/** Group labels (e.g., ["A", "B", ..., "L"]) */
|
||
groupLabels: string[];
|
||
}
|
||
|
||
/**
|
||
* A play-in game within a bracket region (e.g., NCAA First Four).
|
||
* Two teams compete; the winner fills a specific seed slot in the main bracket.
|
||
*/
|
||
export interface BracketPlayIn {
|
||
/** Which seed slot the winner fills (e.g., 11 or 16) */
|
||
seedSlot: number;
|
||
/** Number of teams in this play-in game (always 2) */
|
||
teams: 2;
|
||
}
|
||
|
||
/**
|
||
* A named region within a bracket (e.g., NCAA "East", "South").
|
||
* Each region contributes exactly 16 teams to the Round of 64.
|
||
*/
|
||
export interface BracketRegion {
|
||
/** Display name (e.g., "East", "South") */
|
||
name: string;
|
||
/**
|
||
* Seed numbers that enter the region directly (no play-in).
|
||
* Must be ascending and contain every seed 1–16 except those covered by playIns.
|
||
* Length = 16 - playIns.length.
|
||
*/
|
||
directSeeds: number[];
|
||
/**
|
||
* Play-in games for this region. Order here determines the order their teams
|
||
* appear in the participant array (after all direct-seed teams across all regions).
|
||
*/
|
||
playIns: BracketPlayIn[];
|
||
}
|
||
|
||
/**
|
||
* Defines a named conference or sub-bracket group within a bracket.
|
||
* Used to split matches into East/West (NBA) or regional groups (NCAA) for display.
|
||
*/
|
||
export interface ConferenceGroup {
|
||
/** Display name, e.g. "Eastern Conference" */
|
||
name: string;
|
||
/**
|
||
* Maps round name → the match numbers (1-based) that belong to this conference.
|
||
* Rounds not listed here are either shared (Finals) or not applicable.
|
||
*/
|
||
roundMatchNumbers: Record<string, number[]>;
|
||
}
|
||
|
||
/**
|
||
* A named tab/section within a bracket display.
|
||
* Either shows a simple list of rounds, or a set of conference/regional sub-brackets.
|
||
*/
|
||
export interface BracketPhase {
|
||
/** Tab label */
|
||
name: string;
|
||
/** Simple ordered list of round names to show in this tab */
|
||
rounds?: string[];
|
||
/** Regional/conference sub-groups to show stacked in this tab */
|
||
groups?: ConferenceGroup[];
|
||
/** Rounds rendered after groups (e.g. Final Four, Championship) */
|
||
sharedRounds?: string[];
|
||
/** Custom rendering layout for special phases */
|
||
layout?: "play-in";
|
||
}
|
||
|
||
export interface BracketTemplate {
|
||
/** Unique identifier for this template */
|
||
id: string;
|
||
/** Human-readable name */
|
||
name: string;
|
||
/** Total number of teams in the bracket */
|
||
totalTeams: number;
|
||
/** Ordered list of rounds from earliest to championship */
|
||
rounds: BracketRound[];
|
||
/** Round name where fantasy scoring begins */
|
||
scoringStartsAtRound: string;
|
||
/** Optional group stage configuration (e.g., FIFA World Cup) */
|
||
groupStage?: GroupStageConfig;
|
||
/** Number of teams advancing to knockout stage (when groupStage is defined) */
|
||
knockoutTeams?: number;
|
||
/**
|
||
* Optional named region config. When present, the participant array for bracket
|
||
* generation is structured as: all direct seeds region-by-region in order, then
|
||
* all play-in teams grouped by region (and play-in order within each region).
|
||
*/
|
||
regions?: BracketRegion[];
|
||
/**
|
||
* Optional human-readable labels for each participant slot (0-indexed).
|
||
* When provided, the admin bracket UI shows these labels instead of "Seed N".
|
||
* Length must equal totalTeams.
|
||
*/
|
||
participantLabels?: string[];
|
||
/**
|
||
* Optional conference/group split for brackets with parallel sub-brackets (NBA).
|
||
* When present, the UI renders each group as a separate sub-bracket.
|
||
* Rounds not listed in any group's roundMatchNumbers are treated as shared (e.g., Finals).
|
||
*/
|
||
conferenceGroups?: ConferenceGroup[];
|
||
/**
|
||
* Optional tabbed phase display (NCAA).
|
||
* When present, the UI renders a tab switcher with each phase as a section.
|
||
*/
|
||
phases?: BracketPhase[];
|
||
}
|
||
|
||
/** All seed numbers in a standard 16-team regional bracket (1–16) */
|
||
export const ALL_16_SEEDS: number[] = [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16];
|
||
|
||
// Standard seeding order for a 16-team regional bracket
|
||
// Each entry is [higherSeed, lowerSeed] (lower number = better seed)
|
||
export const STANDARD_BRACKET_SEEDING: [number, number][] = [
|
||
[1, 16], [8, 9], [5, 12], [4, 13], [6, 11], [3, 14], [7, 10], [2, 15],
|
||
];
|
||
|
||
/**
|
||
* Returns the 0-indexed position within the standard 8-match bracket order
|
||
* for a given seed slot. Used to compute which Round of 64 match a play-in
|
||
* winner advances to.
|
||
*
|
||
* Standard order: 1v16, 8v9, 5v12, 4v13, 6v11, 3v14, 7v10, 2v15
|
||
*/
|
||
export function matchIndexForSeedSlot(seedSlot: number): number {
|
||
for (let i = 0; i < STANDARD_BRACKET_SEEDING.length; i++) {
|
||
if (STANDARD_BRACKET_SEEDING[i].includes(seedSlot)) return i;
|
||
}
|
||
throw new Error(`Seed slot ${seedSlot} not found in standard bracket seeding`);
|
||
}
|
||
|
||
export interface NCAA68SlotMap {
|
||
/** Start index in participantIds for each region's direct seeds */
|
||
directOffsets: number[];
|
||
/** Ordered list of all play-ins, with participant index info and region context */
|
||
playInOffsets: Array<{
|
||
regionIndex: number;
|
||
playInIndex: number;
|
||
/** Index of the first team in this play-in within participantIds */
|
||
startIndex: number;
|
||
seedSlot: number;
|
||
}>;
|
||
totalDirect: number;
|
||
totalPlayIn: number;
|
||
}
|
||
|
||
/**
|
||
* Computes the participant array slot mapping for an NCAA-style bracket with regions.
|
||
*
|
||
* Participant array layout:
|
||
* [region 0 direct seeds] [region 1 direct seeds] ... [region N direct seeds]
|
||
* [region 0 play-in 0 team A, team B] [region 0 play-in 1 team A, team B] ...
|
||
* [region 1 play-in 0 team A, team B] ...
|
||
*
|
||
* This layout is shared between the server (bracket generation) and the client
|
||
* (form rendering) so both sides agree on which participant{i} maps where.
|
||
*/
|
||
export function buildNCAA68SlotMap(regions: BracketRegion[]): NCAA68SlotMap {
|
||
let cursor = 0;
|
||
const directOffsets: number[] = [];
|
||
|
||
for (const region of regions) {
|
||
directOffsets.push(cursor);
|
||
cursor += region.directSeeds.length;
|
||
}
|
||
|
||
const totalDirect = cursor;
|
||
const playInOffsets: NCAA68SlotMap["playInOffsets"] = [];
|
||
|
||
for (let r = 0; r < regions.length; r++) {
|
||
for (let p = 0; p < regions[r].playIns.length; p++) {
|
||
playInOffsets.push({
|
||
regionIndex: r,
|
||
playInIndex: p,
|
||
startIndex: cursor,
|
||
seedSlot: regions[r].playIns[p].seedSlot,
|
||
});
|
||
cursor += 2;
|
||
}
|
||
}
|
||
|
||
const totalPlayIn = cursor - totalDirect;
|
||
|
||
return { directOffsets, playInOffsets, totalDirect, totalPlayIn };
|
||
}
|
||
|
||
/**
|
||
* Simple 4-team bracket
|
||
* Semifinals → Finals
|
||
* All rounds score fantasy points
|
||
*/
|
||
export const SIMPLE_4: BracketTemplate = {
|
||
id: "simple_4",
|
||
name: "Simple 4-Team Bracket",
|
||
totalTeams: 4,
|
||
scoringStartsAtRound: "Semifinals",
|
||
rounds: [
|
||
{
|
||
name: "Semifinals",
|
||
matchCount: 2,
|
||
feedsInto: "Finals",
|
||
isScoring: true, // Losers share 3rd-4th
|
||
},
|
||
{
|
||
name: "Finals",
|
||
matchCount: 1,
|
||
feedsInto: null,
|
||
isScoring: true, // Winner 1st, Loser 2nd
|
||
},
|
||
],
|
||
};
|
||
|
||
/**
|
||
* Simple 8-team bracket
|
||
* Quarterfinals → Semifinals → Finals
|
||
* All rounds score fantasy points
|
||
*/
|
||
export const SIMPLE_8: BracketTemplate = {
|
||
id: "simple_8",
|
||
name: "Simple 8-Team Bracket",
|
||
totalTeams: 8,
|
||
scoringStartsAtRound: "Quarterfinals",
|
||
rounds: [
|
||
{
|
||
name: "Quarterfinals",
|
||
matchCount: 4,
|
||
feedsInto: "Semifinals",
|
||
isScoring: true, // Losers share 5th-8th
|
||
},
|
||
{
|
||
name: "Semifinals",
|
||
matchCount: 2,
|
||
feedsInto: "Finals",
|
||
isScoring: true, // Losers share 3rd-4th
|
||
},
|
||
{
|
||
name: "Finals",
|
||
matchCount: 1,
|
||
feedsInto: null,
|
||
isScoring: true, // Winner 1st, Loser 2nd
|
||
},
|
||
],
|
||
};
|
||
|
||
/**
|
||
* Simple 16-team bracket
|
||
* Round of 16 → Quarterfinals → Semifinals → Finals
|
||
* Only Quarterfinals and beyond score points (top 8)
|
||
*/
|
||
export const SIMPLE_16: BracketTemplate = {
|
||
id: "simple_16",
|
||
name: "Simple 16-Team Bracket",
|
||
totalTeams: 16,
|
||
scoringStartsAtRound: "Quarterfinals",
|
||
rounds: [
|
||
{
|
||
name: "Round of 16",
|
||
matchCount: 8,
|
||
feedsInto: "Quarterfinals",
|
||
isScoring: false, // Early elimination = 0 points
|
||
},
|
||
{
|
||
name: "Quarterfinals",
|
||
matchCount: 4,
|
||
feedsInto: "Semifinals",
|
||
isScoring: true, // Losers share 5th-8th
|
||
},
|
||
{
|
||
name: "Semifinals",
|
||
matchCount: 2,
|
||
feedsInto: "Finals",
|
||
isScoring: true, // Losers share 3rd-4th
|
||
},
|
||
{
|
||
name: "Finals",
|
||
matchCount: 1,
|
||
feedsInto: null,
|
||
isScoring: true, // Winner 1st, Loser 2nd
|
||
},
|
||
],
|
||
};
|
||
|
||
/**
|
||
* Simple 32-team bracket
|
||
* Round of 32 → Round of 16 → Quarterfinals → Semifinals → Finals
|
||
* Only Quarterfinals and beyond score points (top 8)
|
||
*/
|
||
export const SIMPLE_32: BracketTemplate = {
|
||
id: "simple_32",
|
||
name: "Simple 32-Team Bracket",
|
||
totalTeams: 32,
|
||
scoringStartsAtRound: "Quarterfinals",
|
||
rounds: [
|
||
{
|
||
name: "Round of 32",
|
||
matchCount: 16,
|
||
feedsInto: "Round of 16",
|
||
isScoring: false, // Early elimination = 0 points
|
||
},
|
||
{
|
||
name: "Round of 16",
|
||
matchCount: 8,
|
||
feedsInto: "Quarterfinals",
|
||
isScoring: false, // Early elimination = 0 points
|
||
},
|
||
{
|
||
name: "Quarterfinals",
|
||
matchCount: 4,
|
||
feedsInto: "Semifinals",
|
||
isScoring: true, // Losers share 5th-8th
|
||
},
|
||
{
|
||
name: "Semifinals",
|
||
matchCount: 2,
|
||
feedsInto: "Finals",
|
||
isScoring: true, // Losers share 3rd-4th
|
||
},
|
||
{
|
||
name: "Finals",
|
||
matchCount: 1,
|
||
feedsInto: null,
|
||
isScoring: true, // Winner 1st, Loser 2nd
|
||
},
|
||
],
|
||
};
|
||
|
||
/**
|
||
* NCAA Men's College Hockey Tournament (16 teams)
|
||
* Regional Semifinals → Regional Finals → Frozen Four Semifinals → National Championship
|
||
* Only Regional Finals and beyond score points (top 8).
|
||
*/
|
||
export const COLLEGE_HOCKEY_16: BracketTemplate = {
|
||
id: "college_hockey_16",
|
||
name: "NCAA Men's Hockey Tournament (16 teams)",
|
||
totalTeams: 16,
|
||
scoringStartsAtRound: "Regional Finals",
|
||
rounds: [
|
||
{
|
||
name: "Regional Semifinals",
|
||
matchCount: 8,
|
||
feedsInto: "Regional Finals",
|
||
isScoring: false,
|
||
},
|
||
{
|
||
name: "Regional Finals",
|
||
matchCount: 4,
|
||
feedsInto: "Frozen Four Semifinals",
|
||
isScoring: true,
|
||
},
|
||
{
|
||
name: "Frozen Four Semifinals",
|
||
matchCount: 2,
|
||
feedsInto: "National Championship",
|
||
isScoring: true,
|
||
},
|
||
{
|
||
name: "National Championship",
|
||
matchCount: 1,
|
||
feedsInto: null,
|
||
isScoring: true,
|
||
},
|
||
],
|
||
};
|
||
|
||
/**
|
||
* 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
|
||
},
|
||
],
|
||
};
|
||
|
||
/**
|
||
* Tennis Grand Slam (128-player single-elimination draw)
|
||
* R128 → R64 → R32 → Round of 16 → Quarterfinals → Semifinals → Final
|
||
*
|
||
* Qualifying-points sport: QP is derived from how far each player advances
|
||
* (see TEMPLATE_ROUND_CONFIG["tennis_128"] in scoring-calculator.ts). Scoring
|
||
* begins at the Round of 16 — R16 losers share placements 9–16; earlier rounds
|
||
* award nothing. Seeding: top 32 fixed, remaining 96 randomly drawn.
|
||
*/
|
||
export const TENNIS_128: BracketTemplate = {
|
||
id: "tennis_128",
|
||
name: "Tennis Grand Slam (128 Players)",
|
||
totalTeams: 128,
|
||
scoringStartsAtRound: "Round of 16",
|
||
rounds: [
|
||
{ name: "Round of 128", matchCount: 64, feedsInto: "Round of 64", isScoring: false },
|
||
{ name: "Round of 64", matchCount: 32, feedsInto: "Round of 32", isScoring: false },
|
||
{ name: "Round of 32", matchCount: 16, feedsInto: "Round of 16", isScoring: false },
|
||
{ name: "Round of 16", matchCount: 8, feedsInto: "Quarterfinals", isScoring: true }, // losers share 9th–16th
|
||
{ name: "Quarterfinals", matchCount: 4, feedsInto: "Semifinals", isScoring: true }, // losers share 5th–8th
|
||
{ name: "Semifinals", matchCount: 2, feedsInto: "Final", isScoring: true }, // 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
|
||
* Only Elite Eight and beyond score points per Q18
|
||
*
|
||
* Region config (year-specific — update each March when the First Four matchups are announced):
|
||
* East — 16 direct seeds, no play-ins
|
||
* South — 15 direct seeds, 16-seed play-in
|
||
* West — 15 direct seeds, 11-seed play-in
|
||
* Midwest — 14 direct seeds, 11-seed play-in + 16-seed play-in
|
||
*
|
||
* Participant array layout (68 slots):
|
||
* [0–15] East seeds 1–16
|
||
* [16–30] South seeds 1–15
|
||
* [31–45] West seeds 1–10, 12–16
|
||
* [46–59] Midwest seeds 1–10, 12–15
|
||
* [60–61] South 16-seed play-in (2 teams)
|
||
* [62–63] West 11-seed play-in (2 teams)
|
||
* [64–65] Midwest 11-seed play-in (2 teams)
|
||
* [66–67] Midwest 16-seed play-in (2 teams)
|
||
*/
|
||
export const NCAA_68: BracketTemplate = {
|
||
id: "ncaa_68",
|
||
name: "NCAA March Madness (68 teams)",
|
||
totalTeams: 68,
|
||
scoringStartsAtRound: "Elite Eight",
|
||
rounds: [
|
||
{
|
||
name: "First Four",
|
||
matchCount: 4,
|
||
feedsInto: "Round of 64",
|
||
isScoring: false, // Play-in games don't score
|
||
},
|
||
{
|
||
name: "Round of 64",
|
||
matchCount: 32,
|
||
feedsInto: "Round of 32",
|
||
isScoring: false,
|
||
},
|
||
{
|
||
name: "Round of 32",
|
||
matchCount: 16,
|
||
feedsInto: "Sweet Sixteen",
|
||
isScoring: false,
|
||
},
|
||
{
|
||
name: "Sweet Sixteen",
|
||
matchCount: 8,
|
||
feedsInto: "Elite Eight",
|
||
isScoring: false,
|
||
},
|
||
{
|
||
name: "Elite Eight",
|
||
matchCount: 4,
|
||
feedsInto: "Final Four",
|
||
isScoring: true, // Losers share 5th-8th
|
||
},
|
||
{
|
||
name: "Final Four",
|
||
matchCount: 2,
|
||
feedsInto: "Championship",
|
||
isScoring: true, // Losers share 3rd-4th
|
||
},
|
||
{
|
||
name: "Championship",
|
||
matchCount: 1,
|
||
feedsInto: null,
|
||
isScoring: true, // Winner 1st, Loser 2nd
|
||
},
|
||
],
|
||
regions: [
|
||
{
|
||
// East: all 16 seeds enter directly — no play-in games
|
||
name: "East",
|
||
directSeeds: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16],
|
||
playIns: [],
|
||
},
|
||
{
|
||
// South: seeds 1–15 direct; 16-seed determined by First Four play-in
|
||
name: "South",
|
||
directSeeds: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15],
|
||
playIns: [{ seedSlot: 16, teams: 2 }],
|
||
},
|
||
{
|
||
// West: seeds 1–10 and 12–16 direct; 11-seed determined by First Four play-in
|
||
name: "West",
|
||
directSeeds: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 13, 14, 15, 16],
|
||
playIns: [{ seedSlot: 11, teams: 2 }],
|
||
},
|
||
{
|
||
// Midwest: seeds 1–10 and 12–15 direct; both 11-seed and 16-seed via play-ins
|
||
name: "Midwest",
|
||
directSeeds: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 13, 14, 15],
|
||
playIns: [
|
||
{ seedSlot: 11, teams: 2 },
|
||
{ seedSlot: 16, teams: 2 },
|
||
],
|
||
},
|
||
],
|
||
// Two-tab display: First Four → Bracket (4 regional sub-brackets + Final Four)
|
||
phases: [
|
||
{
|
||
name: "First Four",
|
||
rounds: ["First Four"],
|
||
},
|
||
{
|
||
name: "Bracket",
|
||
groups: [
|
||
{
|
||
name: "East Region",
|
||
roundMatchNumbers: {
|
||
"Round of 64": [1, 2, 3, 4, 5, 6, 7, 8],
|
||
"Round of 32": [1, 2, 3, 4],
|
||
"Sweet Sixteen": [1, 2],
|
||
"Elite Eight": [1],
|
||
},
|
||
},
|
||
{
|
||
name: "South Region",
|
||
roundMatchNumbers: {
|
||
"Round of 64": [9, 10, 11, 12, 13, 14, 15, 16],
|
||
"Round of 32": [5, 6, 7, 8],
|
||
"Sweet Sixteen": [3, 4],
|
||
"Elite Eight": [2],
|
||
},
|
||
},
|
||
{
|
||
name: "West Region",
|
||
roundMatchNumbers: {
|
||
"Round of 64": [17, 18, 19, 20, 21, 22, 23, 24],
|
||
"Round of 32": [9, 10, 11, 12],
|
||
"Sweet Sixteen": [5, 6],
|
||
"Elite Eight": [3],
|
||
},
|
||
},
|
||
{
|
||
name: "Midwest Region",
|
||
roundMatchNumbers: {
|
||
"Round of 64": [25, 26, 27, 28, 29, 30, 31, 32],
|
||
"Round of 32": [13, 14, 15, 16],
|
||
"Sweet Sixteen": [7, 8],
|
||
"Elite Eight": [4],
|
||
},
|
||
},
|
||
],
|
||
sharedRounds: ["Final Four", "Championship"],
|
||
},
|
||
],
|
||
};
|
||
|
||
/**
|
||
* NFL Playoffs (14 teams)
|
||
* Wild Card → Divisional → Conference Championship → Super Bowl
|
||
* Top 2 seeds get byes (skip Wild Card)
|
||
* Scoring starts at Divisional (top 8)
|
||
*/
|
||
export const NFL_14: BracketTemplate = {
|
||
id: "nfl_14",
|
||
name: "NFL Playoffs (14 teams)",
|
||
totalTeams: 14,
|
||
scoringStartsAtRound: "Divisional",
|
||
rounds: [
|
||
{
|
||
name: "Wild Card",
|
||
matchCount: 6,
|
||
feedsInto: "Divisional",
|
||
isScoring: false, // 12 teams play, 2 have byes
|
||
},
|
||
{
|
||
name: "Divisional",
|
||
matchCount: 4,
|
||
feedsInto: "Conference Championship",
|
||
isScoring: true, // Quarterfinals - Losers share 5th-8th
|
||
},
|
||
{
|
||
name: "Conference Championship",
|
||
matchCount: 2,
|
||
feedsInto: "Super Bowl",
|
||
isScoring: true, // Semifinals - Losers share 3rd-4th
|
||
},
|
||
{
|
||
name: "Super Bowl",
|
||
matchCount: 1,
|
||
feedsInto: null,
|
||
isScoring: true, // Finals - Winner 1st, Loser 2nd
|
||
},
|
||
],
|
||
};
|
||
|
||
/**
|
||
* AFL Finals (10 teams with Wildcard Round from 2026)
|
||
* Complex bracket with double-chance system for top 6 teams
|
||
*
|
||
* Structure:
|
||
* - Wildcard Round: 7v10, 8v9 (losers eliminated with 0 points)
|
||
* - Week 1 Finals:
|
||
* - Qualifying Finals: 1v4, 2v3 (losers get second chance)
|
||
* - Elimination Finals: the two Wildcard winners are re-seeded by ladder position, so
|
||
* 5th hosts the lower-ranked winner and 6th the higher-ranked one (losers share 7th-8th)
|
||
* - Week 2: Semi-Finals (QF losers vs EF winners, losers share 5th-6th)
|
||
* - Week 3: Preliminary Finals (QF winners vs SF winners, losers share 3rd-4th)
|
||
* - Week 4: Grand Final (1st vs 2nd)
|
||
*
|
||
* Note: This is NOT a simple single-elimination tree - it has double-chance paths
|
||
*/
|
||
export const AFL_10: BracketTemplate = {
|
||
id: "afl_10",
|
||
name: "AFL Finals (10 teams with Wildcard)",
|
||
totalTeams: 10,
|
||
scoringStartsAtRound: "Elimination Finals",
|
||
rounds: [
|
||
{
|
||
name: "Wildcard Round",
|
||
matchCount: 2,
|
||
feedsInto: "Elimination Finals",
|
||
isScoring: false, // Losers get 0 points (9th-10th)
|
||
// A Wildcard win only buys an Elimination Final; losing that is the 7th-8th
|
||
// tier, so the winner banks 7 — not the generic "entering a scoring round
|
||
// means top-8" default of 5, which would over-award them a 5th-6th floor.
|
||
nonScoringWinnerFloor: 7,
|
||
},
|
||
{
|
||
name: "Qualifying Finals",
|
||
matchCount: 2,
|
||
feedsInto: "Preliminary Finals", // Winners get bye
|
||
isScoring: false, // Losers get second chance (go to Semi-Finals)
|
||
// Seeds 1-4 have the double chance from the moment the bracket is drawn:
|
||
// lose the QF, lose the Semi-Final, and you still finish in the 5th-6th tier.
|
||
entryFloor: 5,
|
||
// Winning the QF is a bye straight to a Preliminary Final; losing that is the
|
||
// 3rd-4th tier, so the winner's floor is 3 rather than the generic default of 5.
|
||
nonScoringWinnerFloor: 3,
|
||
},
|
||
{
|
||
name: "Elimination Finals",
|
||
matchCount: 2,
|
||
feedsInto: "Semi-Finals",
|
||
isScoring: true, // Losers share 7th-8th
|
||
// Seeds 5-6 are seeded straight into this round, so the 7th-8th tier is
|
||
// locked in for them at generation. (The other slot is a TBD Wildcard winner,
|
||
// who banks the same floor by winning the Wildcard Round.)
|
||
entryFloor: 7,
|
||
},
|
||
{
|
||
name: "Semi-Finals",
|
||
matchCount: 2,
|
||
feedsInto: "Preliminary Finals",
|
||
isScoring: true, // Losers share 5th-6th
|
||
},
|
||
{
|
||
name: "Preliminary Finals",
|
||
matchCount: 2,
|
||
feedsInto: "Grand Final",
|
||
isScoring: true, // Losers share 3rd-4th
|
||
},
|
||
{
|
||
name: "Grand Final",
|
||
matchCount: 1,
|
||
feedsInto: null,
|
||
isScoring: true, // Winner 1st, Loser 2nd
|
||
},
|
||
],
|
||
};
|
||
|
||
/**
|
||
* FIFA World Cup 48-team tournament (2026+)
|
||
* Group stage: 12 groups of 4 teams play round-robin
|
||
* Knockout stage: 32 teams advance to single-elimination bracket
|
||
*
|
||
* Group-to-knockout advancement is fully manual.
|
||
* Admin marks teams as eliminated from groups, then assigns 32 advancing
|
||
* teams into knockout bracket slots.
|
||
*
|
||
* Only knockout stage awards fantasy points.
|
||
* Teams eliminated in groups get finalPosition = 0.
|
||
*/
|
||
export const FIFA_48: BracketTemplate = {
|
||
id: "fifa_48",
|
||
name: "FIFA World Cup (48 teams)",
|
||
totalTeams: 48,
|
||
knockoutTeams: 32,
|
||
scoringStartsAtRound: "Quarterfinals",
|
||
groupStage: {
|
||
groupCount: 12,
|
||
teamsPerGroup: 4,
|
||
groupLabels: ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L"],
|
||
},
|
||
rounds: [
|
||
{
|
||
name: "Round of 32",
|
||
matchCount: 16,
|
||
feedsInto: "Round of 16",
|
||
isScoring: false,
|
||
},
|
||
{
|
||
name: "Round of 16",
|
||
matchCount: 8,
|
||
feedsInto: "Quarterfinals",
|
||
isScoring: false,
|
||
},
|
||
{
|
||
name: "Quarterfinals",
|
||
matchCount: 4,
|
||
feedsInto: "Semifinals",
|
||
isScoring: true,
|
||
},
|
||
{
|
||
name: "Semifinals",
|
||
matchCount: 2,
|
||
feedsInto: "Finals",
|
||
isScoring: true,
|
||
loserFeedsInto: "Third Place Game",
|
||
},
|
||
{
|
||
name: "Third Place Game",
|
||
matchCount: 1,
|
||
feedsInto: null,
|
||
isScoring: true,
|
||
},
|
||
{
|
||
name: "Finals",
|
||
matchCount: 1,
|
||
feedsInto: null,
|
||
isScoring: true,
|
||
},
|
||
],
|
||
};
|
||
|
||
/**
|
||
* College Football Playoff (12 teams, 2024–present format)
|
||
* First Round: 5v12, 6v11, 7v10, 8v9 (campus sites, no fantasy points)
|
||
* Quarterfinals: Seeds 1–4 (bye) vs first-round winners (scoring starts here)
|
||
* Semifinals: 4 → 2
|
||
* National Championship: 1 game
|
||
*/
|
||
export const CFP_12: BracketTemplate = {
|
||
id: "cfp_12",
|
||
name: "College Football Playoff (12 teams)",
|
||
totalTeams: 12,
|
||
scoringStartsAtRound: "Quarterfinals",
|
||
rounds: [
|
||
{
|
||
name: "First Round",
|
||
matchCount: 4,
|
||
feedsInto: "Quarterfinals",
|
||
isScoring: false, // 8 seeds play, top 4 have byes
|
||
},
|
||
{
|
||
name: "Quarterfinals",
|
||
matchCount: 4,
|
||
feedsInto: "Semifinals",
|
||
isScoring: true, // Losers share 5th–8th
|
||
},
|
||
{
|
||
name: "Semifinals",
|
||
matchCount: 2,
|
||
feedsInto: "National Championship",
|
||
isScoring: true, // Losers share 3rd–4th
|
||
},
|
||
{
|
||
name: "National Championship",
|
||
matchCount: 1,
|
||
feedsInto: null,
|
||
isScoring: true, // Winner 1st, loser 2nd
|
||
},
|
||
],
|
||
};
|
||
|
||
/**
|
||
* NBA Playoffs with Play-In Tournament (20 teams)
|
||
*
|
||
* Structure:
|
||
* Play-In Round 1 (4 games, not scoring):
|
||
* East: 7 vs 8 (winner = E7 seed), 9 vs 10 (winner advances; loser eliminated)
|
||
* West: 7 vs 8 (winner = W7 seed), 9 vs 10 (winner advances; loser eliminated)
|
||
* Play-In Round 2 (2 games, not scoring):
|
||
* East: loser of 7/8 vs winner of 9/10 → winner = E8 seed; loser eliminated
|
||
* West: loser of 7/8 vs winner of 9/10 → winner = W8 seed; loser eliminated
|
||
* First Round (8 series, not scoring):
|
||
* East: 1v8, 4v5, 2v7, 3v6
|
||
* West: 1v8, 4v5, 2v7, 3v6
|
||
* Conference Semifinals (4 series, scoring starts — 5th-8th for losers)
|
||
* Conference Finals (2 series, scoring)
|
||
* NBA Finals (1 series, scoring)
|
||
*
|
||
* Participant array layout (20 slots, indices 0-19):
|
||
* [0–9] East seeds 1–10
|
||
* [10–19] West seeds 1–10
|
||
*
|
||
* Play-in loser paths (custom advancement logic):
|
||
* PIR1 M1 (E7v8): winner → First Round M3 p1; loser → PIR2 M1 p1
|
||
* PIR1 M2 (E9v10): winner → PIR2 M1 p2; loser eliminated
|
||
* PIR1 M3 (W7v8): winner → First Round M7 p1; loser → PIR2 M2 p1
|
||
* PIR1 M4 (W9v10): winner → PIR2 M2 p2; loser eliminated
|
||
* PIR2 M1: winner → First Round M1 p2; loser eliminated
|
||
* PIR2 M2: winner → First Round M5 p2; loser eliminated
|
||
*
|
||
* First Round bracket order (enables correct Conference Semis matchups via standard ceil logic):
|
||
* M1: E1 vs E8 (play-in winner) → CS M1 p1
|
||
* M2: E4 vs E5 → CS M1 p2
|
||
* M3: E2 vs E7 (play-in winner) → CS M2 p1
|
||
* M4: E3 vs E6 → CS M2 p2
|
||
* M5: W1 vs W8 (play-in winner) → CS M3 p1
|
||
* M6: W4 vs W5 → CS M3 p2
|
||
* M7: W2 vs W7 (play-in winner) → CS M4 p1
|
||
* M8: W3 vs W6 → CS M4 p2
|
||
*/
|
||
export const NBA_20: BracketTemplate = {
|
||
id: "nba_20",
|
||
name: "NBA Playoffs with Play-In (20 teams)",
|
||
totalTeams: 20,
|
||
scoringStartsAtRound: "Conference Semifinals",
|
||
rounds: [
|
||
{
|
||
name: "Play-In Round 1",
|
||
matchCount: 4,
|
||
feedsInto: "Play-In Round 2",
|
||
isScoring: false, // Play-in games don't score
|
||
},
|
||
{
|
||
name: "Play-In Round 2",
|
||
matchCount: 2,
|
||
feedsInto: "First Round",
|
||
isScoring: false, // Still determining playoff field
|
||
},
|
||
{
|
||
name: "First Round",
|
||
matchCount: 8,
|
||
feedsInto: "Conference Semifinals",
|
||
isScoring: false, // First Round losers score 0 points
|
||
},
|
||
{
|
||
name: "Conference Semifinals",
|
||
matchCount: 4,
|
||
feedsInto: "Conference Finals",
|
||
isScoring: true, // Losers share 5th-8th
|
||
},
|
||
{
|
||
name: "Conference Finals",
|
||
matchCount: 2,
|
||
feedsInto: "NBA Finals",
|
||
isScoring: true, // Losers share 3rd-4th
|
||
},
|
||
{
|
||
name: "NBA Finals",
|
||
matchCount: 1,
|
||
feedsInto: null,
|
||
isScoring: true, // Winner 1st, Loser 2nd
|
||
},
|
||
],
|
||
participantLabels: [
|
||
"East 1", "East 2", "East 3", "East 4", "East 5",
|
||
"East 6", "East 7", "East 8", "East 9", "East 10",
|
||
"West 1", "West 2", "West 3", "West 4", "West 5",
|
||
"West 6", "West 7", "West 8", "West 9", "West 10",
|
||
],
|
||
phases: [
|
||
{
|
||
name: "Play-In",
|
||
rounds: ["Play-In Round 1", "Play-In Round 2"],
|
||
layout: "play-in" as const,
|
||
},
|
||
{
|
||
name: "Playoffs",
|
||
rounds: ["First Round", "Conference Semifinals", "Conference Finals", "NBA Finals"],
|
||
},
|
||
],
|
||
};
|
||
|
||
// ── LLWS 20 ───────────────────────────────────────────────────────────────────
|
||
|
||
/** Side-local match numbers → global match numbers, per round shape. */
|
||
const LLWS_OPENING_OFFSET = 4; // Opening Round: US M1–4, Intl M5–8
|
||
const LLWS_PAIR_OFFSET = 2; // 4-match rounds: US M1–2, Intl M3–4
|
||
const LLWS_SOLO_OFFSET = 1; // 2-match rounds: US M1, Intl M2
|
||
|
||
/** Rounds with 4 matches (2 per side). Opening Round has 8; the rest have 2. */
|
||
export const LLWS_FOUR_MATCH_ROUNDS = new Set([
|
||
"Winners Round 2",
|
||
"Elimination Round 1",
|
||
"Winners Semifinals",
|
||
"Elimination Round 2",
|
||
"Elimination Round 3",
|
||
]);
|
||
|
||
/**
|
||
* Returns the global match number for a side-local match in an LLWS round.
|
||
* side 0 = United States, side 1 = International.
|
||
*/
|
||
export function llwsMatchNumber(round: string, side: 0 | 1, localMatch: number): number {
|
||
const offset =
|
||
round === "Opening Round"
|
||
? LLWS_OPENING_OFFSET
|
||
: LLWS_FOUR_MATCH_ROUNDS.has(round)
|
||
? LLWS_PAIR_OFFSET
|
||
: LLWS_SOLO_OFFSET;
|
||
return localMatch + side * offset;
|
||
}
|
||
|
||
/**
|
||
* Inverse of llwsMatchNumber: global match number → { side, localMatch }.
|
||
*/
|
||
export function llwsSideAndLocal(
|
||
round: string,
|
||
matchNumber: number
|
||
): { side: 0 | 1; localMatch: number } {
|
||
const offset =
|
||
round === "Opening Round"
|
||
? LLWS_OPENING_OFFSET
|
||
: LLWS_FOUR_MATCH_ROUNDS.has(round)
|
||
? LLWS_PAIR_OFFSET
|
||
: LLWS_SOLO_OFFSET;
|
||
const side: 0 | 1 = matchNumber > offset ? 1 : 0;
|
||
return { side, localMatch: matchNumber - side * offset };
|
||
}
|
||
|
||
/**
|
||
* Little League Baseball World Series (20 teams, 2025+ double-elimination format)
|
||
*
|
||
* Two independent 10-team double-elimination brackets — United States and
|
||
* International — each producing a side champion, then a World Championship game and
|
||
* a Consolation Third Place game between the two side runners-up.
|
||
*
|
||
* Rounds are shared across both sides: U.S. matches take the low match numbers and
|
||
* International the high ones (see llwsMatchNumber). The phases/groups config splits
|
||
* them back apart for display.
|
||
*
|
||
* A loss in the winners bracket is NOT an elimination — it drops the team into the
|
||
* elimination bracket at a specific slot (see advanceLLWSWinner in models/playoff-match).
|
||
* A loss in the elimination bracket is final.
|
||
*
|
||
* There is deliberately NO "if necessary" game: the winners-bracket champion is out if
|
||
* it loses the Bracket Championship, dropping to the Consolation game rather than
|
||
* forcing a rematch. This is the official LLWS modified double-elimination format.
|
||
*
|
||
* Placement tiers (only 8 teams score — the field is exactly 8 when Elim R4 begins):
|
||
* 1st / 2nd World Championship
|
||
* 3rd / 4th Consolation Third Place (real game, so positions are distinct)
|
||
* 5th / 6th Elimination Final losers
|
||
* 7th / 8th Elimination Round 4 losers
|
||
* 0 pts the 12 teams eliminated in Elimination Rounds 1–3
|
||
*
|
||
* Participant array layout (20 slots):
|
||
* [0–7] U.S. Opening Round teams, two per game (M1..M4)
|
||
* [8, 9] U.S. bye teams, entering Winners Round 2 M1 / M2 at participant1
|
||
* [10–17] International Opening Round teams, two per game (M5..M8)
|
||
* [18,19] International bye teams, entering Winners Round 2 M3 / M4 at participant1
|
||
*/
|
||
export const LLWS_20: BracketTemplate = {
|
||
id: "llws_20",
|
||
name: "Little League World Series (20 teams)",
|
||
totalTeams: 20,
|
||
scoringStartsAtRound: "Winners Final",
|
||
// Ordered by the real schedule so non-phased views read chronologically.
|
||
rounds: [
|
||
{
|
||
name: "Opening Round",
|
||
matchCount: 8,
|
||
feedsInto: "Winners Round 2",
|
||
isScoring: false,
|
||
loserFeedsInto: "Elimination Round 1",
|
||
nonScoringWinnerFloor: null, // 16 teams still alive — nothing guaranteed
|
||
},
|
||
{
|
||
name: "Winners Round 2",
|
||
matchCount: 4,
|
||
feedsInto: "Winners Semifinals",
|
||
isScoring: false,
|
||
loserFeedsInto: "Elimination Round 2",
|
||
nonScoringWinnerFloor: null,
|
||
},
|
||
{
|
||
name: "Elimination Round 1",
|
||
matchCount: 4,
|
||
feedsInto: "Elimination Round 2",
|
||
isScoring: false, // losers finish 13th–16th
|
||
nonScoringWinnerFloor: null,
|
||
},
|
||
{
|
||
name: "Winners Semifinals",
|
||
matchCount: 4,
|
||
feedsInto: "Winners Final",
|
||
isScoring: false,
|
||
loserFeedsInto: "Elimination Round 3",
|
||
// Reaching the Winners Final guarantees at worst 5th (lose it, then lose the
|
||
// Elimination Final). Same value as the engine default, stated explicitly.
|
||
nonScoringWinnerFloor: 5,
|
||
},
|
||
{
|
||
name: "Elimination Round 2",
|
||
matchCount: 4,
|
||
feedsInto: "Elimination Round 3",
|
||
isScoring: false, // losers finish 11th–12th
|
||
nonScoringWinnerFloor: null,
|
||
},
|
||
{
|
||
name: "Elimination Round 3",
|
||
matchCount: 4,
|
||
feedsInto: "Elimination Round 4",
|
||
isScoring: false, // losers finish 9th–10th
|
||
// Winners reach Elimination Round 4, where a loss is 7th — not 5th.
|
||
nonScoringWinnerFloor: 7,
|
||
},
|
||
{
|
||
name: "Winners Final",
|
||
matchCount: 2,
|
||
feedsInto: "Bracket Championship",
|
||
isScoring: true, // loser drops to the Elimination Final (provisional 5th)
|
||
loserFeedsInto: "Elimination Final",
|
||
},
|
||
{
|
||
name: "Elimination Round 4",
|
||
matchCount: 2,
|
||
feedsInto: "Elimination Final",
|
||
isScoring: true, // losers share 7th–8th
|
||
},
|
||
{
|
||
name: "Elimination Final",
|
||
matchCount: 2,
|
||
feedsInto: "Bracket Championship",
|
||
isScoring: true, // losers share 5th–6th
|
||
},
|
||
{
|
||
name: "Bracket Championship",
|
||
matchCount: 2,
|
||
feedsInto: "World Championship",
|
||
isScoring: true, // loser drops to the Consolation game (provisional 4th)
|
||
loserFeedsInto: "Consolation Third Place",
|
||
},
|
||
{
|
||
name: "Consolation Third Place",
|
||
matchCount: 1,
|
||
feedsInto: null,
|
||
isScoring: true, // winner 3rd, loser 4th
|
||
},
|
||
{
|
||
name: "World Championship",
|
||
matchCount: 1,
|
||
feedsInto: null,
|
||
isScoring: true, // winner 1st, loser 2nd
|
||
},
|
||
],
|
||
// Region assignments rotate year to year (which region draws the bye changes), so
|
||
// these are positional slot labels rather than region names. Kept short — the admin
|
||
// form renders them in a narrow fixed-width column alongside each participant picker.
|
||
participantLabels: [
|
||
"US G1 Home", "US G1 Away",
|
||
"US G2 Home", "US G2 Away",
|
||
"US G3 Home", "US G3 Away",
|
||
"US G4 Home", "US G4 Away",
|
||
"US Bye 1", "US Bye 2",
|
||
"Intl G1 Home", "Intl G1 Away",
|
||
"Intl G2 Home", "Intl G2 Away",
|
||
"Intl G3 Home", "Intl G3 Away",
|
||
"Intl G4 Home", "Intl G4 Away",
|
||
"Intl Bye 1", "Intl Bye 2",
|
||
],
|
||
phases: [
|
||
{
|
||
name: "United States",
|
||
groups: [
|
||
{
|
||
name: "U.S. Winner's Bracket",
|
||
roundMatchNumbers: {
|
||
"Opening Round": [1, 2, 3, 4],
|
||
"Winners Round 2": [1, 2],
|
||
"Winners Semifinals": [1, 2],
|
||
"Winners Final": [1],
|
||
},
|
||
},
|
||
{
|
||
name: "U.S. Elimination Bracket",
|
||
roundMatchNumbers: {
|
||
"Elimination Round 1": [1, 2],
|
||
"Elimination Round 2": [1, 2],
|
||
"Elimination Round 3": [1, 2],
|
||
"Elimination Round 4": [1],
|
||
"Elimination Final": [1],
|
||
},
|
||
},
|
||
{
|
||
name: "U.S. Championship",
|
||
roundMatchNumbers: { "Bracket Championship": [1] },
|
||
},
|
||
],
|
||
},
|
||
{
|
||
name: "International",
|
||
groups: [
|
||
{
|
||
name: "International Winner's Bracket",
|
||
roundMatchNumbers: {
|
||
"Opening Round": [5, 6, 7, 8],
|
||
"Winners Round 2": [3, 4],
|
||
"Winners Semifinals": [3, 4],
|
||
"Winners Final": [2],
|
||
},
|
||
},
|
||
{
|
||
name: "International Elimination Bracket",
|
||
roundMatchNumbers: {
|
||
"Elimination Round 1": [3, 4],
|
||
"Elimination Round 2": [3, 4],
|
||
"Elimination Round 3": [3, 4],
|
||
"Elimination Round 4": [2],
|
||
"Elimination Final": [2],
|
||
},
|
||
},
|
||
{
|
||
name: "International Championship",
|
||
roundMatchNumbers: { "Bracket Championship": [2] },
|
||
},
|
||
],
|
||
},
|
||
{
|
||
name: "Championship",
|
||
rounds: ["Consolation Third Place", "World Championship"],
|
||
},
|
||
],
|
||
};
|
||
|
||
/**
|
||
* All available bracket templates
|
||
*/
|
||
export const BRACKET_TEMPLATES: Record<string, BracketTemplate> = {
|
||
simple_4: SIMPLE_4,
|
||
simple_8: SIMPLE_8,
|
||
simple_16: SIMPLE_16,
|
||
college_hockey_16: COLLEGE_HOCKEY_16,
|
||
simple_32: SIMPLE_32,
|
||
ncaa_68: NCAA_68,
|
||
nfl_14: NFL_14,
|
||
afl_10: AFL_10,
|
||
fifa_48: FIFA_48,
|
||
darts_128: DARTS_128,
|
||
tennis_128: TENNIS_128,
|
||
cfp_12: CFP_12,
|
||
nba_20: NBA_20,
|
||
llws_20: LLWS_20,
|
||
};
|
||
|
||
/**
|
||
* Get a bracket template by ID
|
||
*/
|
||
export function getBracketTemplate(id: string): BracketTemplate | undefined {
|
||
return BRACKET_TEMPLATES[id];
|
||
}
|
||
|
||
/**
|
||
* Get all bracket templates as an array
|
||
*/
|
||
export function getAllBracketTemplates(): BracketTemplate[] {
|
||
return Object.values(BRACKET_TEMPLATES);
|
||
}
|
||
|
||
/**
|
||
* Returns round names in chronological order (earliest first) for the given matches.
|
||
* When a template is provided its defined order is used; otherwise rounds are sorted
|
||
* by descending match count (more matches = earlier round).
|
||
*/
|
||
export function getOrderedRoundsFromMatches(
|
||
matches: Array<{ round: string }>,
|
||
template?: BracketTemplate
|
||
): string[] {
|
||
const roundsInMatches = new Set(matches.map((m) => m.round));
|
||
|
||
if (template) {
|
||
return template.rounds
|
||
.map((r) => r.name)
|
||
.filter((name) => roundsInMatches.has(name));
|
||
}
|
||
|
||
const roundMatchCounts = new Map<string, number>();
|
||
for (const m of matches) {
|
||
roundMatchCounts.set(m.round, (roundMatchCounts.get(m.round) || 0) + 1);
|
||
}
|
||
return Array.from(roundMatchCounts.keys()).toSorted(
|
||
(a, b) => (roundMatchCounts.get(b) || 0) - (roundMatchCounts.get(a) || 0)
|
||
);
|
||
}
|
||
|
||
/**
|
||
* Helper to determine scoring round type based on match count in scoring rounds
|
||
* Used for determining placement sharing (5-8th, 3-4th, 1-2nd)
|
||
*
|
||
* Special handling for AFL finals system which has specific placement rules
|
||
*/
|
||
export function getScoringRoundType(
|
||
roundName: string,
|
||
template: BracketTemplate
|
||
): "quarterfinals" | "semifinals" | "finals" | null {
|
||
const round = template.rounds.find((r) => r.name === roundName);
|
||
if (!round || !round.isScoring) return null;
|
||
|
||
// Special handling for LLWS double elimination: match counts don't identify the
|
||
// tier (Elimination Round 4 and the Elimination Final both have 2 matches), and
|
||
// the Winners Final eliminates nobody.
|
||
if (template.id === "llws_20") {
|
||
if (roundName === "Elimination Round 4") return "quarterfinals"; // losers share 7-8th
|
||
if (roundName === "Elimination Final") return "quarterfinals"; // losers share 5-6th
|
||
if (roundName === "Bracket Championship") return "semifinals"; // losers play for 3-4th
|
||
if (roundName === "Consolation Third Place") return "semifinals"; // finalizes 3rd/4th
|
||
if (roundName === "World Championship") return "finals"; // 1st and 2nd
|
||
return null; // Winners Final: loser drops to the elimination bracket, nobody is out
|
||
}
|
||
|
||
// Special handling for AFL finals
|
||
if (template.id === "afl_10") {
|
||
if (roundName === "Elimination Finals") return "quarterfinals"; // Losers share 7-8th
|
||
if (roundName === "Semi-Finals") return "quarterfinals"; // Losers share 5-6th (custom mapping)
|
||
if (roundName === "Preliminary Finals") return "semifinals"; // Losers share 3-4th
|
||
if (roundName === "Grand Final") return "finals"; // 1st and 2nd
|
||
return null;
|
||
}
|
||
|
||
// Standard logic for other templates
|
||
// Determine type by match count in scoring round
|
||
if (round.matchCount === 4) return "quarterfinals"; // 8 teams, losers share 5-8th
|
||
if (round.matchCount === 2) return "semifinals"; // 4 teams, losers share 3-4th
|
||
if (round.matchCount === 1) return "finals"; // 2 teams, 1st and 2nd
|
||
return null;
|
||
}
|