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

client/server overhaul - tested on localhost, remote testing pending

Browse source
This commit is contained in:
BetaSteward 2011-05-24 23:52:26 -04:00
parent ecbd843fb7
commit 892f7cce1b
90 changed files with 4448 additions and 500 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -34,6 +34,8 @@ import java.util.Calendar;
import java.util.GregorianCalendar;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;
import mage.MageException;
import mage.interfaces.callback.CallbackException;
import mage.interfaces.callback.ClientCallback;
import mage.view.ChatMessage;
import mage.view.ChatMessage.MessageColor;
@ -78,7 +80,11 @@ public class ChatSession {
for (UUID sessionId: clients.keySet()) {
Session session = SessionManager.getInstance().getSession(sessionId);
if (session != null)
session.fireCallback(new ClientCallback("chatMessage", chatId, new ChatMessage(msg, color)));
try {
session.fireCallback(new ClientCallback("chatMessage", chatId, new ChatMessage(msg, color)));
} catch (CallbackException ex) {
logger.fatal("broadcast error", ex);
}
else
kill(sessionId);
}

18
Mage.Server/src/main/java/mage/server/ServerImpl.java
View file

@ -38,13 +38,15 @@ import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
import java.util.concurrent.ExecutorService;
import java.util.logging.Level;
import mage.cards.decks.DeckCardLists;
import mage.game.GameException;
import mage.interfaces.MageException;
import mage.MageException;
import mage.game.match.MatchOptions;
import mage.game.tournament.TournamentOptions;
import mage.interfaces.Server;
import mage.interfaces.ServerState;
import mage.interfaces.callback.CallbackException;
import mage.interfaces.callback.ClientCallback;
import mage.server.game.DeckValidatorFactory;
import mage.server.draft.DraftManager;
@ -105,8 +107,8 @@ public class ServerImpl extends RemoteServer implements Server {
}
@Override
public void ack(String message, UUID sessionId) throws RemoteException, MageException {
SessionManager.getInstance().getSession(sessionId).ack(message);
public void ack(int messageId, UUID sessionId) throws RemoteException, CallbackException {
SessionManager.getInstance().getSession(sessionId).ack(messageId);
}
@Override
@ -209,9 +211,10 @@ public class ServerImpl extends RemoteServer implements Server {
return ret;
}
}
catch (GameException ex) {
throw ex;
}
catch (Exception ex) {
if (ex instanceof GameException)
throw (GameException)ex;
handleException(ex);
}
return false;
@ -226,9 +229,10 @@ public class ServerImpl extends RemoteServer implements Server {
return ret;
}
}
catch (GameException ex) {
throw ex;
}
catch (Exception ex) {
if (ex instanceof GameException)
throw (GameException)ex;
handleException(ex);
}
return false;

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

@ -30,7 +30,12 @@ package mage.server;
import java.util.Date;
import java.util.UUID;
import java.util.logging.Level;
import mage.cards.decks.Deck;
import mage.game.GameException;
import mage.MageException;
import mage.interfaces.callback.CallbackAck;
import mage.interfaces.callback.CallbackException;
import mage.interfaces.callback.CallbackServerSession;
import mage.interfaces.callback.ClientCallback;
import mage.server.game.GameManager;
@ -50,11 +55,12 @@ public class Session {
private String username;
private String host;
private int messageId = 0;
private String ackMessage;
private Date timeConnected;
private long lastPing;
private boolean isAdmin = false;
private boolean killed = false;
private final CallbackServerSession callback = new CallbackServerSession();
private final CallbackAck ackResponse = new CallbackAck();
public Session(String userName, String host, UUID clientId) {
sessionId = UUID.randomUUID();
@ -84,6 +90,8 @@ public class Session {
}
public void kill() {
this.killed = true;
ackResponse.notify();
SessionManager.getInstance().removeSession(sessionId);
TableManager.getInstance().removeSession(sessionId);
GameManager.getInstance().removeSession(sessionId);
@ -99,55 +107,116 @@ public class Session {
return null;
}
public synchronized void fireCallback(final ClientCallback call) {
public synchronized void fireCallback(final ClientCallback call) throws CallbackException {
call.setMessageId(messageId++);
if (logger.isDebugEnabled())
logger.debug(sessionId + " - " + call.getMessageId() + " - " + call.getMethod());
try {
callback.setCallback(call);
int retryCount = 0;
while (retryCount < 3) {
callback.setCallback(call);
if (waitForAck(call.getMessageId()))
return;
retryCount++;
try {
Thread.sleep(2000 * retryCount);
}
catch (InterruptedException ignored) {}
}
} catch (InterruptedException ex) {
logger.fatal("Session fireCallback error", ex);
}
throw new CallbackException("Callback failed for " + call.getMethod());
}
protected boolean waitForAck(int messageId) {
ackResponse.clear();
if (logger.isDebugEnabled())
logger.debug(sessionId + " - waiting for ack: " + messageId);
synchronized(ackResponse) {
try {
if (!ackResponse.isAck())
ackResponse.wait(10000);
if (logger.isDebugEnabled()) {
if (!ackResponse.isAck())
logger.debug(sessionId + " - ack timed out waiting for " + messageId);
else
logger.debug(sessionId + " - ack received: " + messageId);
}
return ackResponse.getValue() == messageId;
} catch (InterruptedException ex) { }
}
return false;
}
public void gameStarted(final UUID gameId, final UUID playerId) {
fireCallback(new ClientCallback("startGame", gameId, new TableClientMessage(gameId, playerId)));
public void gameStarted(final UUID gameId, final UUID playerId) throws GameException {
try {
fireCallback(new ClientCallback("startGame", gameId, new TableClientMessage(gameId, playerId)));
} catch (CallbackException ex) {
logger.fatal("gameStarted exception", ex);
throw new GameException("callback failed");
}
}
public void draftStarted(final UUID draftId, final UUID playerId) {
fireCallback(new ClientCallback("startDraft", draftId, new TableClientMessage(draftId, playerId)));
public void draftStarted(final UUID draftId, final UUID playerId) throws MageException {
try {
fireCallback(new ClientCallback("startDraft", draftId, new TableClientMessage(draftId, playerId)));
} catch (CallbackException ex) {
logger.fatal("draftStarted exception", ex);
throw new MageException("callback failed");
}
}
public void tournamentStarted(final UUID tournamentId, final UUID playerId) {
fireCallback(new ClientCallback("startTournament", tournamentId, new TableClientMessage(tournamentId, playerId)));
public void tournamentStarted(final UUID tournamentId, final UUID playerId) throws MageException {
try {
fireCallback(new ClientCallback("startTournament", tournamentId, new TableClientMessage(tournamentId, playerId)));
} catch (CallbackException ex) {
logger.fatal("tournamentStarted exception", ex);
throw new MageException("callback failed");
}
}
public void sideboard(final Deck deck, final UUID tableId, final int time) {
fireCallback(new ClientCallback("sideboard", tableId, new TableClientMessage(deck, tableId, time)));
public void sideboard(final Deck deck, final UUID tableId, final int time) throws MageException {
try {
fireCallback(new ClientCallback("sideboard", tableId, new TableClientMessage(deck, tableId, time)));
} catch (CallbackException ex) {
logger.fatal("sideboard exception", ex);
throw new MageException("callback failed");
}
}
public void construct(final Deck deck, final UUID tableId, final int time) {
fireCallback(new ClientCallback("construct", tableId, new TableClientMessage(deck, tableId, time)));
public void construct(final Deck deck, final UUID tableId, final int time) throws MageException {
try {
fireCallback(new ClientCallback("construct", tableId, new TableClientMessage(deck, tableId, time)));
} catch (CallbackException ex) {
logger.fatal("construct exception", ex);
throw new MageException("callback failed");
}
}
public void watchGame(final UUID gameId) {
fireCallback(new ClientCallback("watchGame", gameId));
public void watchGame(final UUID gameId) throws MageException {
try {
fireCallback(new ClientCallback("watchGame", gameId));
} catch (CallbackException ex) {
logger.fatal("watchGame exception", ex);
throw new MageException("callback failed");
}
}
public void replayGame(final UUID gameId) {
fireCallback(new ClientCallback("replayGame", gameId));
try {
fireCallback(new ClientCallback("replayGame", gameId));
} catch (CallbackException ex) {
logger.fatal("replayGame exception", ex);
}
}
public void ack(String message) {
this.ackMessage = message;
}
public String getAckMessage() {
return ackMessage;
}
public void clearAck() {
this.ackMessage = "";
public void ack(int messageId) {
synchronized(ackResponse) {
ackResponse.setAck(true);
ackResponse.setValue(messageId);
ackResponse.notify();
}
}
public String getUsername() {

3
Mage.Server/src/main/java/mage/server/SessionManager.java
View file

@ -37,7 +37,7 @@ import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
import mage.interfaces.MageException;
import mage.MageException;
import mage.view.UserView;
import org.apache.log4j.Logger;
@ -97,6 +97,7 @@ public class SessionManager {
}
public void checkSessions() {
logger.info("Checking sessions");
for (Session session: sessions.values()) {
if (!session.stillAlive()) {
logger.info("Client for user " + session.getUsername() + ":" + session.getId() + " timed out - releasing resources");

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

@ -28,6 +28,7 @@
package mage.server;
import java.util.logging.Level;
import mage.Constants.RangeOfInfluence;
import mage.Constants.TableState;
import mage.cards.decks.Deck;
@ -44,6 +45,7 @@ import mage.game.match.Match;
import mage.game.match.MatchOptions;
import mage.game.tournament.Tournament;
import mage.game.tournament.TournamentOptions;
import mage.MageException;
import mage.players.Player;
import mage.server.challenge.ChallengeManager;
import mage.server.draft.DraftManager;
@ -104,13 +106,17 @@ public class TableController {
new Listener<TableEvent> () {
@Override
public void event(TableEvent event) {
switch (event.getEventType()) {
case SIDEBOARD:
sideboard(event.getPlayerId(), event.getDeck(), event.getTimeout());
break;
case SUBMIT_DECK:
submitDeck(event.getPlayerId(), event.getDeck());
break;
try {
switch (event.getEventType()) {
case SIDEBOARD:
sideboard(event.getPlayerId(), event.getDeck(), event.getTimeout());
break;
case SUBMIT_DECK:
submitDeck(event.getPlayerId(), event.getDeck());
break;
}
} catch (MageException ex) {
logger.fatal("Table event listener error", ex);
}
}
}
@ -202,8 +208,13 @@ public class TableController {
if (table.getState() != TableState.DUELING) {
return false;
}
SessionManager.getInstance().getSession(sessionId).watchGame(match.getGame().getId());
return true;
try {
SessionManager.getInstance().getSession(sessionId).watchGame(match.getGame().getId());
return true;
} catch (MageException ex) {
logger.fatal("watchTable error", ex);
}
return false;
}
public boolean replayTable(UUID sessionId) {
@ -312,26 +323,37 @@ public class TableController {
}
public synchronized void startTournament(UUID sessionId) {
if (sessionId.equals(this.sessionId) && table.getState() == TableState.STARTING) {
TournamentManager.getInstance().createTournamentSession(tournament, sessionPlayerMap, table.getId());
SessionManager sessionManager = SessionManager.getInstance();
for (Entry<UUID, UUID> entry: sessionPlayerMap.entrySet()) {
Session session = sessionManager.getSession(entry.getKey());
session.tournamentStarted(tournament.getId(), entry.getValue());
try {
if (sessionId.equals(this.sessionId) && table.getState() == TableState.STARTING) {
TournamentManager.getInstance().createTournamentSession(tournament, sessionPlayerMap, table.getId());
SessionManager sessionManager = SessionManager.getInstance();
for (Entry<UUID, UUID> entry: sessionPlayerMap.entrySet()) {
Session session = sessionManager.getSession(entry.getKey());
session.tournamentStarted(tournament.getId(), entry.getValue());
}
}
}
catch (Exception ex) {
logger.fatal("Error starting tournament", ex);
TableManager.getInstance().removeTable(table.getId());
TournamentManager.getInstance().kill(tournament.getId(), sessionId);
}
}
public void startDraft(Draft draft) {
table.initDraft();
DraftManager.getInstance().createDraftSession(draft, sessionPlayerMap, table.getId());
SessionManager sessionManager = SessionManager.getInstance();
for (Entry<UUID, UUID> entry: sessionPlayerMap.entrySet()) {
sessionManager.getSession(entry.getKey()).draftStarted(draft.getId(), entry.getValue());
try {
for (Entry<UUID, UUID> entry: sessionPlayerMap.entrySet()) {
sessionManager.getSession(entry.getKey()).draftStarted(draft.getId(), entry.getValue());
}
} catch (MageException ex) {
logger.fatal("startDraft error", ex);
}
}
private void sideboard(UUID playerId, Deck deck, int timeout) {
private void sideboard(UUID playerId, Deck deck, int timeout) throws MageException {
SessionManager sessionManager = SessionManager.getInstance();
for (Entry<UUID, UUID> entry: sessionPlayerMap.entrySet()) {
if (entry.getValue().equals(playerId)) {

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

@ -39,6 +39,7 @@ import mage.game.draft.Draft;
import mage.game.match.Match;
import mage.game.match.MatchOptions;
import mage.game.tournament.TournamentOptions;
import mage.MageException;
import mage.players.Player;
import mage.server.game.GamesRoomManager;
import org.apache.log4j.Logger;

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

@ -38,6 +38,7 @@ import mage.game.draft.DraftPlayer;
import mage.game.events.Listener;
import mage.game.events.PlayerQueryEvent;
import mage.game.events.TableEvent;
import mage.MageException;
import mage.server.game.GameController;
import mage.server.TableManager;
import mage.server.util.ThreadExecutor;
@ -73,13 +74,18 @@ public class DraftController {
new Listener<TableEvent> () {
@Override
public void event(TableEvent event) {
switch (event.getEventType()) {
case UPDATE:
updateDraft();
break;
case END:
endDraft();
break;
try {
switch (event.getEventType()) {
case UPDATE:
updateDraft();
break;
case END:
endDraft();
break;
}
}
catch (MageException ex) {
logger.fatal("Table event listener error", ex);
}
}
}
@ -88,10 +94,15 @@ public class DraftController {
new Listener<PlayerQueryEvent> () {
@Override
public void event(PlayerQueryEvent event) {
switch (event.getQueryType()) {
case PICK_CARD:
pickCard(event.getPlayerId(), event.getMax());
break;
try {
switch (event.getQueryType()) {
case PICK_CARD:
pickCard(event.getPlayerId(), event.getMax());
break;
}
}
catch (MageException ex) {
logger.fatal("Table event listener error", ex);
}
}
}
@ -156,7 +167,7 @@ public class DraftController {
draft.leave(getPlayerId(sessionId));
}
private void endDraft() {
private void endDraft() throws MageException {
for (final DraftSession draftSession: draftSessions.values()) {
draftSession.draftOver();
}
@ -189,13 +200,13 @@ public class DraftController {
return null;
}
private synchronized void updateDraft() {
private synchronized void updateDraft() throws MageException {
for (final Entry<UUID, DraftSession> entry: draftSessions.entrySet()) {
entry.getValue().update(getDraftView());
}
}
private synchronized void pickCard(UUID playerId, int timeout) {
private synchronized void pickCard(UUID playerId, int timeout) throws MageException {
if (draftSessions.containsKey(playerId))
draftSessions.get(playerId).pickCard(getDraftPickView(playerId, timeout), timeout);
}

62
Mage.Server/src/main/java/mage/server/draft/DraftSession.java
View file

@ -33,7 +33,10 @@ 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 mage.game.draft.Draft;
import mage.MageException;
import mage.interfaces.callback.CallbackException;
import mage.interfaces.callback.ClientCallback;
import mage.server.Session;
import mage.server.SessionManager;
@ -69,44 +72,62 @@ public class DraftSession {
if (!killed) {
Session session = SessionManager.getInstance().getSession(sessionId);
if (session != null) {
session.clearAck();
session.fireCallback(new ClientCallback("draftInit", draft.getId(), draftView));
if (waitForAck("draftInit"))
try {
session.fireCallback(new ClientCallback("draftInit", draft.getId(), draftView));
return true;
} catch (CallbackException ex) {
logger.fatal("Unable to start draft ", ex);
return false;
}
}
}
return false;
}
public boolean waitForAck(String message) {
Session session = SessionManager.getInstance().getSession(sessionId);
do {
//TODO: add timeout
} while (!session.getAckMessage().equals(message) && !killed);
return true;
}
// public boolean waitForAck(String message) {
// Session session = SessionManager.getInstance().getSession(sessionId);
// do {
// //TODO: add timeout
// } while (!session.getAckMessage().equals(message) && !killed);
// return true;
// }
public void update(final DraftView draftView) {
if (!killed) {
Session session = SessionManager.getInstance().getSession(sessionId);
if (session != null)
session.fireCallback(new ClientCallback("draftUpdate", draft.getId(), draftView));
if (session != null) {
try {
session.fireCallback(new ClientCallback("draftUpdate", draft.getId(), draftView));
} catch (CallbackException ex) {
logger.fatal("update draft exception", ex);
}
}
}
}
public void inform(final String message, final DraftView draftView) {
if (!killed) {
Session session = SessionManager.getInstance().getSession(sessionId);
if (session != null)
session.fireCallback(new ClientCallback("draftInform", draft.getId(), new DraftClientMessage(draftView, message)));
if (session != null) {
try {
session.fireCallback(new ClientCallback("draftInform", draft.getId(), new DraftClientMessage(draftView, message)));
} catch (CallbackException ex) {
logger.fatal("draft inform exception", ex);
}
}
}
}
public void draftOver() {
if (!killed) {
Session session = SessionManager.getInstance().getSession(sessionId);
if (session != null)
session.fireCallback(new ClientCallback("draftOver", draft.getId()));
if (session != null) {
try {
session.fireCallback(new ClientCallback("draftOver", draft.getId()));
} catch (CallbackException ex) {
logger.fatal("draft end exception", ex);
}
}
}
}
@ -114,8 +135,13 @@ public class DraftSession {
if (!killed) {
setupTimeout(timeout);
Session session = SessionManager.getInstance().getSession(sessionId);
if (session != null)
session.fireCallback(new ClientCallback("draftPick", draft.getId(), new DraftClientMessage(draftPickView)));
if (session != null) {
try {
session.fireCallback(new ClientCallback("draftPick", draft.getId(), new DraftClientMessage(draftPickView)));
} catch (CallbackException ex) {
logger.fatal("draft pick exception", ex);
}
}
}
}

4
Mage.Server/src/main/java/mage/server/game/GameCallback.java
View file

@ -28,12 +28,14 @@
package mage.server.game;
import mage.MageException;
/**
*
* @author BetaSteward_at_googlemail.com
*/
public interface GameCallback {
public void gameResult(String result);
public void gameResult(String result) throws MageException;
}

127
Mage.Server/src/main/java/mage/server/game/GameController.java
View file

@ -29,8 +29,10 @@
package mage.server.game;
import java.io.BufferedOutputStream;
import java.util.logging.Level;
import mage.game.LookedAt;
import mage.MageException;
import mage.server.TableManager;
import java.io.File;
import java.io.FileOutputStream;
@ -103,17 +105,21 @@ public class GameController implements GameCallback {
new Listener<TableEvent> () {
@Override
public void event(TableEvent event) {
switch (event.getEventType()) {
case UPDATE:
updateGame();
break;
case INFO:
ChatManager.getInstance().broadcast(chatId, "", event.getMessage(), MessageColor.BLACK);
logger.debug(game.getId() + " " + event.getMessage());
break;
case REVEAL:
revealCards(event.getMessage(), event.getCards());
break;
try {
switch (event.getEventType()) {
case UPDATE:
updateGame();
break;
case INFO:
ChatManager.getInstance().broadcast(chatId, "", event.getMessage(), MessageColor.BLACK);
logger.debug(game.getId() + " " + event.getMessage());
break;
case REVEAL:
revealCards(event.getMessage(), event.getCards());
break;
}
} catch (MageException ex) {
logger.fatal("Table event listener error ", ex);
}
}
}
@ -123,37 +129,41 @@ public class GameController implements GameCallback {
@Override
public void event(PlayerQueryEvent event) {
// logger.info(event.getPlayerId() + "--" + event.getQueryType() + "--" + event.getMessage());
switch (event.getQueryType()) {
case ASK:
ask(event.getPlayerId(), event.getMessage());
break;
case PICK_TARGET:
target(event.getPlayerId(), event.getMessage(), event.getCards(), event.getTargets(), event.isRequired(), event.getOptions());
break;
case PICK_ABILITY:
target(event.getPlayerId(), event.getMessage(), event.getAbilities(), event.isRequired(), event.getOptions());
break;
case SELECT:
select(event.getPlayerId(), event.getMessage());
break;
case PLAY_MANA:
playMana(event.getPlayerId(), event.getMessage());
break;
case PLAY_X_MANA:
playXMana(event.getPlayerId(), event.getMessage());
break;
case CHOOSE_ABILITY:
chooseAbility(event.getPlayerId(), event.getAbilities());
break;
case CHOOSE:
choose(event.getPlayerId(), event.getMessage(), event.getChoices());
break;
case AMOUNT:
amount(event.getPlayerId(), event.getMessage(), event.getMin(), event.getMax());
break;
case LOOK:
lookAtCards(event.getPlayerId(), event.getMessage(), event.getCards());
break;
try {
switch (event.getQueryType()) {
case ASK:
ask(event.getPlayerId(), event.getMessage());
break;
case PICK_TARGET:
target(event.getPlayerId(), event.getMessage(), event.getCards(), event.getTargets(), event.isRequired(), event.getOptions());
break;
case PICK_ABILITY:
target(event.getPlayerId(), event.getMessage(), event.getAbilities(), event.isRequired(), event.getOptions());
break;
case SELECT:
select(event.getPlayerId(), event.getMessage());
break;
case PLAY_MANA:
playMana(event.getPlayerId(), event.getMessage());
break;
case PLAY_X_MANA:
playXMana(event.getPlayerId(), event.getMessage());
break;
case CHOOSE_ABILITY:
chooseAbility(event.getPlayerId(), event.getAbilities());
break;
case CHOOSE:
choose(event.getPlayerId(), event.getMessage(), event.getChoices());
break;
case AMOUNT:
amount(event.getPlayerId(), event.getMessage(), event.getMin(), event.getMax());
break;
case LOOK:
lookAtCards(event.getPlayerId(), event.getMessage(), event.getCards());
break;
}
} catch (MageException ex) {
logger.fatal("Player event listener error ", ex);
}
}
}
@ -282,7 +292,7 @@ public class GameController implements GameCallback {
}
}
public void endGame(final String message) {
public void endGame(final String message) throws MageException {
for (final GameSession gameSession: gameSessions.values()) {
gameSession.gameOver(message);
}
@ -317,7 +327,6 @@ public class GameController implements GameCallback {
}
private synchronized void updateGame() {
for (final Entry<UUID, GameSession> entry: gameSessions.entrySet()) {
entry.getValue().update(getGameView(entry.getKey()));
}
@ -326,25 +335,25 @@ public class GameController implements GameCallback {
}
}
private synchronized void ask(UUID playerId, String question) {
private synchronized void ask(UUID playerId, String question) throws MageException {
if (gameSessions.containsKey(playerId))
gameSessions.get(playerId).ask(question, getGameView(playerId));
informOthers(playerId);
}
private synchronized void chooseAbility(UUID playerId, Collection<? extends Ability> choices) {
private synchronized void chooseAbility(UUID playerId, Collection<? extends Ability> choices) throws MageException {
if (gameSessions.containsKey(playerId))
gameSessions.get(playerId).chooseAbility(new AbilityPickerView(choices));
informOthers(playerId);
}
private synchronized void choose(UUID playerId, String message, Set<String> choices) {
private synchronized void choose(UUID playerId, String message, Set<String> choices) throws MageException {
if (gameSessions.containsKey(playerId))
gameSessions.get(playerId).choose(message, choices);
informOthers(playerId);
}
private synchronized void target(UUID playerId, String question, Cards cards, Set<UUID> targets, boolean required, Map<String, Serializable> options) {
private synchronized void target(UUID playerId, String question, Cards cards, Set<UUID> targets, boolean required, Map<String, Serializable> options) throws MageException {
if (gameSessions.containsKey(playerId)) {
if (cards != null)
gameSessions.get(playerId).target(question, new CardsView(cards.getCards(game)), targets, required, getGameView(playerId), options);
@ -354,48 +363,48 @@ public class GameController implements GameCallback {
informOthers(playerId);
}
private synchronized void target(UUID playerId, String question, Collection<? extends Ability> abilities, boolean required, Map<String, Serializable> options) {
private synchronized void target(UUID playerId, String question, Collection<? extends Ability> abilities, boolean required, Map<String, Serializable> options) throws MageException {
if (gameSessions.containsKey(playerId))
gameSessions.get(playerId).target(question, new CardsView(abilities, game), null, required, getGameView(playerId), options);
informOthers(playerId);
}
private synchronized void select(UUID playerId, String message) {
private synchronized void select(UUID playerId, String message) throws MageException {
if (gameSessions.containsKey(playerId))
gameSessions.get(playerId).select(message, getGameView(playerId));
informOthers(playerId);
}
private synchronized void playMana(UUID playerId, String message) {
private synchronized void playMana(UUID playerId, String message) throws MageException {
if (gameSessions.containsKey(playerId))
gameSessions.get(playerId).playMana(message, getGameView(playerId));
informOthers(playerId);
}
private synchronized void playXMana(UUID playerId, String message) {
private synchronized void playXMana(UUID playerId, String message) throws MageException {
if (gameSessions.containsKey(playerId))
gameSessions.get(playerId).playXMana(message, getGameView(playerId));
informOthers(playerId);
}
private synchronized void amount(UUID playerId, String message, int min, int max) {
private synchronized void amount(UUID playerId, String message, int min, int max) throws MageException {
if (gameSessions.containsKey(playerId))
gameSessions.get(playerId).getAmount(message, min, max);
informOthers(playerId);
}
private synchronized void revealCards(String name, Cards cards) {
private synchronized void revealCards(String name, Cards cards) throws MageException {
for (GameSession session: gameSessions.values()) {
session.revealCards(name, new CardsView(cards.getCards(game)));
}
}
private synchronized void lookAtCards(UUID playerId, String name, Cards cards) {
private synchronized void lookAtCards(UUID playerId, String name, Cards cards) throws MageException {
if (gameSessions.containsKey(playerId))
gameSessions.get(playerId).revealCards(name, new CardsView(cards.getCards(game)));
}
private void informOthers(UUID playerId) {
private void informOthers(UUID playerId) throws MageException {
final String message = "Waiting for " + game.getPlayer(playerId).getName();
for (final Entry<UUID, GameSession> entry: gameSessions.entrySet()) {
if (!entry.getKey().equals(playerId)) {
@ -426,7 +435,11 @@ public class GameController implements GameCallback {
@Override
public void gameResult(String result) {
endGame(result);
try {
endGame(result);
} catch (MageException ex) {
logger.fatal("Game Result error", ex);
}
}
public void saveGame() {

1
Mage.Server/src/main/java/mage/server/game/GameManager.java
View file

@ -32,6 +32,7 @@ import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;
import mage.cards.decks.DeckCardLists;
import mage.game.Game;
import mage.MageException;
import mage.view.GameView;
/**

85
Mage.Server/src/main/java/mage/server/game/GameSession.java
View file

@ -36,6 +36,8 @@ import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.TimeUnit;
import mage.game.Game;
import mage.MageException;
import mage.interfaces.callback.CallbackException;
import mage.interfaces.callback.ClientCallback;
import mage.server.Session;
import mage.server.SessionManager;
@ -64,12 +66,17 @@ public class GameSession extends GameWatcher {
this.playerId = playerId;
}
public void ask(final String question, final GameView gameView) {
public void ask(final String question, final GameView gameView) {
if (!killed) {
setupTimeout();
Session session = SessionManager.getInstance().getSession(sessionId);
if (session != null)
session.fireCallback(new ClientCallback("gameAsk", game.getId(), new GameClientMessage(gameView, question)));
if (session != null) {
try {
session.fireCallback(new ClientCallback("gameAsk", game.getId(), new GameClientMessage(gameView, question)));
} catch (CallbackException ex) {
logger.fatal("game ask exception", ex);
}
}
}
}
@ -77,8 +84,13 @@ public class GameSession extends GameWatcher {
if (!killed) {
setupTimeout();
Session session = SessionManager.getInstance().getSession(sessionId);
if (session != null)
session.fireCallback(new ClientCallback("gameTarget", game.getId(), new GameClientMessage(gameView, question, cardView, targets, required, options)));
if (session != null) {
try {
session.fireCallback(new ClientCallback("gameTarget", game.getId(), new GameClientMessage(gameView, question, cardView, targets, required, options)));
} catch (CallbackException ex) {
logger.fatal("game target exception", ex);
}
}
}
}
@ -86,8 +98,13 @@ public class GameSession extends GameWatcher {
if (!killed) {
setupTimeout();
Session session = SessionManager.getInstance().getSession(sessionId);
if (session != null)
session.fireCallback(new ClientCallback("gameSelect", game.getId(), new GameClientMessage(gameView, message)));
if (session != null) {
try {
session.fireCallback(new ClientCallback("gameSelect", game.getId(), new GameClientMessage(gameView, message)));
} catch (CallbackException ex) {
logger.fatal("game select exception", ex);
}
}
}
}
@ -95,8 +112,13 @@ public class GameSession extends GameWatcher {
if (!killed) {
setupTimeout();
Session session = SessionManager.getInstance().getSession(sessionId);
if (session != null)
session.fireCallback(new ClientCallback("gameChooseAbility", game.getId(), abilities));
if (session != null) {
try {
session.fireCallback(new ClientCallback("gameChooseAbility", game.getId(), abilities));
} catch (CallbackException ex) {
logger.fatal("game choose ability exception", ex);
}
}
}
}
@ -104,8 +126,13 @@ public class GameSession extends GameWatcher {
if (!killed) {
setupTimeout();
Session session = SessionManager.getInstance().getSession(sessionId);
if (session != null)
session.fireCallback(new ClientCallback("gameChoose", game.getId(), new GameClientMessage(choices.toArray(new String[0]), message)));
if (session != null) {
try {
session.fireCallback(new ClientCallback("gameChoose", game.getId(), new GameClientMessage(choices.toArray(new String[0]), message)));
} catch (CallbackException ex) {
logger.fatal("game choose exception", ex);
}
}
}
}
@ -113,8 +140,13 @@ public class GameSession extends GameWatcher {
if (!killed) {
setupTimeout();
Session session = SessionManager.getInstance().getSession(sessionId);
if (session != null)
session.fireCallback(new ClientCallback("gamePlayMana", game.getId(), new GameClientMessage(gameView, message)));
if (session != null) {
try {
session.fireCallback(new ClientCallback("gamePlayMana", game.getId(), new GameClientMessage(gameView, message)));
} catch (CallbackException ex) {
logger.fatal("game play mana exception", ex);
}
}
}
}
@ -122,8 +154,13 @@ public class GameSession extends GameWatcher {
if (!killed) {
setupTimeout();
Session session = SessionManager.getInstance().getSession(sessionId);
if (session != null)
session.fireCallback(new ClientCallback("gamePlayXMana", game.getId(), new GameClientMessage(gameView, message)));
if (session != null) {
try {
session.fireCallback(new ClientCallback("gamePlayXMana", game.getId(), new GameClientMessage(gameView, message)));
} catch (CallbackException ex) {
logger.fatal("game play x mana exception", ex);
}
}
}
}
@ -131,16 +168,26 @@ public class GameSession extends GameWatcher {
if (!killed) {
setupTimeout();
Session session = SessionManager.getInstance().getSession(sessionId);
if (session != null)
session.fireCallback(new ClientCallback("gameSelectAmount", game.getId(), new GameClientMessage(message, min, max)));
if (session != null) {
try {
session.fireCallback(new ClientCallback("gameSelectAmount", game.getId(), new GameClientMessage(message, min, max)));
} catch (CallbackException ex) {
logger.fatal("game select amount exception", ex);
}
}
}
}
public void revealCards(final String name, final CardsView cardView) {
if (!killed) {
Session session = SessionManager.getInstance().getSession(sessionId);
if (session != null)
session.fireCallback(new ClientCallback("gameReveal", game.getId(), new GameClientMessage(cardView, name)));
if (session != null) {
try {
session.fireCallback(new ClientCallback("gameReveal", game.getId(), new GameClientMessage(cardView, name)));
} catch (CallbackException ex) {
logger.fatal("game reveal exception", ex);
}
}
}
}

47
Mage.Server/src/main/java/mage/server/game/GameWatcher.java
View file

@ -30,6 +30,9 @@ package mage.server.game;
import java.rmi.RemoteException;
import java.util.UUID;
import java.util.logging.Level;
import mage.MageException;
import mage.interfaces.callback.CallbackException;
import mage.interfaces.callback.ClientCallback;
import mage.server.Session;
import mage.server.SessionManager;
@ -58,44 +61,54 @@ public class GameWatcher {
if (!killed) {
Session session = SessionManager.getInstance().getSession(sessionId);
if (session != null) {
session.clearAck();
session.fireCallback(new ClientCallback("gameInit", gameId, gameView));
if (waitForAck("gameInit"))
try {
session.fireCallback(new ClientCallback("gameInit", gameId, gameView));
return true;
} catch (CallbackException ex) {
logger.fatal("Unable to start watching ", ex);
return false;
}
}
}
return false;
}
public boolean waitForAck(String message) {
Session session = SessionManager.getInstance().getSession(sessionId);
do {
//TODO: add timeout
} while (!session.getAckMessage().equals(message) && !killed);
return true;
}
public void update(final GameView gameView) {
if (!killed) {
Session session = SessionManager.getInstance().getSession(sessionId);
if (session != null)
session.fireCallback(new ClientCallback("gameUpdate", gameId, gameView));
if (session != null) {
try {
session.fireCallback(new ClientCallback("gameUpdate", gameId, gameView));
} catch (CallbackException ex) {
logger.fatal("game update exception", ex);
}
}
}
}
public void inform(final String message, final GameView gameView) {
if (!killed) {
Session session = SessionManager.getInstance().getSession(sessionId);
if (session != null)
session.fireCallback(new ClientCallback("gameInform", gameId, new GameClientMessage(gameView, message)));
if (session != null) {
try {
session.fireCallback(new ClientCallback("gameInform", gameId, new GameClientMessage(gameView, message)));
} catch (CallbackException ex) {
logger.fatal("game inform exception", ex);
}
}
}
}
public void gameOver(final String message) {
if (!killed) {
Session session = SessionManager.getInstance().getSession(sessionId);
if (session != null)
session.fireCallback(new ClientCallback("gameOver", gameId, message));
if (session != null) {
try {
session.fireCallback(new ClientCallback("gameOver", gameId, message));
} catch (CallbackException ex) {
logger.fatal("game select exception", ex);
}
}
}
}

1
Mage.Server/src/main/java/mage/server/game/GameWorker.java
View file

@ -58,7 +58,6 @@ public class GameWorker implements Callable {
result.gameResult(game.getWinner());
} catch (Exception ex) {
logger.fatal("GameWorker error ", ex);
result.gameResult("Server Error");
}
return null;
}

3
Mage.Server/src/main/java/mage/server/game/GamesRoom.java
View file

@ -35,6 +35,7 @@ import mage.cards.decks.DeckCardLists;
import mage.game.GameException;
import mage.game.match.MatchOptions;
import mage.game.tournament.TournamentOptions;
import mage.MageException;
import mage.view.TableView;
/**
@ -52,6 +53,6 @@ public interface GamesRoom extends Room {
public void removeTable(UUID tableId);
public TableView getTable(UUID tableId);
public void leaveTable(UUID sessionId, UUID tableId);
public boolean watchTable(UUID sessionId, UUID tableId);
public boolean watchTable(UUID sessionId, UUID tableId) throws MageException;
}

3
Mage.Server/src/main/java/mage/server/game/GamesRoomImpl.java
View file

@ -40,6 +40,7 @@ import mage.cards.decks.DeckCardLists;
import mage.game.GameException;
import mage.game.match.MatchOptions;
import mage.game.tournament.TournamentOptions;
import mage.MageException;
import mage.view.TableView;
import org.apache.log4j.Logger;
@ -119,7 +120,7 @@ public class GamesRoomImpl extends RoomImpl implements GamesRoom, Serializable {
}
@Override
public boolean watchTable(UUID sessionId, UUID tableId) {
public boolean watchTable(UUID sessionId, UUID tableId) throws MageException {
return TableManager.getInstance().watchTable(sessionId, tableId);
}

1
Mage.Server/src/main/java/mage/server/game/ReplayManager.java
View file

@ -30,6 +30,7 @@ package mage.server.game;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;
import mage.MageException;
import mage.server.SessionManager;
/**

31
Mage.Server/src/main/java/mage/server/game/ReplaySession.java
View file

@ -31,10 +31,13 @@ package mage.server.game;
import java.util.UUID;
import mage.game.Game;
import mage.game.GameState;
import mage.MageException;
import mage.interfaces.callback.CallbackException;
import mage.interfaces.callback.ClientCallback;
import mage.server.Session;
import mage.server.SessionManager;
import mage.view.GameView;
import org.apache.log4j.Logger;
/**
*
@ -42,6 +45,7 @@ import mage.view.GameView;
*/
public class ReplaySession implements GameCallback {
private final static Logger logger = Logger.getLogger(ReplaySession.class);
private GameReplay replay;
protected UUID sessionId;
@ -53,8 +57,13 @@ public class ReplaySession implements GameCallback {
public void replay() {
replay.start();
Session session = SessionManager.getInstance().getSession(sessionId);
if (session != null)
session.fireCallback(new ClientCallback("replayInit", replay.getGame().getId(), new GameView(replay.next(), replay.getGame())));
if (session != null) {
try {
session.fireCallback(new ClientCallback("replayInit", replay.getGame().getId(), new GameView(replay.next(), replay.getGame())));
} catch (CallbackException ex) {
logger.fatal("replay init exception", ex);
}
}
}
public void stop() {
@ -72,8 +81,13 @@ public class ReplaySession implements GameCallback {
@Override
public void gameResult(final String result) {
Session session = SessionManager.getInstance().getSession(sessionId);
if (session != null)
session.fireCallback(new ClientCallback("replayDone", replay.getGame().getId(), result));
if (session != null) {
try {
session.fireCallback(new ClientCallback("replayDone", replay.getGame().getId(), result));
} catch (CallbackException ex) {
logger.fatal("replay done exception", ex);
}
}
}
private void updateGame(final GameState state, Game game) {
@ -82,8 +96,13 @@ public class ReplaySession implements GameCallback {
}
else {
Session session = SessionManager.getInstance().getSession(sessionId);
if (session != null)
session.fireCallback(new ClientCallback("replayUpdate", replay.getGame().getId(), new GameView(state, game)));
if (session != null) {
try {
session.fireCallback(new ClientCallback("replayUpdate", replay.getGame().getId(), new GameView(state, game)));
} catch (CallbackException ex) {
logger.fatal("replay update exception", ex);
}
}
}
}

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

@ -31,6 +31,7 @@ package mage.server.tournament;
import java.util.Map.Entry;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;
import java.util.logging.Level;
import mage.cards.decks.Deck;
import mage.game.GameException;
import mage.game.Table;
@ -42,6 +43,7 @@ import mage.game.match.MatchOptions;
import mage.game.tournament.Tournament;
import mage.game.tournament.TournamentPairing;
import mage.game.tournament.TournamentPlayer;
import mage.MageException;
import mage.server.ChatManager;
import mage.server.TableManager;
import mage.server.game.GamesRoomManager;
@ -104,10 +106,14 @@ public class TournamentController {
new Listener<PlayerQueryEvent> () {
@Override
public void event(PlayerQueryEvent event) {
switch (event.getQueryType()) {
case CONSTRUCT:
construct(event.getPlayerId(), event.getDeck(), event.getMax());
break;
try {
switch (event.getQueryType()) {
case CONSTRUCT:
construct(event.getPlayerId(), event.getDeck(), event.getMax());
break;
}
} catch (MageException ex) {
logger.fatal("Player event listener error", ex);
}
}
}
@ -190,7 +196,7 @@ public class TournamentController {
TableManager.getInstance().construct(tableId);
}
private void construct(UUID sessionId, Deck deck, int timeout) {
private void construct(UUID sessionId, Deck deck, int timeout) throws MageException {
if (tournamentSessions.containsKey(sessionId))
tournamentSessions.get(sessionId).construct(deck, timeout);
}

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

@ -33,8 +33,11 @@ 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 mage.cards.decks.Deck;
import mage.game.tournament.Tournament;
import mage.MageException;
import mage.interfaces.callback.CallbackException;
import mage.interfaces.callback.ClientCallback;
import mage.server.Session;
import mage.server.SessionManager;
@ -69,40 +72,52 @@ public class TournamentSession {
if (!killed) {
Session session = SessionManager.getInstance().getSession(sessionId);
if (session != null) {
session.clearAck();
session.fireCallback(new ClientCallback("tournamentInit", tournament.getId(), tournamentView));
if (waitForAck("tournamentInit"))
try {
session.fireCallback(new ClientCallback("tournamentInit", tournament.getId(), tournamentView));
return true;
} catch (CallbackException ex) {
logger.fatal("Unable to start tournament", ex);
}
}
}
return false;
}
public boolean waitForAck(String message) {
Session session = SessionManager.getInstance().getSession(sessionId);
do {
//TODO: add timeout
} while (!session.getAckMessage().equals(message) && !killed);
return true;
}
// public boolean waitForAck(String message) {
// Session session = SessionManager.getInstance().getSession(sessionId);
// do {
// //TODO: add timeout
// } while (!session.getAckMessage().equals(message) && !killed);
// return true;
// }
public void update(final TournamentView tournamentView) {
if (!killed) {
Session session = SessionManager.getInstance().getSession(sessionId);
if (session != null)
session.fireCallback(new ClientCallback("tournamentUpdate", tournament.getId(), tournamentView));
if (session != null) {
try {
session.fireCallback(new ClientCallback("tournamentUpdate", tournament.getId(), tournamentView));
} catch (CallbackException ex) {
logger.fatal("tournament update error", ex);
}
}
}
}
public void gameOver(final String message) {
if (!killed) {
Session session = SessionManager.getInstance().getSession(sessionId);
if (session != null)
session.fireCallback(new ClientCallback("tournamentOver", tournament.getId(), message));
if (session != null) {
try {
session.fireCallback(new ClientCallback("tournamentOver", tournament.getId(), message));
} catch (CallbackException ex) {
logger.fatal("tournament over error", ex);
}
}
}
}
public void construct(Deck deck, int timeout) {
public void construct(Deck deck, int timeout) throws MageException {
if (!killed) {
setupTimeout(timeout);
Session session = SessionManager.getInstance().getSession(sessionId);