public void pickAttackerOrder(UUID playerId, Game game) { if (attackers.isEmpty()) { return; } Player player = game.getPlayer(playerId); List<UUID> attackerList = new ArrayList<>(attackers); attackerOrder.clear(); while (true) { if (attackerList.size() == 1) { attackerOrder.add(attackerList.get(0)); break; } else { List<Permanent> attackerPerms = new ArrayList<>(); for (UUID attackerId : attackerList) { attackerPerms.add(game.getPermanent(attackerId)); } UUID attackerId = player.chooseAttackerOrder(attackerPerms, game); if (!player.isInGame()) { break; } attackerOrder.add(attackerId); attackerList.remove(attackerId); } } }
public static List<Card> chooseOrder(String message, Cards cards, Player player, Game game) { List<Card> order = new ArrayList<>(); TargetCard target = new TargetCard(Zone.ALL, new FilterCard(message)); target.setRequired(true); while (player.isInGame() && cards.size() > 1) { player.choose(Outcome.Neutral, cards, target, game); UUID targetObjectId = target.getFirstTarget(); order.add(cards.get(targetObjectId, game)); cards.remove(targetObjectId); target.clearChosen(); } order.add(cards.getCards(game).iterator().next()); return order; }
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; }
@Override public boolean isInactive(Ability source, Game game) { if (duration == Duration.UntilYourNextTurn) { Player player = game.getPlayer(startingControllerId); if (player != null) { if (player.isInGame()) { return game.isActivePlayer(startingControllerId) && game.getTurnNum() != startingTurn; } return player.hasReachedNextTurnAfterLeaving(); } return true; } return false; }
@Override protected boolean checkStateBasedActions() { for (Player player : getPlayers().values()) { for (UUID commanderId : player.getCommandersIds()) { CommanderInfoWatcher damageWatcher = getState().getWatcher(CommanderInfoWatcher.class, commanderId); if (damageWatcher == null) { continue; } for (Map.Entry<UUID, Integer> entrySet : damageWatcher.getDamageToPlayer().entrySet()) { if (entrySet.getValue() > 20) { Player opponent = getPlayer(entrySet.getKey()); if (opponent != null && !opponent.hasLost() && player.isInGame()) { opponent.lost(this); } } } } } return super.checkStateBasedActions(); }
protected UUID pickChoosingPlayer() { UUID[] players = getPlayers().keySet().toArray(new UUID[0]); UUID playerId; while (!hasEnded()) { playerId = players[RandomUtil.nextInt(players.length)]; Player player = getPlayer(playerId); if (player != null && player.isInGame()) { fireInformEvent(state.getPlayer(playerId).getLogName() + " won the toss"); return player.getId(); } } logger.debug("Game was not possible to pick a choosing player. GameId:" + getId()); return null; }
private void defenderDamage(Permanent attacker, int amount, Game game) { if (this.defenderIsPlaneswalker) { Permanent defender = game.getPermanent(defenderId); if (defender != null) { defender.markDamage(amount, attacker.getId(), game, true, true); } } else { Player defender = game.getPlayer(defenderId); if (defender.isInGame()) { defender.damage(amount, attacker.getId(), game, true, true); } } }
case LEFT: players = game.getState().getPlayerList(attackingPlayerId); while (attackingPlayer.isInGame()) { Player opponent = players.getNext(game); if (attackingPlayer.hasOpponent(opponent.getId(), game)) { case RIGHT: players = game.getState().getPlayerList(attackingPlayerId); while (attackingPlayer.isInGame()) { Player opponent = players.getPrevious(game); if (attackingPlayer.hasOpponent(opponent.getId(), game)) {
@Override public boolean apply(Game game, Ability source) { Player targetPlayer = game.getPlayer(targetPointer.getFirst(game, source)); if (targetPlayer != null && targetPlayer.isInGame()) { for (Permanent permanent : game.getBattlefield().getAllActivePermanents(filter, source.getControllerId(), game)) { if (permanent != null && !permanent.getId().equals(source.getSourceId())) { permanent.changeControllerId(targetPlayer.getId(), game); } } } else { discard(); } return true; }
@Override public boolean apply(Game game, Ability source) { Permanent permanent = game.getPermanent(source.getSourceId()); Player newControllingPlayer = game.getPlayer(getTargetPointer().getFirst(game, source)); if (permanent == null || newControllingPlayer == null || !newControllingPlayer.isInGame()) { this.discard(); return false; } permanent.changeControllerId(getTargetPointer().getFirst(game, source), game); return true; } }
@Override public void beginStep(Game game, UUID activePlayerId) { super.beginStep(game, activePlayerId); Player activePlayer = game.getPlayer(activePlayerId); game.getState().setPriorityPlayerId(activePlayer.getId()); //20091005 - 514.1 if (activePlayer.isInGame()) { activePlayer.discardToMax(game); } //20100423 - 514.2 game.getBattlefield().endOfTurn(activePlayerId, game); game.getState().removeEotEffects(game); }
@Override public synchronized void rollbackTurns(int turnsToRollback) { if (gameOptions.rollbackTurnsAllowed) { int turnToGoTo = getTurnNum() - turnsToRollback; if (turnToGoTo < 1 || !gameStatesRollBack.containsKey(turnToGoTo)) { informPlayers(GameLog.getPlayerRequestColoredText("Player request: It's not possible to rollback " + turnsToRollback + " turn(s)")); } else { GameState restore = gameStatesRollBack.get(turnToGoTo); if (restore != null) { informPlayers(GameLog.getPlayerRequestColoredText("Player request: Rolling back to start of turn " + restore.getTurnNum())); state.restoreForRollBack(restore); playerList.setCurrent(state.getPlayerByOrderId()); // Reset temporary created bookmarks because no longer valid after rollback savedStates.clear(); gameStates.clear(); // because restore uses the objects without copy each copy the state again gameStatesRollBack.put(getTurnNum(), state.copy()); executingRollback = true; for (Player playerObject : getPlayers().values()) { if (playerObject.isHuman() && playerObject.isInGame()) { playerObject.resetStoredBookmark(this); playerObject.abort(); playerObject.resetPlayerPassedActions(); } } fireUpdatePlayersEvent(); } } } }
@Override public boolean apply(Game game, Ability source) { Player controller = game.getPlayer(source.getControllerId()); if (controller != null) { while (controller.getLibrary().hasCards() && controller.isInGame()) { Card card = controller.getLibrary().getFromTop(game); if (card != null) { controller.moveCards(card, Zone.EXILED, source, game); if (!card.isLand()) { new DamageTargetEffect(card.getConvertedManaCost()).apply(game, source); break; } } } return true; } return false; }
@Override public boolean apply(Game game, Ability source) { Player controller = game.getPlayer(source.getControllerId()); if (controller != null) { Cards hand = controller.getHand(); while (hand != null && hand.size() > 0 && controller.isInGame() && controller.chooseUse(Outcome.AIDontUseIt, "Discard a card randomly from your hand?", source, game)) { Card discardedCard = controller.discardOne(true, source, game); if (discardedCard != null) { new DamageAllEffect(discardedCard.getConvertedManaCost(), new FilterCreaturePermanent()).apply(game, source); } } return true; } return false; } }
&& player.isInGame()) { player.damage(amount.calculate(game, source, this), source.getSourceId(), game, false, preventable); Player player = game.getPlayer(targetId); if (player != null && player.isInGame()) { player.damage(amount.calculate(game, source, this), source.getSourceId(), game, false, preventable);
private boolean playTurn(Player player) { boolean skipTurn = false; do { if (executingRollback) { executingRollback = false; player = getPlayer(state.getActivePlayerId()); for (Player playerObject : getPlayers().values()) { if (playerObject.isInGame()) { playerObject.abortReset(); } } } else { state.setActivePlayerId(player.getId()); saveRollBackGameState(); } if (checkStopOnTurnOption()) { return false; } skipTurn = state.getTurn().play(this, player); } while (executingRollback); if (isPaused() || checkIfGameIsOver()) { return false; } if (!skipTurn) { endOfTurn(); state.setTurnNum(state.getTurnNum() + 1); } return true; }
@Override public boolean apply(Game game, Ability source) { Player controller = game.getPlayer(source.getControllerId()); Permanent enteringDragon = (Permanent) getValue("permanentEnteringBattlefield"); if (controller != null && enteringDragon != null) { FilterPermanent filter = new FilterPermanent(); filter.add(new SubtypePredicate(SubType.DRAGON)); int dragons = game.getBattlefield().countAll(filter, source.getControllerId(), game); if (dragons > 0) { Permanent permanent = game.getPermanent(getTargetPointer().getFirst(game, source)); if (permanent != null) { permanent.damage(dragons, enteringDragon.getId(), game, false, true); } else { Player player = game.getPlayer(getTargetPointer().getFirst(game, source)); if (player != null && player.isInGame()) { player.damage(dragons, enteringDragon.getId(), game, false, true); } } } return true; } return false; } }
if (targetOpponent.isInGame()) { if (cards.size() > 1) { controller.choose(Outcome.Detriment, cards, target, game);
} while (keepGoing && controller.isInGame()); return true;
} while (controller.isInGame() && (card.isLand() || !cardThatCostsLess(sourceCost, card, game)));