External/mage
1
0
Fork 1
mirror of https://github.com/magefree/mage.git synced 2025-12-24 12:31:59 -08:00
Code Issues Projects Releases Packages Wiki Activity Actions

added Sealed tournaments

Browse source
This commit is contained in:
BetaSteward 2011-02-10 22:00:47 -05:00
parent 44aefaf47a
commit f7ffbb4773
51 changed files with 652 additions and 143 deletions
Download patch file Download diff file Expand all files Collapse all files

8
Mage.Server/src/main/java/mage/server/Session.java
View file

@ -102,12 +102,12 @@ public class Session {
fireCallback(new ClientCallback("startTournament", new TableClientMessage(tournamentId, playerId)));
}
public void sideboard(final Deck deck, final UUID tableId) {
fireCallback(new ClientCallback("sideboard", new TableClientMessage(deck, tableId)));
public void sideboard(final Deck deck, final UUID tableId, final int time) {
fireCallback(new ClientCallback("sideboard", new TableClientMessage(deck, tableId, time)));
}
public void construct(final Deck deck, final UUID tableId) {
fireCallback(new ClientCallback("construct", new TableClientMessage(deck, tableId)));
public void construct(final Deck deck, final UUID tableId, final int time) {
fireCallback(new ClientCallback("construct", new TableClientMessage(deck, tableId, time)));
}
public void watchGame(final UUID gameId) {

65
Mage.Server/src/main/java/mage/server/TableController.java
View file

@ -68,9 +68,6 @@ import mage.game.tournament.Tournament;
import mage.game.tournament.TournamentOptions;
import mage.game.tournament.TournamentPlayer;
import mage.players.Player;
import mage.server.ChatManager;
import mage.server.Main;
import mage.server.SessionManager;
import mage.server.game.DeckValidatorFactory;
import mage.server.game.GameFactory;
import mage.server.game.GameManager;
@ -88,6 +85,8 @@ public class TableController {
private final static Logger logger = Logging.getLogger(TableController.class.getName());
private static final int SIDEBOARD_TIME = 180;
private UUID sessionId;
private UUID chatId;
private Table table;
@ -124,9 +123,9 @@ public class TableController {
case SIDEBOARD:
sideboard(event.getPlayerId(), event.getDeck());
break;
case CONSTRUCT:
construct(event.getPlayerId(), event.getDeck());
break;
// case CONSTRUCT:
// construct(event.getPlayerId(), event.getDeck());
// break;
case SUBMIT_DECK:
submitDeck(event.getPlayerId(), event.getDeck());
break;
@ -200,30 +199,21 @@ public class TableController {
if (table.getState() != TableState.SIDEBOARDING && table.getState() != TableState.CONSTRUCTING) {
return false;
}
String playerName;
if (table.getState() == TableState.SIDEBOARDING) {
MatchPlayer player = match.getPlayer(sessionPlayerMap.get(sessionId));
playerName = player.getPlayer().getName();
}
else {
TournamentPlayer player = tournament.getPlayer(sessionPlayerMap.get(sessionId));
playerName = player.getPlayer().getName();
}
Deck deck = Deck.load(deckList);
if (!Main.server.isTestMode() && !validDeck(deck)) {
throw new GameException(playerName + " has an invalid deck for this format");
throw new GameException("Invalid deck for this format");
}
submitDeck(sessionPlayerMap.get(sessionId), deck);
submitDeck(sessionId, deck);
return true;
}
private void submitDeck(UUID playerId, Deck deck) {
private void submitDeck(UUID sessionId, Deck deck) {
if (table.getState() == TableState.SIDEBOARDING) {
MatchPlayer player = match.getPlayer(playerId);
MatchPlayer player = match.getPlayer(sessionPlayerMap.get(sessionId));
player.submitDeck(deck);
}
else {
tournament.submitDeck(playerId, deck);
TournamentManager.getInstance().submitDeck(tournament.getId(), sessionId, deck);
}
}
@ -294,6 +284,7 @@ public class TableController {
public synchronized void startTournament(UUID sessionId) {
if (sessionId.equals(this.sessionId) && table.getState() == TableState.STARTING) {
table.initTournament();
TournamentManager.getInstance().createTournamentSession(tournament, sessionPlayerMap, table.getId());
SessionManager sessionManager = SessionManager.getInstance();
for (Entry<UUID, UUID> entry: sessionPlayerMap.entrySet()) {
@ -324,29 +315,29 @@ public class TableController {
SessionManager sessionManager = SessionManager.getInstance();
for (Entry<UUID, UUID> entry: sessionPlayerMap.entrySet()) {
if (entry.getValue().equals(playerId)) {
sessionManager.getSession(entry.getKey()).sideboard(deck, table.getId());
sessionManager.getSession(entry.getKey()).sideboard(deck, table.getId(), SIDEBOARD_TIME);
break;
}
}
}
public void construct() {
table.construct();
for (TournamentPlayer player: tournament.getPlayers()) {
player.setConstructing();
player.getPlayer().construct(table, player.getDeck());
}
}
// public void construct() {
// table.construct();
// for (TournamentPlayer player: tournament.getPlayers()) {
// player.setConstructing();
// player.getPlayer().construct(table, player.getDeck());
// }
// }
private void construct(UUID playerId, Deck deck) {
SessionManager sessionManager = SessionManager.getInstance();
for (Entry<UUID, UUID> entry: sessionPlayerMap.entrySet()) {
if (entry.getValue().equals(playerId)) {
sessionManager.getSession(entry.getKey()).construct(deck, table.getId());
break;
}
}
}
// private void construct(UUID playerId, Deck deck) {
// SessionManager sessionManager = SessionManager.getInstance();
// for (Entry<UUID, UUID> entry: sessionPlayerMap.entrySet()) {
// if (entry.getValue().equals(playerId)) {
// sessionManager.getSession(entry.getKey()).construct(deck, table.getId(), CONSTRUCT_TIME);
// break;
// }
// }
// }
public void endGame() {
UUID choosingPlayerId = match.getChooser();

6
Mage.Server/src/main/java/mage/server/TableManager.java
View file

@ -161,9 +161,9 @@ public class TableManager {
}
}
public void construct(UUID tableId) {
controllers.get(tableId).construct();
}
// public void construct(UUID tableId) {
// controllers.get(tableId).construct();
// }
public void addPlayer(UUID sessionId, UUID tableId, Player player, String playerType, Deck deck) throws GameException {
controllers.get(tableId).addPlayer(sessionId, player, playerType, deck);

1
Mage.Server/src/main/java/mage/server/draft/DraftController.java
View file

@ -175,7 +175,6 @@ public class DraftController {
public void timeout(UUID sessionId) {
if (sessionPlayerMap.containsKey(sessionId)) {
// ChatManager.getInstance().broadcast(chatId, "", draft.getPlayer(sessionPlayerMap.get(sessionId)).getPlayer().getName() + " has timed out. Auto picking.", MessageColor.BLACK);
draft.autoPick(sessionPlayerMap.get(sessionId));
}
}

4
Mage.Server/src/main/java/mage/server/draft/DraftManager.java
View file

@ -76,11 +76,11 @@ public class DraftManager {
draftControllers.get(draftId).kill(sessionId);
}
void timeout(UUID gameId, UUID sessionId) {
public void timeout(UUID gameId, UUID sessionId) {
draftControllers.get(gameId).timeout(sessionId);
}
void removeDraft(UUID draftId) {
public void removeDraft(UUID draftId) {
draftControllers.remove(draftId);
}

41
Mage.Server/src/main/java/mage/server/tournament/TournamentController.java
View file

@ -33,10 +33,12 @@ import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;
import java.util.logging.Level;
import java.util.logging.Logger;
import mage.cards.decks.Deck;
import mage.game.GameException;
import mage.game.Table;
import mage.game.draft.Draft;
import mage.game.events.Listener;
import mage.game.events.PlayerQueryEvent;
import mage.game.events.TableEvent;
import mage.game.match.MatchOptions;
import mage.game.tournament.Tournament;
@ -64,6 +66,8 @@ public class TournamentController {
private ConcurrentHashMap<UUID, UUID> sessionPlayerMap = new ConcurrentHashMap<UUID, UUID>();
private ConcurrentHashMap<UUID, TournamentSession> tournamentSessions = new ConcurrentHashMap<UUID, TournamentSession>();
private static final int CONSTRUCT_TIME = 600;
public TournamentController(Tournament tournament, ConcurrentHashMap<UUID, UUID> sessionPlayerMap, UUID tableId) {
sessionId = UUID.randomUUID();
this.sessionPlayerMap = sessionPlayerMap;
@ -83,15 +87,27 @@ public class TournamentController {
ChatManager.getInstance().broadcast(chatId, "", event.getMessage(), MessageColor.BLACK);
logger.finest(tournament.getId() + " " + event.getMessage());
break;
case CONSTRUCT:
construct();
break;
case START_DRAFT:
startDraft(event.getDraft());
break;
case START_MATCH:
startMatch(event.getPair(), event.getMatchOptions());
break;
case SUBMIT_DECK:
submitDeck(event.getPlayerId(), event.getDeck());
break;
}
}
}
);
tournament.addPlayerQueryEventListener(
new Listener<PlayerQueryEvent> () {
@Override
public void event(PlayerQueryEvent event) {
switch (event.getQueryType()) {
case CONSTRUCT:
construct(event.getPlayerId(), event.getDeck(), event.getMax());
break;
}
}
}
@ -108,7 +124,7 @@ public class TournamentController {
public synchronized void join(UUID sessionId) {
UUID playerId = sessionPlayerMap.get(sessionId);
TournamentSession tournamentSession = new TournamentSession(tournament, sessionId, playerId);
TournamentSession tournamentSession = new TournamentSession(tournament, sessionId, tableId, playerId);
tournamentSessions.put(playerId, tournamentSession);
TournamentPlayer player = tournament.getPlayer(playerId);
player.setJoined();
@ -170,8 +186,21 @@ public class TournamentController {
TableManager.getInstance().startDraft(tableId, draft);
}
private void construct() {
TableManager.getInstance().construct(tableId);
private synchronized void construct(UUID sessionId, Deck deck, int timeout) {
if (tournamentSessions.containsKey(sessionId))
tournamentSessions.get(sessionId).construct(deck, timeout);
}
public void submitDeck(UUID sessionId, Deck deck) {
tournamentSessions.get(sessionPlayerMap.get(sessionId)).submitDeck(deck);
}
public void timeout(UUID sessionId) {
if (sessionPlayerMap.containsKey(sessionId)) {
TournamentPlayer player = tournament.getPlayer(sessionPlayerMap.get(sessionId));
tournament.autoSubmit(sessionPlayerMap.get(sessionId), player.getDeck());
}
}
public UUID getSessionId() {

9
Mage.Server/src/main/java/mage/server/tournament/TournamentManager.java
View file

@ -30,6 +30,7 @@ package mage.server.tournament;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;
import mage.cards.decks.Deck;
import mage.game.tournament.Tournament;
import mage.view.TournamentView;
@ -61,6 +62,14 @@ public class TournamentManager {
controllers.get(tournamentId).kill(sessionId);
}
public void timeout(UUID tournamentId, UUID sessionId) {
controllers.get(tournamentId).timeout(sessionId);
}
public void submitDeck(UUID tournamentId, UUID sessionId, Deck deck) {
controllers.get(tournamentId).submitDeck(sessionId, deck);
}
public TournamentView getTournamentView(UUID tournamentId) {
return controllers.get(tournamentId).getTournamentView();
}

47
Mage.Server/src/main/java/mage/server/tournament/TournamentSession.java
View file

@ -30,12 +30,17 @@ package mage.server.tournament;
import java.rmi.RemoteException;
import java.util.UUID;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.TimeUnit;
import java.util.logging.Level;
import java.util.logging.Logger;
import mage.cards.decks.Deck;
import mage.game.tournament.Tournament;
import mage.interfaces.callback.ClientCallback;
import mage.server.Session;
import mage.server.SessionManager;
import mage.server.util.ThreadExecutor;
import mage.util.Logging;
import mage.view.TournamentView;
@ -48,13 +53,18 @@ public class TournamentSession {
protected UUID sessionId;
protected UUID playerId;
protected UUID tableId;
protected Tournament tournament;
protected boolean killed = false;
public TournamentSession(Tournament tournament, UUID sessionId, UUID playerId) {
private ScheduledFuture<?> futureTimeout;
protected static ScheduledExecutorService timeoutExecutor = ThreadExecutor.getInstance().getTimeoutExecutor();
public TournamentSession(Tournament tournament, UUID sessionId, UUID tableId, UUID playerId) {
this.sessionId = sessionId;
this.tournament = tournament;
this.playerId = playerId;
this.tableId = tableId;
}
public boolean init(final TournamentView tournamentView) {
@ -94,6 +104,20 @@ public class TournamentSession {
}
}
public void construct(Deck deck, int timeout) {
if (!killed) {
setupTimeout(timeout);
Session session = SessionManager.getInstance().getSession(sessionId);
if (session != null)
session.construct(deck, tableId, timeout);
}
}
public void submitDeck(Deck deck) {
cancelTimeout();
tournament.submitDeck(playerId, deck);
}
protected void handleRemoteException(RemoteException ex) {
logger.log(Level.SEVERE, null, ex);
TournamentManager.getInstance().kill(tournament.getId(), sessionId);
@ -103,4 +127,25 @@ public class TournamentSession {
killed = true;
}
private synchronized void setupTimeout(int seconds) {
cancelTimeout();
if (seconds > 0) {
futureTimeout = timeoutExecutor.schedule(
new Runnable() {
@Override
public void run() {
TournamentManager.getInstance().timeout(tournament.getId(), sessionId);
}
},
seconds, TimeUnit.SECONDS
);
}
}
private synchronized void cancelTimeout() {
if (futureTimeout != null) {
futureTimeout.cancel(false);
}
}
}