/** {@inheritDoc} */ @Override public final void showMessage() { final Game game = player.getGame(); final StringBuilder sb = new StringBuilder(); if (startingPlayer == player) { sb.append(player).append(", you are going first!\n\n"); } else { sb.append(startingPlayer.getName()).append(" is going first.\n"); sb.append(player) .append(", you are going ") .append(Lang.getOrdinal(game.getPosition(player, startingPlayer))) .append(".\n\n"); } if (isCommander) { getController().getGui().updateButtons(getOwner(), "Keep", "Exile", true, false, true); sb.append( "Will you keep your hand or choose some cards to exile those and draw one less card?"); } else { getController().getGui().updateButtons(getOwner(), "Keep", "Mulligan", true, true, true); sb.append("Do you want to keep your hand?"); } showMessage(sb.toString()); }
@Override public void resolve(SpellAbility sa) { CardCollectionView tgtCards; final Game game = sa.getActivatingPlayer().getGame(); final Card source = sa.getHostCard(); final boolean phaseInOrOut = sa.hasParam("PhaseInOrOutAll"); if (sa.hasParam("AllValid")) { if (phaseInOrOut) { tgtCards = game.getCardsIncludePhasingIn(ZoneType.Battlefield); } else { tgtCards = game.getCardsIn(ZoneType.Battlefield); } tgtCards = AbilityUtils.filterListByType(tgtCards, sa.getParam("AllValid"), sa); } else if (sa.hasParam("Defined")) { tgtCards = AbilityUtils.getDefinedCards(source, sa.getParam("Defined"), sa); } else { tgtCards = getTargetCards(sa); } if (phaseInOrOut) { // Time and Tide for (final Card tgtC : tgtCards) { tgtC.phase(); } } else { // just phase out for (final Card tgtC : tgtCards) { if (!tgtC.isPhasedOut()) { tgtC.phase(); } } } }
/* (non-Javadoc) * @see forge.card.abilityfactory.SpellAiLogic#canPlayAI(forge.game.player.Player, forge.card.spellability.SpellAbility) */ @Override protected boolean canPlayAI(Player aiPlayer, SpellAbility sa) { String logic = sa.getParam("AILogic"); Game game = aiPlayer.getGame(); if ("ZeroToughness".equals(logic)) { // If Creature has Zero Toughness, make sure some static ability is in play // That will grant a toughness bonus final List<Card> list = aiPlayer.getCardsIn(ZoneType.Battlefield); if (!Iterables.any( list, Predicates.or( CardPredicates.nameEquals("Glorious Anthem"), CardPredicates.nameEquals("Gaea's Anthem")))) { return false; } // TODO See if card ETB will survive after Static Effects /* List<Card> cards = game.getCardsIn(ZoneType.Battlefield); for(Card c : cards) { ArrayList<StaticAbility> statics = c.getStaticAbilities(); for(StaticAbility s : statics) { final Map<String, String> stabMap = s.parseParams(); if (!stabMap.get("Mode").equals("Continuous")) { continue; } final String affected = stabMap.get("Affected"); if (affected == null) { continue; } } } */ } // Wait for Main2 if possible if (game.getPhaseHandler().is(PhaseType.MAIN1) && !ComputerUtil.castPermanentInMain1(aiPlayer, sa)) { return false; } // AI shouldn't be retricted all that much for Creatures for now return true; }
@Override public void resolve(SpellAbility sa) { Game game = sa.getActivatingPlayer().getGame(); for (Player p : game.getPlayers()) { p.leaveCurrentPlane(); } if (sa.hasParam("Defined")) { CardCollectionView destinations = AbilityUtils.getDefinedCards(sa.getHostCard(), sa.getParam("Defined"), sa); sa.getActivatingPlayer().planeswalkTo(destinations); } else { sa.getActivatingPlayer().planeswalk(); } }
@Override public void selectButtonCancel() { // cancel auto pass for all players for (final Player player : game.getPlayers()) { player.getController().autoPassCancel(); } }
private Card chooseCardOnStack(SpellAbility sa, Player ai, Game game) { for (SpellAbilityStackInstance si : game.getStack()) { final Card source = si.getSourceCard(); final SpellAbility abilityOnStack = si.getSpellAbility(true); if (sa.hasParam("Choices") && !abilityOnStack.getHostCard().isValid(sa.getParam("Choices"), ai, sa.getHostCard())) { continue; } final ApiType threatApi = abilityOnStack.getApi(); if (threatApi != ApiType.DealDamage && threatApi != ApiType.DamageAll) { continue; } List<? extends GameObject> objects = getTargets(abilityOnStack); if (!abilityOnStack.usesTargeting() && !abilityOnStack.hasParam("Defined") && abilityOnStack.hasParam("ValidPlayers")) objects = AbilityUtils.getDefinedPlayers( source, abilityOnStack.getParam("ValidPlayers"), abilityOnStack); if (!objects.contains(ai) || abilityOnStack.hasParam("NoPrevention")) { continue; } int dmg = AbilityUtils.calculateAmount(source, abilityOnStack.getParam("NumDmg"), abilityOnStack); if (ComputerUtilCombat.predictDamageTo(ai, dmg, source, false) <= 0) { continue; } return source; } return null; }
/* (non-Javadoc) * @see forge.card.ability.SpellAbilityEffect#resolve(forge.card.spellability.SpellAbility) */ @Override public void resolve(SpellAbility sa) { Player activator = sa.getActivatingPlayer(); Card source = sa.getHostCard(); Game game = activator.getGame(); String valid = sa.hasParam("Valid") ? sa.getParam("Valid") : "Card"; ZoneType zone = sa.hasParam("Zone") ? ZoneType.smartValueOf(sa.getParam("Zone")) : ZoneType.Battlefield; int min = Integer.MAX_VALUE; final FCollectionView<Player> players = game.getPlayersInTurnOrder(); final List<CardCollection> validCards = new ArrayList<CardCollection>(players.size()); for (int i = 0; i < players.size(); i++) { // Find the minimum of each Valid per player validCards.add( CardLists.getValidCards(players.get(i).getCardsIn(zone), valid, activator, source)); min = Math.min(min, validCards.get(i).size()); } for (int i = 0; i < players.size(); i++) { Player p = players.get(i); int numToBalance = validCards.get(i).size() - min; if (numToBalance == 0) { continue; } if (zone.equals(ZoneType.Hand)) { for (Card card : p.getController() .chooseCardsToDiscardFrom(p, sa, validCards.get(i), numToBalance, numToBalance)) { if (null == card) continue; p.discard(card, sa); } } else { // Battlefield // TODO: "can'e be sacrificed" for (Card card : p.getController() .choosePermanentsToSacrifice( sa, numToBalance, numToBalance, validCards.get(i), valid)) { if (null == card) continue; game.getAction().sacrifice(card, sa); } } } }
/** {@inheritDoc} */ @Override public boolean canPlay() { final Card card = this.getHostCard(); Player activator = this.getActivatingPlayer(); if (activator == null) { activator = card.getController(); if (activator == null) { return false; } } final Game game = activator.getGame(); if (game.getStack().isSplitSecondOnStack()) { return false; } if (!(card.isInstant() || activator.canCastSorcery() || card.hasKeyword("Flash") || this.getRestrictions().isInstantSpeed() || activator.hasKeyword("You may cast nonland cards as though they had flash.") || card.hasStartOfKeyword("You may cast CARDNAME as though it had flash."))) { return false; } if (!this.getRestrictions().canPlay(card, this)) { return false; } // for uncastables like lotus bloom, check if manaCost is blank (except for morph spells) if (!isCastFaceDown() && isBasicSpell() && card.getState(card.isFaceDown() ? CardStateName.Original : card.getCurrentStateName()) .getManaCost() .isNoCost()) { return false; } if (this.getPayCosts() != null) { if (!CostPayment.canPayAdditionalCosts(this.getPayCosts(), this)) { return false; } } return checkOtherRestrictions(); } // canPlay()
public boolean checkOtherRestrictions() { final Card source = this.getHostCard(); Player activator = getActivatingPlayer(); final Game game = activator.getGame(); // CantBeCast static abilities final CardCollection allp = new CardCollection(game.getCardsIn(ZoneType.listValueOf("Battlefield,Command"))); allp.add(source); for (final Card ca : allp) { final FCollectionView<StaticAbility> staticAbilities = ca.getStaticAbilities(); for (final StaticAbility stAb : staticAbilities) { if (stAb.applyAbility("CantBeCast", source, activator)) { return false; } } } return true; }
public static RegisteredPlayer getGuiRegisteredPlayer(Game game) { LobbyPlayer guiPlayer = GuiBase.getInterface().getGuiPlayer(); for (RegisteredPlayer player : game.getMatch().getPlayers()) { if (player.getPlayer() == guiPlayer) { return player; } } return null; }
@Override public PaymentDecision visit(CostPutCardToLib cost) { Integer c = cost.convertAmount(); final Game game = player.getGame(); List<Card> chosen = new ArrayList<Card>(); List<Card> list; if (cost.isSameZone()) { list = new ArrayList<Card>(game.getCardsIn(cost.getFrom())); } else { list = new ArrayList<Card>(player.getCardsIn(cost.getFrom())); } if (c == null) { final String sVar = ability.getSVar(cost.getAmount()); // Generalize cost if (sVar.equals("XChoice")) { return null; } c = AbilityUtils.calculateAmount(source, cost.getAmount(), ability); } list = CardLists.getValidCards(list, cost.getType().split(";"), player, source); if (cost.isSameZone()) { // Jotun Grunt // TODO: improve AI final List<Player> players = game.getPlayers(); for (Player p : players) { List<Card> enoughType = CardLists.filter(list, CardPredicates.isOwner(p)); if (enoughType.size() >= c) { chosen.addAll(enoughType); break; } } chosen = chosen.subList(0, c); } else { chosen = ComputerUtil.choosePutToLibraryFrom( player, cost.getFrom(), cost.getType(), source, ability.getTargetCard(), c); } return chosen.isEmpty() ? null : PaymentDecision.card(chosen); }
@Override public Card chooseSingleCard( final Player aiChoser, SpellAbility sa, Iterable<Card> options, boolean isOptional, Player targetedPlayer) { if ("NeedsPrevention".equals(sa.getParam("AILogic"))) { final Player ai = sa.getActivatingPlayer(); final Game game = ai.getGame(); if (!game.getStack().isEmpty()) { Card choseCard = chooseCardOnStack(sa, ai, game); if (choseCard != null) { return choseCard; } } final Combat combat = game.getCombat(); List<Card> permanentSources = CardLists.filter( options, new Predicate<Card>() { @Override public boolean apply(final Card c) { if (c == null || c.getZone() == null || c.getZone().getZoneType() != ZoneType.Battlefield || combat == null || !combat.isAttacking(c, ai) || !combat.isUnblocked(c)) { return false; } return ComputerUtilCombat.damageIfUnblocked(c, ai, combat, true) > 0; } }); return ComputerUtilCard.getBestCreatureAI(permanentSources); } else { return ComputerUtilCard.getBestAI(options); } }
private boolean phasesUnpreferredTargeting( final Game game, final SpellAbility sa, final boolean mandatory) { final Card source = sa.getHostCard(); final TargetRestrictions tgt = sa.getTargetRestrictions(); CardCollectionView list = game.getCardsIn(ZoneType.Battlefield); list = CardLists.getTargetableCards( CardLists.getValidCards(list, tgt.getValidTgts(), source.getController(), source), sa); return false; }
// returns a List<Card> that is a subset of list with cards that share a name // with a permanent on the battlefield private static CardCollection sharesNameWithCardOnBattlefield( final Game game, final List<Card> list) { final CardCollection toReturn = new CardCollection(); final CardCollectionView play = game.getCardsIn(ZoneType.Battlefield); for (final Card c : list) { for (final Card p : play) { if (p.getName().equals(c.getName()) && !toReturn.contains(c)) { toReturn.add(c); } } } return toReturn; }
@Override protected int evaluate(Player player, Game game) { if (player.getOutcome().hasWon()) { for (Player p : game.getRegisteredPlayers()) { if (p.isOpponentOf(player) && p.getOutcome().lossState == GameLossReason.CommanderDamage) { Integer damage = p.getCommanderDamage(player.getCommander()); if (damage != null && damage >= THRESHOLD) { return damage; } } } } return 0; }
private void passPriority(final Runnable runnable) { if (FModel.getPreferences().getPrefBoolean(FPref.UI_MANA_LOST_PROMPT)) { // if gui player has mana floating that will be lost if phase ended right now, prompt before // passing priority final Game game = player.getGame(); if (game.getStack().isEmpty()) { // phase can't end right now if stack isn't empty Player player = game.getPhaseHandler().getPriorityPlayer(); if (player != null && player.getManaPool().willManaBeLostAtEndOfPhase() && player.getLobbyPlayer() == GamePlayerUtil.getGuiPlayer()) { ThreadUtil.invokeInGameThread( new Runnable() { // must invoke in game thread so dialog can be shown on mobile game @Override public void run() { String message = "You have mana floating in your mana pool that could be lost if you pass priority now."; if (FModel.getPreferences().getPrefBoolean(FPref.UI_MANABURN)) { message += " You will take mana burn damage equal to the amount of floating mana lost this way."; } if (SOptionPane.showOptionDialog( message, "Mana Floating", SOptionPane.WARNING_ICON, new String[] {"OK", "Cancel"}) == 0) { runnable.run(); } } }); return; } } } runnable.run(); // just pass priority immediately if no mana floating that would be lost }
/* (non-Javadoc) * @see forge.card.ability.SpellAbilityEffect#resolve(forge.card.spellability.SpellAbility) */ @Override public void resolve(final SpellAbility sa) { final Card hostCard = sa.getHostCard(); final Game game = hostCard.getGame(); final List<String> keywords = new ArrayList<String>(); final List<String> types = new ArrayList<String>(); final List<String> svars = new ArrayList<String>(); final List<String> triggers = new ArrayList<String>(); if (sa.hasParam("Optional")) { if (!sa.getActivatingPlayer() .getController() .confirmAction(sa, null, "Copy this permanent?")) { return; } } if (sa.hasParam("Keywords")) { keywords.addAll(Arrays.asList(sa.getParam("Keywords").split(" & "))); } if (sa.hasParam("AddTypes")) { types.addAll(Arrays.asList(sa.getParam("AddTypes").split(" & "))); } if (sa.hasParam("AddSVars")) { svars.addAll(Arrays.asList(sa.getParam("AddSVars").split(" & "))); } if (sa.hasParam("Triggers")) { triggers.addAll(Arrays.asList(sa.getParam("Triggers").split(" & "))); } final int numCopies = sa.hasParam("NumCopies") ? AbilityUtils.calculateAmount(hostCard, sa.getParam("NumCopies"), sa) : 1; Player controller = null; if (sa.hasParam("Controller")) { final FCollectionView<Player> defined = AbilityUtils.getDefinedPlayers(hostCard, sa.getParam("Controller"), sa); if (!defined.isEmpty()) { controller = defined.getFirst(); } } if (controller == null) { controller = sa.getActivatingPlayer(); } List<Card> tgtCards = getTargetCards(sa); final TargetRestrictions tgt = sa.getTargetRestrictions(); if (sa.hasParam("ValidSupportedCopy")) { List<PaperCard> cards = Lists.newArrayList(StaticData.instance().getCommonCards().getUniqueCards()); String valid = sa.getParam("ValidSupportedCopy"); if (valid.contains("X")) { valid = valid.replace("X", Integer.toString(AbilityUtils.calculateAmount(hostCard, "X", sa))); } if (StringUtils.containsIgnoreCase(valid, "creature")) { Predicate<PaperCard> cpp = Predicates.compose(CardRulesPredicates.Presets.IS_CREATURE, PaperCard.FN_GET_RULES); cards = Lists.newArrayList(Iterables.filter(cards, cpp)); } if (StringUtils.containsIgnoreCase(valid, "equipment")) { Predicate<PaperCard> cpp = Predicates.compose(CardRulesPredicates.Presets.IS_EQUIPMENT, PaperCard.FN_GET_RULES); cards = Lists.newArrayList(Iterables.filter(cards, cpp)); } if (sa.hasParam("RandomCopied")) { List<PaperCard> copysource = new ArrayList<PaperCard>(cards); List<Card> choice = new ArrayList<Card>(); final String num = sa.hasParam("RandomNum") ? sa.getParam("RandomNum") : "1"; int ncopied = AbilityUtils.calculateAmount(hostCard, num, sa); while (ncopied > 0) { final PaperCard cp = Aggregates.random(copysource); Card possibleCard = Card.fromPaperCard( cp, sa.getActivatingPlayer()); // Need to temporarily set the Owner so the Game is set if (possibleCard.isValid(valid, hostCard.getController(), hostCard)) { choice.add(possibleCard); copysource.remove(cp); ncopied -= 1; } } tgtCards = choice; } else if (sa.hasParam("DefinedName")) { String name = sa.getParam("DefinedName"); if (name.equals("NamedCard")) { if (!hostCard.getNamedCard().isEmpty()) { name = hostCard.getNamedCard(); } } Predicate<PaperCard> cpp = Predicates.compose( CardRulesPredicates.name(StringOp.EQUALS, name), PaperCard.FN_GET_RULES); cards = Lists.newArrayList(Iterables.filter(cards, cpp)); tgtCards.clear(); if (!cards.isEmpty()) { tgtCards.add(Card.fromPaperCard(cards.get(0), controller)); } } } hostCard.clearClones(); for (final Card c : tgtCards) { if ((tgt == null) || c.canBeTargetedBy(sa)) { int multiplier = numCopies * hostCard.getController().getTokenDoublersMagnitude(); final List<Card> crds = new ArrayList<Card>(multiplier); for (int i = 0; i < multiplier; i++) { final Card copy = CardFactory.copyCopiableCharacteristics(c, sa.getActivatingPlayer()); copy.setToken(true); copy.setCopiedPermanent(c); CardFactory.copyCopiableAbilities(c, copy); // add keywords from sa for (final String kw : keywords) { copy.addIntrinsicKeyword(kw); } for (final String type : types) { copy.addType(type); } for (final String svar : svars) { String actualsVar = hostCard.getSVar(svar); String name = svar; if (actualsVar.startsWith("SVar:")) { actualsVar = actualsVar.split("SVar:")[1]; name = actualsVar.split(":")[0]; actualsVar = actualsVar.split(":")[1]; } copy.setSVar(name, actualsVar); } for (final String s : triggers) { final String actualTrigger = hostCard.getSVar(s); final Trigger parsedTrigger = TriggerHandler.parseTrigger(actualTrigger, copy, true); copy.addTrigger(parsedTrigger); } // Temporarily register triggers of an object created with CopyPermanent // game.getTriggerHandler().registerActiveTrigger(copy, false); final Card copyInPlay = game.getAction().moveToPlay(copy); // when copying something stolen: copyInPlay.setController(controller, 0); copyInPlay.setSetCode(c.getSetCode()); copyInPlay.setCloneOrigin(hostCard); sa.getHostCard().addClone(copyInPlay); crds.add(copyInPlay); if (sa.hasParam("RememberCopied")) { hostCard.addRemembered(copyInPlay); } if (sa.hasParam("Tapped")) { copyInPlay.setTapped(true); } if (sa.hasParam("CopyAttacking") && game.getPhaseHandler().inCombat()) { final String attacked = sa.getParam("CopyAttacking"); GameEntity defender; if ("True".equals(attacked)) { FCollectionView<GameEntity> defs = game.getCombat().getDefenders(); defender = c.getController() .getController() .chooseSingleEntityForEffect( defs, sa, "Choose which defender to attack with " + c, false); } else { defender = AbilityUtils.getDefinedPlayers(hostCard, sa.getParam("CopyAttacking"), sa).get(0); } game.getCombat().addAttacker(copyInPlay, defender); game.fireEvent(new GameEventCombatChanged()); } if (sa.hasParam("AttachedTo")) { CardCollectionView list = AbilityUtils.getDefinedCards(hostCard, sa.getParam("AttachedTo"), sa); if (list.isEmpty()) { list = copyInPlay.getController().getGame().getCardsIn(ZoneType.Battlefield); list = CardLists.getValidCards( list, sa.getParam("AttachedTo"), copyInPlay.getController(), copyInPlay); } if (!list.isEmpty()) { Card attachedTo = sa.getActivatingPlayer() .getController() .chooseSingleEntityForEffect( list, sa, copyInPlay + " - Select a card to attach to."); if (copyInPlay.isAura()) { if (attachedTo.canBeEnchantedBy(copyInPlay)) { copyInPlay.enchantEntity(attachedTo); } else { // can't enchant continue; } } else if (copyInPlay.isEquipment()) { // Equipment if (attachedTo.canBeEquippedBy(copyInPlay)) { copyInPlay.equipCard(attachedTo); } else { continue; } } else { // Fortification copyInPlay.fortifyCard(attachedTo); } } else { continue; } } } if (sa.hasParam("AtEOT")) { final String location = sa.getParam("AtEOT"); registerDelayedTrigger(sa, location, crds); } } // end canBeTargetedBy } // end foreach Card } // end resolve
/* (non-Javadoc) * @see forge.card.abilityfactory.SpellAiLogic#canPlayAI(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility) */ @Override protected boolean canPlayAI(Player ai, SpellAbility sa) { final Cost cost = sa.getPayCosts(); final Game game = ai.getGame(); final PhaseHandler ph = game.getPhaseHandler(); final List<String> keywords = sa.hasParam("KW") ? Arrays.asList(sa.getParam("KW").split(" & ")) : new ArrayList<String>(); final String numDefense = sa.hasParam("NumDef") ? sa.getParam("NumDef") : ""; final String numAttack = sa.hasParam("NumAtt") ? sa.getParam("NumAtt") : ""; if (!ComputerUtilCost.checkLifeCost(ai, cost, sa.getHostCard(), 4, null)) { return false; } if (!ComputerUtilCost.checkDiscardCost(ai, cost, sa.getHostCard())) { return false; } if (!ComputerUtilCost.checkCreatureSacrificeCost(ai, cost, sa.getHostCard())) { return false; } if (!ComputerUtilCost.checkRemoveCounterCost(cost, sa.getHostCard())) { return false; } if (!ComputerUtilCost.checkTapTypeCost(ai, cost, sa.getHostCard())) { return false; } if (game.getStack().isEmpty() && hasTapCost(cost, sa.getHostCard())) { if (ph.getPhase().isBefore(PhaseType.COMBAT_DECLARE_ATTACKERS) && ph.isPlayerTurn(ai)) { return false; } if (ph.getPhase().isBefore(PhaseType.COMBAT_DECLARE_BLOCKERS) && ph.isPlayerTurn(ai.getOpponent())) { return false; } } if (ComputerUtil.preventRunAwayActivations(sa)) { return false; } // Phase Restrictions if (game.getStack().isEmpty() && ph.getPhase().isBefore(PhaseType.COMBAT_BEGIN)) { // Instant-speed pumps should not be cast outside of combat when the // stack is empty if (!sa.isCurse() && !SpellAbilityAi.isSorcerySpeed(sa)) { return false; } } else if (!game.getStack().isEmpty() && !sa.isCurse()) { return pumpAgainstRemoval(ai, sa); } if (sa.hasParam("ActivationNumberSacrifice")) { final SpellAbilityRestriction restrict = sa.getRestrictions(); final int sacActivations = Integer.parseInt(sa.getParam("ActivationNumberSacrifice").substring(2)); final int activations = restrict.getNumberTurnActivations(); // don't risk sacrificing a creature just to pump it if (activations >= sacActivations - 1) { return false; } } final Card source = sa.getHostCard(); if (source.getSVar("X").equals("Count$xPaid")) { source.setSVar("PayX", ""); } int defense; if (numDefense.contains("X") && source.getSVar("X").equals("Count$xPaid")) { // Set PayX here to maximum value. final int xPay = ComputerUtilMana.determineLeftoverMana(sa, ai); source.setSVar("PayX", Integer.toString(xPay)); defense = xPay; if (numDefense.equals("-X")) { defense = -xPay; } } else { defense = AbilityUtils.calculateAmount(sa.getHostCard(), numDefense, sa); } int attack; if (numAttack.contains("X") && source.getSVar("X").equals("Count$xPaid")) { // Set PayX here to maximum value. final String toPay = source.getSVar("PayX"); if (toPay.equals("")) { final int xPay = ComputerUtilMana.determineLeftoverMana(sa, ai); source.setSVar("PayX", Integer.toString(xPay)); attack = xPay; } else { attack = Integer.parseInt(toPay); } } else { attack = AbilityUtils.calculateAmount(sa.getHostCard(), numAttack, sa); } if ((numDefense.contains("X") && defense == 0) || (numAttack.contains("X") && attack == 0)) { return false; } // Untargeted if ((sa.getTargetRestrictions() == null) || !sa.getTargetRestrictions().doesTarget()) { final List<Card> cards = AbilityUtils.getDefinedCards(sa.getHostCard(), sa.getParam("Defined"), sa); if (cards.size() == 0) { return false; } // when this happens we need to expand AI to consider if its ok for // everything? for (final Card card : cards) { if (sa.isCurse()) { if (!card.getController().isOpponentOf(ai)) { return false; } if (!containsUsefulKeyword(ai, keywords, card, sa, attack)) { continue; } return true; } if (!card.getController().isOpponentOf(ai) && shouldPumpCard(ai, sa, card, defense, attack, keywords)) { return true; } } return false; } // Targeted if (!this.pumpTgtAI(ai, sa, defense, attack, false)) { return false; } return true; } // pumpPlayAI()
private boolean pumpMandatoryTarget( final Player ai, final SpellAbility sa, final boolean mandatory) { final Game game = ai.getGame(); List<Card> list = game.getCardsIn(ZoneType.Battlefield); final TargetRestrictions tgt = sa.getTargetRestrictions(); final Player opp = ai.getOpponent(); list = CardLists.getValidCards( list, tgt.getValidTgts(), sa.getActivatingPlayer(), sa.getHostCard()); list = CardLists.getTargetableCards(list, sa); if (list.size() < tgt.getMinTargets(sa.getHostCard(), sa)) { sa.resetTargets(); return false; } // Remove anything that's already been targeted for (final Card c : sa.getTargets().getTargetCards()) { list.remove(c); } List<Card> pref; List<Card> forced; final Card source = sa.getHostCard(); if (sa.isCurse()) { pref = CardLists.filterControlledBy(list, opp); forced = CardLists.filterControlledBy(list, ai); } else { pref = CardLists.filterControlledBy(list, ai); forced = CardLists.filterControlledBy(list, opp); } while (sa.getTargets().getNumTargeted() < tgt.getMaxTargets(source, sa)) { if (pref.isEmpty()) { break; } Card c; if (CardLists.getNotType(pref, "Creature").isEmpty()) { c = ComputerUtilCard.getBestCreatureAI(pref); } else { c = ComputerUtilCard.getMostExpensivePermanentAI(pref, sa, true); } pref.remove(c); sa.getTargets().add(c); } while (sa.getTargets().getNumTargeted() < tgt.getMinTargets(source, sa)) { if (forced.isEmpty()) { break; } Card c; if (CardLists.getNotType(forced, "Creature").isEmpty()) { c = ComputerUtilCard.getWorstCreatureAI(forced); } else { c = ComputerUtilCard.getCheapestPermanentAI(forced, sa, true); } forced.remove(c); sa.getTargets().add(c); } if (sa.getTargets().getNumTargeted() < tgt.getMinTargets(source, sa)) { sa.resetTargets(); return false; } return true; } // pumpMandatoryTarget()
private boolean pumpTgtAI( final Player ai, final SpellAbility sa, final int defense, final int attack, final boolean mandatory) { final List<String> keywords = sa.hasParam("KW") ? Arrays.asList(sa.getParam("KW").split(" & ")) : new ArrayList<String>(); final Game game = ai.getGame(); final Card source = sa.getHostCard(); if (!mandatory && !sa.isTrigger() && game.getPhaseHandler().getPhase().isAfter(PhaseType.COMBAT_DECLARE_BLOCKERS) && !(sa.isCurse() && defense < 0) && !this.containsNonCombatKeyword(keywords) && !sa.hasParam("UntilYourNextTurn")) { return false; } final Player opp = ai.getOpponent(); final TargetRestrictions tgt = sa.getTargetRestrictions(); sa.resetTargets(); if (sa.hasParam("TargetingPlayer") && sa.getActivatingPlayer().equals(ai) && !sa.isTrigger()) { Player targetingPlayer = AbilityUtils.getDefinedPlayers(source, sa.getParam("TargetingPlayer"), sa).get(0); sa.setTargetingPlayer(targetingPlayer); return targetingPlayer.getController().chooseTargetsFor(sa); } List<Card> list = new ArrayList<Card>(); if (sa.hasParam("AILogic")) { if (sa.getParam("AILogic").equals("HighestPower")) { list = CardLists.getValidCards( CardLists.filter(game.getCardsIn(ZoneType.Battlefield), Presets.CREATURES), tgt.getValidTgts(), ai, source); list = CardLists.getTargetableCards(list, sa); CardLists.sortByPowerDesc(list); if (!list.isEmpty()) { sa.getTargets().add(list.get(0)); return true; } else { return false; } } if (sa.getParam("AILogic").equals("Fight") || sa.getParam("AILogic").equals("PowerDmg")) { final AbilitySub tgtFight = sa.getSubAbility(); List<Card> aiCreatures = ai.getCreaturesInPlay(); aiCreatures = CardLists.getTargetableCards(aiCreatures, sa); aiCreatures = ComputerUtil.getSafeTargets(ai, sa, aiCreatures); ComputerUtilCard.sortByEvaluateCreature(aiCreatures); // sort is suboptimal due to conflicting needs depending on game state: // -deathtouch for deal damage // -max power for damage to player // -survivability for generic "fight" // -no support for "heroic" List<Card> humCreatures = ai.getOpponent().getCreaturesInPlay(); humCreatures = CardLists.getTargetableCards(humCreatures, tgtFight); ComputerUtilCard.sortByEvaluateCreature(humCreatures); if (humCreatures.isEmpty() || aiCreatures.isEmpty()) { return false; } int buffedAtk = attack, buffedDef = defense; for (Card humanCreature : humCreatures) { for (Card aiCreature : aiCreatures) { if (sa.isSpell()) { // heroic triggers adding counters for (Trigger t : aiCreature.getTriggers()) { if (t.getMode() == TriggerType.SpellCast) { final Map<String, String> params = t.getMapParams(); if ("Card.Self".equals(params.get("TargetsValid")) && "You".equals(params.get("ValidActivatingPlayer")) && params.containsKey("Execute")) { SpellAbility heroic = AbilityFactory.getAbility( aiCreature.getSVar(params.get("Execute")), aiCreature); if ("Self".equals(heroic.getParam("Defined")) && "P1P1".equals(heroic.getParam("CounterType"))) { int amount = AbilityUtils.calculateAmount( aiCreature, heroic.getParam("CounterNum"), heroic); buffedAtk += amount; buffedDef += amount; } break; } } } } if (sa.getParam("AILogic").equals("PowerDmg")) { if (FightAi.canKill(aiCreature, humanCreature, buffedAtk)) { sa.getTargets().add(aiCreature); tgtFight.getTargets().add(humanCreature); return true; } } else { if (FightAi.shouldFight(aiCreature, humanCreature, buffedAtk, buffedDef)) { sa.getTargets().add(aiCreature); tgtFight.getTargets().add(humanCreature); return true; } } } } } return false; } else if (sa.isCurse()) { if (sa.canTarget(opp)) { sa.getTargets().add(opp); return true; } list = this.getCurseCreatures(ai, sa, defense, attack, keywords); } else { if (!tgt.canTgtCreature()) { ZoneType zone = tgt.getZone().get(0); list = game.getCardsIn(zone); } else { list = this.getPumpCreatures(ai, sa, defense, attack, keywords); } if (sa.canTarget(ai)) { sa.getTargets().add(ai); return true; } } list = CardLists.getValidCards(list, tgt.getValidTgts(), ai, source); if (game.getStack().isEmpty()) { // If the cost is tapping, don't activate before declare // attack/block if (sa.getPayCosts() != null && sa.getPayCosts().hasTapCost()) { if (game.getPhaseHandler().getPhase().isBefore(PhaseType.COMBAT_DECLARE_ATTACKERS) && game.getPhaseHandler().isPlayerTurn(ai)) { list.remove(sa.getHostCard()); } if (game.getPhaseHandler().getPhase().isBefore(PhaseType.COMBAT_DECLARE_BLOCKERS) && game.getPhaseHandler().isPlayerTurn(opp)) { list.remove(sa.getHostCard()); } } } if (list.isEmpty()) { return mandatory && this.pumpMandatoryTarget(ai, sa, mandatory); } if (!sa.isCurse()) { // Don't target cards that will die. list = ComputerUtil.getSafeTargets(ai, sa, list); } while (sa.getTargets().getNumTargeted() < tgt.getMaxTargets(source, sa)) { Card t = null; // boolean goodt = false; if (list.isEmpty()) { if ((sa.getTargets().getNumTargeted() < tgt.getMinTargets(source, sa)) || (sa.getTargets().getNumTargeted() == 0)) { if (mandatory) { return this.pumpMandatoryTarget(ai, sa, mandatory); } sa.resetTargets(); return false; } else { // TODO is this good enough? for up to amounts? break; } } t = ComputerUtilCard.getBestAI(list); // option to hold removal instead only applies for single targeted removal if (!sa.isTrigger() && tgt.getMaxTargets(source, sa) == 1 && sa.isCurse()) { if (!ComputerUtilCard.useRemovalNow(sa, t, -defense, ZoneType.Graveyard)) { return false; } } sa.getTargets().add(t); list.remove(t); } return true; } // pumpTgtAI()
@Override protected boolean canPlayAI(Player ai, SpellAbility sa) { final TargetRestrictions tgt = sa.getTargetRestrictions(); final Card source = sa.getHostCard(); final Game game = source.getGame(); boolean useAbility = true; // if (card.getController().isComputer()) { // final List<Card> creatures = AllZoneUtil.getCreaturesInPlay(); // if (!creatures.isEmpty()) { // cardToCopy = CardFactoryUtil.getBestCreatureAI(creatures); // } // } // TODO - add some kind of check to answer // "Am I going to attack with this?" // TODO - add some kind of check for during human turn to answer // "Can I use this to block something?" PhaseHandler phase = game.getPhaseHandler(); // don't use instant speed clone abilities outside computers // Combat_Begin step if (!phase.is(PhaseType.COMBAT_BEGIN) && phase.isPlayerTurn(ai) && !SpellAbilityAi.isSorcerySpeed(sa) && !sa.hasParam("ActivationPhases") && !sa.hasParam("Permanent")) { return false; } // don't use instant speed clone abilities outside humans // Combat_Declare_Attackers_InstantAbility step if (!phase.is(PhaseType.COMBAT_DECLARE_ATTACKERS) || phase.isPlayerTurn(ai) || game.getCombat().getAttackers().isEmpty()) { return false; } // don't activate during main2 unless this effect is permanent if (phase.is(PhaseType.MAIN2) && !sa.hasParam("Permanent")) { return false; } if (null == tgt) { final List<Card> defined = AbilityUtils.getDefinedCards(source, sa.getParam("Defined"), sa); boolean bFlag = false; for (final Card c : defined) { bFlag |= (!c.isCreature() && !c.isTapped() && !(c.getTurnInZone() == phase.getTurn())); // for creatures that could be improved (like Figure of Destiny) if (c.isCreature() && (sa.hasParam("Permanent") || (!c.isTapped() && !c.isSick()))) { int power = -5; if (sa.hasParam("Power")) { power = AbilityUtils.calculateAmount(source, sa.getParam("Power"), sa); } int toughness = -5; if (sa.hasParam("Toughness")) { toughness = AbilityUtils.calculateAmount(source, sa.getParam("Toughness"), sa); } if ((power + toughness) > (c.getCurrentPower() + c.getCurrentToughness())) { bFlag = true; } } } if (!bFlag) { // All of the defined stuff is cloned, not very // useful return false; } } else { sa.resetTargets(); useAbility &= cloneTgtAI(sa); } return useAbility; } // end cloneCanPlayAI()
@Override public void resolve(final SpellAbility sa) { final Card host = sa.getHostCard(); final Map<String, String> svars = host.getSVars(); // AF specific sa int power = -1; if (sa.hasParam("Power")) { power = AbilityUtils.calculateAmount(host, sa.getParam("Power"), sa); } int toughness = -1; if (sa.hasParam("Toughness")) { toughness = AbilityUtils.calculateAmount(host, sa.getParam("Toughness"), sa); } final Game game = sa.getActivatingPlayer().getGame(); // Every Animate event needs a unique time stamp final long timestamp = game.getNextTimestamp(); final boolean permanent = sa.hasParam("Permanent"); final CardType types = new CardType(); if (sa.hasParam("Types")) { types.addAll(Arrays.asList(sa.getParam("Types").split(","))); } final CardType removeTypes = new CardType(); if (sa.hasParam("RemoveTypes")) { removeTypes.addAll(Arrays.asList(sa.getParam("RemoveTypes").split(","))); } // allow ChosenType - overrides anything else specified if (types.hasSubtype("ChosenType")) { types.clear(); types.add(host.getChosenType()); } final List<String> keywords = new ArrayList<String>(); if (sa.hasParam("Keywords")) { keywords.addAll(Arrays.asList(sa.getParam("Keywords").split(" & "))); } final List<String> removeKeywords = new ArrayList<String>(); if (sa.hasParam("RemoveKeywords")) { removeKeywords.addAll(Arrays.asList(sa.getParam("RemoveKeywords").split(" & "))); } final List<String> hiddenKeywords = new ArrayList<String>(); if (sa.hasParam("HiddenKeywords")) { hiddenKeywords.addAll(Arrays.asList(sa.getParam("HiddenKeywords").split(" & "))); } // allow SVar substitution for keywords for (int i = 0; i < keywords.size(); i++) { final String k = keywords.get(i); if (svars.containsKey(k)) { keywords.add(svars.get(k)); keywords.remove(k); } } // colors to be added or changed to String tmpDesc = ""; if (sa.hasParam("Colors")) { final String colors = sa.getParam("Colors"); if (colors.equals("ChosenColor")) { tmpDesc = CardUtil.getShortColorsString(host.getChosenColors()); } else { tmpDesc = CardUtil.getShortColorsString(new ArrayList<String>(Arrays.asList(colors.split(",")))); } } final String finalDesc = tmpDesc; // abilities to add to the animated being final List<String> abilities = new ArrayList<String>(); if (sa.hasParam("Abilities")) { abilities.addAll(Arrays.asList(sa.getParam("Abilities").split(","))); } // replacement effects to add to the animated being final List<String> replacements = new ArrayList<String>(); if (sa.hasParam("Replacements")) { replacements.addAll(Arrays.asList(sa.getParam("Replacements").split(","))); } // triggers to add to the animated being final List<String> triggers = new ArrayList<String>(); if (sa.hasParam("Triggers")) { triggers.addAll(Arrays.asList(sa.getParam("Triggers").split(","))); } // sVars to add to the animated being final List<String> sVars = new ArrayList<String>(); if (sa.hasParam("sVars")) { sVars.addAll(Arrays.asList(sa.getParam("sVars").split(","))); } String valid = ""; if (sa.hasParam("ValidCards")) { valid = sa.getParam("ValidCards"); } CardCollectionView list; List<Player> tgtPlayers = getTargetPlayers(sa); if (!sa.usesTargeting() && !sa.hasParam("Defined")) { list = game.getCardsIn(ZoneType.Battlefield); } else { list = tgtPlayers.get(0).getCardsIn(ZoneType.Battlefield); } list = CardLists.getValidCards(list, valid.split(","), host.getController(), host); for (final Card c : list) { doAnimate( c, sa, power, toughness, types, removeTypes, finalDesc, keywords, removeKeywords, hiddenKeywords, timestamp); // give abilities final List<SpellAbility> addedAbilities = new ArrayList<SpellAbility>(); if (abilities.size() > 0) { for (final String s : abilities) { final String actualAbility = host.getSVar(s); final SpellAbility grantedAbility = AbilityFactory.getAbility(actualAbility, c); addedAbilities.add(grantedAbility); c.addSpellAbility(grantedAbility); } } // remove abilities final List<SpellAbility> removedAbilities = new ArrayList<SpellAbility>(); if (sa.hasParam("OverwriteAbilities") || sa.hasParam("RemoveAllAbilities")) { for (final SpellAbility ab : c.getSpellAbilities()) { if (ab.isAbility()) { c.removeSpellAbility(ab); removedAbilities.add(ab); } } } // give replacement effects final List<ReplacementEffect> addedReplacements = new ArrayList<ReplacementEffect>(); if (replacements.size() > 0) { for (final String s : replacements) { final String actualReplacement = host.getSVar(s); final ReplacementEffect parsedReplacement = ReplacementHandler.parseReplacement(actualReplacement, c, false); addedReplacements.add(c.addReplacementEffect(parsedReplacement)); } } // Grant triggers final List<Trigger> addedTriggers = new ArrayList<Trigger>(); if (triggers.size() > 0) { for (final String s : triggers) { final String actualTrigger = host.getSVar(s); final Trigger parsedTrigger = TriggerHandler.parseTrigger(actualTrigger, c, false); addedTriggers.add(c.addTrigger(parsedTrigger)); } } // suppress triggers from the animated card final List<Trigger> removedTriggers = new ArrayList<Trigger>(); if (sa.hasParam("OverwriteTriggers") || sa.hasParam("RemoveAllAbilities")) { final FCollectionView<Trigger> triggersToRemove = c.getTriggers(); for (final Trigger trigger : triggersToRemove) { trigger.setSuppressed(true); removedTriggers.add(trigger); } } // suppress static abilities from the animated card final List<StaticAbility> removedStatics = new ArrayList<StaticAbility>(); if (sa.hasParam("OverwriteStatics") || sa.hasParam("RemoveAllAbilities")) { final FCollectionView<StaticAbility> staticsToRemove = c.getStaticAbilities(); for (final StaticAbility stAb : staticsToRemove) { stAb.setTemporarilySuppressed(true); removedStatics.add(stAb); } } // suppress static abilities from the animated card final List<ReplacementEffect> removedReplacements = new ArrayList<ReplacementEffect>(); if (sa.hasParam("OverwriteReplacements") || sa.hasParam("RemoveAllAbilities")) { final FCollectionView<ReplacementEffect> replacementsToRemove = c.getReplacementEffects(); for (final ReplacementEffect re : replacementsToRemove) { re.setTemporarilySuppressed(true); removedReplacements.add(re); } } // give sVars if (sVars.size() > 0) { for (final String s : sVars) { final String actualsVar = host.getSVar(s); c.setSVar(s, actualsVar); } } game.fireEvent(new GameEventCardStatsChanged(c)); final GameCommand unanimate = new GameCommand() { private static final long serialVersionUID = -5861759814760561373L; @Override public void run() { doUnanimate( c, sa, finalDesc, hiddenKeywords, addedAbilities, addedTriggers, addedReplacements, false, removedAbilities, timestamp); // give back suppressed triggers for (final Trigger t : removedTriggers) { t.setSuppressed(false); } // give back suppressed static abilities for (final StaticAbility s : removedStatics) { s.setTemporarilySuppressed(false); } // give back suppressed replacement effects for (final ReplacementEffect re : removedReplacements) { re.setTemporarilySuppressed(false); } game.fireEvent(new GameEventCardStatsChanged(c)); } }; if (!permanent) { if (sa.hasParam("UntilEndOfCombat")) { game.getEndOfCombat().addUntil(unanimate); } else { game.getEndOfTurn().addUntil(unanimate); } } } } // animateAllResolve
@Override public void resolve(SpellAbility sa) { final Card host = sa.getHostCard(); final Player player = sa.getActivatingPlayer(); final Game game = player.getGame(); Player chooser = player; int numToDig = AbilityUtils.calculateAmount(host, sa.getParam("DigNum"), sa); final ZoneType srcZone = sa.hasParam("SourceZone") ? ZoneType.smartValueOf(sa.getParam("SourceZone")) : ZoneType.Library; final ZoneType destZone1 = sa.hasParam("DestinationZone") ? ZoneType.smartValueOf(sa.getParam("DestinationZone")) : ZoneType.Hand; final ZoneType destZone2 = sa.hasParam("DestinationZone2") ? ZoneType.smartValueOf(sa.getParam("DestinationZone2")) : ZoneType.Library; int libraryPosition = sa.hasParam("LibraryPosition") ? Integer.parseInt(sa.getParam("LibraryPosition")) : -1; int destZone1ChangeNum = 1; final boolean mitosis = sa.hasParam("Mitosis"); String changeValid = sa.hasParam("ChangeValid") ? sa.getParam("ChangeValid") : ""; // andOrValid is for cards with "creature card and/or a land card" String andOrValid = sa.hasParam("AndOrValid") ? sa.getParam("AndOrValid") : ""; final boolean anyNumber = sa.hasParam("AnyNumber"); final int libraryPosition2 = sa.hasParam("LibraryPosition2") ? Integer.parseInt(sa.getParam("LibraryPosition2")) : -1; final boolean optional = sa.hasParam("Optional"); final boolean noMove = sa.hasParam("NoMove"); final boolean skipReorder = sa.hasParam("SkipReorder"); // A hack for cards like Explorer's Scope that need to ensure that a card is revealed to the // player activating the ability final boolean forceRevealToController = sa.hasParam("ForceRevealToController"); // These parameters are used to indicate that a dialog box must be show to the player asking if // the player wants to proceed // with an optional ability, otherwise the optional ability is skipped. final boolean mayBeSkipped = sa.hasParam("PromptToSkipOptionalAbility"); final String optionalAbilityPrompt = sa.hasParam("OptionalAbilityPrompt") ? sa.getParam("OptionalAbilityPrompt") : ""; boolean changeAll = false; boolean allButOne = false; final List<String> keywords = new ArrayList<String>(); if (sa.hasParam("Keywords")) { keywords.addAll(Arrays.asList(sa.getParam("Keywords").split(" & "))); } if (sa.hasParam("ChangeNum")) { if (sa.getParam("ChangeNum").equalsIgnoreCase("All")) { changeAll = true; } else if (sa.getParam("ChangeNum").equalsIgnoreCase("AllButOne")) { allButOne = true; } else { destZone1ChangeNum = AbilityUtils.calculateAmount(host, sa.getParam("ChangeNum"), sa); } } final TargetRestrictions tgt = sa.getTargetRestrictions(); final List<Player> tgtPlayers = getTargetPlayers(sa); if (sa.hasParam("Choser")) { final List<Player> choosers = AbilityUtils.getDefinedPlayers(sa.getHostCard(), sa.getParam("Choser"), sa); if (!choosers.isEmpty()) { chooser = choosers.get(0); } } for (final Player p : tgtPlayers) { if (tgt != null && !p.canBeTargetedBy(sa)) { continue; } final CardCollection top = new CardCollection(); final CardCollection rest = new CardCollection(); final PlayerZone sourceZone = p.getZone(srcZone); numToDig = Math.min(numToDig, sourceZone.size()); for (int i = 0; i < numToDig; i++) { top.add(sourceZone.get(i)); } if (!top.isEmpty()) { DelayedReveal delayedReveal = null; boolean hasRevealed = true; if (sa.hasParam("Reveal")) { game.getAction().reveal(top, p, false); } else if (sa.hasParam("RevealOptional")) { String question = "Reveal: " + Lang.joinHomogenous(top) + "?"; hasRevealed = p.getController().confirmAction(sa, null, question); if (hasRevealed) { game.getAction().reveal(top, p); } } else if (sa.hasParam("RevealValid")) { final String revealValid = sa.getParam("RevealValid"); final CardCollection toReveal = CardLists.getValidCards(top, revealValid, host.getController(), host); if (!toReveal.isEmpty()) { game.getAction().reveal(toReveal, host.getController()); if (sa.hasParam("RememberRevealed")) { for (final Card one : toReveal) { host.addRemembered(one); } } } // Singletons.getModel().getGameAction().revealToCopmuter(top.toArray()); // - for when it exists } else if (!sa.hasParam("NoLooking")) { // show the user the revealed cards delayedReveal = new DelayedReveal(top, srcZone, PlayerView.get(p)); if (noMove) { // Let the activating player see the cards even if they're not moved game.getAction().revealTo(top, player); } } if (sa.hasParam("RememberRevealed") && !sa.hasParam("RevealValid") && hasRevealed) { for (final Card one : top) { host.addRemembered(one); } } if (!noMove) { CardCollection movedCards; CardCollection andOrCards; for (final Card c : top) { rest.add(c); } CardCollection valid; if (mitosis) { valid = sharesNameWithCardOnBattlefield(game, top); andOrCards = new CardCollection(); } else if (!changeValid.isEmpty()) { if (changeValid.contains("ChosenType")) { changeValid = changeValid.replace("ChosenType", host.getChosenType()); } valid = CardLists.getValidCards(top, changeValid.split(","), host.getController(), host); if (!andOrValid.equals("")) { andOrCards = CardLists.getValidCards(top, andOrValid.split(","), host.getController(), host); andOrCards.removeAll((Collection<?>) valid); valid.addAll(andOrCards); } else { andOrCards = new CardCollection(); } } else { valid = top; andOrCards = new CardCollection(); } if (forceRevealToController) { // Force revealing the card to the player activating the ability (e.g. Explorer's Scope) game.getAction().revealTo(top, player); } // Optional abilities that use a dialog box to prompt the user to skip the ability (e.g. // Explorer's Scope, Quest for Ula's Temple) if (optional && mayBeSkipped && !valid.isEmpty()) { String prompt = !optionalAbilityPrompt.isEmpty() ? optionalAbilityPrompt : "Would you like to proceed with the optional ability for " + sa.getHostCard() + "?\n\n(" + sa.getDescription() + ")"; if (!p.getController() .confirmAction(sa, null, prompt.replace("CARDNAME", sa.getHostCard().getName()))) { return; } } if (changeAll) { movedCards = new CardCollection(valid); } else if (sa.hasParam("RandomChange")) { int numChanging = Math.min(destZone1ChangeNum, valid.size()); movedCards = CardLists.getRandomSubList(valid, numChanging); } else if (allButOne) { movedCards = new CardCollection(valid); String prompt; if (destZone2.equals(ZoneType.Library) && libraryPosition2 == 0) { prompt = "Choose a card to leave on top of {player's} library"; } else { prompt = "Choose a card to leave in {player's} " + destZone2.name(); } Card chosen = chooser .getController() .chooseSingleEntityForEffect(valid, delayedReveal, sa, prompt, false, p); movedCards.remove(chosen); if (sa.hasParam("RandomOrder")) { CardLists.shuffle(movedCards); } } else { int j = 0; String prompt; if (sa.hasParam("PrimaryPrompt")) { prompt = sa.getParam("PrimaryPrompt"); } else { prompt = "Choose a card to put into " + destZone1.name(); if (destZone1.equals(ZoneType.Library)) { if (libraryPosition == -1) { prompt = "Choose a card to put on the bottom of {player's} library"; } else if (libraryPosition == 0) { prompt = "Choose a card to put on top of {player's} library"; } } } movedCards = new CardCollection(); while (j < destZone1ChangeNum || (anyNumber && j < numToDig)) { // let user get choice Card chosen = null; if (!valid.isEmpty()) { chosen = chooser .getController() .chooseSingleEntityForEffect( valid, delayedReveal, sa, prompt, anyNumber || optional, p); } else { chooser.getController().notifyOfValue(sa, null, "No valid cards"); } if (chosen == null) { break; } movedCards.add(chosen); valid.remove(chosen); if (!andOrValid.equals("")) { andOrCards.remove(chosen); if (!chosen.isValid(andOrValid.split(","), host.getController(), host)) { valid = new CardCollection(andOrCards); } else if (!chosen.isValid(changeValid.split(","), host.getController(), host)) { valid.removeAll((Collection<?>) andOrCards); } } j++; } if (!changeValid.isEmpty()) { game.getAction() .reveal( movedCards, chooser, true, chooser + " picked " + (movedCards.size() == 1 ? "this card" : "these cards") + " from "); } } if (sa.hasParam("ForgetOtherRemembered")) { host.clearRemembered(); } Collections.reverse(movedCards); for (Card c : movedCards) { final PlayerZone zone = c.getOwner().getZone(destZone1); if (zone.is(ZoneType.Library) || zone.is(ZoneType.PlanarDeck) || zone.is(ZoneType.SchemeDeck)) { if (libraryPosition == -1 || libraryPosition > zone.size()) { libraryPosition = zone.size(); } c = game.getAction().moveTo(zone, c, libraryPosition); } else { c = game.getAction().moveTo(zone, c); if (destZone1.equals(ZoneType.Battlefield)) { for (final String kw : keywords) { c.addExtrinsicKeyword(kw); } if (sa.hasParam("Tapped")) { c.setTapped(true); } } } if (sa.hasParam("ExileFaceDown")) { c.setState(CardStateName.FaceDown, true); } if (sa.hasParam("Imprint")) { host.addImprintedCard(c); } if (sa.hasParam("ForgetOtherRemembered")) { host.clearRemembered(); } if (sa.hasParam("RememberChanged")) { host.addRemembered(c); } rest.remove(c); } // now, move the rest to destZone2 if (destZone2 == ZoneType.Library || destZone2 == ZoneType.PlanarDeck || destZone2 == ZoneType.SchemeDeck) { CardCollection afterOrder = rest; if (sa.hasParam("RestRandomOrder")) { CardLists.shuffle(afterOrder); } else if (!skipReorder && rest.size() > 1) { afterOrder = (CardCollection) chooser.getController().orderMoveToZoneList(rest, destZone2); } if (libraryPosition2 != -1) { // Closest to top Collections.reverse(afterOrder); } for (final Card c : afterOrder) { if (destZone2 == ZoneType.Library) { game.getAction().moveToLibrary(c, libraryPosition2); } else { game.getAction().moveToVariantDeck(c, destZone2, libraryPosition2); } } } else { // just move them randomly for (int i = 0; i < rest.size(); i++) { Card c = rest.get(i); final PlayerZone toZone = c.getOwner().getZone(destZone2); c = game.getAction().moveTo(toZone, c); if (destZone2.equals(ZoneType.Battlefield) && !keywords.isEmpty()) { for (final String kw : keywords) { c.addExtrinsicKeyword(kw); } } } } } } } }
/** {@inheritDoc} */ @Override public final boolean performTest(final java.util.Map<String, Object> runParams2) { final SpellAbility spellAbility = (SpellAbility) runParams2.get("CastSA"); if (spellAbility == null) { System.out.println( "TriggerSpellAbilityCast performTest encountered spellAbility == null. runParams2 = " + runParams2); return false; } final Card cast = spellAbility.getHostCard(); final Game game = cast.getGame(); final SpellAbilityStackInstance si = game.getStack().getInstanceFromSpellAbility(spellAbility); if (this.getMode() == TriggerType.SpellCast) { if (!spellAbility.isSpell()) { return false; } } else if (this.getMode() == TriggerType.AbilityCast) { if (!spellAbility.isAbility()) { return false; } } else if (this.getMode() == TriggerType.SpellAbilityCast) { // Empty block for readability. } if (this.mapParams.containsKey("ActivatedOnly")) { if (spellAbility.isTrigger()) { return false; } } if (this.mapParams.containsKey("ValidControllingPlayer")) { if (!matchesValid( cast.getController(), this.mapParams.get("ValidControllingPlayer").split(","), this.getHostCard())) { return false; } } if (this.mapParams.containsKey("ValidActivatingPlayer")) { if (si == null || !matchesValid( si.getSpellAbility(true).getActivatingPlayer(), this.mapParams.get("ValidActivatingPlayer").split(","), this.getHostCard())) { return false; } if (this.mapParams.containsKey("ActivatorThisTurnCast")) { String compare = this.mapParams.get("ActivatorThisTurnCast"); List<Card> thisTurnCast = CardUtil.getThisTurnCast( this.mapParams.containsKey("ValidCard") ? this.mapParams.get("ValidCard") : "Card", this.getHostCard()); thisTurnCast = CardLists.filterControlledBy( thisTurnCast, si.getSpellAbility(true).getActivatingPlayer()); int left = thisTurnCast.size(); int right = Integer.parseInt(compare.substring(2)); if (!Expressions.compare(left, compare, right)) { return false; } } } if (this.mapParams.containsKey("ValidCard")) { if (!matchesValid(cast, this.mapParams.get("ValidCard").split(","), this.getHostCard())) { return false; } } if (this.mapParams.containsKey("TargetsValid")) { SpellAbility sa = spellAbility; if (si != null) { sa = si.getSpellAbility(true); } boolean validTgtFound = false; while (sa != null && !validTgtFound) { for (final Card tgt : sa.getTargets().getTargetCards()) { if (tgt.isValid( this.mapParams.get("TargetsValid").split(","), this.getHostCard().getController(), this.getHostCard())) { validTgtFound = true; break; } } for (final Player p : sa.getTargets().getTargetPlayers()) { if (matchesValid(p, this.mapParams.get("TargetsValid").split(","), this.getHostCard())) { validTgtFound = true; break; } } sa = sa.getSubAbility(); } if (!validTgtFound) { return false; } } if (this.mapParams.containsKey("NonTapCost")) { final Cost cost = (Cost) (runParams2.get("Cost")); if (cost.hasTapCost()) { return false; } } if (this.mapParams.containsKey("Conspire")) { if (!spellAbility.isOptionalCostPaid(OptionalCost.Conspire)) { return false; } if (spellAbility.getConspireInstances() == 0) { return false; } else { spellAbility.subtractConspireInstance(); // System.out.println("Conspire instances left = " + spellAbility.getConspireInstances()); } } if (this.mapParams.containsKey("Outlast")) { if (!spellAbility.isOutlast()) { return false; } } if (this.mapParams.containsKey("IsSingleTarget")) { int numTargeted = 0; for (TargetChoices tc : spellAbility.getAllTargetChoices()) { numTargeted += tc.getNumTargeted(); } if (numTargeted != 1) { return false; } } if (this.mapParams.containsKey("SpellSpeed")) { if (this.mapParams.get("SpellSpeed").equals("NotSorcerySpeed")) { if (this.getHostCard().getController().couldCastSorcery(spellAbility)) { return false; } if (this.getHostCard() .hasKeyword( "You may cast CARDNAME as though it had flash. If you cast it any time a " + "sorcery couldn't have been cast, the controller of the permanent it becomes sacrifices it at the beginning" + " of the next cleanup step.")) { // for these cards the trigger must only fire if using their own ability to cast at // instant speed if (this.getHostCard().hasKeyword("Flash") || this.getHostCard() .getController() .hasKeyword("You may cast nonland cards as though they had flash.")) { return false; } } return true; } } return true; }
/* (non-Javadoc) * @see forge.card.abilityfactory.SpellEffect#resolve(java.util.Map, forge.card.spellability.SpellAbility) */ @Override public void resolve(final SpellAbility sa) { final Card source = sa.getHostCard(); final Game game = source.getGame(); game.reverseTurnOrder(); }
@Override public void resolve(SpellAbility sa) { final Card card = sa.getHostCard(); final Game game = card.getGame(); final boolean remDestroyed = sa.hasParam("RememberDestroyed"); final boolean remAttached = sa.hasParam("RememberAttached"); if (remDestroyed || remAttached) { card.clearRemembered(); } final boolean noRegen = sa.hasParam("NoRegen"); final boolean sac = sa.hasParam("Sacrifice"); final List<Card> tgtCards = getTargetCards(sa); final List<Card> untargetedCards = new ArrayList<Card>(); final TargetRestrictions tgt = sa.getTargetRestrictions(); if (sa.hasParam("Radiance")) { for (final Card c : CardUtil.getRadiance(card, tgtCards.get(0), sa.getParam("ValidTgts").split(","))) { untargetedCards.add(c); } } for (final Card tgtC : tgtCards) { if (tgtC.isInPlay() && ((tgt == null) || tgtC.canBeTargetedBy(sa))) { boolean destroyed = false; final Card lki = CardUtil.getLKICopy(tgtC); if (remAttached) { card.addRemembered(tgtC.getEnchantedBy(false)); card.addRemembered(tgtC.getEquippedBy(false)); card.addRemembered(tgtC.getFortifiedBy(false)); } if (sac) { destroyed = game.getAction().sacrifice(tgtC, sa) != null; } else if (noRegen) { destroyed = game.getAction().destroyNoRegeneration(tgtC, sa); } else { destroyed = game.getAction().destroy(tgtC, sa); } if (destroyed && remDestroyed) { card.addRemembered(tgtC); } if (destroyed && sa.hasParam("RememberLKI")) { card.addRemembered(lki); } } } for (final Card unTgtC : untargetedCards) { if (unTgtC.isInPlay()) { boolean destroyed = false; if (sac) { destroyed = game.getAction().sacrifice(unTgtC, sa) != null; } else if (noRegen) { destroyed = game.getAction().destroyNoRegeneration(unTgtC, sa); } else { destroyed = game.getAction().destroy(unTgtC, sa); } if (destroyed && remDestroyed) { card.addRemembered(unTgtC); } } } }
@Override public void resolve(SpellAbility sa) { final Card host = sa.getHostCard(); final Player player = sa.getActivatingPlayer(); final Game game = player.getGame(); // make list of creatures that controller has on Battlefield CardCollectionView choices = game.getCardsIn(ZoneType.Battlefield); choices = CardLists.getValidCards(choices, "Creature.YouCtrl", host.getController(), host); // if no creatures on battlefield, cannot encoded if (choices.isEmpty()) { return; } // Handle choice of whether or not to encoded final StringBuilder sb = new StringBuilder(); sb.append("Do you want to exile " + host + " and encode it onto a creature you control?"); if (!player.getController().confirmAction(sa, null, sb.toString())) { return; } // move host card to exile Card movedCard = game.getAction().moveTo(ZoneType.Exile, host); // choose a creature Card choice = player .getController() .chooseSingleEntityForEffect( choices, sa, "Choose a creature you control to encode ", true); if (choice == null) { return; } StringBuilder codeLog = new StringBuilder(); codeLog.append("Encoding ").append(host.toString()).append(" to ").append(choice.toString()); game.getGameLog().add(GameLogEntryType.STACK_RESOLVE, codeLog.toString()); // store hostcard in encoded array choice.addEncodedCard(movedCard); // add trigger final int numEncoded = choice.getEncodedCards().size(); final StringBuilder cipherTrigger = new StringBuilder(); cipherTrigger .append( "Mode$ DamageDone | ValidSource$ Card.Self | ValidTarget$ Player | Execute$ PlayEncoded") .append(numEncoded); cipherTrigger.append(" | CombatDamage$ True | OptionalDecider$ You | TriggerDescription$ "); cipherTrigger.append( "Whenever CARDNAME deals combat damage to a player, its controller may cast a copy of "); cipherTrigger.append(movedCard).append(" without paying its mana cost."); final String abName = "PlayEncoded" + numEncoded; final String abString = "AB$ Play | Cost$ 0 | Encoded$ " + numEncoded + " | WithoutManaCost$ True | CopyCard$ True"; final Trigger parsedTrigger = TriggerHandler.parseTrigger(cipherTrigger.toString(), choice, false); choice.addTrigger(parsedTrigger); choice.setSVar(abName, abString); return; }
/* (non-Javadoc) * @see forge.card.abilityfactory.SpellAiLogic#canPlayAI(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility) */ @Override protected boolean canPlayAI(final Player ai, SpellAbility sa) { // TODO: AI Support! Currently this is copied from AF ChooseCard. // When implementing AI, I believe AI also needs to be made aware of the damage sources // chosen // to be prevented (e.g. so the AI doesn't attack with a creature that will not deal any // damage // to the player because a CoP was pre-activated on it - unless, of course, there's // another // possible reason to attack with that creature). final Card host = sa.getHostCard(); final Cost abCost = sa.getPayCosts(); final Card source = sa.getHostCard(); if (abCost != null) { // AI currently disabled for these costs if (!ComputerUtilCost.checkLifeCost(ai, abCost, source, 4, null)) { return false; } if (!ComputerUtilCost.checkDiscardCost(ai, abCost, source)) { return false; } if (!ComputerUtilCost.checkSacrificeCost(ai, abCost, source)) { return false; } if (!ComputerUtilCost.checkRemoveCounterCost(abCost, source)) { return false; } } final TargetRestrictions tgt = sa.getTargetRestrictions(); if (tgt != null) { sa.resetTargets(); if (sa.canTarget(ai.getOpponent())) { sa.getTargets().add(ai.getOpponent()); } else { return false; } } if (sa.hasParam("AILogic")) { final Game game = ai.getGame(); if (sa.getParam("AILogic").equals("NeedsPrevention")) { if (!game.getStack().isEmpty()) { final SpellAbility topStack = game.getStack().peekAbility(); if (sa.hasParam("Choices") && !topStack.getHostCard().isValid(sa.getParam("Choices"), ai, source)) { return false; } final ApiType threatApi = topStack.getApi(); if (threatApi != ApiType.DealDamage && threatApi != ApiType.DamageAll) { return false; } final Card threatSource = topStack.getHostCard(); List<? extends GameObject> objects = getTargets(topStack); if (!topStack.usesTargeting() && topStack.hasParam("ValidPlayers") && !topStack.hasParam("Defined")) { objects = AbilityUtils.getDefinedPlayers( threatSource, topStack.getParam("ValidPlayers"), topStack); } if (!objects.contains(ai) || topStack.hasParam("NoPrevention")) { return false; } int dmg = AbilityUtils.calculateAmount(threatSource, topStack.getParam("NumDmg"), topStack); if (ComputerUtilCombat.predictDamageTo(ai, dmg, threatSource, false) <= 0) { return false; } return true; } if (game.getPhaseHandler().getPhase() != PhaseType.COMBAT_DECLARE_BLOCKERS) { return false; } CardCollectionView choices = game.getCardsIn(ZoneType.Battlefield); if (sa.hasParam("Choices")) { choices = CardLists.getValidCards(choices, sa.getParam("Choices"), host.getController(), host); } final Combat combat = game.getCombat(); choices = CardLists.filter( choices, new Predicate<Card>() { @Override public boolean apply(final Card c) { if (combat == null || !combat.isAttacking(c, ai) || !combat.isUnblocked(c)) { return false; } return ComputerUtilCombat.damageIfUnblocked(c, ai, combat, true) > 0; } }); if (choices.isEmpty()) { return false; } } } return true; }