[maven-release-plugin] prepare release forge-1.6.35

Migrate m21 cards

See merge request core-developers/forge!2929

forge-ai/pom.xml

@@ -6,7 +6,7 @@
     <parent>
         <artifactId>forge</artifactId>
         <groupId>forge</groupId>
-        <version>1.6.30-SNAPSHOT</version>
+        <version>1.6.35</version>
     </parent>
 
     <artifactId>forge-ai</artifactId>

forge-ai/src/main/java/forge/ai/AiAttackController.java

@@ -24,6 +24,7 @@ import forge.ai.ability.AnimateAi;
 import forge.card.CardTypeView;
 import forge.game.GameEntity;
 import forge.game.ability.AbilityFactory;
+import forge.game.ability.AbilityUtils;
 import forge.game.ability.ApiType;
 import forge.game.ability.effects.ProtectEffect;
 import forge.game.card.*;
@@ -464,7 +465,7 @@ public class AiAttackController {
             final CardCollectionView beastions = ai.getCardsIn(ZoneType.Battlefield, "Beastmaster Ascension");
             int minCreatures = 7;
             for (final Card beastion : beastions) {
-                final int counters = beastion.getCounters(CounterType.QUEST);
+                final int counters = beastion.getCounters(CounterEnumType.QUEST);
                 minCreatures = Math.min(minCreatures, 7 - counters);
             }
             if (this.attackers.size() >= minCreatures) {
@@ -1065,7 +1066,7 @@ public class AiAttackController {
                         }
                     }
                     // if enough damage: switch to next planeswalker or player
-                    if (damage >= pw.getCounters(CounterType.LOYALTY)) {
+                    if (damage >= pw.getCounters(CounterEnumType.LOYALTY)) {
                         List<Card> pwDefending = combat.getDefendingPlaneswalkers();
                         boolean found = false;
                         // look for next planeswalker
@@ -1135,7 +1136,6 @@ public class AiAttackController {
             // TODO Somehow subtract expected damage of other attacking creatures from enemy life total (how? other attackers not yet declared? Can the AI guesstimate which of their creatures will not get blocked?)
             if (attacker.getCurrentPower() * Integer.parseInt(attacker.getSVar("NonCombatPriority")) < ai.getOpponentsSmallestLifeTotal()) {
                 // Check if the card actually has an ability the AI can and wants to play, if not, attacking is fine!
-                boolean wantability = false;
                 for (SpellAbility sa : attacker.getSpellAbilities()) {
                     // Do not attack if we can afford using the ability.
                     if (sa.isAbility()) {
@@ -1192,7 +1192,7 @@ public class AiAttackController {
             if (isWorthLessThanAllKillers || canKillAllDangerous || numberOfPossibleBlockers < 2) {
                 numberOfPossibleBlockers += 1;
                 if (isWorthLessThanAllKillers && ComputerUtilCombat.canDestroyAttacker(ai, attacker, defender, combat, false)
-                        && !(attacker.hasKeyword(Keyword.UNDYING) && attacker.getCounters(CounterType.P1P1) == 0)) {
+                        && !(attacker.hasKeyword(Keyword.UNDYING) && attacker.getCounters(CounterEnumType.P1P1) == 0)) {
                     canBeKilledByOne = true; // there is a single creature on the battlefield that can kill the creature
                     // see if the defending creature is of higher or lower
                     // value. We don't want to attack only to lose value
@@ -1365,21 +1365,12 @@ public class AiAttackController {
             if (c.hasSVar("AIExertCondition")) {
                 if (!c.getSVar("AIExertCondition").isEmpty()) {
                     final String needsToExert = c.getSVar("AIExertCondition");
-                    int x = 0;
-                    int y = 0;
                     String sVar = needsToExert.split(" ")[0];
                     String comparator = needsToExert.split(" ")[1];
                     String compareTo = comparator.substring(2);
-                    try {
-                        x = Integer.parseInt(sVar);
-                    } catch (final NumberFormatException e) {
-                        x = CardFactoryUtil.xCount(c, c.getSVar(sVar));
-                    }
-                    try {
-                        y = Integer.parseInt(compareTo);
-                    } catch (final NumberFormatException e) {
-                        y = CardFactoryUtil.xCount(c, c.getSVar(compareTo));
-                    }
+
+                    int x = AbilityUtils.calculateAmount(c, sVar, null);
+                    int y = AbilityUtils.calculateAmount(c, compareTo, null);
                     if (Expressions.compare(x, comparator, y)) {
                         shouldExert = true;
                     }

forge-ai/src/main/java/forge/ai/AiBlockController.java

@@ -228,9 +228,9 @@ public class AiBlockController {
                 // 3.Blockers that can destroy the attacker and have an upside when dying
                 killingBlockers = getKillingBlockers(combat, attacker, blockers);
                 for (Card b : killingBlockers) {
-                    if ((b.hasKeyword(Keyword.UNDYING) && b.getCounters(CounterType.P1P1) == 0) || b.hasSVar("SacMe")
-                            || (b.hasKeyword(Keyword.VANISHING) && b.getCounters(CounterType.TIME) == 1)
-                            || (b.hasKeyword(Keyword.FADING) && b.getCounters(CounterType.FADE) == 0)
+                    if ((b.hasKeyword(Keyword.UNDYING) && b.getCounters(CounterEnumType.P1P1) == 0) || b.hasSVar("SacMe")
+                            || (b.hasKeyword(Keyword.VANISHING) && b.getCounters(CounterEnumType.TIME) == 1)
+                            || (b.hasKeyword(Keyword.FADING) && b.getCounters(CounterEnumType.FADE) == 0)
                             || b.hasSVar("EndOfTurnLeavePlay")) {
                         blocker = b;
                         break;
@@ -299,8 +299,8 @@ public class AiBlockController {
             final List<Card> blockers = getPossibleBlockers(combat, attacker, blockersLeft, true);
 
             for (Card b : blockers) {
-                if ((b.hasKeyword(Keyword.VANISHING) && b.getCounters(CounterType.TIME) == 1)
-                        || (b.hasKeyword(Keyword.FADING) && b.getCounters(CounterType.FADE) == 0)
+                if ((b.hasKeyword(Keyword.VANISHING) && b.getCounters(CounterEnumType.TIME) == 1)
+                        || (b.hasKeyword(Keyword.FADING) && b.getCounters(CounterEnumType.FADE) == 0)
                         || b.hasSVar("EndOfTurnLeavePlay")) {
                     blocker = b;
                     if (!ComputerUtilCombat.canDestroyAttacker(ai, attacker, blocker, combat, false)) {
@@ -851,7 +851,7 @@ public class AiBlockController {
                                 damageToPW += ComputerUtilCombat.predictDamageTo((Card) def, pwatkr.getNetCombatDamage(), pwatkr, true);
                             }
                         }
-                        if ((!onlyIfLethal && damageToPW > 0) || damageToPW >= def.getCounters(CounterType.LOYALTY)) {
+                        if ((!onlyIfLethal && damageToPW > 0) || damageToPW >= def.getCounters(CounterEnumType.LOYALTY)) {
                             threatenedPWs.add((Card) def);
                         }
                     }
@@ -909,7 +909,7 @@ public class AiBlockController {
                                 damageToPW += ComputerUtilCombat.predictDamageTo(pw, pwAtk.getNetCombatDamage(), pwAtk, true);
                             }
                         }
-                        if (!isFullyBlocked && damageToPW >= pw.getCounters(CounterType.LOYALTY)) {
+                        if (!isFullyBlocked && damageToPW >= pw.getCounters(CounterEnumType.LOYALTY)) {
                             for (Card chump : pwDefenders) {
                                 if (chosenChumpBlockers.contains(chump)) {
                                     combat.removeFromCombat(chump);
@@ -1281,6 +1281,7 @@ public class AiBlockController {
             oppCreatureCount = ComputerUtil.countUsefulCreatures(attackersLeft.get(0).getController());
         }
 
+        if (attacker != null && attacker.getOwner() != null)
             if (attacker.getOwner().equals(ai) && "6".equals(attacker.getSVar("SacMe"))) {
             // Temporarily controlled object - don't trade with it
             // TODO: find a more reliable way to figure out that control will be reestablished next turn

forge-ai/src/main/java/forge/ai/AiController.java

@@ -177,7 +177,7 @@ public class AiController {
                             && CardFactoryUtil.isCounterable(host)) {
                         return true;
                     } else if ("ChaliceOfTheVoid".equals(curse) && sa.isSpell() && CardFactoryUtil.isCounterable(host)
-                            && host.getCMC() == c.getCounters(CounterType.CHARGE)) {
+                            && host.getCMC() == c.getCounters(CounterEnumType.CHARGE)) {
                         return true;
                     }  else if ("BazaarOfWonders".equals(curse) && sa.isSpell() && CardFactoryUtil.isCounterable(host)) {
                         String hostName = host.getName();
@@ -769,7 +769,7 @@ public class AiController {
                 return AiPlayDecision.CantPlayAi;
             }
         }
-        else if (sa.getPayCosts() != null){
+        else {
             Cost payCosts = sa.getPayCosts();
             ManaCost mana = payCosts.getTotalMana();
             if (mana != null) {
@@ -858,7 +858,7 @@ public class AiController {
         int neededMana = 0;
         boolean dangerousRecurringCost = false;
 
-        Cost costWithBuyback = sa.getPayCosts() != null ? sa.getPayCosts().copy() : Cost.Zero;
+        Cost costWithBuyback = sa.getPayCosts().copy();
         for (OptionalCostValue opt : GameActionUtil.getOptionalCostValues(sa)) {
             if (opt.getType() == OptionalCost.Buyback) {
                 costWithBuyback.add(opt.getCost());
@@ -907,8 +907,8 @@ public class AiController {
         public int compare(final SpellAbility a, final SpellAbility b) {
             // sort from highest cost to lowest
             // we want the highest costs first
-            int a1 = a.getPayCosts() == null ? 0 : a.getPayCosts().getTotalMana().getCMC();
-            int b1 = b.getPayCosts() == null ? 0 : b.getPayCosts().getTotalMana().getCMC();
+            int a1 = a.getPayCosts().getTotalMana().getCMC();
+            int b1 = b.getPayCosts().getTotalMana().getCMC();
 
             // deprioritize SAs explicitly marked as preferred to be activated last compared to all other SAs
             if (a.hasParam("AIActivateLast") && !b.hasParam("AIActivateLast")) {
@@ -927,12 +927,12 @@ public class AiController {
             // deprioritize pump spells with pure energy cost (can be activated last,
             // since energy is generally scarce, plus can benefit e.g. Electrostatic Pummeler)
             int a2 = 0, b2 = 0;
-            if (a.getApi() == ApiType.Pump && a.getPayCosts() != null && a.getPayCosts().getCostEnergy() != null) {
+            if (a.getApi() == ApiType.Pump && a.getPayCosts().getCostEnergy() != null) {
                 if (a.getPayCosts().hasOnlySpecificCostType(CostPayEnergy.class)) {
                     a2 = a.getPayCosts().getCostEnergy().convertAmount();
                 }
             }
-            if (b.getApi() == ApiType.Pump && b.getPayCosts() != null && b.getPayCosts().getCostEnergy() != null) {
+            if (b.getApi() == ApiType.Pump && b.getPayCosts().getCostEnergy() != null) {
                 if (b.getPayCosts().hasOnlySpecificCostType(CostPayEnergy.class)) {
                     b2 = b.getPayCosts().getCostEnergy().convertAmount();
                 }
@@ -956,8 +956,7 @@ public class AiController {
                 return 1;
             }
 
-            if (a.getHostCard().equals(b.getHostCard()) && a.getApi() == b.getApi()
-                    && a.getPayCosts() != null && b.getPayCosts() != null) {
+            if (a.getHostCard().equals(b.getHostCard()) && a.getApi() == b.getApi()) {
                 // Cheaper Spectacle costs should be preferred
                 // FIXME: Any better way to identify that these are the same ability, one with Spectacle and one not?
                 // (looks like it's not a full-fledged alternative cost as such, and is not processed with other alt costs)
@@ -1479,7 +1478,7 @@ public class AiController {
                 }
 
                 for (SpellAbility sa : card.getSpellAbilities()) {
-                    if (sa.getPayCosts() != null && sa.isAbility()
+                    if (sa.isAbility()
                             && sa.getPayCosts().getCostMana() != null
                             && sa.getPayCosts().getCostMana().getMana().getCMC() > 0
                             && (!sa.getPayCosts().hasTapCost() || !isTapLand)
@@ -1802,7 +1801,7 @@ public class AiController {
         throw new UnsupportedOperationException("AI is not supposed to reach this code at the moment");
     }
 
-    public CardCollection chooseCardsForEffect(CardCollectionView pool, SpellAbility sa, int min, int max, boolean isOptional) {
+    public CardCollection chooseCardsForEffect(CardCollectionView pool, SpellAbility sa, int min, int max, boolean isOptional, Map<String, Object> params) {
         if (sa == null || sa.getApi() == null) {
             throw new UnsupportedOperationException();
         }
@@ -1835,7 +1834,7 @@ public class AiController {
             default:
                 CardCollection editablePool = new CardCollection(pool);
                 for (int i = 0; i < max; i++) {
-                    Card c = player.getController().chooseSingleEntityForEffect(editablePool, sa, null, isOptional);
+                    Card c = player.getController().chooseSingleEntityForEffect(editablePool, sa, null, isOptional, params);
                     if (c != null) {
                         result.add(c);
                         editablePool.remove(c);
@@ -1986,6 +1985,35 @@ public class AiController {
         return MyRandom.getRandom().nextBoolean();
     }
 
+    public boolean chooseEvenOdd(SpellAbility sa) {
+        String aiLogic = sa.getParamOrDefault("AILogic", "");
+
+        if (aiLogic.equals("AlwaysEven")) {
+            return false; // false is Even
+        } else if (aiLogic.equals("AlwaysOdd")) {
+            return true; // true is Odd
+        } else if (aiLogic.equals("Random")) {
+            return MyRandom.getRandom().nextBoolean();
+        } else if (aiLogic.equals("CMCInHand")) {
+            CardCollectionView hand = sa.getActivatingPlayer().getCardsIn(ZoneType.Hand);
+            int numEven = CardLists.filter(hand, CardPredicates.evenCMC()).size();
+            int numOdd = CardLists.filter(hand, CardPredicates.oddCMC()).size();
+            return numOdd > numEven;
+        } else if (aiLogic.equals("CMCOppControls")) {
+            CardCollectionView hand = sa.getActivatingPlayer().getOpponents().getCardsIn(ZoneType.Battlefield);
+            int numEven = CardLists.filter(hand, CardPredicates.evenCMC()).size();
+            int numOdd = CardLists.filter(hand, CardPredicates.oddCMC()).size();
+            return numOdd > numEven;
+        } else if (aiLogic.equals("CMCOppControlsByPower")) {
+            // TODO: improve this to check for how dangerous those creatures actually are relative to host card
+            CardCollectionView hand = sa.getActivatingPlayer().getOpponents().getCardsIn(ZoneType.Battlefield);
+            int powerEven = Aggregates.sum(CardLists.filter(hand, CardPredicates.evenCMC()), Accessors.fnGetNetPower);
+            int powerOdd = Aggregates.sum(CardLists.filter(hand, CardPredicates.oddCMC()), Accessors.fnGetNetPower);
+            return powerOdd > powerEven;
+        }
+        return MyRandom.getRandom().nextBoolean(); // outside of any specific logic, choose randomly
+    }
+
     public Card chooseCardToHiddenOriginChangeZone(ZoneType destination, List<ZoneType> origin, SpellAbility sa,
             CardCollection fetchList, Player player2, Player decider) {
         if (useSimulation) {

forge-ai/src/main/java/forge/ai/AiCostDecision.java

@@ -5,6 +5,7 @@ import java.util.List;
 import java.util.Map;
 
 import com.google.common.base.Predicate;
+import com.google.common.base.Predicates;
 import com.google.common.collect.Lists;
 
 import forge.card.CardType;
@@ -16,12 +17,14 @@ import forge.game.card.CardCollectionView;
 import forge.game.card.CardLists;
 import forge.game.card.CardPredicates;
 import forge.game.card.CardPredicates.Presets;
+import forge.game.card.CounterEnumType;
 import forge.game.card.CounterType;
 import forge.game.cost.*;
 import forge.game.player.Player;
 import forge.game.spellability.SpellAbility;
 import forge.game.spellability.SpellAbilityStackInstance;
 import forge.game.zone.ZoneType;
+import forge.util.Aggregates;
 import forge.util.TextUtil;
 import forge.util.collect.FCollectionView;
 
@@ -104,6 +107,24 @@ public class AiCostDecision extends CostDecisionMakerBase {
             }
             return PaymentDecision.card(randomSubset);
         }
+        else if (type.equals("DifferentNames")) {
+            CardCollection differentNames = new CardCollection();
+            CardCollection discardMe = CardLists.filter(hand, CardPredicates.hasSVar("DiscardMe"));
+            while (c > 0) {
+                Card chosen;
+                if (!discardMe.isEmpty()) {
+                    chosen = Aggregates.random(discardMe);
+                    discardMe = CardLists.filter(discardMe, Predicates.not(CardPredicates.sharesNameWith(chosen)));
+                } else {
+                    final Card worst = ComputerUtilCard.getWorstAI(hand);
+                    chosen = worst != null ? worst : Aggregates.random(hand);
+                }
+                differentNames.add(chosen);
+                hand = CardLists.filter(hand, Predicates.not(CardPredicates.sharesNameWith(chosen)));
+                c--;
+            }
+            return PaymentDecision.card(differentNames);
+        }
         else {
             final AiController aic = ((PlayerControllerAi)player.getController()).getAi();
 
@@ -329,7 +350,7 @@ public class AiCostDecision extends CostDecisionMakerBase {
         }
 
         CardCollectionView topLib = player.getCardsIn(ZoneType.Library, c);
-        return topLib.size() < c ? null : PaymentDecision.card(topLib);
+        return topLib.size() < c ? null : PaymentDecision.number(c);
     }
 
     @Override
@@ -494,7 +515,7 @@ public class AiCostDecision extends CostDecisionMakerBase {
                 @Override
                 public boolean apply(Card card) {
                     for (final SpellAbility sa : card.getSpellAbilities()) {
-                        if (sa.isManaAbility() && sa.getPayCosts() != null && sa.getPayCosts().hasTapCost()) {
+                        if (sa.isManaAbility() && sa.getPayCosts().hasTapCost()) {
                             return true;
                         }
                     }
@@ -579,7 +600,7 @@ public class AiCostDecision extends CostDecisionMakerBase {
     @Override
     public PaymentDecision visit(CostReveal cost) {
         final String type = cost.getType();
-        CardCollectionView hand = player.getCardsIn(ZoneType.Hand);
+        CardCollectionView hand = player.getCardsIn(cost.getRevealFrom());
 
         if (cost.payCostFromSource()) {
             if (!hand.contains(source)) {
@@ -627,41 +648,41 @@ public class AiCostDecision extends CostDecisionMakerBase {
         // the first things are benefit from removing counters
 
         // try to remove +1/+1 counter from undying creature
-        List<Card> prefs = CardLists.filter(typeList, CardPredicates.hasCounter(CounterType.P1P1, c),
+        List<Card> prefs = CardLists.filter(typeList, CardPredicates.hasCounter(CounterEnumType.P1P1, c),
                 CardPredicates.hasKeyword("Undying"));
 
         if (!prefs.isEmpty()) {
-            Collections.sort(prefs, CardPredicates.compareByCounterType(CounterType.P1P1));
+            Collections.sort(prefs, CardPredicates.compareByCounterType(CounterEnumType.P1P1));
             PaymentDecision result = PaymentDecision.card(prefs);
-            result.ct = CounterType.P1P1;
+            result.ct = CounterType.get(CounterEnumType.P1P1);
             return result;
         }
 
         // try to remove -1/-1 counter from persist creature
-        prefs = CardLists.filter(typeList, CardPredicates.hasCounter(CounterType.M1M1, c),
+        prefs = CardLists.filter(typeList, CardPredicates.hasCounter(CounterEnumType.M1M1, c),
                 CardPredicates.hasKeyword("Persist"));
 
         if (!prefs.isEmpty()) {
-            Collections.sort(prefs, CardPredicates.compareByCounterType(CounterType.M1M1));
+            Collections.sort(prefs, CardPredicates.compareByCounterType(CounterEnumType.M1M1));
             PaymentDecision result = PaymentDecision.card(prefs);
-            result.ct = CounterType.M1M1;
+            result.ct = CounterType.get(CounterEnumType.M1M1);
             return result;
         }
 
         // try to remove Time counter from Chronozoa, it will generate more
-        prefs = CardLists.filter(typeList, CardPredicates.hasCounter(CounterType.TIME, c),
+        prefs = CardLists.filter(typeList, CardPredicates.hasCounter(CounterEnumType.TIME, c),
                 CardPredicates.nameEquals("Chronozoa"));
 
         if (!prefs.isEmpty()) {
-            Collections.sort(prefs, CardPredicates.compareByCounterType(CounterType.TIME));
+            Collections.sort(prefs, CardPredicates.compareByCounterType(CounterEnumType.TIME));
             PaymentDecision result = PaymentDecision.card(prefs);
-            result.ct = CounterType.TIME;
+            result.ct = CounterType.get(CounterEnumType.TIME);
             return result;
         }
 
         // try to remove Quest counter on something with enough counters for the
         // effect to continue
-        prefs = CardLists.filter(typeList, CardPredicates.hasCounter(CounterType.QUEST, c));
+        prefs = CardLists.filter(typeList, CardPredicates.hasCounter(CounterEnumType.QUEST, c));
 
         if (!prefs.isEmpty()) {
             prefs = CardLists.filter(prefs, new Predicate<Card>() {
@@ -673,12 +694,12 @@ public class AiCostDecision extends CostDecisionMakerBase {
                     if (crd.hasSVar("MaxQuestEffect")) {
                         e = Integer.parseInt(crd.getSVar("MaxQuestEffect"));
                     }
-                    return crd.getCounters(CounterType.QUEST) >= e + c;
+                    return crd.getCounters(CounterEnumType.QUEST) >= e + c;
                 }
             });
-            Collections.sort(prefs, Collections.reverseOrder(CardPredicates.compareByCounterType(CounterType.QUEST)));
+            Collections.sort(prefs, Collections.reverseOrder(CardPredicates.compareByCounterType(CounterEnumType.QUEST)));
             PaymentDecision result = PaymentDecision.card(prefs);
-            result.ct = CounterType.QUEST;
+            result.ct =  CounterType.get(CounterEnumType.QUEST);
             return result;
         }
 
@@ -775,7 +796,7 @@ public class AiCostDecision extends CostDecisionMakerBase {
                     @Override
                     public boolean apply(final Card crd) {
                         for (Map.Entry<CounterType, Integer> e : crd.getCounters().entrySet()) {
-                            if (e.getValue() >= c && (ctr.equals("ANY") || e.getKey() == CounterType.valueOf(ctr))) {
+                            if (e.getValue() >= c && (ctr.equals("ANY") || e.getKey().equals(CounterType.getType(ctr)))) {
                                 return true;
                             }
                         }
@@ -787,7 +808,7 @@ public class AiCostDecision extends CostDecisionMakerBase {
                     PaymentDecision result = PaymentDecision.card(card);
 
                     for (Map.Entry<CounterType, Integer> e : card.getCounters().entrySet()) {
-                        if (e.getValue() >= c && (ctr.equals("ANY") || e.getKey() == CounterType.valueOf(ctr))) {
+                        if (e.getValue() >= c && (ctr.equals("ANY") || e.getKey().equals(CounterType.getType(ctr)))) {
                             result.ct = e.getKey();
                             break;
                         }

forge-ai/src/main/java/forge/ai/ComputerUtil.java

@@ -91,9 +91,6 @@ public class ComputerUtil {
                 }
             }
 
-            source.setCastSA(sa);
-            sa.setLastStateBattlefield(game.getLastStateBattlefield());
-            sa.setLastStateGraveyard(game.getLastStateGraveyard());
             sa.setHostCard(game.getAction().moveToStack(source, sa));
         }
 
@@ -109,7 +106,7 @@ public class ComputerUtil {
         if (chooseTargets != null) {
             chooseTargets.run();
         }
-        if (sa.hasParam("Bestow")) {
+        if (sa.isBestow()) {
             sa.getHostCard().animateBestow();
         }
 
@@ -219,9 +216,6 @@ public class ComputerUtil {
 
         final Card source = sa.getHostCard();
         if (sa.isSpell() && !source.isCopiedSpell()) {
-            source.setCastSA(sa);
-            sa.setLastStateBattlefield(game.getLastStateBattlefield());
-            sa.setLastStateGraveyard(game.getLastStateGraveyard());
             sa.setHostCard(game.getAction().moveToStack(source, sa));
         }
 
@@ -246,9 +240,6 @@ public class ComputerUtil {
 
         final Card source = sa.getHostCard();
         if (sa.isSpell() && !source.isCopiedSpell()) {
-            source.setCastSA(sa);
-            sa.setLastStateBattlefield(game.getLastStateBattlefield());
-            sa.setLastStateGraveyard(game.getLastStateGraveyard());
             sa.setHostCard(game.getAction().moveToStack(source, sa));
         }
 
@@ -267,9 +258,6 @@ public class ComputerUtil {
 
         final Card source = newSA.getHostCard();
         if (newSA.isSpell() && !source.isCopiedSpell()) {
-            source.setCastSA(newSA);
-            sa.setLastStateBattlefield(game.getLastStateBattlefield());
-            sa.setLastStateGraveyard(game.getLastStateGraveyard());
             newSA.setHostCard(game.getAction().moveToStack(source, sa));
 
             if (newSA.getApi() == ApiType.Charm && !newSA.isWrapper()) {
@@ -290,9 +278,6 @@ public class ComputerUtil {
         if (ComputerUtilCost.canPayCost(sa, ai)) {
             final Card source = sa.getHostCard();
             if (sa.isSpell() && !source.isCopiedSpell()) {
-                source.setCastSA(sa);
-                sa.setLastStateBattlefield(game.getLastStateBattlefield());
-                sa.setLastStateGraveyard(game.getLastStateGraveyard());
                 sa.setHostCard(game.getAction().moveToStack(source, sa));
             }
 
@@ -1367,7 +1352,7 @@ public class ComputerUtil {
                 if (valid.contains("Creature.YouCtrl")
                         || valid.contains("Other+YouCtrl") ) {
 
-                    final SpellAbility sa = t.getTriggeredSA();
+                    final SpellAbility sa = t.getOverridingAbility();
                     if (sa != null && sa.getApi() == ApiType.Pump && sa.hasParam("KW")
                             && sa.getParam("KW").contains("Haste")) {
                         return true;
@@ -2216,10 +2201,13 @@ public class ComputerUtil {
         return getCardsToDiscardFromOpponent(aiChooser, p, sa, validCards, min, max);
     }
 
-    public static String chooseSomeType(Player ai, String kindOfType, String logic, List<String> invalidTypes) {
+    public static String chooseSomeType(Player ai, String kindOfType, String logic, Collection<String> validTypes, List<String> invalidTypes) {
         if (invalidTypes == null) {
             invalidTypes = ImmutableList.of();
         }
+        if (validTypes == null) {
+            validTypes = ImmutableList.of();
+        }
 
         final Game game = ai.getGame();
         String chosen = "";
@@ -2243,7 +2231,7 @@ public class ComputerUtil {
                 }
             }
             if (StringUtils.isEmpty(chosen)) {
-                chosen = "Creature";
+                chosen = validTypes.isEmpty() ? "Creature" : Aggregates.random(validTypes);
             }
         } else if (kindOfType.equals("Creature")) {
             if (logic != null) {
@@ -2338,13 +2326,15 @@ public class ComputerUtil {
         return chosen;
     }
 
-    public static Object vote(Player ai, List<Object> options, SpellAbility sa, Multimap<Object, Player> votes) {
+    public static Object vote(Player ai, List<Object> options, SpellAbility sa, Multimap<Object, Player> votes, Player forPlayer) {
         final Card source = sa.getHostCard();
         final Player controller = source.getController();
         final Game game = controller.getGame();
 
         boolean opponent = controller.isOpponentOf(ai);
 
+        final CounterType p1p1Type = CounterType.get(CounterEnumType.P1P1);
+
         if (!sa.hasParam("AILogic")) {
             return Aggregates.random(options);
         }
@@ -2398,7 +2388,7 @@ public class ComputerUtil {
                 }
             }
             // is it can't receive counters, choose +1/+1 ones
-            if (!source.canReceiveCounters(CounterType.P1P1)) {
+            if (!source.canReceiveCounters(p1p1Type)) {
                 return opponent ? "Feather" : "Quill";
             }
             // if source is not on the battlefield anymore, choose +1/+1
@@ -2430,7 +2420,7 @@ public class ComputerUtil {
             Card token = TokenAi.spawnToken(controller, saToken);
 
             // is it can't receive counters, choose +1/+1 ones
-            if (!source.canReceiveCounters(CounterType.P1P1)) {
+            if (!source.canReceiveCounters(p1p1Type)) {
                 return opponent ? "Strength" : "Numbers";
             }
 
@@ -2440,7 +2430,7 @@ public class ComputerUtil {
             }
 
             // token would not survive
-            if (token == null) {
+            if (token == null || !token.isCreature()  || token.getNetToughness() < 1) {
                 return opponent ? "Numbers" : "Strength";
             }
 
@@ -2453,11 +2443,11 @@ public class ComputerUtil {
             Card sourceNumbers = CardUtil.getLKICopy(source);
             Card sourceStrength = CardUtil.getLKICopy(source);
 
-            sourceNumbers.setCounters(CounterType.P1P1, sourceNumbers.getCounters(CounterType.P1P1) + numStrength);
+            sourceNumbers.setCounters(p1p1Type, sourceNumbers.getCounters(p1p1Type) + numStrength);
             sourceNumbers.setZone(source.getZone());
 
-            sourceStrength.setCounters(CounterType.P1P1,
-                    sourceStrength.getCounters(CounterType.P1P1) + numStrength + 1);
+            sourceStrength.setCounters(p1p1Type,
+                    sourceStrength.getCounters(p1p1Type) + numStrength + 1);
             sourceStrength.setZone(source.getZone());
 
             int scoreStrength = ComputerUtilCard.evaluateCreature(sourceStrength) + tokenScore * numNumbers;
@@ -2479,7 +2469,7 @@ public class ComputerUtil {
             }
 
             // is it can't receive counters, choose +1/+1 ones
-            if (!source.canReceiveCounters(CounterType.P1P1)) {
+            if (!source.canReceiveCounters(p1p1Type)) {
                 return opponent ? "Sprout" : "Harvest";
             }
 
@@ -2771,27 +2761,27 @@ public class ComputerUtil {
     }
 
     public static boolean isNegativeCounter(CounterType type, Card c) {
-        return type == CounterType.AGE || type == CounterType.BRIBERY || type == CounterType.DOOM
-                || type == CounterType.M1M1 || type == CounterType.M0M2 || type == CounterType.M0M1
-                || type == CounterType.M1M0 || type == CounterType.M2M1 || type == CounterType.M2M2
+        return type.is(CounterEnumType.AGE) || type.is(CounterEnumType.BRIBERY) || type.is(CounterEnumType.DOOM)
+                || type.is(CounterEnumType.M1M1) || type.is(CounterEnumType.M0M2) || type.is(CounterEnumType.M0M1)
+                || type.is(CounterEnumType.M1M0) || type.is(CounterEnumType.M2M1) || type.is(CounterEnumType.M2M2)
                 // Blaze only hurts Lands
-                || (type == CounterType.BLAZE && c.isLand())
+                || (type.is(CounterEnumType.BLAZE) && c.isLand())
                 // Iceberg does use Ice as Storage
-                || (type == CounterType.ICE && !"Iceberg".equals(c.getName()))
+                || (type.is(CounterEnumType.ICE) && !"Iceberg".equals(c.getName()))
                 // some lands does use Depletion as Storage Counter
-                || (type == CounterType.DEPLETION && !c.canUntapPhaseController())
+                || (type.is(CounterEnumType.DEPLETION) && c.hasKeyword("CARDNAME doesn't untap during your untap step."))
                 // treat Time Counters on suspended Cards as Bad,
                 // and also on Chronozoa
-                || (type == CounterType.TIME && (!c.isInPlay() || "Chronozoa".equals(c.getName())))
-                || type == CounterType.GOLD || type == CounterType.MUSIC || type == CounterType.PUPA
-                || type == CounterType.PARALYZATION || type == CounterType.SHELL || type == CounterType.SLEEP
-                || type == CounterType.SLUMBER || type == CounterType.SLEIGHT || type == CounterType.WAGE;
+                || (type.is(CounterEnumType.TIME) && (!c.isInPlay() || "Chronozoa".equals(c.getName())))
+                || type.is(CounterEnumType.GOLD) || type.is(CounterEnumType.MUSIC) || type.is(CounterEnumType.PUPA)
+                || type.is(CounterEnumType.PARALYZATION) || type.is(CounterEnumType.SHELL) || type.is(CounterEnumType.SLEEP)
+                || type.is(CounterEnumType.SLUMBER) || type.is(CounterEnumType.SLEIGHT) || type.is(CounterEnumType.WAGE);
     }
 
     // this countertypes has no effect
     public static boolean isUselessCounter(CounterType type) {
-        return type == CounterType.AWAKENING || type == CounterType.MANIFESTATION || type == CounterType.PETRIFICATION
-                || type == CounterType.TRAINING;
+        return type.is(CounterEnumType.AWAKENING) || type.is(CounterEnumType.MANIFESTATION) || type.is(CounterEnumType.PETRIFICATION)
+                || type.is(CounterEnumType.TRAINING);
     }
 
     public static Player evaluateBoardPosition(final List<Player> listToEvaluate) {

forge-ai/src/main/java/forge/ai/ComputerUtilAbility.java

@@ -82,6 +82,10 @@ public class ComputerUtilAbility {
         final List<SpellAbility> spellAbilities = Lists.newArrayList();
         for (final Card c : l) {
             for (final SpellAbility sa : c.getSpellAbilities()) {
+                // Spells of permanents can't be activated on the battlefield
+                if (c.isPermanent() && sa.isSpell() && c.isInZone(ZoneType.Battlefield)) {
+                    continue;
+                }
                 spellAbilities.add(sa);
             }
             if (c.isFaceDown() && c.isInZone(ZoneType.Exile) && !c.mayPlay(player).isEmpty()) {
@@ -109,9 +113,7 @@ public class ComputerUtilAbility {
             List<SpellAbility> priorityAltSa = Lists.newArrayList();
             List<SpellAbility> otherAltSa = Lists.newArrayList();
             for (SpellAbility altSa : saAltCosts) {
-                if (altSa.getPayCosts() == null || sa.getPayCosts() == null) {
-                    otherAltSa.add(altSa);
-                } else if (sa.getPayCosts().isOnlyManaCost()
+                if (sa.getPayCosts().isOnlyManaCost()
                         && altSa.getPayCosts().isOnlyManaCost() && sa.getPayCosts().getTotalMana().compareTo(altSa.getPayCosts().getTotalMana()) == 1) {
                     // the alternative cost is strictly cheaper, so why not? (e.g. Omniscience etc.)
                     priorityAltSa.add(altSa);

forge-ai/src/main/java/forge/ai/ComputerUtilCard.java

@@ -5,7 +5,6 @@ import com.google.common.base.Predicates;
 import com.google.common.collect.Iterables;
 import com.google.common.collect.Lists;
 import com.google.common.collect.Maps;
-
 import forge.card.CardType;
 import forge.card.ColorSet;
 import forge.card.MagicColor;
@@ -172,21 +171,22 @@ public class ComputerUtilCard {
     
         // if no non-basic lands, target the least represented basic land type
         String sminBL = "";
-        int iminBL = 20000; // hopefully no one will ever have more than 20000
-                            // lands of one type....
+        int iminBL = Integer.MAX_VALUE;
         int n = 0;
         for (String name : MagicColor.Constant.BASIC_LANDS) {
             n = CardLists.getType(land, name).size();
-            if ((n < iminBL) && (n > 0)) {
-                // if two or more are tied, only the
-                // first
-                // one checked will be used
+            if (n < iminBL && n > 0) {
                 iminBL = n;
                 sminBL = name;
             }
         }
-        if (iminBL == 20000) {
-            return null; // no basic land was a minimum
+        if (iminBL == Integer.MAX_VALUE) {
+            // All basic lands have no basic land type. Just return something
+            Iterator<Card> untapped = Iterables.filter(land, CardPredicates.Presets.UNTAPPED).iterator();
+            if (untapped.hasNext()) {
+                return untapped.next();
+            }
+            return land.get(0);
         }
     
         final List<Card> bLand = CardLists.getType(land, sminBL);
@@ -195,7 +195,6 @@ public class ComputerUtilCard {
             return ut;
         }
     
-    
         return Aggregates.random(bLand); // random tapped land of least represented type
     }
 
@@ -643,7 +642,7 @@ public class ComputerUtilCard {
         return getMostProminentType(list, CardType.getAllCreatureTypes());
     }
 
-    public static String getMostProminentType(final CardCollectionView list, final List<String> valid) {
+    public static String getMostProminentType(final CardCollectionView list, final Collection<String> valid) {
         if (list.size() == 0) {
             return "";
         }
@@ -964,6 +963,22 @@ public class ComputerUtilCard {
                 }
                 chosen.add(chosenColor);
             }
+            else if (logic.equals("HighestDevotionToColor")) {
+                int curDevotion = 0;
+                String chosenColor = MagicColor.Constant.WHITE;
+                CardCollectionView hand = ai.getCardsIn(ZoneType.Hand);
+                for(byte c : MagicColor.WUBRG) {
+                    String devotionCode = "Count$Devotion." + MagicColor.toLongString(c);
+
+                    int devotion = CardFactoryUtil.xCount(sa.getHostCard(), devotionCode);
+                    if (devotion > curDevotion && !CardLists.filter(hand, CardPredicates.isColor(c)).isEmpty()) {
+                        curDevotion = devotion;
+                        chosenColor = MagicColor.toLongString(c);
+                    }
+                }
+                chosen.add(chosenColor);
+            }
+
         }
         if (chosen.isEmpty()) {
             chosen.add(MagicColor.Constant.GREEN);
@@ -1407,8 +1422,8 @@ public class ComputerUtilCard {
             if (combat.isAttacking(c) && opp.getLife() > 0) {
                 int dmg = ComputerUtilCombat.damageIfUnblocked(c, opp, combat, true);
                 int pumpedDmg = ComputerUtilCombat.damageIfUnblocked(pumped, opp, pumpedCombat, true);
-                int poisonOrig = opp.canReceiveCounters(CounterType.POISON) ? ComputerUtilCombat.poisonIfUnblocked(c, ai) : 0;
-                int poisonPumped = opp.canReceiveCounters(CounterType.POISON) ? ComputerUtilCombat.poisonIfUnblocked(pumped, ai) : 0;
+                int poisonOrig = opp.canReceiveCounters(CounterEnumType.POISON) ? ComputerUtilCombat.poisonIfUnblocked(c, ai) : 0;
+                int poisonPumped = opp.canReceiveCounters(CounterEnumType.POISON) ? ComputerUtilCombat.poisonIfUnblocked(pumped, ai) : 0;
 
                 // predict Infect
                 if (pumpedDmg == 0 && c.hasKeyword(Keyword.INFECT)) {
@@ -1431,7 +1446,8 @@ public class ComputerUtilCard {
                 }
                 if (pumpedDmg > dmg) {
                     if ((!c.hasKeyword(Keyword.INFECT) && pumpedDmg >= opp.getLife())
-                            || (c.hasKeyword(Keyword.INFECT) && opp.canReceiveCounters(CounterType.POISON) && pumpedDmg >= opp.getPoisonCounters())) {
+                            || (c.hasKeyword(Keyword.INFECT) && opp.canReceiveCounters(CounterEnumType.POISON) && pumpedDmg >= opp.getPoisonCounters())
+                            || ("PumpForTrample".equals(sa.getParam("AILogic")))) {
                         return true;
                     }
                 }
@@ -1458,7 +1474,7 @@ public class ComputerUtilCard {
                     if (totalPowerUnblocked >= opp.getLife()) {
                         return true;
                     } else if (totalPowerUnblocked > dmg && sa.getHostCard() != null && sa.getHostCard().isInPlay()) {
-                        if (sa.getPayCosts() != null && sa.getPayCosts().hasNoManaCost()) {
+                        if (sa.getPayCosts().hasNoManaCost()) {
                             return true; // always activate abilities which cost no mana and which can increase unblocked damage
                         }
                     }
@@ -1742,17 +1758,17 @@ public class ComputerUtilCard {
         if (!c.isCreature()) {
             return false;
         }
-        if (c.hasKeyword("CARDNAME can't attack or block.") || (!c.canUntapPhaseController() && c.isTapped()) || (c.getOwner() == ai && ai.getOpponents().contains(c.getController()))) {
+        if (c.hasKeyword("CARDNAME can't attack or block.") || (c.hasKeyword("CARDNAME doesn't untap during your untap step.") && c.isTapped()) || (c.getOwner() == ai && ai.getOpponents().contains(c.getController()))) {
             return true;
         }
         return false;
     }
 
     public static boolean hasActiveUndyingOrPersist(final Card c) {
-        if (c.hasKeyword(Keyword.UNDYING) && c.getCounters(CounterType.P1P1) == 0) {
+        if (c.hasKeyword(Keyword.UNDYING) && c.getCounters(CounterEnumType.P1P1) == 0) {
             return true;
         }
-        if (c.hasKeyword(Keyword.PERSIST) && c.getCounters(CounterType.M1M1) == 0) {
+        if (c.hasKeyword(Keyword.PERSIST) && c.getCounters(CounterEnumType.M1M1) == 0) {
             return true;
         }
         return false;
@@ -1769,10 +1785,6 @@ public class ComputerUtilCard {
 
         for (Card c : otb) {
             for (SpellAbility sa : c.getSpellAbilities()) {
-                if (sa.getPayCosts() == null) {
-                    continue;
-                }
-
                 CostPayEnergy energyCost = sa.getPayCosts().getCostEnergy();
                 if (energyCost != null) {
                     int amount = energyCost.convertAmount();
@@ -1896,21 +1908,12 @@ public class ComputerUtilCard {
         }
         if (card.getSVar(needsToPlayVarName).length() > 0) {
             final String needsToPlay = card.getSVar(needsToPlayVarName);
-            int x = 0;
-            int y = 0;
             String sVar = needsToPlay.split(" ")[0];
             String comparator = needsToPlay.split(" ")[1];
             String compareTo = comparator.substring(2);
-            try {
-                x = Integer.parseInt(sVar);
-            } catch (final NumberFormatException e) {
-                x = CardFactoryUtil.xCount(card, card.getSVar(sVar));
-            }
-            try {
-                y = Integer.parseInt(compareTo);
-            } catch (final NumberFormatException e) {
-                y = CardFactoryUtil.xCount(card, card.getSVar(compareTo));
-            }
+            int x = AbilityUtils.calculateAmount(card, sVar, sa);
+            int y = AbilityUtils.calculateAmount(card, compareTo, sa);
+
             if (!Expressions.compare(x, comparator, y)) {
                 return AiPlayDecision.NeedsToPlayCriteriaNotMet;
             }

forge-ai/src/main/java/forge/ai/ComputerUtilCombat.java

@@ -328,7 +328,7 @@ public class ComputerUtilCombat {
     public static int resultingPoison(final Player ai, final Combat combat) {
 
         // ai can't get poision counters, so the value can't change
-        if (!ai.canReceiveCounters(CounterType.POISON)) {
+        if (!ai.canReceiveCounters(CounterEnumType.POISON)) {
             return ai.getPoisonCounters();
         }
 
@@ -931,7 +931,7 @@ public class ComputerUtilCombat {
         if (dealsFirstStrikeDamage(attacker, withoutAbilities, null)
                 && (attacker.hasKeyword(Keyword.WITHER) || attacker.hasKeyword(Keyword.INFECT))
                 && !dealsFirstStrikeDamage(blocker, withoutAbilities, null)
-                && !blocker.canReceiveCounters(CounterType.M1M1)) {
+                && !blocker.canReceiveCounters(CounterEnumType.M1M1)) {
             power -= attacker.getNetCombatDamage();
         }
 
@@ -973,62 +973,45 @@ public class ComputerUtilCombat {
         }
         theTriggers.addAll(attacker.getTriggers());
         for (final Trigger trigger : theTriggers) {
-            final Map<String, String> trigParams = trigger.getMapParams();
             final Card source = trigger.getHostCard();
 
             if (!ComputerUtilCombat.combatTriggerWillTrigger(attacker, blocker, trigger, null)) {
                 continue;
             }
 
-            Map<String, String> abilityParams = null;
-            if (trigger.getOverridingAbility() != null) {
-                abilityParams = trigger.getOverridingAbility().getMapParams();
-            } else if (trigParams.containsKey("Execute")) {
-                final String ability = source.getSVar(trigParams.get("Execute"));
-                abilityParams = AbilityFactory.getMapParams(ability);
-            } else {
+            SpellAbility sa = trigger.ensureAbility();
+            if (sa == null) {
                 continue;
             }
 
-            if (abilityParams.containsKey("AB") && !abilityParams.get("AB").equals("Pump")) {
+            if (!ApiType.Pump.equals(sa.getApi())) {
                 continue;
             }
-            if (abilityParams.containsKey("DB") && !abilityParams.get("DB").equals("Pump")) {
+
+            if (sa.usesTargeting()) {
                 continue;
             }
-            if (abilityParams.containsKey("ValidTgts") || abilityParams.containsKey("Tgt")) {
-                continue; // targeted pumping not supported
+
+            if (!sa.hasParam("NumAtt")) {
+                continue;
             }
-            final List<Card> list = AbilityUtils.getDefinedCards(source, abilityParams.get("Defined"), null);
-            if (abilityParams.containsKey("Defined") && abilityParams.get("Defined").equals("TriggeredBlocker")) {
+
+            String defined = sa.getParam("Defined");
+            final List<Card> list = AbilityUtils.getDefinedCards(source, defined, sa);
+            if ("TriggeredBlocker".equals(defined)) {
                 list.add(blocker);
             }
-            if (list.isEmpty()) {
-                continue;
-            }
             if (!list.contains(blocker)) {
                 continue;
             }
-            if (!abilityParams.containsKey("NumAtt")) {
-                continue;
-            }
 
-            String att = abilityParams.get("NumAtt");
-            if (att.startsWith("+")) {
-                att = att.substring(1);
-            }
-            try {
-                power += Integer.parseInt(att);
-            } catch (final NumberFormatException nfe) {
-                // can't parse the number (X for example)
-                power += 0;
-            }
+            power += AbilityUtils.calculateAmount(source, sa.getParam("NumAtt"), sa, true);
         }
         if (withoutAbilities) {
             return power;
         }
         for (SpellAbility ability : blocker.getAllSpellAbilities()) {
-            if (!(ability instanceof AbilityActivated) || ability.getPayCosts() == null) {
+            if (!(ability instanceof AbilityActivated)) {
                 continue;
             }
             if (ability.hasParam("ActivationPhases") || ability.hasParam("SorcerySpeed") || ability.hasParam("ActivationZone")) {
@@ -1058,7 +1041,7 @@ public class ComputerUtilCombat {
                     continue;
                 }
 
-                if (ability.hasParam("Adapt") && blocker.getCounters(CounterType.P1P1) > 0) {
+                if (ability.hasParam("Adapt") && blocker.getCounters(CounterEnumType.P1P1) > 0) {
                     continue;
                 }
 
@@ -1108,102 +1091,61 @@ public class ComputerUtilCombat {
         }
         theTriggers.addAll(attacker.getTriggers());
         for (final Trigger trigger : theTriggers) {
-            final Map<String, String> trigParams = trigger.getMapParams();
             final Card source = trigger.getHostCard();
 
             if (!ComputerUtilCombat.combatTriggerWillTrigger(attacker, blocker, trigger, null)) {
                 continue;
             }
 
-            Map<String, String> abilityParams = null;
-            if (trigger.getOverridingAbility() != null) {
-                abilityParams = trigger.getOverridingAbility().getMapParams();
-            } else if (trigParams.containsKey("Execute")) {
-                final String ability = source.getSVar(trigParams.get("Execute"));
-                abilityParams = AbilityFactory.getMapParams(ability);
-            } else {
+            SpellAbility sa = trigger.ensureAbility();
+            if (sa == null) {
                 continue;
             }
 
-            String abType = "";
-            if (abilityParams.containsKey("AB")) {
-            	abType = abilityParams.get("AB");
-            } else if (abilityParams.containsKey("DB")) {
-            	abType = abilityParams.get("DB");
-            }
-
             // DealDamage triggers
-            if (abType.equals("DealDamage")) {
-                if (!abilityParams.containsKey("Defined") || !abilityParams.get("Defined").equals("TriggeredBlocker")) {
-                    continue;
-                }
-                int damage = 0;
-                try {
-                    damage = Integer.parseInt(abilityParams.get("NumDmg"));
-                } catch (final NumberFormatException nfe) {
-                    // can't parse the number (X for example)
+            if (ApiType.DealDamage.equals(sa.getApi())) {
+                if (!"TriggeredBlocker".equals(sa.getParam("Defined"))) {
                     continue;
                 }
+                int damage = AbilityUtils.calculateAmount(source, sa.getParam("NumDmg"), sa);
                 toughness -= predictDamageTo(blocker, damage, 0, source, false);
-                continue;
-            }
+            } else
 
             // -1/-1 PutCounter triggers
-            if (abType.equals("PutCounter")) {
-                if (!abilityParams.containsKey("Defined") || !abilityParams.get("Defined").equals("TriggeredBlocker")) {
+            if (ApiType.PutCounter.equals(sa.getApi())) {
+                if (!"TriggeredBlocker".equals(sa.getParam("Defined"))) {
                     continue;
                 }
-                if (!abilityParams.containsKey("CounterType") || !abilityParams.get("CounterType").equals("M1M1")) {
-                    continue;
-                }
-                int num = 0;
-                try {
-                    num = Integer.parseInt(abilityParams.get("CounterNum"));
-                } catch (final NumberFormatException nfe) {
-                    // can't parse the number (X for example)
-                    continue;
-                }
-                toughness -= num;
+                if (!"M1M1".equals(sa.getParam("CounterType"))) {
                     continue;
                 }
+                toughness -= AbilityUtils.calculateAmount(source, sa.getParam("CounterNum"), sa);
+            } else
 
             // Pump triggers
-            if (!abType.equals("Pump")) {
-                continue;
-            }
-            if (abilityParams.containsKey("ValidTgts") || abilityParams.containsKey("Tgt")) {
+            if (ApiType.Pump.equals(sa.getApi())) {
+                if (sa.usesTargeting()) {
                     continue; // targeted pumping not supported
                 }
-            final List<Card> list = AbilityUtils.getDefinedCards(source, abilityParams.get("Defined"), null);
-            if (abilityParams.containsKey("Defined") && abilityParams.get("Defined").equals("TriggeredBlocker")) {
+                final List<Card> list = AbilityUtils.getDefinedCards(source, sa.getParam("Defined"), null);
+                if ("TriggeredBlocker".equals(sa.getParam("Defined"))) {
                     list.add(blocker);
                 }
-            if (list.isEmpty()) {
+                if (list.isEmpty() || !list.contains(blocker)) {
                     continue;
                 }
-            if (!list.contains(blocker)) {
-                continue;
-            }
-            if (!abilityParams.containsKey("NumDef")) {
+                if (!sa.hasParam("NumDef")) {
                     continue;
                 }
 
-            String def = abilityParams.get("NumDef");
-            if (def.startsWith("+")) {
-                def = def.substring(1);
-            }
-            try {
-                toughness += Integer.parseInt(def);
-            } catch (final NumberFormatException nfe) {
-                // can't parse the number (X for example)
-
+                toughness += AbilityUtils.calculateAmount(source, sa.getParam("NumDef"), sa, true);
             }
         }
         if (withoutAbilities) {
             return toughness;
         }
         for (SpellAbility ability : blocker.getAllSpellAbilities()) {
-            if (!(ability instanceof AbilityActivated) || ability.getPayCosts() == null) {
+            if (!(ability instanceof AbilityActivated)) {
                 continue;
             }
 
@@ -1234,7 +1176,7 @@ public class ComputerUtilCombat {
                     continue;
                 }
 
-                if (ability.hasParam("Adapt") && blocker.getCounters(CounterType.P1P1) > 0) {
+                if (ability.hasParam("Adapt") && blocker.getCounters(CounterEnumType.P1P1) > 0) {
                     continue;
                 }
 
@@ -1296,7 +1238,7 @@ public class ComputerUtilCombat {
             if (ComputerUtilCombat.dealsFirstStrikeDamage(blocker, withoutAbilities, combat)
                     && (blocker.hasKeyword(Keyword.WITHER) || blocker.hasKeyword(Keyword.INFECT))
                     && !ComputerUtilCombat.dealsFirstStrikeDamage(attacker, withoutAbilities, combat)
-                    && !attacker.canReceiveCounters(CounterType.M1M1)) {
+                    && !attacker.canReceiveCounters(CounterEnumType.M1M1)) {
                 power -= blocker.getNetCombatDamage();
             }
             theTriggers.addAll(blocker.getTriggers());
@@ -1426,7 +1368,7 @@ public class ComputerUtilCombat {
             return power;
         }
         for (SpellAbility ability : attacker.getAllSpellAbilities()) {
-            if (!(ability instanceof AbilityActivated) || ability.getPayCosts() == null) {
+            if (!(ability instanceof AbilityActivated)) {
                 continue;
             }
             if (ability.hasParam("ActivationPhases") || ability.hasParam("SorcerySpeed") || ability.hasParam("ActivationZone")) {
@@ -1456,7 +1398,7 @@ public class ComputerUtilCombat {
                     continue;
                 }
 
-                if (ability.hasParam("Adapt") && attacker.getCounters(CounterType.P1P1) > 0) {
+                if (ability.hasParam("Adapt") && attacker.getCounters(CounterEnumType.P1P1) > 0) {
                     continue;
                 }
 
@@ -1521,135 +1463,121 @@ public class ComputerUtilCombat {
             final CardCollectionView cardList = game.getCardsIn(ZoneType.Battlefield);
             for (final Card card : cardList) {
                 for (final StaticAbility stAb : card.getStaticAbilities()) {
-                    final Map<String, String> params = stAb.getMapParams();
-                    if (!params.get("Mode").equals("Continuous")) {
+                    if (!"Continuous".equals(stAb.getParam("Mode"))) {
                         continue;
                     }
-                    if (params.containsKey("Affected") && params.get("Affected").contains("attacking")) {
-                        final String valid = TextUtil.fastReplace(params.get("Affected"), "attacking", "Creature");
+                    if (!stAb.hasParam("Affected")) {
+                        continue;
+                    }
+                    if (!stAb.hasParam("AddToughness")) {
+                        continue;
+                    }
+                    String affected = stAb.getParam("Affected");
+                    String addT = stAb.getParam("AddToughness");
+                    if (affected.contains("attacking")) {
+                        final String valid = TextUtil.fastReplace(affected, "attacking", "Creature");
                         if (!attacker.isValid(valid, card.getController(), card, null)) {
                             continue;
                         }
-                        if (params.containsKey("AddToughness")) {
-                            if (params.get("AddToughness").equals("X")) {
-                                toughness += CardFactoryUtil.xCount(card, card.getSVar("X"));
-                            } else if (params.get("AddToughness").equals("Y")) {
-                                toughness += CardFactoryUtil.xCount(card, card.getSVar("Y"));
-                            } else {
-                                toughness += Integer.valueOf(params.get("AddToughness"));
-                            }
-                        }
-                    } else if (params.containsKey("Affected") && params.get("Affected").contains("untapped")) {
-                        final String valid = TextUtil.fastReplace(params.get("Affected"), "untapped", "Creature");
+                        toughness += AbilityUtils.calculateAmount(card, addT, stAb, true);
+                    } else if (affected.contains("untapped")) {
+                        final String valid = TextUtil.fastReplace(affected, "untapped", "Creature");
                         if (!attacker.isValid(valid, card.getController(), card, null)
                                 || attacker.hasKeyword(Keyword.VIGILANCE)) {
                             continue;
                         }
                         // remove the bonus, because it will no longer be granted
-                        if (params.containsKey("AddToughness")) {
-                            toughness -= Integer.valueOf(params.get("AddToughness"));
-                        }
+                        toughness -= AbilityUtils.calculateAmount(card, addT, stAb, true);
                     }
                 }
             }
         }
 
         for (final Trigger trigger : theTriggers) {
-            final Map<String, String> trigParams = trigger.getMapParams();
             final Card source = trigger.getHostCard();
 
             if (!ComputerUtilCombat.combatTriggerWillTrigger(attacker, blocker, trigger, combat)) {
                 continue;
             }
 
-            Map<String, String> abilityParams = null;
-            if (trigger.getOverridingAbility() != null) {
-                abilityParams = trigger.getOverridingAbility().getMapParams();
-            } else if (trigParams.containsKey("Execute")) {
-                final String ability = source.getSVar(trigParams.get("Execute"));
-                abilityParams = AbilityFactory.getMapParams(ability);
-            } else {
+            SpellAbility sa = trigger.ensureAbility();
+            if (sa == null) {
                 continue;
             }
+            sa.setActivatingPlayer(source.getController());
 
-            if (abilityParams.containsKey("ValidTgts") || abilityParams.containsKey("Tgt")) {
+            if (sa.usesTargeting()) {
                 continue; // targeted pumping not supported
             }
 
             // DealDamage triggers
-            if ((abilityParams.containsKey("AB") && abilityParams.get("AB").equals("DealDamage"))
-                    || (abilityParams.containsKey("DB") && abilityParams.get("DB").equals("DealDamage"))) {
-                if (!abilityParams.containsKey("Defined") || !abilityParams.get("Defined").equals("TriggeredAttacker")) {
-                    continue;
-                }
-                int damage = 0;
-                try {
-                    damage = Integer.parseInt(abilityParams.get("NumDmg"));
-                } catch (final NumberFormatException nfe) {
-                    // can't parse the number (X for example)
+            if (ApiType.DealDamage.equals(sa.getApi())) {
+                if ("TriggeredAttacker".equals(sa.getParam("Defined"))) {
                     continue;
                 }
+                int damage = AbilityUtils.calculateAmount(source, sa.getParam("NumDmg"), sa);
+
                 toughness -= predictDamageTo(attacker, damage, 0, source, false);
                 continue;
-            }
+            } else if (ApiType.Pump.equals(sa.getApi())) {
 
-            // Pump triggers
-            if (abilityParams.containsKey("AB") && !abilityParams.get("AB").equals("Pump")
-                    && !abilityParams.get("AB").equals("PumpAll")) {
-                continue;
-            }
-            if (abilityParams.containsKey("DB") && !abilityParams.get("DB").equals("Pump")
-                    && !abilityParams.get("DB").equals("PumpAll")) {
-                continue;
-            }
-
-            if (abilityParams.containsKey("Cost")) {
-                SpellAbility sa = null;
-                if (trigger.getOverridingAbility() != null) {
-                    sa = trigger.getOverridingAbility();
-                } else {
-                    final String ability = source.getSVar(trigParams.get("Execute"));
-                    sa = AbilityFactory.getAbility(ability, source);
-                }
-
-                sa.setActivatingPlayer(source.getController());
+                if (sa.hasParam("Cost")) {
                     if (!CostPayment.canPayAdditionalCosts(sa.getPayCosts(), sa)) {
                         continue;
                     }
                 }
-
-            List<Card> list = Lists.newArrayList();
-            if (!abilityParams.containsKey("ValidCards")) {
-                list = AbilityUtils.getDefinedCards(source, abilityParams.get("Defined"), null);
-            }
-            if (abilityParams.containsKey("Defined") && abilityParams.get("Defined").equals("TriggeredAttacker")) {
-                list.add(attacker);
-            }
-            if (abilityParams.containsKey("ValidCards")) {
-                if (attacker.isValid(abilityParams.get("ValidCards").split(","), source.getController(), source, null)
-                        || attacker.isValid(abilityParams.get("ValidCards").replace("attacking+", "").split(","),
-                                source.getController(), source, null)) {
-                    list.add(attacker);
-                }
-            }
-            if (list.isEmpty()) {
+                if (!sa.hasParam("NumDef")) {
                     continue;
                 }
+                CardCollection list = AbilityUtils.getDefinedCards(source, sa.getParam("Defined"), sa);
+                if ("TriggeredAttacker".equals(sa.getParam("Defined"))) {
+                    list.add(attacker);
+                }
                 if (!list.contains(attacker)) {
                     continue;
                 }
-            if (!abilityParams.containsKey("NumDef")) {
-                continue;
-            }
 
-            String def = abilityParams.get("NumDef");
+                String def = sa.getParam("NumDef");
                 if (def.startsWith("+")) {
                     def = def.substring(1);
                 }
                 if (def.matches("[0-9][0-9]?") || def.matches("-" + "[0-9][0-9]?")) {
                     toughness += Integer.parseInt(def);
                 } else {
-                String bonus = source.getSVar(def);
+                    String bonus = AbilityUtils.getSVar(sa, def);
+                    if (bonus.contains("TriggerCount$NumBlockers")) {
+                        bonus = TextUtil.fastReplace(bonus, "TriggerCount$NumBlockers", "Number$1");
+                    } else if (bonus.contains("TriggeredPlayersDefenders$Amount")) { // for Melee
+                        bonus = TextUtil.fastReplace(bonus, "TriggeredPlayersDefenders$Amount", "Number$1");
+                    }
+                    toughness += CardFactoryUtil.xCount(source, bonus);
+                }
+            } else if (ApiType.PumpAll.equals(sa.getApi())) {
+
+                if (sa.hasParam("Cost")) {
+                    if (!CostPayment.canPayAdditionalCosts(sa.getPayCosts(), sa)) {
+                        continue;
+                    }
+                }
+
+                if (!sa.hasParam("ValidCards")) {
+                    continue;
+                }
+                if (!sa.hasParam("NumDef")) {
+                    continue;
+                }
+                if (!attacker.isValid(sa.getParam("ValidCards").replace("attacking+", "").split(","), source.getController(), source, sa)) {
+                    continue;
+                }
+
+                String def = sa.getParam("NumDef");
+                if (def.startsWith("+")) {
+                    def = def.substring(1);
+                }
+                if (def.matches("[0-9][0-9]?") || def.matches("-" + "[0-9][0-9]?")) {
+                    toughness += Integer.parseInt(def);
+                } else {
+                    String bonus = AbilityUtils.getSVar(sa, def);
                     if (bonus.contains("TriggerCount$NumBlockers")) {
                         bonus = TextUtil.fastReplace(bonus, "TriggerCount$NumBlockers", "Number$1");
                     } else if (bonus.contains("TriggeredPlayersDefenders$Amount")) { // for Melee
@@ -1658,11 +1586,12 @@ public class ComputerUtilCombat {
                     toughness += CardFactoryUtil.xCount(source, bonus);
                 }
             }
+        }
         if (withoutAbilities) {
             return toughness;
         }
         for (SpellAbility ability : attacker.getAllSpellAbilities()) {
-            if (!(ability instanceof AbilityActivated) || ability.getPayCosts() == null) {
+            if (!(ability instanceof AbilityActivated)) {
                 continue;
             }
 
@@ -1672,18 +1601,19 @@ public class ComputerUtilCombat {
             if (ability.usesTargeting() && !ability.canTarget(attacker)) {
                 continue;
             }
+            if (ability.getPayCosts().hasTapCost() && !attacker.hasKeyword(Keyword.VIGILANCE)) {
+                continue;
+            }
+            if (!ComputerUtilCost.canPayCost(ability, attacker.getController())) {
+                continue;
+            }
 
             if (ability.getApi() == ApiType.Pump) {
                 if (!ability.hasParam("NumDef")) {
                     continue;
                 }
 
-                if (!ability.getPayCosts().hasTapCost() && ComputerUtilCost.canPayCost(ability, attacker.getController())) {
-                    int tBonus = AbilityUtils.calculateAmount(ability.getHostCard(), ability.getParam("NumDef"), ability);
-                    if (tBonus > 0) {
-                        toughness += tBonus;
-                    }
-                }
+                toughness += AbilityUtils.calculateAmount(ability.getHostCard(), ability.getParam("NumDef"), ability, true);
             } else if (ability.getApi() == ApiType.PutCounter) {
                 if (!ability.hasParam("CounterType") || !ability.getParam("CounterType").equals("P1P1")) {
                     continue;
@@ -1693,18 +1623,16 @@ public class ComputerUtilCombat {
                     continue;
                 }
 
-                if (ability.hasParam("Adapt") && attacker.getCounters(CounterType.P1P1) > 0) {
+                if (ability.hasParam("Adapt") && attacker.getCounters(CounterEnumType.P1P1) > 0) {
                     continue;
                 }
 
-                if (!ability.getPayCosts().hasTapCost() && ComputerUtilCost.canPayCost(ability, attacker.getController())) {
                 int tBonus = AbilityUtils.calculateAmount(ability.getHostCard(), ability.getParam("CounterNum"), ability);
                 if (tBonus > 0) {
                     toughness += tBonus;
                 }
             }
         }
-        }
         return toughness;
     }
 
@@ -1848,10 +1776,10 @@ public class ComputerUtilCombat {
 
         if (((attacker.hasKeyword(Keyword.INDESTRUCTIBLE) || (ComputerUtil.canRegenerate(ai, attacker) && !withoutAbilities))
                 && !(blocker.hasKeyword(Keyword.WITHER) || blocker.hasKeyword(Keyword.INFECT)))
-                || (attacker.hasKeyword(Keyword.PERSIST) && !attacker.canReceiveCounters(CounterType.M1M1) && (attacker
-                        .getCounters(CounterType.M1M1) == 0))
-                || (attacker.hasKeyword(Keyword.UNDYING) && !attacker.canReceiveCounters(CounterType.P1P1) && (attacker
-                        .getCounters(CounterType.P1P1) == 0))) {
+                || (attacker.hasKeyword(Keyword.PERSIST) && !attacker.canReceiveCounters(CounterEnumType.M1M1) && (attacker
+                        .getCounters(CounterEnumType.M1M1) == 0))
+                || (attacker.hasKeyword(Keyword.UNDYING) && !attacker.canReceiveCounters(CounterEnumType.P1P1) && (attacker
+                        .getCounters(CounterEnumType.P1P1) == 0))) {
             return false;
         }
 
@@ -2080,10 +2008,10 @@ public class ComputerUtilCombat {
 
         if (((blocker.hasKeyword(Keyword.INDESTRUCTIBLE) || (ComputerUtil.canRegenerate(ai, blocker) && !withoutAbilities)) && !(attacker
                 .hasKeyword(Keyword.WITHER) || attacker.hasKeyword(Keyword.INFECT)))
-                || (blocker.hasKeyword(Keyword.PERSIST) && !blocker.canReceiveCounters(CounterType.M1M1) && (blocker
-                        .getCounters(CounterType.M1M1) == 0))
-                || (blocker.hasKeyword(Keyword.UNDYING) && !blocker.canReceiveCounters(CounterType.P1P1) && (blocker
-                        .getCounters(CounterType.P1P1) == 0))) {
+                || (blocker.hasKeyword(Keyword.PERSIST) && !blocker.canReceiveCounters(CounterEnumType.M1M1) && (blocker
+                        .getCounters(CounterEnumType.M1M1) == 0))
+                || (blocker.hasKeyword(Keyword.UNDYING) && !blocker.canReceiveCounters(CounterEnumType.P1P1) && (blocker
+                        .getCounters(CounterEnumType.P1P1) == 0))) {
             return false;
         }
 
@@ -2389,7 +2317,7 @@ public class ComputerUtilCombat {
         restDamage = target.staticReplaceDamage(restDamage, source, isCombat);
 
         // Predict replacement effects
-        for (final Card ca : game.getCardsIn(ZoneType.listValueOf("Battlefield,Command"))) {
+        for (final Card ca : game.getCardsIn(ZoneType.STATIC_ABILITIES_SOURCE_ZONES)) {
             for (final ReplacementEffect re : ca.getReplacementEffects()) {
                 Map<String, String> params = re.getMapParams();
                 if (!re.getMode().equals(ReplacementType.DamageDone) || !params.containsKey("PreventionEffect")) {
@@ -2517,7 +2445,7 @@ public class ComputerUtilCombat {
     	final Player controller = combatant.getController();
     	for (Card c : controller.getCardsIn(ZoneType.Battlefield)) {
 	    	for (SpellAbility ability : c.getAllSpellAbilities()) {
-	            if (!(ability instanceof AbilityActivated) || ability.getPayCosts() == null) {
+	            if (!(ability instanceof AbilityActivated)) {
 	                continue;
 	            }
 	            if (ability.getApi() != ApiType.Pump) {

forge-ai/src/main/java/forge/ai/ComputerUtilCost.java

@@ -45,7 +45,7 @@ public class ComputerUtilCost {
                 final CostPutCounter addCounter = (CostPutCounter) part;
                 final CounterType type = addCounter.getCounter();
 
-                if (type.equals(CounterType.M1M1)) {
+                if (type.equals(CounterEnumType.M1M1)) {
                     return false;
                 }
             }
@@ -75,7 +75,7 @@ public class ComputerUtilCost {
 
                 final CounterType type = remCounter.counter;
                 if (!part.payCostFromSource()) {
-                    if (CounterType.P1P1.equals(type)) {
+                    if (CounterEnumType.P1P1.equals(type)) {
                         return false;
                     }
                     continue;
@@ -97,7 +97,7 @@ public class ComputerUtilCost {
 
                 // check the sa what the PaymentDecision is.
                 // ignore Loyality abilities with Zero as Cost
-                if (sa != null && !CounterType.LOYALTY.equals(type)) {
+                if (sa != null && !CounterEnumType.LOYALTY.equals(type)) {
                     final AiCostDecision decision = new AiCostDecision(sa.getActivatingPlayer(), sa);
                     PaymentDecision pay = decision.visit(remCounter);
                     if (pay == null || pay.c <= 0) {
@@ -106,7 +106,7 @@ public class ComputerUtilCost {
                 }
 
                 //don't kill the creature
-                if (CounterType.P1P1.equals(type) && source.getLethalDamage() <= 1
+                if (CounterEnumType.P1P1.equals(type) && source.getLethalDamage() <= 1
                         && !source.hasKeyword(Keyword.UNDYING)) {
                     return false;
                 }
@@ -467,9 +467,9 @@ public class ComputerUtilCost {
                     if(!meetsRestriction)
                         continue;
 
-                    try {
+                    if (StringUtils.isNumeric(parts[0])) {
                         extraManaNeeded += Integer.parseInt(parts[0]);
-                    } catch (final NumberFormatException e) {
+                    } else {
                         System.out.println("wrong SpellsNeedExtraMana SVar format on " + c);
                     }
                 }
@@ -480,9 +480,9 @@ public class ComputerUtilCost {
             	}
                 final String snem = c.getSVar("SpellsNeedExtraManaEffect");
                 if (!StringUtils.isBlank(snem)) {
-                    try {
+                    if (StringUtils.isNumeric(snem)) {
                         extraManaNeeded += Integer.parseInt(snem);
-                    } catch (final NumberFormatException e) {
+                    } else {
                         System.out.println("wrong SpellsNeedExtraManaEffect SVar format on " + c);
                     }
                 }
@@ -529,7 +529,7 @@ public class ComputerUtilCost {
                         public boolean apply(Card card) {
                             boolean hasManaSa = false;
                             for (final SpellAbility sa : card.getSpellAbilities()) {
-                                if (sa.isManaAbility() && sa.getPayCosts() != null && sa.getPayCosts().hasTapCost()) {
+                                if (sa.isManaAbility() && sa.getPayCosts().hasTapCost()) {
                                     hasManaSa = true;
                                     break;
                                 }

forge-ai/src/main/java/forge/ai/ComputerUtilMana.java

@@ -371,7 +371,7 @@ public class ComputerUtilMana {
         adjustManaCostToAvoidNegEffects(cost, sa.getHostCard(), ai);
         List<Mana> manaSpentToPay = test ? new ArrayList<>() : sa.getPayingMana();
         boolean purePhyrexian = cost.containsOnlyPhyrexianMana();
-        int testEnergyPool = ai.getCounters(CounterType.ENERGY);
+        int testEnergyPool = ai.getCounters(CounterEnumType.ENERGY);
 
         List<SpellAbility> paymentList = Lists.newArrayList();
 
@@ -507,17 +507,11 @@ public class ComputerUtilMana {
                 }
             }
             else {
-                if (saPayment.getPayCosts() != null) {
                 final CostPayment pay = new CostPayment(saPayment.getPayCosts(), saPayment);
                 if (!pay.payComputerCosts(new AiCostDecision(ai, saPayment))) {
                     saList.remove(saPayment);
                     continue;
                 }
-                }
-                else {
-                    System.err.println("Ability " + saPayment + " from " + saPayment.getHostCard() + "  had NULL as payCost");
-                    saPayment.getHostCard().tap();
-                }
 
                 ai.getGame().getStack().addAndUnfreeze(saPayment);
                 // subtract mana from mana pool
@@ -741,7 +735,7 @@ public class ComputerUtilMana {
                 continue;
             }
 
-            if (thisMana.getManaAbility() != null && !thisMana.getManaAbility().meetsManaRestrictions(saBeingPaidFor)) {
+            if (thisMana.getManaAbility() != null && !thisMana.getManaAbility().meetsSpellAndShardRestrictions(saBeingPaidFor, shard, thisMana.getColor())) {
                 continue;
             }
 
@@ -837,11 +831,10 @@ public class ComputerUtilMana {
         if (checkCosts) {
             // Check if AI can still play this mana ability
             ma.setActivatingPlayer(ai);
-            if (ma.getPayCosts() != null) { // if the AI can't pay the additional costs skip the mana ability
+            // if the AI can't pay the additional costs skip the mana ability
             if (!CostPayment.canPayAdditionalCosts(ma.getPayCosts(), ma)) {
                 return false;
             }
-            }
             else if (sourceCard.isTapped()) {
                 return false;
             } else if (ma.getRestrictions() != null && ma.getRestrictions().isInstantSpeed()) {
@@ -1144,7 +1137,7 @@ public class ComputerUtilMana {
         ManaCostBeingPaid cost = new ManaCostBeingPaid(mana, restriction);
 
         // Tack xMana Payments into mana here if X is a set value
-        if (sa.getPayCosts() != null && (cost.getXcounter() > 0 || extraMana > 0)) {
+        if (cost.getXcounter() > 0 || extraMana > 0) {
             int manaToAdd = 0;
             if (test && extraMana > 0) {
                 final int multiplicator = Math.max(cost.getXcounter(), 1);
@@ -1169,7 +1162,7 @@ public class ComputerUtilMana {
             cost.increaseShard(shardToGrow, manaToAdd);
 
             if (!test) {
-                card.setXManaCostPaid(manaToAdd / cost.getXcounter());
+                sa.setXManaCostPaid(manaToAdd / cost.getXcounter());
             }
         }
         
@@ -1218,7 +1211,7 @@ public class ComputerUtilMana {
             for (SpellAbility ma : src.getManaAbilities()) {
                 ma.setActivatingPlayer(p);
                 if (!checkPlayable || ma.canPlay()) {
-                    int costsToActivate = ma.getPayCosts() != null && ma.getPayCosts().getCostMana() != null ? ma.getPayCosts().getCostMana().convertAmount() : 0;
+                    int costsToActivate = ma.getPayCosts().getCostMana() != null ? ma.getPayCosts().getCostMana().convertAmount() : 0;
                     int producedMana = ma.getParamOrDefault("Produced", "").split(" ").length;
                     int producedAmount = AbilityUtils.calculateAmount(src, ma.getParamOrDefault("Amount", "1"), ma);
 
@@ -1594,7 +1587,7 @@ public class ComputerUtilMana {
     }
 
     public static int determineMaxAffordableX(Player ai, SpellAbility sa) {
-        if (sa.getPayCosts() == null || sa.getPayCosts().getCostMana() == null) {
+        if (sa.getPayCosts().getCostMana() == null) {
             return -1;
         }
 

forge-ai/src/main/java/forge/ai/CreatureEvaluator.java

@@ -5,7 +5,7 @@ import com.google.common.base.Function;
 import forge.game.ability.AbilityUtils;
 import forge.game.ability.ApiType;
 import forge.game.card.Card;
-import forge.game.card.CounterType;
+import forge.game.card.CounterEnumType;
 import forge.game.cost.CostPayEnergy;
 import forge.game.keyword.Keyword;
 import forge.game.keyword.KeywordInterface;
@@ -173,7 +173,7 @@ public class CreatureEvaluator implements Function<Card, Integer> {
         if (c.hasKeyword("CARDNAME can't attack or block.")) {
             value = addValue(50 + (c.getCMC() * 5), "useless"); // reset everything - useless
         }
-        if (!c.canUntapPhaseController()) {
+        if (c.hasKeyword("CARDNAME doesn't untap during your untap step.")) {
             if (c.isTapped()) {
                 value = addValue(50 + (c.getCMC() * 5), "tapped-useless"); // reset everything - useless
             } else {
@@ -242,11 +242,11 @@ public class CreatureEvaluator implements Function<Card, Integer> {
                     && "+X".equals(sa.getParam("NumDef"))
                     && !sa.usesTargeting()
                     && (!sa.hasParam("Defined") || "Self".equals(sa.getParam("Defined")))) {
-                if (sa.getPayCosts() != null && sa.getPayCosts().hasOnlySpecificCostType(CostPayEnergy.class)) {
+                if (sa.getPayCosts().hasOnlySpecificCostType(CostPayEnergy.class)) {
                     // Electrostatic Pummeler, can be expanded for similar cards
                     int initPower = getEffectivePower(sa.getHostCard());
                     int pumpedPower = initPower;
-                    int energy = sa.getHostCard().getController().getCounters(CounterType.ENERGY);
+                    int energy = sa.getHostCard().getController().getCounters(CounterEnumType.ENERGY);
                     if (energy > 0) {
                         int numActivations = energy / 3;
                         for (int i = 0; i < numActivations; i++) {

forge-ai/src/main/java/forge/ai/GameState.java

@@ -9,12 +9,10 @@ import forge.card.CardStateName;
 import forge.card.MagicColor;
 import forge.game.Game;
 import forge.game.GameEntity;
+import forge.game.GameObject;
 import forge.game.ability.AbilityFactory;
 import forge.game.ability.effects.DetachedCardEffect;
-import forge.game.card.Card;
-import forge.game.card.CardCollection;
-import forge.game.card.CardCollectionView;
-import forge.game.card.CounterType;
+import forge.game.card.*;
 import forge.game.card.token.TokenInfo;
 import forge.game.combat.Combat;
 import forge.game.combat.CombatUtil;
@@ -24,6 +22,7 @@ import forge.game.mana.ManaPool;
 import forge.game.phase.PhaseType;
 import forge.game.player.Player;
 import forge.game.spellability.AbilityManaPart;
+import forge.game.spellability.AbilitySub;
 import forge.game.spellability.SpellAbility;
 import forge.game.ability.AbilityKey;
 import forge.game.trigger.TriggerType;
@@ -244,7 +243,7 @@ public abstract class GameState {
                 if (card instanceof DetachedCardEffect) {
                     continue;
                 }
-                addCard(zone, card.getOwner() == ai ? aiCardTexts : humanCardTexts, card);
+                addCard(zone, card.getController() == ai ? aiCardTexts : humanCardTexts, card);
             }
         }
     }
@@ -271,6 +270,10 @@ public abstract class GameState {
         }
 
         if (zoneType == ZoneType.Battlefield) {
+            if (c.getOwner() != c.getController()) {
+                // TODO: Handle more than 2-player games.
+                newText.append("|Owner:" + (c.getOwner().isAI() ?  "AI" : "Human"));
+            }
             if (c.isTapped()) {
                 newText.append("|Tapped");
             }
@@ -362,6 +365,12 @@ public abstract class GameState {
             if (c.isFaceDown()) {
                 newText.append("|FaceDown"); // Exiled face down
             }
+            if (c.isAdventureCard() && c.getZone().is(ZoneType.Exile)) {
+                // TODO: this will basically default all exiled cards with Adventure to being "On Adventure".
+                // Need to figure out a better way to detect if it's actually on adventure.
+                newText.append("|OnAdventure");
+            }
+
         }
 
         if (zoneType == ZoneType.Battlefield || zoneType == ZoneType.Exile) {
@@ -583,6 +592,7 @@ public abstract class GameState {
         cardToEnchantPlayerId.clear();
         cardToRememberedId.clear();
         cardToExiledWithId.clear();
+        cardToImprintedId.clear();
         markedDamage.clear();
         cardToChosenClrs.clear();
         cardToChosenCards.clear();
@@ -807,6 +817,12 @@ public abstract class GameState {
                     break;
             }
         }
+
+        if (sa.hasParam("RememberTargets")) {
+            for (final GameObject o : sa.getTargets().getTargets()) {
+                sa.getHostCard().addRemembered(o);
+            }
+        }
     }
 
     private void handleScriptExecution(final Game game) {
@@ -966,6 +982,17 @@ public abstract class GameState {
             spellDef = spellDef.substring(0, spellDef.indexOf("->")).trim();
         }
 
+        Card c = null;
+
+        if (StringUtils.isNumeric(spellDef)) {
+            // Precast from a specific host
+            c = idToCard.get(Integer.parseInt(spellDef));
+            if (c == null) {
+                System.err.println("ERROR: Could not find a card with ID " + spellDef + " to precast!");
+                return;
+            }
+        } else {
+            // Precast from a card by name
             PaperCard pc = StaticData.instance().getCommonCards().getCard(spellDef);
 
             if (pc == null) {
@@ -973,7 +1000,9 @@ public abstract class GameState {
                 return;
             }
 
-        Card c = Card.fromPaperCard(pc, activator);
+            c = Card.fromPaperCard(pc, activator);
+        }
+
         SpellAbility sa = null;
 
         if (!scriptID.isEmpty()) {
@@ -1062,11 +1091,11 @@ public abstract class GameState {
     }
 
     private void applyCountersToGameEntity(GameEntity entity, String counterString) {
-        entity.setCounters(Maps.newEnumMap(CounterType.class));
+        entity.setCounters(Maps.newHashMap());
         String[] allCounterStrings = counterString.split(",");
         for (final String counterPair : allCounterStrings) {
             String[] pair = counterPair.split("=", 2);
-            entity.addCounter(CounterType.valueOf(pair[0]), Integer.parseInt(pair[1]), null, false, false, null);
+            entity.addCounter(CounterType.getType(pair[0]), Integer.parseInt(pair[1]), null, false, false, null);
         }
     }
 
@@ -1108,7 +1137,7 @@ public abstract class GameState {
                     Map<CounterType, Integer> counters = c.getCounters();
                     // Note: Not clearCounters() since we want to keep the counters
                     // var as-is.
-                    c.setCounters(Maps.newEnumMap(CounterType.class));
+                    c.setCounters(Maps.newHashMap());
                     if (c.isAura()) {
                         // dummy "enchanting" to indicate that the card will be force-attached elsewhere
                         // (will be overridden later, so the actual value shouldn't matter)
@@ -1202,6 +1231,16 @@ public abstract class GameState {
                     c.setState(CardStateName.Flipped, true);
                 } else if (info.startsWith("Meld")) {
                     c.setState(CardStateName.Meld, true);
+                } else if (info.startsWith("OnAdventure")) {
+                    String abAdventure = "DB$ Effect | RememberObjects$ Self | StaticAbilities$ Play | ExileOnMoved$ Exile | Duration$ Permanent | ConditionDefined$ Self | ConditionPresent$ Card.nonCopiedSpell";
+                    AbilitySub saAdventure = (AbilitySub)AbilityFactory.getAbility(abAdventure, c);
+                    StringBuilder sbPlay = new StringBuilder();
+                    sbPlay.append("Mode$ Continuous | MayPlay$ True | EffectZone$ Command | Affected$ Card.IsRemembered+nonAdventure");
+                    sbPlay.append(" | AffectedZone$ Exile | Description$ You may cast the card.");
+                    saAdventure.setSVar("Play", sbPlay.toString());
+                    saAdventure.setActivatingPlayer(c.getOwner());
+                    saAdventure.resolve();
+                    c.setExiledWith(c); // This seems to be the way it's set up internally. Potentially not needed here?
                 } else if (info.startsWith("IsCommander")) {
                     // TODO: This doesn't seem to properly restore the ability to play the commander. Why?
                     c.setCommander(true);

forge-ai/src/main/java/forge/ai/PlayerControllerAi.java

@@ -145,12 +145,12 @@ public class PlayerControllerAi extends PlayerController {
     }
 
     @Override
-    public CardCollectionView chooseCardsForEffect(CardCollectionView sourceList, SpellAbility sa, String title, int min, int max, boolean isOptional) {
-        return brains.chooseCardsForEffect(sourceList, sa, min, max, isOptional);
+    public CardCollectionView chooseCardsForEffect(CardCollectionView sourceList, SpellAbility sa, String title, int min, int max, boolean isOptional, Map<String, Object> params) {
+        return brains.chooseCardsForEffect(sourceList, sa, min, max, isOptional, params);
     }
 
     @Override
-    public <T extends GameEntity> T chooseSingleEntityForEffect(FCollectionView<T> optionList, DelayedReveal delayedReveal, SpellAbility sa, String title, boolean isOptional, Player targetedPlayer) {
+    public <T extends GameEntity> T chooseSingleEntityForEffect(FCollectionView<T> optionList, DelayedReveal delayedReveal, SpellAbility sa, String title, boolean isOptional, Player targetedPlayer, Map<String, Object> params) {
         if (delayedReveal != null) {
             reveal(delayedReveal.getCards(), delayedReveal.getZone(), delayedReveal.getOwner(), delayedReveal.getMessagePrefix());
         }
@@ -158,13 +158,13 @@ public class PlayerControllerAi extends PlayerController {
         if (null == api) {
             throw new InvalidParameterException("SA is not api-based, this is not supported yet");
         }
-        return SpellApiToAi.Converter.get(api).chooseSingleEntity(player, sa, (FCollection<T>)optionList, isOptional, targetedPlayer);
+        return SpellApiToAi.Converter.get(api).chooseSingleEntity(player, sa, (FCollection<T>)optionList, isOptional, targetedPlayer, params);
     }
 
     @Override
     public <T extends GameEntity> List<T> chooseEntitiesForEffect(
             FCollectionView<T> optionList, int min, int max, DelayedReveal delayedReveal, SpellAbility sa, String title,
-            Player targetedPlayer) {
+            Player targetedPlayer, Map<String, Object> params) {
         if (delayedReveal != null) {
             reveal(delayedReveal.getCards(), delayedReveal.getZone(), delayedReveal.getOwner(), delayedReveal.getMessagePrefix());
         }
@@ -172,7 +172,7 @@ public class PlayerControllerAi extends PlayerController {
 	List<T> selecteds = new ArrayList<>();
 	T selected;
 	do {
-	    selected = chooseSingleEntityForEffect(remaining, null, sa, title, selecteds.size()>=min, targetedPlayer);
+	    selected = chooseSingleEntityForEffect(remaining, null, sa, title, selecteds.size()>=min, targetedPlayer, params);
 	    if ( selected != null ) {
 		remaining.remove(selected);
 		selecteds.add(selected);
@@ -182,7 +182,23 @@ public class PlayerControllerAi extends PlayerController {
     }
 
     @Override
-    public SpellAbility chooseSingleSpellForEffect(java.util.List<SpellAbility> spells, SpellAbility sa, String title,
+    public List<SpellAbility> chooseSpellAbilitiesForEffect(List<SpellAbility> spells, SpellAbility sa, String title,
+            int num, Map<String, Object> params) {
+        List<SpellAbility> remaining = Lists.newArrayList(spells);
+        List<SpellAbility> selecteds = Lists.newArrayList();
+        SpellAbility selected;
+        do {
+            selected = chooseSingleSpellForEffect(remaining, sa, title, params);
+            if ( selected != null ) {
+                remaining.remove(selected);
+                selecteds.add(selected);
+            }
+        } while ( (selected != null ) && (selecteds.size() < num) );
+        return selecteds;
+    }
+
+    @Override
+    public SpellAbility chooseSingleSpellForEffect(List<SpellAbility> spells, SpellAbility sa, String title,
             Map<String, Object> params) {
         ApiType api = sa.getApi();
         if (null == api) {
@@ -208,15 +224,13 @@ public class PlayerControllerAi extends PlayerController {
     }
 
     @Override
-    public boolean confirmTrigger(WrappedAbility wrapper, Map<String, String> triggerParams, boolean isMandatory) {
+    public boolean confirmTrigger(WrappedAbility wrapper) {
         final SpellAbility sa = wrapper.getWrappedAbility();
         //final Trigger regtrig = wrapper.getTrigger();
         if (ComputerUtilAbility.getAbilitySourceName(sa).equals("Deathmist Raptor")) {
             return true;
         }
-        if (triggerParams.containsKey("DelayedTrigger") || isMandatory) {
-            //TODO: The only card with an optional delayed trigger is Shirei, Shizo's Caretaker,
-            //      needs to be expanded when a more difficult cards comes up
+        if (wrapper.isMandatory()) {
             return true;
         }
         // Store/replace target choices more properly to get this SA cleared.
@@ -502,20 +516,19 @@ public class PlayerControllerAi extends PlayerController {
     }
 
     @Override
-    public String chooseSomeType(String kindOfType, SpellAbility sa, List<String> validTypes, List<String> invalidTypes, boolean isOptional) {
-        String chosen = ComputerUtil.chooseSomeType(player, kindOfType, sa.getParam("AILogic"), invalidTypes);
-        if (StringUtils.isBlank(chosen) && !validTypes.isEmpty())
-        {
-            chosen = validTypes.get(0);
-            System.err.println("AI has no idea how to choose " + kindOfType +", defaulting to 1st element: chosen");
+    public String chooseSomeType(String kindOfType, SpellAbility sa, Collection<String> validTypes, List<String> invalidTypes, boolean isOptional) {
+        String chosen = ComputerUtil.chooseSomeType(player, kindOfType, sa.getParam("AILogic"), validTypes, invalidTypes);
+        if (StringUtils.isBlank(chosen) && !validTypes.isEmpty()) {
+            chosen = validTypes.iterator().next();
+            System.err.println("AI has no idea how to choose " + kindOfType +", defaulting to arbitrary element: chosen");
         }
         game.getAction().nofityOfValue(sa, player, chosen, player);
         return chosen;
     }
 
     @Override
-    public Object vote(SpellAbility sa, String prompt, List<Object> options, ListMultimap<Object, Player> votes) {
-        return ComputerUtil.vote(player, options, sa, votes);
+    public Object vote(SpellAbility sa, String prompt, List<Object> options, ListMultimap<Object, Player> votes, Player forPlayer) {
+        return ComputerUtil.vote(player, options, sa, votes, forPlayer);
     }
 
     @Override
@@ -604,6 +617,7 @@ public class PlayerControllerAi extends PlayerController {
         if (sa instanceof LandAbility) {
             if (sa.canPlay()) {
                 sa.resolve();
+                game.updateLastStateForCard(sa.getHostCard());
             }
         } else {
             ComputerUtil.handlePlayingSpellAbility(player, sa, game);
@@ -755,6 +769,7 @@ public class PlayerControllerAi extends PlayerController {
                 return defaultVal != null && defaultVal.booleanValue();
             case UntapTimeVault: return false; // TODO Should AI skip his turn for time vault?
             case LeftOrRight: return brains.chooseDirection(sa);
+            case OddsOrEvens: return brains.chooseEvenOdd(sa); // false is Odd, true is Even
             default:
                 return MyRandom.getRandom().nextBoolean();
         }
@@ -1123,7 +1138,8 @@ public class PlayerControllerAi extends PlayerController {
                 CardCollectionView cards = CardLists.getValidCards(aiLibrary, "Creature", player, sa.getHostCard());
                 return ComputerUtilCard.getMostProminentCardName(cards);
             } else if (logic.equals("BestCreatureInComputerDeck")) {
-                return ComputerUtilCard.getBestCreatureAI(aiLibrary).getName();
+                Card bestCreature = ComputerUtilCard.getBestCreatureAI(aiLibrary);
+                return bestCreature != null ? bestCreature.getName() : "Plains";
             } else if (logic.equals("RandomInComputerDeck")) {
                 return Aggregates.random(aiLibrary).getName();
             } else if (logic.equals("MostProminentSpellInComputerDeck")) {
@@ -1214,7 +1230,7 @@ public class PlayerControllerAi extends PlayerController {
     public List<OptionalCostValue> chooseOptionalCosts(SpellAbility chosen,
             List<OptionalCostValue> optionalCostValues) {
         List<OptionalCostValue> chosenOptCosts = Lists.newArrayList();
-        Cost costSoFar = chosen.getPayCosts() != null ? chosen.getPayCosts().copy() : Cost.Zero;
+        Cost costSoFar = chosen.getPayCosts().copy();
 
         for (OptionalCostValue opt : optionalCostValues) {
             // Choose the optional cost if it can be paid (to be improved later, check for playability and other conditions perhaps)
@@ -1253,7 +1269,7 @@ public class PlayerControllerAi extends PlayerController {
         // TODO: improve the logic depending on the keyword and the playability of the cost-modified SA (enough targets present etc.)
         int chosenAmount = 0;
 
-        Cost costSoFar = sa.getPayCosts() != null ? sa.getPayCosts().copy() : Cost.Zero;
+        Cost costSoFar = sa.getPayCosts().copy();
 
         for (int i = 0; i < max; i++) {
             costSoFar.add(cost);
@@ -1269,13 +1285,16 @@ public class PlayerControllerAi extends PlayerController {
     }
 
     @Override
-    public CardCollection chooseCardsForEffectMultiple(Map<String, CardCollection> validMap, SpellAbility sa, String title) {
+    public CardCollection chooseCardsForEffectMultiple(Map<String, CardCollection> validMap, SpellAbility sa, String title, boolean isOptional) {
         CardCollection choices = new CardCollection();
 
         for (String mapKey: validMap.keySet()) {
             CardCollection cc = validMap.get(mapKey);
             cc.removeAll(choices);
-            choices.add(ComputerUtilCard.getBestAI(cc)); // TODO: should the AI limit itself here with the max number of cards in hand?
+            Card chosen = ComputerUtilCard.getBestAI(cc);
+            if (chosen != null) {
+                choices.add(chosen);
+            }
         }
 
         return choices;

forge-ai/src/main/java/forge/ai/SpecialCardAi.java

@@ -327,7 +327,7 @@ public class SpecialCardAi {
             boolean canTrample = source.hasKeyword(Keyword.TRAMPLE);
 
             if (!isBlocking && combat.getDefenderByAttacker(source) instanceof Card) {
-                int loyalty = combat.getDefenderByAttacker(source).getCounters(CounterType.LOYALTY);
+                int loyalty = combat.getDefenderByAttacker(source).getCounters(CounterEnumType.LOYALTY);
                 int totalDamageToPW = 0;
                 for (Card atk : (combat.getAttackersOf(combat.getDefenderByAttacker(source)))) {
                     if (combat.isUnblocked(atk)) {
@@ -407,7 +407,7 @@ public class SpecialCardAi {
         }
 
         public static Pair<Integer, Integer> getPumpedPT(Player ai, int power, int toughness) {
-            int energy = ai.getCounters(CounterType.ENERGY);
+            int energy = ai.getCounters(CounterEnumType.ENERGY);
             if (energy > 0) {
                 int numActivations = energy / 3;
                 for (int i = 0; i < numActivations; i++) {
@@ -708,7 +708,7 @@ public class SpecialCardAi {
             // if there's another reanimator card currently suspended, don't cast a new one until the previous
             // one resolves, otherwise the reanimation attempt will be ruined (e.g. Living End)
             for (Card ex : ai.getCardsIn(ZoneType.Exile)) {
-                if (ex.hasSVar("IsReanimatorCard") && ex.getCounters(CounterType.TIME) > 0) {
+                if (ex.hasSVar("IsReanimatorCard") && ex.getCounters(CounterEnumType.TIME) > 0) {
                     return false;
                 }
             }
@@ -767,7 +767,7 @@ public class SpecialCardAi {
                         Player controller = c.getController();
                         boolean wasCaged = false;
                         for (Card caged : CardLists.filter(controller.getCardsIn(ZoneType.Exile),
-                                CardPredicates.hasCounter(CounterType.CAGE))) {
+                                CardPredicates.hasCounter(CounterEnumType.CAGE))) {
                             if (c.getName().equals(caged.getName())) {
                                 wasCaged = true;
                                 break;
@@ -1073,7 +1073,7 @@ public class SpecialCardAi {
     // Sarkhan the Mad
     public static class SarkhanTheMad {
         public static boolean considerDig(final Player ai, final SpellAbility sa) {
-            return sa.getHostCard().getCounters(CounterType.LOYALTY) == 1;
+            return sa.getHostCard().getCounters(CounterEnumType.LOYALTY) == 1;
         }
 
         public static boolean considerMakeDragon(final Player ai, final SpellAbility sa) {
@@ -1109,7 +1109,7 @@ public class SpecialCardAi {
     // Sorin, Vengeful Bloodlord
     public static class SorinVengefulBloodlord {
         public static boolean consider(final Player ai, final SpellAbility sa) {
-            int loyalty = sa.getHostCard().getCounters(CounterType.LOYALTY);
+            int loyalty = sa.getHostCard().getCounters(CounterEnumType.LOYALTY);
             CardCollection creaturesToGet = CardLists.filter(ai.getCardsIn(ZoneType.Graveyard),
                     Predicates.and(CardPredicates.Presets.CREATURES, CardPredicates.lessCMC(loyalty - 1), new Predicate<Card>() {
                         @Override
@@ -1295,6 +1295,26 @@ public class SpecialCardAi {
         }
     }
 
+    // Timmerian Fiends
+    public static class TimmerianFiends {
+        public static boolean consider(final Player ai, final SpellAbility sa) {
+            final Card targeted = sa.getParentTargetingCard().getTargetCard();
+            if (targeted == null) {
+                return false;
+            }
+
+            if (targeted.isCreature()) {
+                if (ComputerUtil.aiLifeInDanger(ai, true, 0)) {
+                    return true; // do it, hoping to save a valuable potential blocker etc.
+                }
+                return ComputerUtilCard.evaluateCreature(targeted) >= 200; // might need tweaking
+            } else {
+                // TODO: this currently compares purely by CMC. To be somehow improved, especially for stuff like the Power Nine etc.
+                return ComputerUtilCard.evaluatePermanentList(new CardCollection(targeted)) >= 3;
+            }
+        }
+    }
+
     // Volrath's Shapeshifter
     public static class VolrathsShapeshifter {
         public static boolean consider(final Player ai, final SpellAbility sa) {
@@ -1345,7 +1365,7 @@ public class SpecialCardAi {
             Card source = sa.getHostCard();
             Game game = source.getGame();
             
-            final int loyalty = source.getCounters(CounterType.LOYALTY);
+            final int loyalty = source.getCounters(CounterEnumType.LOYALTY);
             int x = -1, best = 0;
             Card single = null;
             for (int i = 0; i < loyalty; i++) {

forge-ai/src/main/java/forge/ai/SpellAbilityAi.java

@@ -2,6 +2,7 @@ package forge.ai;
 
 import com.google.common.collect.Iterables;
 import com.google.common.collect.Lists;
+import forge.card.CardStateName;
 import forge.card.ICardFace;
 import forge.card.mana.ManaCost;
 import forge.card.mana.ManaCostParser;
@@ -167,7 +168,8 @@ public abstract class SpellAbilityAi {
 
         // a mandatory SpellAbility with targeting but without candidates,
         // does not need to go any deeper
-        if (sa.usesTargeting() && mandatory && !sa.getTargetRestrictions().hasCandidates(sa, true)) {
+        if (sa.usesTargeting() && mandatory && !sa.isTargetNumberValid()
+                && !sa.getTargetRestrictions().hasCandidates(sa, true)) {
             return false;
         }
 
@@ -247,6 +249,7 @@ public abstract class SpellAbilityAi {
     protected static boolean isSorcerySpeed(final SpellAbility sa) {
         return (sa.getRootAbility().isSpell() && sa.getHostCard().isSorcery())
             || (sa.getRootAbility().isAbility() && sa.getRestrictions().isSorcerySpeed())
+            || (sa.getRootAbility().isAdventure() && sa.getHostCard().getState(CardStateName.Adventure).getType().isSorcery())
             || (sa.isPwAbility() && !sa.getHostCard().hasKeyword("CARDNAME's loyalty abilities can be activated at instant speed."));
     }
 
@@ -264,7 +267,7 @@ public abstract class SpellAbilityAi {
 
         // TODO probably also consider if winter orb or similar are out
 
-        if (sa.getPayCosts() == null || sa instanceof AbilitySub) {
+        if (sa instanceof AbilitySub) {
             return true; // This is only true for Drawbacks and triggers
         }
         
@@ -304,7 +307,7 @@ public abstract class SpellAbilityAi {
     }
 
     @SuppressWarnings("unchecked")
-    public <T extends GameEntity> T chooseSingleEntity(Player ai, SpellAbility sa, Collection<T> options, boolean isOptional, Player targetedPlayer) {
+    public <T extends GameEntity> T chooseSingleEntity(Player ai, SpellAbility sa, Collection<T> options, boolean isOptional, Player targetedPlayer, Map<String, Object> params) {
         boolean hasPlayer = false;
         boolean hasCard = false;
         boolean hasPlaneswalker = false;
@@ -321,11 +324,11 @@ public abstract class SpellAbilityAi {
         }
 
         if (hasPlayer && hasPlaneswalker) {
-            return (T) chooseSinglePlayerOrPlaneswalker(ai, sa, (Collection<GameEntity>) options);
+            return (T) chooseSinglePlayerOrPlaneswalker(ai, sa, (Collection<GameEntity>) options, params);
         } else if (hasCard) {
-            return (T) chooseSingleCard(ai, sa, (Collection<Card>) options, isOptional, targetedPlayer);
+            return (T) chooseSingleCard(ai, sa, (Collection<Card>) options, isOptional, targetedPlayer, params);
         } else if (hasPlayer) {
-            return (T) chooseSinglePlayer(ai, sa, (Collection<Player>) options);
+            return (T) chooseSinglePlayer(ai, sa, (Collection<Player>) options, params);
         }
 
         return null;
@@ -336,17 +339,17 @@ public abstract class SpellAbilityAi {
         return spells.get(0);
     }
 
-    protected Card chooseSingleCard(Player ai, SpellAbility sa, Iterable<Card> options, boolean isOptional, Player targetedPlayer) {
+    protected Card chooseSingleCard(Player ai, SpellAbility sa, Iterable<Card> options, boolean isOptional, Player targetedPlayer, Map<String, Object> params) {
         System.err.println("Warning: default (ie. inherited from base class) implementation of chooseSingleCard is used by " + sa.getHostCard().getName() + " for " + this.getClass().getName() + ". Consider declaring an overloaded method");
         return Iterables.getFirst(options, null);
     }
     
-    protected Player chooseSinglePlayer(Player ai, SpellAbility sa, Iterable<Player> options) {
+    protected Player chooseSinglePlayer(Player ai, SpellAbility sa, Iterable<Player> options, Map<String, Object> params) {
         System.err.println("Warning: default (ie. inherited from base class) implementation of chooseSinglePlayer is used by " + sa.getHostCard().getName() + " for " + this.getClass().getName() + ". Consider declaring an overloaded method");
         return Iterables.getFirst(options, null);
     }
 
-    protected GameEntity chooseSinglePlayerOrPlaneswalker(Player ai, SpellAbility sa, Iterable<GameEntity> options) {
+    protected GameEntity chooseSinglePlayerOrPlaneswalker(Player ai, SpellAbility sa, Iterable<GameEntity> options, Map<String, Object> params) {
         System.err.println("Warning: default (ie. inherited from base class) implementation of chooseSinglePlayerOrPlaneswalker is used for " + this.getClass().getName() + ". Consider declaring an overloaded method");
         return Iterables.getFirst(options, null);
     }

forge-ai/src/main/java/forge/ai/SpellApiToAi.java

@@ -33,8 +33,7 @@ public enum SpellApiToAi {
             .put(ApiType.BidLife, BidLifeAi.class)
             .put(ApiType.Bond, BondAi.class)
             .put(ApiType.Branch, AlwaysPlayAi.class)
-            .put(ApiType.CantUntapTurn, CantUntapTurnAi.class)
-            .put(ApiType.ChangeCombatants, CannotPlayAi.class)
+            .put(ApiType.ChangeCombatants, ChangeCombatantsAi.class)
             .put(ApiType.ChangeTargets, ChangeTargetsAi.class)
             .put(ApiType.ChangeX, AlwaysPlayAi.class)
             .put(ApiType.ChangeZone, ChangeZoneAi.class)
@@ -43,6 +42,7 @@ public enum SpellApiToAi {
             .put(ApiType.ChooseCard, ChooseCardAi.class)
             .put(ApiType.ChooseColor, ChooseColorAi.class)
             .put(ApiType.ChooseDirection, ChooseDirectionAi.class)
+            .put(ApiType.ChooseEvenOdd, ChooseEvenOddAi.class)
             .put(ApiType.ChooseNumber, ChooseNumberAi.class)
             .put(ApiType.ChoosePlayer, ChoosePlayerAi.class)
             .put(ApiType.ChooseSource, ChooseSourceAi.class)
@@ -84,7 +84,7 @@ public enum SpellApiToAi {
             .put(ApiType.FlipACoin, FlipACoinAi.class)
             .put(ApiType.Fog, FogAi.class)
             .put(ApiType.GainControl, ControlGainAi.class)
-            .put(ApiType.GainControlVariant, AlwaysPlayAi.class)
+            .put(ApiType.GainControlVariant, ControlGainVariantAi.class)
             .put(ApiType.GainLife, LifeGainAi.class)
             .put(ApiType.GainOwnership, CannotPlayAi.class)
             .put(ApiType.GameDrawn, CannotPlayAi.class)
@@ -92,6 +92,7 @@ public enum SpellApiToAi {
             .put(ApiType.Goad, GoadAi.class)
             .put(ApiType.Haunt, HauntAi.class)
             .put(ApiType.ImmediateTrigger, AlwaysPlayAi.class)
+            .put(ApiType.Investigate, InvestigateAi.class)
             .put(ApiType.LoseLife, LifeLoseAi.class)
             .put(ApiType.LosesGame, GameLossAi.class)
             .put(ApiType.Mana, ManaEffectAi.class)

forge-ai/src/main/java/forge/ai/ability/AmassAi.java

@@ -1,5 +1,7 @@
 package forge.ai.ability;
 
+import java.util.Map;
+
 import com.google.common.collect.Iterables;
 import com.google.common.collect.Sets;
 
@@ -23,12 +25,12 @@ public class AmassAi extends SpellAbilityAi {
         final Game game = ai.getGame();
 
         if (!aiArmies.isEmpty()) {
-            return CardLists.count(aiArmies, CardPredicates.canReceiveCounters(CounterType.P1P1)) > 0;
+            return CardLists.count(aiArmies, CardPredicates.canReceiveCounters(CounterEnumType.P1P1)) > 0;
         } else {
             final String tokenScript = "b_0_0_zombie_army";
             final int amount = AbilityUtils.calculateAmount(host, sa.getParamOrDefault("Num", "1"), sa);
 
-            Card token = TokenInfo.getProtoType(tokenScript, sa);
+            Card token = TokenInfo.getProtoType(tokenScript, sa, false);
 
             if (token == null) {
                 return false;
@@ -44,8 +46,8 @@ public class AmassAi extends SpellAbilityAi {
             CardCollection preList = new CardCollection(token);
             game.getAction().checkStaticAbilities(false, Sets.newHashSet(token), preList);
 
-            if (token.canReceiveCounters(CounterType.P1P1)) {
-                token.setCounters(CounterType.P1P1, amount);
+            if (token.canReceiveCounters(CounterEnumType.P1P1)) {
+                token.setCounters(CounterEnumType.P1P1, amount);
             }
 
             if (token.isCreature() && token.getNetToughness() < 1) {
@@ -86,8 +88,8 @@ public class AmassAi extends SpellAbilityAi {
     }
 
     @Override
-    protected Card chooseSingleCard(Player ai, SpellAbility sa, Iterable<Card> options, boolean isOptional, Player targetedPlayer) {
-        Iterable<Card> better = CardLists.filter(options, CardPredicates.canReceiveCounters(CounterType.P1P1));
+    protected Card chooseSingleCard(Player ai, SpellAbility sa, Iterable<Card> options, boolean isOptional, Player targetedPlayer, Map<String, Object> params) {
+        Iterable<Card> better = CardLists.filter(options, CardPredicates.canReceiveCounters(CounterEnumType.P1P1));
         if (Iterables.isEmpty(better)) {
             better = options;
         }

forge-ai/src/main/java/forge/ai/ability/AnimateAi.java

@@ -247,7 +247,6 @@ public class AnimateAi extends SpellAbilityAi {
         final Player ai = sa.getActivatingPlayer();
         final PhaseHandler ph = ai.getGame().getPhaseHandler();
         final boolean alwaysActivatePWAbility = sa.hasParam("Planeswalker")
-                && sa.getPayCosts() != null
                 && sa.getPayCosts().hasSpecificCostType(CostPutCounter.class)
                 && sa.getTargetRestrictions() != null
                 && sa.getTargetRestrictions().getMinTargets(sa.getHostCard(), sa) == 0;

forge-ai/src/main/java/forge/ai/ability/AttachAi.java

@@ -398,7 +398,7 @@ public class AttachAi extends SpellAbilityAi {
                     if (!c.isCreature() && !c.getType().hasSubtype("Vehicle") && !c.isTapped()) {
                         // try to identify if this thing can actually tap
                         for (SpellAbility ab : c.getAllSpellAbilities()) {
-                            if (ab.getPayCosts() != null && ab.getPayCosts().hasTapCost()) {
+                            if (ab.getPayCosts().hasTapCost()) {
                                 return true;
                             }
                         }
@@ -560,7 +560,7 @@ public class AttachAi extends SpellAbilityAi {
                 @Override
                 public boolean apply(final Card c) {
                     for (final SpellAbility sa : c.getSpellAbilities()) {
-                        if (sa.isAbility() && sa.getPayCosts() != null && sa.getPayCosts().hasTapCost()) {
+                        if (sa.isAbility() && sa.getPayCosts().hasTapCost()) {
                             return false;
                         }
                     }
@@ -1031,7 +1031,7 @@ public class AttachAi extends SpellAbilityAi {
         Card c = null;
         List<Card> magnetList = null;
         String stCheck = null;
-        if (attachSource.isAura() || sa.hasParam("Bestow")) {
+        if (attachSource.isAura() || sa.isBestow()) {
             stCheck = "EnchantedBy";
             magnetList = CardLists.filter(list, new Predicate<Card>() {
                 @Override
@@ -1146,7 +1146,6 @@ public class AttachAi extends SpellAbilityAi {
         final List<String> keywords = new ArrayList<>();
         boolean grantingAbilities = false;
         boolean grantingExtraBlock = false;
-        boolean grantingCantUntap = false;
 
         for (final StaticAbility stAbility : attachSource.getStaticAbilities()) {
             final Map<String, String> stabMap = stAbility.getMapParams();
@@ -1166,7 +1165,6 @@ public class AttachAi extends SpellAbilityAi {
 
                 grantingAbilities |= stabMap.containsKey("AddAbility");
                 grantingExtraBlock |= stabMap.containsKey("CanBlockAmount") || stabMap.containsKey("CanBlockAny");
-                grantingCantUntap |= stabMap.containsKey("CantUntap");
 
                 String kws = stabMap.get("AddKeyword");
                 if (kws != null) {
@@ -1199,7 +1197,6 @@ public class AttachAi extends SpellAbilityAi {
         if (totToughness + totPower < 4 && (!keywords.isEmpty() || grantingExtraBlock)) {
             final int pow = totPower;
             final boolean extraBlock = grantingExtraBlock;
-            final boolean cantUntap = grantingCantUntap;
             prefList = CardLists.filter(prefList, new Predicate<Card>() {
                 @Override
                 public boolean apply(final Card c) {
@@ -1218,9 +1215,6 @@ public class AttachAi extends SpellAbilityAi {
                     if (extraBlock && CombatUtil.canBlock(c, true) && !c.canBlockAny()) {
                         return true;
                     }
-                    if (cantUntap && c.isTapped()) {
-                        return true;
-                    }
                     return false;
                 }
             });
@@ -1638,6 +1632,8 @@ public class AttachAi extends SpellAbilityAi {
         } else if (keyword.endsWith("Prevent all combat damage that would be dealt to and dealt by CARDNAME.")
                 || keyword.endsWith("Prevent all damage that would be dealt to and dealt by CARDNAME.")) {
             return ComputerUtilCombat.canAttackNextTurn(card) && card.getNetCombatDamage() >= 2;
+        } else if (keyword.endsWith("CARDNAME doesn't untap during your untap step.")) {
+            return !card.isUntapped();
         }
         return true;
     }
@@ -1708,12 +1704,12 @@ public class AttachAi extends SpellAbilityAi {
     }
 
     @Override
-    protected Card chooseSingleCard(Player ai, SpellAbility sa, Iterable<Card> options, boolean isOptional, Player targetedPlayer) {
+    protected Card chooseSingleCard(Player ai, SpellAbility sa, Iterable<Card> options, boolean isOptional, Player targetedPlayer, Map<String, Object> params) {
         return attachToCardAIPreferences(ai, sa, true);
     }
 
     @Override
-    protected Player chooseSinglePlayer(Player ai, SpellAbility sa, Iterable<Player> options) {
+    protected Player chooseSinglePlayer(Player ai, SpellAbility sa, Iterable<Player> options, Map<String, Object> params) {
         return attachToPlayerAIPreferences(ai, sa, true);
     }
 }

forge-ai/src/main/java/forge/ai/ability/BondAi.java

@@ -17,6 +17,8 @@
  */
 package forge.ai.ability;
 
+import java.util.Map;
+
 import forge.ai.ComputerUtilCard;
 import forge.ai.SpellAbilityAi;
 import forge.game.card.Card;
@@ -50,7 +52,7 @@ public final class BondAi extends SpellAbilityAi {
     
 
     @Override
-    protected Card chooseSingleCard(Player ai, SpellAbility sa, Iterable<Card> options, boolean isOptional, Player targetedPlayer) {
+    protected Card chooseSingleCard(Player ai, SpellAbility sa, Iterable<Card> options, boolean isOptional, Player targetedPlayer, Map<String, Object> params) {
         return ComputerUtilCard.getBestCreatureAI(options);
     }
 

forge-ai/src/main/java/forge/ai/ability/CantUntapTurnAi.java

@@ -1,64 +0,0 @@
-package forge.ai.ability;
-
-import com.google.common.base.Predicate;
-import com.google.common.base.Predicates;
-import forge.ai.ComputerUtilCard;
-import forge.ai.SpellAbilityAi;
-import forge.game.card.Card;
-import forge.game.card.CardCollection;
-import forge.game.card.CardLists;
-import forge.game.card.CardPredicates;
-import forge.game.cost.CostPutCounter;
-import forge.game.player.Player;
-import forge.game.spellability.SpellAbility;
-import forge.game.zone.ZoneType;
-
-public class CantUntapTurnAi extends SpellAbilityAi {
-    @Override
-    protected boolean canPlayAI(Player ai, SpellAbility sa) {
-        if (sa.usesTargeting()) {
-            CardCollection oppCards = ai.getOpponents().getCardsIn(ZoneType.Battlefield);
-
-            CardCollection relevantToHold = CardLists.filter(oppCards,
-                    Predicates.and(CardPredicates.Presets.TAPPED, new Predicate<Card>() {
-                @Override
-                public boolean apply(Card card) {
-                    if (card.isCreature()) {
-                        return true;
-                    }
-                    for (final SpellAbility ab : card.getSpellAbilities()) {
-                        if (ab.isAbility() && (ab.getPayCosts() != null) && ab.getPayCosts().hasTapCost()) {
-                            return true;
-                        }
-                    }
-                    return false;
-                }
-            }));
-
-            Card bestToTap = ComputerUtilCard.getBestAI(relevantToHold);
-            Card validTarget = ComputerUtilCard.getBestAI(CardLists.filter(oppCards, CardPredicates.Presets.TAPPED));
-            if (validTarget == null) {
-                validTarget = ComputerUtilCard.getBestAI(oppCards);
-            }
-
-            if (bestToTap != null) {
-                sa.getTargets().add(bestToTap);
-                return true;
-            } else if (sa.hasParam("Planeswalker")
-                    && sa.getPayCosts() != null && sa.getPayCosts().hasSpecificCostType(CostPutCounter.class)) {
-                sa.getTargets().add(validTarget);
-                return true;
-            }
-
-            return false;
-        }
-
-
-        return true;
-    }
-
-    @Override
-    protected boolean doTriggerAINoCost(Player aiPlayer, SpellAbility sa, boolean mandatory) {
-        return mandatory || canPlayAI(aiPlayer, sa);
-    }
-}

forge-ai/src/main/java/forge/ai/ability/ChangeCombatantsAi.java

@@ -0,0 +1,66 @@
+package forge.ai.ability;
+
+import forge.ai.SpellAbilityAi;
+import forge.game.GameEntity;
+import forge.game.player.Player;
+import forge.game.player.PlayerCollection;
+import forge.game.player.PlayerPredicates;
+import forge.game.spellability.SpellAbility;
+
+import java.util.Collection;
+import java.util.Map;
+
+public class ChangeCombatantsAi extends SpellAbilityAi {
+    /* (non-Javadoc)
+     * @see forge.card.abilityfactory.SpellAiLogic#canPlayAI(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility)
+     */
+    @Override
+    protected boolean canPlayAI(Player aiPlayer, SpellAbility sa) {
+        // TODO: Extend this if possible for cards that have this as an activated ability
+        return false;
+    }
+
+    @Override
+    protected boolean doTriggerAINoCost(Player aiPlayer, SpellAbility sa, boolean mandatory) {
+        return mandatory || canPlayAI(aiPlayer, sa);
+    }
+
+    /* (non-Javadoc)
+     * @see forge.card.abilityfactory.SpellAiLogic#chkAIDrawback(java.util.Map, forge.card.spellability.SpellAbility, forge.game.player.Player)
+     */
+    @Override
+    public boolean chkAIDrawback(SpellAbility sa, Player aiPlayer) {
+        final String logic = sa.getParamOrDefault("AILogic", "");
+
+        if (logic.equals("WeakestOppExceptCtrl")) {
+            PlayerCollection targetableOpps = aiPlayer.getOpponents();
+            targetableOpps.remove(sa.getHostCard().getController());
+            if (targetableOpps.isEmpty()) {
+                return false;
+            }
+
+            return true;
+        }
+
+        return false;
+    }
+
+    @Override
+    public <T extends GameEntity> T chooseSingleEntity(Player ai, SpellAbility sa, Collection<T> options, boolean isOptional, Player targetedPlayer, Map<String, Object> params) {
+        PlayerCollection targetableOpps = new PlayerCollection();
+        for (GameEntity p : options) {
+            if (p instanceof Player && !p.equals(sa.getHostCard().getController())) {
+                Player pp = (Player)p;
+                if (pp.isOpponentOf(ai)) {
+                    targetableOpps.add(pp);
+                }
+            }
+        }
+
+        Player weakestTargetableOpp = targetableOpps.filter(PlayerPredicates.isTargetableBy(sa))
+                .min(PlayerPredicates.compareByLife());
+
+        return (T)weakestTargetableOpp;
+    }
+}
+

forge-ai/src/main/java/forge/ai/ability/ChangeZoneAi.java

@@ -1065,8 +1065,7 @@ public class ChangeZoneAi extends SpellAbilityAi {
         if (destination.equals(ZoneType.Exile) || origin.contains(ZoneType.Battlefield)) {
 
             // don't rush bouncing stuff when not going to attack
-            if (!immediately && sa.getPayCosts() != null
-                    && game.getPhaseHandler().getPhase().isBefore(PhaseType.MAIN2)
+            if (!immediately && game.getPhaseHandler().getPhase().isBefore(PhaseType.MAIN2)
                     && game.getPhaseHandler().isPlayerTurn(ai)
                     && ai.getCreaturesInPlay().isEmpty()) {
                 return false;
@@ -1103,8 +1102,8 @@ public class ChangeZoneAi extends SpellAbilityAi {
             }
         }
 
-        boolean doWithoutTarget = sa.hasParam("Planeswalker") && sa.getTargetRestrictions() != null
-                && sa.getTargetRestrictions().getMinTargets(source, sa) == 0 && sa.getPayCosts() != null
+        boolean doWithoutTarget = sa.hasParam("Planeswalker") && sa.usesTargeting()
+                && sa.getTargetRestrictions().getMinTargets(source, sa) == 0
                 && sa.getPayCosts().hasSpecificCostType(CostPutCounter.class);
 
         if (list.isEmpty() && !doWithoutTarget) {
@@ -1325,11 +1324,11 @@ public class ChangeZoneAi extends SpellAbilityAi {
                 Collections.sort(aiPlaneswalkers, new Comparator<Card>() {
                     @Override
                     public int compare(final Card a, final Card b) {
-                        return a.getCounters(CounterType.LOYALTY) - b.getCounters(CounterType.LOYALTY);
+                        return a.getCounters(CounterEnumType.LOYALTY) - b.getCounters(CounterEnumType.LOYALTY);
                     }
                 });
                 for (Card pw : aiPlaneswalkers) {
-                    int curLoyalty = pw.getCounters(CounterType.LOYALTY);
+                    int curLoyalty = pw.getCounters(CounterEnumType.LOYALTY);
                     int freshLoyalty = Integer.valueOf(pw.getCurrentState().getBaseLoyalty());
                     if (freshLoyalty - curLoyalty >= loyaltyDiff && curLoyalty <= maxLoyaltyToConsider) {
                         return pw;
@@ -1618,7 +1617,7 @@ public class ChangeZoneAi extends SpellAbilityAi {
 
 
     @Override
-    public Card chooseSingleCard(Player ai, SpellAbility sa, Iterable<Card> options, boolean isOptional, Player targetedPlayer) {
+    public Card chooseSingleCard(Player ai, SpellAbility sa, Iterable<Card> options, boolean isOptional, Player targetedPlayer, Map<String, Object> params) {
         // Called when looking for creature to attach aura or equipment
         return ComputerUtilCard.getBestAI(options);
     }
@@ -1627,7 +1626,7 @@ public class ChangeZoneAi extends SpellAbilityAi {
      * @see forge.card.ability.SpellAbilityAi#chooseSinglePlayer(forge.game.player.Player, forge.card.spellability.SpellAbility, java.util.List)
      */
     @Override
-    public Player chooseSinglePlayer(Player ai, SpellAbility sa, Iterable<Player> options) {
+    public Player chooseSinglePlayer(Player ai, SpellAbility sa, Iterable<Player> options, Map<String, Object> params) {
         // Currently only used by Curse of Misfortunes, so this branch should never get hit
         // But just in case it does, just select the first option
         return Iterables.getFirst(options, null);
@@ -1790,6 +1789,7 @@ public class ChangeZoneAi extends SpellAbilityAi {
     }
 
     public boolean doReturnCommanderLogic(SpellAbility sa, Player aiPlayer) {
+        @SuppressWarnings("unchecked")
         Map<AbilityKey, Object> originalParams = (Map<AbilityKey, Object>)sa.getReplacingObject(AbilityKey.OriginalParams);
         SpellAbility causeSa = (SpellAbility)originalParams.get(AbilityKey.Cause);
         SpellAbility causeSub = null;

forge-ai/src/main/java/forge/ai/ability/CharmAi.java

@@ -11,6 +11,7 @@ import forge.util.MyRandom;
 import forge.util.collect.FCollection;
 
 import java.util.List;
+import java.util.Map;
 
 public class CharmAi extends SpellAbilityAi {
     @Override
@@ -232,7 +233,7 @@ public class CharmAi extends SpellAbilityAi {
     } 
 
     @Override
-    public Player chooseSinglePlayer(Player ai, SpellAbility sa, Iterable<Player> opponents) {
+    public Player chooseSinglePlayer(Player ai, SpellAbility sa, Iterable<Player> opponents, Map<String, Object> params) {
         return Aggregates.random(opponents);
     }
 }

forge-ai/src/main/java/forge/ai/ability/ChooseCardAi.java

@@ -2,6 +2,7 @@ package forge.ai.ability;
 
 import java.util.Collections;
 import java.util.List;
+import java.util.Map;
 
 import com.google.common.base.Predicate;
 import com.google.common.base.Predicates;
@@ -20,7 +21,7 @@ import forge.game.card.CardCollectionView;
 import forge.game.card.CardLists;
 import forge.game.card.CardPredicates;
 import forge.game.card.CardPredicates.Presets;
-import forge.game.card.CounterType;
+import forge.game.card.CounterEnumType;
 import forge.game.combat.Combat;
 import forge.game.keyword.Keyword;
 import forge.game.phase.PhaseType;
@@ -99,7 +100,7 @@ public class ChooseCardAi extends SpellAbilityAi {
             });
             return !choices.isEmpty();
         } else if (aiLogic.equals("Ashiok")) {
-            final int loyalty = host.getCounters(CounterType.LOYALTY) - 1;
+            final int loyalty = host.getCounters(CounterEnumType.LOYALTY) - 1;
             for (int i = loyalty; i >= 0; i--) {
                 host.setSVar("ChosenX", "Number$" + i);
                 choices = ai.getGame().getCardsIn(choiceZone);
@@ -145,7 +146,7 @@ public class ChooseCardAi extends SpellAbilityAi {
      * @see forge.card.ability.SpellAbilityAi#chooseSingleCard(forge.card.spellability.SpellAbility, java.util.List, boolean)
      */
     @Override
-    public Card chooseSingleCard(final Player ai, final SpellAbility sa, Iterable<Card> options, boolean isOptional, Player targetedPlayer) {
+    public Card chooseSingleCard(final Player ai, final SpellAbility sa, Iterable<Card> options, boolean isOptional, Player targetedPlayer, Map<String, Object> params) {
         final Card host = sa.getHostCard();
         final Player ctrl = host.getController();
         final String logic = sa.getParam("AILogic");
@@ -233,7 +234,7 @@ public class ChooseCardAi extends SpellAbilityAi {
                         return false;
                     }
                     for (SpellAbility sa : c.getAllSpellAbilities()) {
-                        if (sa.getPayCosts() != null && sa.getPayCosts().hasTapCost()) {
+                        if (sa.getPayCosts().hasTapCost()) {
                             return false;
                         }
                     }

forge-ai/src/main/java/forge/ai/ability/ChooseCardNameAi.java

@@ -1,6 +1,7 @@
 package forge.ai.ability;
 
 import java.util.List;
+import java.util.Map;
 
 import com.google.common.collect.Iterables;
 import com.google.common.collect.Lists;
@@ -23,7 +24,6 @@ public class ChooseCardNameAi extends SpellAbilityAi {
 
     @Override
     protected boolean canPlayAI(Player ai, SpellAbility sa) {
-        Card source = sa.getHostCard();
         if (sa.hasParam("AILogic")) {
             // Don't tap creatures that may be able to block
             if (ComputerUtil.waitForBlocking(sa)) {
@@ -60,7 +60,7 @@ public class ChooseCardNameAi extends SpellAbilityAi {
      * @see forge.card.ability.SpellAbilityAi#chooseSingleCard(forge.card.spellability.SpellAbility, java.util.List, boolean)
      */
     @Override
-    public Card chooseSingleCard(final Player ai, SpellAbility sa, Iterable<Card> options, boolean isOptional, Player targetedPlayer) {
+    public Card chooseSingleCard(final Player ai, SpellAbility sa, Iterable<Card> options, boolean isOptional, Player targetedPlayer, Map<String, Object> params) {
 
         return ComputerUtilCard.getBestAI(options);
     }

forge-ai/src/main/java/forge/ai/ability/ChooseColorAi.java

@@ -8,10 +8,7 @@ import forge.ai.SpecialCardAi;
 import forge.ai.SpellAbilityAi;
 import forge.card.MagicColor;
 import forge.game.Game;
-import forge.game.card.Card;
-import forge.game.card.CardCollectionView;
-import forge.game.card.CardLists;
-import forge.game.card.CardPredicates;
+import forge.game.card.*;
 import forge.game.phase.PhaseHandler;
 import forge.game.phase.PhaseType;
 import forge.game.player.Player;
@@ -69,9 +66,7 @@ public class ChooseColorAi extends SpellAbilityAi {
                 }
             }
             return false;
-        }
-
-        if (logic.equals("MostProminentInComputerDeck")) {
+        } else if (logic.equals("MostProminentInComputerDeck")) {
             if ("Astral Cornucopia".equals(sourceName)) {
                 // activate in Main 2 hoping that the extra mana surplus will make a difference
                 // if there are some nonland permanents in hand
@@ -80,6 +75,11 @@ public class ChooseColorAi extends SpellAbilityAi {
 
                 return permanents.size() > 0 && ph.is(PhaseType.MAIN2, ai);
             }
+        } else if (logic.equals("HighestDevotionToColor")) {
+            // currently only works more or less reliably in Main2 to cast own spells
+            if (!ph.is(PhaseType.MAIN2, ai)) {
+                return false;
+            }
         }
 
         boolean chance = MyRandom.getRandom().nextFloat() <= Math.pow(.6667, sa.getActivationsThisTurn());

forge-ai/src/main/java/forge/ai/ability/ChooseCompanionAi.java

@@ -0,0 +1,29 @@
+package forge.ai.ability;
+
+import com.google.common.collect.Lists;
+import forge.ai.SpellAbilityAi;
+import forge.game.card.Card;
+import forge.game.player.Player;
+import forge.game.spellability.SpellAbility;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+
+public class ChooseCompanionAi extends SpellAbilityAi {
+
+    /* (non-Javadoc)
+     * @see forge.card.ability.SpellAbilityAi#chooseSingleCard(forge.card.spellability.SpellAbility, java.util.List, boolean)
+     */
+    @Override
+    public Card chooseSingleCard(final Player ai, final SpellAbility sa, Iterable<Card> options, boolean isOptional, Player targetedPlayer, Map<String, Object> params) {
+        List<Card> cards = Lists.newArrayList(options);
+        if (cards.isEmpty()) {
+            return null;
+        }
+
+        Collections.shuffle(cards);
+        return cards.get(0);
+    }
+}
+

forge-ai/src/main/java/forge/ai/ability/ChooseDirectionAi.java

@@ -46,6 +46,6 @@ public class ChooseDirectionAi extends SpellAbilityAi {
 
     @Override
     protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
-        return canPlayAI(ai, sa);
+        return mandatory || canPlayAI(ai, sa);
     }
 }

forge-ai/src/main/java/forge/ai/ability/ChooseEvenOddAi.java

@@ -0,0 +1,36 @@
+package forge.ai.ability;
+
+import forge.ai.SpellAbilityAi;
+import forge.game.player.Player;
+import forge.game.spellability.SpellAbility;
+import forge.game.spellability.TargetRestrictions;
+import forge.util.MyRandom;
+
+public class ChooseEvenOddAi extends SpellAbilityAi {
+
+    @Override
+    protected boolean canPlayAI(Player aiPlayer, SpellAbility sa) {
+        if (!sa.hasParam("AILogic")) {
+            return false;
+        }
+        TargetRestrictions tgt = sa.getTargetRestrictions();
+        if (tgt != null) {
+            sa.resetTargets();
+            Player opp = aiPlayer.getWeakestOpponent();
+            if (sa.canTarget(opp)) {
+                sa.getTargets().add(opp);
+            } else {
+                return false;
+            }
+        }
+        boolean chance = MyRandom.getRandom().nextFloat() <= Math.pow(.6667, sa.getActivationsThisTurn());
+        return chance;
+    }
+
+    @Override
+    protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
+        return mandatory || canPlayAI(ai, sa);
+    }
+
+}
+

forge-ai/src/main/java/forge/ai/ability/ChooseGenericEffectAi.java

@@ -244,7 +244,7 @@ public class ChooseGenericEffectAi extends SpellAbilityAi {
             SpellAbility counterSA = spells.get(0), tokenSA = spells.get(1);
 
             // check for something which might prevent the counters to be placed on host
-            if (!host.canReceiveCounters(CounterType.P1P1)) {
+            if (!host.canReceiveCounters(CounterEnumType.P1P1)) {
                 return tokenSA;
             }
 
@@ -256,7 +256,7 @@ public class ChooseGenericEffectAi extends SpellAbilityAi {
             // need a copy for one with extra +1/+1 counter boost,
             // without causing triggers to run
             final Card copy = CardUtil.getLKICopy(host);
-            copy.setCounters(CounterType.P1P1, copy.getCounters(CounterType.P1P1) + n);
+            copy.setCounters(CounterEnumType.P1P1, copy.getCounters(CounterEnumType.P1P1) + n);
             copy.setZone(host.getZone());
 
             // if host would put into the battlefield attacking
@@ -281,10 +281,10 @@ public class ChooseGenericEffectAi extends SpellAbilityAi {
             // TODO check for trigger to turn token ETB into +1/+1 counter for host
             // TODO check for trigger to turn token ETB into damage or life loss for opponent
             // in this cases Token might be prefered even if they would not survive
-            final Card tokenCard = TokenAi.spawnToken(player, tokenSA, true);
+            final Card tokenCard = TokenAi.spawnToken(player, tokenSA);
 
             // Token would not survive
-            if (tokenCard.getNetToughness() < 1) {
+            if (!tokenCard.isCreature() || tokenCard.getNetToughness() < 1) {
                 return counterSA;
             }
 
@@ -362,7 +362,7 @@ public class ChooseGenericEffectAi extends SpellAbilityAi {
         game.getAction().checkStaticAbilities(false);
 
         // can't gain counters, use Haste
-        if (!copy.canReceiveCounters(CounterType.P1P1)) {
+        if (!copy.canReceiveCounters(CounterEnumType.P1P1)) {
             return true;
         }
 

forge-ai/src/main/java/forge/ai/ability/ChoosePlayerAi.java

@@ -9,6 +9,7 @@ import forge.game.spellability.SpellAbility;
 import forge.game.zone.ZoneType;
 
 import java.util.List;
+import java.util.Map;
 
 public class ChoosePlayerAi extends SpellAbilityAi {
     @Override
@@ -27,7 +28,7 @@ public class ChoosePlayerAi extends SpellAbilityAi {
     }
 
     @Override
-    public Player chooseSinglePlayer(Player ai, SpellAbility sa, Iterable<Player> choices) {
+    public Player chooseSinglePlayer(Player ai, SpellAbility sa, Iterable<Player> choices, Map<String, Object> params) {
         Player chosen = null;
         if ("Curse".equals(sa.getParam("AILogic"))) {
             for (Player pc : choices) {

forge-ai/src/main/java/forge/ai/ability/ChooseSourceAi.java

@@ -1,6 +1,7 @@
 package forge.ai.ability;
 
 import java.util.List;
+import java.util.Map;
 
 import com.google.common.base.Predicate;
 import com.google.common.base.Predicates;
@@ -126,7 +127,7 @@ public class ChooseSourceAi extends SpellAbilityAi {
     
     
     @Override
-    public Card chooseSingleCard(final Player aiChoser, SpellAbility sa, Iterable<Card> options, boolean isOptional, Player targetedPlayer) {
+    public Card chooseSingleCard(final Player aiChoser, SpellAbility sa, Iterable<Card> options, boolean isOptional, Player targetedPlayer, Map<String, Object> params) {
         if ("NeedsPrevention".equals(sa.getParam("AILogic"))) {
             final Player ai = sa.getActivatingPlayer();
             final Game game = ai.getGame();

forge-ai/src/main/java/forge/ai/ability/ClashAi.java

@@ -1,6 +1,8 @@
 package forge.ai.ability;
 
 
+import java.util.Map;
+
 import com.google.common.collect.Iterables;
 import forge.ai.ComputerUtilCard;
 
@@ -56,7 +58,7 @@ public class ClashAi extends SpellAbilityAi {
      * forge.game.spellability.SpellAbility, java.lang.Iterable)
      */
     @Override
-    protected Player chooseSinglePlayer(Player ai, SpellAbility sa, Iterable<Player> options) {
+    protected Player chooseSinglePlayer(Player ai, SpellAbility sa, Iterable<Player> options, Map<String, Object> params) {
         for (Player p : options) {
             if (p.getCardsIn(ZoneType.Library).size() == 0)
                 return p;
@@ -82,7 +84,7 @@ public class ClashAi extends SpellAbilityAi {
 
         PlayerCollection players = ai.getOpponents().filter(PlayerPredicates.isTargetableBy(sa));
         // use chooseSinglePlayer function to the select player
-        Player chosen = chooseSinglePlayer(ai, sa, players);
+        Player chosen = chooseSinglePlayer(ai, sa, players, null);
         if (chosen != null) {
             sa.resetTargets();
             sa.getTargets().add(chosen);

forge-ai/src/main/java/forge/ai/ability/CloneAi.java

@@ -15,6 +15,7 @@ import forge.game.spellability.SpellAbility;
 import forge.game.zone.ZoneType;
 
 import java.util.List;
+import java.util.Map;
 
 public class CloneAi extends SpellAbilityAi {
 
@@ -169,7 +170,7 @@ public class CloneAi extends SpellAbilityAi {
      */
     @Override
     protected Card chooseSingleCard(Player ai, SpellAbility sa, Iterable<Card> options, boolean isOptional,
-            Player targetedPlayer) {
+            Player targetedPlayer, Map<String, Object> params) {
 
         final Card host = sa.getHostCard();
         final Player ctrl = host.getController();

forge-ai/src/main/java/forge/ai/ability/ControlGainAi.java

@@ -18,6 +18,7 @@
 package forge.ai.ability;
 
 import java.util.List;
+import java.util.Map;
 
 import com.google.common.base.Predicate;
 import com.google.common.collect.Iterables;
@@ -34,12 +35,12 @@ import forge.game.card.CardCollectionView;
 import forge.game.card.CardLists;
 import forge.game.phase.PhaseType;
 import forge.game.player.Player;
+import forge.game.player.PlayerCollection;
 import forge.game.player.PlayerPredicates;
 import forge.game.spellability.SpellAbility;
 import forge.game.spellability.TargetRestrictions;
 import forge.game.zone.ZoneType;
 import forge.util.Aggregates;
-import forge.util.collect.FCollectionView;
 
 
 //AB:GainControl|ValidTgts$Creature|TgtPrompt$Select target legendary creature|LoseControl$Untap,LoseControl|SpellDescription$Gain control of target xxxxxxx
@@ -54,8 +55,6 @@ import forge.util.collect.FCollectionView;
 //            (as a "&"-separated list; like Haste, Sacrifice CARDNAME at EOT, any standard keyword)
 //  OppChoice - set to True if opponent chooses creature (for Preacher) - not implemented yet
 //  Untap - set to True if target card should untap when control is taken
-//  DestroyTgt - actions upon which the tgt should be destroyed.  same list as LoseControl
-//  NoRegen - set if destroyed creature can't be regenerated.  used only with DestroyTgt
 
 /**
  * <p>
@@ -77,7 +76,7 @@ public class ControlGainAi extends SpellAbilityAi {
 
         final TargetRestrictions tgt = sa.getTargetRestrictions();
         final Game game = ai.getGame();
-        final FCollectionView<Player> opponents = ai.getOpponents();
+        final PlayerCollection opponents = ai.getOpponents();
 
         // if Defined, then don't worry about targeting
         if (tgt == null) {
@@ -94,20 +93,21 @@ public class ControlGainAi extends SpellAbilityAi {
                 sa.setTargetingPlayer(targetingPlayer);
                 return targetingPlayer.getController().chooseTargetsFor(sa);
             }
-            if (tgt.isRandomTarget()) {
-                sa.getTargets().add(Aggregates.random(tgt.getAllCandidates(sa, false)));
-            }
+
             if (tgt.canOnlyTgtOpponent()) {
-                List<Player> oppList = Lists
-                        .newArrayList(Iterables.filter(opponents, PlayerPredicates.isTargetableBy(sa)));
+                List<Player> oppList = opponents.filter(PlayerPredicates.isTargetableBy(sa));
 
                 if (oppList.isEmpty()) {
                     return false;
                 }
 
+                if (tgt.isRandomTarget()) {
+                    sa.getTargets().add(Aggregates.random(oppList));
+                } else {
                     sa.getTargets().add(oppList.get(0));
                 }
             }
+        }
 
         // Don't steal something if I can't Attack without, or prevent it from
         // blocking at least
@@ -303,7 +303,7 @@ public class ControlGainAi extends SpellAbilityAi {
     } // pumpDrawbackAI()
 
     @Override
-    protected Player chooseSinglePlayer(Player ai, SpellAbility sa, Iterable<Player> options) {
+    protected Player chooseSinglePlayer(Player ai, SpellAbility sa, Iterable<Player> options, Map<String, Object> params) {
         final List<Card> cards = Lists.newArrayList();
         for (Player p : options) {
             cards.addAll(p.getCreaturesInPlay());

forge-ai/src/main/java/forge/ai/ability/ControlGainVariantAi.java

@@ -0,0 +1,82 @@
+/*
+ * Forge: Play Magic: the Gathering.
+ * Copyright (C) 2011  Forge Team
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package forge.ai.ability;
+
+import java.util.List;
+import java.util.Map;
+
+import com.google.common.base.Predicate;
+import com.google.common.base.Predicates;
+import com.google.common.collect.Iterables;
+
+import forge.ai.ComputerUtilCard;
+import forge.ai.SpellAbilityAi;
+import forge.game.card.Card;
+import forge.game.card.CardLists;
+import forge.game.card.CardPredicates;
+import forge.game.player.Player;
+import forge.game.spellability.SpellAbility;
+import forge.game.zone.ZoneType;
+
+
+/**
+ * <p>
+ * AbilityFactory_GainControlVariant class.
+ * </p>
+ * 
+ * @author Forge
+ * @version $Id: AbilityFactoryGainControl.java 17764 2012-10-29 11:04:18Z Sloth $
+ */
+public class ControlGainVariantAi extends SpellAbilityAi {
+    @Override
+    protected boolean canPlayAI(final Player ai, final SpellAbility sa) {
+
+        String logic = sa.getParam("AILogic");
+
+        if ("GainControlOwns".equals(logic)) {
+            List<Card> list = CardLists.filter(ai.getGame().getCardsIn(ZoneType.Battlefield), new Predicate<Card>() {
+                @Override
+                public boolean apply(final Card crd) {
+                    return crd.isCreature() && !crd.getController().equals(crd.getOwner());
+                }
+            });
+            if (list.isEmpty()) {
+                return false;
+            }
+            for (final Card c : list) {
+                if (ai.equals(c.getController())) {
+                    return false;
+                }
+            }
+        }
+
+        return true;
+
+    }
+
+    @Override
+    public Card chooseSingleCard(Player ai, SpellAbility sa, Iterable<Card> options, boolean isOptional, Player targetedPlayer, Map<String, Object> params) {
+        Iterable<Card> otherCtrl = CardLists.filter(options, Predicates.not(CardPredicates.isController(ai)));
+        if (Iterables.isEmpty(otherCtrl)) {
+            return ComputerUtilCard.getWorstAI(options);
+        } else {
+            return ComputerUtilCard.getBestAI(otherCtrl);
+        }
+    }
+
+}

forge-ai/src/main/java/forge/ai/ability/CopyPermanentAi.java

@@ -5,6 +5,7 @@ import com.google.common.base.Predicates;
 import com.google.common.collect.Iterables;
 import forge.ai.*;
 import forge.game.Game;
+import forge.game.ability.AbilityKey;
 import forge.game.ability.AbilityUtils;
 import forge.game.card.*;
 import forge.game.card.CardPredicates.Presets;
@@ -18,6 +19,7 @@ import forge.game.zone.ZoneType;
 
 import java.util.Collection;
 import java.util.List;
+import java.util.Map;
 
 public class CopyPermanentAi extends SpellAbilityAi {
     @Override
@@ -180,6 +182,13 @@ public class CopyPermanentAi extends SpellAbilityAi {
             // if no targeting, it should always be ok
         }
 
+        if ("TriggeredCardController".equals(sa.getParam("Controller"))) {
+            Card trigCard = (Card)sa.getTriggeringObject(AbilityKey.Card);
+            if (!mandatory && trigCard != null && trigCard.getController().isOpponentOf(aiPlayer)) {
+                return false;
+            }
+        }
+
         return true;
     }
     
@@ -196,7 +205,7 @@ public class CopyPermanentAi extends SpellAbilityAi {
      * @see forge.card.ability.SpellAbilityAi#chooseSingleCard(forge.game.player.Player, forge.card.spellability.SpellAbility, java.util.List, boolean)
      */
     @Override
-    public Card chooseSingleCard(Player ai, SpellAbility sa, Iterable<Card> options, boolean isOptional, Player targetedPlayer) {
+    public Card chooseSingleCard(Player ai, SpellAbility sa, Iterable<Card> options, boolean isOptional, Player targetedPlayer, Map<String, Object> params) {
         // Select a card to attach to
         CardCollection betterOptions = getBetterOptions(ai, sa, options, isOptional);
         if (!betterOptions.isEmpty()) {
@@ -215,7 +224,7 @@ public class CopyPermanentAi extends SpellAbilityAi {
     }
 
     @Override
-    protected Player chooseSinglePlayer(Player ai, SpellAbility sa, Iterable<Player> options) {
+    protected Player chooseSinglePlayer(Player ai, SpellAbility sa, Iterable<Player> options, Map<String, Object> params) {
         final List<Card> cards = new PlayerCollection(options).getCreaturesInPlay();
         Card chosen = ComputerUtilCard.getBestCreatureAI(cards);
         return chosen != null ? chosen.getController() : Iterables.getFirst(options, null);

forge-ai/src/main/java/forge/ai/ability/CopySpellAbilityAi.java

@@ -29,8 +29,8 @@ public class CopySpellAbilityAi extends SpellAbilityAi {
 
         final SpellAbility top = game.getStack().peekAbility();
         if (top != null
-                && top.getPayCosts() != null && top.getPayCosts().getCostMana() != null
-                && sa.getPayCosts() != null && sa.getPayCosts().getCostMana() != null
+                && top.getPayCosts().getCostMana() != null
+                && sa.getPayCosts().getCostMana() != null
                 && top.getPayCosts().getCostMana().getMana().getCMC() >= sa.getPayCosts().getCostMana().getMana().getCMC() + diff) {
             // The copied spell has a significantly higher CMC than the copy spell, consider copying
             chance = 100;

forge-ai/src/main/java/forge/ai/ability/CountersAi.java

@@ -26,7 +26,7 @@ import forge.game.card.Card;
 import forge.game.card.CardCollection;
 import forge.game.card.CardCollectionView;
 import forge.game.card.CardLists;
-import forge.game.card.CounterType;
+import forge.game.card.CounterEnumType;
 import forge.game.keyword.Keyword;
 import forge.util.Aggregates;
 
@@ -97,7 +97,7 @@ public abstract class CountersAi {
             final CardCollection boon = CardLists.filter(list, new Predicate<Card>() {
                 @Override
                 public boolean apply(final Card c) {
-                    return c.getCounters(CounterType.DIVINITY) == 0;
+                    return c.getCounters(CounterEnumType.DIVINITY) == 0;
                 }
             });
             choice = ComputerUtilCard.getMostExpensivePermanentAI(boon, null, false);

forge-ai/src/main/java/forge/ai/ability/CountersMoveAi.java

@@ -42,14 +42,14 @@ public class CountersMoveAi extends SpellAbilityAi {
     protected boolean checkPhaseRestrictions(final Player ai, final SpellAbility sa, final PhaseHandler ph) {
         final Card host = sa.getHostCard();
         final String type = sa.getParam("CounterType");
-        final CounterType cType = "Any".equals(type) ? null : CounterType.valueOf(type);
+        final CounterType cType = "Any".equals(type) ? null : CounterType.getType(type);
 
         // Don't tap creatures that may be able to block
         if (ComputerUtil.waitForBlocking(sa)) {
             return false;
         }
 
-        if (CounterType.P1P1.equals(cType) && sa.hasParam("Source")) {
+        if (CounterEnumType.P1P1.equals(cType) && sa.hasParam("Source")) {
             int amount = calcAmount(sa, cType);
             final List<Card> srcCards = AbilityUtils.getDefinedCards(host, sa.getParam("Source"), sa);
             if (ph.getPlayerTurn().isOpponentOf(ai)) {
@@ -92,7 +92,7 @@ public class CountersMoveAi extends SpellAbilityAi {
             // for Simic Fluxmage and other
             return ph.getNextTurn().equals(ai) && !ph.getPhase().isBefore(PhaseType.END_OF_TURN);
 
-        } else if (CounterType.P1P1.equals(cType) && sa.hasParam("Defined")) {
+        } else if (CounterEnumType.P1P1.equals(cType) && sa.hasParam("Defined")) {
             // something like Cyptoplast Root-kin
             if (ph.getPlayerTurn().isOpponentOf(ai)) {
                 if (ph.inCombat() && ph.getPhase().isBefore(PhaseType.COMBAT_DECLARE_BLOCKERS)) {
@@ -115,6 +115,7 @@ public class CountersMoveAi extends SpellAbilityAi {
     protected boolean doTriggerAINoCost(final Player ai, SpellAbility sa, boolean mandatory) {
 
         if (sa.usesTargeting()) {
+            sa.resetTargets();
 
             if (!moveTgtAI(ai, sa) && !mandatory) {
                 return false;
@@ -142,7 +143,7 @@ public class CountersMoveAi extends SpellAbilityAi {
             final Card host = sa.getHostCard();
 
             final String type = sa.getParam("CounterType");
-            final CounterType cType = "Any".equals(type) ? null : CounterType.valueOf(type);
+            final CounterType cType = "Any".equals(type) ? null : CounterType.getType(type);
 
             final List<Card> srcCards = AbilityUtils.getDefinedCards(host, sa.getParam("Source"), sa);
             final List<Card> destCards = AbilityUtils.getDefinedCards(host, sa.getParam("Defined"), sa);
@@ -189,7 +190,7 @@ public class CountersMoveAi extends SpellAbilityAi {
 
                 // check for some specific AI preferences
                 if ("DontMoveCounterIfLethal".equals(sa.getParam("AILogic"))) {
-                    return cType != CounterType.P1P1 || src.getNetToughness() - src.getTempToughnessBoost() - 1 > 0;
+                    return !cType.is(CounterEnumType.P1P1) || src.getNetToughness() - src.getTempToughnessBoost() - 1 > 0;
                 }
             }
             // no target
@@ -234,7 +235,7 @@ public class CountersMoveAi extends SpellAbilityAi {
         final Card host = sa.getHostCard();
         final Game game = ai.getGame();
         final String type = sa.getParam("CounterType");
-        final CounterType cType = "Any".equals(type) ? null : CounterType.valueOf(type);
+        final CounterType cType = "Any".equals(type) || "All".equals(type) ? null : CounterType.getType(type);
 
         List<Card> tgtCards = CardLists.getTargetableCards(game.getCardsIn(ZoneType.Battlefield), sa);
 
@@ -278,7 +279,7 @@ public class CountersMoveAi extends SpellAbilityAi {
 
                         // do not steal a P1P1 from Undying if it would die
                         // this way
-                        if (CounterType.P1P1.equals(cType) && srcCardCpy.getNetToughness() <= 0) {
+                        if (CounterEnumType.P1P1.equals(cType) && srcCardCpy.getNetToughness() <= 0) {
                             return srcCardCpy.getCounters(cType) > 0 || !card.hasKeyword(Keyword.UNDYING) || card.isToken();
                         }
                         return true;
@@ -321,13 +322,13 @@ public class CountersMoveAi extends SpellAbilityAi {
                         }
 
                         // try to remove P1P1 from undying or evolve
-                        if (CounterType.P1P1.equals(cType)) {
+                        if (CounterEnumType.P1P1.equals(cType)) {
                             if (card.hasKeyword(Keyword.UNDYING) || card.hasKeyword(Keyword.EVOLVE)
                                     || card.hasKeyword(Keyword.ADAPT)) {
                                 return true;
                             }
                         }
-                        if (CounterType.M1M1.equals(cType) && card.hasKeyword(Keyword.PERSIST)) {
+                        if (CounterEnumType.M1M1.equals(cType) && card.hasKeyword(Keyword.PERSIST)) {
                             return true;
                         }
 
@@ -382,10 +383,10 @@ public class CountersMoveAi extends SpellAbilityAi {
                         }
 
                         if (cType != null) {
-                            if (CounterType.P1P1.equals(cType) && card.hasKeyword(Keyword.UNDYING)) {
+                            if (CounterEnumType.P1P1.equals(cType) && card.hasKeyword(Keyword.UNDYING)) {
                                 return false;
                             }
-                            if (CounterType.M1M1.equals(cType) && card.hasKeyword(Keyword.PERSIST)) {
+                            if (CounterEnumType.M1M1.equals(cType) && card.hasKeyword(Keyword.PERSIST)) {
                                 return false;
                             }
 
@@ -393,7 +394,7 @@ public class CountersMoveAi extends SpellAbilityAi {
                                 return false;
                             }
                         }
-                        return false;
+                        return true;
                     }
                 });
 
@@ -452,7 +453,7 @@ public class CountersMoveAi extends SpellAbilityAi {
     // or for source -> multiple defined
     @Override
     protected Card chooseSingleCard(Player ai, SpellAbility sa, Iterable<Card> options, boolean isOptional,
-            Player targetedPlayer) {
+            Player targetedPlayer, Map<String, Object> params) {
         if (sa.hasParam("AiLogic")) {
             String logic = sa.getParam("AiLogic");
 

forge-ai/src/main/java/forge/ai/ability/CountersMultiplyAi.java

@@ -16,6 +16,7 @@ import forge.game.card.Card;
 import forge.game.card.CardCollection;
 import forge.game.card.CardLists;
 import forge.game.card.CardPredicates;
+import forge.game.card.CounterEnumType;
 import forge.game.card.CounterType;
 import forge.game.phase.PhaseHandler;
 import forge.game.phase.PhaseType;
@@ -77,7 +78,7 @@ public class CountersMultiplyAi extends SpellAbilityAi {
     protected boolean checkPhaseRestrictions(final Player ai, final SpellAbility sa, final PhaseHandler ph) {
         final CounterType counterType = getCounterType(sa);
 
-        if (!CounterType.P1P1.equals(counterType) && counterType != null) {
+        if (!CounterEnumType.P1P1.equals(counterType) && counterType != null) {
             if (!sa.hasParam("ActivationPhases")) {
                 // Don't use non P1P1/M1M1 counters before main 2 if possible
                 if (ph.getPhase().isBefore(PhaseType.MAIN2) && !ComputerUtil.castSpellInMain1(ai, sa)) {
@@ -147,15 +148,15 @@ public class CountersMultiplyAi extends SpellAbilityAi {
         if (!aiList.isEmpty()) {
             // counter type list to check
             // first loyalty, then P1P!, then Charge Counter
-            List<CounterType> typeList = Lists.newArrayList(CounterType.LOYALTY, CounterType.P1P1, CounterType.CHARGE);
-            for (CounterType type : typeList) {
+            List<CounterEnumType> typeList = Lists.newArrayList(CounterEnumType.LOYALTY, CounterEnumType.P1P1, CounterEnumType.CHARGE);
+            for (CounterEnumType type : typeList) {
                 // enough targets
                 if (!sa.canAddMoreTarget()) {
                     break;
                 }
 
-                if (counterType == null || counterType == type) {
-                    addTargetsByCounterType(ai, sa, aiList, type);
+                if (counterType == null || counterType.is(type)) {
+                    addTargetsByCounterType(ai, sa, aiList, CounterType.get(type));
                 }
             }
         }
@@ -164,7 +165,7 @@ public class CountersMultiplyAi extends SpellAbilityAi {
         if (!oppList.isEmpty()) {
             // not enough targets
             if (sa.canAddMoreTarget()) {
-                final CounterType type = CounterType.M1M1;
+                final CounterType type = CounterType.get(CounterEnumType.M1M1);
                 if (counterType == null || counterType == type) {
                     addTargetsByCounterType(ai, sa, oppList, type);
                 }

forge-ai/src/main/java/forge/ai/ability/CountersProliferateAi.java

@@ -15,6 +15,7 @@ import forge.game.GameEntity;
 import forge.game.card.Card;
 import forge.game.card.CardLists;
 import forge.game.card.CardUtil;
+import forge.game.card.CounterEnumType;
 import forge.game.card.CounterType;
 import forge.game.player.Player;
 import forge.game.spellability.SpellAbility;
@@ -32,7 +33,7 @@ public class CountersProliferateAi extends SpellAbilityAi {
 
         for (final Player p : allies) {
         	// player has experience or energy counter
-            if (p.getCounters(CounterType.EXPERIENCE) + p.getCounters(CounterType.ENERGY) >= 1) {
+            if (p.getCounters(CounterEnumType.EXPERIENCE) + p.getCounters(CounterEnumType.ENERGY) >= 1) {
                 allyExpOrEnergy = true;
             }
             cperms.addAll(CardLists.filter(p.getCardsIn(ZoneType.Battlefield), new Predicate<Card>() {
@@ -115,17 +116,19 @@ public class CountersProliferateAi extends SpellAbilityAi {
      */
     @SuppressWarnings("unchecked")
     @Override
-    public <T extends GameEntity> T chooseSingleEntity(Player ai, SpellAbility sa, Collection<T> options, boolean isOptional, Player targetedPlayer) {
+    public <T extends GameEntity> T chooseSingleEntity(Player ai, SpellAbility sa, Collection<T> options, boolean isOptional, Player targetedPlayer, Map<String, Object> params) {
         // Proliferate is always optional for all, no need to select best
 
+        final CounterType poison = CounterType.get(CounterEnumType.POISON);
+
         // because countertype can't be chosen anymore, only look for posion counters
         for (final Player p : Iterables.filter(options, Player.class)) {
             if (p.isOpponentOf(ai)) {
-                if (p.getCounters(CounterType.POISON) > 0 && p.canReceiveCounters(CounterType.POISON)) {
+                if (p.getCounters(poison) > 0 && p.canReceiveCounters(poison)) {
                     return (T)p;
                 }
             } else {
-                if (p.getCounters(CounterType.POISON) <= 5 || p.canReceiveCounters(CounterType.POISON)) {
+                if (p.getCounters(poison) <= 5 || p.canReceiveCounters(poison)) {
                     return (T)p;
                 }
             }

forge-ai/src/main/java/forge/ai/ability/CountersPutAi.java

@@ -56,17 +56,17 @@ public class CountersPutAi extends SpellAbilityAi {
             if (part instanceof CostRemoveCounter) {
                 final CostRemoveCounter remCounter = (CostRemoveCounter) part;
                 final CounterType counterType = remCounter.counter;
-                if (counterType.name().equals(type) && !aiLogic.startsWith("MoveCounter")) {
+                if (counterType.getName().equals(type) && !aiLogic.startsWith("MoveCounter")) {
                     return false;
                 }
                 if (!part.payCostFromSource()) {
-                    if (counterType.equals(CounterType.P1P1)) {
+                    if (counterType.is(CounterEnumType.P1P1)) {
                         return false;
                     }
                     continue;
                 }
                 // don't kill the creature
-                if (counterType.equals(CounterType.P1P1) && source.getLethalDamage() <= 1) {
+                if (counterType.is(CounterEnumType.P1P1) && source.getLethalDamage() <= 1) {
                     return false;
                 }
             }
@@ -109,7 +109,7 @@ public class CountersPutAi extends SpellAbilityAi {
                 }
             }
             int maxLevel = Integer.parseInt(sa.getParam("MaxLevel"));
-            return source.getCounters(CounterType.LEVEL) < maxLevel;
+            return source.getCounters(CounterEnumType.LEVEL) < maxLevel;
         }
 
         return super.checkPhaseRestrictions(ai, sa, ph);
@@ -146,7 +146,7 @@ public class CountersPutAi extends SpellAbilityAi {
                 if (abTgt.canTgtPlayer()) {
                     // try to kill opponent with Poison
                     PlayerCollection oppList = ai.getOpponents().filter(PlayerPredicates.isTargetableBy(sa));
-                    PlayerCollection poisonList = oppList.filter(PlayerPredicates.hasCounter(CounterType.POISON, 9));
+                    PlayerCollection poisonList = oppList.filter(PlayerPredicates.hasCounter(CounterEnumType.POISON, 9));
                     if (!poisonList.isEmpty()) {
                         sa.getTargets().add(poisonList.max(PlayerPredicates.compareByLife()));
                         return true;
@@ -157,13 +157,13 @@ public class CountersPutAi extends SpellAbilityAi {
                     // try to kill creature with -1/-1 counters if it can
                     // receive counters, execpt it has undying
                     CardCollection oppCreat = CardLists.getTargetableCards(ai.getOpponents().getCreaturesInPlay(), sa);
-                    CardCollection oppCreatM1 = CardLists.filter(oppCreat, CardPredicates.hasCounter(CounterType.M1M1));
+                    CardCollection oppCreatM1 = CardLists.filter(oppCreat, CardPredicates.hasCounter(CounterEnumType.M1M1));
                     oppCreatM1 = CardLists.getNotKeyword(oppCreatM1, Keyword.UNDYING);
 
                     oppCreatM1 = CardLists.filter(oppCreatM1, new Predicate<Card>() {
                         @Override
                         public boolean apply(Card input) {
-                            return input.getNetToughness() <= 1 && input.canReceiveCounters(CounterType.M1M1);
+                            return input.getNetToughness() <= 1 && input.canReceiveCounters(CounterType.get(CounterEnumType.M1M1));
                         }
 
                     });
@@ -220,6 +220,8 @@ public class CountersPutAi extends SpellAbilityAi {
 
         if ("Never".equals(logic)) {
             return false;
+        } else if ("AlwaysWithNoTgt".equals(logic)) {
+            return true;
         } else if ("AristocratCounters".equals(logic)) {
             return PumpAi.doAristocratWithCountersLogic(sa, ai);
         } else if ("PayEnergy".equals(logic)) {
@@ -242,7 +244,7 @@ public class CountersPutAi extends SpellAbilityAi {
                     int totBlkPower = Aggregates.sum(blocked, CardPredicates.Accessors.fnGetNetPower);
                     int totBlkToughness = Aggregates.min(blocked, CardPredicates.Accessors.fnGetNetToughness);
 
-                    int numActivations = ai.getCounters(CounterType.ENERGY) / sa.getPayCosts().getCostEnergy().convertAmount();
+                    int numActivations = ai.getCounters(CounterEnumType.ENERGY) / sa.getPayCosts().getCostEnergy().convertAmount();
                     if (sa.getHostCard().getNetToughness() + numActivations > totBlkPower
                             || sa.getHostCard().getNetPower() + numActivations >= totBlkToughness) {
                         return true;
@@ -257,7 +259,7 @@ public class CountersPutAi extends SpellAbilityAi {
                         AiCardMemory.rememberCard(ai, source, AiCardMemory.MemorySet.ACTIVATED_THIS_TURN);
                         return true;
                     }
-            } else if (ai.getCounters(CounterType.ENERGY) > ComputerUtilCard.getMaxSAEnergyCostOnBattlefield(ai) + sa.getPayCosts().getCostEnergy().convertAmount()) {
+            } else if (ai.getCounters(CounterEnumType.ENERGY) > ComputerUtilCard.getMaxSAEnergyCostOnBattlefield(ai) + sa.getPayCosts().getCostEnergy().convertAmount()) {
                 // outside of combat, this logic only works if the relevant AI profile option is enabled
                 // and if there is enough energy saved
                 if (!onlyInCombat) {
@@ -320,7 +322,7 @@ public class CountersPutAi extends SpellAbilityAi {
             Game game = ai.getGame();
             Combat combat = game.getCombat();
 
-            if (!source.canReceiveCounters(CounterType.P1P1) || source.getCounters(CounterType.P1P1) > 0) {
+            if (!source.canReceiveCounters(CounterType.get(CounterEnumType.P1P1)) || source.getCounters(CounterEnumType.P1P1) > 0) {
                 return false;
             } else if (combat != null && ph.is(PhaseType.COMBAT_DECLARE_BLOCKERS)) {
                 return doCombatAdaptLogic(source, amount, combat);
@@ -343,7 +345,7 @@ public class CountersPutAi extends SpellAbilityAi {
                 if (isClockwork) {
                     // Clockwork Avian and other similar cards: do not tap all mana for X,
                     // instead only rewind to max allowed value when the power gets low enough.
-                    int curCtrs = source.getCounters(CounterType.P1P0);
+                    int curCtrs = source.getCounters(CounterEnumType.P1P0);
                     int maxCtrs = Integer.parseInt(sa.getParam("MaxFromEffect"));
 
                     // This will "rewind" clockwork cards when they fall to 50% power or below, consider improving
@@ -433,7 +435,7 @@ public class CountersPutAi extends SpellAbilityAi {
                     if (sacSelf && c.equals(source)) {
                         return false;
                     }
-                    return sa.canTarget(c) && c.canReceiveCounters(CounterType.valueOf(type));
+                    return sa.canTarget(c) && c.canReceiveCounters(CounterType.getType(type));
                 }
             });
 
@@ -452,7 +454,6 @@ public class CountersPutAi extends SpellAbilityAi {
             // but try to do it in Main 2 then so that the AI has a chance to play creatures first.
             if (list.isEmpty()
                     && sa.hasParam("Planeswalker")
-                    && sa.getPayCosts() != null
                     && sa.getPayCosts().hasOnlySpecificCostType(CostPutCounter.class)
                     && sa.isTargetNumberValid()
                     && sa.getTargets().getNumTargeted() == 0
@@ -557,7 +558,7 @@ public class CountersPutAi extends SpellAbilityAi {
                 return false;
             }
 
-            final int currCounters = cards.get(0).getCounters(CounterType.valueOf(type));
+            final int currCounters = cards.get(0).getCounters(CounterType.get(type));
             // each non +1/+1 counter on the card is a 10% chance of not
             // activating this ability.
 
@@ -704,7 +705,7 @@ public class CountersPutAi extends SpellAbilityAi {
                 SpellAbility testSa = sa;
                 int countX = 0;
                 int nonXGlyphs = 0;
-                while (testSa != null && testSa.getPayCosts() != null && countX == 0) {
+                while (testSa != null && countX == 0) {
                     countX = testSa.getPayCosts().getTotalMana().countX();
                     nonXGlyphs = testSa.getPayCosts().getTotalMana().getGlyphCount() - countX;
                     testSa = testSa.getSubAbility();
@@ -732,6 +733,21 @@ public class CountersPutAi extends SpellAbilityAi {
                 // put a counter?
                 // things like Powder Keg, which are way too complex for the AI
             }
+        } else if (sa.getTargetRestrictions().canOnlyTgtOpponent() && !sa.getTargetRestrictions().canTgtCreature()) {
+            // can only target opponent
+            List<Player> playerList = Lists.newArrayList(Iterables.filter(
+                    sa.getTargetRestrictions().getAllCandidates(sa, true, true), Player.class));
+
+            if (playerList.isEmpty() && mandatory) {
+                return false;
+            }
+
+            // try to choose player with less creatures
+            Player choice = Collections.min(playerList, PlayerPredicates.compareByZoneSize(ZoneType.Battlefield, CardPredicates.Presets.CREATURES));
+
+            if (choice != null) {
+                sa.getTargets().add(choice);
+            }
         } else {
             if (sa.isCurse()) {
                 list = ai.getOpponents().getCardsIn(ZoneType.Battlefield);
@@ -873,7 +889,7 @@ public class CountersPutAi extends SpellAbilityAi {
     }
 
     @Override
-    public Player chooseSinglePlayer(Player ai, SpellAbility sa, Iterable<Player> options) {
+    public Player chooseSinglePlayer(Player ai, SpellAbility sa, Iterable<Player> options, Map<String, Object> params) {
         // used by Tribute, select player with lowest Life
         // TODO add more logic using TributeAILogic
         List<Player> list = Lists.newArrayList(options);
@@ -881,16 +897,20 @@ public class CountersPutAi extends SpellAbilityAi {
     }
 
     @Override
-    protected Card chooseSingleCard(final Player ai, SpellAbility sa, Iterable<Card> options, boolean isOptional, Player targetedPlayer) {
+    protected Card chooseSingleCard(final Player ai, SpellAbility sa, Iterable<Card> options, boolean isOptional, Player targetedPlayer, Map<String, Object> params) {
         // Bolster does use this
         // TODO need more or less logic there?
+        final CounterType m1m1 = CounterType.get(CounterEnumType.M1M1);
+        final CounterType p1p1 = CounterType.get(CounterEnumType.P1P1);
 
         // no logic if there is no options or no to choice
         if (!isOptional && Iterables.size(options) <= 1) {
             return Iterables.getFirst(options, null);
         }
 
-        final CounterType type = CounterType.valueOf(sa.getParam("CounterType"));
+        final CounterType type = params.containsKey("CounterType") ? (CounterType)params.get("CounterType")
+                : CounterType.getType(sa.getParam("CounterType"));
+
         final String amountStr = sa.getParamOrDefault("CounterNum", "1");
         final int amount = AbilityUtils.calculateAmount(sa.getHostCard(), amountStr, sa);
 
@@ -907,7 +927,7 @@ public class CountersPutAi extends SpellAbilityAi {
                             return false;
                         if (ComputerUtilCard.isUselessCreature(ai, input))
                             return false;
-                        if (CounterType.M1M1.equals(type) && amount >= input.getNetToughness())
+                        if (type.is(CounterEnumType.M1M1) && amount >= input.getNetToughness())
                             return true;
                         return ComputerUtil.isNegativeCounter(type, input);
                     }
@@ -931,6 +951,20 @@ public class CountersPutAi extends SpellAbilityAi {
 
         CardCollection filtered = mine;
 
+        // Try to filter out keywords that we already have on cards
+        if (type.isKeywordCounter()) {
+            Keyword kw = Keyword.smartValueOf(type.getName());
+            final CardCollection doNotHaveKeyword = CardLists.filter(filtered, new Predicate<Card>() {
+                @Override
+                public boolean apply(Card card) {
+                    return !card.hasKeyword(kw) && card.canBeTargetedBy(sa) && sa.canTarget(card);
+                }
+            });
+
+            if (doNotHaveKeyword.size() > 0)
+                filtered = doNotHaveKeyword;
+        }
+
         final CardCollection notUseless = CardLists.filter(filtered, new Predicate<Card>() {
             @Override
             public boolean apply(Card input) {
@@ -945,26 +979,26 @@ public class CountersPutAi extends SpellAbilityAi {
         }
 
         // some special logic to reload Persist/Undying
-        if (CounterType.P1P1.equals(type)) {
+        if (p1p1.equals(type)) {
             final CardCollection persist = CardLists.filter(filtered, new Predicate<Card>() {
                 @Override
                 public boolean apply(Card input) {
                     if (!input.hasKeyword(Keyword.PERSIST))
                         return false;
-                    return input.getCounters(CounterType.M1M1) <= amount;
+                    return input.getCounters(m1m1) <= amount;
                 }
             });
 
             if (!persist.isEmpty()) {
                 filtered = persist;
             }
-        } else if (CounterType.M1M1.equals(type)) {
+        } else if (m1m1.equals(type)) {
             final CardCollection undying = CardLists.filter(filtered, new Predicate<Card>() {
                 @Override
                 public boolean apply(Card input) {
                     if (!input.hasKeyword(Keyword.UNDYING))
                         return false;
-                    return input.getCounters(CounterType.P1P1) <= amount && input.getNetToughness() > amount;
+                    return input.getCounters(p1p1) <= amount && input.getNetToughness() > amount;
                 }
             });
 
@@ -987,8 +1021,8 @@ public class CountersPutAi extends SpellAbilityAi {
         if (e instanceof Card) {
             Card c = (Card) e;
             if (c.getController().isOpponentOf(ai)) {
-                if (options.contains(CounterType.M1M1) && !c.hasKeyword(Keyword.UNDYING)) {
-                    return CounterType.M1M1;
+                if (options.contains(CounterType.get(CounterEnumType.M1M1)) && !c.hasKeyword(Keyword.UNDYING)) {
+                    return CounterType.get(CounterEnumType.M1M1);
                 }
                 for (CounterType type : options) {
                     if (ComputerUtil.isNegativeCounter(type, c)) {
@@ -1005,12 +1039,12 @@ public class CountersPutAi extends SpellAbilityAi {
         } else if (e instanceof Player) {
             Player p = (Player) e;
             if (p.isOpponentOf(ai)) {
-                if (options.contains(CounterType.POISON)) {
-                    return CounterType.POISON;
+                if (options.contains(CounterType.get(CounterEnumType.POISON))) {
+                    return CounterType.get(CounterEnumType.POISON);
                 }
             } else {
-                if (options.contains(CounterType.EXPERIENCE)) {
-                    return CounterType.EXPERIENCE;
+                if (options.contains(CounterType.get(CounterEnumType.EXPERIENCE))) {
+                    return CounterType.get(CounterEnumType.EXPERIENCE);
                 }
             }
 

forge-ai/src/main/java/forge/ai/ability/CountersPutAllAi.java

@@ -120,7 +120,7 @@ public class CountersPutAllAi extends SpellAbilityAi {
             //Check for cards that could profit from the ability
             PhaseHandler phase = ai.getGame().getPhaseHandler();
             if (type.equals("P1P1") && sa.isAbility() && source.isCreature()
-                    && sa.getPayCosts() != null && sa.getPayCosts().hasTapCost()
+                    && sa.getPayCosts().hasTapCost()
                     && sa instanceof AbilitySub
                     && (!phase.getNextTurn().equals(ai)
                     || phase.getPhase().isBefore(PhaseType.COMBAT_DECLARE_BLOCKERS))) {

forge-ai/src/main/java/forge/ai/ability/CountersPutOrRemoveAi.java

@@ -75,7 +75,7 @@ public class CountersPutOrRemoveAi extends SpellAbilityAi {
 
         if (sa.hasParam("CounterType")) {
             // currently only Jhoira's Timebug
-            final CounterType type = CounterType.valueOf(sa.getParam("CounterType"));
+            final CounterType type = CounterType.getType(sa.getParam("CounterType"));
 
             CardCollection countersList = CardLists.filter(list, CardPredicates.hasCounter(type, amount));
 
@@ -100,7 +100,7 @@ public class CountersPutOrRemoveAi extends SpellAbilityAi {
 
                 if (!ai.isCardInPlay("Marit Lage") || noLegendary) {
                     CardCollectionView depthsList = CardLists.filter(countersList,
-                            CardPredicates.nameEquals("Dark Depths"), CardPredicates.hasCounter(CounterType.ICE));
+                            CardPredicates.nameEquals("Dark Depths"), CardPredicates.hasCounter(CounterEnumType.ICE));
 
                     if (!depthsList.isEmpty()) {
                         sa.getTargets().add(depthsList.getFirst());
@@ -113,7 +113,7 @@ public class CountersPutOrRemoveAi extends SpellAbilityAi {
                 CardCollection planeswalkerList = CardLists.filter(
                         CardLists.filterControlledBy(countersList, ai.getOpponents()),
                         CardPredicates.Presets.PLANESWALKERS,
-                        CardPredicates.hasLessCounter(CounterType.LOYALTY, amount));
+                        CardPredicates.hasLessCounter(CounterEnumType.LOYALTY, amount));
 
                 if (!planeswalkerList.isEmpty()) {
                     sa.getTargets().add(ComputerUtilCard.getBestPlaneswalkerAI(planeswalkerList));
@@ -123,7 +123,7 @@ public class CountersPutOrRemoveAi extends SpellAbilityAi {
                 // do as M1M1 part
                 CardCollection aiList = CardLists.filterControlledBy(countersList, ai);
 
-                CardCollection aiM1M1List = CardLists.filter(aiList, CardPredicates.hasCounter(CounterType.M1M1));
+                CardCollection aiM1M1List = CardLists.filter(aiList, CardPredicates.hasCounter(CounterEnumType.M1M1));
 
                 CardCollection aiPersistList = CardLists.getKeyword(aiM1M1List, Keyword.PERSIST);
                 if (!aiPersistList.isEmpty()) {
@@ -136,7 +136,7 @@ public class CountersPutOrRemoveAi extends SpellAbilityAi {
                 }
 
                 // do as P1P1 part
-                CardCollection aiP1P1List = CardLists.filter(aiList, CardPredicates.hasCounter(CounterType.P1P1));
+                CardCollection aiP1P1List = CardLists.filter(aiList, CardPredicates.hasCounter(CounterEnumType.P1P1));
                 CardCollection aiUndyingList = CardLists.getKeyword(aiM1M1List, Keyword.UNDYING);
 
                 if (!aiUndyingList.isEmpty()) {
@@ -199,18 +199,18 @@ public class CountersPutOrRemoveAi extends SpellAbilityAi {
             Card tgt = (Card) params.get("Target");
 
             // planeswalker has high priority for loyalty counters
-            if (tgt.isPlaneswalker() && options.contains(CounterType.LOYALTY)) {
-                return CounterType.LOYALTY;
+            if (tgt.isPlaneswalker() && options.contains(CounterType.get(CounterEnumType.LOYALTY))) {
+                return CounterType.get(CounterEnumType.LOYALTY);
             }
 
             if (tgt.getController().isOpponentOf(ai)) {
                 // creatures with BaseToughness below or equal zero might be
                 // killed if their counters are removed
                 if (tgt.isCreature() && tgt.getBaseToughness() <= 0) {
-                    if (options.contains(CounterType.P1P1)) {
-                        return CounterType.P1P1;
-                    } else if (options.contains(CounterType.M1M1)) {
-                        return CounterType.M1M1;
+                    if (options.contains(CounterType.get(CounterEnumType.P1P1))) {
+                        return CounterType.get(CounterEnumType.P1P1);
+                    } else if (options.contains(CounterType.get(CounterEnumType.M1M1))) {
+                        return CounterType.get(CounterEnumType.M1M1);
                     }
                 }
 
@@ -222,14 +222,14 @@ public class CountersPutOrRemoveAi extends SpellAbilityAi {
                 }
             } else {
                 // this counters are treat first to be removed
-                if ("Dark Depths".equals(tgt.getName()) && options.contains(CounterType.ICE)) {
+                if ("Dark Depths".equals(tgt.getName()) && options.contains(CounterType.get(CounterEnumType.ICE))) {
                     if (!ai.isCardInPlay("Marit Lage") || noLegendary) {
-                        return CounterType.ICE;
+                        return CounterType.get(CounterEnumType.ICE);
                     }
-                } else if (tgt.hasKeyword(Keyword.UNDYING) && options.contains(CounterType.P1P1)) {
-                    return CounterType.P1P1;
-                } else if (tgt.hasKeyword(Keyword.PERSIST) && options.contains(CounterType.M1M1)) {
-                    return CounterType.M1M1;
+                } else if (tgt.hasKeyword(Keyword.UNDYING) && options.contains(CounterType.get(CounterEnumType.P1P1))) {
+                    return CounterType.get(CounterEnumType.P1P1);
+                } else if (tgt.hasKeyword(Keyword.PERSIST) && options.contains(CounterType.get(CounterEnumType.M1M1))) {
+                    return CounterType.get(CounterEnumType.M1M1);
                 }
 
                 // fallback logic, select positive counter to add more
@@ -262,19 +262,19 @@ public class CountersPutOrRemoveAi extends SpellAbilityAi {
             boolean noLegendary = game.getStaticEffects().getGlobalRuleChange(GlobalRuleChange.noLegendRule);
 
             if (tgt.getController().isOpponentOf(ai)) {
-                if (type.equals(CounterType.LOYALTY) && tgt.isPlaneswalker()) {
+                if (type.is(CounterEnumType.LOYALTY) && tgt.isPlaneswalker()) {
                     return false;
                 }
 
                 return ComputerUtil.isNegativeCounter(type, tgt);
             } else {
-                if (type.equals(CounterType.ICE) && "Dark Depths".equals(tgt.getName())) {
+                if (type.is(CounterEnumType.ICE) && "Dark Depths".equals(tgt.getName())) {
                     if (!ai.isCardInPlay("Marit Lage") || noLegendary) {
                         return false;
                     }
-                } else if (type.equals(CounterType.M1M1) && tgt.hasKeyword(Keyword.PERSIST)) {
+                } else if (type.is(CounterEnumType.M1M1) && tgt.hasKeyword(Keyword.PERSIST)) {
                     return false;
-                } else if (type.equals(CounterType.P1P1) && tgt.hasKeyword(Keyword.UNDYING)) {
+                } else if (type.is(CounterEnumType.P1P1) && tgt.hasKeyword(Keyword.UNDYING)) {
                     return false;
                 }
 

forge-ai/src/main/java/forge/ai/ability/CountersRemoveAi.java

@@ -23,6 +23,14 @@ import java.util.Map;
 
 public class CountersRemoveAi extends SpellAbilityAi {
 
+    @Override
+    protected boolean canPlayWithoutRestrict(final Player ai, final SpellAbility sa) {
+        if ("Always".equals(sa.getParam("AILogic"))) {
+            return true;
+        }
+        return super.canPlayWithoutRestrict(ai, sa);
+    }
+
     /*
      * (non-Javadoc)
      *
@@ -74,7 +82,7 @@ public class CountersRemoveAi extends SpellAbilityAi {
         }
 
         if (!type.matches("Any") && !type.matches("All")) {
-            final int currCounters = sa.getHostCard().getCounters(CounterType.valueOf(type));
+            final int currCounters = sa.getHostCard().getCounters(CounterType.getType(type));
             if (currCounters < 1) {
                 return false;
             }
@@ -111,7 +119,7 @@ public class CountersRemoveAi extends SpellAbilityAi {
             if (!ai.isCardInPlay("Marit Lage") || noLegendary) {
                 CardCollectionView depthsList = ai.getCardsIn(ZoneType.Battlefield, "Dark Depths");
                 depthsList = CardLists.filter(depthsList, CardPredicates.isTargetableBy(sa),
-                        CardPredicates.hasCounter(CounterType.ICE, 3));
+                        CardPredicates.hasCounter(CounterEnumType.ICE, 3));
 
                 if (!depthsList.isEmpty()) {
                     sa.getTargets().add(depthsList.getFirst());
@@ -124,7 +132,7 @@ public class CountersRemoveAi extends SpellAbilityAi {
             list = CardLists.filter(list, CardPredicates.isTargetableBy(sa));
 
             CardCollection planeswalkerList = CardLists.filter(list, CardPredicates.Presets.PLANESWALKERS,
-                    CardPredicates.hasCounter(CounterType.LOYALTY, 5));
+                    CardPredicates.hasCounter(CounterEnumType.LOYALTY, 5));
 
             if (!planeswalkerList.isEmpty()) {
                 sa.getTargets().add(ComputerUtilCard.getBestPlaneswalkerAI(planeswalkerList));
@@ -151,11 +159,11 @@ public class CountersRemoveAi extends SpellAbilityAi {
             if (!ai.isCardInPlay("Marit Lage") || noLegendary) {
                 CardCollectionView depthsList = ai.getCardsIn(ZoneType.Battlefield, "Dark Depths");
                 depthsList = CardLists.filter(depthsList, CardPredicates.isTargetableBy(sa),
-                        CardPredicates.hasCounter(CounterType.ICE));
+                        CardPredicates.hasCounter(CounterEnumType.ICE));
 
                 if (!depthsList.isEmpty()) {
                     Card depth = depthsList.getFirst();
-                    int ice = depth.getCounters(CounterType.ICE);
+                    int ice = depth.getCounters(CounterEnumType.ICE);
                     if (amount >= ice) {
                         sa.getTargets().add(depth);
                         if (xPay) {
@@ -172,7 +180,7 @@ public class CountersRemoveAi extends SpellAbilityAi {
 
             CardCollection planeswalkerList = CardLists.filter(list,
                     Predicates.and(CardPredicates.Presets.PLANESWALKERS, CardPredicates.isControlledByAnyOf(ai.getOpponents())),
-                    CardPredicates.hasLessCounter(CounterType.LOYALTY, amount));
+                    CardPredicates.hasLessCounter(CounterEnumType.LOYALTY, amount));
 
             if (!planeswalkerList.isEmpty()) {
                 Card best = ComputerUtilCard.getBestPlaneswalkerAI(planeswalkerList);
@@ -188,7 +196,7 @@ public class CountersRemoveAi extends SpellAbilityAi {
                 // do as M1M1 part
                 CardCollection aiList = CardLists.filterControlledBy(list, ai);
 
-                CardCollection aiM1M1List = CardLists.filter(aiList, CardPredicates.hasCounter(CounterType.M1M1));
+                CardCollection aiM1M1List = CardLists.filter(aiList, CardPredicates.hasCounter(CounterEnumType.M1M1));
 
                 CardCollection aiPersistList = CardLists.getKeyword(aiM1M1List, Keyword.PERSIST);
                 if (!aiPersistList.isEmpty()) {
@@ -201,7 +209,7 @@ public class CountersRemoveAi extends SpellAbilityAi {
                 }
 
                 // do as P1P1 part
-                CardCollection aiP1P1List = CardLists.filter(aiList, CardPredicates.hasLessCounter(CounterType.P1P1, amount));
+                CardCollection aiP1P1List = CardLists.filter(aiList, CardPredicates.hasLessCounter(CounterEnumType.P1P1, amount));
                 CardCollection aiUndyingList = CardLists.getKeyword(aiP1P1List, Keyword.UNDYING);
 
                 if (!aiUndyingList.isEmpty()) {
@@ -212,7 +220,7 @@ public class CountersRemoveAi extends SpellAbilityAi {
                 // remove P1P1 counters from opposing creatures
                 CardCollection oppP1P1List = CardLists.filter(list,
                         Predicates.and(CardPredicates.Presets.CREATURES, CardPredicates.isControlledByAnyOf(ai.getOpponents())),
-                        CardPredicates.hasCounter(CounterType.P1P1));
+                        CardPredicates.hasCounter(CounterEnumType.P1P1));
                 if (!oppP1P1List.isEmpty()) {
                     sa.getTargets().add(ComputerUtilCard.getBestCreatureAI(oppP1P1List));
                     return true;
@@ -236,7 +244,7 @@ public class CountersRemoveAi extends SpellAbilityAi {
             // no special amount for that one yet
             int amount = AbilityUtils.calculateAmount(source, amountStr, sa);
             CardCollection aiList = CardLists.filterControlledBy(list, ai);
-            aiList = CardLists.filter(aiList, CardPredicates.hasCounter(CounterType.M1M1, amount));
+            aiList = CardLists.filter(aiList, CardPredicates.hasCounter(CounterEnumType.M1M1, amount));
 
             CardCollection aiPersist = CardLists.getKeyword(aiList, Keyword.PERSIST);
             if (!aiPersist.isEmpty()) {
@@ -255,7 +263,7 @@ public class CountersRemoveAi extends SpellAbilityAi {
             // no special amount for that one yet
             int amount = AbilityUtils.calculateAmount(source, amountStr, sa);
 
-            list = CardLists.filter(list, CardPredicates.hasCounter(CounterType.P1P1, amount));
+            list = CardLists.filter(list, CardPredicates.hasCounter(CounterEnumType.P1P1, amount));
 
             // currently only logic for Bloodcrazed Hoplite, but add logic for
             // targeting ai creatures too
@@ -301,12 +309,12 @@ public class CountersRemoveAi extends SpellAbilityAi {
                 amount = AbilityUtils.calculateAmount(source, amountStr, sa);
             }
 
-            CardCollection timeList = CardLists.filter(list, CardPredicates.hasLessCounter(CounterType.TIME, amount));
+            CardCollection timeList = CardLists.filter(list, CardPredicates.hasLessCounter(CounterEnumType.TIME, amount));
 
             if (!timeList.isEmpty()) {
                 Card best = ComputerUtilCard.getBestAI(timeList);
 
-                int timeCount = best.getCounters(CounterType.TIME);
+                int timeCount = best.getCounters(CounterEnumType.TIME);
                 sa.getTargets().add(best);
                 if (xPay) {
                     source.setSVar("PayX", Integer.toString(timeCount));
@@ -327,7 +335,7 @@ public class CountersRemoveAi extends SpellAbilityAi {
                 CardCollection outlastCreats = CardLists.filter(list, CardPredicates.hasKeyword(Keyword.OUTLAST));
                 if (!outlastCreats.isEmpty()) {
                     // outlast cards often benefit from having +1/+1 counters, try not to remove last one
-                    CardCollection betterTargets = CardLists.filter(outlastCreats, CardPredicates.hasCounter(CounterType.P1P1, 2));
+                    CardCollection betterTargets = CardLists.filter(outlastCreats, CardPredicates.hasCounter(CounterEnumType.P1P1, 2));
 
                     if (!betterTargets.isEmpty()) {
                         sa.getTargets().add(ComputerUtilCard.getWorstAI(betterTargets));
@@ -369,8 +377,8 @@ public class CountersRemoveAi extends SpellAbilityAi {
             if (targetCard.getController().isOpponentOf(player)) {
                 return !ComputerUtil.isNegativeCounter(type, targetCard) ? max : min;
             } else {
-                if (targetCard.hasKeyword(Keyword.UNDYING) && type == CounterType.P1P1
-                        && targetCard.getCounters(CounterType.P1P1) >= max) {
+                if (targetCard.hasKeyword(Keyword.UNDYING) && type.is(CounterEnumType.P1P1)
+                        && targetCard.getCounters(CounterEnumType.P1P1) >= max) {
                     return max;
                 }
 
@@ -379,9 +387,9 @@ public class CountersRemoveAi extends SpellAbilityAi {
         } else if (target instanceof Player) {
             Player targetPlayer = (Player) target;
             if (targetPlayer.isOpponentOf(player)) {
-                return !type.equals(CounterType.POISON) ? max : min;
+                return !type.equals(CounterEnumType.POISON) ? max : min;
             } else {
-                return type.equals(CounterType.POISON) ? max : min;
+                return type.equals(CounterEnumType.POISON) ? max : min;
             }
         }
 
@@ -407,7 +415,7 @@ public class CountersRemoveAi extends SpellAbilityAi {
             if (targetCard.getController().isOpponentOf(ai)) {
                 // if its a Planeswalker try to remove Loyality first
                 if (targetCard.isPlaneswalker()) {
-                    return CounterType.LOYALTY;
+                    return CounterType.get(CounterEnumType.LOYALTY);
                 }
                 for (CounterType type : options) {
                     if (!ComputerUtil.isNegativeCounter(type, targetCard)) {
@@ -415,10 +423,10 @@ public class CountersRemoveAi extends SpellAbilityAi {
                     }
                 }
             } else {
-                if (options.contains(CounterType.M1M1) && targetCard.hasKeyword(Keyword.PERSIST)) {
-                    return CounterType.M1M1;
-                } else if (options.contains(CounterType.P1P1) && targetCard.hasKeyword(Keyword.UNDYING)) {
-                    return CounterType.P1P1;
+                if (options.contains(CounterType.get(CounterEnumType.M1M1)) && targetCard.hasKeyword(Keyword.PERSIST)) {
+                    return CounterType.get(CounterEnumType.M1M1);
+                } else if (options.contains(CounterType.get(CounterEnumType.P1P1)) && targetCard.hasKeyword(Keyword.UNDYING)) {
+                    return CounterType.get(CounterEnumType.P1P1);
                 }
                 for (CounterType type : options) {
                     if (ComputerUtil.isNegativeCounter(type, targetCard)) {
@@ -430,13 +438,13 @@ public class CountersRemoveAi extends SpellAbilityAi {
             Player targetPlayer = (Player) target;
             if (targetPlayer.isOpponentOf(ai)) {
                 for (CounterType type : options) {
-                    if (!type.equals(CounterType.POISON)) {
+                    if (!type.equals(CounterEnumType.POISON)) {
                         return type;
                     }
                 }
             } else {
                 for (CounterType type : options) {
-                    if (type.equals(CounterType.POISON)) {
+                    if (type.equals(CounterEnumType.POISON)) {
                         return type;
                     }
                 }

forge-ai/src/main/java/forge/ai/ability/DamageAllAi.java

@@ -6,7 +6,7 @@ import forge.game.ability.AbilityUtils;
 import forge.game.card.Card;
 import forge.game.card.CardCollection;
 import forge.game.card.CardLists;
-import forge.game.card.CounterType;
+import forge.game.card.CounterEnumType;
 import forge.game.cost.Cost;
 import forge.game.keyword.Keyword;
 import forge.game.phase.PhaseType;
@@ -50,10 +50,9 @@ public class  DamageAllAi extends SpellAbilityAi {
             x = ComputerUtilMana.determineLeftoverMana(sa, ai);
         }
         if (damage.equals("ChosenX")) {
-            x = source.getCounters(CounterType.LOYALTY);
+            x = source.getCounters(CounterEnumType.LOYALTY);
         }
         if (x == -1) {
-            Player bestOpp = determineOppToKill(ai, sa, source, dmg);
             if (determineOppToKill(ai, sa, source, dmg) != null) {
                 // we already know we can kill a player, so go for it
                 return true;
@@ -138,7 +137,7 @@ public class  DamageAllAi extends SpellAbilityAi {
         }
 
         int minGain = 200; // The minimum gain in destroyed creatures
-        if (sa.getPayCosts() != null && sa.getPayCosts().isReusuableResource()) {
+        if (sa.getPayCosts().isReusuableResource()) {
             if (computerList.isEmpty()) {
                 minGain = 10; // nothing to lose
                 // no creatures to lose and player can be damaged

forge-ai/src/main/java/forge/ai/ability/DamageDealAi.java

@@ -1,6 +1,7 @@
 package forge.ai.ability;
 
 import com.google.common.base.Predicate;
+import com.google.common.base.Predicates;
 import com.google.common.collect.Lists;
 import com.google.common.collect.Maps;
 import forge.ai.*;
@@ -47,7 +48,7 @@ public class DamageDealAi extends DamageAiBase {
         }
 
         if (damage.equals("X") && sa.getSVar(damage).equals("Count$ChosenNumber")) {
-            int energy = ai.getCounters(CounterType.ENERGY);
+            int energy = ai.getCounters(CounterEnumType.ENERGY);
             for (SpellAbility s : source.getSpellAbilities()) {
                 if ("PayEnergy".equals(s.getParam("AILogic"))) {
                     energy += AbilityUtils.calculateAmount(source, s.getParam("CounterNum"), sa);
@@ -164,7 +165,7 @@ public class DamageDealAi extends DamageAiBase {
             List<Card> wolves = CardLists.getValidCards(ai.getCardsIn(ZoneType.Battlefield), "Creature.Wolf+untapped+YouCtrl+Other", ai, source);
             dmg = Aggregates.sum(wolves, CardPredicates.Accessors.fnGetNetPower);
         } else if ("Triskelion".equals(logic)) {
-            final int n = source.getCounters(CounterType.P1P1);
+            final int n = source.getCounters(CounterEnumType.P1P1);
             if (n > 0) {
                 if (ComputerUtil.playImmediately(ai, sa)) {
                     /*
@@ -197,7 +198,7 @@ public class DamageDealAi extends DamageAiBase {
         }
 
         if (sourceName.equals("Sorin, Grim Nemesis")) {
-            int loyalty = source.getCounters(CounterType.LOYALTY);
+            int loyalty = source.getCounters(CounterEnumType.LOYALTY);
             for (; loyalty > 0; loyalty--) {
                 if (this.damageTargetAI(ai, sa, loyalty, false)) {
                     dmg = ComputerUtilCombat.getEnoughDamageToKill(sa.getTargetCard(), loyalty, source, false, false);
@@ -284,7 +285,7 @@ public class DamageDealAi extends DamageAiBase {
             }
         }
 
-        if ("XCountersDamage".equals(logic) && sa.getPayCosts() != null) {
+        if ("XCountersDamage".equals(logic)) {
             // Check to ensure that we have enough counters to remove per the defined PayX
             for (CostPart part : sa.getPayCosts().getCostParts()) {
                 if (part instanceof CostRemoveCounter) {
@@ -444,11 +445,11 @@ public class DamageDealAi extends DamageAiBase {
         // As of right now, ranks planeswalkers by their Current Loyalty * 10 + Big buff if close to "Ultimate"
         int bestScore = 0;
         for (Card pw : pws) {
-            int curLoyalty = pw.getCounters(CounterType.LOYALTY);
+            int curLoyalty = pw.getCounters(CounterEnumType.LOYALTY);
             int pwScore = curLoyalty * 10;
 
             for (SpellAbility sa : pw.getSpellAbilities()) {
-                if (sa.hasParam("Ultimate") && sa.getPayCosts() != null) {
+                if (sa.hasParam("Ultimate")) {
                     Integer loyaltyCost = 0;
                     CostRemoveCounter remLoyalty = sa.getPayCosts().getCostPartByType(CostRemoveCounter.class);
                     if (remLoyalty != null) {
@@ -472,6 +473,22 @@ public class DamageDealAi extends DamageAiBase {
         return bestTgt;
     }
 
+    private Card getWorstPlaneswalkerToDamage(final List<Card> pws) {
+        Card bestTgt = null;
+
+        int bestScore = Integer.MAX_VALUE;
+        for (Card pw : pws) {
+            int curLoyalty = pw.getCounters(CounterEnumType.LOYALTY);
+
+            if (curLoyalty < bestScore) {
+                bestScore = curLoyalty;
+                bestTgt = pw;
+            }
+        }
+
+        return bestTgt;
+    }
+
 
     private List<Card> getTargetableCards(Player ai, SpellAbility sa, Player pl, TargetRestrictions tgt, Player activator, Card source, Game game) {
         List<Card> hPlay = CardLists.getValidCards(game.getCardsIn(ZoneType.Battlefield), tgt.getValidTgts(), activator, source, sa);
@@ -556,6 +573,13 @@ public class DamageDealAi extends DamageAiBase {
                 sa.getTargets().add(enemy);
             }
             return true;
+        } else if ("DamageAfterPutCounter".equals(logic)
+                && sa.getParent() != null
+                && "P1P1".equals(sa.getParent().getParam("CounterType"))) {
+            // assuming the SA parent is of PutCounter type. Perhaps it's possible to predict counter multipliers here somehow?
+            final String amountStr = sa.getParent().getParamOrDefault("CounterNum", "1");
+            final int amount = AbilityUtils.calculateAmount(sa.getHostCard(), amountStr, sa);
+            dmg += amount;
         }
 
         // AssumeAtLeastOneTarget is used for cards with funky targeting implementation like Fight with Fire which would
@@ -566,7 +590,10 @@ public class DamageDealAi extends DamageAiBase {
 
         immediately |= ComputerUtil.playImmediately(ai, sa);
 
+        if (!(sa.getParent() != null && sa.getParent().isTargetNumberValid())) {
             sa.resetTargets();
+        }
+
         // target loop
         TargetChoices tcs = sa.getTargets();
 
@@ -767,8 +794,7 @@ public class DamageDealAi extends DamageAiBase {
                 if (((phase.is(PhaseType.END_OF_TURN) && phase.getNextTurn().equals(ai))
                         || (SpellAbilityAi.isSorcerySpeed(sa) && phase.is(PhaseType.MAIN2))
                         || ("PingAfterAttack".equals(logic) && phase.getPhase().isAfter(PhaseType.COMBAT_DECLARE_ATTACKERS) && phase.isPlayerTurn(ai))
-                        || sa.getPayCosts() == null || immediately
-                        || this.shouldTgtP(ai, sa, dmg, noPrevention)) &&
+                        || immediately || shouldTgtP(ai, sa, dmg, noPrevention)) &&
                         (!avoidTargetP(ai, sa))) {
                 	tcs.add(enemy);
                     if (divided) {
@@ -785,7 +811,7 @@ public class DamageDealAi extends DamageAiBase {
                     return false;
                 } else {
                     // If the trigger is mandatory, gotta choose my own stuff now
-                    return this.damageChooseRequiredTargets(ai, sa, tgt, dmg, mandatory);
+                    return this.damageChooseRequiredTargets(ai, sa, tgt, dmg);
                 }
             } else {
                 // TODO is this good enough? for up to amounts?
@@ -862,12 +888,9 @@ public class DamageDealAi extends DamageAiBase {
      *            a {@link forge.game.spellability.TargetRestrictions} object.
      * @param dmg
      *            a int.
-     * @param mandatory
-     *            a boolean.
      * @return a boolean.
      */
-    private boolean damageChooseRequiredTargets(final Player ai, final SpellAbility sa, final TargetRestrictions tgt, final int dmg,
-            final boolean mandatory) {
+    private boolean damageChooseRequiredTargets(final Player ai, final SpellAbility sa, final TargetRestrictions tgt, final int dmg) {
         // this is for Triggered targets that are mandatory
         final boolean noPrevention = sa.hasParam("NoPrevention");
         final boolean divided = sa.hasParam("DividedAsYouChoose");
@@ -875,7 +898,7 @@ public class DamageDealAi extends DamageAiBase {
 
         while (sa.getTargets().getNumTargeted() < tgt.getMinTargets(sa.getHostCard(), sa)) {
             if (tgt.canTgtPlaneswalker()) {
-                final Card c = this.dealDamageChooseTgtPW(ai, sa, dmg, noPrevention, ai, mandatory);
+                final Card c = this.dealDamageChooseTgtPW(ai, sa, dmg, noPrevention, ai, true);
                 if (c != null) {
                     sa.getTargets().add(c);
                     if (divided) {
@@ -888,7 +911,7 @@ public class DamageDealAi extends DamageAiBase {
 
             // TODO: This currently also catches planeswalkers that can be killed (still necessary? Or can be removed?)
             if (tgt.canTgtCreature()) {
-                final Card c = this.dealDamageChooseTgtC(ai, sa, dmg, noPrevention, ai, mandatory);
+                final Card c = this.dealDamageChooseTgtC(ai, sa, dmg, noPrevention, ai, true);
                 if (c != null) {
                     sa.getTargets().add(c);
                     if (divided) {
@@ -909,6 +932,32 @@ public class DamageDealAi extends DamageAiBase {
                 }
             }
 
+            // See if there's an indestructible target that can be used
+            CardCollection indestructible = CardLists.filter(ai.getCardsIn(ZoneType.Battlefield),
+                    Predicates.and(CardPredicates.Presets.CREATURES, CardPredicates.Presets.PLANESWALKERS, CardPredicates.hasKeyword(Keyword.INDESTRUCTIBLE), CardPredicates.isTargetableBy(sa)));
+
+            if (!indestructible.isEmpty()) {
+                Card c = ComputerUtilCard.getWorstPermanentAI(indestructible, false, false, false, false);
+                sa.getTargets().add(c);
+                if (divided) {
+                    tgt.addDividedAllocation(c, dmg);
+                    break;
+                }
+                continue;
+            }
+            else if (tgt.canTgtPlaneswalker()) {
+                // Second pass for planeswalkers: choose AI's worst planeswalker
+                final Card c = getWorstPlaneswalkerToDamage(CardLists.filter(ai.getCardsIn(ZoneType.Battlefield), Predicates.and(CardPredicates.Presets.PLANESWALKERS), CardPredicates.isTargetableBy(sa)));
+                if (c != null) {
+                    sa.getTargets().add(c);
+                    if (divided) {
+                        tgt.addDividedAllocation(c, dmg);
+                        break;
+                    }
+                    continue;
+                }
+            }
+
             if (sa.canTarget(ai)) {
                 if (sa.getTargets().add(ai)) {
                     if (divided) {
@@ -1076,8 +1125,7 @@ public class DamageDealAi extends DamageAiBase {
                         continue;
                     }
                     // currently works only with cards that don't have additional costs (only mana is supported)
-                    if (ab.getPayCosts() != null
-                            && (ab.getPayCosts().hasNoManaCost() || ab.getPayCosts().hasOnlySpecificCostType(CostPartMana.class))) {
+                    if (ab.getPayCosts().hasNoManaCost() || ab.getPayCosts().hasOnlySpecificCostType(CostPartMana.class)) {
                         String dmgDef = "0";
                         if (ab.getApi() == ApiType.DealDamage) {
                             dmgDef = ab.getParamOrDefault("NumDmg", "0");
@@ -1101,7 +1149,7 @@ public class DamageDealAi extends DamageAiBase {
                                 }
 
                                 // FIXME: should it also check restrictions for targeting players?
-                                ManaCost costSa = sa.getPayCosts() != null ? sa.getPayCosts().getTotalMana() : ManaCost.NO_COST;
+                                ManaCost costSa = sa.getPayCosts().getTotalMana();
                                 ManaCost costAb = ab.getPayCosts().getTotalMana(); // checked for null above
                                 ManaCost total = ManaCost.combine(costSa, costAb);
                                 SpellAbility combinedAb = ab.copyWithDefinedCost(new Cost(total, false));

forge-ai/src/main/java/forge/ai/ability/DestroyAi.java

@@ -101,7 +101,7 @@ public class DestroyAi extends SpellAbilityAi {
                 return SpecialCardAi.SarkhanTheMad.considerMakeDragon(ai, sa);
             } else if (logic != null && logic.startsWith("MinLoyalty.")) {
                 int minLoyalty = Integer.parseInt(logic.substring(logic.indexOf(".") + 1));
-                if (source.getCounters(CounterType.LOYALTY) < minLoyalty) {
+                if (source.getCounters(CounterEnumType.LOYALTY) < minLoyalty) {
                     return false;
                 }
             } else if ("Polymorph".equals(logic)) {
@@ -161,7 +161,7 @@ public class DestroyAi extends SpellAbilityAi {
                             return false;
                         }
                         //Check for undying
-                        return (!c.hasKeyword(Keyword.UNDYING) || c.getCounters(CounterType.P1P1) > 0);
+                        return (!c.hasKeyword(Keyword.UNDYING) || c.getCounters(CounterEnumType.P1P1) > 0);
                     }
                 });
             }
@@ -231,7 +231,7 @@ public class DestroyAi extends SpellAbilityAi {
                     }
                     if ("Pongify".equals(logic)) {
                         final Card token = TokenAi.spawnToken(choice.getController(), sa.getSubAbility());
-                        if (token == null) {
+                        if (token == null || !token.isCreature() || token.getNetToughness() < 1) {
                             return true;    // becomes Terminate
                         } else {
                             if (source.getGame().getPhaseHandler().getPhase()
@@ -256,7 +256,7 @@ public class DestroyAi extends SpellAbilityAi {
                 }
                 //option to hold removal instead only applies for single targeted removal
                 if (!sa.isTrigger() && abTgt.getMaxTargets(sa.getHostCard(), sa) == 1) {
-                    if (!ComputerUtilCard.useRemovalNow(sa, choice, 0, ZoneType.Graveyard)) {
+                    if (choice == null || !ComputerUtilCard.useRemovalNow(sa, choice, 0, ZoneType.Graveyard)) {
                         return false;
                     }
                 }
@@ -277,6 +277,7 @@ public class DestroyAi extends SpellAbilityAi {
                             SpellAbility sp = aura.getFirstSpellAbility();
                             if (sp != null && "GainControl".equals(sp.getParam("AILogic"))
                                 && aura.getController() != ai && sa.canTarget(aura)) {
+                                list.remove(choice);
                                 choice = aura;
                             }
                         }

forge-ai/src/main/java/forge/ai/ability/DigAi.java

@@ -1,6 +1,10 @@
 package forge.ai.ability;
 
+import java.util.Map;
+
 import com.google.common.base.Predicate;
+import com.google.common.collect.Iterables;
+
 import forge.ai.*;
 import forge.game.Game;
 import forge.game.ability.AbilityUtils;
@@ -130,7 +134,7 @@ public class DigAi extends SpellAbilityAi {
     }
     
     @Override
-    public Card chooseSingleCard(Player ai, SpellAbility sa, Iterable<Card> valid, boolean isOptional, Player relatedPlayer) {
+    public Card chooseSingleCard(Player ai, SpellAbility sa, Iterable<Card> valid, boolean isOptional, Player relatedPlayer, Map<String, Object> params) {
         if ("DigForCreature".equals(sa.getParam("AILogic"))) {
             Card bestChoice = ComputerUtilCard.getBestCreatureAI(valid);
             if (bestChoice == null) {
@@ -157,6 +161,15 @@ public class DigAi extends SpellAbilityAi {
         }
     }
 
+    /* (non-Javadoc)
+     * @see forge.card.ability.SpellAbilityAi#chooseSinglePlayer(forge.game.player.Player, forge.card.spellability.SpellAbility, java.util.List)
+     */
+    @Override
+    public Player chooseSinglePlayer(Player ai, SpellAbility sa, Iterable<Player> options, Map<String, Object> params) {
+        // an opponent choose a card from
+        return Iterables.getFirst(options, null);
+    }
+
     /* (non-Javadoc)
      * @see forge.card.ability.SpellAbilityAi#confirmAction(forge.card.spellability.SpellAbility, forge.game.player.PlayerActionConfirmMode, java.lang.String)
      */

forge-ai/src/main/java/forge/ai/ability/DrawAi.java

@@ -25,6 +25,7 @@ import forge.game.ability.ApiType;
 import forge.game.card.Card;
 import forge.game.card.CardLists;
 import forge.game.card.CardPredicates;
+import forge.game.card.CounterEnumType;
 import forge.game.card.CounterType;
 import forge.game.cost.*;
 import forge.game.phase.PhaseHandler;
@@ -262,7 +263,6 @@ public class DrawAi extends SpellAbilityAi {
                 // Draw up to max hand size but leave at least 3 in library
                 numCards = Math.min(computerMaxHandSize - computerHandSize, computerLibrarySize - 3);
 
-                if (sa.getPayCosts() != null) {
                 if (sa.getPayCosts().hasSpecificCostType(CostPayLife.class)) {
                     // [Necrologia, Pay X Life : Draw X Cards]
                     // Don't draw more than what's "safe" and don't risk a near death experience
@@ -279,7 +279,6 @@ public class DrawAi extends SpellAbilityAi {
                         return false;
                     }
                 }
-                }
 
                 sa.setSVar("ChosenX", Integer.toString(numCards));
                 source.setSVar("ChosenX", Integer.toString(numCards));
@@ -350,7 +349,7 @@ public class DrawAi extends SpellAbilityAi {
                 }
                 // try to make opponent lose to poison
                 // currently only Caress of Phyrexia
-                if (getPoison != null && oppA.canReceiveCounters(CounterType.POISON)) {
+                if (getPoison != null && oppA.canReceiveCounters(CounterType.get(CounterEnumType.POISON))) {
                     if (oppA.getPoisonCounters() + numCards > 9) {
                         sa.getTargets().add(oppA);
                         return true;
@@ -394,7 +393,7 @@ public class DrawAi extends SpellAbilityAi {
                     }
                 }
 
-                if (getPoison != null && ai.canReceiveCounters(CounterType.POISON)) {
+                if (getPoison != null && ai.canReceiveCounters(CounterType.get(CounterEnumType.POISON))) {
                     if (numCards + ai.getPoisonCounters() >= 8) {
                         aiTarget = false;
                     }
@@ -453,7 +452,7 @@ public class DrawAi extends SpellAbilityAi {
                 }
 
                 // ally would lose because of poison
-                if (getPoison != null && ally.canReceiveCounters(CounterType.POISON)) {
+                if (getPoison != null && ally.canReceiveCounters(CounterType.get(CounterEnumType.POISON))) {
                     if (ally.getPoisonCounters() + numCards > 9) {
                         continue;
                     }
@@ -514,6 +513,10 @@ public class DrawAi extends SpellAbilityAi {
 
     @Override
     protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
+        if (!mandatory && !willPayCosts(ai, sa, sa.getPayCosts(), sa.getHostCard())) {
+            return false;
+        }
+
         return targetAI(ai, sa, mandatory);
     }
 

forge-ai/src/main/java/forge/ai/ability/EffectAi.java

@@ -11,6 +11,7 @@ import forge.card.mana.ManaCost;
 import forge.game.Game;
 import forge.game.ability.ApiType;
 import forge.game.card.*;
+import forge.game.combat.Combat;
 import forge.game.combat.CombatUtil;
 import forge.game.cost.Cost;
 import forge.game.keyword.Keyword;
@@ -112,7 +113,7 @@ public class EffectAi extends SpellAbilityAi {
             } else if (logic.equals("SpellCopy")) {
             	// fetch Instant or Sorcery and AI has reason to play this turn
             	// does not try to get itself
-                final ManaCost costSa = sa.getPayCosts() != null ? sa.getPayCosts().getTotalMana() : ManaCost.NO_COST;
+                final ManaCost costSa = sa.getPayCosts().getTotalMana();
             	final int count = CardLists.count(ai.getCardsIn(ZoneType.Hand), new Predicate<Card>() {
                     @Override
                     public boolean apply(final Card c) {
@@ -134,7 +135,7 @@ public class EffectAi extends SpellAbilityAi {
                             AiPlayDecision decision = ((PlayerControllerAi)ai.getController()).getAi().canPlaySa(ab);
                             // see if we can pay both for this spell and for the Effect spell we're considering
                             if (decision == AiPlayDecision.WillPlay || decision == AiPlayDecision.WaitForMain2) {
-                                ManaCost costAb = ab.getPayCosts() != null ? ab.getPayCosts().getTotalMana() : ManaCost.NO_COST;
+                                ManaCost costAb = ab.getPayCosts().getTotalMana();
                                 ManaCost total = ManaCost.combine(costSa, costAb);
                                 SpellAbility combinedAb = ab.copyWithDefinedCost(new Cost(total, false));
                                 // can we pay both costs?
@@ -307,6 +308,16 @@ public class EffectAi extends SpellAbilityAi {
                 if (!ComputerUtil.targetPlayableSpellCard(ai, list, sa, false)) {
                     return false;
                 }
+            } else if (logic.equals("Bribe")) {
+                Card host = sa.getHostCard();
+                Combat combat = game.getCombat();
+                if (combat != null && combat.isAttacking(host, ai) && !combat.isBlocked(host)
+                        && game.getPhaseHandler().is(PhaseType.COMBAT_DECLARE_BLOCKERS)
+                        && !AiCardMemory.isRememberedCard(ai, host, AiCardMemory.MemorySet.ACTIVATED_THIS_TURN)) {
+                    AiCardMemory.rememberCard(ai, host, AiCardMemory.MemorySet.ACTIVATED_THIS_TURN); // ideally needs once per combat or something
+                    return true;
+                }
+                return false;
             }
         } else { //no AILogic
             return false;

forge-ai/src/main/java/forge/ai/ability/EncodeAi.java

@@ -18,6 +18,7 @@
 package forge.ai.ability;
 
 import java.util.List;
+import java.util.Map;
 
 import com.google.common.base.Predicate;
 
@@ -84,7 +85,7 @@ public final class EncodeAi extends SpellAbilityAi {
      * forge.game.player.Player)
      */
     @Override
-    public Card chooseSingleCard(final Player ai, SpellAbility sa, Iterable<Card> options, boolean isOptional, Player targetedPlayer) {
+    public Card chooseSingleCard(final Player ai, SpellAbility sa, Iterable<Card> options, boolean isOptional, Player targetedPlayer, Map<String, Object> params) {
         return chooseCard(ai, options, isOptional);
     }
 

forge-ai/src/main/java/forge/ai/ability/FightAi.java

@@ -45,6 +45,8 @@ public class FightAi extends SpellAbilityAi {
         aiCreatures = ComputerUtil.getSafeTargets(ai, sa, aiCreatures);
         List<Card> humCreatures = ai.getOpponents().getCreaturesInPlay();
         humCreatures = CardLists.getTargetableCards(humCreatures, sa);
+        if (humCreatures.isEmpty())
+            return false; //prevent IndexOutOfBoundsException on MOJHOSTO variant
 
         // assumes the triggered card belongs to the ai
         if (sa.hasParam("Defined")) {

forge-ai/src/main/java/forge/ai/ability/InvestigateAi.java

@@ -0,0 +1,27 @@
+package forge.ai.ability;
+
+
+import forge.ai.SpellAbilityAi;
+import forge.game.phase.PhaseHandler;
+import forge.game.phase.PhaseType;
+import forge.game.player.Player;
+import forge.game.player.PlayerActionConfirmMode;
+import forge.game.spellability.SpellAbility;
+
+public class InvestigateAi extends SpellAbilityAi {
+    /* (non-Javadoc)
+     * @see forge.card.abilityfactory.SpellAiLogic#canPlayAI(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility)
+     */
+    @Override
+    protected boolean canPlayAI(Player aiPlayer, SpellAbility sa) {
+        PhaseHandler ph = aiPlayer.getGame().getPhaseHandler();
+
+        return ph.is(PhaseType.END_OF_TURN) && ph.getNextTurn() == aiPlayer;
+    }
+
+    @Override
+    public boolean confirmAction(Player player, SpellAbility sa, PlayerActionConfirmMode mode, String message) {
+        return true;
+    }
+}
+

forge-ai/src/main/java/forge/ai/ability/LegendaryRuleAi.java

@@ -1,9 +1,11 @@
 package forge.ai.ability;
 
+import java.util.Map;
+
 import com.google.common.collect.Iterables;
 import forge.ai.SpellAbilityAi;
 import forge.game.card.Card;
-import forge.game.card.CounterType;
+import forge.game.card.CounterEnumType;
 import forge.game.player.Player;
 import forge.game.spellability.SpellAbility;
 
@@ -23,7 +25,7 @@ public class LegendaryRuleAi extends SpellAbilityAi {
     
 
     @Override
-    public Card chooseSingleCard(Player ai, SpellAbility sa, Iterable<Card> options, boolean isOptional, Player targetedPlayer) {
+    public Card chooseSingleCard(Player ai, SpellAbility sa, Iterable<Card> options, boolean isOptional, Player targetedPlayer, Map<String, Object> params) {
         // Choose a single legendary/planeswalker card to keep
         Card firstOption = Iterables.getFirst(options, null);
         boolean choosingFromPlanewalkers = firstOption.isPlaneswalker();
@@ -38,16 +40,16 @@ public class LegendaryRuleAi extends SpellAbilityAi {
         if (firstOption.getName().equals("Dark Depths")) {
             Card best = firstOption;
             for (Card c : options) {
-                if (c.getCounters(CounterType.ICE) < best.getCounters(CounterType.ICE)) {
+                if (c.getCounters(CounterEnumType.ICE) < best.getCounters(CounterEnumType.ICE)) {
                     best = c;
                 }
             }
             return best;
-        } else if (firstOption.getCounters(CounterType.KI) > 0) {
+        } else if (firstOption.getCounters(CounterEnumType.KI) > 0) {
         	// Extra Rule for KI counter
         	Card best = firstOption;
             for (Card c : options) {
-                if (c.getCounters(CounterType.KI) > best.getCounters(CounterType.KI)) {
+                if (c.getCounters(CounterEnumType.KI) > best.getCounters(CounterEnumType.KI)) {
                     best = c;
                 }
             }

forge-ai/src/main/java/forge/ai/ability/LifeGainAi.java

@@ -88,7 +88,6 @@ public class LifeGainAi extends SpellAbilityAi {
         if (lifeCritical
                 && sa.isAbility()
                 && sa.getHostCard() != null && sa.getHostCard().isCreature()
-                && sa.getPayCosts() != null
                 && (sa.getPayCosts().hasSpecificCostType(CostRemoveCounter.class) || sa.getPayCosts().hasSpecificCostType(CostSacrifice.class))) {
             if (!game.getStack().isEmpty()) {
                 SpellAbility saTop = game.getStack().peekAbility();

forge-ai/src/main/java/forge/ai/ability/LifeSetAi.java

@@ -5,7 +5,7 @@ import forge.ai.ComputerUtilMana;
 import forge.ai.SpellAbilityAi;
 import forge.game.ability.AbilityUtils;
 import forge.game.card.Card;
-import forge.game.card.CounterType;
+import forge.game.card.CounterEnumType;
 import forge.game.phase.PhaseType;
 import forge.game.player.Player;
 import forge.game.spellability.SpellAbility;
@@ -130,7 +130,7 @@ public class LifeSetAi extends SpellAbilityAi {
         }
 
         if (sourceName.equals("Eternity Vessel")
-                && (opponent.isCardInPlay("Vampire Hexmage") || (source.getCounters(CounterType.CHARGE) == 0))) {
+                && (opponent.isCardInPlay("Vampire Hexmage") || (source.getCounters(CounterEnumType.CHARGE) == 0))) {
             return false;
         }
 

forge-ai/src/main/java/forge/ai/ability/ManaEffectAi.java

@@ -81,7 +81,7 @@ public class ManaEffectAi extends SpellAbilityAi {
             return true; // handled elsewhere, does not meet the standard requirements
         }
 
-        return sa.getPayCosts() != null && sa.getPayCosts().hasNoManaCost() && sa.getPayCosts().isReusuableResource()
+        return sa.getPayCosts().hasNoManaCost() && sa.getPayCosts().isReusuableResource()
                 && sa.getSubAbility() == null && ComputerUtil.playImmediately(ai, sa);
         // return super.checkApiLogic(ai, sa);
     }
@@ -119,8 +119,8 @@ public class ManaEffectAi extends SpellAbilityAi {
         int numCounters = 0;
         int manaSurplus = 0;
         if ("XChoice".equals(host.getSVar("X"))
-                && sa.getPayCosts() != null && sa.getPayCosts().hasSpecificCostType(CostRemoveCounter.class)) {
-            CounterType ctrType = CounterType.KI; // Petalmane Baku
+                && sa.getPayCosts().hasSpecificCostType(CostRemoveCounter.class)) {
+            CounterType ctrType = CounterType.get(CounterEnumType.KI); // Petalmane Baku
             for (CostPart part : sa.getPayCosts().getCostParts()) {
                 if (part instanceof CostRemoveCounter) {
                     ctrType = ((CostRemoveCounter)part).counter;

forge-ai/src/main/java/forge/ai/ability/MillAi.java

@@ -1,15 +1,10 @@
 package forge.ai.ability;
 
-import java.util.Collections;
-import java.util.Comparator;
-import java.util.List;
-import java.util.Map;
-
 import com.google.common.collect.Lists;
 import com.google.common.collect.Maps;
-
 import forge.ai.ComputerUtil;
 import forge.ai.ComputerUtilMana;
+import forge.ai.SpecialCardAi;
 import forge.ai.SpellAbilityAi;
 import forge.game.ability.AbilityUtils;
 import forge.game.card.Card;
@@ -24,6 +19,11 @@ import forge.game.spellability.SpellAbility;
 import forge.game.spellability.TargetRestrictions;
 import forge.game.zone.ZoneType;
 
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Map;
+
 public class MillAi extends SpellAbilityAi {
 
     @Override
@@ -38,6 +38,8 @@ public class MillAi extends SpellAbilityAi {
         } else if (aiLogic.equals("LilianaMill")) {
             // Only mill if a "Raise Dead" target is available, in case of control decks with few creatures
             return CardLists.filter(ai.getCardsIn(ZoneType.Graveyard), CardPredicates.Presets.CREATURES).size() >= 1;
+        } else if (aiLogic.equals("Rebirth")) {
+            return ai.getLife() <= 8;
         }
         return true;
     }
@@ -194,6 +196,10 @@ public class MillAi extends SpellAbilityAi {
      */
     @Override
     public boolean confirmAction(Player player, SpellAbility sa, PlayerActionConfirmMode mode, String message) {
+        if ("TimmerianFiends".equals(sa.getParam("AILogic"))) {
+            return SpecialCardAi.TimmerianFiends.consider(player, sa);
+        }
+
         return true;
     }
 

forge-ai/src/main/java/forge/ai/ability/MustBlockAi.java

@@ -1,7 +1,7 @@
 package forge.ai.ability;
 
 import com.google.common.base.Predicate;
-
+import com.google.common.collect.Iterables;
 import com.google.common.collect.Lists;
 import forge.ai.*;
 import forge.game.Game;
@@ -12,14 +12,13 @@ import forge.game.card.CardPredicates;
 import forge.game.combat.Combat;
 import forge.game.combat.CombatUtil;
 import forge.game.keyword.Keyword;
-import forge.game.phase.PhaseHandler;
 import forge.game.phase.PhaseType;
 import forge.game.player.Player;
 import forge.game.spellability.SpellAbility;
-import forge.game.spellability.TargetRestrictions;
 import forge.game.zone.ZoneType;
 
 import java.util.List;
+import java.util.Map;
 
 public class MustBlockAi extends SpellAbilityAi {
 
@@ -28,7 +27,6 @@ public class MustBlockAi extends SpellAbilityAi {
         final Card source = sa.getHostCard();
         final Game game = aiPlayer.getGame();
         final Combat combat = game.getCombat();
-        final PhaseHandler ph = game.getPhaseHandler();
         final boolean onlyLethal = !"AllowNonLethal".equals(sa.getParam("AILogic"));
 
         if (combat == null || !combat.isAttacking(source)) {
@@ -39,7 +37,6 @@ public class MustBlockAi extends SpellAbilityAi {
             return false;
         }
 
-        final TargetRestrictions abTgt = sa.getTargetRestrictions();
         final List<Card> list = determineGoodBlockers(source, aiPlayer, combat.getDefenderPlayerByAttacker(source), sa, onlyLethal,false);
 
         if (!list.isEmpty()) {
@@ -69,7 +66,6 @@ public class MustBlockAi extends SpellAbilityAi {
     @Override
     protected boolean doTriggerAINoCost(final Player ai, SpellAbility sa, boolean mandatory) {
         final Card source = sa.getHostCard();
-        final TargetRestrictions abTgt = sa.getTargetRestrictions();
 
         // only use on creatures that can attack
         if (!ai.getGame().getPhaseHandler().getPhase().isBefore(PhaseType.MAIN2)) {
@@ -94,7 +90,7 @@ public class MustBlockAi extends SpellAbilityAi {
 
         boolean chance = false;
 
-        if (abTgt != null) {
+        if (sa.usesTargeting()) {
             final List<Card> list = determineGoodBlockers(definedAttacker, ai, ai.getWeakestOpponent(), sa, true,true);
             if (list.isEmpty()) {
                 return false;
@@ -119,6 +115,9 @@ public class MustBlockAi extends SpellAbilityAi {
 
             sa.getTargets().add(blocker);
             chance = true;
+        } else if (sa.hasParam("Choices")) {
+            // currently choice is attacked player
+            return true;
         } else {
             return false;
         }
@@ -126,16 +125,9 @@ public class MustBlockAi extends SpellAbilityAi {
         return chance;
     }
 
-    private List<Card> determineGoodBlockers(final Card attacker, final Player ai, Player defender, SpellAbility sa,
+    private List<Card> determineBlockerFromList(final Card attacker, final Player ai, Iterable<Card> options, SpellAbility sa,
             final boolean onlyLethal, final boolean testTapped) {
-        final Card source = sa.getHostCard();
-        final TargetRestrictions abTgt = sa.getTargetRestrictions();
-
-        List<Card> list = Lists.newArrayList();
-        list = CardLists.filter(defender.getCardsIn(ZoneType.Battlefield), CardPredicates.Presets.CREATURES);
-        list = CardLists.getTargetableCards(list, sa);
-        list = CardLists.getValidCards(list, abTgt.getValidTgts(), source.getController(), source, sa);
-        list = CardLists.filter(list, new Predicate<Card>() {
+        List<Card> list = CardLists.filter(options, new Predicate<Card>() {
             @Override
             public boolean apply(final Card c) {
                 boolean tapped = c.isTapped();
@@ -161,4 +153,40 @@ public class MustBlockAi extends SpellAbilityAi {
 
         return list;
     }
+
+    private List<Card> determineGoodBlockers(final Card attacker, final Player ai, Player defender, SpellAbility sa,
+            final boolean onlyLethal, final boolean testTapped) {
+
+        List<Card> list = Lists.newArrayList();
+        list = CardLists.filter(defender.getCardsIn(ZoneType.Battlefield), CardPredicates.Presets.CREATURES);
+
+        if (sa.usesTargeting()) {
+            list = CardLists.getTargetableCards(list, sa);
+        }
+        return determineBlockerFromList(attacker, ai, list, sa, onlyLethal, testTapped);
+    }
+
+    @Override
+    protected Card chooseSingleCard(Player ai, SpellAbility sa, Iterable<Card> options, boolean isOptional,
+            Player targetedPlayer, Map<String, Object> params) {
+        final Card host = sa.getHostCard();
+
+        Card attacker = host;
+
+        if (sa.hasParam("DefinedAttacker")) {
+            List<Card> attackers = AbilityUtils.getDefinedCards(host, sa.getParam("DefinedAttacker"), sa);
+            attacker = Iterables.getFirst(attackers, null);
+        }
+        if (attacker == null) {
+            return Iterables.getFirst(options, null);
+        }
+
+        List<Card> better = determineBlockerFromList(attacker, ai, options, sa, false, false);
+
+        if (!better.isEmpty()) {
+            return Iterables.getFirst(options, null);
+        }
+
+        return Iterables.getFirst(options, null);
+    }
 }

forge-ai/src/main/java/forge/ai/ability/PlayAi.java

@@ -20,6 +20,7 @@ import forge.game.zone.ZoneType;
 import forge.util.MyRandom;
 
 import java.util.List;
+import java.util.Map;
 
 public class PlayAi extends SpellAbilityAi {
 
@@ -84,11 +85,11 @@ public class PlayAi extends SpellAbilityAi {
             return ComputerUtil.targetPlayableSpellCard(ai, cards, sa, sa.hasParam("WithoutManaCost"));                
         } else if (logic.startsWith("NeedsChosenCard")) {
             int minCMC = 0;
-            if (sa.getPayCosts() != null && sa.getPayCosts().getCostMana() != null) {
-                minCMC = sa.getPayCosts().getCostMana().getMana().getCMC();
+            if (sa.getPayCosts().getCostMana() != null) {
+                minCMC = sa.getPayCosts().getTotalMana().getCMC();
             }
             validOpts = CardLists.filter(validOpts, CardPredicates.greaterCMC(minCMC));
-            return chooseSingleCard(ai, sa, validOpts, sa.hasParam("Optional"), null) != null;
+            return chooseSingleCard(ai, sa, validOpts, sa.hasParam("Optional"), null, null) != null;
         }
 
         if (source != null && source.hasKeyword(Keyword.HIDEAWAY) && source.hasRemembered()) {
@@ -142,8 +143,7 @@ public class PlayAi extends SpellAbilityAi {
      */
     @Override
     public Card chooseSingleCard(final Player ai, final SpellAbility sa, Iterable<Card> options,
-            final boolean isOptional,
-            Player targetedPlayer) {
+            final boolean isOptional, Player targetedPlayer, Map<String, Object> params) {
         List<Card> tgtCards = CardLists.filter(options, new Predicate<Card>() {
             @Override
             public boolean apply(final Card c) {
@@ -156,9 +156,7 @@ public class PlayAi extends SpellAbilityAi {
                     if (sa.hasParam("WithoutManaCost")) {
                         // Try to avoid casting instants and sorceries with X in their cost, since X will be assumed to be 0.
                         if (!(spell instanceof SpellPermanent)) {
-                            if (spell.getPayCosts() != null
-                                    && spell.getPayCosts().getCostMana() != null
-                                    && spell.getPayCosts().getCostMana().getMana().countX() > 0) {
+                            if (spell.getPayCosts().getTotalMana().countX() > 0) {
                                 continue;
                             }
                         }

forge-ai/src/main/java/forge/ai/ability/PoisonAi.java

@@ -5,6 +5,7 @@ import com.google.common.base.Predicate;
 import forge.ai.ComputerUtil;
 import forge.ai.SpellAbilityAi;
 import forge.game.ability.AbilityUtils;
+import forge.game.card.CounterEnumType;
 import forge.game.card.CounterType;
 import forge.game.phase.PhaseHandler;
 import forge.game.phase.PhaseType;
@@ -59,7 +60,7 @@ public class PoisonAi extends SpellAbilityAi {
     protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
         if (sa.usesTargeting()) {
             return tgtPlayer(ai, sa, mandatory);
-        } else if (mandatory || !ai.canReceiveCounters(CounterType.POISON)) {
+        } else if (mandatory || !ai.canReceiveCounters(CounterType.get(CounterEnumType.POISON))) {
             // mandatory or ai is uneffected
             return true;
         } else {
@@ -92,7 +93,7 @@ public class PoisonAi extends SpellAbilityAi {
                 public boolean apply(Player input) {
                     if (input.cantLose()) {
                         return false;
-                    } else if (!input.canReceiveCounters(CounterType.POISON)) {
+                    } else if (!input.canReceiveCounters(CounterType.get(CounterEnumType.POISON))) {
                         return false;
                     }
                     return true;
@@ -113,7 +114,7 @@ public class PoisonAi extends SpellAbilityAi {
         if (tgts.isEmpty()) {
             if (mandatory) {
                 // AI is uneffected
-                if (ai.canBeTargetedBy(sa) && ai.canReceiveCounters(CounterType.POISON)) {
+                if (ai.canBeTargetedBy(sa) && ai.canReceiveCounters(CounterType.get(CounterEnumType.POISON))) {
                     sa.getTargets().add(ai);
                     return true;
                 }
@@ -127,7 +128,7 @@ public class PoisonAi extends SpellAbilityAi {
                             if (input.cantLose()) {
                                 return true;
                             }
-                            return !input.canReceiveCounters(CounterType.POISON);
+                            return !input.canReceiveCounters(CounterType.get(CounterEnumType.POISON));
                         }
 
                     });

forge-ai/src/main/java/forge/ai/ability/ProtectAi.java

@@ -5,11 +5,7 @@ import java.util.List;
 
 import com.google.common.base.Predicate;
 
-import forge.ai.AiAttackController;
-import forge.ai.ComputerUtil;
-import forge.ai.ComputerUtilCard;
-import forge.ai.ComputerUtilCombat;
-import forge.ai.SpellAbilityAi;
+import forge.ai.*;
 import forge.card.MagicColor;
 import forge.game.Game;
 import forge.game.GameObject;
@@ -206,7 +202,7 @@ public class ProtectAi extends SpellAbilityAi {
         if (game.getStack().isEmpty()) {
             // If the cost is tapping, don't activate before declare
             // attack/block
-            if ((sa.getPayCosts() != null) && sa.getPayCosts().hasTapCost()) {
+            if (sa.getPayCosts().hasTapCost()) {
                 if (game.getPhaseHandler().getPhase().isBefore(PhaseType.COMBAT_DECLARE_ATTACKERS)
                         && game.getPhaseHandler().isPlayerTurn(ai)) {
                     list.remove(sa.getHostCard());
@@ -221,6 +217,11 @@ public class ProtectAi extends SpellAbilityAi {
         // Don't target cards that will die.
         list = ComputerUtil.getSafeTargets(ai, sa, list);
 
+        // Don't target self if the cost includes sacrificing itself
+        if (ComputerUtilCost.isSacrificeSelfCost(sa.getPayCosts())) {
+            list.remove(source);
+        }
+
         if (list.isEmpty()) {
             return mandatory && protectMandatoryTarget(ai, sa, mandatory);
         }

forge-ai/src/main/java/forge/ai/ability/PumpAi.java

@@ -150,7 +150,7 @@ public class PumpAi extends PumpAiBase {
             }
 
             final String counterType = moveSA.getParam("CounterType");
-            final CounterType cType = "Any".equals(counterType) ? null : CounterType.valueOf(counterType);
+            final CounterType cType = "Any".equals(counterType) ? null : CounterType.getType(counterType);
 
             final PhaseHandler ph = game.getPhaseHandler();
             if (ph.inCombat() && ph.getPlayerTurn().isOpponentOf(ai)) {
@@ -185,7 +185,7 @@ public class PumpAi extends PumpAiBase {
                             // cant use substract on Copy
                             srcCardCpy.setCounters(cType, srcCardCpy.getCounters(cType) - amount);
 
-                            if (CounterType.P1P1.equals(cType) && srcCardCpy.getNetToughness() <= 0) {
+                            if (CounterEnumType.P1P1.equals(cType) && srcCardCpy.getNetToughness() <= 0) {
                                 return srcCardCpy.getCounters(cType) > 0 || !card.hasKeyword(Keyword.UNDYING)
                                         || card.isToken();
                             }
@@ -235,7 +235,7 @@ public class PumpAi extends PumpAiBase {
                                 // cant use substract on Copy
                                 srcCardCpy.setCounters(cType, srcCardCpy.getCounters(cType) - amount);
 
-                                if (CounterType.P1P1.equals(cType) && srcCardCpy.getNetToughness() <= 0) {
+                                if (CounterEnumType.P1P1.equals(cType) && srcCardCpy.getNetToughness() <= 0) {
                                     return srcCardCpy.getCounters(cType) > 0 || !card.hasKeyword(Keyword.UNDYING)
                                             || card.isToken();
                                 }
@@ -402,7 +402,7 @@ public class PumpAi extends PumpAiBase {
 
         if ("DebuffForXCounters".equals(sa.getParam("AILogic")) && sa.getTargetCard() != null) {
             // e.g. Skullmane Baku
-            CounterType ctrType = CounterType.KI;
+            CounterType ctrType = CounterType.get(CounterEnumType.KI);
             for (CostPart part : sa.getPayCosts().getCostParts()) {
                 if (part instanceof CostRemoveCounter) {
                     ctrType = ((CostRemoveCounter)part).counter;
@@ -515,7 +515,7 @@ public class PumpAi extends PumpAiBase {
         if (game.getStack().isEmpty()) {
             // If the cost is tapping, don't activate before declare
             // attack/block
-            if (sa.getPayCosts() != null && sa.getPayCosts().hasTapCost()) {
+            if (sa.getPayCosts().hasTapCost()) {
                 if (game.getPhaseHandler().getPhase().isBefore(PhaseType.COMBAT_DECLARE_ATTACKERS)
                         && game.getPhaseHandler().isPlayerTurn(ai)) {
                     list.remove(sa.getHostCard());
@@ -730,7 +730,7 @@ public class PumpAi extends PumpAiBase {
         final String numAttack = sa.hasParam("NumAtt") ? sa.getParam("NumAtt") : "";
 
         if (numDefense.equals("-X") && sa.getSVar("X").equals("Count$ChosenNumber")) {
-            int energy = ai.getCounters(CounterType.ENERGY);
+            int energy = ai.getCounters(CounterEnumType.ENERGY);
             for (SpellAbility s : source.getSpellAbilities()) {
                 if ("PayEnergy".equals(s.getParam("AILogic"))) {
                     energy += AbilityUtils.calculateAmount(source, s.getParam("CounterNum"), sa);
@@ -860,7 +860,7 @@ public class PumpAi extends PumpAiBase {
                 final boolean isInfect = source.hasKeyword(Keyword.INFECT); // Flesh-Eater Imp
                 int lethalDmg = isInfect ? 10 - defPlayer.getPoisonCounters() : defPlayer.getLife();
 
-                if (isInfect && !combat.getDefenderByAttacker(source).canReceiveCounters(CounterType.POISON)) {
+                if (isInfect && !combat.getDefenderByAttacker(source).canReceiveCounters(CounterType.get(CounterEnumType.POISON))) {
                     lethalDmg = Integer.MAX_VALUE; // won't be able to deal poison damage to kill the opponent
                 }
 
@@ -976,7 +976,7 @@ public class PumpAi extends PumpAiBase {
                 final boolean isInfect = source.hasKeyword(Keyword.INFECT);
                 int lethalDmg = isInfect ? 10 - defPlayer.getPoisonCounters() : defPlayer.getLife();
 
-                if (isInfect && !combat.getDefenderByAttacker(source).canReceiveCounters(CounterType.POISON)) {
+                if (isInfect && !combat.getDefenderByAttacker(source).canReceiveCounters(CounterType.get(CounterEnumType.POISON))) {
                     lethalDmg = Integer.MAX_VALUE; // won't be able to deal poison damage to kill the opponent
                 }
 

forge-ai/src/main/java/forge/ai/ability/PumpAiBase.java

@@ -15,6 +15,7 @@ import forge.game.combat.CombatUtil;
 import forge.game.keyword.Keyword;
 import forge.game.phase.PhaseHandler;
 import forge.game.phase.PhaseType;
+import forge.game.phase.Untap;
 import forge.game.player.Player;
 import forge.game.spellability.SpellAbility;
 import forge.game.zone.ZoneType;
@@ -93,7 +94,7 @@ public abstract class PumpAiBase extends SpellAbilityAi {
                 List<Card> attackers = CardLists.filter(ai.getCreaturesInPlay(), new Predicate<Card>() {
                     @Override
                     public boolean apply(final Card c) {
-                        if (c.equals(sa.getHostCard()) && sa.getPayCosts() != null && sa.getPayCosts().hasTapCost() 
+                        if (c.equals(sa.getHostCard()) && sa.getPayCosts().hasTapCost() 
                                 && (combat == null || !combat.isAttacking(c))) {
                             return false;
                         }
@@ -111,7 +112,7 @@ public abstract class PumpAiBase extends SpellAbilityAi {
             List<Card> attackers = CardLists.filter(ai.getCreaturesInPlay(), new Predicate<Card>() {
                 @Override
                 public boolean apply(final Card c) {
-                    if (c.equals(sa.getHostCard()) && sa.getPayCosts() != null && sa.getPayCosts().hasTapCost() 
+                    if (c.equals(sa.getHostCard()) && sa.getPayCosts().hasTapCost() 
                             && (combat == null || !combat.isAttacking(c))) {
                         return false;
                     }
@@ -129,6 +130,9 @@ public abstract class PumpAiBase extends SpellAbilityAi {
             // target needs to be a creature, controlled by the player which is attacked
             return !sa.getHostCard().isTapped() || (combat != null && combat.isAttacking(sa.getHostCard())
                     && card.getController().equals(combat.getDefenderPlayerByAttacker(sa.getHostCard())));
+        } else if (keyword.endsWith("This card doesn't untap during your next untap step.")) {
+            return !ph.getPhase().isBefore(PhaseType.MAIN2) && !card.isUntapped() && ph.isPlayerTurn(ai)
+                    && Untap.canUntap(card);
         } else if (keyword.endsWith("Prevent all combat damage that would be dealt by CARDNAME.")
                 || keyword.endsWith("Prevent all damage that would be dealt by CARDNAME.")) {
             if (ph.isPlayerTurn(ai) && (!(CombatUtil.canBlock(card) || combat != null && combat.isBlocking(card))
@@ -507,7 +511,8 @@ public abstract class PumpAiBase extends SpellAbilityAi {
         for (final String keyword : keywords) {
             // since most keywords are combat relevant check for those that are
             // not
-            if (keyword.endsWith("Shroud") || keyword.endsWith("Hexproof")) {
+            if (keyword.endsWith("This card doesn't untap during your next untap step.")
+                    || keyword.endsWith("Shroud") || keyword.endsWith("Hexproof")) {
                 return true;
             }
         }

forge-ai/src/main/java/forge/ai/ability/RearrangeTopOfLibraryAi.java

@@ -26,7 +26,7 @@ public class RearrangeTopOfLibraryAi extends SpellAbilityAi {
         final PhaseHandler ph = aiPlayer.getGame().getPhaseHandler();
         final Card source = sa.getHostCard();
 
-        if (source.isPermanent() && sa.getRestrictions().isInstantSpeed() && sa.getPayCosts() != null
+        if (source.isPermanent() && sa.getRestrictions().isInstantSpeed()
                 && (sa.getPayCosts().hasTapCost() || sa.getPayCosts().hasManaCost())) {
             // If it has an associated cost, try to only do this before own turn
             if (!(ph.is(PhaseType.END_OF_TURN) && ph.getNextTurn() == aiPlayer)) {

forge-ai/src/main/java/forge/ai/ability/RepeatEachAi.java

@@ -1,6 +1,5 @@
 package forge.ai.ability;
 
-import com.google.common.base.Predicate;
 import forge.ai.ComputerUtilCard;
 import forge.ai.SpecialCardAi;
 import forge.ai.SpellAbilityAi;
@@ -16,6 +15,7 @@ import forge.game.zone.ZoneType;
 import forge.util.TextUtil;
 
 import java.util.List;
+import java.util.Map;
 
 
 public class RepeatEachAi extends SpellAbilityAi {
@@ -47,21 +47,6 @@ public class RepeatEachAi extends SpellAbilityAi {
                     return false;
                 }
             }
-        } else if ("GainControlOwns".equals(logic)) {
-            List<Card> list = CardLists.filter(aiPlayer.getGame().getCardsIn(ZoneType.Battlefield), new Predicate<Card>() {
-                @Override
-                public boolean apply(final Card crd) {
-                    return crd.isCreature() && !crd.getController().equals(crd.getOwner());
-                }
-            });
-            if (list.isEmpty()) {
-                return false;
-            }
-            for (final Card c : list) {
-                if (aiPlayer.equals(c.getController())) {
-                    return false;
-                }
-            }
         } else if ("OpponentHasCreatures".equals(logic)) {
             for (Player opp : aiPlayer.getOpponents()) {
                 if (!opp.getCreaturesInPlay().isEmpty()){
@@ -118,7 +103,7 @@ public class RepeatEachAi extends SpellAbilityAi {
     }
 
     @Override
-    protected Card chooseSingleCard(Player ai, SpellAbility sa, Iterable<Card> options, boolean isOptional, Player targetedPlayer) {
+    protected Card chooseSingleCard(Player ai, SpellAbility sa, Iterable<Card> options, boolean isOptional, Player targetedPlayer, Map<String, Object> params) {
         return ComputerUtilCard.getBestCreatureAI(options);
     }
 }

forge-ai/src/main/java/forge/ai/ability/SacrificeAi.java

@@ -63,6 +63,7 @@ public class SacrificeAi extends SpellAbilityAi {
         final boolean destroy = sa.hasParam("Destroy");
 
         Player opp = ai.getWeakestOpponent();
+
         if (tgt != null) {
             sa.resetTargets();
             if (!opp.canBeTargetedBy(sa)) {
@@ -74,8 +75,16 @@ public class SacrificeAi extends SpellAbilityAi {
             num = (num == null) ? "1" : num;
             final int amount = AbilityUtils.calculateAmount(sa.getHostCard(), num, sa);
 
-            List<Card> list =
-                    CardLists.getValidCards(opp.getCardsIn(ZoneType.Battlefield), valid.split(","), sa.getActivatingPlayer(), sa.getHostCard(), sa);
+            List<Card> list = null;
+            try {
+                list = CardLists.getValidCards(opp.getCardsIn(ZoneType.Battlefield), valid.split(","), sa.getActivatingPlayer(), sa.getHostCard(), sa);
+            } catch (NullPointerException e) {
+                return false;
+            } finally {
+                if (list == null)
+                    return false;
+            }//prevent NPE on MoJhoSto
+
             for (Card c : list) {
                 if (c.hasSVar("SacMe") && Integer.parseInt(c.getSVar("SacMe")) > 3) {
                 	return false;
@@ -131,15 +140,31 @@ public class SacrificeAi extends SpellAbilityAi {
                 amount = Math.min(ComputerUtilMana.determineLeftoverMana(sa, ai), amount);
             }
 
-            List<Card> humanList =
-                    CardLists.getValidCards(opp.getCardsIn(ZoneType.Battlefield), valid.split(","), sa.getActivatingPlayer(), sa.getHostCard(), sa);
+            List<Card> humanList = null;
+            try {
+                humanList = CardLists.getValidCards(opp.getCardsIn(ZoneType.Battlefield), valid.split(","), sa.getActivatingPlayer(), sa.getHostCard(), sa);
+            } catch (NullPointerException e) {
+                return false;
+            } finally {
+                if (humanList == null)
+                    return false;
+            }//prevent NPE on MoJhoSto
 
             // Since all of the cards have AI:RemoveDeck:All, I enabled 1 for 1
             // (or X for X) trades for special decks
             return humanList.size() >= amount;
         } else if (defined.equals("You")) {
-            List<Card> computerList =
-                    CardLists.getValidCards(ai.getCardsIn(ZoneType.Battlefield), valid.split(","), sa.getActivatingPlayer(), sa.getHostCard(), sa);
+
+            List<Card> computerList = null;
+            try {
+                computerList = CardLists.getValidCards(ai.getCardsIn(ZoneType.Battlefield), valid.split(","), sa.getActivatingPlayer(), sa.getHostCard(), sa);
+            } catch (NullPointerException e) {
+                return false;
+            } finally {
+                if (computerList == null)
+                    return false;
+            }//prevent NPE on MoJhoSto
+
             for (Card c : computerList) {
                 if (c.hasSVar("SacMe") || ComputerUtilCard.evaluateCreature(c) <= 135) {
                     return true;

forge-ai/src/main/java/forge/ai/ability/ScryAi.java

@@ -46,13 +46,11 @@ public class ScryAi extends SpellAbilityAi {
         // and right before the beginning of AI's turn, if possible, to avoid mana locking the AI and also to
         // try to scry right before drawing a card. Also, avoid tapping creatures in the AI's turn, if possible,
         // even if there's no mana cost.
-        if (sa.getPayCosts() != null) {
         if (sa.getPayCosts().hasTapCost()
                 && (sa.getPayCosts().hasManaCost() || (sa.getHostCard() != null && sa.getHostCard().isCreature()))
                 && !SpellAbilityAi.isSorcerySpeed(sa)) {
             return ph.getNextTurn() == ai && ph.is(PhaseType.END_OF_TURN);
         }
-        }
 
         // AI logic to scry in Main 1 if there is no better option, otherwise scry at opponent's EOT
         // (e.g. Glimmer of Genius)
@@ -76,8 +74,7 @@ public class ScryAi extends SpellAbilityAi {
         boolean hasSomethingElse = false;
         for (Card c : CardLists.filter(ai.getCardsIn(ZoneType.Hand), Predicates.not(CardPredicates.Presets.LANDS))) {
             for (SpellAbility ab : c.getAllSpellAbilities()) {
-                if (ab.getPayCosts() != null
-                        && ab.getPayCosts().hasManaCost()
+                if (ab.getPayCosts().hasManaCost()
                         && ComputerUtilMana.hasEnoughManaSourcesToCast(ab, ai)) {
                     // TODO: currently looks for non-Scry cards, can most certainly be made smarter.
                     if (ab.getApi() != ApiType.Scry) {
@@ -102,7 +99,7 @@ public class ScryAi extends SpellAbilityAi {
         } else if ("BrainJar".equals(aiLogic)) {
             final Card source = sa.getHostCard();
             
-            int counterNum = source.getCounters(CounterType.CHARGE);
+            int counterNum = source.getCounters(CounterEnumType.CHARGE);
             // no need for logic
             if (counterNum == 0) {
                 return false;

forge-ai/src/main/java/forge/ai/ability/SetStateAi.java

@@ -248,7 +248,7 @@ public class SetStateAi extends SpellAbilityAi {
                 final Card othercard = aiPlayer.getCardsIn(ZoneType.Battlefield, other.getName()).getFirst();
 
                 // for legendary KI counter creatures
-                if (othercard.getCounters(CounterType.KI) >= source.getCounters(CounterType.KI)) {
+                if (othercard.getCounters(CounterEnumType.KI) >= source.getCounters(CounterEnumType.KI)) {
                     // if the other legendary is useless try to replace it
                     return ComputerUtilCard.isUselessCreature(aiPlayer, othercard);
                 }

forge-ai/src/main/java/forge/ai/ability/SurveilAi.java

@@ -47,13 +47,11 @@ public class SurveilAi extends SpellAbilityAi {
         // and right before the beginning of AI's turn, if possible, to avoid mana locking the AI and also to
         // try to scry right before drawing a card. Also, avoid tapping creatures in the AI's turn, if possible,
         // even if there's no mana cost.
-        if (sa.getPayCosts() != null) {
         if (sa.getPayCosts().hasTapCost()
                 && (sa.getPayCosts().hasManaCost() || (sa.getHostCard() != null && sa.getHostCard().isCreature()))
                 && !SpellAbilityAi.isSorcerySpeed(sa)) {
             return ph.getNextTurn() == ai && ph.is(PhaseType.END_OF_TURN);
         }
-        }
 
         // in the player's turn Surveil should only be done in Main1 or in Upkeep if able
         if (ph.isPlayerTurn(ai)) {

forge-ai/src/main/java/forge/ai/ability/TapAi.java

@@ -3,6 +3,7 @@ package forge.ai.ability;
 import forge.ai.*;
 import forge.game.ability.AbilityUtils;
 import forge.game.card.Card;
+import forge.game.card.CounterEnumType;
 import forge.game.card.CounterType;
 import forge.game.cost.Cost;
 import forge.game.cost.CostPart;
@@ -68,7 +69,7 @@ public class TapAi extends TapAiBase {
         } else {
             if ("TapForXCounters".equals(sa.getParam("AILogic"))) {
                 // e.g. Waxmane Baku
-                CounterType ctrType = CounterType.KI;
+                CounterType ctrType = CounterType.get(CounterEnumType.KI);
                 for (CostPart part : sa.getPayCosts().getCostParts()) {
                     if (part instanceof CostRemoveCounter) {
                         ctrType = ((CostRemoveCounter)part).counter;

forge-ai/src/main/java/forge/ai/ability/TapAiBase.java

@@ -126,7 +126,7 @@ public abstract class TapAiBase extends SpellAbilityAi  {
                 }
 
                 for (final SpellAbility sa : c.getSpellAbilities()) {
-                    if (sa.isAbility() && sa.getPayCosts() != null && sa.getPayCosts().hasTapCost()) {
+                    if (sa.isAbility() && sa.getPayCosts().hasTapCost()) {
                         return true;
                     }
                 }
@@ -147,7 +147,7 @@ public abstract class TapAiBase extends SpellAbilityAi  {
                     }
 
                     for (final SpellAbility sa : c.getSpellAbilities()) {
-                        if (sa.isAbility() && sa.getPayCosts() != null && sa.getPayCosts().hasTapCost()) {
+                        if (sa.isAbility() && sa.getPayCosts().hasTapCost()) {
                             return true;
                         }
                     }

forge-ai/src/main/java/forge/ai/ability/TokenAi.java

@@ -1,11 +1,12 @@
 package forge.ai.ability;
 
+import java.util.Map;
+
 import com.google.common.base.Predicate;
 import com.google.common.collect.Iterables;
 import forge.ai.*;
 import forge.game.Game;
 import forge.game.GameEntity;
-import forge.game.ability.AbilityFactory;
 import forge.game.ability.AbilityUtils;
 import forge.game.ability.ApiType;
 import forge.game.card.Card;
@@ -25,16 +26,9 @@ import forge.game.player.PlayerActionConfirmMode;
 import forge.game.spellability.AbilitySub;
 import forge.game.spellability.SpellAbility;
 import forge.game.spellability.TargetRestrictions;
-import forge.game.trigger.Trigger;
-import forge.game.trigger.TriggerHandler;
 import forge.game.zone.ZoneType;
-import forge.item.PaperToken;
-import forge.util.MyRandom;
-import forge.util.TextUtil;
 
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
+import forge.util.MyRandom;
 
 /**
  * <p>
@@ -45,35 +39,10 @@ import java.util.List;
  * @version $Id: AbilityFactoryToken.java 17656 2012-10-22 19:32:56Z Max mtg $
  */
 public class TokenAi extends SpellAbilityAi {
-    private String tokenAmount;
-    private String tokenPower;
-    private String tokenToughness;
-
-    private Card actualToken;
-    /**
-     * <p>
-     * Constructor for AbilityFactory_Token.
-     * </p>
-     *
-     *            a {@link forge.game.ability.AbilityFactory} object.
-     */
-    private void readParameters(final SpellAbility mapParams) {
-        this.tokenAmount = mapParams.getParamOrDefault("TokenAmount", "1");
-
-        this.actualToken = TokenInfo.getProtoType(mapParams.getParam("TokenScript"), mapParams);
-
-        if (actualToken == null) {
-            this.tokenPower = mapParams.getParam("TokenPower");
-            this.tokenToughness = mapParams.getParam("TokenToughness");
-        } else {
-            this.tokenPower = actualToken.getBasePowerString();
-            this.tokenToughness = actualToken.getBaseToughnessString();
-        }
-    }
 
     @Override
     protected boolean checkPhaseRestrictions(final Player ai, final SpellAbility sa, final PhaseHandler ph) {
-        readParameters(sa); // remember to call this somewhere!
+
         final Card source = sa.getHostCard();
         // Planeswalker-related flags
         boolean pwMinus = false;
@@ -96,21 +65,23 @@ public class TokenAi extends SpellAbilityAi {
                 }
             }
         }
+        String tokenAmount = sa.getParamOrDefault("TokenAmount", "1");
 
-        if (actualToken == null) {
-            actualToken = spawnToken(ai, sa);
-        }
+        Card actualToken = spawnToken(ai, sa);
 
-        if (actualToken == null) {
+        if (actualToken == null || actualToken.getNetToughness() < 1) {
             final AbilitySub sub = sa.getSubAbility();
             // useful
             // no token created
             return pwPlus || (sub != null && SpellApiToAi.Converter.get(sub.getApi()).chkAIDrawback(sub, ai)); // planeswalker plus ability or sub-ability is
         }
 
+        String tokenPower = sa.getParamOrDefault("TokenPower", actualToken.getBasePowerString());
+        String tokenToughness = sa.getParamOrDefault("TokenToughness", actualToken.getBaseToughnessString());
+
         // X-cost spells
-        if (this.tokenAmount.equals("X") || (this.tokenToughness != null && this.tokenToughness.equals("X"))) {
-            int x = AbilityUtils.calculateAmount(sa.getHostCard(), this.tokenAmount, sa);
+        if ("X".equals(tokenAmount) || "X".equals(tokenPower) || "X".equals(tokenToughness)) {
+            int x = AbilityUtils.calculateAmount(sa.getHostCard(), tokenAmount, sa);
             if (source.getSVar("X").equals("Count$Converge")) {
                 x = ComputerUtilMana.getConvergeCount(sa, ai);
             }
@@ -124,14 +95,14 @@ public class TokenAi extends SpellAbilityAi {
             }
         }
 
-        if (canInterruptSacrifice(ai, sa, actualToken)) {
+        if (canInterruptSacrifice(ai, sa, actualToken, tokenAmount)) {
             return true;
         }
         
-        boolean haste = this.actualToken.hasKeyword(Keyword.HASTE);
+        boolean haste = actualToken.hasKeyword(Keyword.HASTE);
         boolean oneShot = sa.getSubAbility() != null
                 && sa.getSubAbility().getApi() == ApiType.DelayedTrigger;
-        boolean isCreature = this.actualToken.getType().isCreature();
+        boolean isCreature = actualToken.getType().isCreature();
 
         // Don't generate tokens without haste before main 2 if possible
         if (ph.getPhase().isBefore(PhaseType.MAIN2) && ph.isPlayerTurn(ai) && !haste && !sa.hasParam("ActivationPhases")
@@ -166,9 +137,10 @@ public class TokenAi extends SpellAbilityAi {
         if (ComputerUtil.preventRunAwayActivations(sa)) {
             return false;   // prevent infinite tokens?
         }
+        Card actualToken = spawnToken(ai, sa);
 
         // Don't kill AIs Legendary tokens
-        if (this.actualToken.getType().isLegendary() && ai.isCardInPlay(this.actualToken.getName())) {
+        if (actualToken.getType().isLegendary() && ai.isCardInPlay(actualToken.getName())) {
             // TODO Check if Token is useless due to an aura or counters?
             return false;
         }
@@ -240,7 +212,7 @@ public class TokenAi extends SpellAbilityAi {
     /**
      * Checks if the token(s) can save a creature from a sacrifice effect
      */
-    private boolean canInterruptSacrifice(final Player ai, final SpellAbility sa, final Card token) {
+    private boolean canInterruptSacrifice(final Player ai, final SpellAbility sa, final Card token, final String tokenAmount) {
         final Game game = ai.getGame();
         if (game.getStack().isEmpty()) {
             return false;   // nothing to interrupt
@@ -249,7 +221,7 @@ public class TokenAi extends SpellAbilityAi {
         if (topStack.getApi() != ApiType.Sacrifice) {
             return false;   // not sacrifice effect
         }
-        final int nTokens = AbilityUtils.calculateAmount(sa.getHostCard(), this.tokenAmount, sa);
+        final int nTokens = AbilityUtils.calculateAmount(sa.getHostCard(), tokenAmount, sa);
         final String valid = topStack.getParamOrDefault("SacValid", "Card.Self");
         String num = sa.getParam("Amount");
         num = (num == null) ? "1" : num;
@@ -271,7 +243,8 @@ public class TokenAi extends SpellAbilityAi {
 
     @Override
     protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
-        readParameters(sa);
+        String tokenAmount = sa.getParamOrDefault("TokenAmount", "1");
+
         final Card source = sa.getHostCard();
         final TargetRestrictions tgt = sa.getTargetRestrictions();
         if (tgt != null) {
@@ -282,8 +255,12 @@ public class TokenAi extends SpellAbilityAi {
                 sa.getTargets().add(ai);
             }
         }
-        if ("X".equals(this.tokenAmount) || "X".equals(this.tokenPower) || "X".equals(this.tokenToughness)) {
-            int x = AbilityUtils.calculateAmount(source, this.tokenAmount, sa);
+        Card actualToken = spawnToken(ai, sa);
+        String tokenPower = sa.getParamOrDefault("TokenPower", actualToken.getBasePowerString());
+        String tokenToughness = sa.getParamOrDefault("TokenToughness", actualToken.getBaseToughnessString());
+
+        if ("X".equals(tokenAmount) || "X".equals(tokenPower) || "X".equals(tokenToughness)) {
+            int x = AbilityUtils.calculateAmount(source, tokenAmount, sa);
             if (source.getSVar("X").equals("Count$xPaid")) {
                 // Set PayX here to maximum value.
                 x = ComputerUtilMana.determineLeftoverMana(sa, ai);
@@ -321,9 +298,7 @@ public class TokenAi extends SpellAbilityAi {
      * @see forge.card.ability.SpellAbilityAi#chooseSinglePlayer(forge.game.player.Player, forge.card.spellability.SpellAbility, Iterable<forge.game.player.Player> options)
      */
     @Override
-    protected Player chooseSinglePlayer(Player ai, SpellAbility sa, Iterable<Player> options) {
-        // TODO: AILogic
-        readParameters(sa); // remember to call this somewhere!
+    protected Player chooseSinglePlayer(Player ai, SpellAbility sa, Iterable<Player> options, Map<String, Object> params) {
         Combat combat = ai.getGame().getCombat();
         // TokenAttacking
         if (combat != null && sa.hasParam("TokenAttacking")) {
@@ -341,9 +316,7 @@ public class TokenAi extends SpellAbilityAi {
      * @see forge.card.ability.SpellAbilityAi#chooseSinglePlayerOrPlaneswalker(forge.game.player.Player, forge.card.spellability.SpellAbility, Iterable<forge.game.GameEntity> options)
      */
     @Override
-    protected GameEntity chooseSinglePlayerOrPlaneswalker(Player ai, SpellAbility sa, Iterable<GameEntity> options) {
-        // TODO: AILogic
-        readParameters(sa); // remember to call this somewhere!
+    protected GameEntity chooseSinglePlayerOrPlaneswalker(Player ai, SpellAbility sa, Iterable<GameEntity> options, Map<String, Object> params) {
         Combat combat = ai.getGame().getCombat();
         // TokenAttacking
         if (combat != null && sa.hasParam("TokenAttacking")) {
@@ -374,154 +347,22 @@ public class TokenAi extends SpellAbilityAi {
      * @param sa Token SpellAbility
      * @return token creature created by ability
      */
-    @Deprecated
     public static Card spawnToken(Player ai, SpellAbility sa) {
-        return spawnToken(ai, sa, false);
+        if (!sa.hasParam("TokenScript")) {
+            throw new RuntimeException("Spell Ability has no TokenScript: " + sa);
         }
-
-    /**
-     * Create the token as a Card object.
-     * @param ai owner of the new token
-     * @param sa Token SpellAbility
-     * @param notNull if the token would not survive, still return it
-     * @return token creature created by ability
-     */
-    // TODO Is this just completely copied from TokenEffect? Let's just call that thing
-    @Deprecated
-    public static Card spawnToken(Player ai, SpellAbility sa, boolean notNull) {
-        final Card host = sa.getHostCard();
-
         Card result = TokenInfo.getProtoType(sa.getParam("TokenScript"), sa);
 
-        if (result != null) {
-            result.setController(ai, 0);
+        if (result == null) {
+            throw new RuntimeException("don't find Token for TokenScript: " + sa.getParam("TokenScript"));
+        }
+
+        result.setOwner(ai);
+
+        // Apply static abilities
+        final Game game = ai.getGame();
+        ComputerUtilCard.applyStaticContPT(game, result, null);
         return result;
     }
 
-        String[] tokenKeywords = sa.hasParam("TokenKeywords") ? sa.getParam("TokenKeywords").split("<>") : new String[0];
-        String tokenPower = sa.getParam("TokenPower");
-        String tokenToughness = sa.getParam("TokenToughness");
-        String tokenName = sa.getParam("TokenName");
-        String[] tokenTypes = sa.getParam("TokenTypes").split(",");
-        StringBuilder cost = new StringBuilder();
-        String[] tokenColors = sa.getParam("TokenColors").split(",");
-        String tokenImage = sa.hasParam("TokenImage") ? PaperToken.makeTokenFileName(sa.getParam("TokenImage")) : "";
-        String[] tokenAbilities = sa.hasParam("TokenAbilities") ? sa.getParam("TokenAbilities").split(",") : null;
-        String[] tokenTriggers = sa.hasParam("TokenTriggers") ? sa.getParam("TokenTriggers").split(",") : null;
-        String[] tokenSVars = sa.hasParam("TokenSVars") ? sa.getParam("TokenSVars").split(",") : null;
-        String[] tokenStaticAbilities = sa.hasParam("TokenStaticAbilities") ? sa.getParam("TokenStaticAbilities").split(",") : null;
-        String[] tokenHiddenKeywords = sa.hasParam("TokenHiddenKeywords") ? sa.getParam("TokenHiddenKeywords").split("&") : null;
-        final String[] substitutedColors = Arrays.copyOf(tokenColors, tokenColors.length);
-        for (int i = 0; i < substitutedColors.length; i++) {
-            if (substitutedColors[i].equals("ChosenColor")) {
-                // this currently only supports 1 chosen color
-                substitutedColors[i] = host.getChosenColor();
-            }
-        }
-        StringBuilder colorDesc = new StringBuilder();
-        for (final String col : substitutedColors) {
-            if (col.equalsIgnoreCase("White")) {
-                colorDesc.append("W ");
-            } else if (col.equalsIgnoreCase("Blue")) {
-                colorDesc.append("U ");
-            } else if (col.equalsIgnoreCase("Black")) {
-                colorDesc.append("B ");
-            } else if (col.equalsIgnoreCase("Red")) {
-                colorDesc.append("R ");
-            } else if (col.equalsIgnoreCase("Green")) {
-                colorDesc.append("G ");
-            } else if (col.equalsIgnoreCase("Colorless")) {
-                colorDesc = new StringBuilder("C");
-            }
-        }
-        
-        final List<String> imageNames = new ArrayList<>(1);
-        if (tokenImage.equals("")) {
-            imageNames.add(PaperToken.makeTokenFileName(TextUtil.fastReplace(colorDesc.toString(), " ", ""), tokenPower, tokenToughness, tokenName));
-        } else {
-            imageNames.add(0, tokenImage);
-        }
-
-        for (final char c : colorDesc.toString().toCharArray()) {
-            cost.append(c + ' ');
-        }
-
-        cost = new StringBuilder(colorDesc.toString().replace('C', '1').trim());
-
-        final int finalPower = AbilityUtils.calculateAmount(host, tokenPower, sa);
-        final int finalToughness = AbilityUtils.calculateAmount(host, tokenToughness, sa);
-
-        final String[] substitutedTypes = Arrays.copyOf(tokenTypes, tokenTypes.length);
-        for (int i = 0; i < substitutedTypes.length; i++) {
-            if (substitutedTypes[i].equals("ChosenType")) {
-                substitutedTypes[i] = host.getChosenType();
-            }
-        }
-        final String substitutedName = tokenName.equals("ChosenType") ? host.getChosenType() : tokenName;
-        final String imageName = imageNames.get(MyRandom.getRandom().nextInt(imageNames.size()));
-        final TokenInfo tokenInfo = new TokenInfo(substitutedName, imageName,
-                cost.toString(), substitutedTypes, tokenKeywords, finalPower, finalToughness);
-        Card token = tokenInfo.makeOneToken(ai);
-
-        if (token == null) {
-            return null;
-        }
-        
-        // Grant rule changes
-        if (tokenHiddenKeywords != null) {
-            for (final String s : tokenHiddenKeywords) {
-                token.addHiddenExtrinsicKeyword(s);
-            }
-        }
-
-        // Grant abilities
-        if (tokenAbilities != null) {
-            for (final String s : tokenAbilities) {
-                final String actualAbility = host.getSVar(s);
-                final SpellAbility grantedAbility = AbilityFactory.getAbility(actualAbility, token);
-                token.addSpellAbility(grantedAbility);
-            }
-        }
-
-        // Grant triggers
-        if (tokenTriggers != null) {
-            for (final String s : tokenTriggers) {
-                final String actualTrigger = host.getSVar(s);
-                final Trigger parsedTrigger = TriggerHandler.parseTrigger(actualTrigger, token, true);
-                final String ability = host.getSVar(parsedTrigger.getParam("Execute"));
-                parsedTrigger.setOverridingAbility(AbilityFactory.getAbility(ability, token));
-                token.addTrigger(parsedTrigger);
-            }
-        }
-
-        // Grant SVars
-        if (tokenSVars != null) {
-            for (final String s : tokenSVars) {
-                String actualSVar = host.getSVar(s);
-                String name = s;
-                if (actualSVar.startsWith("SVar")) {
-                    actualSVar = actualSVar.split("SVar:")[1];
-                    name = actualSVar.split(":")[0];
-                    actualSVar = actualSVar.split(":")[1];
-                }
-                token.setSVar(name, actualSVar);
-            }
-        }
-
-        // Grant static abilities
-        if (tokenStaticAbilities != null) {
-            for (final String s : tokenStaticAbilities) {
-                token.addStaticAbility(host.getSVar(s));
-            }
-        }
-        
-        // Apply static abilities and prune dead tokens
-        final Game game = ai.getGame();
-        ComputerUtilCard.applyStaticContPT(game, token, null);
-        if (!notNull && token.isCreature() && token.getNetToughness() < 1) {
-            return null;
-        } else {
-            return token;
-        }
-    }
 }

forge-ai/src/main/java/forge/ai/ability/UntapAi.java

@@ -24,6 +24,7 @@ import forge.game.spellability.TargetRestrictions;
 import forge.game.zone.ZoneType;
 
 import java.util.List;
+import java.util.Map;
 
 public class UntapAi extends SpellAbilityAi {
     @Override
@@ -153,12 +154,11 @@ public class UntapAi extends SpellAbilityAi {
 
         // Try to avoid potential infinite recursion,
         // e.g. Kiora's Follower untapping another Kiora's Follower and repeating infinitely
-        if (sa.getPayCosts() != null && sa.getPayCosts().hasOnlySpecificCostType(CostTap.class)) {
+        if (sa.getPayCosts().hasOnlySpecificCostType(CostTap.class)) {
             CardCollection toRemove = new CardCollection();
             for (Card c : untapList) {
                 for (SpellAbility ab : c.getAllSpellAbilities()) {
                     if (ab.getApi() == ApiType.Untap
-                            && ab.getPayCosts() != null
                             && ab.getPayCosts().hasOnlySpecificCostType(CostTap.class)
                             && ab.canTarget(source)) {
                         toRemove.add(c);
@@ -312,7 +312,7 @@ public class UntapAi extends SpellAbilityAi {
     }
     
     @Override
-    public Card chooseSingleCard(Player ai, SpellAbility sa, Iterable<Card> list, boolean isOptional, Player targetedPlayer) {
+    public Card chooseSingleCard(Player ai, SpellAbility sa, Iterable<Card> list, boolean isOptional, Player targetedPlayer, Map<String, Object> params) {
         PlayerCollection pl = new PlayerCollection();
         pl.add(ai);
         pl.addAll(ai.getAllies());
@@ -331,7 +331,7 @@ public class UntapAi extends SpellAbilityAi {
         }
 
         // See if there's anything to untap that is tapped and that doesn't untap during the next untap step by itself
-        CardCollection noAutoUntap = CardLists.filter(untapList, Predicates.not(CardPredicates.canUntapPhaseController()));
+        CardCollection noAutoUntap = CardLists.filter(untapList, CardPredicates.hasKeyword("CARDNAME doesn't untap during your untap step."));
         if (!noAutoUntap.isEmpty()) {
             return ComputerUtilCard.getBestAI(noAutoUntap);
         }

forge-ai/src/main/java/forge/ai/ability/VoteAi.java

@@ -46,6 +46,12 @@ public class VoteAi extends SpellAbilityAi {
 
     @Override
     public int chooseNumber(Player player, SpellAbility sa, int min, int max, Map<String, Object> params) {
+        if (params.containsKey("Voter")) {
+            Player p = (Player)params.get("Voter");
+            if (p.isOpponentOf(player)) {
+                return min;
+            }
+        }
         if (sa.getActivatingPlayer().isOpponentOf(player)) {
             return min;
         }

forge-ai/src/main/java/forge/ai/simulation/GameCopier.java

@@ -76,7 +76,7 @@ public class GameCopier {
                 newPlayer.addSpellCastThisTurn();
             for (int j = 0; j < origPlayer.getLandsPlayedThisTurn(); j++)
                 newPlayer.addLandPlayedThisTurn();
-            newPlayer.setCounters(Maps.newEnumMap(origPlayer.getCounters()));
+            newPlayer.setCounters(Maps.newHashMap(origPlayer.getCounters()));
             newPlayer.setLifeLostLastTurn(origPlayer.getLifeLostLastTurn());
             newPlayer.setLifeLostThisTurn(origPlayer.getLifeLostThisTurn());
             newPlayer.setPreventNextDamage(origPlayer.getPreventNextDamage());
@@ -125,8 +125,6 @@ public class GameCopier {
                 }
             }
         }
-        origGame.validateSpabCache();
-        newGame.validateSpabCache();
 
         // Undo effects first before calculating them below, to avoid them applying twice.
         for (StaticEffect effect : origGame.getStaticEffects().getEffects()) {
@@ -330,7 +328,7 @@ public class GameCopier {
 
             Map<CounterType, Integer> counters = c.getCounters();
             if (!counters.isEmpty()) {
-                newCard.setCounters(Maps.newEnumMap(counters));
+                newCard.setCounters(Maps.newHashMap(counters));
             }
             if (c.getChosenPlayer() != null) {
                 newCard.setChosenPlayer(playerMap.get(c.getChosenPlayer()));

forge-ai/src/main/java/forge/ai/simulation/GameStateEvaluator.java

@@ -3,7 +3,7 @@ package forge.ai.simulation;
 import forge.ai.CreatureEvaluator;
 import forge.game.Game;
 import forge.game.card.Card;
-import forge.game.card.CounterType;
+import forge.game.card.CounterEnumType;
 import forge.game.phase.PhaseType;
 import forge.game.player.Player;
 import forge.game.zone.ZoneType;
@@ -29,6 +29,13 @@ public class GameStateEvaluator {
         if (phase.isAfter(PhaseType.COMBAT_DAMAGE) || evalGame.isGameOver()) {
             return null;
         }
+        // If the current player has no creatures in play, there won't be any combat. This avoids
+        // an expensive game copy operation.
+        // Note: This is is safe to do because the simulation is based on the current game state,
+        // so there isn't a chance to play creatures in between.
+        if (evalGame.getPhaseHandler().getPlayerTurn().getCreaturesInPlay().isEmpty()) {
+            return null;
+        }
         GameCopier copier = new GameCopier(evalGame);
         Game gameCopy = copier.makeCopy();
         gameCopy.getPhaseHandler().devAdvanceToPhase(PhaseType.COMBAT_DAMAGE);
@@ -147,7 +154,7 @@ public class GameStateEvaluator {
             // e.g. a 5 CMC permanent results in 200, whereas a 5/5 creature is ~225
             int value = 50 + 30 * c.getCMC();
             if (c.isPlaneswalker()) {
-                value += 2 * c.getCounters(CounterType.LOYALTY);
+                value += 2 * c.getCounters(CounterEnumType.LOYALTY);
             }
             return value;
         }

forge-ai/src/main/java/forge/ai/simulation/SpellAbilityPicker.java

@@ -23,6 +23,7 @@ import forge.util.TextUtil;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
+import java.util.Set;
 
 public class SpellAbilityPicker {
     private Game game;
@@ -307,7 +308,7 @@ public class SpellAbilityPicker {
             if (conditions == null) {
                 return true;
             }
-            List<PhaseType> phases = conditions.getPhases();
+            Set<PhaseType> phases = conditions.getPhases();
             return phases.isEmpty() || phases.contains(PhaseType.MAIN1);
         }
 

forge-core/pom.xml

@@ -6,7 +6,7 @@
     <parent>
         <artifactId>forge</artifactId>
         <groupId>forge</groupId>
-        <version>1.6.30-SNAPSHOT</version>
+        <version>1.6.35</version>
     </parent>
 
     <artifactId>forge-core</artifactId>
@@ -21,7 +21,7 @@
         <dependency>
             <groupId>org.apache.commons</groupId>
             <artifactId>commons-lang3</artifactId>
-            <version>3.7</version>
+            <version>3.8.1</version>
         </dependency>
     </dependencies>
 

forge-core/src/main/java/forge/ImageKeys.java

@@ -6,6 +6,8 @@ import forge.util.ImageUtil;
 import forge.util.TextUtil;
 import org.apache.commons.lang3.StringUtils;
 
+
+
 import java.io.File;
 import java.util.HashMap;
 import java.util.Map;
@@ -111,7 +113,28 @@ public final class ImageKeys {
             file = findFile(dir, TextUtil.fastReplace(filename, "AE", "Ae"));
             if (file != null) { return file; }
         }
-
+        //try fullborder...
+        if (filename.contains(".full")) {
+            String fullborderFile = TextUtil.fastReplace(filename, ".full", ".fullborder");
+            file = findFile(dir, fullborderFile);
+            if (file != null) { return file; }
+            // if there's a 1st art variant try without it for .fullborder images
+            file = findFile(dir, TextUtil.fastReplace(fullborderFile, "1.fullborder", ".fullborder"));
+            if (file != null) { return file; }
+            // if there's an art variant try without it for .full images
+            file = findFile(dir, filename.replaceAll("[0-9].full]",".full"));
+            if (file != null) { return file; }
+            // if there's a 1st art variant try with it for .full images
+            file = findFile(dir, filename.replaceAll("[0-9]*.full", "1.full"));
+            if (file != null) { return file; }
+        }
+        //if an image, like phenomenon or planes is missing .full in their filenames but you have an existing images that have .full/.fullborder
+        if (!filename.contains(".full")) {
+            file = findFile(dir, TextUtil.addSuffix(filename,".full"));
+            if (file != null) { return file; }
+            file = findFile(dir, TextUtil.addSuffix(filename,".fullborder"));
+            if (file != null) { return file; }
+        }
         // some S00 cards are really part of 6ED
         String s2kAlias = getSetFolder("S00");
         if (filename.startsWith(s2kAlias)) {

forge-core/src/main/java/forge/LobbyPlayer.java

@@ -11,6 +11,7 @@ import org.apache.commons.lang3.StringUtils;
 public abstract class LobbyPlayer {
     protected String name;
     private int avatarIndex = -1;
+    private int sleeveIndex = -1;
     private String avatarCardImageKey;
 
     public LobbyPlayer(String name) {
@@ -59,9 +60,15 @@ public abstract class LobbyPlayer {
     public int getAvatarIndex() {
         return avatarIndex;
     }
+    public int getSleeveIndex() {
+        return sleeveIndex;
+    }
     public void setAvatarIndex(int avatarIndex) {
         this.avatarIndex = avatarIndex;
     }
+    public void setSleeveIndex(int sleeveIndex) {
+        this.sleeveIndex = sleeveIndex;
+    }
 
     public String getAvatarCardImageKey() {
         return avatarCardImageKey;

forge-core/src/main/java/forge/StaticData.java

@@ -35,6 +35,7 @@ public class StaticData {
 
     private Predicate<PaperCard> standardPredicate;
     private Predicate<PaperCard> brawlPredicate;
+    private Predicate<PaperCard> pioneerPredicate;
     private Predicate<PaperCard> modernPredicate;
     private Predicate<PaperCard> commanderPredicate;
     private Predicate<PaperCard> oathbreakerPredicate;
@@ -53,11 +54,11 @@ public class StaticData {
 
     private static StaticData lastInstance = null;
 
-    public StaticData(CardStorageReader cardReader, String editionFolder, String blockDataFolder) {
-        this(cardReader, null, editionFolder, blockDataFolder);
+    public StaticData(CardStorageReader cardReader, String editionFolder, String blockDataFolder, boolean enableUnknownCards) {
+        this(cardReader, null, editionFolder, blockDataFolder, enableUnknownCards);
     }
 
-    public StaticData(CardStorageReader cardReader, CardStorageReader tokenReader, String editionFolder, String blockDataFolder) {
+    public StaticData(CardStorageReader cardReader, CardStorageReader tokenReader, String editionFolder, String blockDataFolder, boolean enableUnknownCards) {
         this.cardReader = cardReader;
         this.tokenReader = tokenReader;
         this.editions = new CardEdition.Collection(new CardEdition.Reader(new File(editionFolder)));
@@ -83,8 +84,8 @@ public class StaticData {
             variantCards = new CardDb(variantsCards, editions);
 
             //must initialize after establish field values for the sake of card image logic
-            commonCards.initialize(false, false);
-            variantCards.initialize(false, false);
+            commonCards.initialize(false, false, enableUnknownCards);
+            variantCards.initialize(false, false, enableUnknownCards);
         }
 
         {
@@ -197,13 +198,13 @@ public class StaticData {
 
     public TokenDb getAllTokens() { return allTokens; }
 
-    public Predicate<PaperCard> getStandardPredicate() {
-        return standardPredicate;
-    }
+    
 
     public void setStandardPredicate(Predicate<PaperCard> standardPredicate) { this.standardPredicate = standardPredicate; }
 
-    public void setModernPredicate(Predicate<PaperCard> modernPredicate) { this.modernPredicate = standardPredicate; }
+    public void setPioneerPredicate(Predicate<PaperCard> pioneerPredicate) { this.pioneerPredicate = pioneerPredicate; }
+
+    public void setModernPredicate(Predicate<PaperCard> modernPredicate) { this.modernPredicate = modernPredicate; }
 
     public void setCommanderPredicate(Predicate<PaperCard> commanderPredicate) { this.commanderPredicate = commanderPredicate; }
 
@@ -211,9 +212,11 @@ public class StaticData {
 
     public void setBrawlPredicate(Predicate<PaperCard> brawlPredicate) { this.brawlPredicate = brawlPredicate; }
 
-    public Predicate<PaperCard> getModernPredicate() {
-        return modernPredicate;
-    }
+    public Predicate<PaperCard> getStandardPredicate() { return standardPredicate; }
+    
+    public Predicate<PaperCard> getPioneerPredicate() { return pioneerPredicate; }
+
+    public Predicate<PaperCard> getModernPredicate() { return modernPredicate; }
 
     public Predicate<PaperCard> getCommanderPredicate() { return commanderPredicate; }
 

forge-core/src/main/java/forge/card/CardDb.java

@@ -165,7 +165,7 @@ public final class CardDb implements ICardDatabase, IDeckGenPool {
         reIndex();
     }
 
-    public void initialize(boolean logMissingPerEdition, boolean logMissingSummary) {
+    public void initialize(boolean logMissingPerEdition, boolean logMissingSummary, boolean enableUnknownCards) {
         Set<String> allMissingCards = new LinkedHashSet<>();
         List<String> missingCards = new ArrayList<>();
         CardEdition upcomingSet = null;
@@ -218,7 +218,7 @@ public final class CardDb implements ICardDatabase, IDeckGenPool {
             if (!contains(cr.getName())) {
                 if (upcomingSet != null) {
                     addCard(new PaperCard(cr, upcomingSet.getCode(), CardRarity.Unknown, 1));
-                } else {
+                } else if(enableUnknownCards) {
                     System.err.println("The card " + cr.getName() + " was not assigned to any set. Adding it to UNKNOWN set... to fix see res/editions/ folder. ");
                     addCard(new PaperCard(cr, CardEdition.UNKNOWN.getCode(), CardRarity.Special, 1));
                 }
@@ -312,17 +312,21 @@ public final class CardDb implements ICardDatabase, IDeckGenPool {
         return tryGetCard(request);
     }
 
-    public int getCardCollectorNumber(String cardName, String reqEdition) {
+    public String getCardCollectorNumber(String cardName, String reqEdition, int artIndex) {
         cardName = getName(cardName);
         CardEdition edition = editions.get(reqEdition);
         if (edition == null)
-            return -1;
+            return null;
+        int numMatches = 0;
         for (CardInSet card : edition.getCards()) {
             if (card.name.equalsIgnoreCase(cardName)) {
+                numMatches += 1;
+                if (numMatches == artIndex) {
                     return card.collectorNumber;
                 }
             }
-        return -1;
+        }
+        return null;
     }
 
     private PaperCard tryGetCard(CardRequest request) {
@@ -553,6 +557,23 @@ public final class CardDb implements ICardDatabase, IDeckGenPool {
         return Lists.newArrayList(Iterables.filter(this.roAllCards, predicate));
     }
 
+    // Do I want a foiled version of these cards?
+    @Override
+    public List<PaperCard> getAllCardsFromEdition(CardEdition edition) {
+        List<PaperCard> cards = Lists.newArrayList();
+
+        for(CardInSet cis : edition.getCards()) {
+            PaperCard card = this.getCard(cis.name, edition.getCode());
+            if (card == null) {
+                // Just in case the card is listed in the edition file but Forge doesn't support it
+                continue;
+            }
+
+            cards.add(card);
+        }
+        return cards;
+    }
+
     @Override
     public boolean contains(String name) {
         return allCardsByName.containsKey(getName(name));

forge-core/src/main/java/forge/card/CardEdition.java

@@ -38,6 +38,8 @@ import java.text.ParseException;
 import java.text.SimpleDateFormat;
 import java.util.*;
 import java.util.Map.Entry;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
 
 
 /**
@@ -75,10 +77,10 @@ public final class CardEdition implements Comparable<CardEdition> { // immutable
 
     public static class CardInSet {
         public final CardRarity rarity;
-        public final int collectorNumber;
+        public final String collectorNumber;
         public final String name;
 
-        public CardInSet(final String name, final int collectorNumber, final CardRarity rarity) {
+        public CardInSet(final String name, final String collectorNumber, final CardRarity rarity) {
             this.name = name;
             this.collectorNumber = collectorNumber;
             this.rarity = rarity;
@@ -86,7 +88,7 @@ public final class CardEdition implements Comparable<CardEdition> { // immutable
  
         public String toString() {
             StringBuilder sb = new StringBuilder();
-            if (collectorNumber != -1) {
+            if (collectorNumber != null) {
                 sb.append(collectorNumber);
                 sb.append(' ');
             }
@@ -110,6 +112,7 @@ public final class CardEdition implements Comparable<CardEdition> { // immutable
     private Type   type;
     private String name;
     private String alias = null;
+    private String prerelease = null;
     private boolean whiteBorder = false;
     private FoilType foilType = FoilType.NOT_SUPPORTED;
     private double foilChanceInBooster = 0;
@@ -178,6 +181,7 @@ public final class CardEdition implements Comparable<CardEdition> { // immutable
     public Type   getType()  { return type;  }
     public String getName()  { return name;  }
     public String getAlias() { return alias; }
+    public String getPrerelease() { return prerelease; }
     public FoilType getFoilType() { return foilType; }
     public double getFoilChanceInBooster() { return foilChanceInBooster; }
     public boolean getFoilAlwaysInCommonSlot() { return foilAlwaysInCommonSlot; }
@@ -188,6 +192,7 @@ public final class CardEdition implements Comparable<CardEdition> { // immutable
     public boolean getSmallSetOverride() { return smallSetOverride; }
     public String getBoosterMustContain() { return boosterMustContain; }
     public CardInSet[] getCards() { return cards; }
+    public boolean isModern() { return getDate().after(parseDate("2003-07-27")); } //8ED and above are modern except some promo cards and others
 
     public Map<String, Integer> getTokens() { return tokenNormalized; }
 
@@ -264,26 +269,35 @@ public final class CardEdition implements Comparable<CardEdition> { // immutable
             Map<String, Integer> tokenNormalized = new HashMap<>();
             List<CardEdition.CardInSet> processedCards = new ArrayList<>();
             if (contents.containsKey("cards")) {
+                final Pattern pattern = Pattern.compile(
+                        /*
+                        The following pattern will match the WAR Japanese art entries,
+                        it should also match the Un-set and older alternate art cards
+                        like Merseine from FEM (should the editions files ever be updated)
+                         */
+                        //"(^(?<cnum>[0-9]+.?) )?((?<rarity>[SCURML]) )?(?<name>.*)$"
+                        /*  Ideally we'd use the named group above, but Android 6 and
+                            earlier don't appear to support named groups.
+                            So, untill support for those devices is officially dropped,
+                            we'll have to suffice with numbered groups.
+                            We are looking for:
+                                * cnum - grouping #2
+                                * rarity - grouping #4
+                                * name - grouping #5
+                         */
+                        "(^([0-9]+.?) )?(([SCURML]) )?(.*)$"
+                );
                 for(String line : contents.get("cards")) {
-                    if (StringUtils.isBlank(line))
-                        continue;
-
-                    // Optional collector number at the start.
-                    String[] split = line.split(" ", 2);
-                    int collectorNumber = -1;
-                    if (split.length >= 2 && StringUtils.isNumeric(split[0])) {
-                        collectorNumber = Integer.parseInt(split[0]);
-                        line = split[1];
-                    }
-
-                    // You may omit rarity for early development
-                    CardRarity r = CardRarity.smartValueOf(line.substring(0, 1));
-                    boolean hadRarity = r != CardRarity.Unknown && line.charAt(1) == ' ';
-                    String cardName = hadRarity ? line.substring(2) : line;
+                    Matcher matcher = pattern.matcher(line);
+                    if (matcher.matches()) {
+                        String collectorNumber = matcher.group(2);
+                        CardRarity r = CardRarity.smartValueOf(matcher.group(4));
+                        String cardName = matcher.group(5);
                         CardInSet cis = new CardInSet(cardName, collectorNumber, r);
                         processedCards.add(cis);
                     }
                 }
+            }
 
             if (contents.containsKey("tokens")) {
                 for(String line : contents.get("tokens")) {
@@ -303,7 +317,7 @@ public final class CardEdition implements Comparable<CardEdition> { // immutable
                 tokenNormalized
             );
 
-            FileSection section = FileSection.parse(contents.get("metadata"), "=");
+            FileSection section = FileSection.parse(contents.get("metadata"), FileSection.EQUALS_KV_SEPARATOR);
             res.name  = section.get("name");
             res.date  = parseDate(section.get("date"));
             res.code  = section.get("code");
@@ -333,6 +347,7 @@ public final class CardEdition implements Comparable<CardEdition> { // immutable
                 }
             }
             res.type = enumType;
+            res.prerelease = section.get("Prerelease", null);
 
             switch(section.get("foil", "newstyle").toLowerCase()) {
                 case "notsupported":
@@ -413,6 +428,16 @@ public final class CardEdition implements Comparable<CardEdition> { // immutable
             return res;
         }
 
+        public Iterable<CardEdition> getPrereleaseEditions() {
+            List<CardEdition> res = Lists.newArrayList(this);
+            return Iterables.filter(res, new Predicate<CardEdition>() {
+                @Override
+                public boolean apply(final CardEdition edition) {
+                    return edition.getPrerelease() != null;
+                }
+            });
+        }
+
         public CardEdition getEditionByCodeOrThrow(final String code) {
             final CardEdition set = this.get(code);
             if (null == set) {

forge-core/src/main/java/forge/card/CardRules.java

@@ -222,7 +222,12 @@ public final class CardRules implements ICardCharacteristics {
 
     public boolean canBeBrawlCommander() {
         CardType type = mainPart.getType();
-        return (type.isLegendary() && type.isCreature()) || type.isPlaneswalker();
+        return type.isLegendary() && (type.isCreature() || type.isPlaneswalker());
+    }
+
+    public boolean canBeTinyLeadersCommander() {
+        CardType type = mainPart.getType();
+        return type.isLegendary() && (type.isCreature() || type.isPlaneswalker());
     }
 
     public String getMeldWith() {
@@ -526,12 +531,10 @@ public final class CardRules implements ICardCharacteristics {
             public final ManaCostShard next() {
                 final String unparsed = st.nextToken();
                 // System.out.println(unparsed);
-                try {
-                    int iVal = Integer.parseInt(unparsed);
-                    this.genericCost += iVal;
+                if (StringUtils.isNumeric(unparsed)) {
+                    this.genericCost += Integer.parseInt(unparsed);
                     return null;
                 }
-                catch (NumberFormatException nex) { }
 
                 return ManaCostShard.parseNonGeneric(unparsed);
             }

forge-core/src/main/java/forge/card/CardRulesPredicates.java

@@ -594,8 +594,10 @@ public final class CardRulesPredicates {
         public static final Predicate<CardRules> IS_VANGUARD = CardRulesPredicates.coreType(true, CardType.CoreType.Vanguard);
         public static final Predicate<CardRules> IS_CONSPIRACY = CardRulesPredicates.coreType(true, CardType.CoreType.Conspiracy);
         public static final Predicate<CardRules> IS_NON_LAND = CardRulesPredicates.coreType(false, CardType.CoreType.Land);
-        public static final Predicate<CardRules> CAN_BE_BRAWL_COMMANDER = Predicates.or(Presets.IS_PLANESWALKER,
-                Predicates.and(Presets.IS_CREATURE, Presets.IS_LEGENDARY));
+        public static final Predicate<CardRules> CAN_BE_BRAWL_COMMANDER = Predicates.and(Presets.IS_LEGENDARY,
+                Predicates.or(Presets.IS_CREATURE, Presets.IS_PLANESWALKER));
+        public static final Predicate<CardRules> CAN_BE_TINY_LEADERS_COMMANDER = Predicates.and(Presets.IS_LEGENDARY,
+                Predicates.or(Presets.IS_CREATURE, Presets.IS_PLANESWALKER));
 
         /** The Constant IS_NON_CREATURE_SPELL. **/
         public static final Predicate<CardRules> IS_NON_CREATURE_SPELL = com.google.common.base.Predicates

forge-core/src/main/java/forge/card/CardType.java

@@ -25,6 +25,7 @@ import java.util.List;
 import java.util.Map;
 import java.util.Set;
 
+import org.apache.commons.lang3.EnumUtils;
 import org.apache.commons.lang3.NotImplementedException;
 import org.apache.commons.lang3.StringUtils;
 
@@ -35,10 +36,8 @@ import com.google.common.collect.HashBiMap;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.Iterables;
 import com.google.common.collect.Lists;
-import com.google.common.collect.Maps;
 import com.google.common.collect.Sets;
 
-import forge.util.EnumUtil;
 import forge.util.Settable;
 
 /**
@@ -47,7 +46,6 @@ import forge.util.Settable;
  * </p>
  *
  * @author Forge
- * @version $Id: java 9708 2011-08-09 19:34:12Z jendave $
  */
 public final class CardType implements Comparable<CardType>, CardTypeView {
     private static final long serialVersionUID = 4629853583167022151L;
@@ -71,7 +69,16 @@ public final class CardType implements Comparable<CardType>, CardTypeView {
         Vanguard(false);
 
         public final boolean isPermanent;
-        private static final ImmutableList<String> allCoreTypeNames = EnumUtil.getNames(CoreType.class);
+        private static Map<String, CoreType> stringToCoreType = EnumUtils.getEnumMap(CoreType.class);
+        private static final Set<String> allCoreTypeNames = stringToCoreType.keySet();
+
+        public static CoreType getEnum(String name) {
+            return stringToCoreType.get(name);
+        }
+
+        public static boolean isValidEnum(String name) {
+            return stringToCoreType.containsKey(name);
+        }
 
         CoreType(final boolean permanent) {
             isPermanent = permanent;
@@ -86,19 +93,17 @@ public final class CardType implements Comparable<CardType>, CardTypeView {
         Ongoing,
         World;
 
-        private static final ImmutableList<String> allSuperTypeNames = EnumUtil.getNames(Supertype.class);
+        private static Map<String, Supertype> stringToSupertype = EnumUtils.getEnumMap(Supertype.class);
+        private static final Set<String> allSuperTypeNames = stringToSupertype.keySet();
+
+        public static Supertype getEnum(String name) {
+            return stringToSupertype.get(name);
         }
 
-    // This will be useful for faster parses
-    private static Map<String, CoreType> stringToCoreType = Maps.newHashMap();
-    private static Map<String, Supertype> stringToSupertype = Maps.newHashMap();
-    static {
-        for (final Supertype st : Supertype.values()) {
-            stringToSupertype.put(st.name(), st);
-        }
-        for (final CoreType ct : CoreType.values()) {
-            stringToCoreType.put(ct.name(), ct);
+        public static boolean isValidEnum(String name) {
+            return stringToSupertype.containsKey(name);
         }
+
     }
 
     private final Set<CoreType> coreTypes = EnumSet.noneOf(CoreType.class);
@@ -120,12 +125,12 @@ public final class CardType implements Comparable<CardType>, CardTypeView {
 
     public boolean add(final String t) {
         boolean changed;
-        final CoreType ct = stringToCoreType.get(t);
+        final CoreType ct = CoreType.getEnum(t);
         if (ct != null) {
             changed = coreTypes.add(ct);
         }
         else {
-            final Supertype st = stringToSupertype.get(t);
+            final Supertype st = Supertype.getEnum(t);
             if (st != null) {
                 changed = supertypes.add(st);
             }
@@ -190,13 +195,21 @@ public final class CardType implements Comparable<CardType>, CardTypeView {
 
     public boolean remove(final String str) {
         boolean changed = false;
-        if (CardType.isASupertype(str) && supertypes.remove(stringToSupertype.get(str))) {
+
+        // try to remove sub type first if able
+        if (subtypes.remove(str)) {
             changed = true;
-        } else if (CardType.isACardType(str) && coreTypes.remove(stringToCoreType.get(str))) {
-            changed = true;
-        } else if (subtypes.remove(str)) {
+        } else {
+            Supertype st = Supertype.getEnum(str);
+            if (st != null && supertypes.remove(st)) {
                 changed = true;
             }
+            CoreType ct = CoreType.getEnum(str);
+            if (ct != null && coreTypes.remove(ct)) {
+                changed = true;
+            }
+        }
+
         if (changed) {
             calculatedType = null;
         }
@@ -267,15 +280,13 @@ public final class CardType implements Comparable<CardType>, CardTypeView {
         if (hasSubtype(t)) {
             return true;
         }
-        final char firstChar = t.charAt(0);
-        if (Character.isLowerCase(firstChar)) {
-            t = Character.toUpperCase(firstChar) + t.substring(1); //ensure string is proper case for enum types
-        }
-        final CoreType type = stringToCoreType.get(t);
+
+        t = StringUtils.capitalize(t);
+        final CoreType type = CoreType.getEnum(t);
         if (type != null) {
             return hasType(type);
         }
-        final Supertype supertype = stringToSupertype.get(t);
+        final Supertype supertype = Supertype.getEnum(t);
         if (supertype != null) {
             return hasSupertype(supertype);
         }
@@ -307,18 +318,18 @@ public final class CardType implements Comparable<CardType>, CardTypeView {
         return subtypes.contains(creatureType) || subtypes.contains("AllCreatureTypes");
     }
     private static String toMixedCase(final String s) {
-        if (s.equals("")) {
+        if (s.isEmpty()) {
             return s;
         }
         final StringBuilder sb = new StringBuilder();
         // to handle hyphenated Types
+        // TODO checkout WordUtils for this
         final String[] types = s.split("-");
         for (int i = 0; i < types.length; i++) {
             if (i != 0) {
                 sb.append("-");
             }
-            sb.append(types[i].substring(0, 1).toUpperCase());
-            sb.append(types[i].substring(1).toLowerCase());
+            sb.append(StringUtils.capitalize(types[i]));
         }
         return sb.toString();
     }
@@ -606,13 +617,13 @@ public final class CardType implements Comparable<CardType>, CardTypeView {
 
     public static class Constant {
         public static final Settable LOADED = new Settable();
-        public static final List<String> BASIC_TYPES = Lists.newArrayList();
-        public static final List<String> LAND_TYPES = Lists.newArrayList();
-        public static final List<String> CREATURE_TYPES = Lists.newArrayList();
-        public static final List<String> SPELL_TYPES = Lists.newArrayList();
-        public static final List<String> ENCHANTMENT_TYPES = Lists.newArrayList();
-        public static final List<String> ARTIFACT_TYPES = Lists.newArrayList();
-        public static final List<String> WALKER_TYPES = Lists.newArrayList();
+        public static final Set<String> BASIC_TYPES = Sets.newHashSet();
+        public static final Set<String> LAND_TYPES = Sets.newHashSet();
+        public static final Set<String> CREATURE_TYPES = Sets.newHashSet();
+        public static final Set<String> SPELL_TYPES = Sets.newHashSet();
+        public static final Set<String> ENCHANTMENT_TYPES = Sets.newHashSet();
+        public static final Set<String> ARTIFACT_TYPES = Sets.newHashSet();
+        public static final Set<String> WALKER_TYPES = Sets.newHashSet();
 
         // singular -> plural
         public static final BiMap<String,String> pluralTypes = HashBiMap.create();
@@ -666,10 +677,10 @@ public final class CardType implements Comparable<CardType>, CardTypeView {
 
     ///////// Utility methods
     public static boolean isACardType(final String cardType) {
-        return getAllCardTypes().contains(cardType);
+        return CoreType.isValidEnum(cardType);
     }
 
-    public static ImmutableList<String> getAllCardTypes() {
+    public static Set<String> getAllCardTypes() {
         return CoreType.allCoreTypeNames;
     }
 
@@ -699,12 +710,12 @@ public final class CardType implements Comparable<CardType>, CardTypeView {
         return sortedSubTypes;
     }
 
-    public static List<String> getBasicTypes() {
-        return Collections.unmodifiableList(Constant.BASIC_TYPES);
+    public static Collection<String> getBasicTypes() {
+        return Collections.unmodifiableCollection(Constant.BASIC_TYPES);
     }
 
-    public static List<String> getAllCreatureTypes() {
-        return Collections.unmodifiableList(Constant.CREATURE_TYPES);
+    public static Collection<String> getAllCreatureTypes() {
+        return Collections.unmodifiableCollection(Constant.CREATURE_TYPES);
     }
     public static List<String> getAllLandTypes() {
         return ImmutableList.<String>builder()
@@ -714,7 +725,7 @@ public final class CardType implements Comparable<CardType>, CardTypeView {
     }
 
     public static boolean isASupertype(final String cardType) {
-        return (Supertype.allSuperTypeNames.contains(cardType));
+        return Supertype.isValidEnum(cardType);
     }
 
     public static boolean isASubType(final String cardType) {

forge-core/src/main/java/forge/card/ICardDatabase.java

@@ -28,6 +28,8 @@ public interface ICardDatabase extends Iterable<PaperCard> {
     List<PaperCard> getAllCards(String cardName);
     List<PaperCard> getAllCards(Predicate<PaperCard> predicate);
 
+    List<PaperCard> getAllCardsFromEdition(CardEdition edition);
+
     Predicate<? super PaperCard> wasPrintedInSets(List<String> allowedSetCodes);
     
 }

forge-core/src/main/java/forge/card/mana/ManaCostShard.java

@@ -289,13 +289,20 @@ public enum ManaCostShard {
         return BinaryUtil.bitCount(this.shard & COLORS_SUPERPOSITION) == 2;
     }
 
+    public boolean isGeneric() {
+    	return isOfKind(ManaAtom.GENERIC)|| isOfKind(ManaAtom.IS_X) || this.isSnow() || this.isOr2Generic();
+    }
     public boolean isOr2Generic() {
         return isOfKind(ManaAtom.OR_2_GENERIC);
     }
     
+    public boolean isColor(byte colorCode) {
+    	return (colorCode & this.shard) > 0;
+    }
+
     public boolean canBePaidWithManaOfColor(byte colorCode) {
         return this.isOr2Generic() || ((COLORS_SUPERPOSITION | ManaAtom.COLORLESS) & this.shard) == 0 ||
-                (colorCode & this.shard) > 0;
+                this.isColor(colorCode);
     }
     
     public boolean isOfKind(int atom) {

forge-core/src/main/java/forge/deck/DeckFormat.java

@@ -21,7 +21,6 @@ import com.google.common.base.Predicate;
 import com.google.common.base.Predicates;
 import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.Iterables;
-
 import forge.StaticData;
 import forge.card.CardRules;
 import forge.card.CardRulesPredicates;
@@ -37,8 +36,11 @@ import forge.util.TextUtil;
 import org.apache.commons.lang3.Range;
 import org.apache.commons.lang3.tuple.ImmutablePair;
 
-import java.util.*;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
 import java.util.Map.Entry;
+import java.util.Set;
 
 /**
  * GameType is an enum to determine the type of current game. :)
@@ -71,7 +73,7 @@ public enum DeckFormat {
         private final Set<String> bannedCards = ImmutableSet.of(
                 "Ancestral Recall", "Balance", "Black Lotus", "Black Vise", "Channel", "Chaos Orb", "Contract From Below", "Counterbalance", "Darkpact", "Demonic Attorney", "Demonic Tutor", "Earthcraft", "Edric, Spymaster of Trest", "Falling Star",
                 "Fastbond", "Flash", "Goblin Recruiter", "Grindstone", "Hermit Druid", "Imperial Seal", "Jeweled Bird", "Karakas", "Library of Alexandria", "Mana Crypt", "Mana Drain", "Mana Vault", "Metalworker", "Mind Twist", "Mishra's Workshop",
-                "Mox Emerald", "Mox Jet", "Mox Pearl", "Mox Ruby", "Mox Sapphire", "Necropotence", "Shahrazad", "Skullclamp", "Sol Ring", "Strip Mine", "Survival of the Fittest", "Sword of Body and Mind", "Time Vault", "Time Walk", "Timetwister",
+                "Mox Emerald", "Mox Jet", "Mox Pearl", "Mox Ruby", "Mox Sapphire", "Najeela, the Blade Blossom", "Necropotence", "Shahrazad", "Skullclamp", "Sol Ring", "Strip Mine", "Survival of the Fittest", "Sword of Body and Mind", "Time Vault", "Time Walk", "Timetwister",
                 "Timmerian Fiends", "Tolarian Academy", "Umezawa's Jitte", "Vampiric Tutor", "Wheel of Fortune", "Yawgmoth's Will");
 
         @Override
@@ -324,23 +326,32 @@ public enum DeckFormat {
         }
 
         final int maxCopies = getMaxCardCopies();
-        if (maxCopies < Integer.MAX_VALUE) {
         //Must contain no more than 4 of the same card
         //shared among the main deck and sideboard, except
         //basic lands, Shadowborn Apostle, Relentless Rats and Rat Colony
+        // Seven Dwarves can have 7 in the deck. More than 7 in deck + sb is ok in Limited
 
         final CardPool allCards = deck.getAllCardsInASinglePool(hasCommander());
 
         // should group all cards by name, so that different editions of same card are really counted as the same card
         for (final Entry<String, Integer> cp : Aggregates.groupSumBy(allCards, PaperCard.FN_GET_NAME)) {
             final IPaperCard simpleCard = StaticData.instance().getCommonCards().getCard(cp.getKey());
+            // Might cause issues since it ignores "Special" Cards
             if (simpleCard == null) {
                 return TextUtil.concatWithSpace("contains the nonexisting card", cp.getKey());
             }
 
-                if (!canHaveAnyNumberOf(simpleCard) && cp.getValue() > maxCopies) {
-                    return TextUtil.concatWithSpace("must not contain more than", String.valueOf(maxCopies), "copies of the card", cp.getKey());
+            if (canHaveAnyNumberOf(simpleCard)) {
+                continue;
             }
+
+            Integer cardCopies = canHaveSpecificNumberInDeck(simpleCard);
+            if (cardCopies != null && deck.getMain().countByName(cp.getKey(), true) > cardCopies) {
+                return TextUtil.concatWithSpace("must not contain more than", String.valueOf(cardCopies), "copies of the card", cp.getKey());
+            }
+
+            if (cardCopies == null && cp.getValue() > maxCopies) {
+                return TextUtil.concatWithSpace("must not contain more than", String.valueOf(maxCopies), "copies of the card", cp.getKey());
             }
         }
 
@@ -362,6 +373,16 @@ public enum DeckFormat {
                 "A deck can have any number of cards named CARDNAME.");
     }
 
+    public static Integer canHaveSpecificNumberInDeck(final IPaperCard card) {
+        // Ideally, this would be parsed during card parsing and set this value
+        if (Iterables.contains(card.getRules().getMainPart().getKeywords(),
+                "A deck can have up to seven cards named CARDNAME.")) {
+            return 7;
+        }
+
+        return null;
+    }
+
     public static String getPlaneSectionConformanceProblem(final CardPool planes) {
         //Must contain at least 10 planes/phenomenons, but max 2 phenomenons. Singleton.
         if (planes == null || planes.countAll() < 10) {
@@ -442,6 +463,9 @@ public enum DeckFormat {
         if (this.equals(DeckFormat.Brawl)) {
             return rules.canBeBrawlCommander();
         }
+        if (this.equals(DeckFormat.TinyLeaders)) {
+            return rules.canBeTinyLeadersCommander();
+        }
         return rules.canBeCommander();
     }
 

forge-core/src/main/java/forge/deck/io/DeckSerializer.java

@@ -27,7 +27,7 @@ public class DeckSerializer {
         }
         final List<String> metadata = map.get("metadata");
         if (metadata != null) {
-            return new DeckFileHeader(FileSection.parse(metadata, "="));
+            return new DeckFileHeader(FileSection.parse(metadata, FileSection.EQUALS_KV_SEPARATOR));
         }
         final List<String> general = map.get("general");
         if (general != null) {

forge-core/src/main/java/forge/item/IPaperCard.java

@@ -6,6 +6,7 @@ import forge.card.CardRarity;
 import forge.card.CardRules;
 import forge.card.CardType.CoreType;
 import forge.card.MagicColor;
+import forge.util.PredicateCard;
 import forge.util.PredicateString;
 import org.apache.commons.lang3.StringUtils;
 
@@ -60,6 +61,8 @@ public interface IPaperCard extends InventoryItem {
             return new PredicateNames(what);
         }
 
+        public static PredicateCards cards(final List<PaperCard> what) { return new PredicateCards(what); }
+
         private static final class PredicateColor implements Predicate<PaperCard> {
 
             private final byte operand;
@@ -161,6 +164,25 @@ public interface IPaperCard extends InventoryItem {
             }
         }
 
+        private static final class PredicateCards extends PredicateCard<PaperCard> {
+            private final List<PaperCard> operand;
+
+            @Override
+            public boolean apply(final PaperCard card) {
+                for (final PaperCard element : this.operand) {
+                    if (this.op(card, element)) {
+                        return true;
+                    }
+                }
+                return false;
+            }
+
+            private PredicateCards(final List<PaperCard> operand) {
+                super(StringOp.EQUALS);
+                this.operand = operand;
+            }
+        }
+
         /**
          * Pre-built predicates are stored here to allow their re-usage and
          * easier access from code.

forge-core/src/main/java/forge/item/PreconDeck.java

@@ -108,7 +108,7 @@ public class PreconDeck implements InventoryItemFromSet {
 
         // To be able to read "shops" section in overloads
         protected PreconDeck getPreconDeckFromSections(final Map<String, List<String>> sections) {
-            FileSection kv = FileSection.parse(sections.get("metadata"), "=");
+            FileSection kv = FileSection.parse(sections.get("metadata"), FileSection.EQUALS_KV_SEPARATOR);
             String imageFilename = kv.get("Image");
             String description = kv.get("Description");
             String deckEdition = kv.get("set");

forge-core/src/main/java/forge/item/generation/BoosterGenerator.java

@@ -566,12 +566,8 @@ public class BoosterGenerator {
                 toAdd = IPaperCard.Predicates.printedInSets(sets);
             } else if (operator.startsWith("fromSheet(") && invert) {
                 String sheetName = StringUtils.strip(operator.substring(9), "()\" ");
-                Iterable<PaperCard> src = StaticData.instance().getPrintSheets().get(sheetName).toFlatList();
-                List<String> cardNames = Lists.newArrayList();
-                for (PaperCard card : src) {
-                    cardNames.add(card.getName());
-                }
-                toAdd = IPaperCard.Predicates.names(Lists.newArrayList(cardNames));
+                Iterable<PaperCard> cards = StaticData.instance().getPrintSheets().get(sheetName).toFlatList();
+                toAdd = IPaperCard.Predicates.cards(Lists.newArrayList(cards));
             }
 
             if (toAdd == null) {

forge-core/src/main/java/forge/util/CardTranslation.java

@@ -1,9 +1,6 @@
-package forge.card;
+package forge.util;
 
-import com.esotericsoftware.minlog.Log;
 import com.google.common.base.Charsets;
-import forge.properties.ForgeConstants;
-import forge.util.LineReader;
 
 import java.io.FileInputStream;
 import java.io.IOException;
@@ -15,12 +12,12 @@ public class CardTranslation {
     private static Map <String, String> translatednames;
     private static Map <String, String> translatedtypes;
     private static Map <String, String> translatedoracles;
-    private static String languageSelected;
+    private static String languageSelected = "en-US";
 
-    private static void readTranslationFile(String language) {
+    private static void readTranslationFile(String language, String languagesDirectory) {
         String filename = "cardnames-" + language + ".txt";
 
-        try (LineReader translationFile = new LineReader(new FileInputStream(ForgeConstants.LANG_DIR + filename), Charsets.UTF_8)) {
+        try (LineReader translationFile = new LineReader(new FileInputStream(languagesDirectory + filename), Charsets.UTF_8)) {
             for (String line : translationFile.readLines()) {
                 String[] matches = line.split("\\|");
                 if (matches.length >= 2) {
@@ -34,7 +31,7 @@ public class CardTranslation {
                 }
             }
         } catch (IOException e) {
-            Log.error("Error reading translation file: cardnames-" + language + ".txt");
+            System.err.println("Error reading translation file: cardnames-" + language + ".txt");
         }
     }
 
@@ -66,7 +63,7 @@ public class CardTranslation {
     }
 
     public static HashMap<String, String> getTranslationTexts(String cardname, String altcardname) {
-        HashMap<String, String> translations = new HashMap<String, String>();
+        HashMap<String, String> translations = new HashMap<>();
         translations.put("name", getTranslatedName(cardname));
         translations.put("oracle", getTranslatedOracle(cardname));
         translations.put("altname", getTranslatedName(altcardname));
@@ -78,14 +75,14 @@ public class CardTranslation {
         return !languageSelected.equals("en-US");
     }
 
-    public static void preloadTranslation(String language) {
+    public static void preloadTranslation(String language, String languagesDirectory) {
         languageSelected = language;
         
         if (needsTranslation()) {
             translatednames = new HashMap<>();
             translatedtypes = new HashMap<>();
             translatedoracles = new HashMap<>();
-            readTranslationFile(languageSelected);
+            readTranslationFile(languageSelected, languagesDirectory);
         }
     }
 }

forge-core/src/main/java/forge/util/FileSection.java

@@ -17,9 +17,12 @@
  */
 package forge.util;
 
+import com.google.common.collect.HashBasedTable;
+import com.google.common.collect.Table;
 import java.text.NumberFormat;
 import java.text.ParseException;
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.List;
 import java.util.Locale;
 import java.util.Map;
@@ -57,31 +60,37 @@ public class FileSection {
         lines = lines0;
     }
 
-    /**
-     * Parses the.
-     *
-     * @param line the line
-     * @param kvSeparator the kv separator
-     * @param pairSeparator the pair separator
-     * @return the file section
-     */
-    public static FileSection parse(final String line, final String kvSeparator, final String pairSeparator) {
-        Map<String, String> map = parseToMap(line, kvSeparator, pairSeparator);
-        return new FileSection(map);
+    public static final Pattern DOLLAR_SIGN_KV_SEPARATOR = Pattern.compile(Pattern.quote("$"));
+    public static final Pattern ARROW_KV_SEPARATOR = Pattern.compile(Pattern.quote("->"));
+    public static final Pattern EQUALS_KV_SEPARATOR = Pattern.compile(Pattern.quote("="));
+    public static final Pattern COLON_KV_SEPARATOR = Pattern.compile(Pattern.quote(":"));
+
+    private static final String BAR_PAIR_SPLITTER = Pattern.quote("|");
+
+    private static Table<String, Pattern, Map<String, String>> parseToMapCache = HashBasedTable.create();
+
+    public static Map<String, String> parseToMap(final String line, final Pattern kvSeparator) {
+        Map<String, String> result = parseToMapCache.get(line, kvSeparator);
+        if (result != null) {
+            return result;
+        }
+        result = parseToMapImpl(line, kvSeparator);
+        parseToMapCache.put(line, kvSeparator, result);
+        return result;
     }
 
-    public static Map<String, String> parseToMap(final String line, final String kvSeparator, final String pairSeparator) {
-        Map<String, String> result = new TreeMap<>(String.CASE_INSENSITIVE_ORDER);
-        if (!StringUtils.isEmpty(line)) {
-            final String[] pairs = line.split(Pattern.quote(pairSeparator));
-            final Pattern splitter = Pattern.compile(Pattern.quote(kvSeparator));
+    private static Map<String, String> parseToMapImpl(final String line, final Pattern kvSeparator) {
+        if (StringUtils.isEmpty(line)) {
+            return Collections.emptyMap();
+        }
 
+        final Map<String, String> result = new TreeMap<>(String.CASE_INSENSITIVE_ORDER);
+        final String[] pairs = line.split(BAR_PAIR_SPLITTER);
         for (final String dd : pairs) {
-                final String[] v = splitter.split(dd, 2);
+            final String[] v = kvSeparator.split(dd, 2);
             result.put(v[0].trim(), v.length > 1 ? v[1].trim() : "");
         }
-        }
-        return result;
+        return Collections.unmodifiableMap(result);
     }
 
     /**
@@ -91,11 +100,10 @@ public class FileSection {
      * @param kvSeparator the kv separator
      * @return the file section
      */
-    public static FileSection parse(final Iterable<String> lines, final String kvSeparator) {
+    public static FileSection parse(final Iterable<String> lines, final Pattern kvSeparator) {
         final FileSection result = new FileSection();
-        final Pattern splitter = Pattern.compile(Pattern.quote(kvSeparator));
         for (final String dd : lines) {
-            final String[] v = splitter.split(dd, 2);
+            final String[] v = kvSeparator.split(dd, 2);
             result.lines.put(v[0].trim(), v.length > 1 ? v[1].trim() : "");
         }