FFA-TB
A free-for-all style tournament, but with tiebreakers in between each round to ensure we can pick out the designated number of advancers unambiguously each round. It is an implementation of tourney.
It is a pointless abstraction if you are modelling a game/sport in which match level ties cannot occur, but for when that's not true - or if you are providing a tiebreaking resolution outside an actual match - then this will provide the glue needed.
Usage
Use like FFA
, but watch for stages. What follows is a comprehensive stage-by-stage example.
Creation
All the constructor arguments are identical to FFA. This example will follow a three round tournament with 16 players in round one, 8 in round two, and 4 in round three. The top 2 from each match (match sizes always 4) will proceed to the next round, and we have additionally asked for an unambiguous top 2 from the final.
var FfaTb = ;var trn = 16 sizes: 4 4 4 advancers: 2 2 limit: 2 ;
Scoring Stages
Each stage is scored in turn. First round is the quarter finals:
trn; // truetrnmatches id: s: 1 r: 1 m: 1 p: 1 5 12 16 id: s: 1 r: 1 m: 2 p: 2 6 11 15 id: s: 1 r: 1 m: 3 p: 3 7 10 14 id: s: 1 r: 1 m: 4 p: 4 8 9 13 trnmatches;
This will complete the first stage, but not the entire tourney:
trn; // truetrn; // false - two more ffa rounds to gotrn; // true - must createNextStage when stageDone && !isDone
Creating next stage will update state, and now we are in a tiebreaker round to resolve match 3:
trn; // truetrnmatches; id: s: 3 r: 1 m: 1 p: 7 10 // 2nd placers from match 3 must be resolvedtrn; trn && !trn; // truetrn; // true - intermediate tiebreaker stage over
This made for a short stage (and typically tiebreakers are short), so we are now back to the FFA part, in round 2, the semifinals:
trn; // truetrn; // false - these are the semistrnmatches; id: s: 1 r: 1 m: 1 p: 1 3 6 10 // player 10 won tiebreaker id: s: 1 r: 1 m: 2 p: 2 4 5 8 trnmatches; trn && !trn; // truetrn; // true - advance to round 3
This round did not have any tiebreakers, so we skip any tiebreaker stages after round 2 and go straight to the final:
trn && trn; // true - in last round, and we're in FFAtrnmatches id: s: 1 r: 1 m: 1 p: 1 2 3 4 // top seeds won their semis trn; // complete tie in final trn && !trn; // true - need to tiebreak final (limit set to 2)trn; // true
Because we had set limit
, we are now forced to replay the final in a tiebreaker:
trn && trn; // true// matches is complete replay of final - full tietrnmatches id: s: 1 r: 1 m: 1 p: 1 2 3 4 trn; // tie slightly lesstrn && !trn; // true - need to tiebreak final bettertrn; // true
This goes on if things do not resolve, but we did at least knock out player 4:
trn && trn; // truetrnmatches; id: s: 1 r: 1 m: 1 p: 1 2 3 trn); // tied for 1st placetrn && trn; // true - we don't need to break the top 2
This is actually sufficient. Note that we have a tie for 1st place, but we can pick out our top 2, which is all we asked of limit
. If you wanted the top 2, then split these two, you would really have an extra FFA round with 2 players and have limit
at 1.
At any rate, this example is over, let's lock it down so no one comes around later and messes with the final state:
trncomplete;
Tiebreaker algorithm
See tiebreaker module. We will break the smallest cluster necessary to determine the top n
players where n
is the current advancers number or the limit
in the final round.
Since we have established that we can play matches with more than 2 players, tiebreakers are simple
, meaning they will make a single multiple player match which is a subset of the previous match. This is different from default behaviour in groupstage tiebreakers which actually require subgroups when there are multi-way ties.
Modelling and tiebreaker matches
In most cases, tiebreaker matches resolve most conflicts with modelling, and maps nicely onto the physical world. However, sometimes this is not true:
Suppose a match tied, but external factors (not present in the map score) actually decided who broke. For such a situation you have two options:
- Use tiebreaker round as model only
I.e. fill in the tiebreaker match with enough external information (pretend it was an actual match) to indicate to tournament who clearly won.
- Lie to FFA and encapsulate external information in original map score
This way, since you never actually intend to play physical tiebreaker matches, you can just use FFA directly.
Both of these solutions are fine, and it comes to you how much data you want.
Modelling Examples
Football
Football/soccer never really presents a physical tiebreaker match, but it certainly does tiebreak. Overtime rounds and penalty shootouts can all be viewed as individual tiebreaker matches, or you can just look at the grand total goal sum as the final score.
Whichever you want to use for a football tournament would depend on the information you want. Since the goals are pretty much perfectly the match score, you could easily just not use tiebreaker since the game itself has a way of resolving ties.
However, if you want a way to model the individual parts of the tiebreaking resolution, it could be useful (but note that this can more easily be done with metadata outside tournament structures).
Quake FFA
Say you stick 10 players in a deatmatch server and want to take the pick the top 5. When the match is over, it is over. If there's a tie between 5th, 6th, and 7th, then extending the match would be unfair to the top 4 that clearly should proceed. In this case a tiebreaker match where these three players play another round of FFA is really the perfect fit.
Given the perfect fit of model and physical reality of the situation, this is were this module shines over plain FFA
.
You could technically still choose not to model this inside the module, and present an amalgamated final score; i.e. if the scores were [10,9,8,7,6,6,6,3,2,1]
and the tie resolver [3,2,1]
, you could just score the match as [10,9,8,7,6,5,4,3,2,1]
and gloss over the details.
Doing so would be a little silly though. This module can formalize manual tiebreaking processes, provide transparency, and can limit the time needed for organizers to work out this kind of stuff.
Installation
Install from npm:
$ npm install ffa-tb
License
MIT-Licensed. See LICENSE file for details.