WCA and Red Bull competition formats in ruTournament

Each category in a ruTournament tournament is assigned exactly one format at creation time. The format is not cosmetic — it determines how individual solve times are aggregated into a score, how competitors are ranked within a round, and how advancement to subsequent rounds (or match-ups in a bracket) is calculated. Switching a category’s format after results have been entered will erase those results, so choose the format deliberately during tournament setup.

WCA Format
Red Bull Format

The WCA format mirrors the rules used at official World Cube Association competitions. Each round consists of a fixed number of solves per competitor, which are then averaged according to the round’s configured format.

Average formats

Format	Solves	Calculation
`ao5`	5	Drop the single best and single worst time; average the middle 3
`ao3`	3	Average all 3 times (mean of 3 — no drops)

Penalties

Every individual solve time is stored as a TimeRecord object with a base value (in seconds) and a penalty flag:

type Penalty = '' | '+2' | 'DNF';

interface TimeRecord {
  base: number;   // solve time in seconds
  penalty: Penalty;
}

Penalty	Meaning	Effect on score
`''`	Clean solve	Score = `base`
`'+2'`	Judge applied a +2 second penalty	Score = `base + 2`
`'DNF'`	Did Not Finish — competitor did not complete the solve	Score = `-1` (treated as infinity in ranking)

Average calculation: `calculateRulesStats`

The following function, taken directly from ResultsWCA.tsx, computes both the single best and the official average for a set of times:

// src/pages/Tournament/ResultsWCA.tsx
export const calculateRulesStats = (
  times: TimeRecord[],
  format: 'ao3' | 'ao5'
) => {
  const solves = times.map(t => getSolveValue(t)); // DNF => -1
  const finishedSolves = solves.filter(s => s > 0);
  const dnfsCount = solves.filter(s => s < 0).length;

  let best = -1;
  if (finishedSolves.length > 0) best = Math.min(...finishedSolves);

  // Only calculate average once all slots are filled
  const allEntered = times.every(t => t.base > 0 || t.penalty === 'DNF');
  if (!allEntered) return { best, average: 0 };

  let average = 0;

  if (format === 'ao3') {
    // Any DNF in ao3 = DNF average
    if (dnfsCount > 0) average = -1;
    else average = solves.reduce((a, b) => a + b, 0) / 3;

  } else if (format === 'ao5') {
    // Two or more DNFs in ao5 = DNF average
    if (dnfsCount >= 2) average = -1;
    else {
      const valid = solves.filter(s => s > 0).sort((a, b) => a - b);
      if (dnfsCount === 1) {
        // The one DNF counts as the "worst" — drop only the best
        valid.shift();
        average = valid.reduce((a, b) => a + b, 0) / 3;
      } else {
        // Drop best and worst, average the middle 3
        valid.shift();
        valid.pop();
        average = valid.reduce((a, b) => a + b, 0) / 3;
      }
    }
  }

  return {
    best:    best    > 0 ? Math.round(best * 100) / 100 : -1,
    average: average > 0 ? Math.round(average * 100) / 100 : -1,
  };
};

Key rules to remember:

ao5 with 1 DNF: The DNF is treated as the worst time. Only the single best time is dropped; the remaining three (including the DNF-penalised slot treated as dropped) are averaged.
ao5 with 2+ DNFs: The entire average is DNF (-1).
ao3 with any DNF: The entire average is DNF (-1).

Ranking: `sortWCA`

Competitors within a round are ranked using the following comparator, also from ResultsWCA.tsx:

// src/pages/Tournament/ResultsWCA.tsx
export const sortWCA = (a: any, b: any) => {
  // Weight 1 = valid average, 2 = DNF average, 3 = incomplete
  const getWeight = (avg: number) => {
    if (avg > 0)  return 1;
    if (avg === -1) return 2;
    return 3;
  };

  const weightA = getWeight(a.average);
  const weightB = getWeight(b.average);

  // First: sort by average tier (valid < DNF < incomplete)
  if (weightA !== weightB) return weightA - weightB;

  // Within valid averages: lower average wins; tie-break on single best
  if (weightA === 1) {
    if (a.average !== b.average) return a.average - b.average;
    const bestA = a.best > 0 ? a.best : Infinity;
    const bestB = b.best > 0 ? b.best : Infinity;
    return bestA - bestB;
  }

  // Within DNF/incomplete: sort by single best
  const bestA = a.best > 0 ? a.best : (a.best === -1 ? Infinity - 1 : Infinity);
  const bestB = b.best > 0 ? b.best : (b.best === -1 ? Infinity - 1 : Infinity);
  if (bestA !== bestB) return bestA - bestB;

  return a.name?.localeCompare(b.name || '');
};

In plain terms: competitors with a valid (non-DNF) average are ranked first, sorted by that average ascending. Ties in the average are broken by the single best time. Competitors whose average is DNF rank below all valid averages, sorted again by their single best. Completely incomplete result sets rank last.

Multi-round advancement

WCA categories can have multiple rounds. Each non-final round has a competitorsToAdvance value that controls how many competitors move forward:

interface RoundLocal {
  num:                   number;
  format:                string;
  results:               ResultLocal[];
  competitorsToAdvance:  number | 'all';
}

After a preliminary round closes, the app sorts all competitors via sortWCA and slices the top competitorsToAdvance entries. Only those competitors appear in the next round’s result table. When competitorsToAdvance is 'all', every competitor with a result advances.

The number of rounds and the competitorsToAdvance value for each round are configured during tournament creation. You can also change them later in the Categories section while the tournament is in the activo state — just be aware that changing the advancement count on a round for which results already exist will immediately affect which competitors are visible in the next round.

The Red Bull format is a direct-elimination bracket. Competitors face off head-to-head in individual matches; the winner advances and the loser is eliminated. The bracket structure is determined at generation time, optionally informed by a seeding round.

Bracket mode

When creating a Red Bull category, you choose how match-ups are generated:

`bracketMode`	Behaviour
`'random'`	The app randomly shuffles all registered competitors and assigns them to bracket slots automatically.
`'manual'`	The bracket slots are created but left empty. The organiser uses dropdown selectors in the Results interface to assign each competitor to a slot.

The bracket size is always rounded up to the nearest power of 2. Any competitor who does not have a first-round opponent receives a bye (automatic advancement to the next round).

Optional seeding round

Setting hasSeeding: true on a category adds a preliminary round before the bracket. In this seeding round, all competitors complete an ao3 or ao5 set of solves (configured via seedingFormat). The resulting averages are ranked using the standard sortWCA comparator; the highest-ranked competitors receive the most favourable bracket positions (top seeds avoid each other until the later rounds).

interface CategoryLocal {
  format:         string;              // 'redbull'
  hasSeeding?:    boolean;
  seedingFormat?: 'ao3' | 'ao5';
  bracketMode?:   RedBullBracketMode;  // 'random' | 'manual'
  rounds:         RoundLocal[];
}

Round structure depending on seeding:

Configuration	Rounds stored
`hasSeeding: false`	`[bracket round (rb)]`
`hasSeeding: true`	`[seeding round (ao3/ao5, isSeeding: true), bracket round (rb)]`

When seeding is enabled and brackets are generated, competitors with the best seeding averages receive byes if the competitor count is not a power of 2. The remaining competitors play the first bracket round in seeded order (1st seed vs last, 2nd vs second-last, and so on).

Match structure

Each match is a best-of-3 series: the first competitor to win 2 individual races wins the match. Times are entered per-race, with penalties ('', '+2', 'DNF') available for each.

interface RedBullMatchLocal {
  id:           string;
  competitor1Id: string;
  competitor2Id: string;
  winner?:      string;   // ID of the winning competitor, set automatically
  times: {
    competitor1: (TimeRecord | null)[];  // up to 3 entries
    competitor2: (TimeRecord | null)[];
  };
  wins: {
    competitor1: number;
    competitor2: number;
  };
}

The app computes wins automatically when results are saved: for each race index, it compares the adjusted times (adding 2 for +2 penalties, treating DNF as a loss). A winner is set on the match as soon as one competitor reaches 2 wins. Once all matches in a bracket round have a winner, the app automatically populates the next round’s match slots with the advancing competitors.

The Red Bull format works best with 8 to 16 competitors per category. That range produces a bracket deep enough to be exciting (3–4 rounds including semifinals and a final) while remaining manageable for a single-day event. Fewer than 4 competitors results in just one or two matches; more than 32 can make the bracket unwieldy to manage offline.

Get Started

Core Concepts

Tournament Management

Competition Day

Reference

WCA and Red Bull competition formats in ruTournament

Average formats

Penalties

Average calculation: `calculateRulesStats`

Ranking: `sortWCA`

Multi-round advancement

Bracket mode

Optional seeding round

Match structure

Build docs developers (and LLMs) love

Get Started

Core Concepts

Tournament Management

Competition Day

Reference

Documentation Index

​Average formats

​Penalties

​Average calculation: calculateRulesStats

​Ranking: sortWCA

​Multi-round advancement

​Bracket mode

​Optional seeding round

​Match structure

Build docs developers (and LLMs) love

Average formats

Penalties

Average calculation: `calculateRulesStats`

Ranking: `sortWCA`

Multi-round advancement

Bracket mode

Optional seeding round

Match structure