How to use mage.game.tournament

private void eliminatePlayers(Round round) {
  for (TournamentPairing pair: round.getPairs()) {
    pair.eliminatePlayers();
  }
}

public void setStateAtTournamentEnd() {
  if (this.getState() == TournamentPlayerState.DRAFTING
      || this.getState() == TournamentPlayerState.CONSTRUCTING
      || this.getState() == TournamentPlayerState.DUELING
      || this.getState() == TournamentPlayerState.SIDEBOARDING
      || this.getState() == TournamentPlayerState.WAITING) {
    this.setState(TournamentPlayerState.FINISHED);
  }
}

public boolean isInTournament() {
  return !(this.getState() == TournamentPlayerState.CANCELED)
      && !(this.getState() == TournamentPlayerState.ELIMINATED)
      && !(this.getState() == TournamentPlayerState.FINISHED);
}

public TournamentTypeView(TournamentType tournamentType) {
  this.name = tournamentType.getName();
  this.minPlayers = tournamentType.getMinPlayers();
  this.maxPlayers = tournamentType.getMaxPlayers();
  this.numBoosters = tournamentType.getNumBoosters();
  this.draft = tournamentType.isDraft();
  this.limited = tournamentType.isLimited();
  this.cubeBooster = tournamentType.isCubeBooster();
  this.elimination = tournamentType.isElimination();
  this.random = tournamentType.isRandom();
  this.richMan = tournamentType.isRichMan();
}

public void playMatch(TournamentPairing pair) {
  options.getMatchOptions().getPlayerTypes().clear();
  options.getMatchOptions().getPlayerTypes().add(pair.getPlayer1().getPlayerType());
  options.getMatchOptions().getPlayerTypes().add(pair.getPlayer2().getPlayerType());
  tableEventSource.fireTableEvent(EventType.START_MATCH, pair, options.getMatchOptions());
}

@Override
public void fireConstructEvent(UUID playerId) {
  playerQueryEventSource.construct(playerId, "Construct", getOptions().getLimitedOptions().getConstructionTime());
}

  private boolean alreadyPaired(List<Round> rounds, TournamentPlayer player1, TournamentPlayer player2) {
    for (Round round : rounds) {
      for (TournamentPairing pairing : round.getPairs()) {
        if (pairing.getPlayer1().equals(player1) || pairing.getPlayer2().equals(player1)) {
          if (pairing.getPlayer1().equals(player2) || pairing.getPlayer2().equals(player2)) {
            return true;
          }
        }
      }
    }
    return false;
  }
}

public void setQuit(String info, TourneyQuitStatus status) {
  setEliminated();
  this.setState(TournamentPlayerState.CANCELED);
  this.setStateInfo(info);
  this.quit = true;
  this.doneConstructing = true;
  this.quitStatus = status;
}

private boolean allJoined() {
  if (!tournament.allJoined()) {
    return false;
  }
  for (TournamentPlayer player : tournament.getPlayers()) {
    if (player.getPlayer().isHuman() && tournamentSessions.get(player.getPlayer().getId()) == null) {
      return false;
    }
  }
  return true;
}

public void setEliminated() {
  this.setDisconnectInfo("");
  this.setState(TournamentPlayerState.ELIMINATED);
  this.eliminated = true;
}

private static String addRoundResult(int round, TournamentPairing pair, TournamentPlayer tournamentPlayer, TournamentPlayer opponentPlayer) {
  StringBuilder playerResult = new StringBuilder(tournamentPlayer.getResults());
  playerResult.append('R').append(round).append(' ');
  playerResult.append(getMatchResultString(tournamentPlayer, opponentPlayer, pair.getMatch()));
  return playerResult.toString();
}

  @Override
  public boolean canJoinTable(Table table) {
    if (table.isTournament()) {
      TournamentType tournamentType = table.getTournament().getTournamentType();
      if(tournamentType != null && tournamentType.isDraft()) {
        return true;
      }
    }
    return false;
  }
}

public void submitDeck(Deck deck) {
  this.deck = deck; // Check if player manipulated available cards???
  this.doneConstructing = true;
  this.setState(TournamentPlayerState.WAITING);
}

@Override
public int getNumberRounds() {
  return options.getNumberRounds();
}

protected void playMultiplayerRound(MultiplayerRound round) {
  playMultiPlayerMatch(round);
  updateResults(); // show points from byes
}

public UUID getTournamentId() {
  return tournament.getId();
}

@Override
public void construct(Tournament tournament, Deck deck) {
  tournament.fireConstructEvent(playerId);
}

public boolean updateDeck(Deck deck) {
  return tournament.updateDeck(playerId, deck);
}

public boolean isAbort() {
  return tournament.isAbort();
}

public void setConstructing() {
  this.setState(TournamentPlayerState.CONSTRUCTING);
  this.doneConstructing = false;
}