public GameController(Game game, ConcurrentHashMap<UUID, UUID> userPlayerMap, UUID tableId, UUID choosingPlayerId, GameOptions gameOptions) { gameSessionId = UUID.randomUUID(); this.userPlayerMap = userPlayerMap; chatId = ChatManager.instance.createChatSession("Game " + game.getId()); this.userReqestingRollback = null; this.game = game; this.game.setSaveGame(ConfigSettings.instance.isSaveGameActivated()); this.tableId = tableId; this.choosingPlayerId = choosingPlayerId; this.gameOptions = gameOptions; useTimeout = game.getPlayers().values().stream().allMatch(Player::isHuman); init(); }
/** * Copies game and replaces all players in copy with simulated players * * @param game * @return a new game object with simulated players */ protected Game createSimulation(Game game) { Game sim = game.copy(); for (Player copyPlayer: sim.getState().getPlayers().values()) { Player origPlayer = game.getState().getPlayers().get(copyPlayer.getId()).copy(); SimulatedPlayer newPlayer = new SimulatedPlayer(copyPlayer.getId(), copyPlayer.getId().equals(playerId), maxDepth); newPlayer.restore(origPlayer); sim.getState().getPlayers().put(copyPlayer.getId(), newPlayer); } sim.setSimulation(true); return sim; }
protected int simulatePostCombatMain(Game game, SimulationNode node, int alpha, int beta) { if (Thread.interrupted()) { Thread.currentThread().interrupt(); logger.debug(indent(node.depth) + "interrupted"); return GameStateEvaluator.evaluate(playerId, game); } logger.debug(indent(node.depth) + "simulating -- post combat main"); game.getTurn().setPhase(new PostCombatMainPhase()); if (game.getPhase().beginPhase(game, game.getActivePlayerId())) { game.getPhase().setStep(new PostCombatMainStep()); game.getStep().beginStep(game, playerId); game.getPlayers().resetPassed(); return addActions(node, alpha, beta); } return simulateCounterAttack(game, node, alpha, beta); }
private void logStartOfTurn(Game game, Player player) { StringBuilder sb = new StringBuilder(game.getState().isExtraTurn() ? "Extra turn" : "Turn "); sb.append(game.getState().getTurnNum()).append(' '); sb.append(player.getLogName()); sb.append(" ("); int delimiter = game.getPlayers().size() - 1; for (Player gamePlayer : game.getPlayers().values()) { sb.append(gamePlayer.getLife()); int poison = gamePlayer.getCounters().getCount(CounterType.POISON); if (poison > 0) { sb.append("[P:").append(poison).append(']'); } if (delimiter > 0) { sb.append(" - "); delimiter--; } } sb.append(')'); game.fireStatusEvent(sb.toString(), true); } }
protected UUID findWinnersAndLosers() { UUID winnerIdFound = null; for (Player player : state.getPlayers().values()) { if (player.hasWon()) { logger.debug(player.getName() + " has won gameId: " + getId()); winnerIdFound = player.getId(); break; } if (!player.hasLost() && !player.hasLeft()) { logger.debug(player.getName() + " has not lost so he won gameId: " + this.getId()); player.won(this); winnerIdFound = player.getId(); break; } } for (Player player : state.getPlayers().values()) { if (winnerIdFound != null && !player.getId().equals(winnerIdFound) && !player.hasLost()) { player.lost(this); } } return winnerIdFound; }
protected void resolve(SimulationNode node, Game game) { StackObject ability = game.getStack().pop(); if (ability instanceof StackAbility) { SearchEffect effect = getSearchEffect((StackAbility) ability); if (effect != null && ability.getControllerId().equals(playerId)) { Target target = effect.getTarget(); if (!target.doneChosing()) { for (UUID targetId: target.possibleTargets(ability.getSourceId(), ability.getControllerId(), game)) { Game sim = game.copy(); StackAbility newAbility = (StackAbility) ability.copy(); SearchEffect newEffect = getSearchEffect((StackAbility) newAbility); newEffect.getTarget().addTarget(targetId, newAbility, sim); sim.getStack().push(newAbility); SimulationNode newNode = new SimulationNode(node, sim, ability.getControllerId()); node.children.add(newNode); newNode.getTargets().add(targetId); logger.debug(indent(node.depth) + "simulating search -- node#: " + SimulationNode.getCount() + "for player: " + sim.getPlayer(ability.getControllerId()).getName()); } return; } } } logger.debug(indent(node.depth) + "simulating resolve "); ability.resolve(game); game.applyEffects(); game.getPlayers().resetPassed(); game.getPlayerList().setCurrent(game.getActivePlayerId()); }
@Override public boolean apply(Game game, Ability source) { Players players = game.getPlayers(); for (Player player : players.values()) { if (!player.getId().equals(source.getControllerId())) { player.loseLife(1, game, false); } } return true; }
private int requestPermissionToRollback(UUID userIdRequester, int numberTurns) { int requests = 0; for (Player player : game.getState().getPlayers().values()) { Optional<User> requestedUser = getUserByPlayerId(player.getId()); if (player.isInGame() && player.isHuman() && requestedUser.isPresent() && !requestedUser.get().getId().equals(userIdRequester)) { requests++; GameSessionPlayer gameSession = gameSessions.get(player.getId()); if (gameSession != null) { gameSession.requestPermissionToRollbackTurn(userIdRequester, numberTurns); } } } return requests; }
public int simulate(UUID playerId) { // long startTime = System.nanoTime(); Game sim = createSimulation(game, playerId); sim.resume(); // long duration = System.nanoTime() - startTime; int retVal = -1; //anything other than a win is a loss for (Player simPlayer: sim.getPlayers().values()) { // logger.info(simPlayer.getName() + " calculated " + ((SimulatedPlayerMCTS)simPlayer).getActionCount() + " actions in " + duration/1000000000.0 + "s"); if (simPlayer.getId().equals(playerId) && simPlayer.hasWon()) { // logger.info("AI won the simulation"); retVal = 1; } } return retVal; }
int highestNumber = 0; int number = 0; Permanent menacingOgre = game.getPermanent(source.getSourceId()); String message = "Choose a number."; Map<Player, Integer> numberChosen = new HashMap<>(); for (Player player : game.getPlayers().values()) { if (player != null) { number = player.getAmount(0, 1000, message, game); for (Player player : game.getPlayers().values()) { if (player != null) { game.informPlayers(player.getLogName() + " chose number " + numberChosen.get(player)); if (numberChosen.get(player) >= highestNumber) { player.loseLife(highestNumber, game, false); if (player.getId().equals(source.getControllerId()) && menacingOgre != null) { menacingOgre.addCounters(CounterType.P1P1.createInstance(2), source, game);
if (node.depth > maxDepth || game.checkIfGameIsOver()) { logger.debug(indent(node.depth) + "simulating -- reached end state"); val = GameStateEvaluator.evaluate(playerId, game); logger.debug(indent(node.depth) + "simulating -- alpha: " + alpha + " beta: " + beta + " depth:" + node.depth + " step:" + game.getTurn().getStepType() + " for player:" + (node.getPlayerId().equals(playerId)?"yes":"no")); if (allPassed(game)) { if (!game.getStack().isEmpty()) { resolve(node, game); game.getPlayers().resetPassed(); playNext(game, game.getActivePlayerId(), node);
Set<UUID> possibleDefender = game.getCombat().getCreaturesForcedToAttack().get(attackerId); if (possibleDefender != null) { forcedToAttack = true; if (forcedToAttack) { StringBuilder sb = new StringBuilder(target.getTargetName()); Permanent attacker = game.getPermanent(attackerId); if (attacker != null) { sb.append(" (").append(attacker.getName()).append(')'); for (Player player : game.getPlayers().values()) { if (player.getId().equals(response.getUUID())) {
for (ExileZone zone : game.getExile().getExileZones()) { exileId = CardUtil.getExileZoneId(game, source.getSourceId(), source.getSourceObjectZoneChangeCounter()); if (zone.getId().equals(exileId)) { for (Card card : zone.getCards(game)) { if (!card.hasSubtype(SubType.AURA, game) game.getState().clear(); for (Card card : game.getCards()) { game.getState().addCard(card); for (Player player : game.getPlayers().values()) { if (player.isInGame()) { // only players alive are in the restarted game player.getGraveyard().clear();
public GameEndView(GameState state, Game game, UUID playerId, Table table) { startTime = game.getStartTime(); endTime = game.getEndTime(); for (Player player : state.getPlayers().values()) { PlayerView playerView = new PlayerView(player, state, game, playerId, null); if (playerView.getPlayerId().equals(playerId)) { clientPlayer = playerView; you = player; gameInfo = "You won the game on turn " + game.getTurnNum() + "."; } else if (winner > 0) { gameInfo = "You lost the game on turn " + game.getTurnNum() + ".";
targets = game.getBattlefield().getActivePermanents(t.getFilter(), playerId, game); targets = game.getBattlefield().getActivePermanents(((FilterCreatureOrPlayer) t.getFilter()).getCreatureFilter(), playerId, game); targets = game.getBattlefield().getActivePermanents(((FilterCreaturePlayerOrPlaneswalker) t.getFilter()).getCreatureFilter(), playerId, game); for (Player player : game.getPlayers().values()) { cards.addAll(player.getGraveyard().getCards(game)); if (!game.getStack().isEmpty()) { for (StackObject o : game.getStack()) { if (o instanceof Spell && !source.getId().equals(o.getStackAbility().getId())) { target.addTarget(o.getId(), source, game); return true; if (!game.getStack().isEmpty()) { for (StackObject stackObject : game.getStack()) { if (stackObject instanceof Spell && source != null && !source.getId().equals(stackObject.getStackAbility().getId())) { if (((TargetSpellOrPermanent) target).getFilter().match(stackObject, game)) { target.addTarget(stackObject.getId(), source, game); for (Player player : game.getPlayers().values()) { cards.addAll(player.getGraveyard().getCards(game)); for (Player player : game.getPlayers().values()) { cards.addAll(player.getGraveyard().getCards(game)); cards.addAll(game.getBattlefield().getAllActivePermanents(new FilterPermanent(), player.getId(), game));
public GameView(GameState state, Game game, UUID createdForPlayerId, UUID watcherUserId) { Player createdForPlayer = null; this.isPlayer = createdForPlayerId != null; this.priorityTime = game.getPriorityTime(); for (Player player : state.getPlayers().values()) { players.add(new PlayerView(player, state, game, createdForPlayerId, watcherUserId)); if (player.getId().equals(createdForPlayerId)) { createdForPlayer = player; if (stackObject instanceof Spell) { CardView spellView = new CardView((Spell) stackObject, game, stackObject.getControllerId().equals(createdForPlayerId)); spellView.paid = ((Spell) stackObject).getSpellAbility().getManaCostsToPay().isPaid(); stack.put(stackObject.getId(), spellView); } else if (stackObject instanceof StackAbility) { MageObject object = game.getObject(stackObject.getSourceId()); Card card = game.getCard(stackObject.getSourceId()); if (card == null && (object instanceof PermanentCard)) { card = ((PermanentCard) object).getCard(); if (object != null) { if (object instanceof Permanent) { boolean controlled = ((Permanent) object).getControllerId().equals(createdForPlayerId); stack.put(stackObject.getId(), new StackAbilityView(game, (StackAbility) stackObject, object.getName(), new CardView(((Permanent) object), game, controlled, false, false))); } else {
@Override public Set<UUID> possibleTargets(UUID sourceControllerId, Game game) { Set<UUID> possibleTargets = new HashSet<>(); for (StackObject stackObject: game.getStack()) { if (game.getState().getPlayersInRange(sourceControllerId, game).contains(stackObject.getControllerId()) && Objects.equals(stackObject.getControllerId(), sourceControllerId)) { possibleTargets.add(stackObject.getId()); } } for (Permanent permanent: game.getBattlefield().getActivePermanents(sourceControllerId, game)) { if (Objects.equals(permanent.getControllerId(), sourceControllerId)) { possibleTargets.add(permanent.getId()); } } for (Player player : game.getPlayers().values()) { if (Objects.equals(player, game.getPlayer(sourceControllerId))) { for (Card card : player.getGraveyard().getCards(game)) { possibleTargets.add(card.getId()); } // 108.4a If anything asks for the controller of a card that doesn't have one (because it's not a permanent or spell), use its owner instead. for (Card card : game.getExile().getAllCards(game)) { if (Objects.equals(card.getOwnerId(), sourceControllerId)) { possibleTargets.add(card.getId()); } } } } return possibleTargets; }
Card card = game.getCard(cardInGraveyard); if (card != null) { for (Player player : game.getPlayers().values()) { if (player.getGraveyard().contains(card.getId())) { graveyardPlayer = player; Card card = game.getCard(source.getSourceId()); if (card != null) { result |= card.moveToZone(Zone.LIBRARY, source.getSourceId(), game, false);
@Override public boolean apply(Game game, Ability source) { int lowestLife = game.getPlayer(source.getControllerId()).getLife(); for (Player playerid : game.getPlayers().values()) { if (playerid != null) { if (lowestLife > playerid.getLife()) { lowestLife = playerid.getLife(); } } } for (Player playerId : game.getPlayers().values()) { if (playerId != null) { playerId.setLife(lowestLife, game, source); } } return true; }