Tournaments

Tournaments is a Pixelmon sidemod and Sponge plugin for creating Pokémon tournaments. It also provides an API to further customize tournaments.

Contents

Installation

Minecraft version Pixelmon version Tournaments version
1.10.2 5.1.1+ 2.1.0

Tournaments is a Sponge plugin, which means it is only for installation on servers. It requires both Pixelmon and SpongeForge to install. The plugin only needs to be in the mods directory of the server for it to run.

  1. Download Tournaments for your version of Minecraft here.
  2. Place the jar inside the mods folder in the server root directory (in the same directory as SpongeForge).

Usage

The first step in running a tournament is creating the tournament with /tournament create. This creates a new tournament, but does not immediately open it for joining. The tournament can be configured with rule- and reward-adding commands, with the base /tournament command to check the existing tournament's settings. Using /tournament open will open it for players to join and send a server-wide announcement advertising the tournament. Players can join using /tournament join. Once players have joined, tournament admins can use /tournament start to start the first tournament round. After starting the tournament, it will continue to run automatically until it is completed.

Commands

Note: Command syntax is displayed in the standard Minecraft command format. An explanation of this format can be found here.

  • /tournament: Gives general information about any current tournament, including rules, current matches, and teams.
    • create [preset] : Creates a new tournament. If an argument is given, a preset of that name will attempt to load.
    • open: Opens the created tournament for players to join.
    • start: Signals the tournament controller to start the tournament. After it has started, the first round will be calculated and started.
    • close: Shuts down any existing tournament.
    • rules: Gives the list of rules for any current tournament.
      • add <ruleType[:argument]>: Adds a rule to the tournament, given rule type and the optional argument. E.g., /tournament rules add LevelMax:50.
      • remove <rule-type>: Removes all current rules of the given type.
      • test [player]: Tests whether a player, and if possible the player's team and side, passes the rules of the tournament. This is primarily for testing custom rules.
    • rewards: Gives the list of rewards for any current tournament.
      • add <rewardType[:argument]>: Adds a reward to the tournament, given the rule type and the optional argument. E.g., /tournament rewards add pokemon:starly,lvl:5,s,gr:Enormous.
      • remove <rewardType>: Removes all current rewards of the given type.
      • test [player]: Gives the sender or the optional argument player the rewards for the tournament. This is primarily for testing custom rewards.
    • zones: Lists the current zones for battle areas. Through the provided interface, new ones can be created or removed.
      • leavezone: Warps to the currently set leave zone. This is the zone players are warped to after their matches end.
        • set: Sets the leave zone for the tournament.
    • presets: Checks the registered presets for rules and rewards.
      • save <name>: Saves the current tournament's rules and rewards to a preset with the given name. If the given name already exists as a preset, it is overwritten.
      • load <name>: Loads the preset with the given name (if it exists) into the current tournament.
      • delete <name>: Deletes the preset with the given name. This cannot be undone.
      • rename <old name> <new name>: Renames a preset.
    • join [teammate]: Joins the tournament. If a player name is given and the tournament allows double teams, the player is invited to join as a double team.
    • leave: Leaves the tournament, if possible. This is not possible in later stages of the tournament, and instead forfeiting is necessary.
    • forfeit [player]: Forfeits the tournament. If a player argument is provided and the user has permission, the given player will be forced to forfeit.
    • flag: Flags a battle as bugged. If both sides flag a battle as bugged, it will be turned into a rematch.
    • ignore [true|false]: Toggles or sets for the user whether tournament messages should be hidden.
    • reroll: Gets a new set of random Pokémon, provided the tournament has the RandomPokemon rule with some number of rerolls allowed, and the player has some rerolls remaining.
    • reload: Reloads all external tournament data and configurations.

Permission nodes

Admin nodes

Note: All admin nodes can be given at once by setting tournaments.command.admin.

  • tournaments.command.admin.create: Permission to create a tournament.
  • tournaments.command.admin.tournaments: Permission to open/close/start a tournament.
  • tournaments.command.admin.rules: Permission to modify rules, and see normally hidden rules.
  • tournaments.command.admin.rewards: Permission to modify rewards and see normally hidden rewards.
  • tournaments.command.admin.presets: Permission to handle presets for rules and rewards.
  • tournaments.command.admin.forfeit: Permission to force other players to forfeit.
  • tournaments.command.admin.zones: Permission to set and inspect zones.
  • tournaments.command.admin.reload: Permission to reload all data and configurations

Common nodes

Note: All common nodes can be given at once by setting tournaments.command.common.

  • tournaments.command.common.tournaments: Permission to view basic tournament information.
  • tournaments.command.common.join: Permission to join a tournament.
  • tournaments.command.common.leave: Permission to leave a tournament.
  • tournaments.command.common.forfeit: Permission to forfeit.
  • tournaments.command.common.ignore: Permission to ignore a tournament's messages.
  • tournaments.command.common.rules: Permission to view a tournament's rules with the rules sub-command.
  • tournaments.command.common.rewards: Permission to view a tournament's rewards with the rewards sub-command.
  • tournaments.command.common.flag: Permission to flag a battle as bugged.
  • tournaments.command.common.reroll: Permission to get a new set of random Pokémon

Provided implementations

Rules

General rules

  • BattleType:<option>: Sets the type of battles that will occur depending on the option.
    • single: Standard single battles, teams are only allowed to have 1 player.
    • double: Double battles, teams are allowed to have either 1 or 2 players. Note: This is best coupled with a PartyMax rule.
    • double1: Double battles, teams are only allowed to have 1 player.
    • double2: Double battles, teams are only allowed to have 2 players.
  • TeamCap:<cap>[,autostart]: Establishes a cap on the number of teams that may join the tournament. If autostart is set, the tournament will begin the moment the tournament is full.
  • SetParty[:specificLevel]: Selects a level for all the Pokémon in the tournament to be temporarily moved to during battles. If a specific level is not given, the rule will attempt to use any existing LevelMin and LevelMax rules to choose what an unacceptable level is, and what level should be set for each Pokémon. If there is neither a LevelMax rule nor a LevelMin rule, all Pokémon are set to level 100.

Decider rules

  • HealthTotal[:weight]: If a battle crashes, a victor will be decided by the side who has the most HP. If a weight is provided, the higher it is, the higher the priority of this decision. Defaults to 1.
  • PartyCount[:weight]: If a battle crashes, a victor will be decided by the side who has the most unfainted Pokémon. If a weight is provided, the higher it is, the higher the priority of this decision. Defaults to 3.

Team rules

  • PartyMax:<1-6>: A team's party (all the Pokémon for every player in the team) is counted (excluding Eggs), and the team is disqualified if the total is larger than the given maximum.
  • PartyMin:<1-6>: A team's party (all the Pokémon for every player in the team) is counted (excluding Eggs), and the team is disqualified if the total is less than the given minimum.

Player rules

  • LevelMax:<1-100>: Every Pokémon in a player's party must have a level less than or equal to the given maximum.
  • LevelMin:<1-100>: Every Pokémon in a player's party must have a level greater than or equal to the given minimum.
  • Healing:<true|false>: If true, healing between battles is both permitted and automated. If false, players will be disqualified if their parties get new Pokémon or their Pokémon are healed in any way.
  • DisallowedAbility:<ability[,ability,...]>: A team may not have the specified Ability(s) (case sensitive). Adding this rule multiple times adds to the list of disallowed Abilities.
  • HeldItems:<true|false>: If true, held items are allowed. If false, no one may use Pokémon holding held items.
  • PokemonTiers:<Pokémon Tiers...>: Defines what tiers of Pokémon can be used during the tournament (see table below).
  • RandomPokemon:pokemon:<number of Pokémon>[,Comma-separated options]: Defines a tournament where random Pokémon are given to the joining teams, and taken afterwards. The available options are:
    • rentalOnly: If set, Pokémon used in the tournament must be among those given to them when they joined.
    • localDuplicates: If set, the given Pokémon will have the chance of being duplicate species.
    • !globalDuplicates: If set, the random generator will not attempt to minimize the number of times the same Pokémon species is given throughout the entire tournament.
    • rerolls:<amount> Sets the number of times a player may use /tournament reroll to get a different set of random Pokémon (1 by default). If set to -1, no rerolls will be allowed.
    • Pokémon spec: Any characteristics from the Pokémon spec format to apply to the random Pokémon.
    • Pokémon tiers...: Comma-separated list of Pokemon tiers (see table below), all of which the given Pokémon must be a part of. If a Pokémon tiers rule is not active at the time of a RandomPokemon rule with this option being added, one will be created to match the given tiers. If one does exist, the tiers will be synchronized between the two rule types.

Rewards

  • Pokemon:<Pokémon spec>: A Pokémon reward. This is in the same format as the /pokegive and /pokespawn commands. E.g., Gyarados,level:1,s,ab:Moxie".
  • Items:<player>: A reward of various items. The given player is the player whose inventory will be taken and used as the reward.
  • Money:<amount>: A reward of the given amount of PokéDollars.
  • Command:[text:<text>;]<cmd:<command>>: Executes a command, replacing all instances of {{player}} with the rewarded player's name. The way to display this reward to players (from /tournament rewards is set with the text option. This is an &-formatting line. E.g., Command:text:&2Example reward;cmd:kill {{player}}.

Pokémon tiers

This is a list of the recognized tiers of Pokémon within Tournaments. This system of classification can be used to create combinations of tiers. Custom tiers can be loaded by added a file ending with .tier.txt into the ./config/tiers directory. The contents of this file should be a line reading display name=<some name>, and then simply a vertical list of all Pokémon contained in the tier.

Tier Key Description
NoLegendaries The tier containing all non-Legendary Pokémon
Legendaries The tier containing all Legendary Pokémon
Gen1 The tier containing all Generation 1 Pokémon (Pokédex numbers 1-151).
Gen2 The tier containing all Generation 2 Pokémon (Pokédex numbers 152-251).
Gen3 The tier containing all Generation 3 Pokémon (Pokédex numbers 252-386).
Gen4 The tier containing all Generation 4 Pokémon (Pokédex numbers 387-493).
Gen5 The tier containing all Generation 5 Pokémon (Pokédex numbers 494-649).
Gen6 The tier containing all Generation 6 Pokémon (Pokédex numbers 650-721).
FE The tier containing all Pokémon that are fully evolved or have no evolutions.
NFE The tier containing all Pokémon that are not fully evolved, and so can still evolve
LC The tier containing Little Cup Pokémon. These are all Pokémon that have not evolved but are able to.
Monotype The tier containing all Pokémon that have only 1 type.
Dualtype The tier containing all Pokémon with 2 types.

For example, Gen1,NFE,Monotype would be all Generation 1 Pokémon that cannot evolve and only have 1 type.

If incompatible tiers are combined, such as Gen1 and Gen2, the tier will be empty.

Configuration

This is a table of all the configuration options within the main Tournaments config (under ./config/tournaments/tournaments.json). In all message config options, leaving the message blank will result in the message not being sent.

Option Description Placeholders (if applicable)
baseCommandAliases A list of all the names for the base /tournament command.
overrideForceEndBattleOption Whether or not the Pixelmon.hocon config option "forceEndBattleResult" should be overridden to prevent issues with tournament flagging and forfeiting. It is strongly recommended that this value not be changed.
timeBeforeMatch The number of seconds after match announcements or rematch announcements that the match should be started. This must be larger than 5 seconds to give time for zone teleportation.
nextZoneID A value used to give unique ID numbers to zones. Modifying this should be avoided when possible.
joinMessage The message to send when a team joins the tournament. {{team}}
leaveMessage The message to send when a team leaves the tournament. {{team}}
forfeitMessage The message to send when a team forfeits the tournament. {{team}}
openMessage The message to send when the tournament is opened.
startMessage The message to send when the tournament starts.
closeMessage The message to send when the tournament closes. This only sends when the tournament was in the active or open state.
noWinnerMessage The message to send when the tournament finishes and there are no winners.
winnerMessage The message to send when the tournament finishes with at least one winner. {{winners}}
matchWinMessage The message to send when a match ends with a winning side and a losing side. {{winners}}, {{losers}}
matchDrawMessage The message to send when a match ends in a draw. {{match}}, {{time}}
matchErrorMessage The message to send when a match ends in an error of some kind. {{match}}, {{time}}
upcomingRoundMessage The message to send when a round is announced. {{round}}
byeMessage The message to send to a team when receiving a free round (a bye).
insufficientPokemonMessage The message to send when a side has insufficient Pokémon for a battle, resulting in disqualification. {{side}}
offlinePlayerMessage The message to send when a single-player team is offline for a battle, resulting in disqualification. {{side}}
offlinePlayersMessage The message to send when a multi-player team has at least one too many members offline for a battle, resulting in disqualification. {{side}}
ruleBreakMessage The message to send when a side breaks a rule, resulting in disqualification. {{ruleerror}}
ignorePromptMessage The message to send when the tournament opens, prompting players to click it to prevent seeing any further tournament messages.
ignoreToggleOnMessage The message to send to a player when turning tournament messages off.
ignoreToggleOffMessage The message to send to a player when they turning tournament messages on.

The placeholders and what they represent are as follows.

Placeholder Description
{{team}} The team in this context. This is either the player's name, or both players' names separated by an ampersand.
{{side}} The side of a match. This is typically identical to {{team}}, but ultimately represents a side of a battle and could potentially be formulated as {{team}} & {{team}}.
{{match}} The match. This is formulated as {{side}} vs. {{side}}.
{{time}} The number of seconds in this context. Typically replaced with the timeBeforeMatch value in the main configuration.
{{winners}} The winning team(s) in this context. This is a comma-separated list of {{team}} regardless of context. If there is only one team, this is identical to {{team}}.
{{losers}} The losing team(s). This is a comma-separated list of {{team}}. If there is only one team, this is identical to {{team}}.
{{round}} A round of matches. This is formulated as a new line separated list of {{match}}. If there is only one match, this is identical to {{match}}.
{{ruleerror}} The details of the broken rule. This includes the {{side}} which broke the rule, and the error thrown by the specific rule.

Version history

Version history/Tournaments