forked from External/mage
892 lines
No EOL
23 KiB
Java
892 lines
No EOL
23 KiB
Java
/*
|
|
* Copyright 2010 BetaSteward_at_googlemail.com. All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without modification, are
|
|
* permitted provided that the following conditions are met:
|
|
*
|
|
* 1. Redistributions of source code must retain the above copyright notice, this list of
|
|
* conditions and the following disclaimer.
|
|
*
|
|
* 2. Redistributions in binary form must reproduce the above copyright notice, this list
|
|
* of conditions and the following disclaimer in the documentation and/or other materials
|
|
* provided with the distribution.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY BetaSteward_at_googlemail.com ``AS IS'' AND ANY EXPRESS OR IMPLIED
|
|
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
|
|
* FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL BetaSteward_at_googlemail.com OR
|
|
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
|
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
|
|
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
|
|
* ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
|
|
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
|
|
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*
|
|
* The views and conclusions contained in the software and documentation are those of the
|
|
* authors and should not be interpreted as representing official policies, either expressed
|
|
* or implied, of BetaSteward_at_googlemail.com.
|
|
*/
|
|
|
|
package mage.remote;
|
|
|
|
import java.net.Authenticator;
|
|
import java.net.MalformedURLException;
|
|
import java.net.PasswordAuthentication;
|
|
import java.util.Collection;
|
|
import java.util.HashMap;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
import java.util.UUID;
|
|
import mage.cards.decks.DeckCardLists;
|
|
import mage.game.GameException;
|
|
import mage.MageException;
|
|
import mage.constants.Constants.SessionState;
|
|
import mage.game.match.MatchOptions;
|
|
import mage.game.tournament.TournamentOptions;
|
|
import mage.interfaces.MageClient;
|
|
import mage.interfaces.MageServer;
|
|
import mage.interfaces.ServerState;
|
|
import mage.interfaces.callback.ClientCallback;
|
|
import mage.view.DraftPickView;
|
|
import mage.view.GameTypeView;
|
|
import mage.view.TableView;
|
|
import mage.view.TournamentTypeView;
|
|
import mage.view.TournamentView;
|
|
import mage.view.UserView;
|
|
import org.apache.log4j.Logger;
|
|
import org.jboss.remoting.Client;
|
|
import org.jboss.remoting.ConnectionListener;
|
|
import org.jboss.remoting.ConnectionValidator;
|
|
import org.jboss.remoting.InvokerLocator;
|
|
import org.jboss.remoting.callback.Callback;
|
|
import org.jboss.remoting.callback.HandleCallbackException;
|
|
import org.jboss.remoting.callback.InvokerCallbackHandler;
|
|
import org.jboss.remoting.transport.bisocket.Bisocket;
|
|
import org.jboss.remoting.transport.socket.SocketWrapper;
|
|
import org.jboss.remoting.transporter.TransporterClient;
|
|
|
|
/**
|
|
*
|
|
* @author BetaSteward_at_googlemail.com
|
|
*/
|
|
public class Session {
|
|
|
|
private final static Logger logger = Logger.getLogger(Session.class);
|
|
|
|
private String sessionId;
|
|
private MageServer server;
|
|
private MageClient client;
|
|
private Client callbackClient;
|
|
private ServerState serverState;
|
|
private SessionState sessionState = SessionState.DISCONNECTED;
|
|
private Connection connection;
|
|
|
|
/**
|
|
* For locking session object.
|
|
* Read-write locking is used for better performance, as in most cases session object won't be changed so
|
|
* there shouldn't be any penalty for synchronization.
|
|
*
|
|
* @author nantuko
|
|
*/
|
|
// private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
|
|
|
|
public Session(MageClient client) {
|
|
this.client = client;
|
|
}
|
|
|
|
public synchronized boolean connect(Connection connection) {
|
|
if (isConnected()) {
|
|
disconnect(true);
|
|
}
|
|
this.connection = connection;
|
|
return connect();
|
|
}
|
|
|
|
public boolean connect() {
|
|
sessionState = SessionState.CONNECTING;
|
|
try {
|
|
System.setProperty("http.nonProxyHosts", "code.google.com");
|
|
System.setProperty("socksNonProxyHosts", "code.google.com");
|
|
|
|
// clear previous values
|
|
System.clearProperty("socksProxyHost");
|
|
System.clearProperty("socksProxyPort");
|
|
System.clearProperty("http.proxyHost");
|
|
System.clearProperty("http.proxyPort");
|
|
|
|
switch (connection.getProxyType()) {
|
|
case SOCKS:
|
|
System.setProperty("socksProxyHost", connection.getProxyHost());
|
|
System.setProperty("socksProxyPort", Integer.toString(connection.getProxyPort()));
|
|
break;
|
|
case HTTP:
|
|
System.setProperty("http.proxyHost", connection.getProxyHost());
|
|
System.setProperty("http.proxyPort", Integer.toString(connection.getProxyPort()));
|
|
Authenticator.setDefault(new MageAuthenticator(connection.getProxyUsername(), connection.getProxyPassword()));
|
|
break;
|
|
}
|
|
InvokerLocator clientLocator = new InvokerLocator(connection.getURI());
|
|
Map<String, String> metadata = new HashMap<String, String>();
|
|
metadata.put(SocketWrapper.WRITE_TIMEOUT, "2000");
|
|
metadata.put("generalizeSocketException", "true");
|
|
server = (MageServer) TransporterClient.createTransporterClient(clientLocator.getLocatorURI(), MageServer.class, metadata);
|
|
|
|
Map<String, String> clientMetadata = new HashMap<String, String>();
|
|
clientMetadata.put(SocketWrapper.WRITE_TIMEOUT, "2000");
|
|
clientMetadata.put("generalizeSocketException", "true");
|
|
clientMetadata.put(Client.ENABLE_LEASE, "true");
|
|
callbackClient = new Client(clientLocator, "callback", clientMetadata);
|
|
|
|
Map<String, String> listenerMetadata = new HashMap<String, String>();
|
|
listenerMetadata.put(ConnectionValidator.VALIDATOR_PING_PERIOD, "5000");
|
|
listenerMetadata.put(ConnectionValidator.VALIDATOR_PING_TIMEOUT, "2000");
|
|
callbackClient.connect(new ClientConnectionListener(), listenerMetadata);
|
|
|
|
Map<String, String> callbackMetadata = new HashMap<String, String>();
|
|
callbackMetadata.put(Bisocket.IS_CALLBACK_SERVER, "true");
|
|
CallbackHandler callbackHandler = new CallbackHandler();
|
|
callbackClient.addListener(callbackHandler, callbackMetadata);
|
|
callbackClient.invoke("");
|
|
|
|
this.sessionId = callbackClient.getSessionId();
|
|
boolean registerResult = false;
|
|
if (connection.getPassword() == null)
|
|
registerResult = server.registerClient(connection.getUsername(), sessionId, client.getVersion());
|
|
else
|
|
registerResult = server.registerAdmin(connection.getPassword(), sessionId, client.getVersion());
|
|
if (registerResult) {
|
|
sessionState = SessionState.CONNECTED;
|
|
serverState = server.getServerState();
|
|
logger.info("Connected to MAGE server at " + connection.getHost() + ":" + connection.getPort());
|
|
client.connected("Connected to " + connection.getHost() + ":" + connection.getPort() + " ");
|
|
return true;
|
|
}
|
|
disconnect(false);
|
|
client.showMessage("Unable to connect to server.");
|
|
} catch (MalformedURLException ex) {
|
|
logger.fatal("", ex);
|
|
client.showMessage("Unable to connect to server. " + ex.getMessage());
|
|
} catch (Throwable t) {
|
|
logger.fatal("Unable to connect to server - ", t);
|
|
disconnect(false);
|
|
client.showMessage("Unable to connect to server. " + t.getMessage());
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public synchronized void disconnect(boolean showMessage) {
|
|
if (isConnected())
|
|
sessionState = SessionState.DISCONNECTING;
|
|
if (connection == null)
|
|
return;
|
|
try {
|
|
callbackClient.disconnect();
|
|
TransporterClient.destroyTransporterClient(server);
|
|
} catch (Throwable ex) {
|
|
logger.fatal("Error disconnecting ...", ex);
|
|
}
|
|
if (sessionState == SessionState.DISCONNECTING || sessionState == SessionState.CONNECTING) {
|
|
sessionState = SessionState.DISCONNECTED;
|
|
logger.info("Disconnected ... ");
|
|
}
|
|
client.disconnected();
|
|
if (showMessage)
|
|
client.showError("Server error. You have been disconnected");
|
|
}
|
|
|
|
class CallbackHandler implements InvokerCallbackHandler {
|
|
@Override
|
|
public void handleCallback(Callback callback) throws HandleCallbackException {
|
|
client.processCallback((ClientCallback)callback.getCallbackObject());
|
|
}
|
|
}
|
|
|
|
class ClientConnectionListener implements ConnectionListener {
|
|
@Override
|
|
public void handleConnectionException(Throwable throwable, Client client) {
|
|
logger.info("connection to server lost - " + throwable.getMessage());
|
|
disconnect(true);
|
|
}
|
|
}
|
|
|
|
public boolean isConnected() {
|
|
if (callbackClient == null)
|
|
return false;
|
|
return callbackClient.isConnected();
|
|
}
|
|
|
|
public String[] getPlayerTypes() {
|
|
return serverState.getPlayerTypes();
|
|
}
|
|
|
|
public List<GameTypeView> getGameTypes() {
|
|
return serverState.getGameTypes();
|
|
}
|
|
|
|
public String[] getDeckTypes() {
|
|
return serverState.getDeckTypes();
|
|
}
|
|
|
|
public List<TournamentTypeView> getTournamentTypes() {
|
|
return serverState.getTournamentTypes();
|
|
}
|
|
|
|
public boolean isTestMode() {
|
|
if (serverState != null)
|
|
return serverState.isTestMode();
|
|
return false;
|
|
}
|
|
|
|
public UUID getMainRoomId() {
|
|
try {
|
|
if (isConnected())
|
|
return server.getMainRoomId();
|
|
} catch (MageException ex) {
|
|
handleMageException(ex);
|
|
} catch (Throwable t) {
|
|
handleThrowable(t);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public UUID getRoomChatId(UUID roomId) {
|
|
try {
|
|
if (isConnected())
|
|
return server.getRoomChatId(roomId);
|
|
} catch (MageException ex) {
|
|
handleMageException(ex);
|
|
} catch (Throwable t) {
|
|
handleThrowable(t);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public UUID getTableChatId(UUID tableId) {
|
|
try {
|
|
if (isConnected())
|
|
return server.getTableChatId(tableId);
|
|
} catch (MageException ex) {
|
|
handleMageException(ex);
|
|
} catch (Throwable t) {
|
|
handleThrowable(t);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public UUID getGameChatId(UUID gameId) {
|
|
try {
|
|
if (isConnected())
|
|
return server.getGameChatId(gameId);
|
|
} catch (MageException ex) {
|
|
handleMageException(ex);
|
|
} catch (Throwable t) {
|
|
handleThrowable(t);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public TableView getTable(UUID roomId, UUID tableId) {
|
|
try {
|
|
if (isConnected())
|
|
return server.getTable(roomId, tableId);
|
|
} catch (MageException ex) {
|
|
handleMageException(ex);
|
|
} catch (Throwable t) {
|
|
handleThrowable(t);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public boolean watchTable(UUID roomId, UUID tableId) {
|
|
try {
|
|
if (isConnected()) {
|
|
server.watchTable(sessionId, roomId, tableId);
|
|
return true;
|
|
}
|
|
} catch (MageException ex) {
|
|
handleMageException(ex);
|
|
} catch (Throwable t) {
|
|
handleThrowable(t);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public boolean joinTable(UUID roomId, UUID tableId, String playerName, String playerType, int skill, DeckCardLists deckList) {
|
|
try {
|
|
if (isConnected())
|
|
return server.joinTable(sessionId, roomId, tableId, playerName, playerType, skill, deckList);
|
|
} catch (GameException ex) {
|
|
handleGameException(ex);
|
|
} catch (MageException ex) {
|
|
handleMageException(ex);
|
|
} catch (Throwable t) {
|
|
handleThrowable(t);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public boolean joinTournamentTable(UUID roomId, UUID tableId, String playerName, String playerType, int skill) {
|
|
try {
|
|
if (isConnected())
|
|
return server.joinTournamentTable(sessionId, roomId, tableId, playerName, playerType, skill);
|
|
} catch (GameException ex) {
|
|
handleGameException(ex);
|
|
} catch (MageException ex) {
|
|
handleMageException(ex);
|
|
} catch (Throwable t) {
|
|
handleThrowable(t);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public Collection<TableView> getTables(UUID roomId) throws MageRemoteException {
|
|
// lock.readLock().lock();
|
|
try {
|
|
if (isConnected())
|
|
return server.getTables(roomId);
|
|
} catch (MageException ex) {
|
|
handleMageException(ex);
|
|
throw new MageRemoteException();
|
|
} catch (Throwable t) {
|
|
handleThrowable(t);
|
|
// } finally {
|
|
// lock.readLock().unlock();
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public Collection<String> getConnectedPlayers(UUID roomId) throws MageRemoteException {
|
|
// lock.readLock().lock();
|
|
try {
|
|
if (isConnected())
|
|
return server.getConnectedPlayers(roomId);
|
|
} catch (MageException ex) {
|
|
handleMageException(ex);
|
|
throw new MageRemoteException();
|
|
} catch (Throwable t) {
|
|
handleThrowable(t);
|
|
// } finally {
|
|
// lock.readLock().unlock();
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public TournamentView getTournament(UUID tournamentId) throws MageRemoteException {
|
|
try {
|
|
if (isConnected())
|
|
return server.getTournament(tournamentId);
|
|
} catch (MageException ex) {
|
|
handleMageException(ex);
|
|
throw new MageRemoteException();
|
|
} catch (Throwable t) {
|
|
handleThrowable(t);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public UUID getTournamentChatId(UUID tournamentId) {
|
|
try {
|
|
if (isConnected())
|
|
return server.getTournamentChatId(tournamentId);
|
|
} catch (MageException ex) {
|
|
handleMageException(ex);
|
|
} catch (Throwable t) {
|
|
handleThrowable(t);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public boolean sendPlayerUUID(UUID gameId, UUID data) {
|
|
try {
|
|
if (isConnected()) {
|
|
server.sendPlayerUUID(gameId, sessionId, data);
|
|
return true;
|
|
}
|
|
} catch (MageException ex) {
|
|
handleMageException(ex);
|
|
} catch (Throwable t) {
|
|
handleThrowable(t);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public boolean sendPlayerBoolean(UUID gameId, boolean data) {
|
|
try {
|
|
if (isConnected()) {
|
|
server.sendPlayerBoolean(gameId, sessionId, data);
|
|
return true;
|
|
}
|
|
} catch (MageException ex) {
|
|
handleMageException(ex);
|
|
} catch (Throwable t) {
|
|
handleThrowable(t);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public boolean sendPlayerInteger(UUID gameId, int data) {
|
|
try {
|
|
if (isConnected()) {
|
|
server.sendPlayerInteger(gameId, sessionId, data);
|
|
return true;
|
|
}
|
|
} catch (MageException ex) {
|
|
handleMageException(ex);
|
|
} catch (Throwable t) {
|
|
handleThrowable(t);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public boolean sendPlayerString(UUID gameId, String data) {
|
|
try {
|
|
if (isConnected()) {
|
|
server.sendPlayerString(gameId, sessionId, data);
|
|
return true;
|
|
}
|
|
} catch (MageException ex) {
|
|
handleMageException(ex);
|
|
} catch (Throwable t) {
|
|
handleThrowable(t);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public DraftPickView sendCardPick(UUID draftId, UUID cardId) {
|
|
try {
|
|
if (isConnected())
|
|
return server.sendCardPick(draftId, sessionId, cardId);
|
|
} catch (MageException ex) {
|
|
handleMageException(ex);
|
|
} catch (Throwable t) {
|
|
handleThrowable(t);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public boolean joinChat(UUID chatId) {
|
|
try {
|
|
if (isConnected()) {
|
|
server.joinChat(chatId, sessionId, connection.getUsername());
|
|
return true;
|
|
}
|
|
} catch (MageException ex) {
|
|
handleMageException(ex);
|
|
} catch (Throwable t) {
|
|
handleThrowable(t);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public boolean leaveChat(UUID chatId) {
|
|
// lock.readLock().lock();
|
|
try {
|
|
if (isConnected()) {
|
|
server.leaveChat(chatId, sessionId);
|
|
return true;
|
|
}
|
|
} catch (MageException ex) {
|
|
handleMageException(ex);
|
|
} catch (Throwable t) {
|
|
handleThrowable(t);
|
|
// } finally {
|
|
// lock.readLock().unlock();
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public boolean sendChatMessage(UUID chatId, String message) {
|
|
// lock.readLock().lock();
|
|
try {
|
|
if (isConnected()) {
|
|
server.sendChatMessage(chatId, connection.getUsername(), message);
|
|
return true;
|
|
}
|
|
} catch (MageException ex) {
|
|
handleMageException(ex);
|
|
} catch (Throwable t) {
|
|
handleThrowable(t);
|
|
// } finally {
|
|
// lock.readLock().unlock();
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public boolean joinGame(UUID gameId) {
|
|
try {
|
|
if (isConnected()) {
|
|
server.joinGame(gameId, sessionId);
|
|
return true;
|
|
}
|
|
} catch (MageException ex) {
|
|
handleMageException(ex);
|
|
} catch (Throwable t) {
|
|
handleThrowable(t);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public boolean joinDraft(UUID draftId) {
|
|
try {
|
|
if (isConnected()) {
|
|
server.joinDraft(draftId, sessionId);
|
|
return true;
|
|
}
|
|
} catch (MageException ex) {
|
|
handleMageException(ex);
|
|
} catch (Throwable t) {
|
|
handleThrowable(t);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public boolean joinTournament(UUID tournamentId) {
|
|
try {
|
|
if (isConnected()) {
|
|
server.joinTournament(tournamentId, sessionId);
|
|
return true;
|
|
}
|
|
} catch (MageException ex) {
|
|
handleMageException(ex);
|
|
} catch (Throwable t) {
|
|
handleThrowable(t);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public boolean watchGame(UUID gameId) {
|
|
try {
|
|
if (isConnected()) {
|
|
server.watchGame(gameId, sessionId);
|
|
return true;
|
|
}
|
|
} catch (MageException ex) {
|
|
handleMageException(ex);
|
|
} catch (Throwable t) {
|
|
handleThrowable(t);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public boolean replayGame(UUID gameId) {
|
|
try {
|
|
if (isConnected()) {
|
|
server.replayGame(gameId, sessionId);
|
|
return true;
|
|
}
|
|
} catch (MageException ex) {
|
|
handleMageException(ex);
|
|
} catch (Throwable t) {
|
|
handleThrowable(t);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public TableView createTable(UUID roomId, MatchOptions matchOptions) {
|
|
try {
|
|
if (isConnected())
|
|
return server.createTable(sessionId, roomId, matchOptions);
|
|
} catch (MageException ex) {
|
|
handleMageException(ex);
|
|
} catch (Throwable t) {
|
|
handleThrowable(t);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public TableView createTournamentTable(UUID roomId, TournamentOptions tournamentOptions) {
|
|
try {
|
|
if (isConnected())
|
|
return server.createTournamentTable(sessionId, roomId, tournamentOptions);
|
|
} catch (MageException ex) {
|
|
handleMageException(ex);
|
|
} catch (Throwable t) {
|
|
handleThrowable(t);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public boolean isTableOwner(UUID roomId, UUID tableId) {
|
|
try {
|
|
if (isConnected())
|
|
return server.isTableOwner(sessionId, roomId, tableId);
|
|
} catch (MageException ex) {
|
|
handleMageException(ex);
|
|
} catch (Throwable t) {
|
|
handleThrowable(t);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public boolean removeTable(UUID roomId, UUID tableId) {
|
|
try {
|
|
if (isConnected()) {
|
|
server.removeTable(sessionId, roomId, tableId);
|
|
return true;
|
|
}
|
|
} catch (MageException ex) {
|
|
handleMageException(ex);
|
|
} catch (Throwable t) {
|
|
handleThrowable(t);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public boolean removeTable(UUID tableId) {
|
|
try {
|
|
if (isConnected()) {
|
|
server.removeTable(sessionId, tableId);
|
|
return true;
|
|
}
|
|
} catch (MageException ex) {
|
|
handleMageException(ex);
|
|
} catch (Throwable t) {
|
|
handleThrowable(t);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public boolean swapSeats(UUID roomId, UUID tableId, int seatNum1, int seatNum2) {
|
|
try {
|
|
if (isConnected()) {
|
|
server.swapSeats(sessionId, roomId, tableId, seatNum1, seatNum2);
|
|
return true;
|
|
}
|
|
} catch (MageException ex) {
|
|
handleMageException(ex);
|
|
} catch (Throwable t) {
|
|
handleThrowable(t);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public boolean leaveTable(UUID roomId, UUID tableId) {
|
|
try {
|
|
if (isConnected()) {
|
|
server.leaveTable(sessionId, roomId, tableId);
|
|
return true;
|
|
}
|
|
} catch (MageException ex) {
|
|
handleMageException(ex);
|
|
} catch (Throwable t) {
|
|
handleThrowable(t);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public boolean startGame(UUID roomId, UUID tableId) {
|
|
try {
|
|
if (isConnected()) {
|
|
server.startMatch(sessionId, roomId, tableId);
|
|
return true;
|
|
}
|
|
} catch (MageException ex) {
|
|
handleMageException(ex);
|
|
} catch (Throwable t) {
|
|
handleThrowable(t);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public boolean startTournament(UUID roomId, UUID tableId) {
|
|
try {
|
|
if (isConnected()) {
|
|
server.startTournament(sessionId, roomId, tableId);
|
|
return true;
|
|
}
|
|
} catch (MageException ex) {
|
|
handleMageException(ex);
|
|
} catch (Throwable t) {
|
|
handleThrowable(t);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public boolean startChallenge(UUID roomId, UUID tableId, UUID challengeId) {
|
|
try {
|
|
if (isConnected()) {
|
|
server.startChallenge(sessionId, roomId, tableId, challengeId);
|
|
return true;
|
|
}
|
|
} catch (MageException ex) {
|
|
handleMageException(ex);
|
|
} catch (Throwable t) {
|
|
handleThrowable(t);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public boolean submitDeck(UUID tableId, DeckCardLists deck) {
|
|
try {
|
|
if (isConnected())
|
|
return server.submitDeck(sessionId, tableId, deck);
|
|
} catch (GameException ex) {
|
|
handleGameException(ex);
|
|
} catch (MageException ex) {
|
|
handleMageException(ex);
|
|
} catch (Throwable t) {
|
|
handleThrowable(t);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public boolean concedeGame(UUID gameId) {
|
|
try {
|
|
if (isConnected()) {
|
|
server.concedeGame(gameId, sessionId);
|
|
return true;
|
|
}
|
|
} catch (MageException ex) {
|
|
handleMageException(ex);
|
|
} catch (Throwable t) {
|
|
handleThrowable(t);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public boolean stopWatching(UUID gameId) {
|
|
try {
|
|
if (isConnected()) {
|
|
server.stopWatching(gameId, sessionId);
|
|
return true;
|
|
}
|
|
} catch (MageException ex) {
|
|
handleMageException(ex);
|
|
} catch (Throwable t) {
|
|
handleThrowable(t);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public boolean startReplay(UUID gameId) {
|
|
try {
|
|
if (isConnected()) {
|
|
server.startReplay(gameId, sessionId);
|
|
return true;
|
|
}
|
|
} catch (MageException ex) {
|
|
handleMageException(ex);
|
|
} catch (Throwable t) {
|
|
handleThrowable(t);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public boolean stopReplay(UUID gameId) {
|
|
try {
|
|
if (isConnected()) {
|
|
server.stopReplay(gameId, sessionId);
|
|
return true;
|
|
}
|
|
} catch (MageException ex) {
|
|
handleMageException(ex);
|
|
} catch (Throwable t) {
|
|
handleThrowable(t);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public boolean nextPlay(UUID gameId) {
|
|
try {
|
|
if (isConnected()) {
|
|
server.nextPlay(gameId, sessionId);
|
|
return true;
|
|
}
|
|
} catch (MageException ex) {
|
|
handleMageException(ex);
|
|
} catch (Throwable t) {
|
|
handleThrowable(t);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public boolean previousPlay(UUID gameId) {
|
|
try {
|
|
if (isConnected()) {
|
|
server.previousPlay(gameId, sessionId);
|
|
return true;
|
|
}
|
|
} catch (MageException ex) {
|
|
handleMageException(ex);
|
|
} catch (Throwable t) {
|
|
handleThrowable(t);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public boolean cheat(UUID gameId, UUID playerId, DeckCardLists deckList) {
|
|
try {
|
|
if (isConnected()) {
|
|
server.cheat(gameId, sessionId, playerId, deckList);
|
|
return true;
|
|
}
|
|
} catch (MageException ex) {
|
|
handleMageException(ex);
|
|
} catch (Throwable t) {
|
|
handleThrowable(t);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public List<UserView> getUsers() {
|
|
try {
|
|
if (isConnected())
|
|
return server.getUsers(sessionId);
|
|
} catch (MageException ex) {
|
|
handleMageException(ex);
|
|
} catch (Throwable t) {
|
|
handleThrowable(t);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public boolean disconnectUser(String userSessionId) {
|
|
try {
|
|
if (isConnected()) {
|
|
server.disconnectUser(sessionId, userSessionId);
|
|
return true;
|
|
}
|
|
} catch (MageException ex) {
|
|
handleMageException(ex);
|
|
} catch (Throwable t) {
|
|
handleThrowable(t);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private void handleThrowable(Throwable t) {
|
|
logger.fatal("Communication error", t);
|
|
sessionState = SessionState.SERVER_UNAVAILABLE;
|
|
disconnect(true);
|
|
}
|
|
|
|
private void handleMageException(MageException ex) {
|
|
logger.fatal("Server error", ex);
|
|
}
|
|
|
|
private void handleGameException(GameException ex) {
|
|
logger.warn(ex.getMessage());
|
|
client.showError(ex.getMessage());
|
|
}
|
|
|
|
|
|
public String getUserName() {
|
|
return connection.getUsername();
|
|
}
|
|
|
|
}
|
|
|
|
class MageAuthenticator extends Authenticator {
|
|
|
|
private String username;
|
|
private String password;
|
|
|
|
public MageAuthenticator(String username, String password) {
|
|
this.username = username;
|
|
this.password = password;
|
|
}
|
|
|
|
@Override
|
|
public PasswordAuthentication getPasswordAuthentication () {
|
|
return new PasswordAuthentication (username, password.toCharArray());
|
|
}
|
|
} |