Tournament Specification Ideas

There have been various thoughts on tournament running programs and tournament specifications on the Registry lately. I was thinking about going in yet another direction from the two already proposed, and realized it might be good to take a step back and do a tournament specification in English, which could then serve as a basis for work in VB, XML, Python, and anything else.

The way the problem had been worked on was just people diving in and writing XML or whatever. I was thinking a more structured approach might be useful, and the structured approach that seemed most relevant was the one from Code Complete. That book defines a process for constructing programs in a professional context, which I have sort of abstracted.

Yoyodyn suggested a wiki, so here it is. When we're just making a list of stuff, if you want to add on, go ahead and do so. If you think we need a massive rewrite, please start a discussion about it, either here on on the Registry, before changing anything.

Once everyone involved thinks we're set on one step of the process, we can move on to the next one. I sort of skipped over the first step, but that one seemed pretty obvious. I could be wrong, of course...

What's the Problem?
The first step in the process is to define the problem. The problem, it seems to me, is that we don't have a consistent way to specify tournaments for any of the various tournament applications that have been proposed.

Definition of Terms

 * Game - A single game in Robot Battle, when only one robot remains, or a timeout occurs the game is over.
 * Match - A match is a set of games in a round. In Robot Battle rarely is one game sufficient to choose a winner.  Therefore multiple games are run in a match to overcome random advantages that may occur due to position or heading.
 * Round - A round is a logical division of a tournament. A tournament may consist of one or more rounds which may be run the same way, or under a different rule set.  A round may contain one or more Matches.  For example, in a Round Robin tournament each robot is pair against every other robot in a match.  After all the robots have been played against all the others, the round would be complete.
 * Tournament - A tournament contains one or more rounds where the robots are played against each other and score under some set of rules to the end that the robots may be ordered from the best performing robot to the worst.
 * Tournament Definition - An electronic file or files that describes the name, length, rule-set, advancement, scoring methods, and other criteria to be used while running the tournament.
 * Tournament Engine - An application, service, person, or script that can run a tournament by reading the tournament definition.

What's the Software Supposed to Do?
Next, we need a clear specification of what the software (or specification, in this case) should do. I think this is where we brain storm ideas about what tournaments need to be covered.

Specific Tournaments
The following specific tournaments should be specifiable:


 * Round Robin
 * Grouped (as in the World Cup)
 * Single Elimination
 * With or without third place match
 * Double/Triple/Etc. elimination
 * Mixed or split losers bracket
 * Step ladder tournament
 * Swiss system
 * I believe this system requires a complicated initial seeding, as well as the rule that one never faces the same opponent twice.
 * No seeding is required, and is simple when used. Complicated seeding is the province of single elimination tournaments. -Ick
 * The rule of not facing an opponent twice is common, but I'm not sure if it's required. -Ick
 * I think the system should support this option though.
 * League/division system
 * Poker elimination
 * This breaks down into a kind of multi-tiered AILO doesn't it?
 * Perhaps, but I think that sort of distinction should be held off until at least the modularization step. -Ick
 * Ladder system
 * Challenge or ranking points
 * All-In Variants: AILO/AIFO/AIFOLO

Matches
Matches should be specifiable for the entire tournament or different parts of the tournament. (Or should they? Is there a situation where you would want different matches for different rounds, and you couldn't think of it as a multi-stage tournament?)

Multi-Stage Tournaments
We would want to be able to link tournaments together, in order to make a grander tournament. Multi-stage situations that need to be covered:


 * Points are carried over from one stage to another
 * Points used only for seeding
 * Eliminations occur between stages
 * Best loser exception
 * Tournaments held in parallel with promotion and relegation (as in the Rally Cup)
 * This could be handled by allowing tournaments to be defined in terms of other tournaments, including a recursive definition.
 * Wouldn't the recent double elimination tournament (AILO-4) be better defined as a single tournament? Even though the two matches could be considered different.
 * If you mean the AIDE-N, I'd say two tournaments. It's an AILO that gives you seeds for another tournament (I'm not sure if I'd call the second part a ladder or a single-elimination). I think anything you can specify as a multi-stage tournament you could describe as a single tournament, but specifying it as multi-stage simplifies things. -Ick

One Shot/Ongoing
The specification should be able to handle ongoing tournaments, or those that just happen once.

Scoring
Scores and one or more tie breakers should be specifiable for any variable in the statistics or score logs. This would cover things like the Flag Bot tournament.

Teams
Obviously teams need to be covered. Team situations that need to be covered:


 * A tournament without teams
 * A tournament where scores/advancement is determined by teams
 * A tournament with teams, but where scores/advancement is deteremine by individual robots.
 * Teams should be able to be set up statically before the tournament, or dynamically (based on a tournament rule), during the tournament.

Exclusions
Things we are specifically not worried about covering, although they may be covered incidentally:


 * Anything that just requires one match to run.
 * Tournament engine will not perform robot code restriction checks for those tournaments that require certain coding practices to be enforced.

Modularization
The third step would be to break down the specification into pieces, and generally decide what each of those pieces would do. We're not at this step yet, so don't put anything here, but keep it in the back of your mind.