Function run_tournament

scripts/tournament_single_elim.py:303–339

The tournament is run in single elimination format. Maps are used in sets of 3, where the 3rd map of one round overlaps with the 1st map of the next round. So if the set of maps is [1, 2, 3, 4, 5], Round 1 will use maps [1, 2, 3] and Round 2 will use maps [3, 4, 5]. maps - A l

(conn, maps: List[Map], teams: List[Team])

def run_tournament(conn, maps: List[Map], teams: List[Team]):
    """
    The tournament is run in single elimination format. Maps are used in sets
    of 3, where the 3rd map of one round overlaps with the 1st map of the next
    round. So if the set of maps is [1, 2, 3, 4, 5], Round 1 will use maps
    [1, 2, 3] and Round 2 will use maps [3, 4, 5].

    maps  - A list of maps for the tournament, run in the order they are given.
    teams - A power of two number of teams, where some of the teams may be BYEs.
    """
    logging.debug('Generating a bracket for {} teams and {} maps'
        .format(len(teams), len(maps)))

    teams = generate_bracket(teams)
    num_rounds = int(math.log(len(teams), 2))

    logging.debug('We want {} maps, and we have {}'
        .format(num_rounds * 2 + 1, len(maps)))
    assert len(maps) >= num_rounds * 2 + 1

    initial_round = int(input('Start at which round? (0 to {}):\n'
        .format(num_rounds - 1)))

    logging.debug('Running rounds {} to {}... here we go!'
        .format(initial_round, num_rounds - 1))
    for round_num in range(initial_round, num_rounds):
        if round_num == 0:
            queue_initial_round(conn, teams, maps[:NUM_MAPS_PER_GAME])
            continue

        wait_for_empty_queue(conn)
        logging.debug('Queuing Round {} out of {}...'
            .format(round_num, num_rounds - 1))
        round_maps = maps[(NUM_MAPS_PER_GAME - 1) * round_num : 
                          (NUM_MAPS_PER_GAME - 1) * (round_num + 1) + 1]
        logging.debug('Using these maps: {}'.format(round_maps))
        queue_round(conn, round_num, round_maps)


def run(conn) -> None: