public UUID getTournamentId() { return tournament.getId(); }
public void rejoin(UUID playerId) { TournamentSession tournamentSession = tournamentSessions.get(playerId); if (tournamentSession == null) { logger.fatal("Tournament session not found - playerId:" + playerId + " tournamentId " + tournament.getId()); return; } if (!tournamentSession.init()) { logger.fatal("Unable to initialize client userId: " + tournamentSession.userId + " tournamentId " + tournament.getId()); return; } tournamentSession.update(); }
public void createTournamentSession(Tournament tournament, ConcurrentHashMap<UUID, UUID> userPlayerMap, UUID tableId) { TournamentController tournamentController = new TournamentController(tournament, userPlayerMap, tableId); controllers.put(tournament.getId(), tournamentController); }
private synchronized void setupTimeout(int seconds) { if (futureTimeout != null && !futureTimeout.isDone()) { return; } cancelTimeout(); if (seconds > 0) { futureTimeout = timeoutExecutor.schedule( () -> { try { TournamentManager.instance.timeout(tournament.getId(), userId); } catch (Exception e) { logger.fatal("TournamentSession error - userId " + userId + " tId " + tournament.getId(), e); } }, seconds, TimeUnit.SECONDS ); } }
private synchronized void startTournament() { for (final TournamentSession tournamentSession : tournamentSessions.values()) { if (!tournamentSession.init()) { logger.fatal("Unable to initialize client userId: " + tournamentSession.userId + " tournamentId " + tournament.getId()); //TODO: generate client error message return; } } started = true; logger.debug("Tournament starts (all players joined): " + tournament.getId() + " - " + tournament.getTournamentType().toString()); tournament.nextStep(); }
public TournamentController(Tournament tournament, ConcurrentHashMap<UUID, UUID> userPlayerMap, UUID tableId) { this.userPlayerMap = userPlayerMap; chatId = ChatManager.instance.createChatSession("Tournament " + tournament.getId()); this.tournament = tournament; this.tableId = tableId; init(); }
public void gameOver(final String message) { if (!killed) { UserManager.instance.getUser(userId).ifPresent(user -> user.fireCallback(new ClientCallback(ClientCallbackMethod.TOURNAMENT_OVER, tournament.getId(), message))); } }
public boolean init() { if (!killed) { Optional<User> user = UserManager.instance.getUser(userId); if (user.isPresent()) { user.get().fireCallback(new ClientCallback(ClientCallbackMethod.TOURNAMENT_INIT, tournament.getId(), getTournamentView())); return true; } } return false; }
public synchronized void startTournament(UUID userId) { try { if (userId.equals(this.userId) && table.getState() == TableState.STARTING) { tournament.setStartTime(); TournamentManager.instance.createTournamentSession(tournament, userPlayerMap, table.getId()); for (Entry<UUID, UUID> entry : userPlayerMap.entrySet()) { UserManager.instance.getUser(entry.getKey()).ifPresent(user -> { logger.info(new StringBuilder("User ").append(user.getName()).append(" tournament started: ").append(tournament.getId()).append(" userId: ").append(user.getId())); user.ccTournamentStarted(tournament.getId(), entry.getValue()); }); } ServerMessagesUtil.instance.incTournamentsStarted(); } } catch (Exception ex) { logger.fatal("Error starting tournament", ex); TableManager.instance.removeTable(table.getId()); TournamentManager.instance.quit(tournament.getId(), userId); } }
public synchronized void join(UUID userId) { UUID playerId = userPlayerMap.get(userId); if (playerId == null) { if (logger.isDebugEnabled()) { UserManager.instance.getUser(userId).ifPresent(user -> logger.debug(user.getName() + " shows tournament panel tournamentId: " + tournament.getId())); } return; } if (tournamentSessions.containsKey(playerId)) { logger.debug("player reopened tournament panel userId: " + userId + " tournamentId: " + tournament.getId()); return; } // first join of player TournamentSession tournamentSession = new TournamentSession(tournament, userId, tableId, playerId); tournamentSessions.put(playerId, tournamentSession); Optional<User> _user = UserManager.instance.getUser(userId); if (_user.isPresent()) { User user = _user.get(); user.addTournament(playerId, tournament.getId()); TournamentPlayer player = tournament.getPlayer(playerId); player.setJoined(); logger.debug("player " + player.getPlayer().getName() + " - client has joined tournament " + tournament.getId()); ChatManager.instance.broadcast(chatId, "", player.getPlayer().getLogName() + " has joined the tournament", MessageColor.BLACK, true, MessageType.STATUS, null); checkStart(); } else { logger.error("User not found userId: " + userId + " tournamentId: " + tournament.getId()); } }
public void update() { if (!killed) { UserManager.instance.getUser(userId).ifPresent(user -> user.fireCallback(new ClientCallback(ClientCallbackMethod.TOURNAMENT_UPDATE, tournament.getId(), getTournamentView()))); } }
private boolean updateDeck(UUID userId, UUID playerId, Deck deck) { boolean validDeck = true; if (table.isTournament()) { if (tournament != null) { validDeck = TournamentManager.instance.updateDeck(tournament.getId(), playerId, deck); } else { logger.fatal("Tournament == null table: " + table.getId() + " userId: " + userId); } } else if (TableState.SIDEBOARDING == table.getState()) { validDeck = match.updateDeck(playerId, deck); } else { // deck was meanwhile submitted so the autoupdate can be ignored } return validDeck; }
public boolean isTournamentStillValid() { if (table.getTournament() != null) { if (table.getState() != TableState.WAITING && table.getState() != TableState.READY_TO_START && table.getState() != TableState.STARTING) { return TournamentManager.instance.getTournamentController(table.getTournament().getId()) .map(tc -> tc.isTournamentStillValid(table.getState())) .orElse(false); } else { // check if table creator is still a valid user, if not removeUserFromAllTablesAndChat table return UserManager.instance.getUser(userId).isPresent(); } } return false; }
private void submitDeck(UUID userId, UUID playerId, Deck deck) { if (table.getState() == TableState.SIDEBOARDING) { match.submitDeck(playerId, deck); UserManager.instance.getUser(userId).ifPresent(user -> user.removeSideboarding(table.getId())); } else { TournamentManager.instance.submitDeck(tournament.getId(), playerId, deck); UserManager.instance.getUser(userId).ifPresent(user -> user.removeConstructing(playerId)); } }
public void userQuitTournamentSubTables(UUID tournamentId, UUID userId) { for (TableController controller : getControllers()) { if (controller.getTable().isTournamentSubTable() && controller.getTable().getTournament().getId().equals(tournamentId)) { if (controller.hasPlayer(userId)) { controller.leaveTable(userId); } } } }
public void quit(UUID userId) { UUID playerId = userPlayerMap.get(userId); if (playerId == null) { logger.debug("Player not found userId:" + userId + " tournId: " + tournament.getId()); return; logger.debug("TournamentPlayer not found userId: " + userId + " tournId: " + tournament.getId()); return; logger.debug("TournamentSession not found userId: " + userId + " tournId: " + tournament.getId()); return; info = new StringBuilder("during round ").append(tournament.getRounds().size()).toString(); TableManager.instance.userQuitTournamentSubTables(tournament.getId(), userId); status = TourneyQuitStatus.DURING_ROUND; } else if (tournamentPlayer.getState() == TournamentPlayerState.DRAFTING) {
@Override public void quitDraft(final UUID draftId, final String sessionId) throws MageException { execute("quitDraft", sessionId, () -> { try { callExecutor.execute( () -> { Optional<Session> session = SessionManager.instance.getSession(sessionId); if (!session.isPresent()) { logger.error("Session not found : " + sessionId); } else { UUID userId = session.get().getUserId(); UUID tableId = DraftManager.instance.getControllerByDraftId(draftId).getTableId(); Table table = TableManager.instance.getTable(tableId); if (table.isTournament()) { UUID tournamentId = table.getTournament().getId(); TournamentManager.instance.quit(tournamentId, userId); } } } ); } catch (Exception ex) { handleException(ex); } } ); }
private void initTournamentTable(Table table) { this.matchId = table.getTournament().getId(); this.matchName = table.getName(); this.gameType = table.getGameType();
public synchronized void startMatch() { if (table.getState() == TableState.STARTING) { try { if (table.isTournamentSubTable()) { logger.info("Tourn. match started id:" + match.getId() + " tournId: " + table.getTournament().getId()); } else { UserManager.instance.getUser(userId).ifPresent(user -> { logger.info("MATCH started [" + match.getName() + "] " + match.getId() + '(' + user.getName() + ')'); logger.debug("- " + match.getOptions().getGameType() + " - " + match.getOptions().getDeckType()); }); } match.startMatch(); startGame(null); } catch (GameException ex) { logger.fatal("Error starting match ", ex); match.endGame(); } } }
public boolean watchTable(UUID userId) { if (table.isTournament()) { UserManager.instance.getUser(userId).ifPresent(user -> user.ccShowTournament(table.getTournament().getId())); return true; } else { if (table.isTournamentSubTable() && !table.getTournament().getOptions().isWatchingAllowed()) { return false; } if (table.getState() != TableState.DUELING) { return false; } // you can't watch your own game if (userPlayerMap.get(userId) != null) { return false; } Optional<User> _user = UserManager.instance.getUser(userId); if (!_user.isPresent()) { return false; } return _user.get().ccWatchGame(match.getGame().getId()); } }