brackets-manager/dist/ordering.js

A simple library to manage tournament brackets (round-robin, single elimination, double elimination)

"use strict";
// https://web.archive.org/web/20200601102344/https://tl.net/forum/sc2-tournaments/202139-superior-double-elimination-losers-bracket-seeding
Object.defineProperty(exports, "__esModule", { value: true });
exports.defaultMinorOrdering = exports.ordering = void 0;
exports.ordering = {
    'natural': (array) => [...array],
    'reverse': (array) => [...array].reverse(),
    'half_shift': (array) => [...array.slice(array.length / 2), ...array.slice(0, array.length / 2)],
    'reverse_half_shift': (array) => [...array.slice(0, array.length / 2).reverse(), ...array.slice(array.length / 2).reverse()],
    'pair_flip': (array) => {
        const result = [];
        for (let i = 0; i < array.length; i += 2)
            result.push(array[i + 1], array[i]);
        return result;
    },
    'inner_outer': (array) => {
        if (array.length === 2)
            return array;
        const size = array.length / 4;
        const innerPart = [array.slice(size, 2 * size), array.slice(2 * size, 3 * size)]; // [_, X, X, _]
        const outerPart = [array.slice(0, size), array.slice(3 * size, 4 * size)]; // [X, _, _, X]
        const methods = {
            inner(part) {
                return [part[0].pop(), part[1].shift()];
            },
            outer(part) {
                return [part[0].shift(), part[1].pop()];
            },
        };
        const result = [];
        /**
         * Adds a part (inner or outer) of a part.
         *
         * @param part The part to process.
         * @param method The method to use.
         */
        function add(part, method) {
            if (part[0].length > 0 && part[1].length > 0)
                result.push(...methods[method](part));
        }
        for (let i = 0; i < size / 2; i++) {
            add(outerPart, 'outer'); // Outer part's outer
            add(innerPart, 'inner'); // Inner part's inner
            add(outerPart, 'inner'); // Outer part's inner
            add(innerPart, 'outer'); // Inner part's outer
        }
        return result;
    },
    'groups.effort_balanced': (array, groupCount) => {
        const result = [];
        let i = 0, j = 0;
        while (result.length < array.length) {
            result.push(array[i]);
            i += groupCount;
            if (i >= array.length)
                i = ++j;
        }
        return result;
    },
    'groups.seed_optimized': (array, groupCount) => {
        const groups = Array.from({ length: groupCount }, (_) => []);
        for (let run = 0; run < array.length / groupCount; run++) {
            if (run % 2 === 0) {
                for (let group = 0; group < groupCount; group++)
                    groups[group].push(array[run * groupCount + group]);
            }
            else {
                for (let group = 0; group < groupCount; group++)
                    groups[groupCount - group - 1].push(array[run * groupCount + group]);
            }
        }
        return groups.flat();
    },
    'groups.bracket_optimized': () => {
        throw Error('Not implemented.');
    },
};
exports.defaultMinorOrdering = {
    // 1 or 2: Not possible.
    4: ['natural', 'reverse'],
    8: ['natural', 'reverse', 'natural'],
    16: ['natural', 'reverse_half_shift', 'reverse', 'natural'],
    32: ['natural', 'reverse', 'half_shift', 'natural', 'natural'],
    64: ['natural', 'reverse', 'half_shift', 'reverse', 'natural', 'natural'],
    128: ['natural', 'reverse', 'half_shift', 'pair_flip', 'pair_flip', 'pair_flip', 'natural'],
};
//# sourceMappingURL=ordering.js.map