duel
Duel elimination tournament
npm install duel
Want to see pretty graphs? Log in now!
40 | downloads in the last month |
Last Published By | |
---|---|
Version | 0.5.0 last updated 4 months ago |
License | MIT |
Keywords | duel, elimination, tournament |
Repository | git://github.com/clux/duel (git) |
Homepage | https://github.com/clux/duel |
Bugs | http://github.com/clux/duel/issues |
Dependencies | interlude, tournament |
Duel elimination tournaments
Overview
Duel elimination tournaments consist of two players / teams per match. after each match the winner is advanced to the right in the bracket, and if loser bracket is in use, the loser is put in the loser bracket.
Duel tournaments can be of any size although perfect powers of 2 are the nicest because they are perfectly balanced. That said, the module will fill out the gaps with walkover markers (-1
) and will run an unbalanced tournament in the fairest possible way. Unbalanced tournaments typically benefits the highest seeds as these are the players receiving walk-overs in the first round.
A nice property of this duel tournament implementation is that if the seeding is perfect (i.e. if player a is seeded higher than player b, then player a wins over player b) then the top X in the results are also the top X seeded players. As an example, seed 1 can only meet seed 2 in the final in single elimination.
In this doc
For readibility and convenience:
WB
:=Duel.WB
:=1
LB
:=Duel.LB
:=2
Construction
Specify the number of players an optional options object.
// 5 players - single elimination (8 player model)
var duel3 = new Duel(5);
// 4 players - double elimination
var duel1 = new Duel(4, { last: LB });
The Duel.invalid(numPlayers, opts)
will tell you whether the constructor arguments produce a valid tournament. Read its entry in the tournament commonalities doc for info on this.
The only option supported at the moment is a boolean short
:
Short Variants
The default implementation of an elimination tournament includes the usual (but sometimes controversial) extra match in each case:
- bronze final in single elimination
- double grand final in double elimination
Passing a short:true
flag in the options object to the Duel
constructor will override the default behaviour and use the short variants.
// no bronze final in this
var duelSingle = new Duel(16, { short: true });
// winner of LB can win the grand final in one match
var duelDouble = new Duel(16, { last: LB, short: true });
NB: Short double elimination tournaments are strongly discouraged because they breaks several fairness properties. As a worst case example, if player 1 and 4 met early in the tournament and 1 won, 4 could come back from the losers bracket and win the grand final in one game despite the two players being 1-1 in games overall in the tournament.
Match Ids
Like all tournament types, matches have an id
object that contains three values all in {1, 2, ...}
:
{
s: Number, // the bracket - either WB or LB
r: Number, // the round number in the current bracket
m: Number // the match number in the current bracket and round
}
Finding matches
All the normal Base class helper methods exist on a Duel
instance.
Some notable examples follow:
var wb = duel.findMatches({ s: WB });
var lb = duel.findMatches({ s: LB });
var wbr3 = duel.findMatches({ s: WB, r: 3 });
var upcomingForSeed1 = duel.upcoming(1);
var matchesForSeed1 = duel.matchesFor(1);
Scoring Matches
Call duel.score(id, [player0Score, player1Score])
as for every match played.
The duel.unscorable(id, scoreArray)
will tell you whether the score is valid. Read the entry in the tournament commonalities doc.
NB: Restrictions
Duel tournaments does not allow ties at any stage. It's meant to eliminate, so you have to do your own best of 3 / overtime methods etc to determine winners in case of draws.
Special Methods
Progression Trackers
A players progress is in a tournament is entirely determined by a sequence of booleans for wins/losses. If you have a match id and want to know where a player will gets sent, either to the right in the bracket or downwards to the losers bracket, pass the id to the following helpers methods:
duel.right(id [, underdogWon]) :: [rightId, index]
duel.down(id [, underdogWon]) :: [downId, index]
The underdogWon
bool is simply whether the winner is the player at the bottom in the players array, and is only needed for accurate double grand final cases for double elimination.
The index
returned is the index in the player array the winner (if right
) or loser (if down
) will end up in. This is mostly beneficial internally. If you end up using this, you'd likely want to look at duel.upcoming(playerId)
.
duel.roundName(id) :: String
Find the name of the round that id
is found in. The id
must minimally contain { s: bracket, r: round }
.
var d = new Duel(4, WB);
d.roundName(d.matches[3].id);
'Bronze Final';
d.roundName(d.matches[2].id);h
'Grand Final'
Caveats
End progression
Towards the end of a duel tournament, players may move in seemingly strange ways. These are:
- In single elimination, winner of the each semi final goes to
{ s: WB, r: duel.p, m: 1 }
, whereas the loser goes to{ s: LB, r: 1, m: 1 }
.
The duel.p
is the power of the tournament (defined as smallest integer p
such that 2^(p-1)
is the number of matches in WBR1). The WB final always occurs in this round.
The loser gets sent to the bronze final which is situated in "LBR1", perhaps a little oddly so, but it the bronze final does contain two losers, and it's the first round where losers get to play.
- In double elimination: the winner of the winner bracket final go to the grand final in
{ s: LB, r: 2*duel.p - 1, m: 1 }
to meet the winner of the losers bracket.
This is a special case match of double eliminations. The match is neither in the winners bracket nor the losers bracket because it got players from both, but by our convention it is located in the losers bracket. It also makes the following convention more sensible:
- In double elimination: if the grand final in
{ s: LB, r: 2*duel.p - 1, m: 1 }
is won by the player coming from the losers bracket, then a second grand final is required, and is located in{ s: LB, r: 2*duel.p, m: 1 }
.
This makes more sense, because we can sensibly say that both players are in the losers bracket (both having lost one match). The winner of this second grand final wins the tournament. Note that if the winner of the winner bracket wins the first grand final, the second grand final (the last match in duel.matches) never gets its players filled in, however duel.isDone()
will return true. Double elimination tournaments are the only tournaments where isDone()
can return true while a match is not played.
Bracket movement
In double elimination, the losers bracket moves upwards to meet the winner bracket close to the final. This is a design decision that unfortunately has to be made, because it affects the match ids score
will drop the next player at. An issue is open for this, but it is currently not prioritized.
License
MIT-Licensed. See LICENSE file for details.