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

playertype, enum singleton

Browse source
This commit is contained in:
ingmargoudt 2017-04-02 20:02:14 +02:00
parent b19170f34f
commit 211d433ea9
50 changed files with 642 additions and 675 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -27,10 +27,6 @@
*/
package mage.server;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import mage.cards.repository.CardInfo;
import mage.cards.repository.CardRepository;
import mage.server.exceptions.UserNotFoundException;
@ -40,6 +36,11 @@ import mage.view.ChatMessage.MessageType;
import mage.view.ChatMessage.SoundToPlay;
import org.apache.log4j.Logger;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* @author BetaSteward_at_googlemail.com
*/

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

@ -61,14 +61,14 @@ public class ChatSession {
}
public void join(UUID userId) {
UserManager.instance.getUser(userId).ifPresent(user-> {
if (!clients.containsKey(userId)) {
String userName = user.getName();
clients.put(userId, userName);
broadcast(null, userName + " has joined (" + user.getClientVersion() + ')', MessageColor.BLUE, true, MessageType.STATUS, null);
logger.trace(userName + " joined chat " + chatId);
}
});
UserManager.instance.getUser(userId).ifPresent(user -> {
if (!clients.containsKey(userId)) {
String userName = user.getName();
clients.put(userId, userName);
broadcast(null, userName + " has joined (" + user.getClientVersion() + ')', MessageColor.BLUE, true, MessageType.STATUS, null);
logger.trace(userName + " joined chat " + chatId);
}
});
}
public void kill(UUID userId, DisconnectReason reason) {
@ -139,24 +139,20 @@ public class ChatSession {
public void broadcast(String userName, String message, MessageColor color, boolean withTime, MessageType messageType, SoundToPlay soundToPlay) {
if (!message.isEmpty()) {
HashSet<UUID> clientsToRemove = null;
HashSet<UUID> clientsToRemove = new HashSet<>();
ClientCallback clientCallback = new ClientCallback("chatMessage", chatId, new ChatMessage(userName, message, (withTime ? timeFormatter.format(new Date()) : ""), color, messageType, soundToPlay));
for (UUID userId : clients.keySet()) {
Optional<User> user = UserManager.instance.getUser(userId);
if (user.isPresent()) {
user.get().fireCallback(clientCallback);
} else {
if (clientsToRemove == null) {
clientsToRemove = new HashSet<>();
}
clientsToRemove.add(userId);
clientsToRemove = new HashSet<>();
}
}
if (clientsToRemove != null) {
for (UUID userIdToRemove : clientsToRemove) {
clients.remove(userIdToRemove);
}
for (UUID userIdToRemove : clientsToRemove) {
clients.remove(userIdToRemove);
}
}
}

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

@ -6,5 +6,11 @@ package mage.server;
*/
public enum DisconnectReason {
LostConnection, Disconnected, CleaningUp, ConnectingOtherInstance, AdminDisconnect, SessionExpired, Undefined
LostConnection,
Disconnected,
CleaningUp,
ConnectingOtherInstance,
AdminDisconnect,
SessionExpired,
Undefined
}

23
Mage.Server/src/main/java/mage/server/MageServerImpl.java
View file

@ -45,6 +45,7 @@ import mage.interfaces.ActionWithResult;
import mage.interfaces.MageServer;
import mage.interfaces.ServerState;
import mage.interfaces.callback.ClientCallback;
import mage.players.PlayerType;
import mage.players.net.UserData;
import mage.remote.MageVersionException;
import mage.server.draft.CubeFactory;
@ -74,7 +75,7 @@ import java.util.concurrent.ExecutorService;
public class MageServerImpl implements MageServer {
private static final Logger logger = Logger.getLogger(MageServerImpl.class);
private static final ExecutorService callExecutor = ThreadExecutor.getInstance().getCallExecutor();
private static final ExecutorService callExecutor = ThreadExecutor.instance.getCallExecutor();
private static final SecureRandom RANDOM = new SecureRandom();
private final String adminPassword;
@ -233,8 +234,8 @@ public class MageServerImpl implements MageServer {
String maxAiOpponents = ConfigSettings.instance.getMaxAiOpponents();
if (maxAiOpponents != null) {
int aiPlayers = 0;
for (String playerType : options.getPlayerTypes()) {
if (!playerType.equals("Human")) {
for (PlayerType playerType : options.getPlayerTypes()) {
if (playerType != PlayerType.HUMAN) {
aiPlayers++;
}
}
@ -282,7 +283,7 @@ public class MageServerImpl implements MageServer {
}
@Override
public boolean joinTable(final String sessionId, final UUID roomId, final UUID tableId, final String name, final String playerType, final int skill, final DeckCardLists deckList, final String password) throws MageException, GameException {
public boolean joinTable(final String sessionId, final UUID roomId, final UUID tableId, final String name, final PlayerType playerType, final int skill, final DeckCardLists deckList, final String password) throws MageException, GameException {
return executeWithResult("joinTable", sessionId, new ActionWithBooleanResult() {
@Override
public Boolean execute() throws MageException {
@ -309,7 +310,7 @@ public class MageServerImpl implements MageServer {
}
@Override
public boolean joinTournamentTable(final String sessionId, final UUID roomId, final UUID tableId, final String name, final String playerType, final int skill, final DeckCardLists deckList, final String password) throws MageException, GameException {
public boolean joinTournamentTable(final String sessionId, final UUID roomId, final UUID tableId, final String name, final PlayerType playerType, final int skill, final DeckCardLists deckList, final String password) throws MageException, GameException {
return executeWithResult("joinTournamentTable", sessionId, new ActionWithBooleanResult() {
@Override
public Boolean execute() throws MageException {
@ -989,11 +990,11 @@ public class MageServerImpl implements MageServer {
public ServerState getServerState() throws MageException {
try {
return new ServerState(
GameFactory.getInstance().getGameTypes(),
TournamentFactory.getInstance().getTournamentTypes(),
PlayerFactory.getInstance().getPlayerTypes().toArray(new String[PlayerFactory.getInstance().getPlayerTypes().size()]),
DeckValidatorFactory.getInstance().getDeckTypes().toArray(new String[DeckValidatorFactory.getInstance().getDeckTypes().size()]),
CubeFactory.getInstance().getDraftCubes().toArray(new String[CubeFactory.getInstance().getDraftCubes().size()]),
GameFactory.instance.getGameTypes(),
TournamentFactory.instance.getTournamentTypes(),
PlayerFactory.instance.getPlayerTypes().toArray(new PlayerType[PlayerFactory.instance.getPlayerTypes().size()]),
DeckValidatorFactory.instance.getDeckTypes().toArray(new String[DeckValidatorFactory.instance.getDeckTypes().size()]),
CubeFactory.instance.getDraftCubes().toArray(new String[CubeFactory.instance.getDraftCubes().size()]),
testMode,
Main.getVersion(),
CardRepository.instance.getContentVersionConstant(),
@ -1161,7 +1162,7 @@ public class MageServerImpl implements MageServer {
session -> FeedbackServiceImpl.instance.feedback(username, title, type, message, email, session.getHost())
));
));
}
}

15
Mage.Server/src/main/java/mage/server/Main.java
View file

@ -62,7 +62,6 @@ import org.w3c.dom.Element;
import javax.management.MBeanServer;
import java.io.File;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.net.InetAddress;
import java.net.MalformedURLException;
import java.util.*;
@ -164,31 +163,31 @@ public final class Main {
deleteSavedGames();
ConfigSettings config = ConfigSettings.instance;
for (GamePlugin plugin : config.getGameTypes()) {
GameFactory.getInstance().addGameType(plugin.getName(), loadGameType(plugin), loadPlugin(plugin));
GameFactory.instance.addGameType(plugin.getName(), loadGameType(plugin), loadPlugin(plugin));
}
for (GamePlugin plugin : config.getTournamentTypes()) {
TournamentFactory.getInstance().addTournamentType(plugin.getName(), loadTournamentType(plugin), loadPlugin(plugin));
TournamentFactory.instance.addTournamentType(plugin.getName(), loadTournamentType(plugin), loadPlugin(plugin));
}
for (Plugin plugin : config.getPlayerTypes()) {
PlayerFactory.getInstance().addPlayerType(plugin.getName(), loadPlugin(plugin));
PlayerFactory.instance.addPlayerType(plugin.getName(), loadPlugin(plugin));
}
for (Plugin plugin : config.getDraftCubes()) {
CubeFactory.getInstance().addDraftCube(plugin.getName(), loadPlugin(plugin));
CubeFactory.instance.addDraftCube(plugin.getName(), loadPlugin(plugin));
}
for (Plugin plugin : config.getDeckTypes()) {
DeckValidatorFactory.getInstance().addDeckType(plugin.getName(), loadPlugin(plugin));
DeckValidatorFactory.instance.addDeckType(plugin.getName(), loadPlugin(plugin));
}
for (ExtensionPackage pkg : extensions) {
Map<String, Class> draftCubes = pkg.getDraftCubes();
for (String name : draftCubes.keySet()) {
logger.info("Loading extension: [" + name + "] " + draftCubes.get(name).toString());
CubeFactory.getInstance().addDraftCube(name, draftCubes.get(name));
CubeFactory.instance.addDraftCube(name, draftCubes.get(name));
}
Map<String, Class> deckTypes = pkg.getDeckTypes();
for (String name : deckTypes.keySet()) {
logger.info("Loading extension: [" + name + "] " + deckTypes.get(name));
DeckValidatorFactory.getInstance().addDeckType(name, deckTypes.get(name));
DeckValidatorFactory.instance.addDeckType(name, deckTypes.get(name));
}
}

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

@ -45,6 +45,7 @@ import mage.game.tournament.Tournament;
import mage.game.tournament.TournamentOptions;
import mage.game.tournament.TournamentPlayer;
import mage.players.Player;
import mage.players.PlayerType;
import mage.server.draft.DraftManager;
import mage.server.game.DeckValidatorFactory;
import mage.server.game.GameFactory;
@ -87,12 +88,12 @@ public class TableController {
private Tournament tournament;
private ScheduledFuture<?> futureTimeout;
protected static final ScheduledExecutorService timeoutExecutor = ThreadExecutor.getInstance().getTimeoutExecutor();
protected static final ScheduledExecutorService timeoutExecutor = ThreadExecutor.instance.getTimeoutExecutor();
public TableController(UUID roomId, UUID userId, MatchOptions options) {
this.userId = userId;
this.options = options;
match = GameFactory.getInstance().createMatch(options.getGameType(), options);
match = GameFactory.instance.createMatch(options.getGameType(), options);
if (userId != null) {
Optional<User> user = UserManager.instance.getUser(userId);
// TODO: Handle if user == null
@ -100,14 +101,14 @@ public class TableController {
} else {
controllerName = "System";
}
table = new Table(roomId, options.getGameType(), options.getName(), controllerName, DeckValidatorFactory.getInstance().createDeckValidator(options.getDeckType()), options.getPlayerTypes(), TableRecorderImpl.getInstance(), match, options.getBannedUsers());
table = new Table(roomId, options.getGameType(), options.getName(), controllerName, DeckValidatorFactory.instance.createDeckValidator(options.getDeckType()), options.getPlayerTypes(), TableRecorderImpl.instance, match, options.getBannedUsers());
chatId = ChatManager.instance.createChatSession("Match Table " + table.getId());
init();
}
public TableController(UUID roomId, UUID userId, TournamentOptions options) {
this.userId = userId;
tournament = TournamentFactory.getInstance().createTournament(options.getTournamentType(), options);
tournament = TournamentFactory.instance.createTournament(options.getTournamentType(), options);
if (userId != null) {
Optional<User> user = UserManager.instance.getUser(userId);
if (!user.isPresent()) {
@ -119,7 +120,7 @@ public class TableController {
} else {
controllerName = "System";
}
table = new Table(roomId, options.getTournamentType(), options.getName(), controllerName, DeckValidatorFactory.getInstance().createDeckValidator(options.getMatchOptions().getDeckType()), options.getPlayerTypes(), TableRecorderImpl.getInstance(), tournament, options.getMatchOptions().getBannedUsers());
table = new Table(roomId, options.getTournamentType(), options.getName(), controllerName, DeckValidatorFactory.instance.createDeckValidator(options.getMatchOptions().getDeckType()), options.getPlayerTypes(), TableRecorderImpl.instance, tournament, options.getMatchOptions().getBannedUsers());
chatId = ChatManager.instance.createChatSession("Tourn. table " + table.getId());
}
@ -139,7 +140,7 @@ public class TableController {
);
}
public synchronized boolean joinTournament(UUID userId, String name, String playerType, int skill, DeckCardLists deckList, String password) throws GameException {
public synchronized boolean joinTournament(UUID userId, String name, PlayerType playerType, int skill, DeckCardLists deckList, String password) throws GameException {
if (table.getState() != TableState.WAITING) {
return false;
}
@ -155,13 +156,13 @@ public class TableController {
}
User user = _user.get();
// check password
if (!table.getTournament().getOptions().getPassword().isEmpty() && playerType.equals("Human")) {
if (!table.getTournament().getOptions().getPassword().isEmpty() && playerType == PlayerType.HUMAN) {
if (!table.getTournament().getOptions().getPassword().equals(password)) {
user.showUserMessage("Join Table", "Wrong password.");
return false;
}
}
if (userPlayerMap.containsKey(userId) && playerType.equals("Human")) {
if (userPlayerMap.containsKey(userId) && playerType == PlayerType.HUMAN) {
user.showUserMessage("Join Table", "You can join a table only one time.");
return false;
}
@ -228,7 +229,7 @@ public class TableController {
return userPlayerMap.containsKey(userId);
}
public synchronized boolean replaceDraftPlayer(Player oldPlayer, String name, String playerType, int skill) {
public synchronized boolean replaceDraftPlayer(Player oldPlayer, String name, PlayerType playerType, int skill) {
Optional<Player> newPlayerOpt = createPlayer(name, playerType, skill);
if (!newPlayerOpt.isPresent() || table.getState() != TableState.DRAFTING) {
return false;
@ -246,13 +247,13 @@ public class TableController {
return true;
}
public synchronized boolean joinTable(UUID userId, String name, String playerType, int skill, DeckCardLists deckList, String password) throws MageException {
public synchronized boolean joinTable(UUID userId, String name, PlayerType playerType, int skill, DeckCardLists deckList, String password) throws MageException {
Optional<User> _user = UserManager.instance.getUser(userId);
if (!_user.isPresent()) {
return false;
}
User user = _user.get();
if (userPlayerMap.containsKey(userId) && playerType.equals("Human")) {
if (userPlayerMap.containsKey(userId) && playerType == PlayerType.HUMAN) {
user.showUserMessage("Join Table", new StringBuilder("You can join a table only one time.").toString());
return false;
}
@ -261,7 +262,7 @@ public class TableController {
return false;
}
// check password
if (!table.getMatch().getOptions().getPassword().isEmpty() && playerType.equals("Human")) {
if (!table.getMatch().getOptions().getPassword().isEmpty() && playerType == PlayerType.HUMAN) {
if (!table.getMatch().getOptions().getPassword().equals(password)) {
user.showUserMessage("Join Table", "Wrong password.");
return false;
@ -370,7 +371,7 @@ public class TableController {
return true;
}
public void addPlayer(UUID userId, Player player, String playerType, Deck deck) throws GameException {
public void addPlayer(UUID userId, Player player, PlayerType playerType, Deck deck) throws GameException {
if (table.getState() != TableState.WAITING) {
return;
}
@ -480,12 +481,12 @@ public class TableController {
// ReplayManager.instance.replayGame(table.getId(), userId);
// return true;
// }
private Optional<Player> createPlayer(String name, String playerType, int skill) {
private Optional<Player> createPlayer(String name, PlayerType playerType, int skill) {
Optional<Player> playerOpt;
if (options == null) {
playerOpt = PlayerFactory.getInstance().createPlayer(playerType, name, RangeOfInfluence.ALL, skill);
playerOpt = PlayerFactory.instance.createPlayer(playerType, name, RangeOfInfluence.ALL, skill);
} else {
playerOpt = PlayerFactory.getInstance().createPlayer(playerType, name, options.getRange(), skill);
playerOpt = PlayerFactory.instance.createPlayer(playerType, name, options.getRange(), skill);
}
if (playerOpt.isPresent()) {
Player player = playerOpt.get();
@ -876,7 +877,7 @@ public class TableController {
if (table.getState() == TableState.READY_TO_START) {
if (seatNum1 >= 0 && seatNum2 >= 0 && seatNum1 < table.getSeats().length && seatNum2 < table.getSeats().length) {
Player swapPlayer = table.getSeats()[seatNum1].getPlayer();
String swapType = table.getSeats()[seatNum1].getPlayerType();
PlayerType swapType = table.getSeats()[seatNum1].getPlayerType();
table.getSeats()[seatNum1].setPlayer(table.getSeats()[seatNum2].getPlayer());
table.getSeats()[seatNum1].setPlayerType(table.getSeats()[seatNum2].getPlayerType());
table.getSeats()[seatNum2].setPlayer(swapPlayer);

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

@ -28,17 +28,7 @@
package mage.server;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.Map.Entry;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
import mage.MageException;
import mage.cards.decks.Deck;
import mage.cards.decks.DeckCardLists;
import mage.constants.TableState;
import mage.game.Game;
@ -50,13 +40,22 @@ import mage.game.match.MatchOptions;
import mage.game.tournament.Tournament;
import mage.game.tournament.TournamentOptions;
import mage.game.tournament.TournamentPlayer;
import mage.players.Player;
import mage.players.PlayerType;
import mage.server.game.GameController;
import mage.server.game.GameManager;
import mage.server.game.GamesRoomManager;
import mage.server.util.ThreadExecutor;
import org.apache.log4j.Logger;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.Map.Entry;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
/**
* @author BetaSteward_at_googlemail.com
*/
@ -133,14 +132,14 @@ public enum TableManager {
return Optional.empty();
}
public boolean joinTable(UUID userId, UUID tableId, String name, String playerType, int skill, DeckCardLists deckList, String password) throws MageException {
public boolean joinTable(UUID userId, UUID tableId, String name, PlayerType playerType, int skill, DeckCardLists deckList, String password) throws MageException {
if (controllers.containsKey(tableId)) {
return controllers.get(tableId).joinTable(userId, name, playerType, skill, deckList, password);
}
return false;
}
public boolean joinTournament(UUID userId, UUID tableId, String name, String playerType, int skill, DeckCardLists deckList, String password) throws GameException {
public boolean joinTournament(UUID userId, UUID tableId, String name, PlayerType playerType, int skill, DeckCardLists deckList, String password) throws GameException {
if (controllers.containsKey(tableId)) {
return controllers.get(tableId).joinTournament(userId, name, playerType, skill, deckList, password);
}
@ -376,7 +375,7 @@ public enum TableManager {
logger.debug(chatSession.getChatId() + " " + formatter.format(chatSession.getCreateTime()) + ' ' + chatSession.getInfo() + ' ' + chatSession.getClients().values().toString());
}
logger.debug("------- Games: " + GameManager.instance.getNumberActiveGames() + " --------------------------------------------");
logger.debug(" Active Game Worker: " + ThreadExecutor.getInstance().getActiveThreads(ThreadExecutor.getInstance().getGameExecutor()));
logger.debug(" Active Game Worker: " + ThreadExecutor.instance.getActiveThreads(ThreadExecutor.instance.getGameExecutor()));
for (Entry<UUID, GameController> entry : GameManager.instance.getGameController().entrySet()) {
logger.debug(entry.getKey() + entry.getValue().getPlayerNameList());
}

2
Mage.Server/src/main/java/mage/server/UserManager.java
View file

@ -51,7 +51,7 @@ public enum UserManager {
private final ConcurrentHashMap<UUID, User> users = new ConcurrentHashMap<>();
private static final ExecutorService USER_EXECUTOR = ThreadExecutor.getInstance().getCallExecutor();
private static final ExecutorService USER_EXECUTOR = ThreadExecutor.instance.getCallExecutor();
UserManager() {
expireExecutor.scheduleAtFixedRate(this::checkExpired, 60, 60, TimeUnit.SECONDS);

13
Mage.Server/src/main/java/mage/server/challenge/ChallengeManager.java
View file

@ -1,10 +1,11 @@
package mage.server.challenge;
import mage.constants.Zone;
import mage.game.match.Match;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;
import mage.constants.Zone;
import mage.game.match.Match;
/**
* C U R R E N T L Y U N U S E D
@ -12,13 +13,9 @@ import mage.game.match.Match;
* Loads challenges from scenarios.
* Configure games by initializing starting game board.
*/
public class ChallengeManager {
public enum ChallengeManager {
public static final ChallengeManager instance = new ChallengeManager();
public static ChallengeManager getInstance() {
return instance;
}
instance;
public void prepareChallenge(UUID playerId, Match match) {
Map<Zone, String> commands = new HashMap<>();

15
Mage.Server/src/main/java/mage/server/draft/CubeFactory.java
View file

@ -27,30 +27,27 @@
*/
package mage.server.draft;
import mage.cards.decks.Deck;
import mage.game.draft.DraftCube;
import org.apache.log4j.Logger;
import java.lang.reflect.Constructor;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;
import mage.cards.decks.Deck;
import mage.game.draft.DraftCube;
import org.apache.log4j.Logger;
/**
*
* @author LevelX2
*/
public class CubeFactory {
public enum CubeFactory {
private static final CubeFactory INSTANCE = new CubeFactory();
instance;
private static final Logger logger = Logger.getLogger(CubeFactory.class);
private final Map<String, Class> draftCubes = new LinkedHashMap<>();
public static CubeFactory getInstance() {
return INSTANCE;
}
private CubeFactory() {}
public DraftCube createDraftCube(String draftCubeName) {

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

@ -28,12 +28,6 @@
package mage.server.draft;
import java.io.File;
import java.util.Map.Entry;
import java.util.Optional;
import java.util.Set;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;
import mage.MageException;
import mage.game.draft.Draft;
import mage.game.draft.DraftPlayer;
@ -48,6 +42,13 @@ import mage.server.util.ThreadExecutor;
import mage.view.DraftPickView;
import org.apache.log4j.Logger;
import java.io.File;
import java.util.Map.Entry;
import java.util.Optional;
import java.util.Set;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;
/**
*
* @author BetaSteward_at_googlemail.com
@ -152,7 +153,7 @@ public class DraftController {
private synchronized void checkStart() {
if (!draft.isStarted() && allJoined()) {
draft.setStarted();
ThreadExecutor.getInstance().getCallExecutor().execute(this::startDraft);
ThreadExecutor.instance.getCallExecutor().execute(this::startDraft);
}
}

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

@ -28,14 +28,6 @@
package mage.server.draft;
import java.rmi.RemoteException;
import java.util.Optional;
import java.util.Set;
import java.util.UUID;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.TimeUnit;
import mage.game.draft.Draft;
import mage.interfaces.callback.ClientCallback;
import mage.server.User;
@ -46,6 +38,14 @@ import mage.view.DraftPickView;
import mage.view.DraftView;
import org.apache.log4j.Logger;
import java.rmi.RemoteException;
import java.util.Optional;
import java.util.Set;
import java.util.UUID;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.TimeUnit;
/**
* @author BetaSteward_at_googlemail.com
*/
@ -60,7 +60,7 @@ public class DraftSession {
protected UUID markedCard;
private ScheduledFuture<?> futureTimeout;
protected static final ScheduledExecutorService timeoutExecutor = ThreadExecutor.getInstance().getTimeoutExecutor();
protected static final ScheduledExecutorService timeoutExecutor = ThreadExecutor.instance.getTimeoutExecutor();
public DraftSession(Draft draft, UUID userId, UUID playerId) {
this.userId = userId;

13
Mage.Server/src/main/java/mage/server/game/DeckValidatorFactory.java
View file

@ -28,27 +28,26 @@
package mage.server.game;
import mage.cards.decks.DeckValidator;
import org.apache.log4j.Logger;
import java.lang.reflect.Constructor;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;
import mage.cards.decks.DeckValidator;
import org.apache.log4j.Logger;
/**
*
* @author BetaSteward_at_googlemail.com
*/
public class DeckValidatorFactory {
public enum DeckValidatorFactory {
private static final DeckValidatorFactory INSTANCE = new DeckValidatorFactory();
instance;
private static final Logger logger = Logger.getLogger(DeckValidatorFactory.class);
private final Map<String, Class> deckTypes = new LinkedHashMap<>();
public static DeckValidatorFactory getInstance() {
return INSTANCE;
}
private DeckValidatorFactory() {}

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

@ -27,23 +27,6 @@
*/
package mage.server.game;
import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutput;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.io.Serializable;
import java.util.*;
import java.util.Map.Entry;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.TimeUnit;
import java.util.zip.GZIPOutputStream;
import mage.MageException;
import mage.abilities.Ability;
import mage.cards.Card;
@ -66,37 +49,35 @@ import mage.game.events.TableEvent;
import mage.game.permanent.Permanent;
import mage.interfaces.Action;
import mage.players.Player;
import mage.server.ChatManager;
import mage.server.Main;
import mage.server.TableManager;
import mage.server.User;
import mage.server.UserManager;
import mage.server.*;
import mage.server.util.ConfigSettings;
import mage.server.util.Splitter;
import mage.server.util.SystemUtil;
import mage.server.util.ThreadExecutor;
import mage.utils.timer.PriorityTimer;
import mage.view.AbilityPickerView;
import mage.view.CardsView;
import mage.view.ChatMessage;
import mage.view.*;
import mage.view.ChatMessage.MessageColor;
import mage.view.ChatMessage.MessageType;
import mage.view.GameView;
import mage.view.PermanentView;
import org.apache.log4j.Logger;
import java.io.*;
import java.util.*;
import java.util.Map.Entry;
import java.util.concurrent.*;
import java.util.zip.GZIPOutputStream;
/**
* @author BetaSteward_at_googlemail.com
*/
public class GameController implements GameCallback {
private static final ExecutorService gameExecutor = ThreadExecutor.getInstance().getGameExecutor();
private static final ExecutorService gameExecutor = ThreadExecutor.instance.getGameExecutor();
private static final Logger logger = Logger.getLogger(GameController.class);
protected final ScheduledExecutorService joinWaitingExecutor = Executors.newSingleThreadScheduledExecutor();
private ScheduledFuture<?> futureTimeout;
protected static final ScheduledExecutorService timeoutIdleExecutor = ThreadExecutor.getInstance().getTimeoutIdleExecutor();
protected static final ScheduledExecutorService timeoutIdleExecutor = ThreadExecutor.instance.getTimeoutIdleExecutor();
private final ConcurrentHashMap<UUID, GameSessionPlayer> gameSessions = new ConcurrentHashMap<>();
private final ConcurrentHashMap<UUID, GameSessionWatcher> watchers = new ConcurrentHashMap<>();
@ -388,7 +369,7 @@ public class GameController implements GameCallback {
private void checkStart() {
if (allJoined()) {
joinWaitingExecutor.shutdownNow();
ThreadExecutor.getInstance().getCallExecutor().execute(this::startGame);
ThreadExecutor.instance.getCallExecutor().execute(this::startGame);
}
}

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

@ -28,24 +28,25 @@
package mage.server.game;
import java.lang.reflect.Constructor;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import mage.game.match.Match;
import mage.game.match.MatchOptions;
import mage.game.match.MatchType;
import mage.view.GameTypeView;
import org.apache.log4j.Logger;
import java.lang.reflect.Constructor;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
*
* @author BetaSteward_at_googlemail.com
*/
public class GameFactory {
public enum GameFactory {
private static final GameFactory INSTANCE = new GameFactory();
instance;
private static final Logger logger = Logger.getLogger(GameFactory.class);
private final Map<String, Class<Match>> games = new HashMap<>();
@ -53,9 +54,6 @@ public class GameFactory {
private final List<GameTypeView> gameTypeViews = new ArrayList<>();
public static GameFactory getInstance() {
return INSTANCE;
}
private GameFactory() {}

11
Mage.Server/src/main/java/mage/server/game/GameSessionPlayer.java
View file

@ -27,10 +27,6 @@
*/
package mage.server.game;
import java.io.Serializable;
import java.util.*;
import java.util.Map.Entry;
import java.util.concurrent.ExecutorService;
import mage.cards.Cards;
import mage.choices.Choice;
import mage.constants.ManaType;
@ -45,6 +41,11 @@ import mage.server.util.ThreadExecutor;
import mage.view.*;
import org.apache.log4j.Logger;
import java.io.Serializable;
import java.util.*;
import java.util.Map.Entry;
import java.util.concurrent.ExecutorService;
/**
* @author BetaSteward_at_googlemail.com
*/
@ -54,7 +55,7 @@ public class GameSessionPlayer extends GameSessionWatcher {
private final UUID playerId;
private static final ExecutorService callExecutor = ThreadExecutor.getInstance().getCallExecutor();
private static final ExecutorService callExecutor = ThreadExecutor.instance.getCallExecutor();
public GameSessionPlayer(Game game, UUID userId, UUID playerId) {
super(userId, game, true);

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

@ -28,19 +28,21 @@
package mage.server.game;
import java.util.List;
import java.util.Optional;
import java.util.UUID;
import mage.MageException;
import mage.cards.decks.DeckCardLists;
import mage.game.GameException;
import mage.game.match.MatchOptions;
import mage.game.tournament.TournamentOptions;
import mage.players.PlayerType;
import mage.server.Room;
import mage.view.MatchView;
import mage.view.RoomUsersView;
import mage.view.TableView;
import java.util.List;
import java.util.Optional;
import java.util.UUID;
/**
*
* @author BetaSteward_at_googlemail.com
@ -50,8 +52,8 @@ public interface GamesRoom extends Room {
List<TableView> getTables();
List<MatchView> getFinished();
List<RoomUsersView> getRoomUsersInfo();
boolean joinTable(UUID userId, UUID tableId, String name, String playerType, int skill, DeckCardLists deckList, String password) throws MageException;
boolean joinTournamentTable(UUID userId, UUID tableId, String name, String playerType, int skill, DeckCardLists deckList, String password) throws GameException;
boolean joinTable(UUID userId, UUID tableId, String name, PlayerType playerType, int skill, DeckCardLists deckList, String password) throws MageException;
boolean joinTournamentTable(UUID userId, UUID tableId, String name, PlayerType playerType, int skill, DeckCardLists deckList, String password) throws GameException;
TableView createTable(UUID userId, MatchOptions options);
TableView createTournamentTable(UUID userId, TournamentOptions options);
void removeTable(UUID userId, UUID tableId);

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

@ -27,13 +27,6 @@
*/
package mage.server.game;
import java.io.Serializable;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
import mage.MageException;
import mage.cards.decks.DeckCardLists;
import mage.constants.TableState;
@ -41,6 +34,7 @@ import mage.game.GameException;
import mage.game.Table;
import mage.game.match.MatchOptions;
import mage.game.tournament.TournamentOptions;
import mage.players.PlayerType;
import mage.server.RoomImpl;
import mage.server.TableManager;
import mage.server.User;
@ -54,6 +48,13 @@ import mage.view.TableView;
import mage.view.UsersView;
import org.apache.log4j.Logger;
import java.io.Serializable;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
/**
* @author BetaSteward_at_googlemail.com
*/
@ -133,7 +134,7 @@ public class GamesRoomImpl extends RoomImpl implements GamesRoom, Serializable {
List<RoomUsersView> roomUserInfo = new ArrayList<>();
roomUserInfo.add(new RoomUsersView(users,
GameManager.instance.getNumberActiveGames(),
ThreadExecutor.getInstance().getActiveThreads(ThreadExecutor.getInstance().getGameExecutor()),
ThreadExecutor.instance.getActiveThreads(ThreadExecutor.instance.getGameExecutor()),
ConfigSettings.instance.getMaxGameThreads()
));
roomUsersView = roomUserInfo;
@ -145,7 +146,7 @@ public class GamesRoomImpl extends RoomImpl implements GamesRoom, Serializable {
}
@Override
public boolean joinTable(UUID userId, UUID tableId, String name, String playerType, int skill, DeckCardLists deckList, String password) throws MageException {
public boolean joinTable(UUID userId, UUID tableId, String name, PlayerType playerType, int skill, DeckCardLists deckList, String password) throws MageException {
if (tables.containsKey(tableId)) {
return TableManager.instance.joinTable(userId, tableId, name, playerType, skill, deckList, password);
} else {
@ -161,7 +162,7 @@ public class GamesRoomImpl extends RoomImpl implements GamesRoom, Serializable {
}
@Override
public boolean joinTournamentTable(UUID userId, UUID tableId, String name, String playerType, int skill, DeckCardLists deckList, String password) throws GameException {
public boolean joinTournamentTable(UUID userId, UUID tableId, String name, PlayerType playerType, int skill, DeckCardLists deckList, String password) throws GameException {
if (tables.containsKey(tableId)) {
return TableManager.instance.joinTournament(userId, tableId, name, playerType, skill, deckList, password);
} else {

30
Mage.Server/src/main/java/mage/server/game/PlayerFactory.java
View file

@ -30,32 +30,26 @@ package mage.server.game;
import mage.constants.RangeOfInfluence;
import mage.players.Player;
import mage.players.PlayerType;
import org.apache.log4j.Logger;
import java.lang.reflect.Constructor;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.EnumMap;
import java.util.Optional;
import java.util.Set;
/**
*
* @author BetaSteward_at_googlemail.com
*/
public class PlayerFactory {
public enum PlayerFactory {
private static final PlayerFactory INSTANCE = new PlayerFactory();
instance;
private static final Logger logger = Logger.getLogger(PlayerFactory.class);
private final Map<String, Class> playerTypes = new LinkedHashMap<>();
private final EnumMap<PlayerType, Class> playerTypes = new EnumMap<>(PlayerType.class);
public static PlayerFactory getInstance() {
return INSTANCE;
}
private PlayerFactory() {}
public Optional<Player> createPlayer(String playerType, String name, RangeOfInfluence range, int skill) {
public Optional<Player> createPlayer(PlayerType playerType, String name, RangeOfInfluence range, int skill) {
try {
Class playerTypeClass = playerTypes.get(playerType);
if (playerTypeClass != null) {
@ -63,8 +57,7 @@ public class PlayerFactory {
Player player = (Player) con.newInstance(name, range, skill);
logger.trace("Player created: " + name + " - " + player.getId());
return Optional.of(player);
}
else {
} else {
logger.fatal("Unknown player type: " + playerType);
}
} catch (Exception ex) {
@ -73,13 +66,16 @@ public class PlayerFactory {
return Optional.empty();
}
public Set<String> getPlayerTypes() {
public Set<PlayerType> getPlayerTypes() {
return playerTypes.keySet();
}
public void addPlayerType(String name, Class playerType) {
if (playerType != null) {
this.playerTypes.put(name, playerType);
PlayerType type = PlayerType.getByDescription(name);
if (type != null) {
if (playerType != null) {
this.playerTypes.put(type, playerType);
}
}
}

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

@ -5,13 +5,9 @@ import mage.game.Table.TableRecorder;
import mage.game.result.ResultProtos.TableProto;
import mage.server.UserManager;
public class TableRecorderImpl implements TableRecorder {
public enum TableRecorderImpl implements TableRecorder {
private final static TableRecorderImpl INSTANCE = new TableRecorderImpl();
public static TableRecorderImpl getInstance() {
return INSTANCE;
}
instance;
@Override
public void record(Table table) {

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

@ -37,17 +37,19 @@ import mage.game.draft.Draft;
import mage.game.events.Listener;
import mage.game.events.PlayerQueryEvent;
import mage.game.events.TableEvent;
import mage.game.match.Match;
import mage.game.match.MatchOptions;
import mage.game.result.ResultProtos.TourneyQuitStatus;
import mage.game.tournament.MultiplayerRound;
import mage.game.tournament.Tournament;
import mage.game.tournament.TournamentPairing;
import mage.game.tournament.TournamentPlayer;
import mage.server.*;
import mage.players.PlayerType;
import mage.server.ChatManager;
import mage.server.TableManager;
import mage.server.User;
import mage.server.UserManager;
import mage.server.draft.DraftController;
import mage.server.draft.DraftManager;
import mage.server.draft.DraftSession;
import mage.server.game.GamesRoomManager;
import mage.server.util.ThreadExecutor;
import mage.view.ChatMessage.MessageColor;
@ -198,7 +200,7 @@ public class TournamentController {
private void checkStart() {
if (!started && allJoined()) {
ThreadExecutor.getInstance().getCallExecutor().execute(this::startTournament);
ThreadExecutor.instance.getCallExecutor().execute(this::startTournament);
}
}
@ -434,7 +436,7 @@ public class TournamentController {
if (user.isPresent()) {
replacePlayerName = "Draftbot (" + user.get().getName() + ')';
}
tableController.replaceDraftPlayer(leavingPlayer.getPlayer(), replacePlayerName, "Computer - draftbot", 5);
tableController.replaceDraftPlayer(leavingPlayer.getPlayer(), replacePlayerName, PlayerType.COMPUTER_DRAFT_BOT, 5);
if (user.isPresent()) {
user.get().removeDraft(leavingPlayer.getPlayer().getId());
user.get().removeTable(leavingPlayer.getPlayer().getId());

21
Mage.Server/src/main/java/mage/server/tournament/TournamentFactory.java
View file

@ -28,12 +28,6 @@
package mage.server.tournament;
import java.lang.reflect.Constructor;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import mage.cards.Sets;
import mage.game.draft.DraftCube;
import mage.game.tournament.Tournament;
@ -43,23 +37,22 @@ import mage.server.draft.CubeFactory;
import mage.view.TournamentTypeView;
import org.apache.log4j.Logger;
import java.lang.reflect.Constructor;
import java.util.*;
/**
*
* @author BetaSteward_at_googlemail.com
*/
public class TournamentFactory {
private static final TournamentFactory INSTANCE = new TournamentFactory();
public enum TournamentFactory {
instance;
private static final Logger logger = Logger.getLogger(TournamentFactory.class);
private final Map<String, Class<Tournament>> tournaments = new HashMap<>();
private final Map<String, TournamentType> tournamentTypes = new HashMap<>();
private final List<TournamentTypeView> tournamentTypeViews = new ArrayList<>();
public static TournamentFactory getInstance() {
return INSTANCE;
}
private TournamentFactory() {}
public Tournament createTournament(String tournamentType, TournamentOptions options) {
@ -81,9 +74,9 @@ public class TournamentFactory {
DraftCube draftCube;
if (tournament.getOptions().getLimitedOptions().getCubeFromDeck() != null) {
draftCube = CubeFactory.getInstance().createDeckDraftCube(tournament.getOptions().getLimitedOptions().getDraftCubeName(), tournament.getOptions().getLimitedOptions().getCubeFromDeck());
draftCube = CubeFactory.instance.createDeckDraftCube(tournament.getOptions().getLimitedOptions().getDraftCubeName(), tournament.getOptions().getLimitedOptions().getCubeFromDeck());
} else {
draftCube = CubeFactory.getInstance().createDraftCube(tournament.getOptions().getLimitedOptions().getDraftCubeName());
draftCube = CubeFactory.instance.createDraftCube(tournament.getOptions().getLimitedOptions().getDraftCubeName());
}
tournament.getOptions().getLimitedOptions().setDraftCube(draftCube);
tournament.setBoosterInfo(tournament.getOptions().getLimitedOptions().getDraftCubeName());

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

@ -56,7 +56,7 @@ public class TournamentSession {
protected boolean killed = false;
private ScheduledFuture<?> futureTimeout;
protected static final ScheduledExecutorService timeoutExecutor = ThreadExecutor.getInstance().getTimeoutExecutor();
protected static final ScheduledExecutorService timeoutExecutor = ThreadExecutor.instance.getTimeoutExecutor();
public TournamentSession(Tournament tournament, UUID userId, UUID tableId, UUID playerId) {
this.userId = userId;

12
Mage.Server/src/main/java/mage/server/util/ThreadExecutor.java
View file

@ -38,8 +38,8 @@ import java.util.concurrent.TimeUnit;
*
* @author BetaSteward_at_googlemail.com
*/
public class ThreadExecutor {
public enum ThreadExecutor {
instance;
private static final ExecutorService callExecutor = Executors.newCachedThreadPool();
private static final ExecutorService userExecutor = Executors.newCachedThreadPool();
private static final ExecutorService gameExecutor = Executors.newFixedThreadPool(ConfigSettings.instance.getMaxGameThreads());
@ -74,14 +74,6 @@ public class ThreadExecutor {
((ThreadPoolExecutor) timeoutIdleExecutor).setThreadFactory(new XMageThreadFactory("TIMEOUT_IDLE"));
}
private static final ThreadExecutor INSTANCE = new ThreadExecutor();
public static ThreadExecutor getInstance() {
return INSTANCE;
}
private ThreadExecutor() {
}
public int getActiveThreads(ExecutorService executerService) {
if (executerService instanceof ThreadPoolExecutor) {