github/mage
1
0
Fork 0
mirror of https://github.com/correl/mage.git synced 2024-12-26 11:09:27 +00:00
Code Issues Projects Releases Packages Wiki Activity

Merge origin/master

Browse source
This commit is contained in:
LevelX2 2018-01-27 11:43:01 +01:00
commit 020beb1bf6
9 changed files with 882 additions and 304 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

61
Mage.Server.Plugins/Mage.Player.AI/src/main/java/mage/player/ai/ComputerPlayer.java
View file

@ -1633,7 +1633,42 @@ public class ComputerPlayer extends PlayerImpl implements Player {
} }
public static Deck buildDeck(List<Card> cardPool, final List<ColoredManaSymbol> colors) { public static Deck buildDeck(List<Card> cardPool, final List<ColoredManaSymbol> colors) {
return buildDeck(cardPool, colors, false);
}
public static Deck buildDeck(List<Card> cardPool, final List<ColoredManaSymbol> colors, boolean onlyBasicLands) {
if (onlyBasicLands) {
return buildDeckWithOnlyBasicLands(cardPool);
} else {
return buildDeckWithNormalCards(cardPool, colors);
}
}
public static Deck buildDeckWithOnlyBasicLands(List<Card> cardPool) {
// random cards from card pool
Deck deck = new Deck(); Deck deck = new Deck();
final int DECK_SIZE = 40;
List<Card> sortedCards = new ArrayList<>(cardPool);
if (sortedCards.size() > 0) {
while (deck.getCards().size() < DECK_SIZE) {
deck.getCards().add(sortedCards.get(RandomUtil.nextInt(sortedCards.size())));
}
return deck;
} else {
addBasicLands(deck, "Forest", DECK_SIZE);
return deck;
}
}
public static Deck buildDeckWithNormalCards(List<Card> cardPool, final List<ColoredManaSymbol> colors) {
// top 23 cards plus basic lands until 40 deck size
Deck deck = new Deck();
final int DECK_SIZE = 40;
final int DECK_CARDS_COUNT = 23;
final int DECK_LANDS_COUNT = DECK_SIZE - DECK_CARDS_COUNT;
// sort card pool by top score
List<Card> sortedCards = new ArrayList<>(cardPool); List<Card> sortedCards = new ArrayList<>(cardPool);
Collections.sort(sortedCards, new Comparator<Card>() { Collections.sort(sortedCards, new Comparator<Card>() {
@Override @Override
@ -1643,8 +1678,10 @@ public class ComputerPlayer extends PlayerImpl implements Player {
return score2.compareTo(score1); return score2.compareTo(score1);
} }
}); });
// get top cards
int cardNum = 0; int cardNum = 0;
while (deck.getCards().size() < 23 && sortedCards.size() > cardNum) { while (deck.getCards().size() < DECK_CARDS_COUNT && sortedCards.size() > cardNum) {
Card card = sortedCards.get(cardNum); Card card = sortedCards.get(cardNum);
if (!card.isBasic()) { if (!card.isBasic()) {
deck.getCards().add(card); deck.getCards().add(card);
@ -1652,53 +1689,61 @@ public class ComputerPlayer extends PlayerImpl implements Player {
} }
cardNum++; cardNum++;
} }
// add basic lands
// add basic lands by color percent
// TODO: compensate for non basic lands // TODO: compensate for non basic lands
Mana mana = new Mana(); Mana mana = new Mana();
for (Card card : deck.getCards()) { for (Card card : deck.getCards()) {
mana.add(card.getManaCost().getMana()); mana.add(card.getManaCost().getMana());
} }
double total = mana.getBlack() + mana.getBlue() + mana.getGreen() + mana.getRed() + mana.getWhite(); double total = mana.getBlack() + mana.getBlue() + mana.getGreen() + mana.getRed() + mana.getWhite();
// most frequent land is forest by defalt
int mostLand = 0; int mostLand = 0;
String mostLandName = "Forest"; String mostLandName = "Forest";
if (mana.getGreen() > 0) { if (mana.getGreen() > 0) {
int number = (int) Math.round(mana.getGreen() / total * 17); int number = (int) Math.round(mana.getGreen() / total * DECK_LANDS_COUNT);
addBasicLands(deck, "Forest", number); addBasicLands(deck, "Forest", number);
mostLand = number; mostLand = number;
} }
if (mana.getBlack() > 0) { if (mana.getBlack() > 0) {
int number = (int) Math.round(mana.getBlack() / total * 17); int number = (int) Math.round(mana.getBlack() / total * DECK_LANDS_COUNT);
addBasicLands(deck, "Swamp", number); addBasicLands(deck, "Swamp", number);
if (number > mostLand) { if (number > mostLand) {
mostLand = number; mostLand = number;
mostLandName = "Swamp"; mostLandName = "Swamp";
} }
} }
if (mana.getBlue() > 0) { if (mana.getBlue() > 0) {
int number = (int) Math.round(mana.getBlue() / total * 17); int number = (int) Math.round(mana.getBlue() / total * DECK_LANDS_COUNT);
addBasicLands(deck, "Island", number); addBasicLands(deck, "Island", number);
if (number > mostLand) { if (number > mostLand) {
mostLand = number; mostLand = number;
mostLandName = "Island"; mostLandName = "Island";
} }
} }
if (mana.getWhite() > 0) { if (mana.getWhite() > 0) {
int number = (int) Math.round(mana.getWhite() / total * 17); int number = (int) Math.round(mana.getWhite() / total * DECK_LANDS_COUNT);
addBasicLands(deck, "Plains", number); addBasicLands(deck, "Plains", number);
if (number > mostLand) { if (number > mostLand) {
mostLand = number; mostLand = number;
mostLandName = "Plains"; mostLandName = "Plains";
} }
} }
if (mana.getRed() > 0) { if (mana.getRed() > 0) {
int number = (int) Math.round(mana.getRed() / total * 17); int number = (int) Math.round(mana.getRed() / total * DECK_LANDS_COUNT);
addBasicLands(deck, "Mountain", number); addBasicLands(deck, "Mountain", number);
if (number > mostLand) { if (number > mostLand) {
mostLandName = "Plains"; mostLandName = "Plains";
} }
} }
addBasicLands(deck, mostLandName, 40 - deck.getCards().size()); // adds remaining lands (most popular name)
addBasicLands(deck, mostLandName, DECK_SIZE - deck.getCards().size());
return deck; return deck;
} }

69
Mage.Server.Plugins/Mage.Player.Human/src/mage/player/human/HumanPlayer.java
View file

@ -74,6 +74,7 @@ import mage.target.common.TargetDefender;
import mage.util.GameLog; import mage.util.GameLog;
import mage.util.ManaUtil; import mage.util.ManaUtil;
import mage.util.MessageToClient; import mage.util.MessageToClient;
import mage.util.RandomUtil;
import org.apache.log4j.Logger; import org.apache.log4j.Logger;
/** /**
@ -82,6 +83,7 @@ import org.apache.log4j.Logger;
*/ */
public class HumanPlayer extends PlayerImpl { public class HumanPlayer extends PlayerImpl {
private transient Boolean responseOpenedForAnswer = false; // can't get response until prepared target (e.g. until send all fire events to all players)
private final transient PlayerResponse response = new PlayerResponse(); private final transient PlayerResponse response = new PlayerResponse();
protected static FilterCreatureForCombatBlock filterCreatureForCombatBlock = new FilterCreatureForCombatBlock(); protected static FilterCreatureForCombatBlock filterCreatureForCombatBlock = new FilterCreatureForCombatBlock();
@ -148,6 +150,17 @@ public class HumanPlayer extends PlayerImpl {
|| (actionIterations > 0 && !actionQueueSaved.isEmpty())); || (actionIterations > 0 && !actionQueueSaved.isEmpty()));
} }
protected void waitResponseOpen() {
// wait response open for answer process
while(!responseOpenedForAnswer && canRespond()) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
logger.warn("Response waiting interrapted for " + getId());
}
}
}
protected boolean pullResponseFromQueue(Game game) { protected boolean pullResponseFromQueue(Game game) {
if (actionQueue.isEmpty() && actionIterations > 0 && !actionQueueSaved.isEmpty()) { if (actionQueue.isEmpty() && actionIterations > 0 && !actionQueueSaved.isEmpty()) {
actionQueue = new LinkedList(actionQueueSaved); actionQueue = new LinkedList(actionQueueSaved);
@ -164,6 +177,7 @@ public class HumanPlayer extends PlayerImpl {
} }
sendPlayerAction(PlayerAction.PASS_PRIORITY_UNTIL_STACK_RESOLVED, game, null); sendPlayerAction(PlayerAction.PASS_PRIORITY_UNTIL_STACK_RESOLVED, game, null);
} }
waitResponseOpen();
synchronized (response) { synchronized (response) {
response.copy(action); response.copy(action);
response.notifyAll(); response.notifyAll();
@ -174,6 +188,11 @@ public class HumanPlayer extends PlayerImpl {
return false; return false;
} }
protected void prepareForResponse(Game game) {
//logger.info("Prepare waiting " + getId());
responseOpenedForAnswer = false;
}
protected void waitForResponse(Game game) { protected void waitForResponse(Game game) {
if (isExecutingMacro()) { if (isExecutingMacro()) {
pullResponseFromQueue(game); pullResponseFromQueue(game);
@ -184,21 +203,27 @@ public class HumanPlayer extends PlayerImpl {
// } // }
return; return;
} }
response.clear(); response.clear(); // TODO: only one response for all games (can play only one game per session)?!
logger.debug("Waiting response from player: " + getId()); //logger.info("Waiting response from player: " + getId());
game.resumeTimer(getTurnControlledBy()); game.resumeTimer(getTurnControlledBy());
responseOpenedForAnswer = true; // start waiting for next response
boolean loop = true; boolean loop = true;
while (loop) { while (loop) {
loop = false; loop = false;
synchronized (response) { synchronized (response) {
try { try {
//logger.info("wait start: " + getId());
response.wait(); response.wait();
//logger.info("wait end: " + getId());
} catch (InterruptedException ex) { } catch (InterruptedException ex) {
logger.error("Response error for player " + getName() + " gameId: " + game.getId(), ex); logger.error("Response error for player " + getName() + " gameId: " + game.getId(), ex);
} finally { } finally {
responseOpenedForAnswer = false;
game.pauseTimer(getTurnControlledBy()); game.pauseTimer(getTurnControlledBy());
} }
} }
if (response.getResponseConcedeCheck()) { if (response.getResponseConcedeCheck()) {
((GameImpl) game).checkConcede(); ((GameImpl) game).checkConcede();
if (game.hasEnded()) { if (game.hasEnded()) {
@ -210,6 +235,7 @@ public class HumanPlayer extends PlayerImpl {
} }
} }
} }
//logger.info("Waiting response DONE (res queue " + actionQueueSaved.size() + "): " + getId() + ", res: " + response.toString());
if (recordingMacro && !macroTriggeredSelectionFlag) { if (recordingMacro && !macroTriggeredSelectionFlag) {
// logger.info("Adding an action " + response); // logger.info("Adding an action " + response);
actionQueueSaved.add(new PlayerResponse(response)); actionQueueSaved.add(new PlayerResponse(response));
@ -227,6 +253,7 @@ public class HumanPlayer extends PlayerImpl {
Map<String, Serializable> options = new HashMap<>(); Map<String, Serializable> options = new HashMap<>();
options.put("UI.left.btn.text", "Mulligan"); options.put("UI.left.btn.text", "Mulligan");
options.put("UI.right.btn.text", "Keep"); options.put("UI.right.btn.text", "Keep");
prepareForResponse(game);
if (!isExecutingMacro()) { if (!isExecutingMacro()) {
game.fireAskPlayerEvent(playerId, new MessageToClient(message), null, options); game.fireAskPlayerEvent(playerId, new MessageToClient(message), null, options);
} }
@ -269,6 +296,7 @@ public class HumanPlayer extends PlayerImpl {
if (messageToClient.getSecondMessage() == null) { if (messageToClient.getSecondMessage() == null) {
messageToClient.setSecondMessage(getRelatedObjectName(source, game)); messageToClient.setSecondMessage(getRelatedObjectName(source, game));
} }
prepareForResponse(game);
if (!isExecutingMacro()) { if (!isExecutingMacro()) {
game.fireAskPlayerEvent(playerId, messageToClient, source, options); game.fireAskPlayerEvent(playerId, messageToClient, source, options);
} }
@ -330,10 +358,11 @@ public class HumanPlayer extends PlayerImpl {
replacementEffectChoice.setKeyChoices(rEffects); replacementEffectChoice.setKeyChoices(rEffects);
while (!abort) { while (!abort) {
updateGameStatePriority("chooseEffect", game);
prepareForResponse(game);
if (!isExecutingMacro()) { if (!isExecutingMacro()) {
game.fireChooseChoiceEvent(playerId, replacementEffectChoice); game.fireChooseChoiceEvent(playerId, replacementEffectChoice);
} }
updateGameStatePriority("chooseEffect", game);
waitForResponse(game); waitForResponse(game);
logger.debug("Choose effect: " + response.getString()); logger.debug("Choose effect: " + response.getString());
if (response.getString() != null) { if (response.getString() != null) {
@ -367,6 +396,7 @@ public class HumanPlayer extends PlayerImpl {
} }
updateGameStatePriority("choose(3)", game); updateGameStatePriority("choose(3)", game);
while (!abort) { while (!abort) {
prepareForResponse(game);
if (!isExecutingMacro()) { if (!isExecutingMacro()) {
game.fireChooseChoiceEvent(playerId, choice); game.fireChooseChoiceEvent(playerId, choice);
} }
@ -416,6 +446,7 @@ public class HumanPlayer extends PlayerImpl {
List<UUID> chosen = target.getTargets(); List<UUID> chosen = target.getTargets();
options.put("chosen", (Serializable) chosen); options.put("chosen", (Serializable) chosen);
prepareForResponse(game);
if (!isExecutingMacro()) { if (!isExecutingMacro()) {
game.fireSelectTargetEvent(getId(), new MessageToClient(target.getMessage(), getRelatedObjectName(sourceId, game)), targetIds, required, getOptions(target, options)); game.fireSelectTargetEvent(getId(), new MessageToClient(target.getMessage(), getRelatedObjectName(sourceId, game)), targetIds, required, getOptions(target, options));
} }
@ -483,6 +514,7 @@ public class HumanPlayer extends PlayerImpl {
required = false; required = false;
} }
prepareForResponse(game);
if (!isExecutingMacro()) { if (!isExecutingMacro()) {
game.fireSelectTargetEvent(getId(), new MessageToClient(target.getMessage(), getRelatedObjectName(source, game)), possibleTargets, required, getOptions(target, null)); game.fireSelectTargetEvent(getId(), new MessageToClient(target.getMessage(), getRelatedObjectName(source, game)), possibleTargets, required, getOptions(target, null));
} }
@ -553,6 +585,7 @@ public class HumanPlayer extends PlayerImpl {
options.put("choosable", (Serializable) choosable); options.put("choosable", (Serializable) choosable);
} }
prepareForResponse(game);
if (!isExecutingMacro()) { if (!isExecutingMacro()) {
game.fireSelectTargetEvent(playerId, new MessageToClient(target.getMessage()), cards, required, options); game.fireSelectTargetEvent(playerId, new MessageToClient(target.getMessage()), cards, required, options);
} }
@ -617,6 +650,7 @@ public class HumanPlayer extends PlayerImpl {
if (!isExecutingMacro()) { if (!isExecutingMacro()) {
game.fireSelectTargetEvent(playerId, new MessageToClient(target.getMessage(), getRelatedObjectName(source, game)), cards, required, options); game.fireSelectTargetEvent(playerId, new MessageToClient(target.getMessage(), getRelatedObjectName(source, game)), cards, required, options);
} }
prepareForResponse(game);
waitForResponse(game); waitForResponse(game);
if (response.getUUID() != null) { if (response.getUUID() != null) {
if (target.getTargets().contains(response.getUUID())) { // if already included remove it if (target.getTargets().contains(response.getUUID())) { // if already included remove it
@ -643,6 +677,7 @@ public class HumanPlayer extends PlayerImpl {
public boolean chooseTargetAmount(Outcome outcome, TargetAmount target, Ability source, Game game) { public boolean chooseTargetAmount(Outcome outcome, TargetAmount target, Ability source, Game game) {
updateGameStatePriority("chooseTargetAmount", game); updateGameStatePriority("chooseTargetAmount", game);
while (!abort) { while (!abort) {
prepareForResponse(game);
if (!isExecutingMacro()) { if (!isExecutingMacro()) {
game.fireSelectTargetEvent(playerId, new MessageToClient(target.getMessage() + "\n Amount remaining:" + target.getAmountRemaining(), getRelatedObjectName(source, game)), game.fireSelectTargetEvent(playerId, new MessageToClient(target.getMessage() + "\n Amount remaining:" + target.getAmountRemaining(), getRelatedObjectName(source, game)),
target.possibleTargets(source == null ? null : source.getSourceId(), playerId, game), target.possibleTargets(source == null ? null : source.getSourceId(), playerId, game),
@ -786,6 +821,7 @@ public class HumanPlayer extends PlayerImpl {
while (canRespond()) { while (canRespond()) {
updateGameStatePriority("priority", game); updateGameStatePriority("priority", game);
holdingPriority = false; holdingPriority = false;
prepareForResponse(game);
if (!isExecutingMacro()) { if (!isExecutingMacro()) {
game.firePriorityEvent(playerId); game.firePriorityEvent(playerId);
} }
@ -920,6 +956,7 @@ public class HumanPlayer extends PlayerImpl {
} }
macroTriggeredSelectionFlag = true; macroTriggeredSelectionFlag = true;
updateGameStatePriority("chooseTriggeredAbility", game); updateGameStatePriority("chooseTriggeredAbility", game);
prepareForResponse(game);
if (!isExecutingMacro()) { if (!isExecutingMacro()) {
game.fireSelectTargetTriggeredAbilityEvent(playerId, "Pick triggered ability (goes to the stack first)", abilitiesWithNoOrderSet); game.fireSelectTargetTriggeredAbilityEvent(playerId, "Pick triggered ability (goes to the stack first)", abilitiesWithNoOrderSet);
} }
@ -956,6 +993,7 @@ public class HumanPlayer extends PlayerImpl {
protected boolean playManaHandling(Ability abilityToCast, ManaCost unpaid, String promptText, Game game) { protected boolean playManaHandling(Ability abilityToCast, ManaCost unpaid, String promptText, Game game) {
updateGameStatePriority("playMana", game); updateGameStatePriority("playMana", game);
Map<String, Serializable> options = new HashMap<>(); Map<String, Serializable> options = new HashMap<>();
prepareForResponse(game);
if (!isExecutingMacro()) { if (!isExecutingMacro()) {
game.firePlayManaEvent(playerId, "Pay " + promptText, options); game.firePlayManaEvent(playerId, "Pay " + promptText, options);
} }
@ -992,6 +1030,7 @@ public class HumanPlayer extends PlayerImpl {
int xValue = 0; int xValue = 0;
updateGameStatePriority("announceRepetitions", game); updateGameStatePriority("announceRepetitions", game);
do { do {
prepareForResponse(game);
game.fireGetAmountEvent(playerId, "How many times do you want to repeat your shortcut?", 0, 999); game.fireGetAmountEvent(playerId, "How many times do you want to repeat your shortcut?", 0, 999);
waitForResponse(game); waitForResponse(game);
} while (response.getInteger() == null } while (response.getInteger() == null
@ -1018,6 +1057,7 @@ public class HumanPlayer extends PlayerImpl {
int xValue = 0; int xValue = 0;
updateGameStatePriority("announceXMana", game); updateGameStatePriority("announceXMana", game);
do { do {
prepareForResponse(game);
if (!isExecutingMacro()) { if (!isExecutingMacro()) {
game.fireGetAmountEvent(playerId, message, min, max); game.fireGetAmountEvent(playerId, message, min, max);
} }
@ -1036,6 +1076,7 @@ public class HumanPlayer extends PlayerImpl {
int xValue = 0; int xValue = 0;
updateGameStatePriority("announceXCost", game); updateGameStatePriority("announceXCost", game);
do { do {
prepareForResponse(game);
if (!isExecutingMacro()) { if (!isExecutingMacro()) {
game.fireGetAmountEvent(playerId, message, min, max); game.fireGetAmountEvent(playerId, message, min, max);
} }
@ -1107,6 +1148,7 @@ public class HumanPlayer extends PlayerImpl {
options.put(Constants.Option.SPECIAL_BUTTON, (Serializable) "All attack"); options.put(Constants.Option.SPECIAL_BUTTON, (Serializable) "All attack");
} }
prepareForResponse(game);
if (!isExecutingMacro()) { if (!isExecutingMacro()) {
game.fireSelectEvent(playerId, "Select attackers", options); game.fireSelectEvent(playerId, "Select attackers", options);
} }
@ -1326,6 +1368,7 @@ public class HumanPlayer extends PlayerImpl {
return; return;
} }
while (!abort) { while (!abort) {
prepareForResponse(game);
if (!isExecutingMacro()) { if (!isExecutingMacro()) {
game.fireSelectEvent(playerId, "Select blockers"); game.fireSelectEvent(playerId, "Select blockers");
} }
@ -1358,6 +1401,7 @@ public class HumanPlayer extends PlayerImpl {
public UUID chooseAttackerOrder(List<Permanent> attackers, Game game) { public UUID chooseAttackerOrder(List<Permanent> attackers, Game game) {
updateGameStatePriority("chooseAttackerOrder", game); updateGameStatePriority("chooseAttackerOrder", game);
while (!abort) { while (!abort) {
prepareForResponse(game);
if (!isExecutingMacro()) { if (!isExecutingMacro()) {
game.fireSelectTargetEvent(playerId, "Pick attacker", attackers, true); game.fireSelectTargetEvent(playerId, "Pick attacker", attackers, true);
} }
@ -1377,6 +1421,7 @@ public class HumanPlayer extends PlayerImpl {
public UUID chooseBlockerOrder(List<Permanent> blockers, CombatGroup combatGroup, List<UUID> blockerOrder, Game game) { public UUID chooseBlockerOrder(List<Permanent> blockers, CombatGroup combatGroup, List<UUID> blockerOrder, Game game) {
updateGameStatePriority("chooseBlockerOrder", game); updateGameStatePriority("chooseBlockerOrder", game);
while (!abort) { while (!abort) {
prepareForResponse(game);
if (!isExecutingMacro()) { if (!isExecutingMacro()) {
game.fireSelectTargetEvent(playerId, "Pick blocker", blockers, true); game.fireSelectTargetEvent(playerId, "Pick blocker", blockers, true);
} }
@ -1395,6 +1440,7 @@ public class HumanPlayer extends PlayerImpl {
protected void selectCombatGroup(UUID defenderId, UUID blockerId, Game game) { protected void selectCombatGroup(UUID defenderId, UUID blockerId, Game game) {
updateGameStatePriority("selectCombatGroup", game); updateGameStatePriority("selectCombatGroup", game);
TargetAttackingCreature target = new TargetAttackingCreature(); TargetAttackingCreature target = new TargetAttackingCreature();
prepareForResponse(game);
if (!isExecutingMacro()) { if (!isExecutingMacro()) {
game.fireSelectTargetEvent(playerId, new MessageToClient("Select attacker to block", getRelatedObjectName(blockerId, game)), game.fireSelectTargetEvent(playerId, new MessageToClient("Select attacker to block", getRelatedObjectName(blockerId, game)),
target.possibleTargets(null, playerId, game), false, getOptions(target, null)); target.possibleTargets(null, playerId, game), false, getOptions(target, null));
@ -1447,6 +1493,7 @@ public class HumanPlayer extends PlayerImpl {
public int getAmount(int min, int max, String message, Game game) { public int getAmount(int min, int max, String message, Game game) {
updateGameStatePriority("getAmount", game); updateGameStatePriority("getAmount", game);
do { do {
prepareForResponse(game);
if (!isExecutingMacro()) { if (!isExecutingMacro()) {
game.fireGetAmountEvent(playerId, message, min, max); game.fireGetAmountEvent(playerId, message, min, max);
} }
@ -1478,6 +1525,7 @@ public class HumanPlayer extends PlayerImpl {
LinkedHashMap<UUID, SpecialAction> specialActions = game.getState().getSpecialActions().getControlledBy(playerId, false); LinkedHashMap<UUID, SpecialAction> specialActions = game.getState().getSpecialActions().getControlledBy(playerId, false);
if (!specialActions.isEmpty()) { if (!specialActions.isEmpty()) {
updateGameStatePriority("specialAction", game); updateGameStatePriority("specialAction", game);
prepareForResponse(game);
if (!isExecutingMacro()) { if (!isExecutingMacro()) {
game.fireGetChoiceEvent(playerId, name, null, new ArrayList<>(specialActions.values())); game.fireGetChoiceEvent(playerId, name, null, new ArrayList<>(specialActions.values()));
} }
@ -1494,6 +1542,7 @@ public class HumanPlayer extends PlayerImpl {
LinkedHashMap<UUID, SpecialAction> specialActions = game.getState().getSpecialActions().getControlledBy(playerId, true); LinkedHashMap<UUID, SpecialAction> specialActions = game.getState().getSpecialActions().getControlledBy(playerId, true);
if (!specialActions.isEmpty()) { if (!specialActions.isEmpty()) {
updateGameStatePriority("specialAction", game); updateGameStatePriority("specialAction", game);
prepareForResponse(game);
if (!isExecutingMacro()) { if (!isExecutingMacro()) {
game.fireGetChoiceEvent(playerId, name, null, new ArrayList<>(specialActions.values())); game.fireGetChoiceEvent(playerId, name, null, new ArrayList<>(specialActions.values()));
} }
@ -1539,6 +1588,7 @@ public class HumanPlayer extends PlayerImpl {
} }
} }
prepareForResponse(game);
if (!isExecutingMacro()) { if (!isExecutingMacro()) {
game.fireGetChoiceEvent(playerId, name, object, new ArrayList<>(abilities.values())); game.fireGetChoiceEvent(playerId, name, object, new ArrayList<>(abilities.values()));
} }
@ -1579,6 +1629,7 @@ public class HumanPlayer extends PlayerImpl {
return (SpellAbility) useableAbilities.values().iterator().next(); return (SpellAbility) useableAbilities.values().iterator().next();
} else if (useableAbilities != null } else if (useableAbilities != null
&& !useableAbilities.isEmpty()) { && !useableAbilities.isEmpty()) {
prepareForResponse(game);
if (!isExecutingMacro()) { if (!isExecutingMacro()) {
game.fireGetChoiceEvent(playerId, name, object, new ArrayList<>(useableAbilities.values())); game.fireGetChoiceEvent(playerId, name, object, new ArrayList<>(useableAbilities.values()));
} }
@ -1631,6 +1682,7 @@ public class HumanPlayer extends PlayerImpl {
if (!modeMap.isEmpty()) { if (!modeMap.isEmpty()) {
boolean done = false; boolean done = false;
while (!done) { while (!done) {
prepareForResponse(game);
if (!isExecutingMacro()) { if (!isExecutingMacro()) {
game.fireGetModeEvent(playerId, "Choose Mode", modeMap); game.fireGetModeEvent(playerId, "Choose Mode", modeMap);
} }
@ -1660,6 +1712,7 @@ public class HumanPlayer extends PlayerImpl {
public boolean choosePile(Outcome outcome, String message, List<? extends Card> pile1, List<? extends Card> pile2, Game game) { public boolean choosePile(Outcome outcome, String message, List<? extends Card> pile1, List<? extends Card> pile2, Game game) {
updateGameStatePriority("choosePile", game); updateGameStatePriority("choosePile", game);
do { do {
prepareForResponse(game);
if (!isExecutingMacro()) { if (!isExecutingMacro()) {
game.fireChoosePileEvent(playerId, message, pile1, pile2); game.fireChoosePileEvent(playerId, message, pile1, pile2);
} }
@ -1673,6 +1726,7 @@ public class HumanPlayer extends PlayerImpl {
@Override @Override
public void setResponseString(String responseString) { public void setResponseString(String responseString) {
waitResponseOpen();
synchronized (response) { synchronized (response) {
response.setString(responseString); response.setString(responseString);
response.notifyAll(); response.notifyAll();
@ -1682,6 +1736,7 @@ public class HumanPlayer extends PlayerImpl {
@Override @Override
public void setResponseManaType(UUID manaTypePlayerId, ManaType manaType) { public void setResponseManaType(UUID manaTypePlayerId, ManaType manaType) {
waitResponseOpen();
synchronized (response) { synchronized (response) {
response.setManaType(manaType); response.setManaType(manaType);
response.setResponseManaTypePlayerId(manaTypePlayerId); response.setResponseManaTypePlayerId(manaTypePlayerId);
@ -1692,6 +1747,7 @@ public class HumanPlayer extends PlayerImpl {
@Override @Override
public void setResponseUUID(UUID responseUUID) { public void setResponseUUID(UUID responseUUID) {
waitResponseOpen();
synchronized (response) { synchronized (response) {
response.setUUID(responseUUID); response.setUUID(responseUUID);
response.notifyAll(); response.notifyAll();
@ -1701,15 +1757,17 @@ public class HumanPlayer extends PlayerImpl {
@Override @Override
public void setResponseBoolean(Boolean responseBoolean) { public void setResponseBoolean(Boolean responseBoolean) {
waitResponseOpen();
synchronized (response) { synchronized (response) {
response.setBoolean(responseBoolean); response.setBoolean(responseBoolean);
response.notifyAll(); response.notifyAll();
logger.debug("Got response boolean from player: " + getId()); logger.info("Got response boolean from player: " + getId());
} }
} }
@Override @Override
public void setResponseInteger(Integer responseInteger) { public void setResponseInteger(Integer responseInteger) {
waitResponseOpen();
synchronized (response) { synchronized (response) {
response.setInteger(responseInteger); response.setInteger(responseInteger);
response.notifyAll(); response.notifyAll();
@ -1720,6 +1778,7 @@ public class HumanPlayer extends PlayerImpl {
@Override @Override
public void abort() { public void abort() {
abort = true; abort = true;
waitResponseOpen();
synchronized (response) { synchronized (response) {
response.notifyAll(); response.notifyAll();
logger.debug("Got cancel action from player: " + getId()); logger.debug("Got cancel action from player: " + getId());
@ -1728,6 +1787,7 @@ public class HumanPlayer extends PlayerImpl {
@Override @Override
public void signalPlayerConcede() { public void signalPlayerConcede() {
waitResponseOpen();
synchronized (response) { synchronized (response) {
response.setResponseConcedeCheck(); response.setResponseConcedeCheck();
response.notifyAll(); response.notifyAll();
@ -1737,6 +1797,7 @@ public class HumanPlayer extends PlayerImpl {
@Override @Override
public void skip() { public void skip() {
waitResponseOpen();
synchronized (response) { synchronized (response) {
response.setInteger(0); response.setInteger(0);
response.notifyAll(); response.notifyAll();

150
Mage.Tests/src/test/java/org/mage/test/load/LoadCallbackClient.java
View file

@ -1,28 +1,32 @@
package org.mage.test.load; package org.mage.test.load;
import mage.constants.PhaseStep;
import mage.constants.PlayerAction;
import mage.interfaces.callback.CallbackClient; import mage.interfaces.callback.CallbackClient;
import mage.interfaces.callback.ClientCallback; import mage.interfaces.callback.ClientCallback;
import mage.remote.Session; import mage.remote.Session;
import mage.util.RandomUtil;
import mage.utils.CompressUtil; import mage.utils.CompressUtil;
import mage.view.GameClientMessage; import mage.view.*;
import mage.view.GameView;
import mage.view.SimpleCardView;
import mage.view.TableClientMessage;
import org.apache.log4j.Logger; import org.apache.log4j.Logger;
import java.util.Random;
import java.util.UUID; import java.util.UUID;
/** /**
* @author noxx * @author JayDi85
*/ */
public class LoadCallbackClient implements CallbackClient { public class LoadCallbackClient implements CallbackClient {
private static final Logger log = Logger.getLogger(LoadCallbackClient.class); //private static final Logger log = Logger.getLogger(LoadCallbackClient.class);
private static final Logger log = Logger.getLogger("Load call");
private Session session; private Session session;
private UUID gameId; private UUID gameId;
private UUID playerId; private UUID playerId;
private boolean gameOver; private boolean gameOver;
private String gameResult = "unknown";
private boolean needToConcede = false; // will concede on first priority
private volatile int controlCount; private volatile int controlCount;
@ -32,63 +36,152 @@ public class LoadCallbackClient implements CallbackClient {
public void processCallback(ClientCallback callback) { public void processCallback(ClientCallback callback) {
//TODO //TODO
controlCount = 0; controlCount = 0;
log.info(callback.getMethod());
callback.setData(CompressUtil.decompress(callback.getData())); callback.setData(CompressUtil.decompress(callback.getData()));
/*
// random sleep can help with freezes (server concurrent access problem?!)
try {
Thread.sleep(RandomUtil.nextInt(1000));
}catch (InterruptedException e) {
log.error("thread error", e);
}
*/
log.info(callback.getMethod());
log.info(getLogStartInfo() + "callback: " + callback.getMethod());
switch (callback.getMethod()) { switch (callback.getMethod()) {
case START_GAME: { case START_GAME: {
TableClientMessage message = (TableClientMessage) callback.getData(); TableClientMessage message = (TableClientMessage) callback.getData();
log.info(getLogStartInfo() + "game started");
gameId = message.getGameId(); gameId = message.getGameId();
playerId = message.getPlayerId(); playerId = message.getPlayerId();
session.joinGame(message.getGameId()); session.joinGame(message.getGameId());
startControlThread(); startControlThread();
break; break;
} }
case GAME_INFORM: {
case GAME_INFORM:
case GAME_INFORM_PERSONAL: {
GameClientMessage message = (GameClientMessage) callback.getData(); GameClientMessage message = (GameClientMessage) callback.getData();
log.info("Inform: " + message.getMessage());
gameView = message.getGameView(); gameView = message.getGameView();
log.info(getLogStartInfo() + "Inform: " + message.getMessage());
break; break;
} }
case GAME_INIT:
break;
case GAME_TARGET: { case GAME_TARGET: {
GameClientMessage message = (GameClientMessage) callback.getData(); GameClientMessage message = (GameClientMessage) callback.getData();
this.gameView = message.getGameView();
log.info("Target: " + message.getMessage()); log.info("Target: " + message.getMessage());
switch (message.getMessage()) { switch (message.getMessage()) {
case "Select a starting player": case "Select a starting player":
session.sendPlayerUUID(gameId, playerId); session.sendPlayerUUID(gameId, playerId);
break; return;
//break;
case "Select a card to discard": case "Select a card to discard":
log.info("hand size: " + gameView.getHand().size()); log.info(getLogStartInfo() + "hand size: " + gameView.getHand().size());
SimpleCardView card = gameView.getHand().values().iterator().next(); SimpleCardView card = gameView.getHand().values().iterator().next();
session.sendPlayerUUID(gameId, card.getId()); session.sendPlayerUUID(gameId, card.getId());
break; return;
//break;
default:
log.error(getLogStartInfo() + "unknown GAME_TARGET message: " + message.toString());
} }
break; break;
} }
case GAME_ASK: { case GAME_ASK: {
GameClientMessage message = (GameClientMessage) callback.getData(); GameClientMessage message = (GameClientMessage) callback.getData();
log.info("Ask: " + message.getMessage()); log.info(getLogStartInfo() + "Ask: " + message.getMessage());
if (message.getMessage().equals("Do you want to take a mulligan?")) { if (message.getMessage().startsWith("Mulligan")) {
session.sendPlayerBoolean(gameId, false); session.sendPlayerBoolean(gameId, false);
return;
} else {
log.error(getLogStartInfo() + "unknown GAME_ASK message: " + message.toString());
} }
break; break;
} }
case GAME_SELECT: { case GAME_SELECT: {
GameClientMessage message = (GameClientMessage) callback.getData(); GameClientMessage message = (GameClientMessage) callback.getData();
log.info("Select: " + message.getMessage()); log.info("Select: " + message.getMessage());
if (LoadPhaseManager.getInstance().isSkip(message.getGameView(), message.getMessage(), playerId)) { this.gameView = message.getGameView();
log.info("Skipped: " + message.getMessage());
session.sendPlayerBoolean(gameId, false); // concede
if (needToConcede) {
log.info(getLogStartInfo() + "game conceded");
needToConcede = false;
session.sendPlayerAction(PlayerAction.CONCEDE, gameId, null);
return;
} }
break;
// end priority step
session.sendPlayerBoolean(gameId, false);
return;
/*
if (LoadPhaseManager.getInstance().isSkip(message.getGameView(), message.getMessage(), playerId)) {
log.info(getLogStartInfo() + "Skipped: " + message.getMessage());
session.sendPlayerBoolean(gameId, false);
} else {
log.error(getLogStartInfo() + "unknown GAME_SELECT or skips message: " + message.toString());
}
*/
//break;
} }
case GAME_OVER: case GAME_OVER:
log.info("Game over"); log.info(getLogStartInfo() + "Game over");
gameOver = true; gameOver = true;
break; break;
case END_GAME_INFO:
GameEndView message = (GameEndView) callback.getData();
this.gameResult = message.hasWon() ? "win" : "lose";
log.info(getLogStartInfo() + "Game end info, " + this.gameResult);
break;
// skip callbacks (no need to react)
case GAME_INIT:
case GAME_UPDATE:
case CHATMESSAGE:
case JOINED_TABLE:
break;
default:
log.error(getLogStartInfo() + "Unknown callback: " + callback.getMethod() + ", " + callback.getData().toString());
session.sendPlayerBoolean(gameId, false);
return;
//break;
}
}
private PlayerView getPlayer() {
if ((this.gameView != null) && (this.playerId != null)) {
for (PlayerView p: this.gameView.getPlayers()) {
if (p.getPlayerId().equals(this.playerId)) {
return p;
}
}
}
return null;
}
private String getLogStartInfo() {
String mes = "";
//throw new IllegalArgumentException("test exception");
if (this.session != null) {
mes += session.getUserName() + ": ";
} }
PlayerView p = getPlayer();
if (this.gameView != null && p != null && this.gameView.getStep() != null) {
mes += "T" + this.gameView.getTurn() + "-" + this.gameView.getStep().getIndex() + ", L:" + p.getLibraryCount() + ", H:" + getPlayer().getHandCount() + ": ";
}
return mes;
} }
public void setSession(Session session) { public void setSession(Session session) {
@ -108,8 +201,13 @@ public class LoadCallbackClient implements CallbackClient {
} catch (InterruptedException e) { } catch (InterruptedException e) {
e.printStackTrace(); e.printStackTrace();
} }
if(isGameOver()) {
return;
}
if (controlCount > 5) { if (controlCount > 5) {
log.warn("Game seems freezed. Sending boolean message to server."); log.warn(getLogStartInfo() + "Game seems freezed. Sending boolean message to server.");
session.sendPlayerBoolean(gameId, false); session.sendPlayerBoolean(gameId, false);
controlCount = 0; controlCount = 0;
} }
@ -117,4 +215,12 @@ public class LoadCallbackClient implements CallbackClient {
}).start(); }).start();
} }
public void setConcede(boolean needToConcede) {
this.needToConcede = needToConcede;
}
public String getLastGameResult() {
return this.gameResult;
}
} }

70
Mage.Tests/src/test/java/org/mage/test/load/LoadPhaseManager.java
View file

@ -1,13 +1,16 @@
package org.mage.test.load; package org.mage.test.load;
import mage.constants.PhaseStep;
import mage.view.GameView; import mage.view.GameView;
import mage.view.PlayerView; import mage.view.PlayerView;
import org.apache.log4j.Logger;
import java.util.HashMap; import java.util.HashMap;
import java.util.Map; import java.util.Map;
import java.util.UUID; import java.util.UUID;
public class LoadPhaseManager { public class LoadPhaseManager {
private static final Logger log = Logger.getLogger("Load phase");
private static final LoadPhaseManager instance = new LoadPhaseManager(); private static final LoadPhaseManager instance = new LoadPhaseManager();
@ -31,52 +34,63 @@ public class LoadPhaseManager {
public static String MAIN_2_OTHERS = "main2Others"; public static String MAIN_2_OTHERS = "main2Others";
public static String END_OF_TURN_OTHERS = "endOfTurnOthers"; public static String END_OF_TURN_OTHERS = "endOfTurnOthers";
private static Map<String, String> mapYou = new HashMap<String, String>() {{ private static Map<PhaseStep, Boolean> skipYou;
put("Upkeep - play instants and activated abilities.", UPKEEP_YOU); static {
put("Draw - play instants and activated abilities.", DRAW_YOU); skipYou = new HashMap() {{
put("Precombat Main - play spells and abilities.", MAIN_YOU); put(PhaseStep.UPKEEP, true);
put("Begin Combat - play instants and activated abilities.", BEFORE_COMBAT_YOU); put(PhaseStep.PRECOMBAT_MAIN, true);
put("End Combat - play instants and activated abilities.", END_OF_COMBAT_YOU); put(PhaseStep.BEGIN_COMBAT, true);
put("Postcombat Main - play spells and abilities.", MAIN_2_YOU); put(PhaseStep.DECLARE_ATTACKERS, true);
put("End Turn - play instants and activated abilities.", END_OF_TURN_YOU); put(PhaseStep.DECLARE_BLOCKERS, true);
}}; put(PhaseStep.END_COMBAT, true);
put(PhaseStep.POSTCOMBAT_MAIN, true);
put(PhaseStep.END_TURN, true);
}};
}
private static Map<String, String> mapOthers = new HashMap<String, String>() {{ private static Map<PhaseStep, Boolean> skipOthers;
put("Upkeep - play instants and activated abilities.", UPKEEP_OTHERS); static {
put("Draw - play instants and activated abilities.", DRAW_OTHERS); skipYou = new HashMap() {{
put("Precombat Main - play instants and activated abilities.", MAIN_OTHERS); put(PhaseStep.UPKEEP, true);
put("Begin Combat - play instants and activated abilities.", BEFORE_COMBAT_OTHERS); put(PhaseStep.PRECOMBAT_MAIN, true);
put("End Combat - play instants and activated abilities.", END_OF_COMBAT_OTHERS); put(PhaseStep.BEGIN_COMBAT, true);
put("Postcombat Main - play instants and activated abilities.", MAIN_2_OTHERS); put(PhaseStep.DECLARE_ATTACKERS, true);
put("End Turn - play instants and activated abilities.", END_OF_TURN_OTHERS); put(PhaseStep.DECLARE_BLOCKERS, true);
}}; put(PhaseStep.END_COMBAT, true);
put(PhaseStep.POSTCOMBAT_MAIN, true);
put(PhaseStep.END_TURN, true);
}};
}
public static LoadPhaseManager getInstance() { public static LoadPhaseManager getInstance() {
return instance; return instance;
} }
public boolean isSkip(GameView gameView, String message, UUID playerId) { public boolean isSkip(GameView gameView, String message, UUID playerId) {
// skip callbacks
UUID activePlayer = null; UUID activePlayer = null;
Map<String, String> map = mapOthers; Map<PhaseStep, Boolean> map = skipOthers;
for (PlayerView playerView : gameView.getPlayers()) { for (PlayerView playerView : gameView.getPlayers()) {
if (playerView.isActive()) { if (playerView.isActive()) {
activePlayer = playerView.getPlayerId(); activePlayer = playerView.getPlayerId();
if (activePlayer.equals(playerId)) { if (activePlayer.equals(playerId)) {
map = mapYou; map = skipYou;
} }
} }
} }
if (activePlayer == null) { if (activePlayer == null) {
throw new IllegalStateException("No active player found."); throw new IllegalStateException("No active player found.");
} }
for (Map.Entry<String, String> entry : map.entrySet()) {
if (message.equals(entry.getKey())) { // PROCCESS
/*if (message.equals("Precombat Main - play spells and abilities.")) {
return false; if(map.containsKey(gameView.getStep())){
}*/ return map.get(gameView.getStep());
return true; } else {
} log.error("Unknown phase manager step: " + gameView.getStep().toString());
return false;
} }
return false;
} }
} }

707
Mage.Tests/src/test/java/org/mage/test/load/LoadTest.java
View file

@ -7,26 +7,24 @@ import mage.cards.decks.DeckCardInfo;
import mage.cards.decks.DeckCardLists; import mage.cards.decks.DeckCardLists;
import mage.cards.repository.CardInfo; import mage.cards.repository.CardInfo;
import mage.cards.repository.CardRepository; import mage.cards.repository.CardRepository;
import mage.constants.ColoredManaSymbol; import mage.constants.*;
import mage.constants.MatchTimeLimit;
import mage.constants.MultiplayerAttackOption;
import mage.constants.RangeOfInfluence;
import mage.game.match.MatchOptions; import mage.game.match.MatchOptions;
import mage.player.ai.ComputerPlayer; import mage.player.ai.ComputerPlayer;
import mage.players.PlayerType; import mage.players.PlayerType;
import mage.remote.Connection; import mage.remote.Connection;
import mage.remote.MageRemoteException;
import mage.remote.Session; import mage.remote.Session;
import mage.remote.SessionImpl; import mage.remote.SessionImpl;
import mage.view.GameTypeView; import mage.util.RandomUtil;
import mage.view.TableView; import mage.view.*;
import org.apache.log4j.Logger; import org.apache.log4j.Logger;
import org.junit.Assert; import org.junit.Assert;
import org.junit.Ignore; import org.junit.Ignore;
import org.junit.Test; import org.junit.Test;
import java.util.ArrayList; import java.time.Instant;
import java.util.List; import java.time.temporal.ChronoUnit;
import java.util.UUID; import java.util.*;
/** /**
* Intended to test Mage server under different load patterns. * Intended to test Mage server under different load patterns.
@ -36,236 +34,296 @@ import java.util.UUID;
* *
* Then it's also better to use -Xms256M -Xmx512M JVM options for these stests. * Then it's also better to use -Xms256M -Xmx512M JVM options for these stests.
* *
* @author noxx * @author JayDi85
*/ */
public class LoadTest { public class LoadTest {
/** private static final Logger logger = Logger.getLogger(LoadTest.class);
* Logger for tests
*/
private static final Logger log = Logger.getLogger(LoadTest.class);
/**
* First player's username
*/
private static final String TEST_USER_NAME = "player";
/**
* Second player's username
*/
private static final String TEST_USER_NAME_2 = "opponent";
/**
* Server connection setting.
*/
private static final String TEST_SERVER = "localhost"; private static final String TEST_SERVER = "localhost";
/**
* Server connection setting.
*/
private static final int TEST_PORT = 17171; private static final int TEST_PORT = 17171;
/**
* Server connection setting.
*/
private static final String TEST_PROXY_TYPE = "None"; private static final String TEST_PROXY_TYPE = "None";
private static final String TEST_USER_NAME = "user";
/** @Test
* Determines how many times test will be executed in a row. public void test_CreateRandomDeck() {
*/
private static final int EXECUTION_COUNT = 100;
/** Deck deck;
* Determines how many times test will be executed in a row.
*/ deck = generateRandomDeck("G", false);
private static final int EXECUTION_COUNT_PLAY_GAME = 100; for(Card card : deck.getCards()) {
Assert.assertTrue("card " + card.getName() + " color " + card.getColorIdentity().toString() + " must be in G",
card.getColorIdentity().isGreen());
}
deck = generateRandomDeck("U", false);
for(Card card : deck.getCards()) {
Assert.assertTrue("card " + card.getName() + " color " + card.getColorIdentity().toString() + " must be in U",
card.getColorIdentity().isBlue());
}
deck = generateRandomDeck("BR", false);
for(Card card : deck.getCards()) {
Assert.assertTrue("card " + card.getName() + " color " + card.getColorIdentity().toString() + " must be in BR",
card.getColorIdentity().isBlack() || card.getColorIdentity().isRed());
}
deck = generateRandomDeck("BUG", false);
for(Card card : deck.getCards()) {
Assert.assertTrue("card " + card.getName() + " color " + card.getColorIdentity().toString() + " must be in BUG",
card.getColorIdentity().isBlack() || card.getColorIdentity().isBlue() || card.getColorIdentity().isGreen());
}
// lands
deck = generateRandomDeck("UR", true);
for(Card card : deck.getCards()) {
Assert.assertTrue("card " + card.getName() + " color " + card.getColorIdentity().toString() + " must be in UR",
card.getColorIdentity().isBlue() || card.getColorIdentity().isRed());
Assert.assertEquals("card " + card.getName() + " must be basic land ", Rarity.LAND, card.getRarity());
}
deck = generateRandomDeck("B", true);
for(Card card : deck.getCards()) {
Assert.assertTrue("card " + card.getName() + " color " + card.getColorIdentity().toString() + " must be in B", card.getColorIdentity().isBlack());
Assert.assertEquals("card " + card.getName() + " must be basic land ", Rarity.LAND, card.getRarity());
}
}
/**
* Tests connecting with two players, creating game and starting it.
*
* Executes the test EXECUTION_COUNT times.
*
* @throws Exception
*/
@Test @Test
@Ignore @Ignore
public void testStartGame() throws Exception { public void test_UsersConnectToServer() throws Exception {
DeckCardLists deckList = createDeck();
for (int i = 0; i < EXECUTION_COUNT; i++) { // simple connection to server
Connection connection = createConnection(TEST_USER_NAME + i);
SimpleMageClient mageClient = new SimpleMageClient(); // monitor other players
Session session = new SessionImpl(mageClient); LoadPlayer monitor = new LoadPlayer("monitor");
Assert.assertTrue(monitor.session.isConnected());
int startUsersCount = monitor.getAllRoomUsers().size();
int minimumSleepTime = 2000;
session.connect(connection); // user 1
UUID roomId = session.getMainRoomId(); LoadPlayer player1 = new LoadPlayer("1");
Thread.sleep(minimumSleepTime);
Assert.assertEquals("Can't see users count change 1", startUsersCount + 1, monitor.getAllRoomUsers().size());
Assert.assertNotNull("Can't find user 1", monitor.findUser(player1.userName));
GameTypeView gameTypeView = session.getGameTypes().get(0); // user 2
log.info("Game type view: " + gameTypeView.getName()); LoadPlayer player2 = new LoadPlayer("2");
MatchOptions options = createGameOptions(gameTypeView, session); Thread.sleep(minimumSleepTime);
Assert.assertEquals("Can't see users count change 2", startUsersCount + 2, monitor.getAllRoomUsers().size());
Assert.assertNotNull("Can't find user 2", monitor.findUser(player2.userName));
}
TableView table = session.createTable(roomId, options); @Test
@Ignore
public void test_TwoUsersPlayGameUntilEnd() {
// simple connection to server test
if (!session.joinTable(roomId, table.getTableId(), TEST_USER_NAME + i, PlayerType.HUMAN, 1, deckList,"")) { // monitor other players
log.error("Error while joining table"); LoadPlayer monitor = new LoadPlayer("monitor");
Assert.fail("Error while joining table");
return; // users
LoadPlayer player1 = new LoadPlayer("1");
LoadPlayer player2 = new LoadPlayer("2");
// game by user 1
GameTypeView gameType = player1.session.getGameTypes().get(0);
MatchOptions gameOptions = createSimpleGameOptions(gameType, player1.session);
TableView game = player1.session.createTable(player1.roomID, gameOptions);
UUID tableId = game.getTableId();
Assert.assertEquals(player1.userName, game.getControllerName());
DeckCardLists deckList = createSimpleDeck("GR", true);
Optional<TableView> checkGame;
/*
for(DeckCardInfo info: deckList.getCards()) {
logger.info(info.getCardName());
}*/
// before connect
checkGame = monitor.getTable(tableId);
Assert.assertTrue(checkGame.isPresent());
Assert.assertEquals(2, checkGame.get().getSeats().size());
Assert.assertEquals("", checkGame.get().getSeats().get(0).getPlayerName());
Assert.assertEquals("", checkGame.get().getSeats().get(1).getPlayerName());
// connect user 1
Assert.assertTrue(player1.session.joinTable(player1.roomID, tableId, player1.userName, PlayerType.HUMAN, 1, deckList, ""));
checkGame = monitor.getTable(tableId);
Assert.assertTrue(checkGame.isPresent());
Assert.assertEquals(2, checkGame.get().getSeats().size());
Assert.assertEquals(player1.userName, checkGame.get().getSeats().get(0).getPlayerName());
Assert.assertEquals("", checkGame.get().getSeats().get(1).getPlayerName());
// connect user 2
Assert.assertTrue(player2.session.joinTable(player2.roomID, tableId, player2.userName, PlayerType.HUMAN, 1, deckList, ""));
checkGame = monitor.getTable(tableId);
Assert.assertTrue(checkGame.isPresent());
Assert.assertEquals(2, checkGame.get().getSeats().size());
Assert.assertEquals(player1.userName, checkGame.get().getSeats().get(0).getPlayerName());
Assert.assertEquals(player2.userName, checkGame.get().getSeats().get(1).getPlayerName());
// match start
Assert.assertTrue(player1.session.startMatch(player1.roomID, tableId));
// playing until game over
while(!player1.client.isGameOver() && !player2.client.isGameOver()) {
checkGame = monitor.getTable(tableId);
logger.warn(checkGame.get().getTableState());
try {
Thread.sleep(1000);
} catch (InterruptedException e){
logger.error(e.getMessage(), e);
}
}
}
@Test
@Ignore
public void test_GameThread() {
// simple game thread to the end
LoadGame game = new LoadGame(
"game",
"thread",
createSimpleDeck("GR", true),
createSimpleDeck("GR", true)
);
game.gameStart();
while (game.isPlaying()) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
logger.error(e.getMessage(), e);
}
}
Assert.assertEquals("finished", game.gameResult);
}
@Test
@Ignore
public void test_GameThreadWithAbort() {
// simple game thread with game abort
LoadGame game = new LoadGame(
"game",
"thread",
createSimpleDeck("GR", true),
createSimpleDeck("GR", true)
);
game.gameStart();
game.gameEnd(true); // abort -- close client thread
Assert.assertEquals("aborted", game.gameResult);
}
@Test
@Ignore
public void test_GameThreadWithConcede() {
// simple game thread with game abort
LoadGame game = new LoadGame(
"game",
"thread",
createSimpleDeck("GR", true),
createSimpleDeck("GR", true)
);
game.gameStart();
try {
Thread.sleep(3000);
} catch (Throwable e) {
//
}
game.gameConcede(1);
game.gameWaitToStop();
Assert.assertEquals("finished", game.gameResult);
Assert.assertEquals("lose", game.player1.lastGameResult);
Assert.assertEquals("win", game.player2.lastGameResult);
}
@Test
@Ignore
public void test_MultipleGames() {
// multiple games until finish
Instant startTime = Instant.now();
int MAX_GAMES = 30;
// creating
logger.info("creating games...");
ArrayList<LoadGame> gamesList = new ArrayList<>();
for(int i = 1; i <= MAX_GAMES; i++) {
gamesList.add(new LoadGame(
"game" + i,
"game" + i,
createSimpleDeck("GR", true),
createSimpleDeck("GR", true)
));
}
logger.info("created " + gamesList.size() + " games");
// running
for(LoadGame game: gamesList) {
game.gameStart();
}
logger.info("run " + gamesList.size() + " games");
// waiting
while (true) {
boolean isComplete = true;
for(LoadGame game: gamesList) {
isComplete = isComplete && !game.isPlaying();
} }
/*** Connect with a second player ***/ if(isComplete) {
Connection connection2 = createConnection(TEST_USER_NAME_2 + i); break;
SimpleMageClient mageClient2 = new SimpleMageClient();
Session session2 = new SessionImpl(mageClient2);
session2.connect(connection2);
UUID roomId2 = session2.getMainRoomId();
// connect to the table with the same deck
if (!session2.joinTable(roomId2, table.getTableId(), TEST_USER_NAME_2 + i, PlayerType.HUMAN, 1, deckList,"")) {
log.error("Error while joining table");
Assert.fail("Error while joining table");
return;
} }
/*** Start game ***/ try {
session.startMatch(roomId, table.getTableId()); Thread.sleep(1000);
} catch (InterruptedException e) {
logger.error(e.getMessage(), e);
}
}
logger.info("completed " + gamesList.size() + " games");
Thread.sleep(100); Instant endTime = Instant.now();
logger.info("total time: " + ChronoUnit.SECONDS.between(startTime, endTime) + " secs");
// check statuses
ArrayList<String> errors = new ArrayList<>();
for(LoadGame game: gamesList) {
if (!"finished".equals(game.gameResult)) {
errors.add(game.gameName + ": not finished, got " + game.gameResult);
}
}
if (errors.size() > 0) {
System.out.println("Not all games finished, founded " + errors.size() + " errors: ");
for (String s: errors) {
System.out.println(s);
}
Assert.fail("Not all games finished");
} }
} }
/** private Connection createSimpleConnection(String username) {
* Tests 10 simple games played one after another. Connection con = new Connection();
*/ con.setUsername(username);
@Test con.setHost(TEST_SERVER);
@Ignore con.setPort(TEST_PORT);
public void testSimpleGame() throws Exception {
final DeckCardLists deckList = createDeck();
for (int i = 0; i < EXECUTION_COUNT_PLAY_GAME; i++) {
final int j = i;
Thread t = new Thread(() -> {
try {
testSimpleGame0(deckList, j);
} catch (InterruptedException e) {
e.printStackTrace();
}
});
t.start();
t.join();
}
}
/**
* Tests simple game till the end (game over).
* Players do nothing but skip phases and discard cards at the end.
*
* This results in a game that lasts until there is no cards in library.
*/
private boolean testSimpleGame0(DeckCardLists deckList, int i) throws InterruptedException {
Connection connection = createConnection(TEST_USER_NAME + i);
SimpleMageClient mageClient = new SimpleMageClient();
Session session = new SessionImpl(mageClient);
session.connect(connection);
mageClient.setSession(session);
UUID roomId = session.getMainRoomId();
GameTypeView gameTypeView = session.getGameTypes().get(0);
log.info("Game type view: " + gameTypeView.getName());
MatchOptions options = createGameOptions(gameTypeView, session);
TableView table = session.createTable(roomId, options);
if (!session.joinTable(roomId, table.getTableId(), TEST_USER_NAME + i, PlayerType.HUMAN, 1, deckList,"")) {
log.error("Error while joining table");
Assert.fail("Error while joining table");
return true;
}
/*** Connect with a second player ***/
Connection connection2 = createConnection(TEST_USER_NAME_2 + i);
SimpleMageClient mageClient2 = new SimpleMageClient();
Session session2 = new SessionImpl(mageClient2);
session2.connect(connection2);
mageClient2.setSession(session2);
UUID roomId2 = session2.getMainRoomId();
// connect to the table with the same deck
if (!session2.joinTable(roomId2, table.getTableId(), TEST_USER_NAME_2 + i, PlayerType.HUMAN, 1, deckList,"")) {
log.error("Error while joining table");
Assert.fail("Error while joining table");
return true;
}
/*** Start game ***/
session.startMatch(roomId, table.getTableId());
while (!mageClient.isGameOver()) {
Thread.sleep(1000);
}
return false;
}
/**
* Tests playing the whole game.
* Player use cheat to add lands, creatures and other cards.
* Then play only lands, one of them plays 1 damage targeting player.
*
* This results in 40 turns of the game.
*/
@Test
@Ignore
public void testPlayGame() throws Exception {
//TODO: to be implemented
}
/**
* Creates connection to the server.
* Server should run independently.
*
* @param username
* @return
*/
private Connection createConnection(String username) {
Connection connection = new Connection();
connection.setUsername(username);
connection.setHost(TEST_SERVER);
connection.setPort(TEST_PORT);
Connection.ProxyType proxyType = Connection.ProxyType.valueByText(TEST_PROXY_TYPE); Connection.ProxyType proxyType = Connection.ProxyType.valueByText(TEST_PROXY_TYPE);
connection.setProxyType(proxyType); con.setProxyType(proxyType);
return connection; return con;
} }
/** private MatchOptions createSimpleGameOptions(GameTypeView gameTypeView, Session session) {
* Returns random deck.
* Converts deck returned by {@link #generateRandomDeck} method to {@link DeckCardLists} format.
*
* @return
*/
private DeckCardLists createDeck() {
DeckCardLists deckList = new DeckCardLists();
Deck deck = generateRandomDeck();
for (Card card : deck.getCards()) {
CardInfo cardInfo = CardRepository.instance.findCard(card.getExpansionSetCode(), card.getCardNumber());
if (cardInfo != null) {
deckList.getCards().add(new DeckCardInfo(cardInfo.getName(), cardInfo.getCardNumber(), cardInfo.getSetCode()));
}
}
return deckList;
}
/**
* Creates game options with two human players.
*
* @param gameTypeView
* @param session
* @return
*/
private MatchOptions createGameOptions(GameTypeView gameTypeView, Session session) {
MatchOptions options = new MatchOptions("Test game", gameTypeView.getName(), false, 2); MatchOptions options = new MatchOptions("Test game", gameTypeView.getName(), false, 2);
options.getPlayerTypes().add(PlayerType.HUMAN); options.getPlayerTypes().add(PlayerType.HUMAN);
@ -280,21 +338,224 @@ public class LoadTest {
return options; return options;
} }
/** private Deck generateRandomDeck(String colors, boolean onlyBasicLands) {
* Generates random deck in {@link Deck} format. logger.info("Building " + (onlyBasicLands ? "only lands" : "random") + " deck with colors: " + colors);
* Uses {B}{R} as deck colors.
*
* @return
*/
private Deck generateRandomDeck() {
String selectedColors = "BR";
List<ColoredManaSymbol> allowedColors = new ArrayList<>(); List<ColoredManaSymbol> allowedColors = new ArrayList<>();
log.info("Building deck with colors: " + selectedColors); for (int i = 0; i < colors.length(); i++) {
for (int i = 0; i < selectedColors.length(); i++) { char c = colors.charAt(i);
char c = selectedColors.charAt(i);
allowedColors.add(ColoredManaSymbol.lookup(c)); allowedColors.add(ColoredManaSymbol.lookup(c));
} }
List<Card> cardPool = Sets.generateRandomCardPool(45, allowedColors); List<Card> cardPool = Sets.generateRandomCardPool(45, allowedColors, onlyBasicLands);
return ComputerPlayer.buildDeck(cardPool, allowedColors); return ComputerPlayer.buildDeck(cardPool, allowedColors, onlyBasicLands);
}
private DeckCardLists createSimpleDeck(String colors, boolean onlyBasicLands) {
Deck deck = generateRandomDeck(colors, onlyBasicLands);
DeckCardLists deckList = new DeckCardLists();
for (Card card : deck.getCards()) {
CardInfo cardInfo = CardRepository.instance.findCard(card.getExpansionSetCode(), card.getCardNumber());
if (cardInfo != null) {
deckList.getCards().add(new DeckCardInfo(cardInfo.getName(), cardInfo.getCardNumber(), cardInfo.getSetCode()));
}
}
return deckList;
}
private class LoadPlayer {
String userName;
Connection connection;
SimpleMageClient client;
Session session;
UUID roomID;
UUID createdTableID;
UUID connectedTableID;
DeckCardLists deckList;
String lastGameResult = "";
public LoadPlayer(String userPrefix) {
this.userName = TEST_USER_NAME + "_" + userPrefix + "_" + RandomUtil.nextInt(10000);
this.connection = createSimpleConnection(this.userName);
this.client = new SimpleMageClient();
this.session = new SessionImpl(this.client);
this.session.connect(this.connection);
this.client.setSession(this.session);
this.roomID = this.session.getMainRoomId();
}
public ArrayList<UsersView> getAllRoomUsers() {
ArrayList<UsersView> res = new ArrayList<>();
try {
for (RoomUsersView roomUsers : this.session.getRoomUsers(this.roomID)) {
res.addAll(roomUsers.getUsersView());
}
} catch (MageRemoteException e)
{
logger.error(e);
}
return res;
}
public UsersView findUser(String userName) {
for (UsersView user: this.getAllRoomUsers()) {
if (user.getUserName().equals(userName)) {
return user;
}
}
return null;
}
public Optional<TableView> getTable(UUID tableID) {
return this.session.getTable(this.roomID, tableID);
}
public UUID createNewTable() {
GameTypeView gameType = this.session.getGameTypes().get(0);
MatchOptions gameOptions = createSimpleGameOptions(gameType, this.session);
TableView game = this.session.createTable(this.roomID, gameOptions);
this.createdTableID = game.getTableId();
Assert.assertEquals(this.userName, game.getControllerName());
connectToTable(this.createdTableID);
return this.createdTableID;
}
public void connectToTable(UUID tableID) {
Assert.assertTrue(this.session.joinTable(this.roomID, tableID, this.userName, PlayerType.HUMAN, 1, this.deckList, ""));
this.connectedTableID = tableID;
}
public void startMatch() {
Assert.assertNotNull(this.createdTableID);
Assert.assertTrue(this.session.startMatch(this.roomID, this.createdTableID));
}
public void setDeckList(DeckCardLists deckList) {
this.deckList = deckList;
}
public void disconnect() {
this.session.disconnect(false);
}
public void concede() {
this.client.setConcede(true);
}
}
private class LoadGame {
String gameName = null;
Thread runningThread = null;
LoadPlayer player1 = null;
LoadPlayer player2 = null;
Boolean abort = false;
UUID tableID = null;
String gameResult = null;
public LoadGame(String gameName, String playerPrefix) {
this(gameName, playerPrefix,
createSimpleDeck("GR", true),
createSimpleDeck("GR", true)
);
}
public LoadGame(String gameName, String playerPrefix, DeckCardLists deck1, DeckCardLists deck2) {
this.gameName = gameName;
player1 = new LoadPlayer(playerPrefix + "_" + 1);
player1.setDeckList(deck1);
player2 = new LoadPlayer(playerPrefix + "_" + 2);
player2.setDeckList(deck2);
}
public void gameStart() {
this.abort = false;
runningThread = new Thread(() -> {
try {
this.tableID = this.player1.createNewTable();
Assert.assertNotNull(this.tableID);
this.player2.connectToTable(this.tableID);
this.gameResult = "prepared";
this.player1.startMatch();
this.gameResult = "started";
// playing until game over or abort
while(!abort && (!player1.client.isGameOver() || !player2.client.isGameOver())) {
try {
Thread.sleep(1000);
} catch (InterruptedException e){
logger.error(e.getMessage(), e);
}
}
// game results
if (abort) {
this.gameResult = "aborted";
} else {
this.gameResult = "finished";
}
player1.lastGameResult = player1.client.getLastGameResult();
player2.lastGameResult = player2.client.getLastGameResult();
} catch (Throwable e) {
this.gameResult = "error";
logger.fatal("Game thread " + this.gameName + " was stopped by error");
e.printStackTrace();
}
// disconnect on end
this.player1.disconnect();
this.player2.disconnect();
// clean up after game
this.runningThread = null;
this.tableID = null;
});
runningThread.start();
}
public void gameEnd() {
gameEnd(false);
}
public void gameEnd(Boolean waitToStop) {
this.abort = true;
if (waitToStop) {
gameWaitToStop();
}
}
public void gameConcede(int playerNumber) {
switch (playerNumber) {
case 1:
this.player1.concede();
break;
case 2:
this.player2.concede();
break;
}
}
public void gameWaitToStop() {
while (this.runningThread != null) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
logger.error(e.getMessage(), e);
}
}
}
public Boolean isPlaying() {
return (this.runningThread != null);
}
} }
} }

18
Mage.Tests/src/test/java/org/mage/test/load/SimpleMageClient.java
View file

@ -11,7 +11,7 @@ import org.apache.log4j.Logger;
/** /**
* For tests only * For tests only
* *
* @author noxx * @author noxx, JayDi85
*/ */
public class SimpleMageClient implements MageClient { public class SimpleMageClient implements MageClient {
@ -20,7 +20,7 @@ public class SimpleMageClient implements MageClient {
private static final Logger log = Logger.getLogger(SimpleMageClient.class); private static final Logger log = Logger.getLogger(SimpleMageClient.class);
private final CallbackClient callbackClient; private final LoadCallbackClient callbackClient;
public SimpleMageClient() { public SimpleMageClient() {
clientId = UUID.randomUUID(); clientId = UUID.randomUUID();
@ -54,7 +54,11 @@ public class SimpleMageClient implements MageClient {
@Override @Override
public void processCallback(ClientCallback callback) { public void processCallback(ClientCallback callback) {
callbackClient.processCallback(callback); try {
callbackClient.processCallback(callback);
} catch (Throwable e) {
log.error(e.getMessage(), e);
}
} }
public void setSession(Session session) { public void setSession(Session session) {
@ -64,4 +68,12 @@ public class SimpleMageClient implements MageClient {
public boolean isGameOver() { public boolean isGameOver() {
return ((LoadCallbackClient)callbackClient).isGameOver(); return ((LoadCallbackClient)callbackClient).isGameOver();
} }
public void setConcede(boolean needToConcede) {
this.callbackClient.setConcede(needToConcede);
}
public String getLastGameResult() {
return this.callbackClient.getLastGameResult();
}
} }

26
Mage/src/main/java/mage/abilities/effects/ContinuousEffects.java
View file

@ -111,12 +111,14 @@ public class ContinuousEffects implements Serializable {
costModificationEffects = effect.costModificationEffects.copy(); costModificationEffects = effect.costModificationEffects.copy();
spliceCardEffects = effect.spliceCardEffects.copy(); spliceCardEffects = effect.spliceCardEffects.copy();
temporaryEffects.putAll(effect.temporaryEffects); for (Map.Entry<ContinuousEffect, Set<Ability>> entry: effect.temporaryEffects.entrySet()) {
temporaryEffects.put(entry.getKey().copy(), entry.getValue());
}
collectAllEffects(); collectAllEffects();
order = effect.order; order = effect.order;
} }
private void collectAllEffects() { private synchronized void collectAllEffects() {
allEffectsLists.add(layeredEffects); allEffectsLists.add(layeredEffects);
allEffectsLists.add(continuousRuleModifyingEffects); allEffectsLists.add(continuousRuleModifyingEffects);
allEffectsLists.add(replacementEffects); allEffectsLists.add(replacementEffects);
@ -143,7 +145,7 @@ public class ContinuousEffects implements Serializable {
return restrictionEffects; return restrictionEffects;
} }
public void removeEndOfCombatEffects() { public synchronized void removeEndOfCombatEffects() {
layeredEffects.removeEndOfCombatEffects(); layeredEffects.removeEndOfCombatEffects();
continuousRuleModifyingEffects.removeEndOfCombatEffects(); continuousRuleModifyingEffects.removeEndOfCombatEffects();
replacementEffects.removeEndOfCombatEffects(); replacementEffects.removeEndOfCombatEffects();
@ -157,7 +159,7 @@ public class ContinuousEffects implements Serializable {
spliceCardEffects.removeEndOfCombatEffects(); spliceCardEffects.removeEndOfCombatEffects();
} }
public void removeEndOfTurnEffects() { public synchronized void removeEndOfTurnEffects() {
layeredEffects.removeEndOfTurnEffects(); layeredEffects.removeEndOfTurnEffects();
continuousRuleModifyingEffects.removeEndOfTurnEffects(); continuousRuleModifyingEffects.removeEndOfTurnEffects();
replacementEffects.removeEndOfTurnEffects(); replacementEffects.removeEndOfTurnEffects();
@ -171,7 +173,7 @@ public class ContinuousEffects implements Serializable {
spliceCardEffects.removeEndOfTurnEffects(); spliceCardEffects.removeEndOfTurnEffects();
} }
public void removeInactiveEffects(Game game) { public synchronized void removeInactiveEffects(Game game) {
layeredEffects.removeInactiveEffects(game); layeredEffects.removeInactiveEffects(game);
continuousRuleModifyingEffects.removeInactiveEffects(game); continuousRuleModifyingEffects.removeInactiveEffects(game);
replacementEffects.removeInactiveEffects(game); replacementEffects.removeInactiveEffects(game);
@ -186,7 +188,7 @@ public class ContinuousEffects implements Serializable {
spliceCardEffects.removeInactiveEffects(game); spliceCardEffects.removeInactiveEffects(game);
} }
public List<ContinuousEffect> getLayeredEffects(Game game) { public synchronized List<ContinuousEffect> getLayeredEffects(Game game) {
List<ContinuousEffect> layerEffects = new ArrayList<>(); List<ContinuousEffect> layerEffects = new ArrayList<>();
for (ContinuousEffect effect : layeredEffects) { for (ContinuousEffect effect : layeredEffects) {
switch (effect.getDuration()) { switch (effect.getDuration()) {
@ -226,7 +228,7 @@ public class ContinuousEffects implements Serializable {
* *
* @param layerEffects * @param layerEffects
*/ */
private void updateTimestamps(List<ContinuousEffect> layerEffects) { private synchronized void updateTimestamps(List<ContinuousEffect> layerEffects) {
for (ContinuousEffect continuousEffect : layerEffects) { for (ContinuousEffect continuousEffect : layerEffects) {
// check if it's new, then set order // check if it's new, then set order
if (!previous.contains(continuousEffect)) { if (!previous.contains(continuousEffect)) {
@ -857,7 +859,7 @@ public class ContinuousEffects implements Serializable {
} }
//20091005 - 613 //20091005 - 613
public void apply(Game game) { public synchronized void apply(Game game) {
removeInactiveEffects(game); removeInactiveEffects(game);
List<ContinuousEffect> activeLayerEffects = getLayeredEffects(game); List<ContinuousEffect> activeLayerEffects = getLayeredEffects(game);
@ -1071,7 +1073,7 @@ public class ContinuousEffects implements Serializable {
* @param sourceId * @param sourceId
* @param source * @param source
*/ */
public void addEffect(ContinuousEffect effect, UUID sourceId, Ability source) { public synchronized void addEffect(ContinuousEffect effect, UUID sourceId, Ability source) {
if (!(source instanceof MageSingleton)) { // because MageSingletons may never be removed by removing the temporary effecs they are not added to the temporaryEffects to prevent this if (!(source instanceof MageSingleton)) { // because MageSingletons may never be removed by removing the temporary effecs they are not added to the temporaryEffects to prevent this
effect.setTemporary(true); effect.setTemporary(true);
Set<Ability> abilities = temporaryEffects.get(effect); Set<Ability> abilities = temporaryEffects.get(effect);
@ -1089,7 +1091,7 @@ public class ContinuousEffects implements Serializable {
addEffect(effect, source); addEffect(effect, source);
} }
public void addEffect(ContinuousEffect effect, Ability source) { public synchronized void addEffect(ContinuousEffect effect, Ability source) {
if (effect == null) { if (effect == null) {
logger.error("Effect is null: " + source.toString()); logger.error("Effect is null: " + source.toString());
return; return;
@ -1167,14 +1169,14 @@ public class ContinuousEffects implements Serializable {
} }
} }
public void clear() { public synchronized void clear() {
for (ContinuousEffectsList effectsList : allEffectsLists) { for (ContinuousEffectsList effectsList : allEffectsLists) {
effectsList.clear(); effectsList.clear();
} }
temporaryEffects.clear(); temporaryEffects.clear();
} }
public void removeAllTemporaryEffects() { public synchronized void removeAllTemporaryEffects() {
for (Map.Entry<ContinuousEffect, Set<Ability>> entry : temporaryEffects.entrySet()) { for (Map.Entry<ContinuousEffect, Set<Ability>> entry : temporaryEffects.entrySet()) {
switch (entry.getKey().getEffectType()) { switch (entry.getKey().getEffectType()) {
case REPLACEMENT: case REPLACEMENT:

67
Mage/src/main/java/mage/cards/Sets.java
View file

@ -27,6 +27,7 @@
*/ */
package mage.cards; package mage.cards;
import mage.Mana;
import mage.cards.decks.DeckCardInfo; import mage.cards.decks.DeckCardInfo;
import mage.cards.decks.DeckCardLayout; import mage.cards.decks.DeckCardLayout;
import mage.cards.decks.DeckCardLists; import mage.cards.decks.DeckCardLists;
@ -35,9 +36,12 @@ import mage.cards.repository.CardInfo;
import mage.cards.repository.CardRepository; import mage.cards.repository.CardRepository;
import mage.constants.CardType; import mage.constants.CardType;
import mage.constants.ColoredManaSymbol; import mage.constants.ColoredManaSymbol;
import mage.constants.Rarity;
import mage.filter.FilterMana;
import mage.util.ClassScanner; import mage.util.ClassScanner;
import mage.util.RandomUtil; import mage.util.RandomUtil;
import org.apache.log4j.Logger; import org.apache.log4j.Logger;
import org.junit.Assert;
import java.io.FileNotFoundException; import java.io.FileNotFoundException;
import java.io.PrintWriter; import java.io.PrintWriter;
@ -45,7 +49,7 @@ import java.util.*;
/** /**
* *
* @author BetaSteward_at_googlemail.com * @author BetaSteward_at_googlemail.com, JayDi85
*/ */
public class Sets extends HashMap<String, ExpansionSet> { public class Sets extends HashMap<String, ExpansionSet> {
@ -93,23 +97,50 @@ public class Sets extends HashMap<String, ExpansionSet> {
* @return * @return
*/ */
public static List<Card> generateRandomCardPool(int cardsCount, List<ColoredManaSymbol> allowedColors) { public static List<Card> generateRandomCardPool(int cardsCount, List<ColoredManaSymbol> allowedColors) {
return generateRandomCardPool(cardsCount, allowedColors, false);
}
public static List<Card> generateRandomCardPool(int cardsCount, List<ColoredManaSymbol> allowedColors, boolean onlyBasicLands) {
CardCriteria criteria = new CardCriteria(); CardCriteria criteria = new CardCriteria();
criteria.notTypes(CardType.LAND);
if (onlyBasicLands) {
// only lands
criteria.rarities(Rarity.LAND);
criteria.colorless(true); // basic lands is colorless
} else {
// any card, but not basic lands
criteria.notTypes(CardType.LAND);
// clear colors
criteria.white(false);
criteria.blue(false);
criteria.black(false);
criteria.red(false);
criteria.green(false);
criteria.colorless(false); // colorless is not allowed for gen
}
FilterMana manaNeed = new FilterMana();
for (ColoredManaSymbol color : allowedColors) { for (ColoredManaSymbol color : allowedColors) {
switch (color) { switch (color) {
case W: case W:
manaNeed.setWhite(true);
criteria.white(true); criteria.white(true);
break; break;
case U: case U:
manaNeed.setBlue(true);
criteria.blue(true); criteria.blue(true);
break; break;
case B: case B:
manaNeed.setBlack(true);
criteria.black(true); criteria.black(true);
break; break;
case R: case R:
manaNeed.setRed(true);
criteria.red(true); criteria.red(true);
break; break;
case G: case G:
manaNeed.setGreen(true);
criteria.green(true); criteria.green(true);
break; break;
} }
@ -123,9 +154,37 @@ public class Sets extends HashMap<String, ExpansionSet> {
CardInfo cardInfo = cards.get(RandomUtil.nextInt(cards.size())); CardInfo cardInfo = cards.get(RandomUtil.nextInt(cards.size()));
Card card = cardInfo != null ? cardInfo.getCard() : null; Card card = cardInfo != null ? cardInfo.getCard() : null;
if (card != null) { if (card != null) {
cardPool.add(card);
count++; FilterMana manaCard = card.getColorIdentity();
boolean cardManaOK = true;
if (onlyBasicLands) {
// lands is colorless
// discard not needed color by mana produce
Assert.assertEquals("only basic lands allow", 1, card.getMana().size());
for (Mana manaLand : card.getMana()) {
if (manaLand.getWhite() > 0 && !manaNeed.isWhite()) { cardManaOK = false; }
if (manaLand.getBlue() > 0 && !manaNeed.isBlue()) { cardManaOK = false; }
if (manaLand.getBlack() > 0 && !manaNeed.isBlack()) { cardManaOK = false; }
if (manaLand.getRed() > 0 && !manaNeed.isRed()) { cardManaOK = false; }
if (manaLand.getGreen() > 0 && !manaNeed.isGreen()) { cardManaOK = false; }
}
} else {
// cards
// discard any card that have not needed color
if (manaCard.isWhite() && !manaNeed.isWhite()) { cardManaOK = false; }
if (manaCard.isBlue() && !manaNeed.isBlue()) { cardManaOK = false; }
if (manaCard.isBlack() && !manaNeed.isBlack()) { cardManaOK = false; }
if (manaCard.isRed() && !manaNeed.isRed()) { cardManaOK = false; }
if (manaCard.isGreen() && !manaNeed.isGreen()) { cardManaOK = false; }
}
if (cardManaOK) {
cardPool.add(card);
count++;
}
} }
tries++; tries++;
if (tries > 4096) { // to avoid infinite loop if (tries > 4096) { // to avoid infinite loop
throw new IllegalStateException("Not enough cards for chosen colors to generate deck: " + allowedColors); throw new IllegalStateException("Not enough cards for chosen colors to generate deck: " + allowedColors);

18
Mage/src/main/java/mage/players/PlayerImpl.java
View file

@ -3773,4 +3773,22 @@ public abstract class PlayerImpl implements Player, Serializable {
public List<Designation> getDesignations() { public List<Designation> getDesignations() {
return designations; return designations;
} }
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
PlayerImpl obj = (PlayerImpl) o;
if (this.getId() == null || obj.getId() == null) {
return false;
}
return this.getId().equals(obj.getId());
}
} }