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

Simple fix for EditionTracking with new format style

See merge request core-developers/forge!449

forge-ai/.classpath

@@ -2,8 +2,9 @@
 <classpath>
 	<classpathentry kind="src" output="target/classes" path="src/main/java"/>
 	<classpathentry kind="src" output="target/test-classes" path="src/test/java"/>
-	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.7"/>
 	<classpathentry kind="con" path="org.eclipse.m2e.MAVEN2_CLASSPATH_CONTAINER"/>
 	<classpathentry kind="con" path="org.testng.TESTNG_CONTAINER"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
+	<classpathentry combineaccessrules="false" kind="src" path="/forge-core"/>
 	<classpathentry kind="output" path="target/classes"/>
 </classpath>

forge-ai/.settings/org.eclipse.core.resources.prefs

@@ -1,4 +1,3 @@
 eclipse.preferences.version=1
 encoding//src/main/java=ISO-8859-1
-encoding//src/test/java=ISO-8859-1
 encoding/<project>=UTF-8

forge-ai/pom.xml

@@ -6,7 +6,7 @@
     <parent>
         <artifactId>forge</artifactId>
         <groupId>forge</groupId>
-        <version>1.6.2</version>
+        <version>1.6.9</version>
     </parent>
 
     <artifactId>forge-ai</artifactId>

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

@@ -17,14 +17,9 @@
  */
 package forge.ai;
 
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Random;
-
 import com.google.common.base.Predicate;
 import com.google.common.base.Predicates;
 import com.google.common.collect.Lists;
-
 import forge.ai.ability.AnimateAi;
 import forge.card.CardTypeView;
 import forge.game.GameEntity;
@@ -35,14 +30,20 @@ import forge.game.card.*;
 import forge.game.combat.Combat;
 import forge.game.combat.CombatUtil;
 import forge.game.combat.GlobalAttackRestrictions;
+import forge.game.keyword.KeywordInterface;
 import forge.game.player.Player;
 import forge.game.spellability.SpellAbility;
 import forge.game.trigger.Trigger;
 import forge.game.trigger.TriggerType;
 import forge.game.zone.ZoneType;
+import forge.util.Expressions;
 import forge.util.MyRandom;
 import forge.util.collect.FCollectionView;
 
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+
 
 //doesHumanAttackAndWin() uses the global variable AllZone.getComputerPlayer()
 /**
@@ -243,6 +244,19 @@ public class AiAttackController {
         return false;
     }
 
+    public final static Card getCardCanBlockAnAttacker(final Card c, final List<Card> attackers, final boolean nextTurn) {
+        final List<Card> attackerList = new ArrayList<Card>(attackers);
+        if (!c.isCreature()) {
+            return null;
+        }
+        for (final Card attacker : attackerList) {
+            if (CombatUtil.canBlock(attacker, c, nextTurn)) {
+                return attacker;
+            }
+        }
+        return null;
+    }
+
     // this checks to make sure that the computer player doesn't lose when the human player attacks
     // this method is used by getAttackers()
     public final List<Card> notNeededAsBlockers(final Player ai, final List<Card> attackers) {
@@ -362,8 +376,12 @@ public class AiAttackController {
                 blockersLeft--;
                 continue;
             }
-            totalAttack += ComputerUtilCombat.damageIfUnblocked(attacker, ai, null, false);
-            totalPoison += ComputerUtilCombat.poisonIfUnblocked(attacker, ai);
+
+            // Test for some special triggers that can change the creature in combat
+            Card effectiveAttacker = ComputerUtilCombat.applyPotentialAttackCloneTriggers(attacker);
+
+            totalAttack += ComputerUtilCombat.damageIfUnblocked(effectiveAttacker, ai, null, false);
+            totalPoison += ComputerUtilCombat.poisonIfUnblocked(effectiveAttacker, ai);
         }
 
         if (totalAttack > 0 && ai.getLife() <= totalAttack && !ai.cantLoseForZeroOrLessLife()) {
@@ -402,7 +420,7 @@ public class AiAttackController {
             CardCollectionView oppBattlefield = c.getController().getCardsIn(ZoneType.Battlefield);
 
             if (c.getName().equals("Heart of Kiran")) {
-                if (!CardLists.filter(oppBattlefield, CardPredicates.Presets.PLANEWALKERS).isEmpty()) {
+                if (!CardLists.filter(oppBattlefield, CardPredicates.Presets.PLANESWALKERS).isEmpty()) {
                     // can be activated by removing a loyalty counter instead of tapping a creature
                     continue;
                 }
@@ -424,16 +442,45 @@ public class AiAttackController {
 
         final Player opp = this.defendingOpponent;
 
-        for (Card attacker : attackers) {
-            if (!CombatUtil.canBeBlocked(attacker, this.blockers, null)
-                    || attacker.hasKeyword("You may have CARDNAME assign its combat damage as though it weren't blocked.")) {
-                unblockedAttackers.add(attacker);
+        // if true, the AI will attempt to identify which blockers will already be taken,
+        // thus attempting to predict how many creatures with evasion can actively block
+        boolean predictEvasion = false;
+        if (ai.getController().isAI()) {
+            AiController aic = ((PlayerControllerAi) ai.getController()).getAi();
+            if (aic.getBooleanProperty(AiProps.COMBAT_ASSAULT_ATTACK_EVASION_PREDICTION)) {
+                predictEvasion = true;
             }
         }
 
+        CardCollection accountedBlockers = new CardCollection(this.blockers);
+        CardCollection categorizedAttackers = new CardCollection();
+
+        if (predictEvasion) {
+            // split categorizedAttackers such that the ones with evasion come first and
+            // can be properly accounted for. Note that at this point the attackers need
+            // to be sorted by power already (see the Collections.sort call above).
+            categorizedAttackers.addAll(ComputerUtilCombat.categorizeAttackersByEvasion(this.attackers));
+        } else {
+            categorizedAttackers.addAll(this.attackers);
+        }
+
+        for (Card attacker : categorizedAttackers) {
+            if (!CombatUtil.canBeBlocked(attacker, accountedBlockers, null)
+                    || attacker.hasKeyword("You may have CARDNAME assign its combat damage as though it weren't blocked.")) {
+                unblockedAttackers.add(attacker);
+            } else {
+                if (predictEvasion) {
+                    List<Card> potentialBestBlockers = CombatUtil.getPotentialBestBlockers(attacker, accountedBlockers, null);
+                    accountedBlockers.removeAll(potentialBestBlockers);
+                }
+            }
+        }
+
+        remainingAttackers.removeAll(unblockedAttackers);
+
         for (Card blocker : this.blockers) {
             if (blocker.hasKeyword("CARDNAME can block any number of creatures.")
-                    || blocker.hasKeyword("CARDNAME can block an additional ninety-nine creatures.")) {
+                    || blocker.hasKeyword("CARDNAME can block an additional ninety-nine creatures each combat.")) {
                 for (Card attacker : this.attackers) {
                     if (CombatUtil.canBlock(attacker, blocker)) {
                         remainingAttackers.remove(attacker);
@@ -449,7 +496,7 @@ public class AiAttackController {
             if (remainingAttackers.isEmpty() || maxBlockersAfterCrew == 0) {
                 break;
             }
-            if (blocker.hasKeyword("CARDNAME can block an additional creature.")) {
+            if (blocker.hasKeyword("CARDNAME can block an additional creature each combat.")) {
                 blockedAttackers.add(remainingAttackers.get(0));
                 remainingAttackers.remove(0);
                 maxBlockersAfterCrew--;
@@ -498,11 +545,16 @@ public class AiAttackController {
         }
         Player prefDefender = (Player) (defs.contains(this.defendingOpponent) ? this.defendingOpponent : defs.get(0));
 
-        final GameEntity entity = ai.getMustAttackEntity();
+        // Attempt to see if there's a defined entity that must be attacked strictly this turn...
+        GameEntity entity = ai.getMustAttackEntityThisTurn();
+        if (entity == null) {
+            // ...or during the attacking creature controller's turn
+            entity = ai.getMustAttackEntity();
+        }
         if (null != entity) {
             int n = defs.indexOf(entity);
             if (-1 == n) {
-                System.out.println("getMustAttackEntity() returned something not in defenders.");
+                System.out.println("getMustAttackEntity() or getMustAttackEntityThisTurn() returned something not in defenders.");
                 return prefDefender;
             } else {
                 return entity;
@@ -544,10 +596,21 @@ public class AiAttackController {
             return;
         }
 
+        // Aggro options
         boolean playAggro = false;
+        int chanceToAttackToTrade = 0;
+        boolean tradeIfTappedOut = false;
+        int extraChanceIfOppHasMana = 0;
+        boolean tradeIfLowerLifePressure = false;
         if (ai.getController().isAI()) {
-            playAggro = ((PlayerControllerAi) ai.getController()).getAi().getProperty(AiProps.PLAY_AGGRO).equals("true");
+            AiController aic = ((PlayerControllerAi) ai.getController()).getAi();
+            playAggro = aic.getBooleanProperty(AiProps.PLAY_AGGRO);
+            chanceToAttackToTrade = aic.getIntProperty(AiProps.CHANCE_TO_ATTACK_INTO_TRADE);
+            tradeIfTappedOut = aic.getBooleanProperty(AiProps.ATTACK_INTO_TRADE_WHEN_TAPPED_OUT);
+            extraChanceIfOppHasMana = aic.getIntProperty(AiProps.CHANCE_TO_ATKTRADE_WHEN_OPP_HAS_MANA);
+            tradeIfLowerLifePressure = aic.getBooleanProperty(AiProps.RANDOMLY_ATKTRADE_ONLY_ON_LOWER_LIFE_PRESSURE);
         }
+
         final boolean bAssault = this.doAssault(ai);
         // TODO: detect Lightmine Field by presence of a card with a specific trigger
         final boolean lightmineField = ComputerUtilCard.isPresentOnBattlefield(ai.getGame(), "Lightmine Field");
@@ -585,7 +648,8 @@ public class AiAttackController {
                     && isEffectiveAttacker(ai, attacker, combat)) {
                 mustAttack = true;
             } else {
-                for (String s : attacker.getKeywords()) {
+                for (KeywordInterface inst : attacker.getKeywords()) {
+                    String s = inst.getOriginal();
                     if (s.equals("CARDNAME attacks each turn if able.")
                             || s.startsWith("CARDNAME attacks specific player each combat if able")
                             || s.equals("CARDNAME attacks each combat if able.")) {
@@ -594,7 +658,7 @@ public class AiAttackController {
                     }
                 }
             }
-            if (mustAttack || attacker.getController().getMustAttackEntity() != null) {
+            if (mustAttack || attacker.getController().getMustAttackEntity() != null || attacker.getController().getMustAttackEntityThisTurn() != null) {
                 combat.addAttacker(attacker, defender);
                 attackersLeft.remove(attacker);
                 numForcedAttackers++;
@@ -715,7 +779,20 @@ public class AiAttackController {
             }
         }
 
-        for (final Card pCard : this.oppList) {
+        boolean predictEvasion = (ai.getController().isAI()
+                && ((PlayerControllerAi)ai.getController()).getAi().getBooleanProperty(AiProps.COMBAT_ATTRITION_ATTACK_EVASION_PREDICTION));
+
+        CardCollection categorizedOppList = new CardCollection();
+        if (predictEvasion) {
+            // If predicting evasion, make sure that attackers with evasion are considered first
+            // (to avoid situations where the AI would predict his non-flyers to be blocked with
+            // flying creatures and then believe that flyers will necessarily be left unblocked)
+            categorizedOppList.addAll(ComputerUtilCombat.categorizeAttackersByEvasion(this.oppList));
+        } else {
+            categorizedOppList.addAll(this.oppList);
+        }
+
+        for (final Card pCard : categorizedOppList) {
             // if the creature can attack next turn add it to counter attackers list
             if (ComputerUtilCombat.canAttackNextTurn(pCard) && pCard.getNetCombatDamage() > 0) {
                 nextTurnAttackers.add(pCard);
@@ -723,8 +800,13 @@ public class AiAttackController {
                 humanForces += 1; // player forces they might use to attack
             }
             // increment player forces that are relevant to an attritional attack - includes walls
-            if (canBlockAnAttacker(pCard, candidateAttackers, true)) {
+
+            Card potentialOppBlocker = getCardCanBlockAnAttacker(pCard, candidateAttackers, true);
+            if (potentialOppBlocker != null) {
                 humanForcesForAttritionalAttack += 1;
+                if (predictEvasion) {
+                    candidateAttackers.remove(potentialOppBlocker);
+                }
             }
         }
 
@@ -851,8 +933,18 @@ public class AiAttackController {
         if (ratioDiff > 0 && doAttritionalAttack) {
             this.aiAggression = 5; // attack at all costs
         } else if ((ratioDiff >= 1 && this.attackers.size() > 1 && (humanLifeToDamageRatio < 2 || outNumber > 0))
-        		|| (playAggro && humanLifeToDamageRatio > 1)) {
+        		|| (playAggro && MyRandom.percentTrue(chanceToAttackToTrade) && humanLifeToDamageRatio > 1)) {
             this.aiAggression = 4; // attack expecting to trade or damage player.
+        } else if (MyRandom.percentTrue(chanceToAttackToTrade) && humanLifeToDamageRatio > 1
+                && defendingOpponent != null
+                && ComputerUtil.countUsefulCreatures(ai) > ComputerUtil.countUsefulCreatures(defendingOpponent)
+                && ai.getLife() > defendingOpponent.getLife()
+                && !ComputerUtilCombat.lifeInDanger(ai, combat)
+                && (ComputerUtilMana.getAvailableManaEstimate(ai) > 0) || tradeIfTappedOut
+                && (ComputerUtilMana.getAvailableManaEstimate(defendingOpponent) == 0) || MyRandom.percentTrue(extraChanceIfOppHasMana)
+                && (!tradeIfLowerLifePressure || (ai.getLifeLostLastTurn() + ai.getLifeLostThisTurn() <
+                        defendingOpponent.getLifeLostThisTurn() + defendingOpponent.getLifeLostThisTurn()))) {
+            this.aiAggression = 4; // random (chance-based) attack expecting to trade or damage player.
         } else if (ratioDiff >= 0 && this.attackers.size() > 1) {
             this.aiAggression = 3; // attack expecting to make good trades or damage player.
         } else if (ratioDiff + outNumber >= -1 || aiLifeToPlayerDamageRatio > 1
@@ -990,6 +1082,28 @@ public class AiAttackController {
         boolean canBeBlocked = false;
         int numberOfPossibleBlockers = 0;
 
+        // Is it a creature that has a more valuable ability with a tap cost than what it can do by attacking?
+        if ((attacker.hasSVar("NonCombatPriority"))
+                && (!attacker.hasKeyword("Vigilance"))) {
+            // For each level of priority, enemy has to have life as much as the creature's power
+            // so a priority of 4 means the creature will not attack unless it can defeat that player in 4 successful attacks.
+            // the lower the priroity, the less willing the AI is to use the creature for attacking.
+            // 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()) {
+                        if (ComputerUtilCost.canPayCost(sa, ai)) {
+                            return false;
+                        }
+                        // TODO Eventually The Ai will need to learn to predict if they have any use for the ability before next untap or not.
+                        // TODO abilities that tap enemy creatures should probably only be saved if the enemy has nonzero creatures? Haste can be a threat though...
+                    }
+                }
+            }
+        }
 
         if (!this.isEffectiveAttacker(ai, attacker, combat)) {
             return false;
@@ -998,9 +1112,14 @@ public class AiAttackController {
         // is there a gain in attacking even when the blocker is not killed (Lifelink, Wither,...)
         boolean hasCombatEffect = attacker.getSVar("HasCombatEffect").equals("TRUE") 
         		|| "Blocked".equals(attacker.getSVar("HasAttackEffect"));
+        // total power of the defending creatures, used in predicting whether a gang block can kill the attacker
+        int defPower = CardLists.getTotalPower(defenders, true);
+
         if (!hasCombatEffect) {
-            for (String keyword : attacker.getKeywords()) {
-                if (keyword.equals("Wither") || keyword.equals("Infect") || keyword.equals("Lifelink")) {
+            for (KeywordInterface inst : attacker.getKeywords()) {
+                String keyword = inst.getOriginal();
+                if (keyword.equals("Wither") || keyword.equals("Infect")
+                        || keyword.equals("Lifelink") || keyword.startsWith("Afflict")) {
                     hasCombatEffect = true;
                     break;
                 }
@@ -1033,7 +1152,8 @@ public class AiAttackController {
                     if (defender.getSVar("HasCombatEffect").equals("TRUE") || defender.getSVar("HasBlockEffect").equals("TRUE")) {
                         canKillAllDangerous = false;
                     } else {
-                        for (String keyword : defender.getKeywords()) {
+                        for (KeywordInterface inst : defender.getKeywords()) {
+                            String keyword = inst.getOriginal();
                             if (keyword.equals("Wither") || keyword.equals("Infect") || keyword.equals("Lifelink")) {
                                 canKillAllDangerous = false;
                                 break;
@@ -1041,12 +1161,29 @@ public class AiAttackController {
                                 // and combat will have negative effects
                             }
                         }
+
+                        // Check if maybe we are too reckless in adding this attacker
+                        if (canKillAllDangerous) {
+                            boolean avoidAttackingIntoBlock = ai.getController().isAI()
+                                    && ((PlayerControllerAi) ai.getController()).getAi().getBooleanProperty(AiProps.TRY_TO_AVOID_ATTACKING_INTO_CERTAIN_BLOCK);
+                            boolean attackerWillDie = defPower >= attacker.getNetToughness();
+                            boolean uselessAttack = !hasCombatEffect && !hasAttackEffect;
+                            boolean noContributionToAttack = this.attackers.size() <= defenders.size() || attacker.getNetPower() <= 0;
+
+                            // We are attacking too recklessly if we can't kill a single blocker and:
+                            // - our creature will die for sure (chump attack)
+                            // - our attack will not do anything special (no attack/combat effect to proc)
+                            // - we can't deal damage to our opponent with sheer number of attackers and/or our attacker's power is 0 or less
+                            if (attackerWillDie || (avoidAttackingIntoBlock && (uselessAttack || noContributionToAttack))) {
+                                canKillAllDangerous = false;
+                            }
+                        }
                     }
                 }
             }
         }
         
-        if (!attacker.hasKeyword("vigilance") && ComputerUtilCard.canBeKilledByRoyalAssassin(ai, attacker)) {
+        if (!attacker.hasKeyword("Vigilance") && ComputerUtilCard.canBeKilledByRoyalAssassin(ai, attacker)) {
             canKillAllDangerous = false;
             canBeKilled = true;
             canBeKilledByOne = true;
@@ -1151,18 +1288,51 @@ public class AiAttackController {
                 }
                 if (sa.usesTargeting()) {
                     sa.setActivatingPlayer(c.getController());
-                    if (CardUtil.getValidCardsToTarget(sa.getTargetRestrictions(), sa).isEmpty()) {
+                    List<Card> validTargets = CardUtil.getValidCardsToTarget(sa.getTargetRestrictions(), sa);
+                    if (validTargets.isEmpty()) {
+                        missTarget = true;
+                        break;
+                    } else if (sa.isCurse() && CardLists.filter(validTargets,
+                            CardPredicates.isControlledByAnyOf(c.getController().getOpponents())).isEmpty()) {
+                        // e.g. Ahn-Crop Crasher - the effect is only good when aimed at opponent's creatures
                         missTarget = true;
                         break;
                     }
                 }
+
             }
 
             if (missTarget) {
                 continue;
             }
 
-            if (random.nextBoolean()) {
+            // A specific AI condition for Exert: if specified on the card, the AI will always
+            // exert creatures that meet this condition
+            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));
+                    }
+                    if (Expressions.compare(x, comparator, y)) {
+                        shouldExert = true;
+                    }
+                }
+            }
+
+            if (!shouldExert && random.nextBoolean()) {
                 // TODO Improve when the AI wants to use Exert powers
                 shouldExert = true;
             }

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

@@ -19,26 +19,20 @@ package forge.ai;
 
 import com.google.common.base.Predicate;
 import com.google.common.base.Predicates;
+import forge.card.CardStateName;
 import forge.game.CardTraitBase;
 import forge.game.GameEntity;
-import forge.game.card.Card;
-import forge.game.card.CardCollection;
-import forge.game.card.CardCollectionView;
-import forge.game.card.CardLists;
-import forge.game.card.CardPredicates;
-import forge.game.card.CounterType;
+import forge.game.card.*;
 import forge.game.combat.Combat;
 import forge.game.combat.CombatUtil;
 import forge.game.player.Player;
 import forge.game.trigger.Trigger;
 import forge.game.trigger.TriggerType;
+import forge.game.zone.ZoneType;
+import forge.util.MyRandom;
 import forge.util.collect.FCollectionView;
 
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.Comparator;
-import java.util.List;
-import java.util.Map;
+import java.util.*;
 
 
 /**
@@ -89,8 +83,10 @@ public class AiBlockController {
     private List<Card> getSafeBlockers(final Combat combat, final Card attacker, final List<Card> blockersLeft) {
         final List<Card> blockers = new ArrayList<>();
 
+        // We don't check attacker static abilities at this point since the attackers have already attacked and, thus,
+        // their P/T modifiers are active and are counted as a part of getNetPower/getNetToughness
         for (final Card b : blockersLeft) {
-            if (!ComputerUtilCombat.canDestroyBlocker(ai, b, attacker, combat, false)) {
+            if (!ComputerUtilCombat.canDestroyBlocker(ai, b, attacker, combat, false, true)) {
                 blockers.add(b);
             }
         }
@@ -102,8 +98,10 @@ public class AiBlockController {
     private List<Card> getKillingBlockers(final Combat combat, final Card attacker, final List<Card> blockersLeft) {
         final List<Card> blockers = new ArrayList<>();
 
+        // We don't check attacker static abilities at this point since the attackers have already attacked and, thus,
+        // their P/T modifiers are active and are counted as a part of getNetPower/getNetToughness
         for (final Card b : blockersLeft) {
-            if (ComputerUtilCombat.canDestroyAttacker(ai, attacker, b, combat, false)) {
+            if (ComputerUtilCombat.canDestroyAttacker(ai, attacker, b, combat, false, true)) {
                 blockers.add(b);
             }
         }
@@ -349,9 +347,9 @@ public class AiBlockController {
                 final List<Card> firstStrikeBlockers = new ArrayList<>();
                 final List<Card> blockGang = new ArrayList<>();
                 for (Card blocker : blockers) {
-                	if (ComputerUtilCombat.canDestroyBlockerBeforeFirstStrike(blocker, attacker, false)) {
-                		continue;
-                	}
+                    if (ComputerUtilCombat.canDestroyBlockerBeforeFirstStrike(blocker, attacker, false)) {
+                        continue;
+                    }
                     if (blocker.hasFirstStrike() || blocker.hasDoubleStrike()) {
                         firstStrikeBlockers.add(blocker);
                     }
@@ -417,7 +415,8 @@ public class AiBlockController {
                             && !ComputerUtilCombat.dealsFirstStrikeDamage(c, false, combat)) {
                         return false;
                     }
-                    return lifeInDanger || ComputerUtilCard.evaluateCreature(c) + diff < ComputerUtilCard.evaluateCreature(attacker);
+                    final boolean randomTrade = wouldLikeToRandomlyTrade(attacker, c, combat);
+                    return lifeInDanger || ComputerUtilCard.evaluateCreature(c) + diff < ComputerUtilCard.evaluateCreature(attacker) || randomTrade;
                 }
             });
             if (usableBlockers.size() < 2) {
@@ -445,9 +444,9 @@ public class AiBlockController {
                         // The attacker will be killed
                         && (absorbedDamage2 + absorbedDamage > attacker.getNetCombatDamage()
                         // only one blocker can be killed
-                        	|| currentValue + addedValue - 50 <= evalAttackerValue
+                        || currentValue + addedValue - 50 <= evalAttackerValue
                         // or attacker is worth more
-                        	|| (lifeInDanger && ComputerUtilCombat.lifeInDanger(ai, combat)))
+                        || (lifeInDanger && ComputerUtilCombat.lifeInDanger(ai, combat)))
                         // or life is in danger
                         && CombatUtil.canBlock(attacker, blocker, combat)) {
                     // this is needed for attackers that can't be blocked by
@@ -497,7 +496,7 @@ public class AiBlockController {
                             && !(damageNeeded > currentDamage + additionalDamage2 + additionalDamage3)
                             // The attacker will be killed
                             && ((absorbedDamage2 + absorbedDamage > netCombatDamage && absorbedDamage3 + absorbedDamage > netCombatDamage
-                               && absorbedDamage3 + absorbedDamage2 > netCombatDamage)
+                            && absorbedDamage3 + absorbedDamage2 > netCombatDamage)
                             // only one blocker can be killed
                             || currentValue + addedValue2 + addedValue3 - 50 <= evalAttackerValue
                             // or attacker is worth more
@@ -526,7 +525,56 @@ public class AiBlockController {
         attackersLeft = (new ArrayList<>(currentAttackers));
     }
 
+    private void makeGangNonLethalBlocks(final Combat combat) {
+        List<Card> currentAttackers = new ArrayList<>(attackersLeft);
+        List<Card> blockers;
+
+        // Try to block a Menace attacker with two blockers, neither of which will die
+        for (final Card attacker : attackersLeft) {
+            if (!attacker.hasKeyword("Menace") && !attacker.hasStartOfKeyword("CantBeBlockedByAmount LT2")) {
+                continue;
+            }
+
+            blockers = getPossibleBlockers(combat, attacker, blockersLeft, false);
+            List<Card> usableBlockers;
+            final List<Card> blockGang = new ArrayList<>();
+            int absorbedDamage; // The amount of damage needed to kill the first blocker
+
+            usableBlockers = CardLists.filter(blockers, new Predicate<Card>() {
+                @Override
+                public boolean apply(final Card c) {
+                    return c.getNetToughness() > attacker.getNetCombatDamage();
+                }
+            });
+            if (usableBlockers.size() < 2) {
+                return;
+            }
+
+            final Card leader = ComputerUtilCard.getWorstCreatureAI(usableBlockers);
+            blockGang.add(leader);
+            usableBlockers.remove(leader);
+            absorbedDamage = ComputerUtilCombat.getEnoughDamageToKill(leader, attacker.getNetCombatDamage(), attacker, true);
+
+            // consider a double block
+            for (final Card blocker : usableBlockers) {
+                final int absorbedDamage2 = ComputerUtilCombat.getEnoughDamageToKill(blocker, attacker.getNetCombatDamage(), attacker, true);
+                // only do it if neither blocking creature will die
+                if (absorbedDamage > attacker.getNetCombatDamage() && absorbedDamage2 > attacker.getNetCombatDamage()) {
+                    currentAttackers.remove(attacker);
+                    combat.addBlocker(attacker, blocker);
+                    if (CombatUtil.canBlock(attacker, leader, combat)) {
+                        combat.addBlocker(attacker, leader);
+                    }
+                    break;
+                }
+            }
+        }
+
+        attackersLeft = (new ArrayList<>(currentAttackers));
+    }
+
     // Bad Trade Blocks (should only be made if life is in danger)
+    // Random Trade Blocks (performed randomly if enabled in profile and only when in favorable conditions)
     /**
      * <p>
      * makeTradeBlocks.
@@ -546,16 +594,29 @@ public class AiBlockController {
                     || attacker.hasKeyword("CARDNAME can't be blocked unless all creatures defending player controls block it.")) {
                 continue;
             }
+            if (ComputerUtilCombat.attackerHasThreateningAfflict(attacker, ai)) {
+                continue;
+            }
 
             List<Card> possibleBlockers = getPossibleBlockers(combat, attacker, blockersLeft, true);
             killingBlockers = getKillingBlockers(combat, attacker, possibleBlockers);
-            if (!killingBlockers.isEmpty() && ComputerUtilCombat.lifeInDanger(ai, combat)) {
-                if (ComputerUtilCombat.attackerHasThreateningAfflict(attacker, ai)) {
-                    continue;
-                }
+
+            if (!killingBlockers.isEmpty()) {
                 final Card blocker = ComputerUtilCard.getWorstCreatureAI(killingBlockers);
-                combat.addBlocker(attacker, blocker);
-                currentAttackers.remove(attacker);
+                boolean doTrade = false;
+
+                if (ComputerUtilCombat.lifeInDanger(ai, combat)) {
+                    // Always trade when life in danger
+                    doTrade = true;
+                } else {
+                    // Randomly trade creatures with lower power and [hopefully] worse abilities, if enabled in profile
+                    doTrade = wouldLikeToRandomlyTrade(attacker, blocker, combat);
+                }
+
+                if (doTrade) {
+                    combat.addBlocker(attacker, blocker);
+                    currentAttackers.remove(attacker);
+                }
             }
         }
         attackersLeft = (new ArrayList<>(currentAttackers));
@@ -760,6 +821,105 @@ public class AiBlockController {
         }
     }
 
+    private void makeChumpBlocksToSavePW(Combat combat) {
+        if (ComputerUtilCombat.lifeInDanger(ai, combat) || ai.getLife() <= ai.getStartingLife() / 5) {
+            // most likely not worth trying to protect planeswalkers when at threateningly low life or in
+            // dangerous combat which threatens lethal or severe damage to face
+            return;
+        }
+
+        AiController aic = ((PlayerControllerAi) ai.getController()).getAi();
+        final int evalThresholdToken = aic.getIntProperty(AiProps.THRESHOLD_TOKEN_CHUMP_TO_SAVE_PLANESWALKER);
+        final int evalThresholdNonToken = aic.getIntProperty(AiProps.THRESHOLD_TOKEN_CHUMP_TO_SAVE_PLANESWALKER);
+        final boolean onlyIfLethal = aic.getBooleanProperty(AiProps.CHUMP_TO_SAVE_PLANESWALKER_ONLY_ON_LETHAL);
+
+        if (evalThresholdToken > 0 || evalThresholdNonToken > 0) {
+            // detect how much damage is threatened to each of the planeswalkers, see which ones would be
+            // worth protecting according to the AI profile properties
+            CardCollection threatenedPWs = new CardCollection();
+            for (final Card attacker : attackers) {
+                GameEntity def = combat.getDefenderByAttacker(attacker);
+                if (def instanceof Card) {
+                    if (!onlyIfLethal) {
+                        threatenedPWs.add((Card) def);
+                    } else {
+                        int damageToPW = 0;
+                        for (final Card pwatkr : combat.getAttackersOf(def)) {
+                            if (!combat.isBlocked(pwatkr)) {
+                                damageToPW += ComputerUtilCombat.predictDamageTo((Card) def, pwatkr.getNetCombatDamage(), pwatkr, true);
+                            }
+                        }
+                        if ((!onlyIfLethal && damageToPW > 0) || damageToPW >= ((Card) def).getCounters(CounterType.LOYALTY)) {
+                            threatenedPWs.add((Card) def);
+                        }
+                    }
+                }
+            }
+
+            CardCollection pwsWithChumpBlocks = new CardCollection();
+            CardCollection chosenChumpBlockers = new CardCollection();
+            CardCollection chumpPWDefenders = CardLists.filter(new CardCollection(this.blockersLeft), new Predicate<Card>() {
+                @Override
+                public boolean apply(Card card) {
+                    return ComputerUtilCard.evaluateCreature(card) <= (card.isToken() ? evalThresholdToken
+                            : evalThresholdNonToken);
+                }
+            });
+            CardLists.sortByPowerAsc(chumpPWDefenders);
+            if (!chumpPWDefenders.isEmpty()) {
+                for (final Card attacker : attackers) {
+                    GameEntity def = combat.getDefenderByAttacker(attacker);
+                    if (def instanceof Card && threatenedPWs.contains((Card) def)) {
+                        if (attacker.hasKeyword("Trample")) {
+                            // don't bother trying to chump a trampling creature
+                            continue;
+                        }
+                        if (!combat.getBlockers(attacker).isEmpty()) {
+                            // already blocked by something, no need to chump
+                            continue;
+                        }
+                        Card blockerDecided = null;
+                        for (final Card blocker : chumpPWDefenders) {
+                            if (CombatUtil.canBlock(attacker, blocker, combat)) {
+                                combat.addBlocker(attacker, blocker);
+                                pwsWithChumpBlocks.add((Card) combat.getDefenderByAttacker(attacker));
+                                chosenChumpBlockers.add(blocker);
+                                blockerDecided = blocker;
+                                blockersLeft.remove(blocker);
+                                break;
+                            }
+                        }
+                        chumpPWDefenders.remove(blockerDecided);
+                    }
+                }
+                // check to see if we managed to cover all the blockers of the planeswalker; if not, bail
+                for (final Card pw : pwsWithChumpBlocks) {
+                    CardCollection pwAttackers = combat.getAttackersOf(pw);
+                    CardCollection pwDefenders = new CardCollection();
+                    boolean isFullyBlocked = true;
+                    if (!pwAttackers.isEmpty()) {
+                        int damageToPW = 0;
+                        for (Card pwAtk : pwAttackers) {
+                            if (!combat.getBlockers(pwAtk).isEmpty()) {
+                                pwDefenders.addAll(combat.getBlockers(pwAtk));
+                            } else {
+                                isFullyBlocked = false;
+                                damageToPW += ComputerUtilCombat.predictDamageTo((Card) pw, pwAtk.getNetCombatDamage(), pwAtk, true);
+                            }
+                        }
+                        if (!isFullyBlocked && damageToPW >= pw.getCounters(CounterType.LOYALTY)) {
+                            for (Card chump : pwDefenders) {
+                                if (chosenChumpBlockers.contains(chump)) {
+                                    combat.removeFromCombat(chump);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
     private void clearBlockers(final Combat combat, final List<Card> possibleBlockers) {
 
         final List<Card> oldBlockers = combat.getAllBlockers();
@@ -824,7 +984,7 @@ public class AiBlockController {
         List<Card> chumpBlockers;
 
         diff = (ai.getLife() * 2) - 5; // This is the minimal gain for an unnecessary trade
-        if (ai.getController().isAI() && diff > 0 && ((PlayerControllerAi) ai.getController()).getAi().getProperty(AiProps.PLAY_AGGRO).equals("true")) {
+        if (ai.getController().isAI() && diff > 0 && ((PlayerControllerAi) ai.getController()).getAi().getBooleanProperty(AiProps.PLAY_AGGRO)) {
         	diff = 0;
         }
 
@@ -856,9 +1016,8 @@ public class AiBlockController {
         // When the AI holds some Fog effect, don't bother about lifeInDanger
         if (!ComputerUtil.hasAFogEffect(ai)) {
         	lifeInDanger = ComputerUtilCombat.lifeInDanger(ai, combat);
-	        if (lifeInDanger) {
-	            makeTradeBlocks(combat); // choose necessary trade blocks
-	        }
+            makeTradeBlocks(combat); // choose necessary trade blocks
+
 	        // if life is still in danger
 	        if (lifeInDanger && ComputerUtilCombat.lifeInDanger(ai, combat)) {
 	            makeChumpBlocks(combat); // choose necessary chump blocks
@@ -927,6 +1086,7 @@ public class AiBlockController {
 
         // assign blockers that have to block
         chumpBlockers = CardLists.getKeyword(blockersLeft, "CARDNAME blocks each turn if able.");
+        chumpBlockers.addAll(CardLists.getKeyword(blockersLeft, "CARDNAME blocks each combat if able."));
         // if an attacker with lure attacks - all that can block
         for (final Card blocker : blockersLeft) {
             if (CombatUtil.mustBlockAnAttacker(blocker, combat)) {
@@ -940,7 +1100,8 @@ public class AiBlockController {
                 for (final Card blocker : blockers) {
                     if (CombatUtil.canBlock(attacker, blocker, combat) && blockersLeft.contains(blocker)
                             && (CombatUtil.mustBlockAnAttacker(blocker, combat)
-                                    || blocker.hasKeyword("CARDNAME blocks each turn if able."))) {
+                                    || blocker.hasKeyword("CARDNAME blocks each turn if able.")
+                                    || blocker.hasKeyword("CARDNAME blocks each combat if able."))) {
                         combat.addBlocker(attacker, blocker);
                         if (blocker.getMustBlockCards() != null) {
                             int mustBlockAmt = blocker.getMustBlockCards().size();
@@ -956,6 +1117,18 @@ public class AiBlockController {
                 }
             }
         }
+
+
+        // check to see if it's possible to defend a Planeswalker under attack with a chump block,
+        // unless life is low enough to be more worried about saving preserving the life total
+        if (ai.getController().isAI() && !ComputerUtilCombat.lifeInDanger(ai, combat)) {
+            makeChumpBlocksToSavePW(combat);
+        }
+
+        // if there are still blockers left, see if it's possible to block Menace creatures with
+        // non-lethal blockers that won't kill the attacker but won't die to it as well
+        makeGangNonLethalBlocks(combat);
+
         //Check for validity of blocks in case something slipped through
         for (Card attacker : attackers) {
             if (!CombatUtil.canAttackerBeBlockedWithAmount(attacker, combat.getBlockers(attacker).size(), combat)) {
@@ -1056,4 +1229,91 @@ public class AiBlockController {
         return first;
     }
 
+    private boolean wouldLikeToRandomlyTrade(Card attacker, Card blocker, Combat combat) {
+        // Determines if the AI would like to randomly trade its blocker for the attacker in given combat
+        boolean enableRandomTrades = false;
+        boolean randomTradeIfBehindOnBoard = false;
+        boolean randomTradeIfCreatInHand = false;
+        int chanceModForEmbalm = 0;
+        int chanceToTradeToSaveWalker = 0;
+        int chanceToTradeDownToSaveWalker = 0;
+        int minRandomTradeChance = 0;
+        int maxRandomTradeChance = 0;
+        int maxCreatDiff = 0;
+        int maxCreatDiffWithRepl = 0;
+        int aiCreatureCount = 0;
+        int oppCreatureCount = 0;
+        if (ai.getController().isAI()) {
+            AiController aic = ((PlayerControllerAi) ai.getController()).getAi();
+            enableRandomTrades = aic.getBooleanProperty(AiProps.ENABLE_RANDOM_FAVORABLE_TRADES_ON_BLOCK);
+            randomTradeIfBehindOnBoard = aic.getBooleanProperty(AiProps.RANDOMLY_TRADE_EVEN_WHEN_HAVE_LESS_CREATS);
+            randomTradeIfCreatInHand = aic.getBooleanProperty(AiProps.ALSO_TRADE_WHEN_HAVE_A_REPLACEMENT_CREAT);
+            minRandomTradeChance = aic.getIntProperty(AiProps.MIN_CHANCE_TO_RANDOMLY_TRADE_ON_BLOCK);
+            maxRandomTradeChance = aic.getIntProperty(AiProps.MAX_CHANCE_TO_RANDOMLY_TRADE_ON_BLOCK);
+            chanceModForEmbalm = aic.getIntProperty(AiProps.CHANCE_DECREASE_TO_TRADE_VS_EMBALM);
+            maxCreatDiff = aic.getIntProperty(AiProps.MAX_DIFF_IN_CREATURE_COUNT_TO_TRADE);
+            maxCreatDiffWithRepl = aic.getIntProperty(AiProps.MAX_DIFF_IN_CREATURE_COUNT_TO_TRADE_WITH_REPL);
+            chanceToTradeToSaveWalker = aic.getIntProperty(AiProps.CHANCE_TO_TRADE_TO_SAVE_PLANESWALKER);
+            chanceToTradeDownToSaveWalker = aic.getIntProperty(AiProps.CHANCE_TO_TRADE_DOWN_TO_SAVE_PLANESWALKER);
+        }
+
+        if (!enableRandomTrades) {
+            return false;
+        }
+
+        aiCreatureCount = ComputerUtil.countUsefulCreatures(ai);
+
+        if (!attackersLeft.isEmpty()) {
+            oppCreatureCount = ComputerUtil.countUsefulCreatures(attackersLeft.get(0).getController());
+        }
+
+        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
+            return false;
+        }
+
+        int numSteps = ai.getStartingLife() - 5; // e.g. 15 steps between 5 life and 20 life
+        float chanceStep = (maxRandomTradeChance - minRandomTradeChance) / numSteps;
+        int chance = (int)Math.max(minRandomTradeChance, (maxRandomTradeChance - (Math.max(5, ai.getLife() - 5)) * chanceStep));
+        if (chance > maxRandomTradeChance) {
+            chance = maxRandomTradeChance;
+        }
+
+        int evalAtk = ComputerUtilCard.evaluateCreature(attacker, true, false);
+        int evalBlk = ComputerUtilCard.evaluateCreature(blocker, true, false);
+        boolean atkEmbalm = (attacker.hasStartOfKeyword("Embalm") || attacker.hasStartOfKeyword("Eternalize")) && !attacker.isToken();
+        boolean blkEmbalm = (blocker.hasStartOfKeyword("Embalm") || blocker.hasStartOfKeyword("Eternalize")) && !blocker.isToken();
+
+        if (atkEmbalm && !blkEmbalm) {
+            // The opponent will eventually get his creature back, while the AI won't
+            chance = Math.max(0, chance - chanceModForEmbalm);
+        }
+
+        if (blocker.isFaceDown() && blocker.getState(CardStateName.Original).getType().isCreature()) {
+            // if the blocker is a face-down creature (e.g. cast via Morph, Manifest), evaluate it
+            // in relation to the original state, not to the Morph state
+            evalBlk = ComputerUtilCard.evaluateCreature(Card.fromPaperCard(blocker.getPaperCard(), ai), false, true);
+        }
+        int chanceToSavePW = chanceToTradeDownToSaveWalker > 0 && evalAtk + 1 < evalBlk ? chanceToTradeDownToSaveWalker : chanceToTradeToSaveWalker;
+        boolean powerParityOrHigher = blocker.getNetPower() <= attacker.getNetPower();
+        boolean creatureParityOrAllowedDiff = aiCreatureCount
+                + (randomTradeIfBehindOnBoard ? maxCreatDiff : 0) >= oppCreatureCount;
+        boolean wantToTradeWithCreatInHand = randomTradeIfCreatInHand
+                && !CardLists.filter(ai.getCardsIn(ZoneType.Hand), CardPredicates.Presets.CREATURES).isEmpty()
+                && aiCreatureCount + maxCreatDiffWithRepl >= oppCreatureCount;
+        boolean wantToSavePlaneswalker = MyRandom.percentTrue(chanceToSavePW)
+                && combat.getDefenderByAttacker(attacker) instanceof Card
+                && ((Card) combat.getDefenderByAttacker(attacker)).isPlaneswalker();
+        boolean wantToTradeDownToSavePW = chanceToTradeDownToSaveWalker > 0;
+
+        if (((evalBlk <= evalAtk + 1) || (wantToSavePlaneswalker && wantToTradeDownToSavePW)) // "1" accounts for tapped.
+                && powerParityOrHigher
+                && (creatureParityOrAllowedDiff || wantToTradeWithCreatInHand)
+                && (MyRandom.percentTrue(chance) || wantToSavePlaneswalker)) {
+            return true;
+        }
+
+        return false;
+    }
 }

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

@@ -41,17 +41,23 @@ import java.util.Set;
 public class AiCardMemory {
 
     private final Set<Card> memMandatoryAttackers;
+    private final Set<Card> memTrickAttackers;
     private final Set<Card> memHeldManaSources;
+    private final Set<Card> memHeldManaSourcesForCombat;
     private final Set<Card> memAttachedThisTurn;
     private final Set<Card> memAnimatedThisTurn;
     private final Set<Card> memBouncedThisTurn;
+    private final Set<Card> memActivatedThisTurn;
 
     public AiCardMemory() {
         this.memMandatoryAttackers = new HashSet<>();
         this.memHeldManaSources = new HashSet<>();
+        this.memHeldManaSourcesForCombat = new HashSet<>();
         this.memAttachedThisTurn = new HashSet<>();
         this.memAnimatedThisTurn = new HashSet<>();
         this.memBouncedThisTurn = new HashSet<>();
+        this.memActivatedThisTurn = new HashSet<>();
+        this.memTrickAttackers = new HashSet<>();
     }
 
     /**
@@ -61,10 +67,13 @@ public class AiCardMemory {
      */
     public enum MemorySet {
         MANDATORY_ATTACKERS,
-        HELD_MANA_SOURCES, 
+        TRICK_ATTACKERS,
+        HELD_MANA_SOURCES_FOR_MAIN2,
+        HELD_MANA_SOURCES_FOR_DECLBLK,
         ATTACHED_THIS_TURN,
         ANIMATED_THIS_TURN,
         BOUNCED_THIS_TURN,
+        ACTIVATED_THIS_TURN,
         //REVEALED_CARDS // stub, not linked to AI code yet
     }
 
@@ -72,14 +81,20 @@ public class AiCardMemory {
         switch (set) {
             case MANDATORY_ATTACKERS:
                 return memMandatoryAttackers;
-            case HELD_MANA_SOURCES:
+            case TRICK_ATTACKERS:
+                return memTrickAttackers;
+            case HELD_MANA_SOURCES_FOR_MAIN2:
                 return memHeldManaSources;
+            case HELD_MANA_SOURCES_FOR_DECLBLK:
+                return memHeldManaSourcesForCombat;
             case ATTACHED_THIS_TURN:
                 return memAttachedThisTurn;
             case ANIMATED_THIS_TURN:
                 return memAnimatedThisTurn;
             case BOUNCED_THIS_TURN:
                 return memBouncedThisTurn;
+            case ACTIVATED_THIS_TURN:
+                return memActivatedThisTurn;
             //case REVEALED_CARDS:
             //    return memRevealedCards;
             default:
@@ -249,10 +264,13 @@ public class AiCardMemory {
      */
     public void clearAllRemembered() {
         clearMemorySet(MemorySet.MANDATORY_ATTACKERS);
-        clearMemorySet(MemorySet.HELD_MANA_SOURCES);
+        clearMemorySet(MemorySet.TRICK_ATTACKERS);
+        clearMemorySet(MemorySet.HELD_MANA_SOURCES_FOR_MAIN2);
+        clearMemorySet(MemorySet.HELD_MANA_SOURCES_FOR_DECLBLK);
         clearMemorySet(MemorySet.ATTACHED_THIS_TURN);
         clearMemorySet(MemorySet.ANIMATED_THIS_TURN);
         clearMemorySet(MemorySet.BOUNCED_THIS_TURN);
+        clearMemorySet(MemorySet.ACTIVATED_THIS_TURN);
     }
 
     // Static functions to simplify access to AI card memory of a given AI player.
@@ -265,6 +283,9 @@ public class AiCardMemory {
     public static boolean isRememberedCard(Player ai, Card c, MemorySet set) {
         return ((PlayerControllerAi)ai.getController()).getAi().getCardMemory().isRememberedCard(c, set);
     }
+    public static boolean isRememberedCardByName(Player ai, String name, MemorySet set) {
+        return ((PlayerControllerAi)ai.getController()).getAi().getCardMemory().isRememberedCardByName(name, set);
+    }
     public static void clearMemorySet(Player ai, MemorySet set) {
         ((PlayerControllerAi)ai.getController()).getAi().getCardMemory().clearMemorySet(set);
     }

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

@@ -17,14 +17,6 @@
  */
 package forge.ai;
 
-import java.security.InvalidParameterException;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.Comparator;
-import java.util.List;
-import java.util.Map;
-import java.util.Map.Entry;
-
 import com.esotericsoftware.minlog.Log;
 import com.google.common.base.Function;
 import com.google.common.base.Predicate;
@@ -32,52 +24,31 @@ 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.ai.ability.ChangeZoneAi;
+import forge.ai.ability.ExploreAi;
 import forge.ai.simulation.SpellAbilityPicker;
 import forge.card.MagicColor;
 import forge.card.mana.ManaCost;
 import forge.deck.CardPool;
 import forge.deck.Deck;
 import forge.deck.DeckSection;
-import forge.game.CardTraitBase;
-import forge.game.CardTraitPredicates;
-import forge.game.Direction;
-import forge.game.Game;
-import forge.game.GameEntity;
-import forge.game.GlobalRuleChange;
+import forge.game.*;
 import forge.game.ability.AbilityFactory;
 import forge.game.ability.AbilityUtils;
 import forge.game.ability.ApiType;
 import forge.game.ability.SpellApiBased;
-import forge.game.card.Card;
-import forge.game.card.CardCollection;
-import forge.game.card.CardCollectionView;
-import forge.game.card.CardFactoryUtil;
-import forge.game.card.CardLists;
-import forge.game.card.CardPredicates;
+import forge.game.card.*;
 import forge.game.card.CardPredicates.Presets;
-import forge.game.card.CounterType;
 import forge.game.combat.Combat;
 import forge.game.combat.CombatUtil;
-import forge.game.cost.Cost;
-import forge.game.cost.CostDiscard;
-import forge.game.cost.CostPart;
-import forge.game.cost.CostPutCounter;
-import forge.game.cost.CostRemoveCounter;
+import forge.game.cost.*;
 import forge.game.mana.ManaCostBeingPaid;
+import forge.game.phase.PhaseType;
 import forge.game.player.Player;
 import forge.game.player.PlayerActionConfirmMode;
 import forge.game.replacement.ReplaceMoved;
 import forge.game.replacement.ReplacementEffect;
-import forge.game.spellability.AbilityManaPart;
-import forge.game.spellability.AbilitySub;
-import forge.game.spellability.OptionalCost;
-import forge.game.spellability.Spell;
-import forge.game.spellability.SpellAbility;
-import forge.game.spellability.SpellAbilityCondition;
-import forge.game.spellability.SpellAbilityPredicates;
-import forge.game.spellability.SpellPermanent;
+import forge.game.spellability.*;
 import forge.game.trigger.Trigger;
 import forge.game.trigger.TriggerType;
 import forge.game.trigger.WrappedAbility;
@@ -88,6 +59,10 @@ import forge.util.Expressions;
 import forge.util.MyRandom;
 import forge.util.collect.FCollectionView;
 
+import java.security.InvalidParameterException;
+import java.util.*;
+import java.util.Map.Entry;
+
 /**
  * <p>
  * AiController class.
@@ -605,11 +580,32 @@ public class AiController {
         return null;
     }
 
-    public void reserveManaSourcesForMain2(SpellAbility sa) {
+    public void reserveManaSources(SpellAbility sa) {
+        reserveManaSources(sa, PhaseType.MAIN2);
+    }
+
+    public void reserveManaSources(SpellAbility sa, PhaseType phaseType) {
         ManaCostBeingPaid cost = ComputerUtilMana.calculateManaCost(sa, true, 0);
         CardCollection manaSources = ComputerUtilMana.getManaSourcesToPayCost(cost, sa, player);
+
+        AiCardMemory.MemorySet memSet;
+
+        switch (phaseType) {
+            case MAIN2:
+                memSet = AiCardMemory.MemorySet.HELD_MANA_SOURCES_FOR_MAIN2;
+                break;
+            case COMBAT_DECLARE_BLOCKERS:
+                memSet = AiCardMemory.MemorySet.HELD_MANA_SOURCES_FOR_DECLBLK;
+                break;
+            default:
+                System.out.println("Warning: unsupported mana reservation phase specified for reserveManaSources: "
+                        + phaseType.name() + ", reserving until Main 2 instead. Consider adding support for the phase if needed.");
+                memSet = AiCardMemory.MemorySet.HELD_MANA_SOURCES_FOR_MAIN2;
+                break;
+        }
+
         for (Card c : manaSources) {
-            AiCardMemory.rememberCard(player, c, AiCardMemory.MemorySet.HELD_MANA_SOURCES);
+            AiCardMemory.rememberCard(player, c, memSet);
         }
     }
 
@@ -666,6 +662,11 @@ public class AiController {
         if (sa instanceof SpellPermanent) {
             return canPlayFromEffectAI((SpellPermanent)sa, false, true);
         }
+        if (sa.usesTargeting() && !sa.isTargetNumberValid()) {
+            if (!sa.getTargetRestrictions().hasCandidates(sa, true)) {
+                return AiPlayDecision.TargetingFailed;
+            }
+        }
         if (sa instanceof Spell) {
             if (ComputerUtil.getDamageForPlaying(player, sa) >= player.getLife() 
                     && !player.cantLoseForZeroOrLessLife() && player.canLoseLife()) {
@@ -676,42 +677,34 @@ public class AiController {
         return AiPlayDecision.WillPlay;
     }
 
+    public boolean isNonDisabledCardInPlay(final String cardName) {
+        for (Card card : player.getCardsIn(ZoneType.Battlefield)) {
+            if (card.getName().equals(cardName)) {
+                // TODO - Better logic to detemine if a permanent is disabled by local effects
+                // currently assuming any permanent enchanted by another player
+                // is disabled and a second copy is necessary
+                // will need actual logic that determines if the enchantment is able
+                // to disable the permanent or it's still functional and a duplicate is unneeded.
+                boolean disabledByEnemy = false;
+                for (Card card2 : card.getEnchantedBy(false)) {
+                    if (card2.getOwner() != player) {
+                        disabledByEnemy = true;
+                    }
+                }
+                if (!disabledByEnemy) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
     private AiPlayDecision canPlaySpellBasic(final Card card, final SpellAbility sa) {
-        boolean isRightSplit = sa != null && sa.isRightSplit();
-        String needsToPlayName = isRightSplit ? "SplitNeedsToPlay" : "NeedsToPlay";
-        String needsToPlayVarName = isRightSplit ? "SplitNeedsToPlayVar": "NeedsToPlayVar";
-
-        if (card.hasSVar(needsToPlayName)) {
-            final String needsToPlay = card.getSVar(needsToPlayName);
-            CardCollectionView list = game.getCardsIn(ZoneType.Battlefield);
-
-            list = CardLists.getValidCards(list, needsToPlay.split(","), card.getController(), card, null);
-            if (list.isEmpty()) {
-                return AiPlayDecision.MissingNeededCards;
-            }
+        if ("True".equals(card.getSVar("NonStackingEffect")) && isNonDisabledCardInPlay(card.getName())) {
+            return AiPlayDecision.NeedsToPlayCriteriaNotMet;
         }
-        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));
-            }
-            if (!Expressions.compare(x, comparator, y)) {
-                return AiPlayDecision.NeedsToPlayCriteriaNotMet;
-            }
-        }
-        return AiPlayDecision.WillPlay;
+        // add any other necessary logic to play a basic spell here
+        return ComputerUtilCard.checkNeedsToPlayReqs(card, sa);
     }
 
     // not sure "playing biggest spell" matters?
@@ -724,12 +717,31 @@ public class AiController {
             int b1 = b.getPayCosts() == null ? 0 : b.getPayCosts().getTotalMana().getCMC();
 
             // deprioritize planar die roll marked with AIRollPlanarDieParams:LowPriority$ True
-            if (ApiType.RollPlanarDice == a.getApi() && a.getHostCard().hasSVar("AIRollPlanarDieParams") && a.getHostCard().getSVar("AIRollPlanarDieParams").toLowerCase().matches(".*lowpriority\\$\\s*true.*")) {
+            if (ApiType.RollPlanarDice == a.getApi() && a.getHostCard() != null && a.getHostCard().hasSVar("AIRollPlanarDieParams") && a.getHostCard().getSVar("AIRollPlanarDieParams").toLowerCase().matches(".*lowpriority\\$\\s*true.*")) {
                 return 1;
-            } else if (ApiType.RollPlanarDice == b.getApi() && b.getHostCard().hasSVar("AIRollPlanarDieParams") && b.getHostCard().getSVar("AIRollPlanarDieParams").toLowerCase().matches(".*lowpriority\\$\\s*true.*")) {
+            } else if (ApiType.RollPlanarDice == b.getApi() && b.getHostCard() != null && b.getHostCard().hasSVar("AIRollPlanarDieParams") && b.getHostCard().getSVar("AIRollPlanarDieParams").toLowerCase().matches(".*lowpriority\\$\\s*true.*")) {
                 return -1;
             }
 
+            // 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.getPayCosts().hasOnlySpecificCostType(CostPayEnergy.class)) {
+                    a2 = a.getPayCosts().getCostEnergy().convertAmount();
+                }
+            }
+            if (b.getApi() == ApiType.Pump && b.getPayCosts() != null && b.getPayCosts().getCostEnergy() != null) {
+                if (b.getPayCosts().hasOnlySpecificCostType(CostPayEnergy.class)) {
+                    b2 = b.getPayCosts().getCostEnergy().convertAmount();
+                }
+            }
+            if (a2 == 0 && b2 > 0) {
+                return -1;
+            } else if (b2 == 0 && a2 > 0) {
+                return 1;
+            }
+
             // cast 0 mana cost spells first (might be a Mox)
             if (a1 == 0 && b1 > 0 && ApiType.Mana != a.getApi()) {
                 return -1;
@@ -737,9 +749,9 @@ public class AiController {
                 return 1;
             }
             
-            if (a.getHostCard().hasSVar("FreeSpellAI")) {
+            if (a.getHostCard() != null && a.getHostCard().hasSVar("FreeSpellAI")) {
                 return -1;
-            } else if (b.getHostCard().hasSVar("FreeSpellAI")) {
+            } else if (b.getHostCard() != null && b.getHostCard().hasSVar("FreeSpellAI")) {
                 return 1;
             }
 
@@ -752,36 +764,44 @@ public class AiController {
         private int getSpellAbilityPriority(SpellAbility sa) {
             int p = 0;
             Card source = sa.getHostCard();
-            final Player ai = source.getController();
+            final Player ai = source == null ? sa.getActivatingPlayer() : source.getController();
+            if (ai == null) {
+                System.err.println("Error: couldn't figure out the activating player and host card for SA: " + sa);
+                return 0;
+            }
             final boolean noCreatures = ai.getCreaturesInPlay().isEmpty();
-            // puts creatures in front of spells
-            if (source.isCreature()) {
-                p += 1;
-            }
-            // don't play equipments before having any creatures
-            if (source.isEquipment() && noCreatures) {
-                p -= 9;
+
+            if (source != null) {
+                // puts creatures in front of spells
+                if (source.isCreature()) {
+                    p += 1;
+                }
+                // don't play equipments before having any creatures
+                if (source.isEquipment() && noCreatures) {
+                    p -= 9;
+                }
+                // 1. increase chance of using Surge effects
+                // 2. non-surged versions are usually inefficient
+                if (source.getOracleText().contains("surge cost") && !sa.isSurged()) {
+                    p -= 9;
+                }
+                // move snap-casted spells to front
+                if (source.isInZone(ZoneType.Graveyard)) {
+                    if (sa.getMayPlay() != null && source.mayPlay(sa.getMayPlay()) != null) {
+                        p += 50;
+                    }
+                }
+                // if the profile specifies it, deprioritize Storm spells in an attempt to build up storm count
+                if (source.hasKeyword("Storm") && ai.getController() instanceof PlayerControllerAi) {
+                    p -= (((PlayerControllerAi) ai.getController()).getAi().getIntProperty(AiProps.PRIORITY_REDUCTION_FOR_STORM_SPELLS));
+                }
             }
+
             // use Surge and Prowl costs when able to
             if (sa.isSurged() || 
                     (sa.getRestrictions().getProwlTypes() != null && !sa.getRestrictions().getProwlTypes().isEmpty())) {
                 p += 9;
             }
-            // 1. increase chance of using Surge effects
-            // 2. non-surged versions are usually inefficient
-            if (sa.getHostCard().getOracleText().contains("surge cost") && !sa.isSurged()) {
-                p -= 9;
-            }
-            // move snap-casted spells to front
-            if (source.isInZone(ZoneType.Graveyard)) {
-                if(sa.getMayPlay() != null && source.mayPlay(sa.getMayPlay()) != null) {
-                    p += 50;
-                }
-            }
-            // artifacts and enchantments with effects that do not stack
-            if ("True".equals(source.getSVar("NonStackingEffect")) && ai.isCardInPlay(source.getName())) {
-                p -= 9;
-            }
             // sort planeswalker abilities with most costly first
             if (sa.getRestrictions().isPwAbility()) {
                 final CostPart cost = sa.getPayCosts().getCostParts().get(0);
@@ -801,11 +821,6 @@ public class AiController {
                 p -= 9;
             }
 
-            // if the profile specifies it, deprioritize Storm spells in an attempt to build up storm count
-            if (source.hasKeyword("Storm") && ai.getController() instanceof PlayerControllerAi) {
-                p -= (((PlayerControllerAi)ai.getController()).getAi().getIntProperty(AiProps.PRIORITY_REDUCTION_FOR_STORM_SPELLS));
-            }
-
             // try to cast mana ritual spells before casting spells to maximize potential mana
             if ("ManaRitual".equals(sa.getParam("AILogic"))) {
                 p += 9;
@@ -840,7 +855,36 @@ public class AiController {
             sourceCard = sa.getHostCard();
             if ("Always".equals(sa.getParam("AILogic")) && !validCards.isEmpty()) {
                 min = 1;
+            } else if ("VolrathsShapeshifter".equals(sa.getParam("AILogic"))) {
+                return SpecialCardAi.VolrathsShapeshifter.targetBestCreature(player, sa);
             }
+
+            if (sa.hasParam("AnyNumber")) {
+                if ("DiscardUncastableAndExcess".equals(sa.getParam("AILogic"))) {
+                    CardCollection discards = new CardCollection();
+                    final CardCollectionView inHand = player.getCardsIn(ZoneType.Hand);
+                    final int numLandsOTB = CardLists.filter(player.getCardsIn(ZoneType.Hand), CardPredicates.Presets.LANDS).size();
+                    int numOppInHand = 0;
+                    for (Player p : player.getGame().getPlayers()) {
+                        if (p.getCardsIn(ZoneType.Hand).size() > numOppInHand) {
+                            numOppInHand = p.getCardsIn(ZoneType.Hand).size();
+                        }
+                    }
+                    for (Card c : inHand) {
+                        if (c.hasSVar("DoNotDiscardIfAble") || c.hasSVar("IsReanimatorCard")) { continue; }
+                        if (c.isCreature() && !ComputerUtilMana.hasEnoughManaSourcesToCast(c.getSpellPermanent(), player)) {
+                            discards.add(c);
+                        }
+                        if ((c.isLand() && numLandsOTB >= 5) || (c.getFirstSpellAbility() != null && !ComputerUtilMana.hasEnoughManaSourcesToCast(c.getFirstSpellAbility(), player))) {
+                            if (discards.size() + 1 <= numOppInHand) {
+                                discards.add(c);
+                            }
+                        }
+                    }
+                    return discards;
+                }
+            }
+
         }
 
         // look for good discards
@@ -858,6 +902,9 @@ public class AiController {
             }
             if (prefCard == null) {
                 prefCard = ComputerUtil.getCardPreference(player, sourceCard, "DiscardCost", validCards);
+                if (prefCard != null && prefCard.hasSVar("DoNotDiscardIfAble")) {
+                    prefCard = null;
+                }
             }
             if (prefCard != null) {
                 discardList.add(prefCard);
@@ -894,13 +941,52 @@ public class AiController {
                 if (numLandsInHand > 0) {
                     numLandsAvailable++;
                 }
+
                 //Discard unplayable card
-                if (validCards.get(0).getCMC() > numLandsAvailable) {
-                    discardList.add(validCards.get(0));
-                    validCards.remove(validCards.get(0));
+                boolean discardedUnplayable = false;
+                for (int j = 0; j < validCards.size(); j++) {
+                    if (validCards.get(j).getCMC() > numLandsAvailable && !validCards.get(j).hasSVar("DoNotDiscardIfAble")) {
+                        discardList.add(validCards.get(j));
+                        validCards.remove(validCards.get(j));
+                        discardedUnplayable = true;
+                        break;
+                    } else if (validCards.get(j).getCMC() <= numLandsAvailable) {
+                        // cut short to avoid looping over cards which are guaranteed not to fit the criteria
+                        break;
+                    }
                 }
-                else { //Discard worst card
+
+                if (!discardedUnplayable) {
+                    // discard worst card
                     Card worst = ComputerUtilCard.getWorstAI(validCards);
+                    if (worst == null) {
+                        // there were only instants and sorceries, and maybe cards that are not good to discard, so look
+                        // for more discard options
+                        worst = ComputerUtilCard.getCheapestSpellAI(validCards);
+                    }
+                    if (worst == null && !validCards.isEmpty()) {
+                        // still nothing chosen, so choose the first thing that works, trying not to make DoNotDiscardIfAble
+                        // discards
+                        for (Card c : validCards) {
+                            if (!c.hasSVar("DoNotDiscardIfAble")) {
+                                worst = c;
+                                break;
+                            }
+                        }
+                        // Only DoNotDiscardIfAble cards? If we have a duplicate for something, discard it
+                        if (worst == null) {
+                            for (Card c : validCards) {
+                                if (CardLists.filter(player.getCardsIn(ZoneType.Hand), CardPredicates.nameEquals(c.getName())).size() > 1) {
+                                    worst = c;
+                                    break;
+                                }
+                            }
+                            if (worst == null) {
+                                // Otherwise just grab a random card and discard it
+                                worst = Aggregates.random(validCards);
+                            }
+                        }
+                    }
                     discardList.add(worst);
                     validCards.remove(worst);
                 }
@@ -1059,17 +1145,46 @@ public class AiController {
         }
 
         CardCollection landsWannaPlay = ComputerUtilAbility.getAvailableLandsToPlay(game, player);
+        CardCollection playBeforeLand = CardLists.filter(
+            player.getCardsIn(ZoneType.Hand), CardPredicates.hasSVar("PlayBeforeLandDrop")
+        );
+
+        if (!playBeforeLand.isEmpty()) {
+            SpellAbility wantToPlayBeforeLand = chooseSpellAbilityToPlayFromList(
+                ComputerUtilAbility.getSpellAbilities(playBeforeLand, player), false
+            );
+            if (wantToPlayBeforeLand != null) {
+                return singleSpellAbilityList(wantToPlayBeforeLand);
+            }
+        }
+
         if (landsWannaPlay != null) {
             landsWannaPlay = filterLandsToPlay(landsWannaPlay);
             Log.debug("Computer " + game.getPhaseHandler().getPhase().nameForUi);
             if (landsWannaPlay != null && !landsWannaPlay.isEmpty() && player.canPlayLand(null)) {
+                // TODO search for other land it might want to play?
                 Card land = chooseBestLandToPlay(landsWannaPlay);
                 if (ComputerUtil.getDamageFromETB(player, land) < player.getLife() || !player.canLoseLife() 
                         || player.cantLoseForZeroOrLessLife() ) {
-                    game.PLAY_LAND_SURROGATE.setHostCard(land);
-                    final List<SpellAbility> abilities = Lists.newArrayList();
-                    abilities.add(game.PLAY_LAND_SURROGATE);
-                    return abilities;
+                    if (!game.getPhaseHandler().is(PhaseType.MAIN1) || !isSafeToHoldLandDropForMain2(land)) {
+                        final List<SpellAbility> abilities = Lists.newArrayList();
+
+                        LandAbility la = new LandAbility(land, player, null);
+                        if (la.canPlay()) {
+                            abilities.add(la);
+                        }
+
+                        // add mayPlay option
+                        for (CardPlayOption o : land.mayPlay(player)) {
+                            la = new LandAbility(land, player, o.getAbility());
+                            if (la.canPlay()) {
+                                abilities.add(la);
+                            }
+                        }
+                        if (!abilities.isEmpty()) {
+                            return abilities;
+                        }
+                    }
                 }
             }
         }
@@ -1077,6 +1192,116 @@ public class AiController {
         return singleSpellAbilityList(getSpellAbilityToPlay());
     }
 
+    private boolean isSafeToHoldLandDropForMain2(Card landToPlay) {
+        boolean hasMomir = !CardLists.filter(player.getCardsIn(ZoneType.Command),
+                CardPredicates.nameEquals("Momir Vig, Simic Visionary Avatar")).isEmpty();
+        if (hasMomir) {
+            // Don't do this in Momir variants since it messes with the AI decision making for the avatar.
+            return false;
+        }
+
+        if (!MyRandom.percentTrue(getIntProperty(AiProps.HOLD_LAND_DROP_FOR_MAIN2_IF_UNUSED))) {
+            // check against the chance specified in the profile
+            return false;
+        }
+        if (game.getPhaseHandler().getTurn() <= 2) {
+            // too obvious when doing it on the very first turn of the game
+            return false;
+        }
+
+        CardCollection inHand = CardLists.filter(player.getCardsIn(ZoneType.Hand),
+                Predicates.not(CardPredicates.Presets.LANDS));
+        CardCollectionView otb = player.getCardsIn(ZoneType.Battlefield);
+
+        if (getBooleanProperty(AiProps.HOLD_LAND_DROP_ONLY_IF_HAVE_OTHER_PERMS)) {
+            if (CardLists.filter(otb, Predicates.not(CardPredicates.Presets.LANDS)).isEmpty()) {
+                return false;
+            }
+        }
+
+        // TODO: improve the detection of taplands
+        boolean isTapLand = false;
+        for (ReplacementEffect repl : landToPlay.getReplacementEffects()) {
+            if (repl.getParamOrDefault("Description", "").equals("CARDNAME enters the battlefield tapped.")) {
+                isTapLand = true;
+            }
+        }
+
+        int totalCMCInHand = Aggregates.sum(inHand, CardPredicates.Accessors.fnGetCmc);
+        int minCMCInHand = Aggregates.min(inHand, CardPredicates.Accessors.fnGetCmc);
+        int predictedMana = ComputerUtilMana.getAvailableManaEstimate(player, true);
+
+        boolean canCastWithLandDrop = (predictedMana + 1 >= minCMCInHand) && !isTapLand;
+        boolean cantCastAnythingNow = predictedMana < minCMCInHand;
+
+        boolean hasRelevantAbsOTB = !CardLists.filter(otb, new Predicate<Card>() {
+            @Override
+            public boolean apply(Card card) {
+                boolean isTapLand = false;
+                for (ReplacementEffect repl : card.getReplacementEffects()) {
+                    // TODO: improve the detection of taplands
+                    if (repl.getParamOrDefault("Description", "").equals("CARDNAME enters the battlefield tapped.")) {
+                        isTapLand = true;
+                    }
+                }
+
+                for (SpellAbility sa : card.getSpellAbilities()) {
+                    if (sa.getPayCosts() != null && sa.isAbility()
+                            && sa.getPayCosts().getCostMana() != null
+                            && sa.getPayCosts().getCostMana().getMana().getCMC() > 0
+                            && (!sa.getPayCosts().hasTapCost() || !isTapLand)
+                            && (!sa.hasParam("ActivationZone") || sa.getParam("ActivationZone").contains("Battlefield"))) {
+                        return true;
+                    }
+                }
+                return false;
+            }
+        }).isEmpty();
+
+        boolean hasLandBasedEffect = !CardLists.filter(otb, new Predicate<Card>() {
+            @Override
+            public boolean apply(Card card) {
+                for (Trigger t : card.getTriggers()) {
+                    Map<String, String> params = t.getMapParams();
+                    if ("ChangesZone".equals(params.get("Mode"))
+                            && params.containsKey("ValidCard")
+                            && !params.get("ValidCard").contains("nonLand")
+                            && ((params.get("ValidCard").contains("Land")) || (params.get("ValidCard").contains("Permanent")))
+                            && "Battlefield".equals(params.get("Destination"))) {
+                        // Landfall and other similar triggers
+                        return true;
+                    }
+                }
+                for (String sv : card.getSVars().keySet()) {
+                    String varValue = card.getSVar(sv);
+                    if (varValue.startsWith("Count$Valid") || sv.equals("BuffedBy")) {
+                        if (varValue.contains("Land") || varValue.contains("Plains") || varValue.contains("Forest")
+                                || varValue.contains("Mountain") || varValue.contains("Island") || varValue.contains("Swamp")
+                                || varValue.contains("Wastes")) {
+                            // In presence of various cards that get buffs like "equal to the number of lands you control",
+                            // safer for our AI model to just play the land earlier rather than make a blunder
+                            return true;
+                        }
+                    }
+                }
+                return false;
+            }
+        }).isEmpty();
+
+        // TODO: add prediction for effects that will untap a tapland as it enters the battlefield
+        if (!canCastWithLandDrop && cantCastAnythingNow && !hasLandBasedEffect && (!hasRelevantAbsOTB || isTapLand)) {
+            // Hopefully there's not much to do with the extra mana immediately, can wait for Main 2
+            return true;
+        }
+        if ((predictedMana <= totalCMCInHand && canCastWithLandDrop) || (hasRelevantAbsOTB && !isTapLand) || hasLandBasedEffect) {
+            // Might need an extra land to cast something, or for some kind of an ETB ability with a cost or an
+            // alternative cost (if we cast it in Main 1), or to use an activated ability on the battlefield
+            return false;
+        }
+
+        return true;
+    }
+
     private final SpellAbility getSpellAbilityToPlay() {
         // if top of stack is owned by me
         if (!game.getStack().isEmpty() && game.getStack().peekAbility().getActivatingPlayer().equals(player)) {
@@ -1571,7 +1796,11 @@ public class AiController {
         if (useSimulation) {
             return simPicker.chooseCardToHiddenOriginChangeZone(destination, origin, sa, fetchList, player2, decider);
         }
-        return ChangeZoneAi.chooseCardToHiddenOriginChangeZone(destination, origin, sa, fetchList, player2, decider);
+        if (sa.getApi() == ApiType.Explore) {
+            return ExploreAi.shouldPutInGraveyard(fetchList, decider);
+        } else {
+            return ChangeZoneAi.chooseCardToHiddenOriginChangeZone(destination, origin, sa, fetchList, player2, decider);
+        }
     }
 
     public List<SpellAbility> orderPlaySa(List<SpellAbility> activePlayerSAs) {
@@ -1593,6 +1822,10 @@ public class AiController {
 
         List<SpellAbility> evolve = filterList(putCounter, SpellAbilityPredicates.hasParam("Evolve"));
 
+        List<SpellAbility> token = filterListByApi(activePlayerSAs, ApiType.Token);
+        List<SpellAbility> pump = filterListByApi(activePlayerSAs, ApiType.Pump);
+        List<SpellAbility> pumpAll = filterListByApi(activePlayerSAs, ApiType.PumpAll);
+
         // do mandatory discard early if hand is empty or has DiscardMe card
         boolean discardEarly = false;
         CardCollectionView playerHand = player.getCardsIn(ZoneType.Hand);
@@ -1601,6 +1834,11 @@ public class AiController {
             result.addAll(mandatoryDiscard);
         }
 
+        // token should be added first so they might get the pump bonus
+        result.addAll(token);
+        result.addAll(pump);
+        result.addAll(pumpAll);
+
         // do Evolve Trigger before other PutCounter SpellAbilities
         // do putCounter before Draw/Discard because it can cause a Draw Trigger
         result.addAll(evolve);
@@ -1616,6 +1854,9 @@ public class AiController {
         }
 
         result.addAll(activePlayerSAs);
+
+        //need to reverse because of magic stack
+        Collections.reverse(result);
         return result;
     }
 

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

@@ -63,8 +63,8 @@ public class AiCostDecision extends CostDecisionMakerBase {
     @Override
     public PaymentDecision visit(CostDiscard cost) {
         final String type = cost.getType();
+        CardCollectionView hand = player.getCardsIn(ZoneType.Hand);
 
-        final CardCollectionView hand = player.getCardsIn(ZoneType.Hand);
         if (type.equals("LastDrawn")) {
             if (!hand.contains(player.getLastDrawnCard())) {
                 return null;
@@ -79,6 +79,9 @@ public class AiCostDecision extends CostDecisionMakerBase {
             return PaymentDecision.card(source);
         }
         else if (type.equals("Hand")) {
+            if (hand.size() > 1 && ability.getActivatingPlayer() != null) {
+                hand = ability.getActivatingPlayer().getController().orderMoveToZoneList(hand, ZoneType.Graveyard);
+            }
             return PaymentDecision.card(hand);
         }
 
@@ -95,7 +98,11 @@ public class AiCostDecision extends CostDecisionMakerBase {
         }
 
         if (type.equals("Random")) {
-            return PaymentDecision.card(CardLists.getRandomSubList(new CardCollection(hand), c));
+            CardCollectionView randomSubset = CardLists.getRandomSubList(new CardCollection(hand), c);
+            if (randomSubset.size() > 1 && ability.getActivatingPlayer() != null) {
+                randomSubset = ability.getActivatingPlayer().getController().orderMoveToZoneList(randomSubset, ZoneType.Graveyard);
+            }
+            return PaymentDecision.card(randomSubset);
         }
         else {
             final AiController aic = ((PlayerControllerAi)player.getController()).getAi();
@@ -340,6 +347,9 @@ public class AiCostDecision extends CostDecisionMakerBase {
                 if (source.getName().equals("Maralen of the Mornsong Avatar")) {
                     return PaymentDecision.number(2);
                 }
+                if (source.getName().equals("Necrologia")) {
+                    return PaymentDecision.number(Integer.parseInt(ability.getSVar("ChosenX")));
+                }
                 return null;
             } else {
                 c = AbilityUtils.calculateAmount(source, cost.getAmount(), ability);
@@ -373,6 +383,9 @@ public class AiCostDecision extends CostDecisionMakerBase {
 
     @Override
     public PaymentDecision visit(CostPutCardToLib cost) {
+        if (cost.payCostFromSource()) {
+            return PaymentDecision.card(source);
+        }
         Integer c = cost.convertAmount();
         final Game game = player.getGame();
         CardCollection chosen = new CardCollection();
@@ -469,7 +482,7 @@ public class AiCostDecision extends CostDecisionMakerBase {
         CardCollectionView totap;
         if (isVehicle) {
             totalP = type.split("withTotalPowerGE")[1];
-            type = type.replace("+withTotalPowerGE" + totalP, "");
+            type = TextUtil.fastReplace(type, "+withTotalPowerGE", "");
             totap = ComputerUtil.chooseTapTypeAccumulatePower(player, type, ability, !cost.canTapSource, Integer.parseInt(totalP), tapped);
         } else {
             totap = ComputerUtil.chooseTapType(player, type, source, !cost.canTapSource, c, tapped);
@@ -497,6 +510,15 @@ public class AiCostDecision extends CostDecisionMakerBase {
         Integer c = cost.convertAmount();
         if (c == null) {
             if (ability.getSVar(cost.getAmount()).equals("XChoice")) {
+                if ("SacToReduceCost".equals(ability.getParam("AILogic"))) {
+                    // e.g. Torgaar, Famine Incarnate
+                    // TODO: currently returns an empty list, so the AI doesn't sacrifice anything. Trying to make
+                    // the AI decide on creatures to sac makes the AI sacrifice them, but the cost is not reduced and the
+                    // AI pays the full mana cost anyway (despite sacrificing creatures).
+                    return PaymentDecision.card(new CardCollection());
+                }
+
+                // Other cards are assumed to be flagged RemAIDeck for now
                 return null;
             }
 

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

@@ -21,6 +21,7 @@ import forge.LobbyPlayer;
 import forge.util.Aggregates;
 import forge.util.FileUtil;
 
+import forge.util.TextUtil;
 import org.apache.commons.lang3.ArrayUtils;
 
 import java.io.File;
@@ -52,7 +53,7 @@ public class AiProfileUtil {
      * @return the full relative path and file name for the given profile.
      */
     private static String buildFileName(final String profileName) {
-        return String.format("%s/%s%s", AI_PROFILE_DIR, profileName, AI_PROFILE_EXT);
+        return TextUtil.concatNoSpace(AI_PROFILE_DIR, "/", profileName, AI_PROFILE_EXT);
     }
     
     /**

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

@@ -29,20 +29,51 @@ public enum AiProps { /** */
     DEFAULT_PLANAR_DIE_ROLL_CHANCE ("50"), /** */
     MULLIGAN_THRESHOLD ("5"), /** */
     PLANAR_DIE_ROLL_HESITATION_CHANCE ("10"),
+    HOLD_LAND_DROP_FOR_MAIN2_IF_UNUSED ("0"), /** */
+    HOLD_LAND_DROP_ONLY_IF_HAVE_OTHER_PERMS ("true"), /** */
     CHEAT_WITH_MANA_ON_SHUFFLE ("false"),
     MOVE_EQUIPMENT_TO_BETTER_CREATURES ("from_useless_only"),
     MOVE_EQUIPMENT_CREATURE_EVAL_THRESHOLD ("60"),
     PRIORITIZE_MOVE_EQUIPMENT_IF_USELESS ("true"),
     PREDICT_SPELLS_FOR_MAIN2 ("true"), /** */
     RESERVE_MANA_FOR_MAIN2_CHANCE ("0"), /** */
-    PLAY_AGGRO ("false"), /** */
-    MIN_SPELL_CMC_TO_COUNTER ("0"),
+    PLAY_AGGRO ("false"),
+    CHANCE_TO_ATTACK_INTO_TRADE ("40"), /** */
+    RANDOMLY_ATKTRADE_ONLY_ON_LOWER_LIFE_PRESSURE ("true"), /** */
+    ATTACK_INTO_TRADE_WHEN_TAPPED_OUT ("false"), /** */
+    CHANCE_TO_ATKTRADE_WHEN_OPP_HAS_MANA ("0"), /** */
+    TRY_TO_AVOID_ATTACKING_INTO_CERTAIN_BLOCK ("true"), /** */
+    TRY_TO_HOLD_COMBAT_TRICKS_UNTIL_BLOCK ("false"), /** */
+    CHANCE_TO_HOLD_COMBAT_TRICKS_UNTIL_BLOCK ("30"), /** */
+    ENABLE_RANDOM_FAVORABLE_TRADES_ON_BLOCK ("true"), /** */
+    RANDOMLY_TRADE_EVEN_WHEN_HAVE_LESS_CREATS ("false"), /** */
+    MAX_DIFF_IN_CREATURE_COUNT_TO_TRADE ("1"), /** */
+    ALSO_TRADE_WHEN_HAVE_A_REPLACEMENT_CREAT ("true"), /** */
+    MAX_DIFF_IN_CREATURE_COUNT_TO_TRADE_WITH_REPL ("1"), /** */
+    MIN_CHANCE_TO_RANDOMLY_TRADE_ON_BLOCK ("30"), /** */
+    MAX_CHANCE_TO_RANDOMLY_TRADE_ON_BLOCK ("70"), /** */
+    CHANCE_DECREASE_TO_TRADE_VS_EMBALM ("30"), /** */
+    CHANCE_TO_TRADE_TO_SAVE_PLANESWALKER ("70"), /** */
+    CHANCE_TO_TRADE_DOWN_TO_SAVE_PLANESWALKER ("0"), /** */
+    THRESHOLD_TOKEN_CHUMP_TO_SAVE_PLANESWALKER ("135"), /** */
+    THRESHOLD_NONTOKEN_CHUMP_TO_SAVE_PLANESWALKER ("110"), /** */
+    CHUMP_TO_SAVE_PLANESWALKER_ONLY_ON_LETHAL ("true"), /** */
+    MIN_SPELL_CMC_TO_COUNTER ("0"), /** */
+    CHANCE_TO_COUNTER_CMC_1 ("50"), /** */
+    CHANCE_TO_COUNTER_CMC_2 ("75"), /** */
+    CHANCE_TO_COUNTER_CMC_3 ("100"), /** */
     ALWAYS_COUNTER_OTHER_COUNTERSPELLS ("true"), /** */
     ALWAYS_COUNTER_DAMAGE_SPELLS ("true"), /** */
     ALWAYS_COUNTER_CMC_0_MANA_MAKING_PERMS ("true"), /** */
     ALWAYS_COUNTER_REMOVAL_SPELLS ("true"), /** */
+    ALWAYS_COUNTER_PUMP_SPELLS ("true"), /** */
+    ALWAYS_COUNTER_AURAS ("true"), /** */
     ALWAYS_COUNTER_SPELLS_FROM_NAMED_CARDS (""), /** */
-    ACTIVELY_DESTROY_ARTS_AND_NONAURA_ENCHS ("false"), /** */
+    ACTIVELY_DESTROY_ARTS_AND_NONAURA_ENCHS ("true"), /** */
+    ACTIVELY_DESTROY_IMMEDIATELY_UNBLOCKABLE ("false"), /** */
+    DESTROY_IMMEDIATELY_UNBLOCKABLE_THRESHOLD ("2"), /** */
+    DESTROY_IMMEDIATELY_UNBLOCKABLE_ONLY_IN_DNGR ("true"), /** */
+    DESTROY_IMMEDIATELY_UNBLOCKABLE_LIFE_IN_DNGR ("5"), /** */
     PRIORITY_REDUCTION_FOR_STORM_SPELLS ("0"), /** */
     USE_BERSERK_AGGRESSIVELY ("false"), /** */
     MIN_COUNT_FOR_STORM_SPELLS ("0"), /** */
@@ -50,7 +81,35 @@ public enum AiProps { /** */
     STRIPMINE_MIN_LANDS_FOR_NO_TIMING_CHECK ("3"), /** */
     STRIPMINE_MIN_LANDS_OTB_FOR_NO_TEMPO_CHECK ("6"), /** */
     STRIPMINE_MAX_LANDS_TO_ATTEMPT_MANALOCKING ("3"), /** */
-    STRIPMINE_HIGH_PRIORITY_ON_SKIPPED_LANDDROP ("false"); /** */
+    STRIPMINE_HIGH_PRIORITY_ON_SKIPPED_LANDDROP ("false"),
+    TOKEN_GENERATION_ABILITY_CHANCE ("80"), /** */
+    TOKEN_GENERATION_ALWAYS_IF_FROM_PLANESWALKER ("true"), /** */
+    TOKEN_GENERATION_ALWAYS_IF_OPP_ATTACKS ("true"), /** */
+    SCRY_NUM_LANDS_TO_STILL_NEED_MORE ("4"), /** */
+    SCRY_NUM_LANDS_TO_NOT_NEED_MORE ("7"), /** */
+    SCRY_NUM_CREATURES_TO_NOT_NEED_SUBPAR_ONES ("4"), /** */
+    SCRY_EVALTHR_CREATCOUNT_TO_SCRY_AWAY_LOWCMC ("3"), /** */
+    SCRY_EVALTHR_TO_SCRY_AWAY_LOWCMC_CREATURE ("160"), /** */
+    SCRY_EVALTHR_CMC_THRESHOLD ("3"), /** */
+    SCRY_IMMEDIATELY_UNCASTABLE_TO_BOTTOM ("false"), /** */
+    SCRY_IMMEDIATELY_UNCASTABLE_CMC_DIFF ("1"), /** */
+    COMBAT_ASSAULT_ATTACK_EVASION_PREDICTION ("true"), /** */
+    COMBAT_ATTRITION_ATTACK_EVASION_PREDICTION ("true"), /** */
+    CONSERVATIVE_ENERGY_PAYMENT_ONLY_IN_COMBAT ("true"), /** */
+    CONSERVATIVE_ENERGY_PAYMENT_ONLY_DEFENSIVELY ("true"), /** */
+    BOUNCE_ALL_TO_HAND_CREAT_EVAL_DIFF ("200"), /** */
+    BOUNCE_ALL_ELSEWHERE_CREAT_EVAL_DIFF ("200"), /** */
+    BOUNCE_ALL_TO_HAND_NONCREAT_EVAL_DIFF ("3"), /** */
+    BOUNCE_ALL_ELSEWHERE_NONCREAT_EVAL_DIFF ("3"), /** */
+    INTUITION_ALTERNATIVE_LOGIC ("false"), /** */
+    EXPLORE_MAX_CMC_DIFF_TO_PUT_IN_GRAVEYARD ("2"),
+    EXPLORE_NUM_LANDS_TO_STILL_NEED_MORE("2"), /** */
+    MOJHOSTO_NUM_LANDS_TO_ACTIVATE_JHOIRA("5"), /** */
+    // Experimental features, must be removed after extensive testing and, ideally, defaulting
+    // <-- There are no experimental options here -->
+    AI_IN_DANGER_THRESHOLD("4"),
+    AI_IN_DANGER_MAX_THRESHOLD("4");
+
 
     private final String strDefaultVal;
 

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

@@ -17,23 +17,9 @@
  */
 package forge.ai;
 
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.List;
-import java.util.Map;
-import java.util.Random;
-
-import org.apache.commons.lang3.StringUtils;
-
 import com.google.common.base.Predicate;
 import com.google.common.base.Predicates;
-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.Multimap;
-
+import com.google.common.collect.*;
 import forge.ai.ability.ProtectAi;
 import forge.ai.ability.TokenAi;
 import forge.card.CardType;
@@ -46,32 +32,17 @@ import forge.game.ability.AbilityFactory;
 import forge.game.ability.AbilityUtils;
 import forge.game.ability.ApiType;
 import forge.game.ability.effects.CharmEffect;
-import forge.game.card.Card;
-import forge.game.card.CardCollection;
-import forge.game.card.CardCollectionView;
-import forge.game.card.CardLists;
-import forge.game.card.CardPredicates;
+import forge.game.card.*;
 import forge.game.card.CardPredicates.Presets;
-import forge.game.card.CardUtil;
-import forge.game.card.CounterType;
 import forge.game.combat.Combat;
 import forge.game.combat.CombatUtil;
-import forge.game.cost.Cost;
-import forge.game.cost.CostDiscard;
-import forge.game.cost.CostPart;
-import forge.game.cost.CostPayment;
-import forge.game.cost.CostPutCounter;
-import forge.game.cost.CostSacrifice;
+import forge.game.cost.*;
 import forge.game.phase.PhaseHandler;
 import forge.game.phase.PhaseType;
 import forge.game.player.Player;
 import forge.game.replacement.ReplacementEffect;
 import forge.game.replacement.ReplacementLayer;
-import forge.game.spellability.AbilityManaPart;
-import forge.game.spellability.AbilitySub;
-import forge.game.spellability.SpellAbility;
-import forge.game.spellability.SpellAbilityStackInstance;
-import forge.game.spellability.TargetRestrictions;
+import forge.game.spellability.*;
 import forge.game.staticability.StaticAbility;
 import forge.game.trigger.Trigger;
 import forge.game.trigger.TriggerType;
@@ -79,7 +50,11 @@ import forge.game.zone.Zone;
 import forge.game.zone.ZoneType;
 import forge.util.Aggregates;
 import forge.util.MyRandom;
+import forge.util.TextUtil;
 import forge.util.collect.FCollection;
+import org.apache.commons.lang3.StringUtils;
+
+import java.util.*;
 
 
 /**
@@ -99,16 +74,28 @@ public class ComputerUtil {
         final Card source = sa.getHostCard();
 
         if (sa.isSpell() && !source.isCopiedSpell()) {
+            if (source.getType().hasStringType("Arcane")) {
+                sa = AbilityUtils.addSpliceEffects(sa);
+                if (sa.getSplicedCards() != null && !sa.getSplicedCards().isEmpty() && ai.getController().isAI()) {
+                    // we need to reconsider and retarget the SA after additional SAs have been added onto it via splice,
+                    // otherwise the AI will fail to add the card to stack and that'll knock it out of the game
+                    sa.resetTargets();
+                    if (((PlayerControllerAi) ai.getController()).getAi().canPlaySa(sa) != AiPlayDecision.WillPlay) {
+                        // for whatever reason the AI doesn't want to play the thing with the spliced subs anymore,
+                        // proceeding past this point may result in an illegal play
+                        return false;
+                    }
+                }
+            }
+
             source.setCastSA(sa);
             sa.setLastStateBattlefield(game.getLastStateBattlefield());
             sa.setLastStateGraveyard(game.getLastStateGraveyard());
             sa.setHostCard(game.getAction().moveToStack(source, sa));
-
-            if (source.getType().hasStringType("Arcane")) {
-                sa = AbilityUtils.addSpliceEffects(sa);
-            }
         }
 
+        sa.resetPaidHash();
+
         if (sa.getApi() == ApiType.Charm && !sa.isWrapper()) {
             CharmEffect.makeChoices(sa);
         }
@@ -192,7 +179,7 @@ public class ComputerUtil {
         if (unless != null && !unless.endsWith(">")) {
             final int amount = AbilityUtils.calculateAmount(source, unless, sa);
 
-            final int usableManaSources = ComputerUtilMana.getAvailableMana(ComputerUtil.getOpponentFor(ai), true).size();
+            final int usableManaSources = ComputerUtilMana.getAvailableManaSources(ComputerUtil.getOpponentFor(ai), true).size();
 
             // If the Unless isn't enough, this should be less likely to be used
             if (amount > usableManaSources) {
@@ -310,43 +297,46 @@ public class ComputerUtil {
 
     public static Card getCardPreference(final Player ai, final Card activate, final String pref, final CardCollection typeList) {
         final Game game = ai.getGame();
+        String prefDef = "";
         if (activate != null) {
+            prefDef = activate.getSVar("AIPreference");
             final String[] prefGroups = activate.getSVar("AIPreference").split("\\|");
             for (String prefGroup : prefGroups) {
                 final String[] prefValid = prefGroup.trim().split("\\$");
-                if (prefValid[0].equals(pref)) {
-                    final CardCollection prefList = CardLists.getValidCards(typeList, prefValid[1].split(","), activate.getController(), activate, null);
+                if (prefValid[0].equals(pref) && !prefValid[1].startsWith("Special:")) {
                     CardCollection overrideList = null;
-
                     if (activate.hasSVar("AIPreferenceOverride")) {
                         overrideList = CardLists.getValidCards(typeList, activate.getSVar("AIPreferenceOverride"), activate.getController(), activate, null);
                     }
 
-                    int threshold = getAIPreferenceParameter(activate, "CreatureEvalThreshold");
-                    int minNeeded = getAIPreferenceParameter(activate, "MinCreaturesBelowThreshold");
+                    for (String validItem : prefValid[1].split(",")) {
+                        final CardCollection prefList = CardLists.getValidCards(typeList, validItem, activate.getController(), activate, null);
+                        int threshold = getAIPreferenceParameter(activate, "CreatureEvalThreshold");
+                        int minNeeded = getAIPreferenceParameter(activate, "MinCreaturesBelowThreshold");
 
-                    if (threshold != -1) {
-                        List<Card> toRemove = Lists.newArrayList();
-                        for (Card c : prefList) {
-                            if (c.isCreature()) {
-                                if (ComputerUtilCard.isUselessCreature(ai, c) || ComputerUtilCard.evaluateCreature(c) <= threshold) {
-                                    continue;
-                                } else if (ComputerUtilCard.hasActiveUndyingOrPersist(c)) {
-                                    continue;
+                        if (threshold != -1) {
+                            List<Card> toRemove = Lists.newArrayList();
+                            for (Card c : prefList) {
+                                if (c.isCreature()) {
+                                    if (ComputerUtilCard.isUselessCreature(ai, c) || ComputerUtilCard.evaluateCreature(c) <= threshold) {
+                                        continue;
+                                    } else if (ComputerUtilCard.hasActiveUndyingOrPersist(c)) {
+                                        continue;
+                                    }
+                                    toRemove.add(c);
                                 }
-                                toRemove.add(c);
+                            }
+                            prefList.removeAll(toRemove);
+                        }
+                        if (minNeeded != -1) {
+                            if (prefList.size() < minNeeded) {
+                                return null;
                             }
                         }
-                        prefList.removeAll(toRemove);
-                    }
-                    if (minNeeded != -1) {
-                        if (prefList.size() < minNeeded) {
-                            return null;
-                        }
-                    }
 
-                    if (!prefList.isEmpty()) {
-                        return ComputerUtilCard.getWorstAI(overrideList == null ? prefList : overrideList);
+                        if (!prefList.isEmpty() || (overrideList != null && !overrideList.isEmpty())) {
+                            return ComputerUtilCard.getWorstAI(overrideList == null ? prefList : overrideList);
+                        }
                     }
                 }
             }
@@ -411,6 +401,11 @@ public class ComputerUtil {
                 }
             }
 
+            // Survival of the Fittest logic
+            if (prefDef.contains("DiscardCost$Special:SurvivalOfTheFittest")) {
+                return SpecialCardAi.SurvivalOfTheFittest.considerDiscardTarget(ai);
+            }
+
             // Discard lands
             final CardCollection landsInHand = CardLists.getType(typeList, "Land");
             if (!landsInHand.isEmpty()) {
@@ -707,6 +702,8 @@ public class ComputerUtil {
                 return sacrificed; // sacrifice none
             }
         }
+        boolean exceptSelf = "ExceptSelf".equals(source.getParam("AILogic"));
+        boolean removedSelf = false;
 
         if (isOptional && source.hasParam("Devour") || source.hasParam("Exploit") || considerSacLogic) {
         	if (source.hasParam("Exploit")) {
@@ -764,11 +761,22 @@ public class ComputerUtil {
 
         final int max = Math.min(remaining.size(), amount);
 
+        if (exceptSelf) {
+            removedSelf = remaining.remove(source.getHostCard());
+        }
+
         for (int i = 0; i < max; i++) {
             Card c = chooseCardToSacrifice(remaining, ai, destroy);
             remaining.remove(c);
-            sacrificed.add(c);
+            if (c != null) {
+                sacrificed.add(c);
+            }
         }
+
+        if (sacrificed.isEmpty() && removedSelf) {
+            sacrificed.add(source.getHostCard());
+        }
+
         return sacrificed;
     }
 
@@ -848,11 +856,11 @@ public class ComputerUtil {
                                 continue; // Won't play ability
                             }
 
-                            if (!ComputerUtilCost.checkSacrificeCost(controller, abCost, c)) {
+                            if (!ComputerUtilCost.checkSacrificeCost(controller, abCost, c, sa)) {
                                 continue; // Won't play ability
                             }
 
-                            if (!ComputerUtilCost.checkCreatureSacrificeCost(controller, abCost, c)) {
+                            if (!ComputerUtilCost.checkCreatureSacrificeCost(controller, abCost, c, sa)) {
                                 continue; // Won't play ability
                             }
                         }
@@ -868,7 +876,7 @@ public class ComputerUtil {
                     }
 
                 }  catch (final Exception ex) {
-                    throw new RuntimeException(String.format("There is an error in the card code for %s:%s", c.getName(), ex.getMessage()), ex);
+                    throw new RuntimeException(TextUtil.concatNoSpace("There is an error in the card code for ", c.getName(), ":", ex.getMessage()), ex);
                 } 
             }
         }
@@ -907,7 +915,7 @@ public class ComputerUtil {
                         }
                     }
                 } catch (final Exception ex) {
-                    throw new RuntimeException(String.format("There is an error in the card code for %s:%s", c.getName(), ex.getMessage()), ex);
+                    throw new RuntimeException(TextUtil.concatNoSpace("There is an error in the card code for ", c.getName(), ":", ex.getMessage()), ex);
                 }
             }
         }
@@ -917,16 +925,12 @@ public class ComputerUtil {
     public static boolean castPermanentInMain1(final Player ai, final SpellAbility sa) {
         final Card card = sa.getHostCard();
 
-        if ("True".equals(card.getSVar("NonStackingEffect")) && card.getController().isCardInPlay(card.getName())) {
-            return false;
-        }
-
         if (card.hasSVar("PlayMain1")) {
         	if (card.getSVar("PlayMain1").equals("ALWAYS") || sa.getPayCosts().hasNoManaCost()) {
         		return true;
         	} else if (card.getSVar("PlayMain1").equals("OPPONENTCREATURES")) {
         		//Only play these main1 when the opponent has creatures (stealing and giving them haste)
-        		if (!ComputerUtil.getOpponentFor(card.getController()).getCreaturesInPlay().isEmpty()) {
+        		if (!ai.getOpponents().getCreaturesInPlay().isEmpty()) {
         			return true;
         		}
         	} else if (!card.getController().getCreaturesInPlay().isEmpty()) {
@@ -934,11 +938,21 @@ public class ComputerUtil {
         	}
         }
 
+        // try not to cast Raid creatures in main 1 if an attack is likely
+        if ("Count$AttackersDeclared".equals(card.getSVar("RaidTest")) && !card.hasKeyword("Haste")) {
+            for (Card potentialAtkr: ai.getCreaturesInPlay()) {
+                if (ComputerUtilCard.doesCreatureAttackAI(ai, potentialAtkr)) {
+                    return false;
+                }
+            }
+        }
+
         if (card.getManaCost().isZero()) {
         	return true;
         }
 
-        if (card.isCreature() && !card.hasKeyword("Defender") && (card.hasKeyword("Haste") || ComputerUtil.hasACardGivingHaste(ai) || sa.isDash())) {
+        if (card.isCreature() && !card.hasKeyword("Defender")
+                && (card.hasKeyword("Haste") || ComputerUtil.hasACardGivingHaste(ai, true) || sa.isDash())) {
             return true;
         }
         
@@ -1111,6 +1125,10 @@ public class ComputerUtil {
         final Card source = sa.getHostCard();
         final SpellAbility sub = sa.getSubAbility();
 
+        if (source != null && "ALWAYS".equals(source.getSVar("PlayMain1"))) {
+            return true;
+        }
+
         // Cipher spells
         if (sub != null) {
             final ApiType api = sub.getApi();
@@ -1168,16 +1186,14 @@ public class ComputerUtil {
         int activations = sa.getRestrictions().getNumberTurnActivations();
 
         if (sa.isTemporary()) {
-        	final Random r = MyRandom.getRandom();
-        	return r.nextFloat() >= .95; // Abilities created by static abilities have no memory
+        	return MyRandom.getRandom().nextFloat() >= .95; // Abilities created by static abilities have no memory
         }
 
         if (activations < 10) { //10 activations per turn should still be acceptable
             return false;
         }
 
-        final Random r = MyRandom.getRandom();
-        return r.nextFloat() >= Math.pow(.95, activations);
+        return MyRandom.getRandom().nextFloat() >= Math.pow(.95, activations);
     }
 
     public static boolean activateForCost(SpellAbility sa, final Player ai) {
@@ -1220,8 +1236,8 @@ public class ComputerUtil {
         return false;
     }
 
-    public static boolean hasACardGivingHaste(final Player ai) {
-        final CardCollection all = new CardCollection(ai.getCardsIn(ZoneType.Battlefield));
+    public static boolean hasACardGivingHaste(final Player ai, final boolean checkOpponentCards) {
+        final CardCollection all = new CardCollection(ai.getCardsIn(Lists.newArrayList(ZoneType.Battlefield, ZoneType.Command)));
 
         // Special for Anger
         if (!ai.getGame().isCardInPlay("Yixlid Jailer")
@@ -1288,6 +1304,28 @@ public class ComputerUtil {
                 }
             }
         }
+
+        if (checkOpponentCards) {
+            // Check if the opponents have any cards giving Haste to all creatures on the battlefield
+            CardCollection opp = new CardCollection();
+            opp.addAll(ai.getOpponents().getCardsIn(ZoneType.Battlefield));
+            opp.addAll(ai.getOpponents().getCardsIn(ZoneType.Command));
+
+            for (final Card c : opp) {
+                for (StaticAbility stAb : c.getStaticAbilities()) {
+                    Map<String, String> params = stAb.getMapParams();
+                    if ("Continuous".equals(params.get("Mode")) && params.containsKey("AddKeyword")
+                            && params.get("AddKeyword").contains("Haste")) {
+
+                        final ArrayList affected = Lists.newArrayList(params.get("Affected").split(","));
+                        if (affected.contains("Creature")) {
+                            return true;
+                        }
+                    }
+                }
+            }
+        }
+
         return false;
     }
 
@@ -1436,17 +1474,26 @@ public class ComputerUtil {
             objects = canBeTargeted;
         }
 
-        if (saviourApi == ApiType.Pump || saviourApi == ApiType.PumpAll) {
-            toughness = saviour.hasParam("NumDef") ? 
-                    AbilityUtils.calculateAmount(saviour.getHostCard(), saviour.getParam("NumDef"), saviour) : 0;
-            final List<String> keywords = saviour.hasParam("KW") ? 
-                            Arrays.asList(saviour.getParam("KW").split(" & ")) : new ArrayList<String>();
-            if (keywords.contains("Indestructible")) {
-                grantIndestructible = true;
-            }
-            if (keywords.contains("Hexproof") || keywords.contains("Shroud")) {
-                grantShroud = true;
+        SpellAbility saviorWithSubs = saviour;
+        ApiType saviorWithSubsApi = saviorWithSubs == null ? null : saviorWithSubs.getApi();
+        while (saviorWithSubs != null) {
+            ApiType curApi = saviorWithSubs.getApi();
+            if (curApi == ApiType.Pump || curApi == ApiType.PumpAll) {
+                toughness = saviorWithSubs.hasParam("NumDef") ?
+                        AbilityUtils.calculateAmount(saviorWithSubs.getHostCard(), saviorWithSubs.getParam("NumDef"), saviour) : 0;
+                final List<String> keywords = saviorWithSubs.hasParam("KW") ?
+                        Arrays.asList(saviorWithSubs.getParam("KW").split(" & ")) : new ArrayList<String>();
+                if (keywords.contains("Indestructible")) {
+                    grantIndestructible = true;
+                }
+                if (keywords.contains("Hexproof") || keywords.contains("Shroud")) {
+                    grantShroud = true;
+                }
+                break;
             }
+            // Consider pump in subabilities, e.g. Bristling Hydra hexproof subability
+            saviorWithSubs = saviorWithSubs.getSubAbility();
+
         }
 
         if (saviourApi == ApiType.PutCounter || saviourApi == ApiType.PutCounterAll) {
@@ -1590,7 +1637,8 @@ public class ComputerUtil {
                 && (((saviourApi == ApiType.Regenerate || saviourApi == ApiType.RegenerateAll)
                         && !topStack.hasParam("NoRegen")) || saviourApi == ApiType.ChangeZone
                         || saviourApi == ApiType.Pump || saviourApi == ApiType.PumpAll
-                        || saviourApi == ApiType.Protection || saviourApi == null)) {
+                        || saviourApi == ApiType.Protection || saviourApi == null
+                        || saviorWithSubsApi == ApiType.Pump || saviorWithSubsApi == ApiType.PumpAll)) {
             for (final Object o : objects) {
                 if (o instanceof Card) {
                     final Card c = (Card) o;
@@ -1604,7 +1652,9 @@ public class ComputerUtil {
                         continue;
                     }
 
-                    if (saviourApi == ApiType.Pump || saviourApi == ApiType.PumpAll) {
+                    if (saviourApi == ApiType.Pump || saviourApi == ApiType.PumpAll
+                            || saviorWithSubsApi == ApiType.Pump
+                            || saviorWithSubsApi == ApiType.PumpAll) {
                         if ((tgt == null && !grantIndestructible)
                                 || (!grantShroud && !grantIndestructible)) {
                             continue;
@@ -1857,6 +1907,27 @@ public class ComputerUtil {
     public static boolean scryWillMoveCardToBottomOfLibrary(Player player, Card c) {
         boolean bottom = false;
 
+        // AI profile-based toggles
+        int maxLandsToScryLandsToTop = 3;
+        int minLandsToScryLandsAway = 8;
+        int minCreatsToScryCreatsAway = 5;
+        int minCreatEvalThreshold = 160; // just a bit higher than a baseline 2/2 creature or a 1/1 mana dork
+        int lowCMCThreshold = 3;
+        int maxCreatsToScryLowCMCAway = 3;
+        boolean uncastablesToBottom = false;
+        int uncastableCMCThreshold = 1;
+        if (player.getController().isAI()) {
+            AiController aic = ((PlayerControllerAi)player.getController()).getAi();
+            maxLandsToScryLandsToTop = aic.getIntProperty(AiProps.SCRY_NUM_LANDS_TO_STILL_NEED_MORE);
+            minLandsToScryLandsAway = aic.getIntProperty(AiProps.SCRY_NUM_LANDS_TO_NOT_NEED_MORE);
+            minCreatsToScryCreatsAway = aic.getIntProperty(AiProps.SCRY_NUM_CREATURES_TO_NOT_NEED_SUBPAR_ONES);
+            minCreatEvalThreshold = aic.getIntProperty(AiProps.SCRY_EVALTHR_TO_SCRY_AWAY_LOWCMC_CREATURE);
+            lowCMCThreshold = aic.getIntProperty(AiProps.SCRY_EVALTHR_CMC_THRESHOLD);
+            maxCreatsToScryLowCMCAway = aic.getIntProperty(AiProps.SCRY_EVALTHR_CREATCOUNT_TO_SCRY_AWAY_LOWCMC);
+            uncastablesToBottom = aic.getBooleanProperty(AiProps.SCRY_IMMEDIATELY_UNCASTABLE_TO_BOTTOM);
+            uncastableCMCThreshold = aic.getIntProperty(AiProps.SCRY_IMMEDIATELY_UNCASTABLE_CMC_DIFF);
+        }
+
         CardCollectionView allCards = player.getAllCards();
         CardCollectionView cardsInHand = player.getCardsIn(ZoneType.Hand);
         CardCollectionView cardsOTB = player.getCardsIn(ZoneType.Battlefield);
@@ -1871,8 +1942,9 @@ public class ComputerUtil {
         CardCollectionView allCreatures = CardLists.filter(allCards, Predicates.and(CardPredicates.Presets.CREATURES, CardPredicates.isOwner(player)));
         int numCards = allCreatures.size();
 
-        if (landsOTB.size() < 3 && landsInHand.isEmpty()) {
-            if ((!c.isLand() && !manaArts.contains(c.getName())) || c.getManaAbilities().isEmpty()) {
+        if (landsOTB.size() < maxLandsToScryLandsToTop && landsInHand.isEmpty()) {
+            if ((!c.isLand() && !manaArts.contains(c.getName()))
+                    || (c.getManaAbilities().isEmpty() && !c.hasABasicLandType())) {
                 // scry away non-lands and non-manaproducing lands in situations when the land count
                 // on the battlefield is low, to try to improve the mana base early
                 bottom = true;
@@ -1880,7 +1952,7 @@ public class ComputerUtil {
         }
 
         if (c.isLand()) {
-            if (landsOTB.size() >= 8) {
+            if (landsOTB.size() >= minLandsToScryLandsAway) {
                 // probably enough lands not to urgently need another one, so look for more gas instead
                 bottom = true;
             } else if (landsInHand.size() >= Math.max(cardsInHand.size() / 2, 2)) {
@@ -1898,16 +1970,15 @@ public class ComputerUtil {
         } else if (c.isCreature()) {
             CardCollection creaturesOTB = CardLists.filter(cardsOTB, CardPredicates.Presets.CREATURES);
             int avgCreatureValue = numCards != 0 ? ComputerUtilCard.evaluateCreatureList(allCreatures) / numCards : 0;
-            int minCreatEvalThreshold = 160; // just a bit higher than a baseline 2/2 creature or a 1/1 mana dork
             int maxControlledCMC = Aggregates.max(creaturesOTB, CardPredicates.Accessors.fnGetCmc);
 
             if (ComputerUtilCard.evaluateCreature(c) < avgCreatureValue) {
-                if (creaturesOTB.size() > 5) {
+                if (creaturesOTB.size() > minCreatsToScryCreatsAway) {
                     // if there are more than five creatures and the creature is question is below average for
                     // the deck, scry it to the bottom
                     bottom = true;
-                } else if (creaturesOTB.size() > 3 && c.getCMC() <= 3
-                        && maxControlledCMC >= 4 && ComputerUtilCard.evaluateCreature(c) <= minCreatEvalThreshold) {
+                } else if (creaturesOTB.size() > maxCreatsToScryLowCMCAway && c.getCMC() <= lowCMCThreshold
+                        && maxControlledCMC >= lowCMCThreshold + 1 && ComputerUtilCard.evaluateCreature(c) <= minCreatEvalThreshold) {
                     // if we are already at a stage when we have 4+ CMC creatures on the battlefield,
                     // probably worth it to scry away very low value creatures with low CMC
                     bottom = true;
@@ -1915,6 +1986,15 @@ public class ComputerUtil {
             }
         }
 
+        if (uncastablesToBottom && !c.isLand()) {
+            int cmc = c.isSplitCard() ? Math.min(c.getCMC(Card.SplitCMCMode.LeftSplitCMC), c.getCMC(Card.SplitCMCMode.RightSplitCMC))
+                    : c.getCMC();
+            int maxCastable = ComputerUtilMana.getAvailableManaEstimate(player, false) + landsInHand.size();
+            if (cmc - maxCastable >= uncastableCMCThreshold) {
+                bottom = true;
+            }
+        }
+
         return bottom;
     }
 
@@ -2685,21 +2765,122 @@ public class ComputerUtil {
     }
 
 
+    @Deprecated
     public static final Player getOpponentFor(final Player player) {
-        Player opponent = null;
-        int minLife = Integer.MAX_VALUE;
-
-        for (Player p : player.getOpponents()) {
-            if (p.getLife() < minLife) {
-                opponent = p;
-                minLife = p.getLife();
-            }
-        }
+        // This method is deprecated and currently functions as a synonym for player.getWeakestOpponent
+        // until it can be replaced everywhere in the code.
 
+        // Consider replacing calls to this method either with a multiplayer-friendly determination of
+        // opponent that contextually makes the most sense, or with a direct call to player.getWeakestOpponent
+        // where that is applicable and makes sense from the point of view of multiplayer AI logic.
+        Player opponent = player.getWeakestOpponent();
         if (opponent != null) {
             return opponent;
         }
 
         throw new IllegalStateException("No opponents left ingame for " + player);
     }
+
+    public static int countUsefulCreatures(Player p) {
+        CardCollection creats = p.getCreaturesInPlay();
+        int count = 0;
+
+        for (Card c : creats) {
+            if (!ComputerUtilCard.isUselessCreature(p, c)) {
+                count ++;
+            }
+        }
+
+        return count;
+    }
+
+    public static boolean isPlayingReanimator(final Player ai) {
+        // TODO: either add SVars to other reanimator cards, or improve the prediction so that it avoids using a SVar
+        // at all but detects this effect from SA parameters (preferred, but difficult)
+        CardCollectionView inHand = ai.getCardsIn(ZoneType.Hand);
+        CardCollectionView inDeck = ai.getCardsIn(new ZoneType[] {ZoneType.Hand, ZoneType.Library});
+
+        Predicate<Card> markedAsReanimator = new Predicate<Card>() {
+            @Override
+            public boolean apply(Card card) {
+                return "true".equalsIgnoreCase(card.getSVar("IsReanimatorCard"));
+            }
+        };
+
+        int numInHand = CardLists.filter(inHand, markedAsReanimator).size();
+        int numInDeck = CardLists.filter(inDeck, markedAsReanimator).size();
+
+        return numInHand > 0 || numInDeck >= 3;
+    }
+
+    public static CardCollection filterAITgts(SpellAbility sa, Player ai, CardCollection srcList, boolean alwaysStrict) {
+        final Card source = sa.getHostCard();
+        if (source == null) { return srcList; }
+
+        if (sa.hasParam("AITgts")) {
+            CardCollection list;
+            if (sa.getParam("AITgts").equals("BetterThanSource")) {
+                int value = ComputerUtilCard.evaluateCreature(source);
+                if (source.isEnchanted()) {
+                    for (Card enc : source.getEnchantedBy(false)) {
+                        if (enc.getController().equals(ai)) {
+                            value += 100; // is 100 per AI's own aura enough?
+                        }
+                    }
+                }
+                final int totalValue = value;
+                list = CardLists.filter(srcList, new Predicate<Card>() {
+                    @Override
+                    public boolean apply(final Card c) {
+                        return ComputerUtilCard.evaluateCreature(c) > totalValue + 30;
+                    }
+                });
+            } else {
+                list = CardLists.getValidCards(srcList, sa.getParam("AITgts"), sa.getActivatingPlayer(), source);
+            }
+
+            if (!list.isEmpty() || sa.hasParam("AITgtsStrict") || alwaysStrict) {
+                return list;
+            } else {
+                return srcList;
+            }
+        }
+
+        return srcList;
+    }
+
+    // Check if AI life is in danger/serious danger based on next expected combat
+    // assuming a loss of "payment" life
+    // call this to determine if it's safe to use a life payment spell
+    // or trigger "emergency" strategies such as holding mana for Spike Weaver of Counterspell.
+    public static boolean aiLifeInDanger(Player ai, boolean serious, int payment) {
+        Player opponent = ComputerUtil.getOpponentFor(ai);
+        // test whether the human can kill the ai next turn
+        Combat combat = new Combat(opponent);
+        boolean containsAttacker = false;
+        for (Card att : opponent.getCreaturesInPlay()) {
+            if (ComputerUtilCombat.canAttackNextTurn(att, ai)) {
+                combat.addAttacker(att, ai);
+                containsAttacker = true;
+            }
+        }
+        if (!containsAttacker) {
+            return false;
+        }
+        AiBlockController block = new AiBlockController(ai);
+        block.assignBlockersForCombat(combat);
+
+        // TODO predict other, noncombat sources of damage and add them to the "payment" variable.
+        // examples : Black Vise, The Rack, known direct damage spells in enemy hand, etc
+        // If added, might need a parameter to define whether we want to check all threats or combat threats.
+
+        if ((serious) && (ComputerUtilCombat.lifeInSeriousDanger(ai, combat, payment))) {
+            return true;
+        }
+        if ((!serious) && (ComputerUtilCombat.lifeInDanger(ai, combat, payment))) {
+            return true;
+        }
+        return false;
+
+    }
 }

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

@@ -1,13 +1,15 @@
 package forge.ai;
 
-import java.util.ArrayList;
+import java.util.Iterator;
 import java.util.List;
 
 import com.google.common.base.Predicate;
+import com.google.common.collect.Lists;
 
 import forge.card.CardStateName;
 import forge.game.Game;
 import forge.game.GameActionUtil;
+import forge.game.ability.ApiType;
 import forge.game.card.Card;
 import forge.game.card.CardCollection;
 import forge.game.card.CardCollectionView;
@@ -17,7 +19,6 @@ import forge.game.player.Player;
 import forge.game.spellability.SpellAbility;
 import forge.game.spellability.SpellAbilityStackInstance;
 import forge.game.zone.ZoneType;
-import java.util.Iterator;
 
 public class ComputerUtilAbility {
     public static CardCollection getAvailableLandsToPlay(final Game game, final Player player) {
@@ -78,7 +79,7 @@ public class ComputerUtilAbility {
     }
 
     public static List<SpellAbility> getSpellAbilities(final CardCollectionView l, final Player player) {
-        final List<SpellAbility> spellAbilities = new ArrayList<SpellAbility>();
+        final List<SpellAbility> spellAbilities = Lists.newArrayList();
         for (final Card c : l) {
             for (final SpellAbility sa : c.getSpellAbilities()) {
                 spellAbilities.add(sa);
@@ -93,7 +94,7 @@ public class ComputerUtilAbility {
     }
 
     public static List<SpellAbility> getOriginalAndAltCostAbilities(final List<SpellAbility> originList, final Player player) {
-        final List<SpellAbility> newAbilities = new ArrayList<SpellAbility>();
+        final List<SpellAbility> newAbilities = Lists.newArrayList();
         for (SpellAbility sa : originList) {
             sa.setActivatingPlayer(player);
             //add alternative costs as additional spell abilities
@@ -101,7 +102,7 @@ public class ComputerUtilAbility {
             newAbilities.addAll(GameActionUtil.getAlternativeCosts(sa, player));
         }
     
-        final List<SpellAbility> result = new ArrayList<SpellAbility>();
+        final List<SpellAbility> result = Lists.newArrayList();
         for (SpellAbility sa : newAbilities) {
             sa.setActivatingPlayer(player);
             result.addAll(GameActionUtil.getOptionalCosts(sa));
@@ -132,6 +133,42 @@ public class ComputerUtilAbility {
     }
 
     public static String getAbilitySourceName(SpellAbility sa) {
-        return sa.getOriginalHost() != null ? sa.getOriginalHost().getName() : sa.getHostCard() != null ? sa.getHostCard().getName() : "";
+        final Card c = getAbilitySource(sa);
+        return c != null ? c.getName() : "";
+    }
+
+    public static CardCollection getCardsTargetedWithApi(Player ai, CardCollection cardList, SpellAbility sa, ApiType api) {
+        // Returns a collection of cards which have already been targeted with the given API either in the parent ability,
+        // in the sub ability, or by something on stack. If "sa" is specified, the parent and sub abilities of this SA will
+        // be checked for targets. If "sa" is null, only the stack instances will be checked.
+        CardCollection targeted = new CardCollection();
+        if (sa != null) {
+            SpellAbility saSub = sa.getRootAbility();
+            while (saSub != null) {
+                if (saSub.getApi() == api && saSub.getTargets() != null) {
+                    for (Card c : cardList) {
+                        if (saSub.getTargets().getTargetCards().contains(c)) {
+                            // Was already targeted with this API in a parent or sub SA
+                            targeted.add(c);
+                        }
+                    }
+                }
+                saSub = saSub.getSubAbility();
+            }
+        }
+        for (SpellAbilityStackInstance si : ai.getGame().getStack()) {
+            SpellAbility ab = si.getSpellAbility(false);
+            if (ab != null && ab.getApi() == api && si.getTargetChoices() != null) {
+                for (Card c : cardList) {
+                    // TODO: somehow ensure that the detected SA won't be countered
+                    if (si.getTargetChoices().getTargetCards().contains(c)) {
+                        // Was already targeted by a spell ability instance on stack
+                        targeted.add(c);
+                    }
+                }
+            }
+        }
+
+        return targeted;
     }
 }

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

@@ -1,20 +1,9 @@
 package forge.ai;
 
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.Comparator;
-import java.util.List;
-import java.util.Map;
-import java.util.Map.Entry;
-import java.util.Set;
-
-import org.apache.commons.lang3.StringUtils;
-import org.apache.commons.lang3.tuple.MutablePair;
-import org.apache.commons.lang3.tuple.Pair;
-
 import com.google.common.base.Predicate;
 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;
@@ -29,19 +18,13 @@ import forge.game.GameObject;
 import forge.game.ability.AbilityFactory;
 import forge.game.ability.AbilityUtils;
 import forge.game.ability.ApiType;
-import forge.game.card.Card;
-import forge.game.card.CardCollection;
-import forge.game.card.CardCollectionView;
-import forge.game.card.CardFactory;
-import forge.game.card.CardFactoryUtil;
-import forge.game.card.CardLists;
-import forge.game.card.CardPredicates;
-import forge.game.card.CardUtil;
-import forge.game.card.CounterType;
+import forge.game.card.*;
 import forge.game.combat.Combat;
 import forge.game.combat.CombatUtil;
 import forge.game.cost.CostPayEnergy;
 import forge.game.keyword.Keyword;
+import forge.game.keyword.KeywordCollection;
+import forge.game.keyword.KeywordInterface;
 import forge.game.phase.PhaseHandler;
 import forge.game.phase.PhaseType;
 import forge.game.player.Player;
@@ -54,8 +37,14 @@ import forge.game.zone.MagicStack;
 import forge.game.zone.ZoneType;
 import forge.item.PaperCard;
 import forge.util.Aggregates;
+import forge.util.Expressions;
 import forge.util.MyRandom;
+import org.apache.commons.lang3.StringUtils;
+import org.apache.commons.lang3.tuple.MutablePair;
+import org.apache.commons.lang3.tuple.Pair;
 
+import java.util.*;
+import java.util.Map.Entry;
 
 public class ComputerUtilCard {
     public static Card getMostExpensivePermanentAI(final CardCollectionView list, final SpellAbility spell, final boolean targeted) {
@@ -107,14 +96,28 @@ public class ComputerUtilCard {
      * @return best Planeswalker
      */
     public static Card getBestPlaneswalkerAI(final List<Card> list) {
-        List<Card> all = CardLists.filter(list, CardPredicates.Presets.PLANEWALKERS);
-        if (all.size() == 0) {
+        List<Card> all = CardLists.filter(list, CardPredicates.Presets.PLANESWALKERS);
+        if (all.isEmpty()) {
             return null;
         }
         // no AI logic, just return most expensive
         return Aggregates.itemWithMax(all, CardPredicates.Accessors.fnGetCmc);
     }
 
+    /**
+     * Returns the worst Planeswalker from a given list
+     * @param list list of cards to evaluate
+     * @return best Planeswalker
+     */
+    public static Card getWorstPlaneswalkerAI(final List<Card> list) {
+        List<Card> all = CardLists.filter(list, CardPredicates.Presets.PLANESWALKERS);
+        if (all.isEmpty()) {
+            return null;
+        }
+        // no AI logic, just return least expensive
+        return Aggregates.itemWithMin(all, CardPredicates.Accessors.fnGetCmc);
+    }
+
     // The AI doesn't really pick the best enchantment, just the most expensive.
     /**
      * <p>
@@ -364,7 +367,12 @@ public class ComputerUtilCard {
         }
     
         if (hasEnchantmants || hasArtifacts) {
-            final List<Card> ae = CardLists.filter(list, Predicates.<Card>or(CardPredicates.Presets.ARTIFACTS, CardPredicates.Presets.ENCHANTMENTS));
+            final List<Card> ae = CardLists.filter(list, Predicates.and(Predicates.<Card>or(CardPredicates.Presets.ARTIFACTS, CardPredicates.Presets.ENCHANTMENTS), new Predicate<Card>() {
+                @Override
+                public boolean apply(Card card) {
+                    return !card.hasSVar("DoNotDiscardIfAble");
+                }
+            }));
             return getCheapestPermanentAI(ae, null, false);
         }
     
@@ -377,6 +385,32 @@ public class ComputerUtilCard {
         return getCheapestPermanentAI(list, null, false);
     }
 
+    public static final Card getCheapestSpellAI(final Iterable<Card> list) {
+        if (!Iterables.isEmpty(list)) {
+            CardCollection cc = CardLists.filter(new CardCollection(list),
+                    Predicates.or(CardPredicates.isType("Instant"), CardPredicates.isType("Sorcery")));
+            Collections.sort(cc, CardLists.CmcComparatorInv);
+
+            if (cc.isEmpty()) {
+                return null;
+            }
+
+            Card cheapest = cc.getLast();
+            if (cheapest.hasSVar("DoNotDiscardIfAble")) {
+                for (int i = cc.size() - 1; i >= 0; i--) {
+                    if (!cc.get(i).hasSVar("DoNotDiscardIfAble")) {
+                        cheapest = cc.get(i);
+                        break;
+                    }
+                }
+            }
+
+            return cheapest;
+        }
+
+        return null;
+    }
+
     public static final Comparator<Card> EvaluateCreatureComparator = new Comparator<Card>() {
         @Override
         public int compare(final Card a, final Card b) {
@@ -399,6 +433,10 @@ public class ComputerUtilCard {
         return creatureEvaluator.evaluateCreature(c);
     }
 
+    public static int evaluateCreature(final Card c, final boolean considerPT, final boolean considerCMC) {
+        return creatureEvaluator.evaluateCreature(c, considerPT, considerCMC);
+    }
+
     public static int evaluatePermanentList(final CardCollectionView list) {
         int value = 0;
         for (int i = 0; i < list.size(); i++) {
@@ -1175,6 +1213,18 @@ public class ComputerUtilCard {
         final PhaseHandler phase = game.getPhaseHandler();
         final Combat combat = phase.getCombat();
         final boolean isBerserk = "Berserk".equals(sa.getParam("AILogic"));
+        final boolean loseCardAtEOT = "Sacrifice".equals(sa.getParam("AtEOT")) || "Exile".equals(sa.getParam("AtEOT"))
+                || "Destroy".equals(sa.getParam("AtEOT")) || "ExileCombat".equals(sa.getParam("AtEOT"));
+
+        boolean combatTrick = false;
+        boolean holdCombatTricks = false;
+        int chanceToHoldCombatTricks = -1;
+
+        if (ai.getController().isAI()) {
+            AiController aic = ((PlayerControllerAi)ai.getController()).getAi();
+            holdCombatTricks = aic.getBooleanProperty(AiProps.TRY_TO_HOLD_COMBAT_TRICKS_UNTIL_BLOCK);
+            chanceToHoldCombatTricks = aic.getIntProperty(AiProps.CHANCE_TO_HOLD_COMBAT_TRICKS_UNTIL_BLOCK);
+        }
         
         if (!c.canBeTargetedBy(sa)) {
             return false;
@@ -1187,11 +1237,11 @@ public class ComputerUtilCard {
         /* -- currently disabled until better conditions are devised and the spell prediction is made smarter --
         // Determine if some mana sources need to be held for the future spell to cast in Main 2 before determining whether to pump.
         AiController aic = ((PlayerControllerAi)ai.getController()).getAi();
-        if (aic.getCardMemory().isMemorySetEmpty(AiCardMemory.MemorySet.HELD_MANA_SOURCES)) {
+        if (aic.getCardMemory().isMemorySetEmpty(AiCardMemory.MemorySet.HELD_MANA_SOURCES_FOR_MAIN2)) {
             // only hold mana sources once
             SpellAbility futureSpell = aic.predictSpellToCastInMain2(ApiType.Pump);
             if (futureSpell != null && futureSpell.getHostCard() != null) {
-                aic.reserveManaSourcesForMain2(futureSpell);
+                aic.reserveManaSources(futureSpell);
             }
         }
         */
@@ -1205,8 +1255,8 @@ public class ComputerUtilCard {
             return true;
         }
 
-        // buff attacker/blocker using triggered pump
-        if (immediately && phase.getPhase().isBefore(PhaseType.COMBAT_DECLARE_ATTACKERS)) {
+        // buff attacker/blocker using triggered pump (unless it's lethal and we don't want to be reckless)
+        if (immediately && phase.getPhase().isBefore(PhaseType.COMBAT_DECLARE_ATTACKERS) && !loseCardAtEOT) {
             if (phase.isPlayerTurn(ai)) {
                 if (CombatUtil.canAttack(c)) {
                     return true;
@@ -1235,6 +1285,28 @@ public class ComputerUtilCard {
                     threat *= 4;    //over-value self +attack for 0 power creatures which may be pumped further after attacking 
                 }
                 chance += threat;
+
+                // -- Hold combat trick (the AI will try to delay the pump until Declare Blockers) --
+                // Enable combat trick mode only in case it's a pure buff spell in hand with no keywords or with Trample,
+                // First Strike, or Double Strike, otherwise the AI is unlikely to cast it or it's too late to
+                // cast it during Declare Blockers, thus ruining its attacker
+                if (holdCombatTricks && sa.getApi() == ApiType.Pump
+                        && sa.hasParam("NumAtt") && sa.getHostCard() != null
+                        && sa.getHostCard().getZone() != null && sa.getHostCard().getZone().is(ZoneType.Hand)
+                        && c.getNetPower() > 0 // too obvious if attacking with a 0-power creature
+                        && sa.getHostCard().isInstant() // only do it for instant speed spells in hand
+                        && ComputerUtilMana.hasEnoughManaSourcesToCast(sa, ai)) {
+                    combatTrick = true;
+
+                    final List<String> kws = sa.hasParam("KW") ? Arrays.asList(sa.getParam("KW").split(" & "))
+                            : Lists.<String>newArrayList();
+                    for (String kw : kws) {
+                        if (!kw.equals("Trample") && !kw.equals("First Strike") && !kw.equals("Double Strike")) {
+                            combatTrick = false;
+                            break;
+                        }
+                    }
+                }
             }
             
             //2. grant haste
@@ -1262,7 +1334,7 @@ public class ComputerUtilCard {
             boolean pumpedWillDie = false;
             final boolean isAttacking = combat.isAttacking(c);
 
-            if (isBerserk && isAttacking) { pumpedWillDie = true; }
+            if ((isBerserk && isAttacking) || loseCardAtEOT) { pumpedWillDie = true; }
 
             if (isAttacking) {
                 pumpedCombat.addAttacker(pumped, opp);
@@ -1320,6 +1392,16 @@ 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;
+
+                // predict Infect
+                if (pumpedDmg == 0 && c.hasKeyword("Infect")) {
+                    if (poisonPumped > poisonOrig) {
+                        pumpedDmg = poisonPumped;
+                    }
+                }
+
                 if (combat.isBlocked(c)) {
                     if (!c.hasKeyword("Trample")) {
                         dmg = 0;
@@ -1332,8 +1414,11 @@ public class ComputerUtilCard {
                         pumpedDmg = 0;
                     }
                 }
-                if (pumpedDmg >= opp.getLife()) {
-                    return true;
+                if (pumpedDmg > dmg) {
+                    if ((!c.hasKeyword("Infect") && pumpedDmg >= opp.getLife())
+                            || (c.hasKeyword("Infect") && opp.canReceiveCounters(CounterType.POISON) && pumpedDmg >= opp.getPoisonCounters())) {
+                        return true;
+                    }
                 }
                 // try to determine if pumping a creature for more power will give lethal on board
                 // considering all unblocked creatures after the blockers are already declared
@@ -1396,14 +1481,47 @@ public class ComputerUtilCard {
         
         if (isBerserk) {
             // if we got here, Berserk will result in the pumped creature dying at EOT and the opponent will not lose
+            // (other similar cards with AILogic$ Berserk that do not die only when attacking are excluded from consideration)
             if (ai.getController() instanceof PlayerControllerAi) {
-                boolean aggr = ((PlayerControllerAi)ai.getController()).getAi().getBooleanProperty(AiProps.USE_BERSERK_AGGRESSIVELY);
+                boolean aggr = ((PlayerControllerAi)ai.getController()).getAi().getBooleanProperty(AiProps.USE_BERSERK_AGGRESSIVELY)
+                        || sa.hasParam("AtEOT");
                 if (!aggr) {
                     return false;
                 }
             }
         }
 
+        boolean wantToHoldTrick = holdCombatTricks;
+        if (chanceToHoldCombatTricks >= 0) {
+            // Obey the chance specified in the AI profile for holding combat tricks
+            wantToHoldTrick &= MyRandom.percentTrue(chanceToHoldCombatTricks);
+        } else {
+            // Use standard considerations dependent solely on the buff chance determined above
+            wantToHoldTrick &= MyRandom.getRandom().nextFloat() < chance;
+        }
+
+        boolean isHeldCombatTrick = combatTrick && wantToHoldTrick;
+
+        if (isHeldCombatTrick) {
+           if (AiCardMemory.isMemorySetEmpty(ai, AiCardMemory.MemorySet.TRICK_ATTACKERS)) {
+               // Attempt to hold combat tricks until blockers are declared, and try to lure the opponent into blocking
+               // (The AI will only do it for one attacker at the moment, otherwise it risks running his attackers into
+               // an army of opposing blockers with only one combat trick in hand)
+               AiCardMemory.rememberCard(ai, c, AiCardMemory.MemorySet.MANDATORY_ATTACKERS);
+               AiCardMemory.rememberCard(ai, c, AiCardMemory.MemorySet.TRICK_ATTACKERS);
+               // Reserve the mana until Declare Blockers such that the AI doesn't tap out before having a chance to use
+               // the combat trick
+               if (ai.getController().isAI()) {
+                   ((PlayerControllerAi) ai.getController()).getAi().reserveManaSources(sa, PhaseType.COMBAT_DECLARE_BLOCKERS);
+               }
+               return false;
+           } else {
+               // Don't try to mix "lure" and "precast" paradigms for combat tricks, since that creates issues with
+               // the AI overextending the attack
+               return false;
+           }
+        }
+
         return MyRandom.getRandom().nextFloat() < chance;
     }
     
@@ -1418,8 +1536,7 @@ public class ComputerUtilCard {
      * @return
      */
     public static Card getPumpedCreature(final Player ai, final SpellAbility sa,
-            final Card c, final int toughness, final int power,
-            final List<String> keywords) {
+            final Card c, int toughness, int power, final List<String> keywords) {
         Card pumped = CardFactory.copyCard(c, true);
         pumped.setSickness(c.hasSickness());
         final long timestamp = c.getGame().getNextTimestamp();
@@ -1432,8 +1549,25 @@ public class ComputerUtilCard {
             }
         }
 
+        // Berserk (and other similar cards)
         final boolean isBerserk = "Berserk".equals(sa.getParam("AILogic"));
-        final int berserkPower = isBerserk ? c.getCurrentPower() : 0;
+        int berserkPower = 0;
+        if (isBerserk && sa.hasSVar("X")) {
+            if ("Targeted$CardPower".equals(sa.getSVar("X"))) {
+                berserkPower = c.getCurrentPower();
+            } else {
+                berserkPower = AbilityUtils.calculateAmount(sa.getHostCard(), "X", sa);
+            }
+        }
+
+        // Electrostatic Pummeler
+        for (SpellAbility ab : c.getSpellAbilities()) {
+            if ("Pummeler".equals(ab.getParam("AILogic"))) {
+                Pair<Integer, Integer> newPT = SpecialCardAi.ElectrostaticPummeler.getPumpedPT(ai, power, toughness);
+                power = newPT.getLeft();
+                toughness = newPT.getRight();
+            }
+        }
 
         pumped.addNewPT(c.getCurrentPower(), c.getCurrentToughness(), timestamp);
         pumped.addTempPowerBoost(c.getTempPowerBoost() + power + berserkPower);
@@ -1447,19 +1581,21 @@ public class ComputerUtilCard {
         if (c.isTapped()) {
             pumped.setTapped(true);
         }
-        final List<String> copiedKeywords = pumped.getKeywords();
-        List<String> toCopy = new ArrayList<String>();
-        for (String kw : c.getKeywords()) {
-            if (!copiedKeywords.contains(kw)) {
-                if (kw.startsWith("HIDDEN")) {
-                    pumped.addHiddenExtrinsicKeyword(kw);
+
+        KeywordCollection copiedKeywords = new KeywordCollection();
+        copiedKeywords.insertAll(pumped.getKeywords());
+        List<KeywordInterface> toCopy = Lists.newArrayList();
+        for (KeywordInterface k : c.getKeywords()) {
+            if (!copiedKeywords.contains(k.getOriginal())) {
+                if (k.getHidden()) {
+                    pumped.addHiddenExtrinsicKeyword(k);
                 } else {
-                    toCopy.add(kw);
+                    toCopy.add(k);
                 }
             }
         }
         final long timestamp2 = c.getGame().getNextTimestamp(); //is this necessary or can the timestamp be re-used?
-        pumped.addChangedCardKeywords(toCopy, new ArrayList<String>(), false, timestamp2);
+        pumped.addChangedCardKeywordsInternal(toCopy, Lists.<KeywordInterface>newArrayList(), false, timestamp2, true);
         ComputerUtilCard.applyStaticContPT(ai.getGame(), pumped, new CardCollection(c));
         return pumped;
     }
@@ -1613,4 +1749,95 @@ public class ComputerUtilCard {
 
         return maxEnergyCost;
     }
+
+    public static CardCollection prioritizeCreaturesWorthRemovingNow(final Player ai, CardCollection oppCards, final boolean temporary) {
+        if (!CardLists.getNotType(oppCards, "Creature").isEmpty()) {
+            // non-creatures were passed, nothing to do here
+            return oppCards;
+        }
+
+        boolean enablePriorityRemoval = false;
+        boolean priorityRemovalOnlyInDanger = false;
+        int priorityRemovalThreshold = 0;
+        int lifeInDanger = 5;
+        if (ai.getController().isAI()) {
+            AiController aic = ((PlayerControllerAi)ai.getController()).getAi();
+            enablePriorityRemoval = aic.getBooleanProperty(AiProps.ACTIVELY_DESTROY_IMMEDIATELY_UNBLOCKABLE);
+            priorityRemovalThreshold = aic.getIntProperty(AiProps.DESTROY_IMMEDIATELY_UNBLOCKABLE_THRESHOLD);
+            priorityRemovalOnlyInDanger = aic.getBooleanProperty(AiProps.DESTROY_IMMEDIATELY_UNBLOCKABLE_ONLY_IN_DNGR);
+            lifeInDanger = aic.getIntProperty(AiProps.DESTROY_IMMEDIATELY_UNBLOCKABLE_LIFE_IN_DNGR);
+        }
+
+        if (!enablePriorityRemoval) {
+            // Nothing to do here, the profile does not allow prioritizing
+            return oppCards;
+        }
+
+        CardCollection aiCreats = CardLists.filter(ai.getCardsIn(ZoneType.Battlefield), CardPredicates.Presets.CREATURES);
+        if (temporary) {
+            // Pump effects that add "CARDNAME can't attack" and similar things. Only do it if something is untapped.
+            oppCards = CardLists.filter(oppCards, CardPredicates.Presets.UNTAPPED);
+        }
+
+        CardCollection priorityCards = new CardCollection();
+        for (Card atk : oppCards) {
+            if (isUselessCreature(atk.getController(), atk)) {
+                continue;
+            }
+            for (Card blk : aiCreats) {
+                if (!CombatUtil.canBlock(atk, blk, true)) {
+                    boolean threat = atk.getNetCombatDamage() >= ai.getLife() - lifeInDanger;
+                    if (!priorityRemovalOnlyInDanger || threat) {
+                        priorityCards.add(atk);
+                    }
+                }
+            }
+        }
+
+        if (!priorityCards.isEmpty() && priorityCards.size() <= priorityRemovalThreshold) {
+            return priorityCards;
+        }
+
+        return oppCards;
+    }
+
+    public static AiPlayDecision checkNeedsToPlayReqs(final Card card, final SpellAbility sa) {
+        Game game = card.getGame();
+        boolean isRightSplit = sa != null && sa.isRightSplit();
+        String needsToPlayName = isRightSplit ? "SplitNeedsToPlay" : "NeedsToPlay";
+        String needsToPlayVarName = isRightSplit ? "SplitNeedsToPlayVar" : "NeedsToPlayVar";
+
+        if (card.hasSVar(needsToPlayName)) {
+            final String needsToPlay = card.getSVar(needsToPlayName);
+            CardCollectionView list = game.getCardsIn(ZoneType.Battlefield);
+
+            list = CardLists.getValidCards(list, needsToPlay.split(","), card.getController(), card, null);
+            if (list.isEmpty()) {
+                return AiPlayDecision.MissingNeededCards;
+            }
+        }
+        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));
+            }
+            if (!Expressions.compare(x, comparator, y)) {
+                return AiPlayDecision.NeedsToPlayCriteriaNotMet;
+            }
+        }
+
+        return AiPlayDecision.WillPlay;
+    }
 }

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

@@ -32,16 +32,11 @@ import forge.game.GlobalRuleChange;
 import forge.game.ability.AbilityFactory;
 import forge.game.ability.AbilityUtils;
 import forge.game.ability.ApiType;
-import forge.game.card.Card;
-import forge.game.card.CardCollection;
-import forge.game.card.CardCollectionView;
-import forge.game.card.CardFactoryUtil;
-import forge.game.card.CardLists;
-import forge.game.card.CardUtil;
-import forge.game.card.CounterType;
+import forge.game.card.*;
 import forge.game.combat.Combat;
 import forge.game.combat.CombatUtil;
 import forge.game.cost.CostPayment;
+import forge.game.keyword.KeywordInterface;
 import forge.game.phase.Untap;
 import forge.game.player.Player;
 import forge.game.replacement.ReplacementEffect;
@@ -53,6 +48,8 @@ import forge.game.trigger.Trigger;
 import forge.game.trigger.TriggerHandler;
 import forge.game.trigger.TriggerType;
 import forge.game.zone.ZoneType;
+import forge.util.MyRandom;
+import forge.util.TextUtil;
 import forge.util.collect.FCollection;
 
 
@@ -109,7 +106,8 @@ public class ComputerUtilCombat {
             return false;
         }
 
-        for (final String keyword : atacker.getKeywords()) {
+        for (final KeywordInterface inst : atacker.getKeywords()) {
+            final String keyword = inst.getOriginal();
             if (keyword.startsWith("CARDNAME attacks specific player each combat if able")) {
                 final String defined = keyword.split(":")[1];
                 final Player player = AbilityUtils.getDefinedPlayers(atacker, defined, null).get(0);
@@ -385,11 +383,27 @@ public class ComputerUtilCombat {
      * @return a boolean.
      */
     public static boolean lifeInDanger(final Player ai, final Combat combat) {
+        return lifeInDanger(ai, combat, 0);
+    }
+
+    public static boolean lifeInDanger(final Player ai, final Combat combat, final int payment) {
         // life in danger only cares about the player's life. Not Planeswalkers' life
         if (ai.cantLose() || combat == null || combat.getAttackingPlayer() == ai) {
             return false;
         }
 
+        CardCollectionView otb = ai.getCardsIn(ZoneType.Battlefield);
+        // Special cases:
+        // AI can't lose in combat in presence of Worship (with creatures)
+        if (!CardLists.filter(otb, CardPredicates.nameEquals("Worship")).isEmpty() && !ai.getCreaturesInPlay().isEmpty()) {
+            return false;
+        }
+        // AI can't lose in combat in presence of Elderscale Wurm (at 7 life or more)
+        if (!CardLists.filter(otb, CardPredicates.nameEquals("Elderscale Wurm")).isEmpty() && ai.getLife() >= 7) {
+            return false;
+        }
+
+
         // check for creatures that must be blocked
         final List<Card> attackers = combat.getAttackersOf(ai);
 
@@ -401,7 +415,18 @@ public class ComputerUtilCombat {
 
             if (blockers.isEmpty()) {
                 if (!attacker.getSVar("MustBeBlocked").equals("")) {
-                    return true;
+                    boolean cond = false;
+                    String condVal = attacker.getSVar("MustBeBlocked");
+                    boolean isAttackingPlayer = combat.getDefenderByAttacker(attacker) instanceof Player;
+
+                    cond |= "true".equalsIgnoreCase(condVal);
+                    cond |= "attackingplayer".equalsIgnoreCase(condVal) && isAttackingPlayer;
+                    cond |= "attackingplayerconservative".equalsIgnoreCase(condVal) && isAttackingPlayer
+                            && ai.getCreaturesInPlay().size() >= 3 && ai.getCreaturesInPlay().size() > attacker.getController().getCreaturesInPlay().size();
+
+                    if (cond) {
+                        return true;
+                    }
                 }
             }
             if (threateningCommanders.contains(attacker)) {
@@ -409,7 +434,18 @@ public class ComputerUtilCombat {
             }
         }
 
-        if (ComputerUtilCombat.lifeThatWouldRemain(ai, combat) < Math.min(4, ai.getLife())
+        int threshold = (((PlayerControllerAi) ai.getController()).getAi().getIntProperty(AiProps.AI_IN_DANGER_THRESHOLD));
+        int maxTreshold = (((PlayerControllerAi) ai.getController()).getAi().getIntProperty(AiProps.AI_IN_DANGER_MAX_THRESHOLD)) - threshold;
+        
+        int chance = MyRandom.getRandom().nextInt(80) + 5;
+        while (maxTreshold > 0) {
+            if (MyRandom.getRandom().nextInt(100) < chance) {
+                threshold++;
+            }
+            maxTreshold--;
+        }
+
+        if (ComputerUtilCombat.lifeThatWouldRemain(ai, combat) - payment < Math.min(threshold, ai.getLife())
                 && !ai.cantLoseForZeroOrLessLife()) {
             return true;
         }
@@ -443,6 +479,10 @@ public class ComputerUtilCombat {
      * @return a boolean.
      */
     public static boolean lifeInSeriousDanger(final Player ai, final Combat combat) {
+        return lifeInSeriousDanger(ai, combat, 0);
+    }
+
+    public static boolean lifeInSeriousDanger(final Player ai, final Combat combat, final int payment) {
         // life in danger only cares about the player's life. Not about a
         // Planeswalkers life
         if (ai.cantLose() || combat == null) {
@@ -468,7 +508,7 @@ public class ComputerUtilCombat {
             }
         }
 
-        if (ComputerUtilCombat.lifeThatWouldRemain(ai, combat) < 1 && !ai.cantLoseForZeroOrLessLife()) {
+        if (ComputerUtilCombat.lifeThatWouldRemain(ai, combat) - payment < 1 && !ai.cantLoseForZeroOrLessLife()) {
             return true;
         }
 
@@ -683,12 +723,21 @@ public class ComputerUtilCombat {
      */
     public static boolean attackerWouldBeDestroyed(Player ai, final Card attacker, Combat combat) {
         final List<Card> blockers = combat.getBlockers(attacker);
+        int firstStrikeBlockerDmg = 0;
 
         for (final Card defender : blockers) {
             if (ComputerUtilCombat.canDestroyAttacker(ai, attacker, defender, combat, true)
                     && !(defender.hasKeyword("Wither") || defender.hasKeyword("Infect"))) {
                 return true;
             }
+            if (defender.hasKeyword("First Strike") || defender.hasKeyword("Double Strike")) {
+                firstStrikeBlockerDmg += defender.getNetCombatDamage();
+            }
+        }
+
+        // Consider first strike and double strike
+        if (attacker.hasKeyword("First Strike") || attacker.hasKeyword("Double Strike")) {
+            return firstStrikeBlockerDmg >= ComputerUtilCombat.getDamageToKill(attacker);
         }
 
         return ComputerUtilCombat.totalDamageOfBlockers(attacker, blockers) >= ComputerUtilCombat.getDamageToKill(attacker);
@@ -781,7 +830,7 @@ public class ComputerUtilCombat {
                 if (validBlocked.contains(".withLesserPower")) {
                     // Have to check this restriction here as triggering objects aren't set yet, so
                     // ValidBlocked$Creature.powerLTX where X:TriggeredBlocker$CardPower crashes with NPE
-                    validBlocked = validBlocked.replace(".withLesserPower", "");
+                    validBlocked = TextUtil.fastReplace(validBlocked, ".withLesserPower", "");
                     if (defender.getCurrentPower() <= attacker.getCurrentPower()) {
                         return false;
                     }
@@ -795,7 +844,7 @@ public class ComputerUtilCombat {
                 if (validBlocker.contains(".withLesserPower")) {
                     // Have to check this restriction here as triggering objects aren't set yet, so
                     // ValidCard$Creature.powerLTX where X:TriggeredAttacker$CardPower crashes with NPE
-                    validBlocker = validBlocker.replace(".withLesserPower", "");
+                    validBlocker = TextUtil.fastReplace(validBlocker, ".withLesserPower", "");
                     if (defender.getCurrentPower() >= attacker.getCurrentPower()) {
                         return false;
                     }
@@ -854,9 +903,12 @@ public class ComputerUtilCombat {
     public static int predictPowerBonusOfBlocker(final Card attacker, final Card blocker, boolean withoutAbilities) {
         int power = 0;
 
+        // Apparently, Flanking is predicted below from a trigger, so using the code below results in double
+        // application of power bonus. A bit more testing may be needed though, so commenting out for now.
+        /*
         if (attacker.hasKeyword("Flanking") && !blocker.hasKeyword("Flanking")) {
             power -= attacker.getAmountOfKeyword("Flanking");
-        }
+        }*/
         
         // Serene Master switches power with attacker
         if (blocker.getName().equals("Serene Master")) {
@@ -874,8 +926,6 @@ public class ComputerUtilCombat {
             power -= attacker.getNetCombatDamage();
         }
 
-        power += blocker.getKeywordMagnitude("Bushido");
-
         final Game game = attacker.getGame();
         // look out for continuous static abilities that only care for blocking
         // creatures
@@ -889,7 +939,7 @@ public class ComputerUtilCombat {
                 if (!params.containsKey("Affected") || !params.get("Affected").contains("blocking")) {
                     continue;
                 }
-                final String valid = params.get("Affected").replace("blocking", "Creature");
+                final String valid = TextUtil.fastReplace(params.get("Affected"), "blocking", "Creature");
                 if (!blocker.isValid(valid, card.getController(), card, null)) {
                     continue;
                 }
@@ -967,6 +1017,9 @@ public class ComputerUtilCombat {
             if (ability.hasParam("ActivationPhases") || ability.hasParam("SorcerySpeed") || ability.hasParam("ActivationZone")) {
                 continue;
             }
+            if (ability.usesTargeting() && !ability.canTarget(blocker)) {
+                continue;
+            }
 
             if (ability.getApi() == ApiType.Pump) {
                 if (!ability.hasParam("NumAtt")) {
@@ -1024,7 +1077,6 @@ public class ComputerUtilCombat {
             toughness += attacker.getNetToughness() - blocker.getNetToughness();
         } 
 
-        toughness += blocker.getKeywordMagnitude("Bushido");
         final Game game = attacker.getGame();
         final FCollection<Trigger> theTriggers = new FCollection<Trigger>();
         for (Card card : game.getCardsIn(ZoneType.Battlefield)) {
@@ -1129,6 +1181,9 @@ public class ComputerUtilCombat {
             if (ability.hasParam("ActivationPhases") || ability.hasParam("SorcerySpeed") || ability.hasParam("ActivationZone")) {
                 continue;
             }
+            if (ability.usesTargeting() && !ability.canTarget(blocker)) {
+                continue;
+            }
 
             if (ability.getApi() == ApiType.Pump) {
                 if (!ability.hasParam("NumDef")) {
@@ -1176,10 +1231,12 @@ public class ComputerUtilCombat {
      *            a {@link forge.game.combat.Combat} object.
      * @return a int.
      */
-    public static int predictPowerBonusOfAttacker(final Card attacker, final Card blocker, final Combat combat , boolean withoutAbilities) {
+    public static int predictPowerBonusOfAttacker(final Card attacker, final Card blocker, final Combat combat, boolean withoutAbilities) {
+        return predictPowerBonusOfAttacker(attacker, blocker, combat, withoutAbilities, false);
+    }
+    public static int predictPowerBonusOfAttacker(final Card attacker, final Card blocker, final Combat combat, boolean withoutAbilities, boolean withoutCombatStaticAbilities) {
         int power = 0;
 
-        power += attacker.getKeywordMagnitude("Bushido");
         //check Exalted only for the first attacker
         if (combat != null && combat.getAttackers().isEmpty()) {
             for (Card card : attacker.getController().getCardsIn(ZoneType.Battlefield)) {
@@ -1216,27 +1273,29 @@ public class ComputerUtilCombat {
 
         // look out for continuous static abilities that only care for attacking
         // creatures
-        final CardCollectionView cardList = CardCollection.combine(game.getCardsIn(ZoneType.Battlefield), game.getCardsIn(ZoneType.Command));
-        for (final Card card : cardList) {
-            for (final StaticAbility stAb : card.getStaticAbilities()) {
-                final Map<String, String> params = stAb.getMapParams();
-                if (!params.get("Mode").equals("Continuous")) {
-                    continue;
-                }
-                if (!params.containsKey("Affected") || !params.get("Affected").contains("attacking")) {
-                    continue;
-                }
-                final String valid = params.get("Affected").replace("attacking", "Creature");
-                if (!attacker.isValid(valid, card.getController(), card, null)) {
-                    continue;
-                }
-                if (params.containsKey("AddPower")) {
-                    if (params.get("AddPower").equals("X")) {
-                        power += CardFactoryUtil.xCount(card, card.getSVar("X"));
-                    } else if (params.get("AddPower").equals("Y")) {
-                        power += CardFactoryUtil.xCount(card, card.getSVar("Y"));
-                    } else {
-                        power += Integer.valueOf(params.get("AddPower"));
+        if (!withoutCombatStaticAbilities) {
+            final CardCollectionView cardList = CardCollection.combine(game.getCardsIn(ZoneType.Battlefield), game.getCardsIn(ZoneType.Command));
+            for (final Card card : cardList) {
+                for (final StaticAbility stAb : card.getStaticAbilities()) {
+                    final Map<String, String> params = stAb.getMapParams();
+                    if (!params.get("Mode").equals("Continuous")) {
+                        continue;
+                    }
+                    if (!params.containsKey("Affected") || !params.get("Affected").contains("attacking")) {
+                        continue;
+                    }
+                    final String valid = TextUtil.fastReplace(params.get("Affected"), "attacking", "Creature");
+                    if (!attacker.isValid(valid, card.getController(), card, null)) {
+                        continue;
+                    }
+                    if (params.containsKey("AddPower")) {
+                        if (params.get("AddPower").equals("X")) {
+                            power += CardFactoryUtil.xCount(card, card.getSVar("X"));
+                        } else if (params.get("AddPower").equals("Y")) {
+                            power += CardFactoryUtil.xCount(card, card.getSVar("Y"));
+                        } else {
+                            power += Integer.valueOf(params.get("AddPower"));
+                        }
                     }
                 }
             }
@@ -1305,13 +1364,13 @@ public class ComputerUtilCombat {
             } else {
                 String bonus = new String(source.getSVar(att));
                 if (bonus.contains("TriggerCount$NumBlockers")) {
-                    bonus = bonus.replace("TriggerCount$NumBlockers", "Number$1");
+                    bonus = TextUtil.fastReplace(bonus, "TriggerCount$NumBlockers", "Number$1");
                 } else if (bonus.contains("TriggeredPlayersDefenders$Amount")) { // for Melee
-                    bonus = bonus.replace("TriggeredPlayersDefenders$Amount", "Number$1");
+                    bonus = TextUtil.fastReplace(bonus, "TriggeredPlayersDefenders$Amount", "Number$1");
                 } else if (bonus.contains("TriggeredAttacker$CardPower")) { // e.g. Arahbo, Roar of the World
-                    bonus = bonus.replace("TriggeredAttacker$CardPower", "Number$" + attacker.getNetPower());
+                    bonus = TextUtil.fastReplace(bonus, "TriggeredAttacker$CardPower", TextUtil.concatNoSpace("Number$", String.valueOf(attacker.getNetPower())));
                 } else if (bonus.contains("TriggeredAttacker$CardToughness")) {
-                    bonus = bonus.replace("TriggeredAttacker$CardToughness", "Number$" + attacker.getNetToughness());
+                    bonus = TextUtil.fastReplace(bonus, "TriggeredAttacker$CardToughness", TextUtil.concatNoSpace("Number$", String.valueOf(attacker.getNetToughness())));
                 }
                 power += CardFactoryUtil.xCount(source, bonus);
 
@@ -1327,6 +1386,9 @@ public class ComputerUtilCombat {
             if (ability.hasParam("ActivationPhases") || ability.hasParam("SorcerySpeed") || ability.hasParam("ActivationZone")) {
                 continue;
             }
+            if (ability.usesTargeting() && !ability.canTarget(attacker)) {
+                continue;
+            }
 
             if (ability.getApi() == ApiType.Pump) {
                 if (!ability.hasParam("NumAtt")) {
@@ -1376,6 +1438,10 @@ public class ComputerUtilCombat {
      */
     public static int predictToughnessBonusOfAttacker(final Card attacker, final Card blocker, final Combat combat
             , boolean withoutAbilities) {
+        return predictToughnessBonusOfAttacker(attacker, blocker, combat, withoutAbilities, false);
+    }
+    public static int predictToughnessBonusOfAttacker(final Card attacker, final Card blocker, final Combat combat
+            , boolean withoutAbilities, boolean withoutCombatStaticAbilities) {
         int toughness = 0;
 
         //check Exalted only for the first attacker
@@ -1398,43 +1464,44 @@ public class ComputerUtilCombat {
             theTriggers.addAll(card.getTriggers());
         }
         if (blocker != null) {
-            toughness += attacker.getKeywordMagnitude("Bushido");
             theTriggers.addAll(blocker.getTriggers());
         }
 
         // look out for continuous static abilities that only care for attacking
         // creatures
-        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")) {
-                    continue;
-                }
-                if (params.containsKey("Affected") && params.get("Affected").contains("attacking")) {
-	                final String valid = params.get("Affected").replace("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 = params.get("Affected").replace("untapped", "Creature");
-	                if (!attacker.isValid(valid, card.getController(), card, null) 
-	                		|| attacker.hasKeyword("Vigilance")) {
-	                    continue;
-	                }
-	                // remove the bonus, because it will no longer be granted
-	                if (params.containsKey("AddToughness")) {
-	                	toughness -= Integer.valueOf(params.get("AddToughness"));
-	                }
+        if (!withoutCombatStaticAbilities) {
+            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")) {
+                        continue;
+                    }
+                    if (params.containsKey("Affected") && params.get("Affected").contains("attacking")) {
+                        final String valid = TextUtil.fastReplace(params.get("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");
+                        if (!attacker.isValid(valid, card.getController(), card, null)
+                                || attacker.hasKeyword("Vigilance")) {
+                            continue;
+                        }
+                        // remove the bonus, because it will no longer be granted
+                        if (params.containsKey("AddToughness")) {
+                            toughness -= Integer.valueOf(params.get("AddToughness"));
+                        }
+                    }
                 }
             }
         }
@@ -1521,9 +1588,9 @@ public class ComputerUtilCombat {
             } else {
                 String bonus = new String(source.getSVar(def));
                 if (bonus.contains("TriggerCount$NumBlockers")) {
-                    bonus = bonus.replace("TriggerCount$NumBlockers", "Number$1");
+                    bonus = TextUtil.fastReplace(bonus, "TriggerCount$NumBlockers", "Number$1");
                 } else if (bonus.contains("TriggeredPlayersDefenders$Amount")) { // for Melee
-                    bonus = bonus.replace("TriggeredPlayersDefenders$Amount", "Number$1");
+                    bonus = TextUtil.fastReplace(bonus, "TriggeredPlayersDefenders$Amount", "Number$1");
                 }
                 toughness += CardFactoryUtil.xCount(source, bonus);
             }
@@ -1539,6 +1606,9 @@ public class ComputerUtilCombat {
             if (ability.hasParam("ActivationPhases") || ability.hasParam("SorcerySpeed") || ability.hasParam("ActivationZone")) {
                 continue;
             }
+            if (ability.usesTargeting() && !ability.canTarget(attacker)) {
+                continue;
+            }
 
             if (ability.getApi() == ApiType.Pump) {
                 if (!ability.hasParam("NumDef")) {
@@ -1678,6 +1748,10 @@ public class ComputerUtilCombat {
      */
     public static boolean canDestroyAttacker(Player ai, Card attacker, Card blocker, final Combat combat,
             final boolean withoutAbilities) {
+        return canDestroyAttacker(ai, attacker, blocker, combat, withoutAbilities, false);
+    }
+    public static boolean canDestroyAttacker(Player ai, Card attacker, Card blocker, final Combat combat,
+            final boolean withoutAbilities, final boolean withoutAttackerStaticAbilities) {
         // Can activate transform ability
         if (!withoutAbilities) {
             attacker = canTransform(attacker);
@@ -1729,10 +1803,10 @@ public class ComputerUtilCombat {
         }
         if (attacker.toughnessAssignsDamage()) {
             attackerDamage = attacker.getNetToughness()
-                    + ComputerUtilCombat.predictToughnessBonusOfAttacker(attacker, blocker, combat, withoutAbilities);
+                    + ComputerUtilCombat.predictToughnessBonusOfAttacker(attacker, blocker, combat, withoutAbilities, withoutAttackerStaticAbilities);
         } else {
         	attackerDamage = attacker.getNetPower()
-                    + ComputerUtilCombat.predictPowerBonusOfAttacker(attacker, blocker, combat, withoutAbilities);
+                    + ComputerUtilCombat.predictPowerBonusOfAttacker(attacker, blocker, combat, withoutAbilities, withoutAttackerStaticAbilities);
         }
 
         int possibleDefenderPrevention = 0;
@@ -1754,7 +1828,7 @@ public class ComputerUtilCombat {
         final int defenderLife = ComputerUtilCombat.getDamageToKill(blocker)
                 + ComputerUtilCombat.predictToughnessBonusOfBlocker(attacker, blocker, withoutAbilities);
         final int attackerLife = ComputerUtilCombat.getDamageToKill(attacker)
-                + ComputerUtilCombat.predictToughnessBonusOfAttacker(attacker, blocker, combat, withoutAbilities);
+                + ComputerUtilCombat.predictToughnessBonusOfAttacker(attacker, blocker, combat, withoutAbilities, withoutAttackerStaticAbilities);
 
         if (blocker.hasKeyword("Double Strike")) {
             if (defenderDamage > 0 && (hasKeyword(blocker, "Deathtouch", withoutAbilities, combat) || attacker.hasSVar("DestroyWhenDamaged"))) {
@@ -1923,6 +1997,10 @@ public class ComputerUtilCombat {
      */
     public static boolean canDestroyBlocker(Player ai, Card blocker, Card attacker, final Combat combat,
             final boolean withoutAbilities) {
+        return canDestroyBlocker(ai, blocker, attacker, combat, withoutAbilities, false);
+    }
+    public static boolean canDestroyBlocker(Player ai, Card blocker, Card attacker, final Combat combat,
+            final boolean withoutAbilities, final boolean withoutAttackerStaticAbilities) {
         // Can activate transform ability
         if (!withoutAbilities) {
             attacker = canTransform(attacker);
@@ -1956,10 +2034,10 @@ public class ComputerUtilCombat {
         }
         if (attacker.toughnessAssignsDamage()) {
             attackerDamage = attacker.getNetToughness()
-                    + ComputerUtilCombat.predictToughnessBonusOfAttacker(attacker, blocker, combat, withoutAbilities);
+                    + ComputerUtilCombat.predictToughnessBonusOfAttacker(attacker, blocker, combat, withoutAbilities, withoutAttackerStaticAbilities);
         } else {
         	attackerDamage = attacker.getNetPower()
-                    + ComputerUtilCombat.predictPowerBonusOfAttacker(attacker, blocker, combat, withoutAbilities);
+                    + ComputerUtilCombat.predictPowerBonusOfAttacker(attacker, blocker, combat, withoutAbilities, withoutAttackerStaticAbilities);
         }
 
         int possibleDefenderPrevention = 0;
@@ -1984,7 +2062,7 @@ public class ComputerUtilCombat {
         final int defenderLife = ComputerUtilCombat.getDamageToKill(blocker)
                 + ComputerUtilCombat.predictToughnessBonusOfBlocker(attacker, blocker, withoutAbilities);
         final int attackerLife = ComputerUtilCombat.getDamageToKill(attacker)
-                + ComputerUtilCombat.predictToughnessBonusOfAttacker(attacker, blocker, combat, withoutAbilities);
+                + ComputerUtilCombat.predictToughnessBonusOfAttacker(attacker, blocker, combat, withoutAbilities, withoutAttackerStaticAbilities);
 
         if (attacker.hasKeyword("Double Strike")) {
             if (attackerDamage > 0 && (hasKeyword(attacker, "Deathtouch", withoutAbilities, combat) || blocker.hasSVar("DestroyWhenDamaged"))) {
@@ -2201,6 +2279,7 @@ public class ComputerUtilCombat {
      */
     public final static int getDamageToKill(final Card c) {
         int killDamage = c.getLethalDamage() + c.getPreventNextDamageTotalShields();
+
         if ((killDamage > c.getPreventNextDamageTotalShields())
                 && c.hasSVar("DestroyWhenDamaged")) {
             killDamage = 1 + c.getPreventNextDamageTotalShields();
@@ -2407,7 +2486,7 @@ public class ComputerUtilCombat {
             for (SpellAbility sa : original.getSpellAbilities()) {
                 if (sa.getApi() == ApiType.SetState && ComputerUtilCost.canPayCost(sa, original.getController())) {
                     Card transformed = CardUtil.getLKICopy(original);
-                    transformed.getCurrentState().copyFrom(original, original.getAlternateState());
+                    transformed.getCurrentState().copyFrom(original.getAlternateState(), true);
                     transformed.updateStateForView();
                     return transformed;
                 }
@@ -2454,6 +2533,81 @@ public class ComputerUtilCombat {
 
         return -1;
     }
+
+    public static List<Card> categorizeAttackersByEvasion(List<Card> attackers) {
+        List<Card> categorizedAttackers = Lists.newArrayList();
+
+        CardCollection withEvasion = new CardCollection();
+        CardCollection withoutEvasion = new CardCollection();
+
+        for (Card atk : attackers) {
+            boolean hasProtection = false;
+            for (KeywordInterface inst : atk.getKeywords()) {
+                String kw = inst.getOriginal();
+                if (kw.startsWith("Protection")) {
+                    hasProtection = true;
+                    break;
+                }
+            }
+
+            if (atk.hasKeyword("Flying") || atk.hasKeyword("Shadow")
+                    || atk.hasKeyword("Horsemanship") || (atk.hasKeyword("Fear")
+                    || atk.hasKeyword("Intimidate") || atk.hasKeyword("Skulk") || hasProtection)) {
+                withEvasion.add(atk);
+            } else {
+                withoutEvasion.add(atk);
+            }
+        }
+
+        // attackers that can only be blocked by cards with specific keywords or color, etc.
+        // (maybe will need to split into 2 or 3 tiers depending on importance)
+        categorizedAttackers.addAll(withEvasion);
+        // all other attackers that have no evasion
+        // (Menace and other abilities that limit blocking by amount of blockers is likely handled
+        // elsewhere, but that needs testing and possibly fine-tuning).
+        categorizedAttackers.addAll(withoutEvasion);
+
+        return categorizedAttackers;
+    }
+
+    public static Card applyPotentialAttackCloneTriggers(Card attacker) {
+        // This method returns the potentially cloned card if the creature turns into something else during the attack
+        // (currently looks for the creature with maximum raw power since that's what the AI usually judges by when
+        // deciding whether the creature is worth blocking).
+        // If the creature doesn't change into anything, returns the original creature.
+        if (attacker == null) { return null; }
+        Card attackerAfterTrigs = attacker;
+
+        // Test for some special triggers that can change the creature in combat
+        for (Trigger t : attacker.getTriggers()) {
+            if (t.getMode() == TriggerType.Attacks && t.hasParam("Execute")) {
+                if (!attacker.hasSVar(t.getParam("Execute"))) {
+                    continue;
+                }
+                SpellAbility exec = AbilityFactory.getAbility(attacker, t.getParam("Execute"));
+                if (exec != null) {
+                    if (exec.getApi() == ApiType.Clone && "Self".equals(exec.getParam("CloneTarget"))
+                            && exec.hasParam("ValidTgts") && exec.getParam("ValidTgts").contains("Creature")
+                            && exec.getParam("ValidTgts").contains("attacking")) {
+                        // Tilonalli's Skinshifter and potentially other similar cards that can clone other stuff
+                        // while attacking
+                        if (exec.getParam("ValidTgts").contains("nonLegendary") && attacker.getType().isLegendary()) {
+                            continue;
+                        }
+                        int maxPwr = 0;
+                        for (Card c : attacker.getController().getCreaturesInPlay()) {
+                            if (c.getNetPower() > maxPwr || (c.getNetPower() == maxPwr && ComputerUtilCard.evaluateCreature(c) > ComputerUtilCard.evaluateCreature(attackerAfterTrigs))) {
+                                maxPwr = c.getNetPower();
+                                attackerAfterTrigs = c;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        return attackerAfterTrigs;
+    }
 }
 
 

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

@@ -1,14 +1,8 @@
 package forge.ai;
 
-import java.util.List;
-import java.util.Set;
-
-import org.apache.commons.lang3.StringUtils;
-
 import com.google.common.base.Predicate;
 import com.google.common.collect.Lists;
 import com.google.common.collect.Sets;
-
 import forge.ai.ability.AnimateAi;
 import forge.card.ColorSet;
 import forge.game.GameActionUtil;
@@ -27,6 +21,10 @@ import forge.game.zone.ZoneType;
 import forge.util.MyRandom;
 import forge.util.TextUtil;
 import forge.util.collect.FCollectionView;
+import org.apache.commons.lang3.StringUtils;
+
+import java.util.List;
+import java.util.Set;
 
 
 public class ComputerUtilCost {
@@ -90,6 +88,15 @@ public class ComputerUtilCost {
                     return false;
                 }
 
+                // Remove X counters - set ChosenX to max possible value here, the SAs should correct that
+                // value later as the AI decides what to do (in checkApiLogic / checkAiLogic)
+                if (sa != null && sa.hasSVar(remCounter.getAmount())) {
+                    final String sVar = sa.getSVar(remCounter.getAmount());
+                    if (sVar.equals("XChoice")) {
+                        sa.setSVar("ChosenX", String.valueOf(source.getCounters(type)));
+                    }
+                }
+
                 // check the sa what the PaymentDecision is.
                 // ignore Loyality abilities with Zero as Cost
                 if (sa != null && !CounterType.LOYALTY.equals(type)) {
@@ -231,13 +238,15 @@ public class ComputerUtilCost {
      *            the source
      * @return true, if successful
      */
-    public static boolean checkCreatureSacrificeCost(final Player ai, final Cost cost, final Card source) {
+    public static boolean checkCreatureSacrificeCost(final Player ai, final Cost cost, final Card source, final SpellAbility sourceAbility) {
         if (cost == null) {
             return true;
         }
         for (final CostPart part : cost.getCostParts()) {
             if (part instanceof CostSacrifice) {
                 final CostSacrifice sac = (CostSacrifice) part;
+                final int amount = AbilityUtils.calculateAmount(source, sac.getAmount(), sourceAbility);
+
                 if (sac.payCostFromSource() && source.isCreature()) {
                     return false;
                 }
@@ -247,9 +256,18 @@ public class ComputerUtilCost {
                     continue;
                 }
 
-                final CardCollection typeList = CardLists.getValidCards(ai.getCardsIn(ZoneType.Battlefield), type.split(","), source.getController(), source, null);
-                if (ComputerUtil.getCardPreference(ai, source, "SacCost", typeList) == null) {
-                    return false;
+                final CardCollection sacList = new CardCollection();
+                final CardCollection typeList = CardLists.getValidCards(ai.getCardsIn(ZoneType.Battlefield), type.split(";"), source.getController(), source, null);
+
+                int count = 0;
+                while (count < amount) {
+                    Card prefCard = ComputerUtil.getCardPreference(ai, source, "SacCost", typeList);
+                    if (prefCard == null) {
+                        return false;
+                    }
+                    sacList.add(prefCard);
+                    typeList.remove(prefCard);
+                    count++;
                 }
             }
         }
@@ -267,13 +285,14 @@ public class ComputerUtilCost {
      *            is the gain important enough?
      * @return true, if successful
      */
-    public static boolean checkSacrificeCost(final Player ai, final Cost cost, final Card source, final boolean important) {
+    public static boolean checkSacrificeCost(final Player ai, final Cost cost, final Card source, final SpellAbility sourceAbility, final boolean important) {
         if (cost == null) {
             return true;
         }
         for (final CostPart part : cost.getCostParts()) {
             if (part instanceof CostSacrifice) {
                 final CostSacrifice sac = (CostSacrifice) part;
+                final int amount = AbilityUtils.calculateAmount(source, sac.getAmount(), sourceAbility);
 
                 final String type = sac.getType();
 
@@ -286,9 +305,19 @@ public class ComputerUtilCost {
                     }
                     continue;
                 }
+
+                final CardCollection sacList = new CardCollection();
                 final CardCollection typeList = CardLists.getValidCards(ai.getCardsIn(ZoneType.Battlefield), type.split(";"), source.getController(), source, null);
-                if (ComputerUtil.getCardPreference(ai, source, "SacCost", typeList) == null) {
-                    return false;
+
+                int count = 0;
+                while (count < amount) {
+                    Card prefCard = ComputerUtil.getCardPreference(ai, source, "SacCost", typeList);
+                    if (prefCard == null) {
+                        return false;
+                    }
+                    sacList.add(prefCard);
+                    typeList.remove(prefCard);
+                    count++;
                 }
             }
         }
@@ -336,7 +365,7 @@ public class ComputerUtilCost {
                     final int vehicleValue = ComputerUtilCard.evaluateCreature(vehicle);
                     String type = part.getType();
                     String totalP = type.split("withTotalPowerGE")[1];
-                    type = type.replace("+withTotalPowerGE" + totalP, "");
+                    type = TextUtil.fastReplace(type, TextUtil.concatNoSpace("+withTotalPowerGE", totalP), "");
                     CardCollection exclude = CardLists.getValidCards(
                             new CardCollection(ai.getCardsIn(ZoneType.Battlefield)), type.split(";"),
                             source.getController(), source, sa);
@@ -364,8 +393,8 @@ public class ComputerUtilCost {
      *            the source
      * @return true, if successful
      */
-    public static boolean checkSacrificeCost(final Player ai, final Cost cost, final Card source) {
-        return checkSacrificeCost(ai, cost, source, true);
+    public static boolean checkSacrificeCost(final Player ai, final Cost cost, final Card source, final SpellAbility sourceAbility) {
+        return checkSacrificeCost(ai, cost, source, sourceAbility,true);
     }
 
     /**
@@ -561,7 +590,7 @@ public class ComputerUtilCost {
 
         return checkLifeCost(payer, cost, source, 4, sa)
             && checkDamageCost(payer, cost, source, 4)
-            && (isMine || checkSacrificeCost(payer, cost, source))
+            && (isMine || checkSacrificeCost(payer, cost, source, sa))
             && (isMine || checkDiscardCost(payer, cost, source))
             && (!source.getName().equals("Tyrannize") || payer.getCardsIn(ZoneType.Hand).size() > 2)
             && (!source.getName().equals("Perplex") || payer.getCardsIn(ZoneType.Hand).size() < 2)

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

@@ -1,12 +1,8 @@
 package forge.ai;
 
 import com.google.common.base.Predicate;
-import com.google.common.collect.ArrayListMultimap;
-import com.google.common.collect.ListMultimap;
-import com.google.common.collect.Lists;
-import com.google.common.collect.Maps;
-import com.google.common.collect.Multimap;
-
+import com.google.common.base.Predicates;
+import com.google.common.collect.*;
 import forge.ai.ability.AnimateAi;
 import forge.card.ColorSet;
 import forge.card.MagicColor;
@@ -18,15 +14,12 @@ import forge.game.Game;
 import forge.game.GameActionUtil;
 import forge.game.ability.AbilityUtils;
 import forge.game.ability.ApiType;
-import forge.game.card.Card;
-import forge.game.card.CardCollection;
-import forge.game.card.CardCollectionView;
-import forge.game.card.CardLists;
-import forge.game.card.CardUtil;
+import forge.game.card.*;
 import forge.game.combat.CombatUtil;
 import forge.game.cost.Cost;
 import forge.game.cost.CostAdjustment;
 import forge.game.cost.CostPartMana;
+import forge.game.cost.CostPayEnergy;
 import forge.game.cost.CostPayment;
 import forge.game.mana.Mana;
 import forge.game.mana.ManaCostBeingPaid;
@@ -41,7 +34,6 @@ import forge.game.spellability.SpellAbility;
 import forge.game.zone.ZoneType;
 import forge.util.MyRandom;
 import forge.util.TextUtil;
-
 import org.apache.commons.lang3.StringUtils;
 import org.apache.commons.lang3.tuple.Pair;
 
@@ -203,20 +195,42 @@ public class ComputerUtilMana {
                 continue;
             }
 
-            if (sa.getHostCard() != null && sa.getApi() == ApiType.Animate) {
-                // For abilities like Genju of the Cedars, make sure that we're not activating the aura ability by tapping the enchanted card for mana
-                if (sa.getHostCard().isAura() && "Enchanted".equals(sa.getParam("Defined"))
-                        && ma.getHostCard() == sa.getHostCard().getEnchantingCard()
-                        && ma.getPayCosts().hasTapCost()) {
-                    continue;
+            if (sa.getHostCard() != null) {
+                if (sa.getApi() == ApiType.Animate) {
+                    // For abilities like Genju of the Cedars, make sure that we're not activating the aura ability by tapping the enchanted card for mana
+                    if (sa.getHostCard().isAura() && "Enchanted".equals(sa.getParam("Defined"))
+                            && ma.getHostCard() == sa.getHostCard().getEnchantingCard()
+                            && ma.getPayCosts().hasTapCost()) {
+                        continue;
+                    }
+
+                    // If a manland was previously animated this turn, do not tap it to animate another manland
+                    if (sa.getHostCard().isLand() && ma.getHostCard().isLand()
+                            && ai.getController().isAI()
+                            && AnimateAi.isAnimatedThisTurn(ai, ma.getHostCard())) {
+                        continue;
+                    }
+                } else if (sa.getApi() == ApiType.Pump) {
+                    if ((sa.getHostCard().isInstant() || sa.getHostCard().isSorcery())
+                            && ma.getHostCard().isCreature()
+                            && ai.getController().isAI()
+                            && ma.getPayCosts().hasTapCost()
+                            && sa.getTargets().getTargetCards().contains(ma.getHostCard())) {
+                        // do not activate pump instants/sorceries targeting creatures by tapping targeted
+                        // creatures for mana (for example, Servant of the Conduit)
+                        continue;
+                    }
+                } else if (sa.getApi() == ApiType.Attach
+                        && "AvoidPayingWithAttachTarget".equals(sa.getHostCard().getSVar("AIPaymentPreference"))) {
+                    // For cards like Genju of the Cedars, make sure we're not attaching to the same land that will
+                    // be tapped to pay its own cost if there's another untapped land like that available
+                    if (ma.getHostCard().equals(sa.getTargetCard())) {
+                        if (CardLists.filter(ai.getCardsIn(ZoneType.Battlefield), Predicates.and(CardPredicates.nameEquals(ma.getHostCard().getName()), CardPredicates.Presets.UNTAPPED)).size() > 1) {
+                            continue;
+                        }
+                    }
                 }
 
-                // If a manland was previously animated this turn, do not tap it to animate another manland
-                if (sa.getHostCard().isLand() && ma.getHostCard().isLand() 
-                        && ai.getController() instanceof PlayerControllerAi
-                        && AnimateAi.isAnimatedThisTurn(ai, ma.getHostCard())) {
-                    continue;
-                }
             }
 
             SpellAbility paymentChoice = ma;
@@ -231,8 +245,10 @@ public class ComputerUtilMana {
                 } else if (toPay == ManaCostShard.GENERIC || toPay == ManaCostShard.X) {
                     for (SpellAbility ab : saList) {
                         if (ab.isManaAbility() && ab.getManaPart().isAnyMana() && ab.hasParam("AddsNoCounter")) {
-                            paymentChoice = ab;
-                            break;
+                            if (!ab.getHostCard().isTapped()) {
+                                paymentChoice = ab;
+                                break;
+                            }
                         }
                     }
                 }
@@ -345,6 +361,7 @@ public class ComputerUtilMana {
         adjustManaCostToAvoidNegEffects(cost, sa.getHostCard(), ai);
         List<Mana> manaSpentToPay = test ? new ArrayList<Mana>() : sa.getPayingMana();
         boolean purePhyrexian = cost.containsOnlyPhyrexianMana();
+        int testEnergyPool = ai.getCounters(CounterType.ENERGY);
 
         List<SpellAbility> paymentList = Lists.newArrayList();
 
@@ -443,6 +460,16 @@ public class ComputerUtilMana {
             setExpressColorChoice(sa, ai, cost, toPay, saPayment);
 
             if (test) {
+				// Check energy when testing
+				CostPayEnergy energyCost = saPayment.getPayCosts().getCostEnergy();
+				if (energyCost != null) {
+					testEnergyPool -= Integer.parseInt(energyCost.getAmount());
+					if (testEnergyPool < 0) {
+						// Can't pay energy cost
+						break;
+					}
+				}
+
                 String manaProduced = toPay.isSnow() ? "S" : GameActionUtil.generatedMana(saPayment);
                 manaProduced = AbilityManaPart.applyManaReplacement(saPayment, manaProduced);
                 //System.out.println(manaProduced);
@@ -498,6 +525,16 @@ public class ComputerUtilMana {
 //                    extraMana, sa.getHostCard(), sa.toUnsuppressedString(), StringUtils.join(paymentPlan, "\n\t"));
 //        }
 
+        // See if it's possible to pay with something that was left in the mana pool in corner cases,
+        // e.g. Gemstone Caverns with a Luck counter on it generating colored mana (which fails to be
+        // processed correctly on a per-ability basis, leaving floating mana in the pool)
+        if (!cost.isPaid() && !manapool.isEmpty()) {
+            for (byte color : MagicColor.WUBRGC) {
+                manapool.tryPayCostWithColor(color, sa, cost);
+            }
+        }
+
+        // The cost is still unpaid, so refund the mana and report
         if (!cost.isPaid()) {
             refundMana(manaSpentToPay, ai, sa);
             if (test) {
@@ -809,7 +846,7 @@ public class ComputerUtilMana {
     }
 
     // isManaSourceReserved returns true if sourceCard is reserved as a mana source for payment
-    // for the future spell to be cast in Mana 2. However, if "sa" (the spell ability that is
+    // for the future spell to be cast in another phase. However, if "sa" (the spell ability that is
     // being considered for casting) is high priority, then mana source reservation will be
     // ignored.
     private static boolean isManaSourceReserved(Player ai, Card sourceCard, SpellAbility sa) {
@@ -823,8 +860,21 @@ public class ComputerUtilMana {
         AiController aic = ((PlayerControllerAi)ai.getController()).getAi();
         int chanceToReserve = aic.getIntProperty(AiProps.RESERVE_MANA_FOR_MAIN2_CHANCE);
 
+        PhaseType curPhase = ai.getGame().getPhaseHandler().getPhase();
+
+        // For combat tricks, always obey mana reservation
+        if (curPhase == PhaseType.COMBAT_DECLARE_BLOCKERS || curPhase == PhaseType.CLEANUP) {
+            AiCardMemory.clearMemorySet(ai, AiCardMemory.MemorySet.HELD_MANA_SOURCES_FOR_DECLBLK);
+        }
+        else {
+            if (AiCardMemory.isRememberedCard(ai, sourceCard, AiCardMemory.MemorySet.HELD_MANA_SOURCES_FOR_DECLBLK)) {
+                // This mana source is held elsewhere for a combat trick.
+                return true;
+            }
+        }
+
         // If it's a low priority spell (it's explicitly marked so elsewhere in the AI with a SVar), always
-        // obey mana reservations; otherwise, obey mana reservations depending on the "chance to reserve" 
+        // obey mana reservations for Main 2; otherwise, obey mana reservations depending on the "chance to reserve"
         // AI profile variable.
         if (sa.getSVar("LowPriorityAI").equals("")) {
             if (chanceToReserve == 0 || MyRandom.getRandom().nextInt(100) >= chanceToReserve) {
@@ -832,16 +882,16 @@ public class ComputerUtilMana {
             }
         }
 
-        PhaseType curPhase = ai.getGame().getPhaseHandler().getPhase();
         if (curPhase == PhaseType.MAIN2 || curPhase == PhaseType.CLEANUP) {
-            AiCardMemory.clearMemorySet(ai, AiCardMemory.MemorySet.HELD_MANA_SOURCES);
+            AiCardMemory.clearMemorySet(ai, AiCardMemory.MemorySet.HELD_MANA_SOURCES_FOR_MAIN2);
         }
         else {
-            if (AiCardMemory.isRememberedCard(ai, sourceCard, AiCardMemory.MemorySet.HELD_MANA_SOURCES)) {
+            if (AiCardMemory.isRememberedCard(ai, sourceCard, AiCardMemory.MemorySet.HELD_MANA_SOURCES_FOR_MAIN2)) {
                 // This mana source is held elsewhere for a Main Phase 2 spell.
                 return true;
             }
         }
+
         return false;
     }
 
@@ -1040,7 +1090,7 @@ public class ComputerUtilMana {
         ZoneType castFromBackup = null;
         if (test && sa.isSpell()) {
             castFromBackup = card.getCastFrom();
-            sa.getHostCard().setCastFrom(card.getZone().getZoneType());
+            sa.getHostCard().setCastFrom(card.getZone() != null ? card.getZone().getZoneType() : null);
         }
 
         Cost payCosts = CostAdjustment.adjust(sa.getPayCosts(), sa);
@@ -1065,7 +1115,9 @@ public class ComputerUtilMana {
                 final String xSvar = card.getSVar("X").startsWith("Count$xPaid") ? "PayX" : "X";
                 if (!sa.getSVar(xSvar).isEmpty() || card.hasSVar(xSvar)) {
                     if (xSvar.equals("PayX") && card.hasSVar(xSvar)) {
-                        manaToAdd = Integer.parseInt(card.getSVar(xSvar)) * cost.getXcounter(); // X
+                         // X SVar may end up being an empty string when copying a spell with no cost (e.g. Jhoira Avatar)
+                        String xValue = card.getSVar(xSvar);
+                        manaToAdd = xValue.isEmpty() ? 0 : Integer.parseInt(card.getSVar(xSvar)) * cost.getXcounter(); // X
                     } else {
                         manaToAdd = AbilityUtils.calculateAmount(card, xSvar, sa) * cost.getXcounter();
                     }
@@ -1099,8 +1151,65 @@ public class ComputerUtilMana {
         return cost;
     }
 
+    // This method can be used to estimate the total amount of mana available to the player,
+    // including the mana available in that player's mana pool
+    public static int getAvailableManaEstimate(final Player p) {
+        return getAvailableManaEstimate(p, true);
+    }
+
+    public static int getAvailableManaEstimate(final Player p, final boolean checkPlayable) {
+        int availableMana = 0;
+
+        final CardCollectionView list = new CardCollection(p.getCardsIn(ZoneType.Battlefield));
+        final List<Card> srcs = CardLists.filter(list, new Predicate<Card>() {
+            @Override
+            public boolean apply(final Card c) {
+                return !c.getManaAbilities().isEmpty();
+            }
+        });
+
+        int maxProduced = 0;
+        int producedWithCost = 0;
+        boolean hasSourcesWithNoManaCost = false;
+
+        for (Card src : srcs) {
+            maxProduced = 0;
+
+            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 producedMana = ma.getParamOrDefault("Produced", "").split(" ").length;
+                    int producedAmount = AbilityUtils.calculateAmount(src, ma.getParamOrDefault("Amount", "1"), ma);
+
+                    int producedTotal = producedMana * producedAmount - costsToActivate;
+
+                    if (costsToActivate > 0) {
+                        producedWithCost += producedTotal;
+                    } else if (!hasSourcesWithNoManaCost) {
+                        hasSourcesWithNoManaCost = true;
+                    }
+
+                    if (producedTotal > maxProduced) {
+                        maxProduced = producedTotal;
+                    }
+                }
+            }
+
+            availableMana += maxProduced;
+        }
+
+        availableMana += p.getManaPool().totalMana();
+
+        if (producedWithCost > 0 && !hasSourcesWithNoManaCost) {
+            availableMana -= producedWithCost; // probably can't activate them, no other mana available
+        }
+
+        return availableMana;
+    }
+
     //This method is currently used by AI to estimate available mana
-    public static CardCollection getAvailableMana(final Player ai, final boolean checkPlayable) {
+    public static CardCollection getAvailableManaSources(final Player ai, final boolean checkPlayable) {
         final CardCollectionView list = CardCollection.combine(ai.getCardsIn(ZoneType.Battlefield), ai.getCardsIn(ZoneType.Hand));
         final List<Card> manaSources = CardLists.filter(list, new Predicate<Card>() {
             @Override
@@ -1207,7 +1316,7 @@ public class ComputerUtilMana {
             System.out.println("DEBUG_MANA_PAYMENT: sortedManaSources = " + sortedManaSources);
         }
         return sortedManaSources;
-    } // getAvailableMana()
+    } // getAvailableManaSources()
 
     //This method is currently used by AI to estimate mana available
     private static ListMultimap<Integer, SpellAbility> groupSourcesByManaColor(final Player ai, boolean checkPlayable) {
@@ -1228,7 +1337,7 @@ public class ComputerUtilMana {
         }
 
         // Loop over all current available mana sources
-        for (final Card sourceCard : getAvailableMana(ai, checkPlayable)) {
+        for (final Card sourceCard : getAvailableManaSources(ai, checkPlayable)) {
             if (DEBUG_MANA_PAYMENT) {
                 System.out.println("DEBUG_MANA_PAYMENT: groupSourcesByManaColor sourceCard = " + sourceCard);
             }
@@ -1271,7 +1380,7 @@ public class ComputerUtilMana {
                         Card crd = replacementEffect.getHostCard();
                         String repType = crd.getSVar(replacementEffect.getMapParams().get("ManaReplacement"));
                         if (repType.contains("Chosen")) {
-                            repType = repType.replace("Chosen", MagicColor.toShortString(crd.getChosenColor()));
+                            repType = TextUtil.fastReplace(repType, "Chosen", MagicColor.toShortString(crd.getChosenColor()));
                         }
                         mp.setManaReplaceType(repType);
                     }

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

@@ -2,7 +2,12 @@ package forge.ai;
 
 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.cost.CostPayEnergy;
+import forge.game.keyword.KeywordInterface;
 import forge.game.spellability.SpellAbility;
 
 public class CreatureEvaluator implements Function<Card, Integer> {
@@ -19,13 +24,18 @@ public class CreatureEvaluator implements Function<Card, Integer> {
     }
 
     public int evaluateCreature(final Card c) {
+        return evaluateCreature(c, true, true);
+    }
+
+    public int evaluateCreature(final Card c, final boolean considerPT, final boolean considerCMC) {
         int value = 80;
         if (!c.isToken()) {
             value += addValue(20, "non-token"); // tokens should be worth less than actual cards
         }
         int power = getEffectivePower(c);
         final int toughness = getEffectiveToughness(c);
-        for (String keyword : c.getKeywords()) {
+        for (KeywordInterface kw : c.getKeywords()) {
+            String keyword = kw.getOriginal();
             if (keyword.equals("Prevent all combat damage that would be dealt by CARDNAME.")
                     || keyword.equals("Prevent all damage that would be dealt by CARDNAME.")
                     || keyword.equals("Prevent all combat damage that would be dealt to and dealt by CARDNAME.")
@@ -34,9 +44,13 @@ public class CreatureEvaluator implements Function<Card, Integer> {
                 break;
             }
         }
-        value += addValue(power * 15, "power");
-        value += addValue(toughness * 10, "toughness: " + toughness);
-        value += addValue(c.getCMC() * 5, "cmc");
+        if (considerPT) {
+            value += addValue(power * 15, "power");
+            value += addValue(toughness * 10, "toughness: " + toughness);
+        }
+        if (considerCMC) {
+            value += addValue(c.getCMC() * 5, "cmc");
+        }
     
         // Evasion keywords
         if (c.hasKeyword("Flying")) {
@@ -91,6 +105,7 @@ public class CreatureEvaluator implements Function<Card, Integer> {
                 value += addValue(power * 15, "infect");
             }
             value += addValue(c.getKeywordMagnitude("Rampage"), "rampage");
+            value += addValue(c.getKeywordMagnitude("Afflict") * 5, "afflict");
         }
     
         value += addValue(c.getKeywordMagnitude("Bushido") * 16, "bushido");
@@ -99,6 +114,14 @@ public class CreatureEvaluator implements Function<Card, Integer> {
         value += addValue(c.getKeywordMagnitude("Annihilator") * 50, "eldrazi");
         value += addValue(c.getKeywordMagnitude("Absorb") * 11, "absorb");
 
+        // Keywords that may produce temporary or permanent buffs over time
+        if (c.hasKeyword("Prowess")) {
+            value += addValue(5, "prowess");
+        }
+        if (c.hasKeyword("Outlast")) {
+            value += addValue(10, "outlast");
+        }
+
         // Defensive Keywords
         if (c.hasKeyword("Reach") && !c.hasKeyword("Flying")) {
             value += addValue(5, "reach");
@@ -184,7 +207,7 @@ public class CreatureEvaluator implements Function<Card, Integer> {
     
         for (final SpellAbility sa : c.getSpellAbilities()) {
             if (sa.isAbility()) {
-                value += addValue(10, "sa: " + sa);
+                value += addValue(evaluateSpellAbility(sa), "sa: " + sa);
             }
         }
         if (!c.getManaAbilities().isEmpty()) {
@@ -203,9 +226,44 @@ public class CreatureEvaluator implements Function<Card, Integer> {
         if (!c.getEncodedCards().isEmpty()) {
             value += addValue(24, "encoded");
         }
+
+        // card-specific evaluation modifier
+        if (c.hasSVar("AIEvaluationModifier")) {
+            int mod = AbilityUtils.calculateAmount(c, c.getSVar("AIEvaluationModifier"), null);
+            value += mod;
+        }
+
         return value;
     }
 
+    private int evaluateSpellAbility(SpellAbility sa) {
+        // Pump abilities
+        if (sa.getApi() == ApiType.Pump) {
+            // Pump abilities that grant +X/+X to the card
+            if ("+X".equals(sa.getParam("NumAtt"))
+                    && "+X".equals(sa.getParam("NumDef"))
+                    && !sa.usesTargeting()
+                    && (!sa.hasParam("Defined") || "Self".equals(sa.getParam("Defined")))) {
+                if (sa.getPayCosts() != null && 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);
+                    if (energy > 0) {
+                        int numActivations = energy / 3;
+                        for (int i = 0; i < numActivations; i++) {
+                            pumpedPower *= 2;
+                        }
+                        return (pumpedPower - initPower) * 15;
+                    }
+                }
+            }
+        }
+
+        // default value
+        return 10;
+    }
+
     protected int addValue(int value, String text) {
         return value;
     }

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

@@ -1,23 +1,9 @@
 package forge.ai;
 
-import java.io.BufferedReader;
-import java.io.InputStream;
-import java.io.InputStreamReader;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.EnumMap;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.Map.Entry;
-import java.util.Set;
-
 import com.google.common.collect.ArrayListMultimap;
 import com.google.common.collect.Lists;
 import com.google.common.collect.Maps;
 import com.google.common.collect.Multimap;
-
 import forge.StaticData;
 import forge.card.CardStateName;
 import forge.game.Game;
@@ -27,8 +13,8 @@ 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.CardFactory;
 import forge.game.card.CounterType;
+import forge.game.card.token.TokenInfo;
 import forge.game.combat.Combat;
 import forge.game.combat.CombatUtil;
 import forge.game.event.GameEventAttackersDeclared;
@@ -45,6 +31,12 @@ import forge.util.TextUtil;
 import forge.util.collect.FCollectionView;
 import org.apache.commons.lang3.StringUtils;
 
+import java.io.BufferedReader;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.util.*;
+import java.util.Map.Entry;
+
 public abstract class GameState {
     private static final Map<ZoneType, String> ZONES = new HashMap<ZoneType, String>();
     static {
@@ -61,6 +53,8 @@ public abstract class GameState {
     private String humanCounters = "";
     private String computerCounters = "";
 
+    private boolean puzzleCreatorState = false;
+
     private final Map<ZoneType, String> humanCardTexts = new EnumMap<ZoneType, String>(ZoneType.class);
     private final Map<ZoneType, String> aiCardTexts = new EnumMap<ZoneType, String>(ZoneType.class);
 
@@ -70,6 +64,8 @@ public abstract class GameState {
     private final Map<Card, List<String>> cardToChosenClrs = new HashMap<>();
     private final Map<Card, String> cardToChosenType = new HashMap<>();
     private final Map<Card, List<String>> cardToRememberedId = new HashMap<>();
+    private final Map<Card, List<String>> cardToImprintedId = new HashMap<>();
+    private final Map<Card, String> cardToNamedCard = new HashMap<>();
     private final Map<Card, String> cardToExiledWithId = new HashMap<>();
     private final Map<Card, Card> cardAttackMap = new HashMap<>();
 
@@ -78,6 +74,7 @@ public abstract class GameState {
     private final Map<String, String> abilityString = new HashMap<>();
 
     private final Set<Card> cardsReferencedByID = new HashSet<>();
+    private final Set<Card> cardsWithoutETBTrigs = new HashSet<>();
 
     private String tChangePlayer = "NONE";
     private String tChangePhase = "NONE";
@@ -85,6 +82,8 @@ public abstract class GameState {
     private String precastHuman = null;
     private String precastAI = null;
 
+    private int turn = 1;
+
     // Targeting for precast spells in a game state (mostly used by Puzzle Mode game states)
     private final int TARGET_NONE = -1; // untargeted spell (e.g. Joraga Invocation)
     private final int TARGET_HUMAN = -2;
@@ -98,18 +97,32 @@ public abstract class GameState {
     @Override
     public String toString() {
         StringBuilder sb = new StringBuilder();
-        sb.append(String.format("humanlife=%d\n", humanLife));
-        sb.append(String.format("ailife=%d\n", computerLife));
+
+        if (puzzleCreatorState) {
+            // append basic puzzle metadata if we're dumping from the puzzle creator screen
+            sb.append("[metadata]\n");
+            sb.append("Name:New Puzzle\n");
+            sb.append("URL:https://www.cardforge.org\n");
+            sb.append("Goal:Win\n");
+            sb.append("Turns:1\n");
+            sb.append("Difficulty:Easy\n");
+            sb.append("Description:Win this turn.\n");
+            sb.append("[state]\n");
+        }
+
+        sb.append(TextUtil.concatNoSpace("humanlife=", String.valueOf(humanLife), "\n"));
+        sb.append(TextUtil.concatNoSpace("ailife=", String.valueOf(computerLife), "\n"));
+        sb.append(TextUtil.concatNoSpace("turn=", String.valueOf(turn), "\n"));
 
         if (!humanCounters.isEmpty()) {
-            sb.append(String.format("humancounters=%s\n", humanCounters));
+            sb.append(TextUtil.concatNoSpace("humancounters=", humanCounters, "\n"));
         }
         if (!computerCounters.isEmpty()) {
-            sb.append(String.format("aicounters=%s\n", computerCounters));
+            sb.append(TextUtil.concatNoSpace("aicounters=", computerCounters, "\n"));
         }
 
-        sb.append(String.format("activeplayer=%s\n", tChangePlayer));
-        sb.append(String.format("activephase=%s\n", tChangePhase));
+        sb.append(TextUtil.concatNoSpace("activeplayer=", tChangePlayer, "\n"));
+        sb.append(TextUtil.concatNoSpace("activephase=", tChangePhase, "\n"));
         appendCards(humanCardTexts, "human", sb);
         appendCards(aiCardTexts, "ai", sb);
         return sb.toString();
@@ -117,13 +130,13 @@ public abstract class GameState {
 
     private void appendCards(Map<ZoneType, String> cardTexts, String categoryPrefix, StringBuilder sb) {
         for (Entry<ZoneType, String> kv : cardTexts.entrySet()) {
-            sb.append(String.format("%s%s=%s\n", categoryPrefix, ZONES.get(kv.getKey()), kv.getValue()));
+            sb.append(TextUtil.concatNoSpace(categoryPrefix, ZONES.get(kv.getKey()), "=", kv.getValue(), "\n"));
         }
     }
 
     public void initFromGame(Game game) throws Exception {
         FCollectionView<Player> players = game.getPlayers();
-        // Can only serialized a two player game with one AI and one human.
+        // Can only serialize a two player game with one AI and one human.
         if (players.size() != 2) {
             throw new Exception("Game not supported");
         }
@@ -139,6 +152,7 @@ public abstract class GameState {
 
         tChangePlayer = game.getPhaseHandler().getPlayerTurn() == ai ? "ai" : "human";
         tChangePhase = game.getPhaseHandler().getPhase().toString();
+        turn = game.getPhaseHandler().getTurn();
         aiCardTexts.clear();
         humanCardTexts.clear();
 
@@ -160,11 +174,14 @@ public abstract class GameState {
                 }
                 for (Object o : card.getRemembered()) {
                     // Remember the IDs of remembered cards
-                    // TODO: we can currently support remembered cards only. Expand to support other remembered objects.
                     if (o instanceof Card) {
                         cardsReferencedByID.add((Card)o);
                     }
                 }
+                for (Card i : card.getImprintedCards()) {
+                    // Remember the IDs of imprinted cards
+                    cardsReferencedByID.add(i);
+                }
                 if (game.getCombat() != null && game.getCombat().isAttacking(card)) {
                     // Remember the IDs of attacked planeswalkers
                     GameEntity def = game.getCombat().getDefenderByAttacker(card);
@@ -181,6 +198,9 @@ public abstract class GameState {
             aiCardTexts.put(zone, "");
             humanCardTexts.put(zone, "");
             for (Card card : game.getCardsIn(zone)) {
+                if (card.getName().equals("Puzzle Goal") && card.getOracleText().contains("New Puzzle")) {
+                    puzzleCreatorState = true;
+                }
                 if (card instanceof DetachedCardEffect) {
                     continue;
                 }
@@ -195,7 +215,7 @@ public abstract class GameState {
             newText.append(";");
         }
         if (c.isToken()) {
-            newText.append("t:" + new CardFactory.TokenInfo(c).toString());
+            newText.append("t:" + new TokenInfo(c).toString());
         } else {
             if (c.getPaperCard() == null) {
                 return;
@@ -240,11 +260,6 @@ public abstract class GameState {
             } else if (c.getCurrentStateName().equals(CardStateName.Meld)) {
                 newText.append("|Meld");
             }
-            Map<CounterType, Integer> counters = c.getCounters();
-            if (!counters.isEmpty()) {
-                newText.append("|Counters:");
-                newText.append(countersToString(counters));
-            }
             if (c.getEquipping() != null) {
                 newText.append("|Attaching:").append(c.getEquipping().getId());
             } else if (c.getFortifying() != null) {
@@ -263,6 +278,9 @@ public abstract class GameState {
             if (!c.getChosenType().isEmpty()) {
                 newText.append("|ChosenType:").append(c.getChosenType());
             }
+            if (!c.getNamedCard().isEmpty()) {
+                newText.append("|NamedCard:").append(c.getNamedCard());
+            }
 
             List<String> rememberedCardIds = Lists.newArrayList();
             for (Object obj : c.getRemembered()) {
@@ -274,12 +292,33 @@ public abstract class GameState {
             if (!rememberedCardIds.isEmpty()) {
                 newText.append("|RememberedCards:").append(TextUtil.join(rememberedCardIds, ","));
             }
+
+            List<String> imprintedCardIds = Lists.newArrayList();
+            for (Card impr : c.getImprintedCards()) {
+                int id = impr.getId();
+                imprintedCardIds.add(String.valueOf(id));
+            }
+            if (!imprintedCardIds.isEmpty()) {
+                newText.append("|Imprinting:").append(TextUtil.join(imprintedCardIds, ","));
+            }
         }
 
         if (zoneType == ZoneType.Exile) {
             if (c.getExiledWith() != null) {
                 newText.append("|ExiledWith:").append(c.getExiledWith().getId());
             }
+            if (c.isFaceDown()) {
+                newText.append("|FaceDown"); // Exiled face down
+            }
+        }
+
+        if (zoneType == ZoneType.Battlefield || zoneType == ZoneType.Exile) {
+            // A card can have counters on the battlefield and in exile (e.g. exiled by Mairsil, the Pretender)
+            Map<CounterType, Integer> counters = c.getCounters();
+            if (!counters.isEmpty()) {
+                newText.append("|Counters:");
+                newText.append(countersToString(counters));
+            }
         }
 
         if (c.getGame().getCombat() != null) {
@@ -305,7 +344,7 @@ public abstract class GameState {
             }
 
             first = false;
-            counterString.append(String.format("%s=%d", kv.getKey().toString(), kv.getValue()));
+            counterString.append(TextUtil.concatNoSpace(kv.getKey().toString(), "=", String.valueOf(kv.getValue())));
         }
         return counterString.toString();
     }
@@ -357,7 +396,11 @@ public abstract class GameState {
 
         boolean isHuman = categoryName.startsWith("human");
 
-        if (categoryName.endsWith("life")) {
+        if (categoryName.equals("turn")) {
+            turn = Integer.parseInt(categoryValue);
+        }
+
+        else if (categoryName.endsWith("life")) {
             if (isHuman)
                 humanLife = Integer.parseInt(categoryValue);
             else
@@ -464,7 +507,7 @@ public abstract class GameState {
             applyCountersToGameEntity(ai, computerCounters);
         }
 
-        game.getPhaseHandler().devModeSet(newPhase, newPlayerTurn);
+        game.getPhaseHandler().devModeSet(newPhase, newPlayerTurn, turn);
 
         game.getTriggerHandler().setSuppressAllTriggers(true);
 
@@ -495,7 +538,7 @@ public abstract class GameState {
     private void handleCombat(final Game game, final Player attackingPlayer, final Player defendingPlayer, final boolean toDeclareBlockers) {
         // First we need to ensure that all attackers are declared in the Declare Attackers step,
         // even if proceeding straight to Declare Blockers
-        game.getPhaseHandler().devModeSet(PhaseType.COMBAT_DECLARE_ATTACKERS, attackingPlayer);
+        game.getPhaseHandler().devModeSet(PhaseType.COMBAT_DECLARE_ATTACKERS, attackingPlayer, turn);
 
         if (game.getPhaseHandler().getCombat() == null) {
             game.getPhaseHandler().setCombat(new Combat(attackingPlayer));
@@ -558,6 +601,17 @@ public abstract class GameState {
             }
         }
 
+        // Imprinting: X
+        for (Entry<Card, List<String>> imprintedCards : cardToImprintedId.entrySet()) {
+            Card c = imprintedCards.getKey();
+            List<String> ids = imprintedCards.getValue();
+
+            for (String id : ids) {
+                Card tgt = idToCard.get(Integer.parseInt(id));
+                c.addImprintedCard(tgt);
+            }
+        }
+
         // Exiled with X
         for (Entry<Card, String> rememberedEnts : cardToExiledWithId.entrySet()) {
             Card c = rememberedEnts.getKey();
@@ -613,10 +667,10 @@ public abstract class GameState {
     private void executeScript(Game game, Card c, String sPtr) {
         int tgtID = TARGET_NONE;
         if (sPtr.contains("->")) {
-            String tgtDef = sPtr.substring(sPtr.indexOf("->") + 2);
+            String tgtDef = sPtr.substring(sPtr.lastIndexOf("->") + 2);
 
             tgtID = parseTargetInScript(tgtDef);
-            sPtr = sPtr.substring(0, sPtr.indexOf("->"));
+            sPtr = sPtr.substring(0, sPtr.lastIndexOf("->"));
         }
 
         SpellAbility sa = null;
@@ -628,15 +682,58 @@ public abstract class GameState {
                 System.err.println("ERROR: Unable to find SA with index " + numSA + " on card " + c + " to execute!");
             }
         } else {
-            if (!c.hasSVar(sPtr)) {
-                System.err.println("ERROR: Unable to find SVar " + sPtr + " on card " + c + " + to execute!");
-                return;
-            }
+            // Special handling for keyworded abilities
+            if (sPtr.startsWith("KW#")) {
+                String kwName = sPtr.substring(3);
+                FCollectionView<SpellAbility> saList = c.getSpellAbilities();
 
-            String svarValue = c.getSVar(sPtr);
-            sa = AbilityFactory.getAbility(svarValue, c);
-            if (sa == null) {
-                System.err.println("ERROR: Unable to generate ability for SVar " + svarValue);
+                if (kwName.equals("Awaken") || kwName.equals("AwakenOnly")) {
+                    // AwakenOnly only creates the Awaken effect, while Awaken precasts the whole spell with Awaken
+                    for (SpellAbility ab : saList) {
+                        if (ab.getDescription().startsWith("Awaken")) {
+                            ab.setActivatingPlayer(c.getController());
+                            ab.getSubAbility().setActivatingPlayer(c.getController());
+                            // target for Awaken is set in its first subability
+                            handleScriptedTargetingForSA(game, ab.getSubAbility(), tgtID);
+                            sa = kwName.equals("AwakenOnly") ? ab.getSubAbility() : ab;
+                        }
+                    }
+                    if (sa == null) {
+                        System.err.println("ERROR: Could not locate keyworded ability Awaken in card " + c + " to execute!");
+                        return;
+                    }
+                }
+            } else {
+                // SVar-based script execution
+                String svarValue = "";
+
+                if (sPtr.startsWith("CustomScript:")) {
+                    // A custom line defined in the game state file
+                    svarValue = sPtr.substring(sPtr.indexOf(":") + 1);
+                } else {
+                    // A SVar from the card script file
+                    if (!c.hasSVar(sPtr)) {
+                        System.err.println("ERROR: Unable to find SVar " + sPtr + " on card " + c + " + to execute!");
+                        return;
+                    }
+
+                    svarValue = c.getSVar(sPtr);
+
+                    if (tgtID != TARGET_NONE && svarValue.contains("| Defined$")) {
+                        // We want a specific target, so try to undefine a predefined target if possible
+                        svarValue = TextUtil.fastReplace(svarValue, "| Defined$", "| Undefined$");
+                        if (tgtID == TARGET_HUMAN || tgtID == TARGET_AI) {
+                            svarValue += " | ValidTgts$ Player";
+                        } else {
+                            svarValue += " | ValidTgts$ Card";
+                        }
+                    }
+                }
+
+                sa = AbilityFactory.getAbility(svarValue, c);
+                if (sa == null) {
+                    System.err.println("ERROR: Unable to generate ability for SVar " + svarValue);
+                }
             }
         }
 
@@ -644,6 +741,13 @@ public abstract class GameState {
         handleScriptedTargetingForSA(game, sa, tgtID);
 
         sa.resolve();
+
+        // resolve subabilities
+        SpellAbility subSa = sa.getSubAbility();
+        while (subSa != null) {
+            subSa.resolve();
+            subSa = subSa.getSubAbility();
+        }
     }
 
     private void handlePrecastSpells(final Game game) {
@@ -670,12 +774,12 @@ public abstract class GameState {
 
         if (spellDef.contains(":")) {
             // targeting via -> will be handled in executeScript
-            scriptID = spellDef.substring(spellDef.indexOf(":") + 1);
-            spellDef = spellDef.substring(0, spellDef.indexOf(":"));
+            scriptID = spellDef.substring(spellDef.indexOf(":") + 1).trim();
+            spellDef = spellDef.substring(0, spellDef.indexOf(":")).trim();
         } else if (spellDef.contains("->")) {
-            String tgtDef = spellDef.substring(spellDef.indexOf("->") + 2);
+            String tgtDef = spellDef.substring(spellDef.indexOf("->") + 2).trim();
             tgtID = parseTargetInScript(tgtDef);
-            spellDef = spellDef.substring(0, spellDef.indexOf("->"));
+            spellDef = spellDef.substring(0, spellDef.indexOf("->")).trim();
         }
 
         PaperCard pc = StaticData.instance().getCommonCards().getCard(spellDef);
@@ -728,6 +832,12 @@ public abstract class GameState {
             Card c = entry.getKey();
             c.setChosenType(entry.getValue());
         }
+
+        // Named card
+        for (Entry<Card, String> entry : cardToNamedCard.entrySet()) {
+            Card c = entry.getKey();
+            c.setNamedCard(entry.getValue());
+        }
     }
 
     private void handleCardAttachments() {
@@ -758,7 +868,7 @@ public abstract class GameState {
     }
 
     private void applyCountersToGameEntity(GameEntity entity, String counterString) {
-        //entity.setCounters(new HashMap<CounterType, Integer>());
+        entity.setCounters(Maps.<CounterType, Integer>newEnumMap(CounterType.class));
         String[] allCounterStrings = counterString.split(",");
         for (final String counterPair : allCounterStrings) {
             String[] pair = counterPair.split("=", 2);
@@ -796,14 +906,16 @@ public abstract class GameState {
                     // Note: Not clearCounters() since we want to keep the counters
                     // var as-is.
                     c.setCounters(Maps.<CounterType, Integer>newEnumMap(CounterType.class));
-                    p.getZone(ZoneType.Hand).add(c);
                     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)
                         c.setEnchanting(c);
+                    }
 
-                        p.getGame().getAction().moveToPlay(c, null);
+                    if (cardsWithoutETBTrigs.contains(c)) {
+                        p.getGame().getAction().moveTo(ZoneType.Battlefield, c, null);
                     } else {
+                        p.getZone(ZoneType.Hand).add(c);
                         p.getGame().getAction().moveToPlay(c, null);
                     }
 
@@ -845,8 +957,9 @@ public abstract class GameState {
             Card c;
             boolean hasSetCurSet = false;
             if (cardinfo[0].startsWith("t:")) {
+                // TODO Make sure Game State conversion works with new tokens
                 String tokenStr = cardinfo[0].substring(2);
-                c = CardFactory.makeOneToken(CardFactory.TokenInfo.fromString(tokenStr), player);
+                c = new TokenInfo(tokenStr).makeOneToken(player);
             } else {
                 PaperCard pc = StaticData.instance().getCommonCards().getCard(cardinfo[0], setCode);
                 if (pc == null) {
@@ -907,10 +1020,14 @@ public abstract class GameState {
                     cardToChosenClrs.put(c, Arrays.asList(info.substring(info.indexOf(':') + 1).split(",")));
                 } else if (info.startsWith("ChosenType:")) {
                     cardToChosenType.put(c, info.substring(info.indexOf(':') + 1));
+                } else if (info.startsWith("NamedCard:")) {
+                    cardToNamedCard.put(c, info.substring(info.indexOf(':') + 1));
                 } else if (info.startsWith("ExecuteScript:")) {
                     cardToScript.put(c, info.substring(info.indexOf(':') + 1));
                 } else if (info.startsWith("RememberedCards:")) {
                     cardToRememberedId.put(c, Arrays.asList(info.substring(info.indexOf(':') + 1).split(",")));
+                } else if (info.startsWith("Imprinting:")) {
+                    cardToImprintedId.put(c, Arrays.asList(info.substring(info.indexOf(':') + 1).split(",")));
                 } else if (info.startsWith("ExiledWith:")) {
                     cardToExiledWithId.put(c, info.substring(info.indexOf(':') + 1));
                 } else if (info.startsWith("Attacking")) {
@@ -920,6 +1037,8 @@ public abstract class GameState {
                     } else {
                         cardAttackMap.put(c, null);
                     }
+                } else if (info.equals("NoETBTrigs")) {
+                    cardsWithoutETBTrigs.add(c);
                 }
             }
 

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

@@ -1,23 +1,14 @@
 package forge.ai;
 
-import java.security.InvalidParameterException;
-import java.util.*;
-
-import forge.card.CardStateName;
-import org.apache.commons.lang3.StringUtils;
-import org.apache.commons.lang3.tuple.ImmutablePair;
-import org.apache.commons.lang3.tuple.Pair;
-
-import com.esotericsoftware.minlog.Log;
 import com.google.common.base.Predicate;
 import com.google.common.base.Predicates;
 import com.google.common.collect.Iterables;
 import com.google.common.collect.ListMultimap;
 import com.google.common.collect.Lists;
 import com.google.common.collect.Multimap;
-
 import forge.LobbyPlayer;
 import forge.ai.ability.ProtectAi;
+import forge.card.CardStateName;
 import forge.card.ColorSet;
 import forge.card.ICardFace;
 import forge.card.MagicColor;
@@ -33,18 +24,12 @@ import forge.game.ability.ApiType;
 import forge.game.card.*;
 import forge.game.card.CardPredicates.Presets;
 import forge.game.combat.Combat;
-import forge.game.cost.Cost;
-import forge.game.cost.CostPart;
-import forge.game.cost.CostPartMana;
+import forge.game.cost.*;
 import forge.game.mana.Mana;
 import forge.game.mana.ManaCostBeingPaid;
 import forge.game.phase.PhaseHandler;
 import forge.game.phase.PhaseType;
-import forge.game.player.DelayedReveal;
-import forge.game.player.Player;
-import forge.game.player.PlayerActionConfirmMode;
-import forge.game.player.PlayerController;
-import forge.game.player.PlayerView;
+import forge.game.player.*;
 import forge.game.replacement.ReplacementEffect;
 import forge.game.spellability.*;
 import forge.game.trigger.WrappedAbility;
@@ -55,6 +40,12 @@ import forge.util.ITriggerEvent;
 import forge.util.MyRandom;
 import forge.util.collect.FCollection;
 import forge.util.collect.FCollectionView;
+import org.apache.commons.lang3.StringUtils;
+import org.apache.commons.lang3.tuple.ImmutablePair;
+import org.apache.commons.lang3.tuple.Pair;
+
+import java.security.InvalidParameterException;
+import java.util.*;
 
 
 /** 
@@ -168,6 +159,14 @@ public class PlayerControllerAi extends PlayerController {
         return SpellApiToAi.Converter.get(api).chooseSingleEntity(player, sa, (FCollection<T>)optionList, isOptional, targetedPlayer);
     }
 
+    @Override
+    public <T extends GameEntity> List<T> chooseEntitiesForEffect(
+            FCollectionView<T> optionList, DelayedReveal delayedReveal, SpellAbility sa, String title,
+            Player targetedPlayer) {
+        // this isn't used
+        return null;
+    }
+
     @Override
     public SpellAbility chooseSingleSpellForEffect(java.util.List<SpellAbility> spells, SpellAbility sa, String title) {
         ApiType api = sa.getApi();
@@ -298,8 +297,43 @@ public class PlayerControllerAi extends PlayerController {
     }
 
     @Override
-    public CardCollectionView orderMoveToZoneList(CardCollectionView cards, ZoneType destinationZone) {
-        //TODO Add logic for AI ordering here
+    public CardCollectionView orderMoveToZoneList(CardCollectionView cards, ZoneType destinationZone, SpellAbility source) {
+        //TODO Add more logic for AI ordering here
+
+        // In presence of Volrath's Shapeshifter in deck, try to place the best creature on top of the graveyard
+        if (destinationZone == ZoneType.Graveyard) {
+            if (!CardLists.filter(game.getCardsInGame(), new Predicate<Card>() {
+                @Override
+                public boolean apply(Card card) {
+                    // need a custom predicate here since Volrath's Shapeshifter may have a different name OTB
+                    return card.getName().equals("Volrath's Shapeshifter")
+                            || card.getStates().contains(CardStateName.OriginalText) && card.getState(CardStateName.OriginalText).getName().equals("Volrath's Shapeshifter");
+                }
+            }).isEmpty()) {
+                int bestValue = 0;
+                Card bestCreature = null;
+                for (Card c : cards) {
+                    int curValue = ComputerUtilCard.evaluateCreature(c);
+                    if (c.isCreature() && curValue > bestValue) {
+                        bestValue = curValue;
+                        bestCreature = c;
+                    }
+                }
+
+                if (bestCreature != null) {
+                    CardCollection reordered = new CardCollection();
+                    for (Card c : cards) {
+                        if (!c.equals(bestCreature)) {
+                            reordered.add(c);
+                        }
+                    }
+                    reordered.add(bestCreature);
+                    return reordered;
+                }
+            }
+        }
+
+        // Default: return with the same order as was passed into this method
         return cards;
     }
 
@@ -371,7 +405,7 @@ public class PlayerControllerAi extends PlayerController {
         if (StringUtils.isBlank(chosen) && !validTypes.isEmpty())
         {
             chosen = validTypes.get(0);
-            Log.warn("AI has no idea how to choose " + kindOfType +", defaulting to 1st element: chosen");
+            System.err.println("AI has no idea how to choose " + kindOfType +", defaulting to 1st element: chosen");
         }
         game.getAction().nofityOfValue(sa, player, chosen, player);
         return chosen;
@@ -414,8 +448,10 @@ public class PlayerControllerAi extends PlayerController {
     @Override
     public void playChosenSpellAbility(SpellAbility sa) {
         // System.out.println("Playing sa: " + sa);
-        if (sa == sa.getHostCard().getGame().PLAY_LAND_SURROGATE) {
-            player.playLand(sa.getHostCard(), false);
+        if (sa instanceof LandAbility) {
+            if (sa.canPlay()) {
+                sa.resolve();
+            }
         } else {
             ComputerUtil.handlePlayingSpellAbility(player, sa, game);
         }
@@ -437,6 +473,24 @@ public class PlayerControllerAi extends PlayerController {
         final Ability ability = new AbilityStatic(c, cost, null) { @Override public void resolve() {} };
         ability.setActivatingPlayer(c.getController());
 
+        // FIXME: This is a hack to check if the AI can play the "exile from library" pay costs (Cumulative Upkeep,
+        // e.g. Thought Lash). We have to do it and bail early if the AI can't pay, because otherwise the AI will
+        // pay the cost partially, which should not be possible
+        int nExileLib = 0;
+        List<CostPart> parts = CostAdjustment.adjust(cost, sa).getCostParts();
+        for (final CostPart part : parts) {
+            if (part instanceof CostExile) {
+                CostExile exile = (CostExile) part;
+                if (exile.from == ZoneType.Library) {
+                    nExileLib += exile.convertAmount();
+                }
+            }
+        }
+        if (nExileLib > c.getController().getCardsIn(ZoneType.Library).size()) {
+            return false;
+        }
+        // - End of hack for Exile a card from library Cumulative Upkeep -
+
         if (ComputerUtilCost.canPayCost(ability, c.getController())) {
             ComputerUtil.playNoStack(c.getController(), ability, game);
             return true;
@@ -509,7 +563,41 @@ public class PlayerControllerAi extends PlayerController {
     public boolean chooseBinary(SpellAbility sa, String question, BinaryChoiceType kindOfChoice, Boolean defaultVal) {
         switch(kindOfChoice) {
             case TapOrUntap: return true;
-            case UntapOrLeaveTapped: return defaultVal != null && defaultVal.booleanValue();
+            case UntapOrLeaveTapped:
+                Card source = sa.getHostCard();
+                if (source != null && source.hasSVar("AIUntapPreference")) {
+                    switch (source.getSVar("AIUntapPreference")) {
+                        case "Always":
+                            return true;
+                        case "Never":
+                            return false;
+                        case "NothingRemembered":
+                            if (source.getRememberedCount() == 0) {
+                                return true;
+                            } else {
+                                Card rem = (Card) source.getFirstRemembered();
+                                if (!rem.getZone().is(ZoneType.Battlefield)) {
+                                    return true;
+                                }
+                            }
+                        case "BetterTgtThanRemembered":
+                            if (source.getRememberedCount() > 0) {
+                                Card rem = (Card) source.getFirstRemembered();
+                                if (!rem.getZone().is(ZoneType.Battlefield)) {
+                                    return true;
+                                }
+                                for (Card c : source.getController().getCreaturesInPlay()) {
+                                    if (c != rem && ComputerUtilCard.evaluateCreature(c) > ComputerUtilCard.evaluateCreature(rem) + 30) {
+                                        return true;
+                                    }
+                                }
+                                return false;
+                            }
+                        default:
+                            break;
+                    }
+                }
+                return defaultVal != null && defaultVal.booleanValue();
             case UntapTimeVault: return false; // TODO Should AI skip his turn for time vault?
             case LeftOrRight: return brains.chooseDirection(sa);
             default:
@@ -796,11 +884,6 @@ public class PlayerControllerAi extends PlayerController {
         return brains.getBooleanProperty(AiProps.CHEAT_WITH_MANA_ON_SHUFFLE) ? brains.cheatShuffle(list) : list;
     }
 
-	@Override
-	public CardShields chooseRegenerationShield(Card c) {
-		return Iterables.getFirst(c.getShields(), null);
-	}
-
     @Override
     public List<PaperCard> chooseCardsYouWonToAddToDeck(List<PaperCard> losses) {
         // TODO AI takes all by default
@@ -892,6 +975,8 @@ public class PlayerControllerAi extends PlayerController {
             } else if (logic.equals("MostProminentSpellInComputerDeck")) {
                 CardCollectionView cards = CardLists.getValidCards(aiLibrary, "Card.Instant,Card.Sorcery", player, sa.getHostCard());
                 return ComputerUtilCard.getMostProminentCardName(cards);
+            } else if (logic.equals("CursedScroll")) {
+                return SpecialCardAi.CursedScroll.chooseCard(player, sa);
             }
         } else {
             CardCollectionView list = CardLists.filterControlledBy(game.getCardsInGame(), player.getOpponents());
@@ -913,6 +998,14 @@ public class PlayerControllerAi extends PlayerController {
         return brains.chooseCardToHiddenOriginChangeZone(destination, origin, sa, fetchList, player, decider);
     }
 
+    @Override
+    public List<Card> chooseCardsForZoneChange(
+            ZoneType destination, List<ZoneType> origin, SpellAbility sa, CardCollection fetchList,
+            DelayedReveal delayedReveal, String selectPrompt, Player decider) {
+        // this isn't used
+        return null;
+    }
+
     @Override
     public void resetAtEndOfTurn() {
         // TODO - if card memory is ever used to remember something for longer than a turn, make sure it's not reset here.

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

@@ -25,9 +25,13 @@ import forge.card.ColorSet;
 import forge.card.MagicColor;
 import forge.card.mana.ManaCost;
 import forge.game.Game;
+import forge.game.GameType;
+import forge.game.ability.AbilityFactory;
 import forge.game.ability.AbilityUtils;
 import forge.game.ability.ApiType;
 import forge.game.card.*;
+import forge.game.combat.Combat;
+import forge.game.combat.CombatUtil;
 import forge.game.cost.CostPart;
 import forge.game.mana.ManaCostBeingPaid;
 import forge.game.phase.PhaseHandler;
@@ -35,8 +39,16 @@ import forge.game.phase.PhaseType;
 import forge.game.player.Player;
 import forge.game.player.PlayerPredicates;
 import forge.game.spellability.SpellAbility;
+import forge.game.spellability.SpellPermanent;
+import forge.game.staticability.StaticAbility;
+import forge.game.trigger.Trigger;
 import forge.game.zone.ZoneType;
 import forge.util.Aggregates;
+import forge.util.MyRandom;
+import forge.util.TextUtil;
+import forge.util.maps.LinkedHashMapToAmount;
+import forge.util.maps.MapToAmount;
+import org.apache.commons.lang3.tuple.Pair;
 
 import java.util.Arrays;
 import java.util.Collections;
@@ -66,8 +78,8 @@ public class SpecialCardAi {
 
     // Black Lotus and Lotus Bloom
     public static class BlackLotus {
-        public static boolean consider(Player ai, SpellAbility sa, ManaCostBeingPaid cost) {
-            CardCollection manaSources = ComputerUtilMana.getAvailableMana(ai, true);
+        public static boolean consider(final Player ai, final SpellAbility sa, final ManaCostBeingPaid cost) {
+            CardCollection manaSources = ComputerUtilMana.getAvailableManaSources(ai, true);
             int numManaSrcs = manaSources.size();
 
             CardCollection allCards = CardLists.filter(ai.getAllCards(), Arrays.asList(CardPredicates.Presets.NON_TOKEN,
@@ -93,49 +105,9 @@ public class SpecialCardAi {
         }
     }
 
-    // Bonds of Faith
-    public static class BondsOfFaith {
-        public static Card getBestAttachTarget(final Player ai, SpellAbility sa, List<Card> list) {
-            Card chosen = null;
-            
-            List<Card> aiHumans = CardLists.filter(list, new Predicate<Card>() {
-                @Override
-                public boolean apply(final Card c) {
-                    // Don't buff opponent's humans
-                    if (!c.getController().equals(ai)) {
-                        return false;
-                    }
-                    return c.getType().hasCreatureType("Human");
-                }
-            });
-            List<Card> oppNonHumans = CardLists.filter(list, new Predicate<Card>() {
-                @Override
-                public boolean apply(final Card c) {
-                    // Don't debuff AI's own non-humans
-                    if (c.getController().equals(ai)) {
-                        return false;
-                    }
-                    return !c.getType().hasCreatureType("Human") && !ComputerUtilCard.isUselessCreature(ai, c);
-                }
-            });
-
-            if (!aiHumans.isEmpty() && !oppNonHumans.isEmpty()) {
-                Card bestAi = ComputerUtilCard.getBestCreatureAI(aiHumans);
-                Card bestOpp = ComputerUtilCard.getBestCreatureAI(oppNonHumans);
-                chosen = ComputerUtilCard.evaluateCreature(bestAi) > ComputerUtilCard.evaluateCreature(bestOpp) ? bestAi : bestOpp;
-            } else if (!aiHumans.isEmpty()) {
-                chosen = ComputerUtilCard.getBestCreatureAI(aiHumans);
-            } else if (!oppNonHumans.isEmpty()) {
-                chosen = ComputerUtilCard.getBestCreatureAI(oppNonHumans);
-            }
-            
-            return chosen;
-        }
-    }
-
     // Chain of Acid
     public static class ChainOfAcid {
-        public static boolean consider(Player ai, SpellAbility sa) {
+        public static boolean consider(final Player ai, final SpellAbility sa) {
             List<Card> AiLandsOnly = CardLists.filter(ai.getCardsIn(ZoneType.Battlefield),
                     CardPredicates.Presets.LANDS);
             List<Card> OppPerms = CardLists.filter(ai.getOpponents().getCardsIn(ZoneType.Battlefield),
@@ -151,7 +123,7 @@ public class SpecialCardAi {
 
     // Chain of Smog
     public static class ChainOfSmog {
-        public static boolean consider(Player ai, SpellAbility sa) {
+        public static boolean consider(final Player ai, final SpellAbility sa) {
             if (ai.getCardsIn(ZoneType.Hand).isEmpty()) {
                 // to avoid failure to add to stack, provide a legal target opponent first (choosing random at this point)
                 // TODO: this makes the AI target opponents with 0 cards in hand, but bailing from here causes a
@@ -174,11 +146,66 @@ public class SpecialCardAi {
         }
     }
 
+    // Cursed Scroll
+    public static class CursedScroll {
+        public static boolean consider(final Player ai, final SpellAbility sa) {
+            CardCollectionView hand = ai.getCardsIn(ZoneType.Hand);
+            if (hand.isEmpty()) {
+                return false;
+            }
+
+            // For now, see if all cards in hand have the same name, and then proceed if true
+            return CardLists.filter(hand, CardPredicates.nameEquals(hand.getFirst().getName())).size() == hand.size();
+        }
+
+        public static String chooseCard(final Player ai, final SpellAbility sa) {
+            int maxCount = 0;
+            Card best = null;
+            CardCollectionView hand = ai.getCardsIn(ZoneType.Hand);
+
+            for (Card c : ai.getCardsIn(ZoneType.Hand)) {
+                int count = CardLists.filter(hand, CardPredicates.nameEquals(c.getName())).size();
+                if (count > maxCount) {
+                    maxCount = count;
+                    best = c;
+                }
+            }
+
+            return best.getName();
+        }
+    }
+
+    // Deathgorge Scavenger
+    public static class DeathgorgeScavenger {
+        public static boolean consider(final Player ai, final SpellAbility sa) {
+            Card worstCreat = ComputerUtilCard.getWorstAI(CardLists.filter(ai.getOpponents().getCardsIn(ZoneType.Graveyard), CardPredicates.Presets.CREATURES));
+            Card worstNonCreat = ComputerUtilCard.getWorstAI(CardLists.filter(ai.getOpponents().getCardsIn(ZoneType.Graveyard), Predicates.not(CardPredicates.Presets.CREATURES)));
+            if (worstCreat == null) {
+                worstCreat = ComputerUtilCard.getWorstAI(CardLists.filter(ai.getCardsIn(ZoneType.Graveyard), CardPredicates.Presets.CREATURES));
+            }
+            if (worstNonCreat == null) {
+                worstNonCreat = ComputerUtilCard.getWorstAI(CardLists.filter(ai.getCardsIn(ZoneType.Graveyard), Predicates.not(CardPredicates.Presets.CREATURES)));
+            }
+
+            sa.resetTargets();
+            if (worstCreat != null && ai.getLife() <= ai.getStartingLife() / 4) {
+                sa.getTargets().add(worstCreat);
+            } else if (worstNonCreat != null && ai.getGame().getCombat() != null
+                    && ai.getGame().getCombat().isAttacking(sa.getHostCard())) {
+                sa.getTargets().add(worstNonCreat);
+            } else if (worstCreat != null) {
+                sa.getTargets().add(worstCreat);
+            }
+
+            return sa.getTargets().getNumTargeted() > 0;
+        }
+    }
+
     // Desecration Demon
     public static class DesecrationDemon {
         private static final int demonSacThreshold = Integer.MAX_VALUE; // if we're in dire conditions, sac everything from worst to best hoping to find an answer
 
-        public static boolean considerSacrificingCreature(Player ai, SpellAbility sa) {
+        public static boolean considerSacrificingCreature(final Player ai, final SpellAbility sa) {
             CardCollection flyingCreatures = CardLists.filter(ai.getCardsIn(ZoneType.Battlefield), Predicates.and(CardPredicates.Presets.UNTAPPED, Predicates.or(CardPredicates.hasKeyword("Flying"), CardPredicates.hasKeyword("Reach"))));
             boolean hasUsefulBlocker = false;
 
@@ -202,7 +229,7 @@ public class SpecialCardAi {
 
     // Donate
     public static class Donate {
-        public static boolean considerTargetingOpponent(Player ai, SpellAbility sa) {
+        public static boolean considerTargetingOpponent(final Player ai, final SpellAbility sa) {
             final Card donateTarget = ComputerUtil.getCardPreference(ai, sa.getHostCard(), "DonateMe", CardLists.filter(
                     ai.getCardsIn(ZoneType.Battlefield).threadSafeIterable(), CardPredicates.hasSVar("DonateMe")));
             if (donateTarget != null) {
@@ -238,7 +265,7 @@ public class SpecialCardAi {
             return false;
         }
 
-        public static boolean considerDonatingPermanent(Player ai, SpellAbility sa) {
+        public static boolean considerDonatingPermanent(final Player ai, final SpellAbility sa) {
             Card donateTarget = ComputerUtil.getCardPreference(ai, sa.getHostCard(), "DonateMe", CardLists.filter(ai.getCardsIn(ZoneType.Battlefield).threadSafeIterable(), CardPredicates.hasSVar("DonateMe")));
             if (donateTarget != null) {
                 sa.resetTargets();
@@ -252,9 +279,199 @@ public class SpecialCardAi {
         }
     }
 
+    // Electrostatic Pummeler
+    public static class ElectrostaticPummeler {
+        public static boolean consider(final Player ai, final SpellAbility sa) {
+            final Card source = sa.getHostCard();
+            Game game = ai.getGame();
+            Combat combat = game.getCombat();
+            Pair<Integer, Integer> predictedPT = getPumpedPT(ai, source.getNetCombatDamage(), source.getNetToughness());
+
+            // Try to save the Pummeler from death by pumping it if it's threatened with a damage spell
+            if (ComputerUtil.predictThreatenedObjects(ai, null, true).contains(source)) {
+                SpellAbility saTop = game.getStack().peekAbility();
+
+                if (saTop.getApi() == ApiType.DealDamage || saTop.getApi() == ApiType.DamageAll) {
+                    int dmg = AbilityUtils.calculateAmount(saTop.getHostCard(), saTop.getParam("NumDmg"), saTop);
+                    if (source.getNetToughness() - source.getDamage() <= dmg && predictedPT.getRight() - source.getDamage() > dmg)
+                    return true;
+                }
+            }
+
+            // Do not activate if damage will be prevented
+            if (source.staticDamagePrevention(predictedPT.getLeft(), source, true, true) == 0) {
+                return false;
+            }
+
+            // Activate Electrostatic Pummeler's pump only as a combat trick
+            if (game.getPhaseHandler().is(PhaseType.COMBAT_BEGIN)) {
+                if (predictOverwhelmingDamage(ai, sa)) {
+                    // We'll try to deal lethal trample/unblocked damage, so remember the card for attack
+                    // and wait until declare blockers step.
+                    AiCardMemory.rememberCard(ai, source, AiCardMemory.MemorySet.MANDATORY_ATTACKERS);
+                    return false;
+                }
+            } else if (!game.getPhaseHandler().is(PhaseType.COMBAT_DECLARE_BLOCKERS)) {
+                return false;
+            }
+
+            if (combat == null || !(combat.isAttacking(source) || combat.isBlocking(source))) {
+                return false;
+            }
+
+            boolean isBlocking = combat.isBlocking(source);
+            boolean cantDie = ComputerUtilCombat.attackerCantBeDestroyedInCombat(ai, source);
+
+            CardCollection opposition = isBlocking ? combat.getAttackersBlockedBy(source) : combat.getBlockers(source);
+            int oppP = Aggregates.sum(opposition, CardPredicates.Accessors.fnGetAttack);
+            int oppT = Aggregates.sum(opposition, CardPredicates.Accessors.fnGetNetToughness);
+
+            boolean oppHasFirstStrike = false;
+            boolean oppCantDie = true;
+            boolean unblocked = opposition.isEmpty();
+            boolean canTrample = source.hasKeyword("Trample");
+
+            if (!isBlocking && combat.getDefenderByAttacker(source) instanceof Card) {
+                int loyalty = ((Card)combat.getDefenderByAttacker(source)).getCounters(CounterType.LOYALTY);
+                int totalDamageToPW = 0;
+                for (Card atk : (combat.getAttackersOf(combat.getDefenderByAttacker(source)))) {
+                    if (combat.isUnblocked(atk)) {
+                        totalDamageToPW += atk.getNetCombatDamage();
+                    }
+                }
+                if (totalDamageToPW >= oppT + loyalty) {
+                    // Already enough damage to take care of the planeswalker
+                    return false;
+                }
+                if ((unblocked || canTrample) && predictedPT.getLeft() >= oppT + loyalty) {
+                    // Can pump to kill the planeswalker, go for it
+                    return true;
+                }
+
+            }
+
+            for (Card c : opposition) {
+                if (c.hasKeyword("First Strike") || c.hasKeyword("Double Strike")) {
+                    oppHasFirstStrike = true;
+                }
+                if (!ComputerUtilCombat.attackerCantBeDestroyedInCombat(c.getController(), c)) {
+                    oppCantDie = false;
+                }
+            }
+
+            if (!isBlocking) {
+                int oppLife = combat.getDefendingPlayerRelatedTo(source).getLife();
+                if (((unblocked || canTrample) && (predictedPT.getLeft() - oppT > oppLife / 2))
+                        || (canTrample && predictedPT.getLeft() - oppT > 0 && predictedPT.getRight() > oppP)) {
+                    // We can deal a lot of damage (either a lot of damage directly to the opponent,
+                    // or kill the blocker(s) and damage the opponent at the same time, so go for it
+                    AiCardMemory.rememberCard(ai, source, AiCardMemory.MemorySet.MANDATORY_ATTACKERS);
+                    return true;
+                }
+            }
+
+            if (predictedPT.getRight() - source.getDamage() <= oppP && oppHasFirstStrike && !cantDie) {
+                // Can't survive first strike or double strike, don't pump
+                return false;
+            }
+            if (predictedPT.getLeft() < oppT && (!cantDie || predictedPT.getRight() - source.getDamage() <= oppP)) {
+                // Can't pump enough to kill the blockers and survive, don't pump
+                return false;
+            }
+            if (source.getNetCombatDamage() > oppT && source.getNetToughness() > oppP) {
+                // Already enough to kill the blockers and survive, don't overpump
+                return false;
+            }
+            if (oppCantDie && !source.hasKeyword("Trample") && !source.hasKeyword("Wither")
+                    && !source.hasKeyword("Infect") && predictedPT.getLeft() <= oppT) {
+                // Can't kill or cripple anyone, as well as can't Trample over, so don't pump
+                return false;
+            }
+
+            // If we got here, it should be a favorable combat pump, resulting in at least one
+            // opposing creature dying, and hopefully with the Pummeler surviving combat.
+            return true;
+        }
+
+        public static boolean predictOverwhelmingDamage(final Player ai, final SpellAbility sa) {
+            final Card source = sa.getHostCard();
+            int oppLife = ai.getWeakestOpponent().getLife();
+            CardCollection oppInPlay = ai.getWeakestOpponent().getCreaturesInPlay();
+            CardCollection potentialBlockers = new CardCollection();
+
+            for (Card b : oppInPlay) {
+                if (CombatUtil.canBlock(sa.getHostCard(), b)) {
+                    potentialBlockers.add(b);
+                }
+            }
+
+            Pair<Integer, Integer> predictedPT = getPumpedPT(ai, source.getNetCombatDamage(), source.getNetToughness());
+            int oppT = Aggregates.sum(potentialBlockers, CardPredicates.Accessors.fnGetNetToughness);
+
+            if (potentialBlockers.isEmpty() || (sa.getHostCard().hasKeyword("Trample") && predictedPT.getLeft() - oppT >= oppLife)) {
+                return true;
+            }
+
+            return false;
+        }
+
+        public static Pair<Integer, Integer> getPumpedPT(Player ai, int power, int toughness) {
+            int energy = ai.getCounters(CounterType.ENERGY);
+            if (energy > 0) {
+                int numActivations = energy / 3;
+                for (int i = 0; i < numActivations; i++) {
+                    power *= 2;
+                    toughness *= 2;
+                }
+            }
+
+            return Pair.of(power, toughness);
+        }
+    }
+
+    // Extraplanar Lens
+    public static class ExtraplanarLens {
+        public static boolean consider(final Player ai, final SpellAbility sa) {
+            Card bestBasic = null;
+            Card bestBasicSelfOnly = null;
+
+            CardCollection aiLands = CardLists.filter(ai.getCardsIn(ZoneType.Battlefield), CardPredicates.Presets.LANDS_PRODUCING_MANA);
+            CardCollection oppLands = CardLists.filter(ai.getOpponents().getCardsIn(ZoneType.Battlefield),
+                    CardPredicates.Presets.LANDS_PRODUCING_MANA);
+
+            int bestCount = 0;
+            int bestSelfOnlyCount = 0;
+            for (String landType : MagicColor.Constant.BASIC_LANDS) {
+                CardCollection landsOfType = CardLists.filter(aiLands, CardPredicates.nameEquals(landType));
+                CardCollection oppLandsOfType = CardLists.filter(oppLands, CardPredicates.nameEquals(landType));
+
+                int numCtrl = CardLists.filter(aiLands, CardPredicates.nameEquals(landType)).size();
+                if (numCtrl > bestCount) {
+                    bestCount = numCtrl;
+                    bestBasic = ComputerUtilCard.getWorstLand(landsOfType);
+                }
+                if (numCtrl > bestSelfOnlyCount && numCtrl > 1 && oppLandsOfType.isEmpty() && bestBasicSelfOnly == null) {
+                    bestSelfOnlyCount = numCtrl;
+                    bestBasicSelfOnly = ComputerUtilCard.getWorstLand(landsOfType);
+                }
+            }
+
+            sa.resetTargets();
+            if (bestBasicSelfOnly != null) {
+                sa.getTargets().add(bestBasicSelfOnly);
+                return true;
+            } else if (bestBasic != null) {
+                sa.getTargets().add(bestBasic);
+                return true;
+            }
+
+            return false;
+        }
+    }
+
     // Force of Will
     public static class ForceOfWill {
-        public static boolean consider(Player ai, SpellAbility sa) {
+        public static boolean consider(final Player ai, final SpellAbility sa) {
             CardCollection blueCards = CardLists.filter(ai.getCardsIn(ZoneType.Hand), CardPredicates.isColor(MagicColor.BLUE));
 
             boolean isExileMode = false;
@@ -281,8 +498,9 @@ public class SpecialCardAi {
         }
     }
 
+    // Guilty Conscience
     public static class GuiltyConscience {
-        public static Card getBestAttachTarget(final Player ai, SpellAbility sa, List<Card> list) {
+        public static Card getBestAttachTarget(final Player ai, final SpellAbility sa, final List<Card> list) {
             Card chosen = null;
             
             List<Card> aiStuffies = CardLists.filter(list, new Predicate<Card>() {
@@ -317,10 +535,148 @@ public class SpecialCardAi {
         }
     }
 
-    // Living Death (and possibly other similar cards using AILogic LivingDeath)
+    // Intuition (and any other card that might potentially let you pick N cards from the library,
+    // one of which will then be picked for you by the opponent)
+    public static class Intuition {
+        public static CardCollection considerMultiple(final Player ai, final SpellAbility sa) {
+            if (ai.getController().isAI()) {
+                if (!((PlayerControllerAi) ai.getController()).getAi().getBooleanProperty(AiProps.INTUITION_ALTERNATIVE_LOGIC)) {
+                    return new CardCollection(); // fall back to standard ChangeZoneAi considerations
+                }
+            }
+
+            int changeNum = AbilityUtils.calculateAmount(sa.getHostCard(), sa.getParam("ChangeNum"), sa);
+            CardCollection lib = CardLists.filter(ai.getCardsIn(ZoneType.Library),
+                    Predicates.not(CardPredicates.nameEquals(sa.getHostCard().getName())));
+            Collections.sort(lib, CardLists.CmcComparatorInv);
+
+            // Additional cards which are difficult to auto-classify but which are generally good to Intuition for
+            List<String> highPriorityNamedCards = Lists.newArrayList("Accumulated Knowledge", "Take Inventory");
+
+            // figure out how many of each card we have in deck
+            MapToAmount<String> cardAmount = new LinkedHashMapToAmount<>();
+            for (Card c : lib) {
+                cardAmount.add(c.getName());
+            }
+
+            // Trix: see if we can complete the combo (if it looks like we might win shortly or if we need to get a Donate stat)
+            boolean donateComboMightWin = false;
+            int numIllusionsOTB = CardLists.filter(ai.getCardsIn(ZoneType.Battlefield), CardPredicates.nameEquals("Illusions of Grandeur")).size();
+            if (ai.getOpponentsSmallestLifeTotal() < 20 || numIllusionsOTB > 0) {
+                donateComboMightWin = true;
+                int numIllusionsInHand = CardLists.filter(ai.getCardsIn(ZoneType.Hand), CardPredicates.nameEquals("Illusions of Grandeur")).size();
+                int numDonateInHand = CardLists.filter(ai.getCardsIn(ZoneType.Hand), CardPredicates.nameEquals("Donate")).size();
+                int numIllusionsInLib = CardLists.filter(ai.getCardsIn(ZoneType.Library), CardPredicates.nameEquals("Illusions of Grandeur")).size();
+                int numDonateInLib = CardLists.filter(ai.getCardsIn(ZoneType.Library), CardPredicates.nameEquals("Donate")).size();
+                CardCollection comboList = new CardCollection();
+                if ((numIllusionsInHand > 0 || numIllusionsOTB > 0) && numDonateInHand == 0 && numDonateInLib >= 3) {
+                    for (Card c : lib) {
+                        if (c.getName().equals("Donate")) {
+                            comboList.add(c);
+                        }
+                    }
+                    return comboList;
+                } else if (numDonateInHand > 0 && numIllusionsInHand == 0 && numIllusionsInLib >= 3) {
+                    for (Card c : lib) {
+                        if (c.getName().equals("Illusions of Grandeur")) {
+                            comboList.add(c);
+                        }
+                    }
+                    return comboList;
+                }
+            }
+
+            // Create a priority list for cards that we have no more than 4 of and that are not lands
+            CardCollection libPriorityList = new CardCollection();
+            CardCollection libHighPriorityList = new CardCollection();
+            CardCollection libLowPriorityList = new CardCollection();
+            List<String> processed = Lists.newArrayList();
+            for (int i = 4; i > 0; i--) {
+                for (Card c : lib) {
+                    if (!donateComboMightWin && (c.getName().equals("Illusions of Grandeur") || c.getName().equals("Donate"))) {
+                        // Probably not worth putting two of the combo pieces into the graveyard
+                        // since one Illusions-Donate is likely to not be enough
+                        continue;
+                    }
+                    if (cardAmount.get(c.getName()) == i && !c.isLand() && !processed.contains(c.getName())) {
+                        // if it's a card that is generally good to place in the graveyard, also add it
+                        // to the mix
+                        boolean canRetFromGrave = false;
+                        String name = c.getName().replace(',', ';');
+                        for (Trigger t : c.getTriggers()) {
+                            SpellAbility ab = null;
+                            if (t.hasParam("Execute")) {
+                                ab = AbilityFactory.getAbility(c.getSVar(t.getParam("Execute")), c);
+                            }
+                            if (ab == null) { continue; }
+
+                            if (ab.getApi() == ApiType.ChangeZone
+                                    && "Self".equals(ab.getParam("Defined"))
+                                    && "Graveyard".equals(ab.getParam("Origin"))
+                                    && "Battlefield".equals(ab.getParam("Destination"))) {
+                                canRetFromGrave = true;
+                            }
+                            if (ab.getApi() == ApiType.ChangeZoneAll
+                                    && TextUtil.concatNoSpace("Creature.named", name).equals(ab.getParam("ChangeType"))
+                                    && "Graveyard".equals(ab.getParam("Origin"))
+                                    && "Battlefield".equals(ab.getParam("Destination"))) {
+                                canRetFromGrave = true;
+                            }
+                        }
+                        boolean isGoodToPutInGrave = c.hasSVar("DiscardMe") || canRetFromGrave
+                                || (ComputerUtil.isPlayingReanimator(ai) && c.isCreature());
+
+                        for (Card c1 : lib) {
+                            if (c1.getName().equals(c.getName())) {
+                                if (CardLists.filter(ai.getCardsIn(ZoneType.Hand), CardPredicates.nameEquals(c1.getName())).isEmpty()
+                                        && ComputerUtilMana.hasEnoughManaSourcesToCast(c1.getFirstSpellAbility(), ai)) {
+                                    // Try not to search for things we already have in hand or that we can't cast
+                                    libPriorityList.add(c1);
+                                } else {
+                                    libLowPriorityList.add(c1);
+                                }
+                                if (isGoodToPutInGrave || highPriorityNamedCards.contains(c.getName())) {
+                                    libHighPriorityList.add(c1);
+                                }
+                            }
+                        }
+                        processed.add(c.getName());
+                    }
+                }
+            }
+
+            // If we're playing Reanimator, we're really interested just in the highest CMC spells, not the
+            // ones we necessarily have multiples of
+            if (ComputerUtil.isPlayingReanimator(ai)) {
+                Collections.sort(libHighPriorityList, CardLists.CmcComparatorInv);
+            }
+
+            // Otherwise, try to grab something that is hopefully decent to grab, in priority order
+            CardCollection chosen = new CardCollection();
+            if (libHighPriorityList.size() >= changeNum) {
+                for (int i = 0; i < changeNum; i++) {
+                    chosen.add(libHighPriorityList.get(i));
+                }
+            } else if (libPriorityList.size() >= changeNum) {
+                for (int i = 0; i < changeNum; i++) {
+                    chosen.add(libPriorityList.get(i));
+                }
+            } else if (libLowPriorityList.size() >= changeNum) {
+                for (int i = 0; i < changeNum; i++) {
+                    chosen.add(libLowPriorityList.get(i));
+                }
+            }
+
+            return chosen;
+        }
+    }
+
+    // Living Death (and other similar cards using AILogic LivingDeath or AILogic ReanimateAll)
     public static class LivingDeath {
-        public static boolean consider(Player ai, SpellAbility sa) {
+        public static boolean consider(final Player ai, final SpellAbility sa) {
             int aiBattlefieldPower = 0, aiGraveyardPower = 0;
+            int threshold = 320; // approximately a 4/4 Flying creature worth of extra value
+
             CardCollection aiCreaturesInGY = CardLists.filter(ai.getZone(ZoneType.Graveyard).getCards(), CardPredicates.Presets.CREATURES);
 
             if (aiCreaturesInGY.isEmpty()) {
@@ -357,7 +713,7 @@ public class SpecialCardAi {
             }
 
             // if we get more value out of this than our opponent does (hopefully), go for it
-            return (aiGraveyardPower - aiBattlefieldPower) > (oppGraveyardPower - oppBattlefieldPower);
+            return (aiGraveyardPower - aiBattlefieldPower) > (oppGraveyardPower - oppBattlefieldPower + threshold);
         }
     }
 
@@ -365,7 +721,7 @@ public class SpecialCardAi {
     public static class MairsilThePretender {
         // Scan the fetch list for a card with at least one activated ability.
         // TODO: can be improved to a full consider(sa, ai) logic which would scan the graveyard first and hand last
-        public static Card considerCardFromList(CardCollection fetchList) {
+        public static Card considerCardFromList(final CardCollection fetchList) {
             for (Card c : CardLists.filter(fetchList, Predicates.or(CardPredicates.Presets.ARTIFACTS, CardPredicates.Presets.CREATURES))) {
                 for (SpellAbility ab : c.getSpellAbilities()) {
                     if (ab.isAbility() && !ab.isTrigger()) {
@@ -389,9 +745,73 @@ public class SpecialCardAi {
         }
     }
 
+    // Mimic Vat
+    public static class MimicVat {
+        public static boolean considerExile(final Player ai, final SpellAbility sa) {
+            final Card source = sa.getHostCard();
+            final Card exiledWith = source.getImprintedCards().isEmpty() ? null : source.getImprintedCards().getFirst();
+            final List<Card> defined = AbilityUtils.getDefinedCards(sa.getHostCard(), sa.getParam("Defined"), sa);
+            final Card tgt = defined.isEmpty() ? null : defined.get(0);
+
+            return exiledWith == null || (tgt != null && ComputerUtilCard.evaluateCreature(tgt) > ComputerUtilCard.evaluateCreature(exiledWith));
+        }
+
+        public static boolean considerCopy(final Player ai, final SpellAbility sa) {
+            final Card source = sa.getHostCard();
+            final Card exiledWith = source.getImprintedCards().isEmpty() ? null : source.getImprintedCards().getFirst();
+
+            if (exiledWith == null) {
+                return false;
+            }
+
+            // We want to either be able to attack with the creature, or keep it until our opponent's end of turn as a
+            // potential blocker
+            return ComputerUtilCard.doesSpecifiedCreatureAttackAI(ai, exiledWith)
+                    || (ai.getGame().getPhaseHandler().getPlayerTurn().isOpponentOf(ai) && ai.getGame().getCombat() != null
+                    && !ai.getGame().getCombat().getAttackers().isEmpty());
+        }
+    }
+
+    // Momir Vig, Simic Visionary Avatar
+    public static class MomirVigAvatar {
+        public static boolean consider(final Player ai, final SpellAbility sa) {
+            Card source = sa.getHostCard();
+
+            if (source.getGame().getPhaseHandler().getPhase().isBefore(PhaseType.MAIN1)) {
+                return false;
+            }
+
+            // In MoJhoSto, prefer Jhoira sorcery ability from time to time
+            if (source.getGame().getRules().hasAppliedVariant(GameType.MoJhoSto)
+                    && CardLists.filter(ai.getLandsInPlay(), CardPredicates.Presets.UNTAPPED).size() >= 3
+                    && MyRandom.percentTrue(50)) {
+                int numLandsForJhoira = (((PlayerControllerAi)ai.getController())).getAi().getIntProperty(AiProps.MOJHOSTO_NUM_LANDS_TO_ACTIVATE_JHOIRA);
+                if (ai.getLandsInPlay().size() >= numLandsForJhoira) {
+                    return false;
+                }
+            }
+
+            // Set PayX here to maximum value.
+            int tokenSize = ComputerUtilMana.determineLeftoverMana(sa, ai);
+
+            // Some basic strategy for Momir
+            if (tokenSize < 2) {
+                return false;
+            }
+
+            if (tokenSize > 11) {
+                tokenSize = 11;
+            }
+
+            source.setSVar("PayX", Integer.toString(tokenSize));
+
+            return true;
+        }
+    }
+
     // Necropotence
     public static class Necropotence {
-        public static boolean consider(Player ai, SpellAbility sa) {
+        public static boolean consider(final Player ai, final SpellAbility sa) {
             Game game = ai.getGame();
             int computerHandSize = ai.getZone(ZoneType.Hand).size();
             int maxHandSize = ai.getMaxHandSize();
@@ -444,9 +864,34 @@ public class SpecialCardAi {
         }
     }
 
+    // Null Brooch
+    public static class NullBrooch {
+        public static boolean consider(final Player ai, final SpellAbility sa) {
+            // TODO: improve the detection of Ensnaring Bridge type effects ("GTX", "X" need generalization)
+            boolean hasEnsnaringBridgeEffect = false;
+            for (Card otb : ai.getCardsIn(ZoneType.Battlefield)) {
+                for (StaticAbility stab : otb.getStaticAbilities()) {
+                    if ("CARDNAME can't attack.".equals(stab.getParam("AddHiddenKeyword"))
+                            && "Creature.powerGTX".equals(stab.getParam("Affected"))
+                            && "Count$InYourHand".equals(otb.getSVar("X"))) {
+                        hasEnsnaringBridgeEffect = true;
+                        break;
+                    }
+                }
+
+            }
+            // Maybe use it for some important high-impact spells even if there are more cards in hand?
+            if (ai.getCardsIn(ZoneType.Hand).size() > 1 && !hasEnsnaringBridgeEffect) {
+                return false;
+            }
+
+            return true;
+        }
+    }
+
     // Nykthos, Shrine to Nyx
     public static class NykthosShrineToNyx {
-        public static boolean consider(Player ai, SpellAbility sa) {
+        public static boolean consider(final Player ai, final SpellAbility sa) {
             Game game = ai.getGame();
             PhaseHandler ph = game.getPhaseHandler();
             if (!ph.isPlayerTurn(ai) || ph.getPhase().isBefore(PhaseType.MAIN2)) {
@@ -465,7 +910,7 @@ public class SpecialCardAi {
             final CardCollectionView cards = ai.getCardsIn(new ZoneType[] {ZoneType.Hand, ZoneType.Battlefield, ZoneType.Command});
             List<SpellAbility> all = ComputerUtilAbility.getSpellAbilities(cards, ai);
 
-            int numManaSrcs = CardLists.filter(ComputerUtilMana.getAvailableMana(ai, true), CardPredicates.Presets.UNTAPPED).size();
+            int numManaSrcs = CardLists.filter(ComputerUtilMana.getAvailableManaSources(ai, true), CardPredicates.Presets.UNTAPPED).size();
 
             for (final SpellAbility testSa : ComputerUtilAbility.getOriginalAndAltCostAbilities(all, ai)) {
                 ManaCost cost = testSa.getPayCosts().getTotalMana();
@@ -505,7 +950,7 @@ public class SpecialCardAi {
 
     // Phyrexian Dreadnought
     public static class PhyrexianDreadnought {
-        public static CardCollection reviseCreatureSacList(Player ai, SpellAbility sa, CardCollection choices) {
+        public static CardCollection reviseCreatureSacList(final Player ai, final SpellAbility sa, final CardCollection choices) {
             choices.sort(Collections.reverseOrder(ComputerUtilCard.EvaluateCreatureComparator));
             int power = 0;
             List<Card> toKeep = Lists.newArrayList();
@@ -527,13 +972,71 @@ public class SpecialCardAi {
         }
     }
 
+    // Price of Progress
+    public static class PriceOfProgress {
+        public static boolean consider(final Player ai, final SpellAbility sa) {
+            // Don't play in early game - opponent likely still has lands to play
+            if (ai.getGame().getPhaseHandler().getTurn() < 10) {
+                return false;
+            }
+
+            int aiLands = CardLists.filter(ai.getCardsIn(ZoneType.Battlefield), Predicates.and(CardPredicates.Presets.LANDS, Predicates.not(CardPredicates.Presets.BASIC_LANDS))).size();
+
+            boolean hasBridge = false;
+            for (Card c : ai.getCardsIn(ZoneType.Battlefield)) {
+                // Do we have a card in play that makes us want to empty out hand?
+                if (c.hasSVar("PreferredHandSize") && ai.getCardsIn(ZoneType.Hand).size() > Integer.parseInt(c.getSVar("PreferredHandSize"))) {
+                    hasBridge = true;
+                    break;
+                }
+            }
+
+            // Do if we need to lose cards to activate Ensnaring Bridge or Cursed Scroll
+            // even if suboptimal play, but don't waste the card too early even then!
+            if ((hasBridge) && (ai.getGame().getPhaseHandler().getTurn() >= 10)) {
+                return true;
+            }
+
+            for (Player opp : ai.getOpponents()) {
+                int oppLands = CardLists.filter(opp.getCardsIn(ZoneType.Battlefield), Predicates.and(CardPredicates.Presets.LANDS, Predicates.not(CardPredicates.Presets.BASIC_LANDS))).size();
+                // Always if enemy would die and we don't!
+                // TODO : predict actual damage instead of assuming it'll be 2*lands
+                // Don't if we lose, unless we lose anyway to unblocked creatures next turn
+                if ((ai.getLife() <= aiLands * 2) &&
+                        (!(ComputerUtil.aiLifeInDanger(ai, true, 0)) && ((ai.getOpponentsSmallestLifeTotal()) <= oppLands * 2))) {
+                    return false;
+                }
+                // Do if we can win
+                if ((ai.getOpponentsSmallestLifeTotal()) <= oppLands * 2) {
+                    return true;
+                }
+                // Don't if we'd lose a larger percentage of our remaining life than enemy
+                if ((aiLands / ((double) ai.getLife())) >
+                        (oppLands / ((double) ai.getOpponentsSmallestLifeTotal()))) {
+                    return false;
+                }
+                // Don't if no enemy nonbasic lands
+                if (oppLands == 0) {
+                    return false;
+                }
+                // Don't if loss is equal in percentage but we lose more points
+                if (((aiLands / ((double) ai.getLife())) == (oppLands / ((double) ai.getOpponentsSmallestLifeTotal())))
+                        && (aiLands > oppLands)) {
+                    return false;
+                }
+
+            }
+            return true;
+        }
+    }
+
     // Sarkhan the Mad
     public static class SarkhanTheMad {
-        public static boolean considerDig(Player ai, SpellAbility sa) {
+        public static boolean considerDig(final Player ai, final SpellAbility sa) {
             return sa.getHostCard().getCounters(CounterType.LOYALTY) == 1;
         }
 
-        public static boolean considerMakeDragon(Player ai, SpellAbility sa) {
+        public static boolean considerMakeDragon(final Player ai, final SpellAbility sa) {
             // TODO: expand this logic to make the AI force the opponent to sacrifice a big threat bigger than a 5/5 flier?
             CardCollection creatures = ai.getCreaturesInPlay();
             boolean hasValidTgt = !CardLists.filter(creatures, new Predicate<Card>() {
@@ -550,7 +1053,7 @@ public class SpecialCardAi {
             return false;
         }
 
-        public static boolean considerUltimate(Player ai, SpellAbility sa, Player weakestOpp) {
+        public static boolean considerUltimate(final Player ai, final SpellAbility sa, final Player weakestOpp) {
             int minLife = weakestOpp.getLife();
 
             int dragonPower = 0;
@@ -563,9 +1066,140 @@ public class SpecialCardAi {
         }
     }
 
+    // Survival of the Fittest
+    public static class SurvivalOfTheFittest {
+        public static Card considerDiscardTarget(final Player ai) {
+            // The AI here only checks the number of available creatures of various CMC, which is equivalent to knowing
+            // your deck composition and checking (and counting) the cards in other zones so you know what you have left
+            // in the library. As such, this does not cause unfair advantage, at least unless there are cards that are
+            // face down (on the battlefield or in exile). Might need some kind of an update to consider hidden information
+            // like that properly (probably by adding all those cards to the evaluation mix so the AI doesn't "know" which
+            // ones are already face down in play and which are still in the library)
+            CardCollectionView creatsInLib = CardLists.filter(ai.getCardsIn(ZoneType.Library), CardPredicates.Presets.CREATURES);
+            CardCollectionView creatsInHand = CardLists.filter(ai.getCardsIn(ZoneType.Hand), CardPredicates.Presets.CREATURES);
+            CardCollectionView manaSrcsInHand = CardLists.filter(ai.getCardsIn(ZoneType.Hand), CardPredicates.Presets.LANDS_PRODUCING_MANA);
+
+            if (creatsInHand.isEmpty() || creatsInLib.isEmpty()) { return null; }
+
+            int numManaSrcs = ComputerUtilMana.getAvailableManaEstimate(ai, false)
+                    + Math.min(1, manaSrcsInHand.size());
+
+            // Cards in library that are either below/at (preferred) or above the max CMC affordable by the AI
+            // (the latter might happen if we're playing a Reanimator deck with lots of fatties)
+            CardCollection atTargetCMCInLib = CardLists.filter(creatsInLib, new Predicate<Card>() {
+                @Override
+                public boolean apply(Card card) {
+                    return ComputerUtilMana.hasEnoughManaSourcesToCast(card.getSpellPermanent(), ai);
+                }
+            });
+            if (atTargetCMCInLib.isEmpty()) {
+                atTargetCMCInLib = CardLists.filter(creatsInLib, CardPredicates.greaterCMC(numManaSrcs));
+            }
+            Collections.sort(atTargetCMCInLib, CardLists.CmcComparatorInv);
+            if (atTargetCMCInLib.isEmpty()) {
+                // Nothing to aim for?
+                return null;
+            }
+
+            // Cards in hand that are below the max CMC affordable by the AI
+            CardCollection belowMaxCMC = CardLists.filter(creatsInHand, CardPredicates.lessCMC(numManaSrcs - 1));
+            Collections.sort(belowMaxCMC, Collections.reverseOrder(CardLists.CmcComparatorInv));
+
+            // Cards in hand that are above the max CMC affordable by the AI
+            CardCollection aboveMaxCMC = CardLists.filter(creatsInHand, CardPredicates.greaterCMC(numManaSrcs + 1));
+            Collections.sort(aboveMaxCMC, CardLists.CmcComparatorInv);
+
+            Card maxCMC = !aboveMaxCMC.isEmpty() ? aboveMaxCMC.getFirst() : null;
+            Card minCMC = !belowMaxCMC.isEmpty() ? belowMaxCMC.getFirst() : null;
+            Card bestInLib = !atTargetCMCInLib.isEmpty() ? atTargetCMCInLib.getFirst() : null;
+
+            int maxCMCdiff = 0;
+            if (maxCMC != null) {
+                maxCMCdiff = maxCMC.getCMC() - numManaSrcs; // how far are we from viably casting it?
+            }
+
+            // We have something too fat to viably cast in the nearest future, discard it hoping to
+            // grab something more immediately valuable (or maybe we're playing Reanimator and we want
+            // it to be in the graveyard anyway)
+            if (maxCMCdiff >= 3) {
+                return maxCMC;
+            }
+            // We have a card in hand that is worse than the one in library, so discard the worst card
+            if (maxCMCdiff <= 0 && minCMC != null
+                    && ComputerUtilCard.evaluateCreature(bestInLib) > ComputerUtilCard.evaluateCreature(minCMC)) {
+                return minCMC;
+            }
+            // We have a card in the library that is closer to being castable than the one in hand, and
+            // no options with smaller CMC, so discard the one that is harder to cast for the one that is
+            // easier to cast right now, but only if the best card in the library is at least CMC 3
+            // (probably not worth it to grab low mana cost cards this way)
+            if (maxCMC != null && maxCMC.getCMC() < bestInLib.getCMC() && bestInLib.getCMC() >= 3) {
+                return maxCMC;
+            }
+            // We appear to be playing Reanimator (or we have a reanimator card in hand already), so it's
+            // worth to fill the graveyard now
+            if (ComputerUtil.isPlayingReanimator(ai) && !creatsInLib.isEmpty()) {
+                CardCollection creatsInHandByCMC = new CardCollection(creatsInHand);
+                Collections.sort(creatsInHandByCMC, CardLists.CmcComparatorInv);
+                return creatsInHandByCMC.getFirst();
+            }
+
+            // probably nothing that is worth changing, so bail
+            return null;
+        }
+
+        public static Card considerCardToGet(final Player ai, final SpellAbility sa) {
+            CardCollectionView creatsInLib = CardLists.filter(ai.getCardsIn(ZoneType.Library), CardPredicates.Presets.CREATURES);
+            if (creatsInLib.isEmpty()) { return null; }
+
+            CardCollectionView manaSrcsInHand = CardLists.filter(ai.getCardsIn(ZoneType.Hand), CardPredicates.Presets.LANDS_PRODUCING_MANA);
+            int numManaSrcs = ComputerUtilMana.getAvailableManaEstimate(ai, false)
+                    + Math.min(1, manaSrcsInHand.size());
+
+            CardCollection atTargetCMCInLib = CardLists.filter(creatsInLib, new Predicate<Card>() {
+                @Override
+                public boolean apply(Card card) {
+                    return ComputerUtilMana.hasEnoughManaSourcesToCast(card.getSpellPermanent(), ai);
+                }
+            });
+            if (atTargetCMCInLib.isEmpty()) {
+                atTargetCMCInLib = CardLists.filter(creatsInLib, CardPredicates.greaterCMC(numManaSrcs));
+            }
+            Collections.sort(atTargetCMCInLib, CardLists.CmcComparatorInv);
+
+            Card bestInLib = atTargetCMCInLib != null ? atTargetCMCInLib.getFirst() : null;
+
+            if (bestInLib == null && ComputerUtil.isPlayingReanimator(ai)) {
+                // For Reanimator, we don't mind grabbing the biggest thing possible to recycle it again with SotF later.
+                CardCollection creatsInLibByCMC = new CardCollection(creatsInLib);
+                Collections.sort(creatsInLibByCMC, CardLists.CmcComparatorInv);
+                return creatsInLibByCMC.getFirst();
+            }
+
+            return bestInLib;
+        }
+    }
+
+    // The Scarab God
+    public static class TheScarabGod {
+        public static boolean consider(final Player ai, final SpellAbility sa) {
+            Card bestOppCreat = ComputerUtilCard.getBestAI(CardLists.filter(ai.getOpponents().getCardsIn(ZoneType.Graveyard), CardPredicates.Presets.CREATURES));
+            Card worstOwnCreat = ComputerUtilCard.getWorstAI(CardLists.filter(ai.getCardsIn(ZoneType.Graveyard), CardPredicates.Presets.CREATURES));
+
+            sa.resetTargets();
+            if (bestOppCreat != null) {
+                sa.getTargets().add(bestOppCreat);
+            } else if (worstOwnCreat != null) {
+                sa.getTargets().add(worstOwnCreat);
+            }
+
+            return sa.getTargets().getNumTargeted() > 0;
+        }
+    }
+
     // Timetwister
     public static class Timetwister {
-        public static boolean consider(Player ai, SpellAbility sa) {
+        public static boolean consider(final Player ai, final SpellAbility sa) {
             final int aiHandSize = ai.getCardsIn(ZoneType.Hand).size();
             int maxOppHandSize = 0;
 
@@ -587,8 +1221,55 @@ public class SpecialCardAi {
         }
     }
 
+    // Volrath's Shapeshifter
+    public static class VolrathsShapeshifter {
+        public static boolean consider(final Player ai, final SpellAbility sa) {
+            PhaseHandler ph = ai.getGame().getPhaseHandler();
+            if (ph.getPhase().isBefore(PhaseType.COMBAT_BEGIN)) {
+                // try not to do this too early to at least attempt to avoid situations where the AI
+                // would cast a spell which would ruin the shapeshifting
+                return false;
+            }
+
+            CardCollectionView aiGY = ai.getCardsIn(ZoneType.Graveyard);
+            Card topGY = null;
+            Card creatHand = ComputerUtilCard.getBestCreatureAI(ai.getCardsIn(ZoneType.Hand));
+            int numCreatsInHand = CardLists.filter(ai.getCardsIn(ZoneType.Hand), CardPredicates.Presets.CREATURES).size();
+
+            if (!aiGY.isEmpty()) {
+                topGY = ai.getCardsIn(ZoneType.Graveyard).get(0);
+            }
+
+            if (creatHand != null) {
+                if (topGY == null
+                        || !topGY.isCreature()
+                        || ComputerUtilCard.evaluateCreature(creatHand) > ComputerUtilCard.evaluateCreature(topGY) + 80) {
+                    if (numCreatsInHand > 1 || !ComputerUtilMana.canPayManaCost(creatHand.getSpellPermanent(), ai, 0)) {
+                        return true;
+                    }
+                }
+            }
+
+            return false;
+        }
+
+        public static CardCollection targetBestCreature(final Player ai, final SpellAbility sa) {
+            Card creatHand = ComputerUtilCard.getBestCreatureAI(ai.getCardsIn(ZoneType.Hand));
+            if (creatHand != null) {
+                CardCollection cc = new CardCollection();
+                cc.add(creatHand);
+                return cc;
+            }
+
+            // Should ideally never get here
+            System.err.println("Volrath's Shapeshifter AI: Could not find a discard target despite the previous confirmation to proceed!");
+            return null;
+        }
+    }
+
+    // Ugin, the Spirit Dragon
     public static class UginTheSpiritDragon {
-        public static boolean considerPWAbilityPriority(Player ai, SpellAbility sa, ZoneType origin, CardCollectionView oppType, CardCollectionView computerType) {
+        public static boolean considerPWAbilityPriority(final Player ai, final SpellAbility sa, final ZoneType origin, CardCollectionView oppType, CardCollectionView computerType) {
             Card source = sa.getHostCard();
             Game game = source.getGame();
             
@@ -647,7 +1328,7 @@ public class SpecialCardAi {
 
     // Yawgmoth's Bargain
     public static class YawgmothsBargain {
-        public static boolean consider(Player ai, SpellAbility sa) {
+        public static boolean consider(final Player ai, final SpellAbility sa) {
             Game game = ai.getGame();
             PhaseHandler ph = game.getPhaseHandler();
 
@@ -688,12 +1369,16 @@ public class SpecialCardAi {
         }
     }
     
-    // Yawgmoth's Will (can potentially be expanded for other broadly similar effects too)
+    // Yawgmoth's Will and other cards with similar effect, e.g. Magus of the Will
     public static class YawgmothsWill {
-        public static boolean consider(Player ai, SpellAbility sa) {
+        public static boolean consider(final Player ai, final SpellAbility sa) {
             CardCollectionView cardsInGY = ai.getCardsIn(ZoneType.Graveyard);
             if (cardsInGY.size() == 0) {
                 return false;
+            } else if (ai.getGame().getPhaseHandler().getPlayerTurn() != ai) {
+                // The AI is not very good at deciding for what to viably do during the opp's turn when this
+                // comes from an instant speed effect (e.g. Magus of the Will)
+                return false;
             }
 
             int minManaAdj = 2; // we want the AI to have some spare mana for possible other spells to cast
@@ -710,8 +1395,8 @@ public class SpecialCardAi {
                     continue;
                 }
 
-                if (ComputerUtilAbility.getAbilitySourceName(ab).equals(ComputerUtilAbility.getAbilitySourceName(sa))
-                        || ab.hasParam("AINoRecursiveCheck")) {
+                if ((ComputerUtilAbility.getAbilitySourceName(ab).equals(ComputerUtilAbility.getAbilitySourceName(sa))
+                        && !(ab instanceof SpellPermanent)) || ab.hasParam("AINoRecursiveCheck")) {
                     // prevent infinitely recursing abilities that are susceptible to reentry
                     continue;
                 }

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

@@ -1,12 +1,7 @@
 package forge.ai;
 
-import java.util.Collection;
-import java.util.List;
-import java.util.Map;
-
 import com.google.common.collect.Iterables;
 import com.google.common.collect.Lists;
-
 import forge.card.ICardFace;
 import forge.card.mana.ManaCost;
 import forge.card.mana.ManaCostParser;
@@ -25,6 +20,10 @@ import forge.game.spellability.SpellAbility;
 import forge.game.spellability.SpellAbilityCondition;
 import forge.util.MyRandom;
 
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+
 /**
  * Base class for API-specific AI logic
  * <p>
@@ -103,6 +102,12 @@ public abstract class SpellAbilityAi {
      * Checks if the AI will play a SpellAbility with the specified AiLogic
      */
     protected boolean checkAiLogic(final Player ai, final SpellAbility sa, final String aiLogic) {
+        if (aiLogic.equals("CheckCondition")) {
+            SpellAbility saCopy = sa.copy();
+            saCopy.setActivatingPlayer(ai);
+            return saCopy.getConditions().areMet(saCopy);
+        }
+
         return !("Never".equals(aiLogic));
     }
 
@@ -118,7 +123,7 @@ public abstract class SpellAbilityAi {
         if (!ComputerUtilCost.checkDiscardCost(ai, cost, source)) {
             return false;
         }
-        if (!ComputerUtilCost.checkSacrificeCost(ai, cost, source)) {
+        if (!ComputerUtilCost.checkSacrificeCost(ai, cost, source, sa)) {
             return false;
         }
         if (!ComputerUtilCost.checkRemoveCounterCost(cost, source, sa)) {

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

@@ -1,14 +1,13 @@
 package forge.ai;
 
-import java.util.Map;
-
 import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.Maps;
-
 import forge.ai.ability.*;
 import forge.game.ability.ApiType;
 import forge.util.ReflectionUtil;
 
+import java.util.Map;
+
 public enum SpellApiToAi {
     Converter;
 
@@ -25,12 +24,14 @@ public enum SpellApiToAi {
             .put(ApiType.Animate, AnimateAi.class)
             .put(ApiType.AnimateAll, AnimateAllAi.class)
             .put(ApiType.Attach, AttachAi.class)
+            .put(ApiType.Ascend, AlwaysPlayAi.class)
             .put(ApiType.Balance, BalanceAi.class)
             .put(ApiType.BecomeMonarch, AlwaysPlayAi.class)
             .put(ApiType.BecomesBlocked, BecomesBlockedAi.class)
             .put(ApiType.BidLife, BidLifeAi.class)
             .put(ApiType.Bond, BondAi.class)
             .put(ApiType.Branch, AlwaysPlayAi.class)
+            .put(ApiType.ChangeCombatants, CannotPlayAi.class)
             .put(ApiType.ChangeTargets, ChangeTargetsAi.class)
             .put(ApiType.ChangeZone, ChangeZoneAi.class)
             .put(ApiType.ChangeZoneAll, ChangeZoneAllAi.class)
@@ -67,16 +68,19 @@ public enum SpellApiToAi {
             .put(ApiType.Encode, EncodeAi.class)
             .put(ApiType.EndTurn, EndTurnAi.class)
             .put(ApiType.ExchangeLife, LifeExchangeAi.class)
+            .put(ApiType.ExchangeLifeVariant, LifeExchangeVariantAi.class)
             .put(ApiType.ExchangeControl, ControlExchangeAi.class)
             .put(ApiType.ExchangeControlVariant, CannotPlayAi.class)
             .put(ApiType.ExchangePower, PowerExchangeAi.class)
             .put(ApiType.ExchangeZone, ZoneExchangeAi.class)
+            .put(ApiType.Explore, ExploreAi.class)
             .put(ApiType.Fight, FightAi.class)
             .put(ApiType.FlipACoin, FlipACoinAi.class)
             .put(ApiType.Fog, FogAi.class)
             .put(ApiType.GainControl, ControlGainAi.class)
             .put(ApiType.GainLife, LifeGainAi.class)
             .put(ApiType.GainOwnership, CannotPlayAi.class)
+            .put(ApiType.GameDrawn, CannotPlayAi.class)
             .put(ApiType.GenericChoice, ChooseGenericEffectAi.class)
             .put(ApiType.Goad, GoadAi.class)
             .put(ApiType.Haunt, HauntAi.class)
@@ -114,6 +118,7 @@ public enum SpellApiToAi {
             .put(ApiType.RearrangeTopOfLibrary, RearrangeTopOfLibraryAi.class)
             .put(ApiType.Regenerate, RegenerateAi.class)
             .put(ApiType.RegenerateAll, RegenerateAllAi.class)
+            .put(ApiType.Regeneration, AlwaysPlayAi.class)
             .put(ApiType.RemoveCounter, CountersRemoveAi.class)
             .put(ApiType.RemoveCounterAll, CannotPlayAi.class)
             .put(ApiType.RemoveFromCombat, RemoveFromCombatAi.class)
@@ -121,6 +126,7 @@ public enum SpellApiToAi {
             .put(ApiType.Repeat, RepeatAi.class)
             .put(ApiType.RepeatEach, RepeatEachAi.class)
             .put(ApiType.ReplaceEffect, AlwaysPlayAi.class)
+            .put(ApiType.ReplaceDamage, AlwaysPlayAi.class)
             .put(ApiType.ReplaceSplitDamage, AlwaysPlayAi.class)
             .put(ApiType.RestartGame, RestartGameAi.class)
             .put(ApiType.Reveal, RevealAi.class)
@@ -151,6 +157,7 @@ public enum SpellApiToAi {
             .put(ApiType.Vote, VoteAi.class)
             .put(ApiType.WinsGame, GameWinAi.class)
 
+            .put(ApiType.DamageResolve, AlwaysPlayAi.class)
             .put(ApiType.InternalEtbReplacement, CanPlayAsDrawbackAi.class)
             .put(ApiType.InternalLegendaryRule, LegendaryRuleAi.class)
             .put(ApiType.InternalIgnoreEffect, CannotPlayAi.class)

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

@@ -12,7 +12,6 @@ import forge.game.zone.ZoneType;
 import forge.util.MyRandom;
 
 import java.util.List;
-import java.util.Random;
 
 public class ActivateAbilityAi extends SpellAbilityAi {
 
@@ -23,8 +22,7 @@ public class ActivateAbilityAi extends SpellAbilityAi {
         final TargetRestrictions tgt = sa.getTargetRestrictions();
         final Card source = sa.getHostCard();
         final Player opp = ComputerUtil.getOpponentFor(ai);
-        final Random r = MyRandom.getRandom();
-        boolean randomReturn = r.nextFloat() <= Math.pow(.6667, sa.getActivationsThisTurn());
+        boolean randomReturn = MyRandom.getRandom().nextFloat() <= Math.pow(.6667, sa.getActivationsThisTurn());
 
         List<Card> list = CardLists.getType(opp.getCardsIn(ZoneType.Battlefield), sa.getParamOrDefault("Type", "Card"));
         if (list.isEmpty()) {

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

@@ -1,28 +1,15 @@
 package forge.ai.ability;
 
-import java.util.Arrays;
-import java.util.List;
-import java.util.Map;
-
 import com.google.common.collect.Iterables;
 import com.google.common.collect.Lists;
 import com.google.common.collect.Maps;
-import forge.ai.AiCardMemory;
-import forge.ai.ComputerUtil;
-import forge.ai.ComputerUtilCard;
-import forge.ai.ComputerUtilCost;
-import forge.ai.SpellAbilityAi;
+import forge.ai.*;
 import forge.card.CardType;
 import forge.game.Game;
 import forge.game.ability.AbilityFactory;
 import forge.game.ability.AbilityUtils;
 import forge.game.ability.ApiType;
-import forge.game.card.Card;
-import forge.game.card.CardCollection;
-import forge.game.card.CardCollectionView;
-import forge.game.card.CardLists;
-import forge.game.card.CardPredicates;
-import forge.game.card.CardUtil;
+import forge.game.card.*;
 import forge.game.phase.PhaseHandler;
 import forge.game.phase.PhaseType;
 import forge.game.player.Player;
@@ -38,6 +25,10 @@ import forge.game.trigger.TriggerHandler;
 import forge.game.zone.ZoneType;
 import forge.util.collect.FCollectionView;
 
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+
 
 /**
  * <p>
@@ -172,11 +163,17 @@ public class AnimateAi extends SpellAbilityAi {
                         }
                     }
                     if (power + toughness > c.getCurrentPower() + c.getCurrentToughness()) {
-                        bFlag = true;
+                        if (!c.isTapped() || (game.getCombat() != null && game.getCombat().isAttacking(c))) {
+                            bFlag = true;
+                        }
                     }
                 }
 
                 if (!SpellAbilityAi.isSorcerySpeed(sa) && !sa.hasParam("Permanent")) {
+                    if (sa.hasParam("Crew") && c.isCreature()) {
+                        // Do not try to crew a vehicle which is already a creature
+                        return false;
+                    }
                     Card animatedCopy = becomeAnimated(c, sa);
                     if (ph.isPlayerTurn(aiPlayer)
                             && !ComputerUtilCard.doesSpecifiedCreatureAttackAI(aiPlayer, animatedCopy)) {
@@ -186,9 +183,21 @@ public class AnimateAi extends SpellAbilityAi {
                             && !ComputerUtilCard.doesSpecifiedCreatureBlock(aiPlayer, animatedCopy)) {
                         return false;
                     }
-                    this.rememberAnimatedThisTurn(aiPlayer, c);
+                    // also check if maybe there are static effects applied to the animated copy that would matter
+                    // (e.g. Myth Realized)
+                    if (animatedCopy.getCurrentPower() + animatedCopy.getCurrentToughness() >
+                            c.getCurrentPower() + c.getCurrentToughness()) {
+                        if (!isAnimatedThisTurn(aiPlayer, sa.getHostCard())) {
+                            if (!sa.getHostCard().isTapped() || (game.getCombat() != null && game.getCombat().isAttacking(sa.getHostCard()))) {
+                                bFlag = true;
+                            }
+                        }
+                    }
                 }
             }
+            if (bFlag) {
+                this.rememberAnimatedThisTurn(aiPlayer, sa.getHostCard());
+            }
             return bFlag; // All of the defined stuff is animated, not very useful
         } else {
             sa.resetTargets();
@@ -251,13 +260,8 @@ public class AnimateAi extends SpellAbilityAi {
             // need to targetable
             list = CardLists.getTargetableCards(list, sa);
 
-            // try to look for AI targets if able
-            if (sa.hasParam("AITgts")) {
-                CardCollection prefList = CardLists.getValidCards(list, sa.getParam("AITgts").split(","), ai, source, sa);
-                if(!prefList.isEmpty() || sa.hasParam("AITgtsStrict")) {
-                    list = prefList;
-                }
-            }
+            // Filter AI-specific targets if provided
+            list = ComputerUtil.filterAITgts(sa, ai, (CardCollection)list, false);
 
             // list is empty, no possible targets
             if (list.isEmpty()) {
@@ -301,8 +305,9 @@ public class AnimateAi extends SpellAbilityAi {
                 // if its player turn,
                 // check if its Permanent or that creature would attack
                 if (ph.isPlayerTurn(ai)) {
-                    if (!sa.hasParam("Permanent") && 
-                            !ComputerUtilCard.doesSpecifiedCreatureAttackAI(ai, animatedCopy)) {
+                    if (!sa.hasParam("Permanent")
+                            && !ComputerUtilCard.doesSpecifiedCreatureAttackAI(ai, animatedCopy)
+                            && !sa.hasParam("UntilHostLeavesPlay")) {
                         continue;
                     }
                 }

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

@@ -13,7 +13,7 @@ public class AnimateAllAi extends SpellAbilityAi {
 
     @Override
     protected boolean doTriggerAINoCost(Player aiPlayer, SpellAbility sa, boolean mandatory) {
-        return false;
+        return mandatory;
     }
 
 } // end class AbilityFactoryAnimate

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

@@ -2,13 +2,13 @@ package forge.ai.ability;
 
 import com.google.common.base.Predicate;
 import com.google.common.base.Predicates;
-
 import forge.ai.*;
 import forge.game.GameObject;
 import forge.game.ability.AbilityFactory;
 import forge.game.ability.AbilityUtils;
 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.cost.CostPart;
@@ -24,7 +24,10 @@ import forge.game.trigger.Trigger;
 import forge.game.trigger.TriggerType;
 import forge.game.zone.ZoneType;
 
-import java.util.*;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
 
 public class AttachAi extends SpellAbilityAi {
 
@@ -38,7 +41,7 @@ public class AttachAi extends SpellAbilityAi {
 
         if (abCost != null) {
             // AI currently disabled for these costs
-            if (!ComputerUtilCost.checkSacrificeCost(ai, abCost, source)) {
+            if (!ComputerUtilCost.checkSacrificeCost(ai, abCost, source, sa)) {
                 return false;
             }
             if (!ComputerUtilCost.checkLifeCost(ai, abCost, source, 4, sa)) {
@@ -250,6 +253,18 @@ public class AttachAi extends SpellAbilityAi {
                     return false;
                 }
 
+                if (!mandatory) {
+                    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()) {
+                                return true;
+                            }
+                        }
+                        return false;
+                    }
+                }
+
                 if (!c.isEnchanted()) {
                     return true;
                 }
@@ -455,6 +470,65 @@ public class AttachAi extends SpellAbilityAi {
         return c;
     }
 
+    // Cards that trigger on dealing damage
+    private static Card attachAICuriosityPreference(final SpellAbility sa, final List<Card> list, final boolean mandatory,
+                                                    final Card attachSource) {
+        Card chosen = null;
+        int priority = 0;
+        for (Card card : list) {
+            int cardPriority = 0;
+            // Prefer Evasion
+            if (card.hasKeyword("Trample")) {
+                cardPriority += 10;
+            }
+            if (card.hasKeyword("Menace")) {
+                cardPriority += 10;
+            }
+            // Avoid this for Sleepers Robe?
+            if (card.hasKeyword("Fear")) {
+                cardPriority += 15;
+            }
+            if (card.hasKeyword("Flying")) {
+                cardPriority += 20;
+            }
+            if (card.hasKeyword("Shadow")) {
+                cardPriority += 30;
+            }
+            if (card.hasKeyword("Horsemanship")) {
+                cardPriority += 40;
+            }
+            if (card.hasKeyword("Unblockable")) {
+                cardPriority += 50;
+            }
+            // Prefer "tap to deal damage"
+            // TODO : Skip this one if triggers on combat damage only?
+            for (SpellAbility sa2 : card.getSpellAbilities()) {
+                if ((sa2.getApi().equals(ApiType.DealDamage))
+                        && (sa2.getTargetRestrictions().canTgtPlayer())) {
+                    cardPriority += 300;
+                }
+            }
+            // Prefer stronger creatures, avoid if can't attack
+            cardPriority += card.getCurrentToughness() * 2;
+            cardPriority += card.getCurrentPower();
+            if (card.getCurrentPower() <= 0) {
+                cardPriority = -100;
+            }
+            if (card.hasKeyword("Defender")) {
+                cardPriority = -100;
+            }
+            if (card.hasKeyword("Indestructible")) {
+                cardPriority += 15;
+            }
+            if (cardPriority > priority) {
+                priority = cardPriority;
+                chosen = card;
+            }
+        }
+
+
+        return chosen;
+    }
     /**
      * Attach ai specific card preference.
      * 
@@ -478,7 +552,9 @@ public class AttachAi extends SpellAbilityAi {
         if ("Guilty Conscience".equals(sourceName)) {
             chosen = SpecialCardAi.GuiltyConscience.getBestAttachTarget(ai, sa, list);
         } else if ("Bonds of Faith".equals(sourceName)) {
-            chosen = SpecialCardAi.BondsOfFaith.getBestAttachTarget(ai, sa, list);
+            chosen = doPumpOrCurseAILogic(ai, sa, list, "Human");
+        } else if ("Clutch of Undeath".equals(sourceName)) {
+            chosen = doPumpOrCurseAILogic(ai, sa, list, "Zombie");
         }
 
         // If Mandatory (brought directly into play without casting) gotta
@@ -490,6 +566,44 @@ public class AttachAi extends SpellAbilityAi {
         return chosen;
     }
 
+    private static Card attachAIInstantReequipPreference(final SpellAbility sa, final Card attachSource) {
+        // e.g. Cranial Plating
+        PhaseHandler ph = attachSource.getGame().getPhaseHandler();
+        Combat combat = attachSource.getGame().getCombat();
+        Card equipped = sa.getHostCard().getEquipping();
+        if (equipped == null) {
+            return null;
+        }
+
+        int powerBuff = 0;
+        for (StaticAbility stAb : sa.getHostCard().getStaticAbilities()) {
+            if ("Card.EquippedBy".equals(stAb.getParam("Affected")) && stAb.hasParam("AddPower")) {
+                powerBuff = AbilityUtils.calculateAmount(sa.getHostCard(), stAb.getParam("AddPower"), null);
+            }
+        }
+        if (combat != null && combat.isAttacking(equipped) && ph.is(PhaseType.COMBAT_DECLARE_BLOCKERS, sa.getActivatingPlayer())) {
+            int damage = 0;
+            for (Card c : combat.getUnblockedAttackers()) {
+                damage += ComputerUtilCombat.predictDamageTo(combat.getDefenderPlayerByAttacker(equipped), c.getNetCombatDamage(), c, true);
+            }
+            if (combat.isBlocked(equipped)) {
+                for (Card atk : combat.getAttackers()) {
+                    if (!combat.isBlocked(atk) && !ComputerUtil.predictThreatenedObjects(sa.getActivatingPlayer(), null).contains(atk)) {
+                        if (ComputerUtilCombat.predictDamageTo(combat.getDefenderPlayerByAttacker(atk),
+                                atk.getNetCombatDamage(), atk, true) > 0) {
+                            if (damage + powerBuff >= combat.getDefenderPlayerByAttacker(atk).getLife()) {
+                                sa.resetTargets(); // this is needed to avoid bugs with adding two targets to a single SA
+                                return atk; // lethal damage, we can win right now, so why not?
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        return null;
+    }
+
     // Should generalize this code a bit since they all have similar structures
     /**
      * Attach ai control preference.
@@ -1022,9 +1136,9 @@ public class AttachAi extends SpellAbilityAi {
             return null;
         }
         CardCollection prefList = list;
-        if (sa.hasParam("AITgts")) {
-            prefList = CardLists.getValidCards(list, sa.getParam("AITgts"), sa.getActivatingPlayer(), attachSource);
-        }
+
+        // Filter AI-specific targets if provided
+        prefList = ComputerUtil.filterAITgts(sa, aiPlayer, (CardCollection)list, true);
 
         Card c = attachGeneralAI(aiPlayer, sa, prefList, mandatory, attachSource, sa.getParam("AILogic"));
 
@@ -1037,6 +1151,10 @@ public class AttachAi extends SpellAbilityAi {
                 return null;
             }
 
+            if ("InstantReequipPowerBuff".equals(sa.getParam("AILogic"))) {
+                return c;
+            }
+
             boolean uselessCreature = ComputerUtilCard.isUselessCreature(aiPlayer, attachSource.getEquipping());
 
             if (aic.getProperty(AiProps.MOVE_EQUIPMENT_TO_BETTER_CREATURES).equals("never")) {
@@ -1053,10 +1171,10 @@ public class AttachAi extends SpellAbilityAi {
             // make sure to prioritize casting spells in main 2 (creatures, other equipment, etc.) rather than moving equipment around
             boolean decideMoveFromUseless = uselessCreature && aic.getBooleanProperty(AiProps.PRIORITIZE_MOVE_EQUIPMENT_IF_USELESS);
 
-            if (!decideMoveFromUseless && AiCardMemory.isMemorySetEmpty(aiPlayer, AiCardMemory.MemorySet.HELD_MANA_SOURCES)) {
+            if (!decideMoveFromUseless && AiCardMemory.isMemorySetEmpty(aiPlayer, AiCardMemory.MemorySet.HELD_MANA_SOURCES_FOR_MAIN2)) {
                 SpellAbility futureSpell = aic.predictSpellToCastInMain2(ApiType.Attach);
                 if (futureSpell != null && futureSpell.getHostCard() != null) {
-                    aic.reserveManaSourcesForMain2(futureSpell);
+                    aic.reserveManaSources(futureSpell);
                 }
             }
 
@@ -1099,7 +1217,7 @@ public class AttachAi extends SpellAbilityAi {
     private static Card attachGeneralAI(final Player ai, final SpellAbility sa, final List<Card> list, final boolean mandatory,
             final Card attachSource, final String logic) {
         Player prefPlayer = ai.getWeakestOpponent();
-        if ("Pump".equals(logic) || "Animate".equals(logic)) {
+        if ("Pump".equals(logic) || "Animate".equals(logic) || "Curiosity".equals(logic)) {
             prefPlayer = ai;
         }
         // Some ChangeType cards are beneficial, and PrefPlayer should be
@@ -1113,6 +1231,12 @@ public class AttachAi extends SpellAbilityAi {
             prefList = CardLists.filterControlledBy(list, prefPlayer);
         }
 
+        // AI logic types that do not require a prefList and that evaluate the
+        // usefulness of attach action autonomously
+        if ("InstantReequipPowerBuff".equals(logic)) {
+            return attachAIInstantReequipPreference(sa, attachSource);
+        }
+
         // If there are no preferred cards, and not mandatory bail out
         if (prefList.isEmpty()) {
             return chooseUnpreferred(mandatory, list);
@@ -1127,6 +1251,8 @@ public class AttachAi extends SpellAbilityAi {
             c = attachAICursePreference(sa, prefList, mandatory, attachSource);
         } else if ("Pump".equals(logic)) {
             c = attachAIPumpPreference(ai, sa, prefList, mandatory, attachSource);
+        } else if ("Curiosity".equals(logic)) {
+            c = attachAICuriosityPreference(sa, prefList, mandatory, attachSource);
         } else if ("ChangeType".equals(logic)) {
             c = attachAIChangeTypePreference(sa, prefList, mandatory, attachSource);
         } else if ("KeepTapped".equals(logic)) {
@@ -1263,9 +1389,9 @@ public class AttachAi extends SpellAbilityAi {
             if (card.hasKeyword("Flying") || !CombatUtil.canBlock(card, true)) {
                 return false;
             }
-        } else if (keyword.endsWith("CARDNAME can block an additional creature.")) {
+        } else if (keyword.endsWith("CARDNAME can block an additional creature each combat.")) {
             if (!CombatUtil.canBlock(card, true) || card.hasKeyword("CARDNAME can block any number of creatures.")
-                    || card.hasKeyword("CARDNAME can block an additional ninety-nine creatures.")) {
+                    || card.hasKeyword("CARDNAME can block an additional ninety-nine creatures each combat.")) {
                 return false;
             }
         } else if (keyword.equals("CARDNAME can attack as though it didn't have defender.")) {
@@ -1362,6 +1488,43 @@ public class AttachAi extends SpellAbilityAi {
         return true;
     }
 
+    public static Card doPumpOrCurseAILogic(final Player ai, final SpellAbility sa, final List<Card> list, final String type) {
+        Card chosen = null;
+
+        List<Card> aiType = CardLists.filter(list, new Predicate<Card>() {
+            @Override
+            public boolean apply(final Card c) {
+                // Don't buff opponent's creatures of given type
+                if (!c.getController().equals(ai)) {
+                    return false;
+                }
+                return c.getType().hasCreatureType(type);
+            }
+        });
+        List<Card> oppNonType = CardLists.filter(list, new Predicate<Card>() {
+            @Override
+            public boolean apply(final Card c) {
+                // Don't debuff AI's own creatures not of given type
+                if (c.getController().equals(ai)) {
+                    return false;
+                }
+                return !c.getType().hasCreatureType(type) && !ComputerUtilCard.isUselessCreature(ai, c);
+            }
+        });
+
+        if (!aiType.isEmpty() && !oppNonType.isEmpty()) {
+            Card bestAi = ComputerUtilCard.getBestCreatureAI(aiType);
+            Card bestOpp = ComputerUtilCard.getBestCreatureAI(oppNonType);
+            chosen = ComputerUtilCard.evaluateCreature(bestAi) > ComputerUtilCard.evaluateCreature(bestOpp) ? bestAi : bestOpp;
+        } else if (!aiType.isEmpty()) {
+            chosen = ComputerUtilCard.getBestCreatureAI(aiType);
+        } else if (!oppNonType.isEmpty()) {
+            chosen = ComputerUtilCard.getBestCreatureAI(oppNonType);
+        }
+
+        return chosen;
+    }
+
     @Override
     public boolean confirmAction(Player player, SpellAbility sa, PlayerActionConfirmMode mode, String message) {
         return true;

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

@@ -36,10 +36,10 @@ public final class BondAi extends SpellAbilityAi {
      * <p>
      * bondCanPlayAI.
      * </p>
+     * @param aiPlayer
+     *            a {@link forge.game.player.Player} object.
      * @param sa
      *            a {@link forge.game.spellability.SpellAbility} object.
-     * @param af
-     *            a {@link forge.game.ability.AbilityFactory} object.
      *
      * @return a boolean.
      */
@@ -53,4 +53,9 @@ public final class BondAi extends SpellAbilityAi {
     protected Card chooseSingleCard(Player ai, SpellAbility sa, Iterable<Card> options, boolean isOptional, Player targetedPlayer) {
         return ComputerUtilCard.getBestCreatureAI(options);
     }
+
+    @Override
+    protected boolean doTriggerAINoCost(final Player aiPlayer, final SpellAbility sa, final boolean mandatory) {
+        return true;
+    }
 }

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

@@ -1,21 +1,10 @@
 package forge.ai.ability;
 
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.Comparator;
-import java.util.List;
-import java.util.Map;
-
-import forge.game.card.*;
-import org.apache.commons.lang3.StringUtils;
-
 import com.google.common.base.Predicate;
 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.ai.*;
 import forge.card.MagicColor;
 import forge.game.Game;
@@ -23,6 +12,7 @@ import forge.game.GameObject;
 import forge.game.GlobalRuleChange;
 import forge.game.ability.AbilityUtils;
 import forge.game.ability.ApiType;
+import forge.game.card.*;
 import forge.game.card.CardPredicates.Presets;
 import forge.game.combat.Combat;
 import forge.game.cost.Cost;
@@ -36,6 +26,9 @@ import forge.game.spellability.AbilitySub;
 import forge.game.spellability.SpellAbility;
 import forge.game.spellability.TargetRestrictions;
 import forge.game.zone.ZoneType;
+import org.apache.commons.lang3.StringUtils;
+
+import java.util.*;
 
 public class ChangeZoneAi extends SpellAbilityAi {
     /*
@@ -45,6 +38,10 @@ public class ChangeZoneAi extends SpellAbilityAi {
      * too much: blink/bounce/exile/tutor/Raise Dead/Surgical Extraction/......
      */
 
+    // multipleCardsToChoose is used by Intuition and can be adapted to be used by other
+    // cards where multiple cards are fetched at once and they need to be coordinated
+    private static CardCollection multipleCardsToChoose = new CardCollection();
+
     @Override
     protected boolean checkAiLogic(final Player ai, final SpellAbility sa, final String aiLogic) {
         if (sa.getHostCard() != null && sa.getHostCard().hasSVar("AIPreferenceOverride")) {
@@ -60,23 +57,49 @@ public class ChangeZoneAi extends SpellAbilityAi {
             if (ai.getGame().getPhaseHandler().getPhase().isBefore(PhaseType.COMBAT_DECLARE_ATTACKERS)) {
                 return false;
             }
+        } else if (aiLogic.equals("PriorityOptionalCost")) {
+            boolean highPriority = false;
+            // if we have more than one of these in hand, might not be worth waiting for optional cost payment on the additional copy
+            highPriority |= CardLists.filter(ai.getCardsIn(ZoneType.Hand), CardPredicates.nameEquals(sa.getHostCard().getName())).size() > 1;
+            // if we are in danger in combat, no need to wait to pay the optional cost
+            highPriority |= ai.getGame().getPhaseHandler().is(PhaseType.COMBAT_DECLARE_BLOCKERS)
+                    && ai.getGame().getCombat() != null && ComputerUtilCombat.lifeInDanger(ai, ai.getGame().getCombat());
+
+            if (!highPriority) {
+                if (Iterables.isEmpty(sa.getOptionalCosts())) {
+                    return false;
+                }
+            }
         }
+
         return super.checkAiLogic(ai, sa, aiLogic);
     }
 
     @Override
     protected boolean checkApiLogic(Player aiPlayer, SpellAbility sa) {
         // Checks for "return true" unlike checkAiLogic()
+
+        multipleCardsToChoose.clear();
         String aiLogic = sa.getParam("AILogic");
         if (aiLogic != null) {
             if (aiLogic.equals("Always")) {
                 return true;
             } else if (aiLogic.startsWith("SacAndUpgrade")) { // Birthing Pod, Natural Order, etc.
                 return this.doSacAndUpgradeLogic(aiPlayer, sa);
+            } else if (aiLogic.startsWith("SacAndRetFromGrave")) { // Recurring Nightmare, etc.
+                return this.doSacAndReturnFromGraveLogic(aiPlayer, sa);
             } else if (aiLogic.equals("Necropotence")) {
                 return SpecialCardAi.Necropotence.consider(aiPlayer, sa);
-            } else if (aiLogic.equals("SameName")) {   // Declaration in Stone
+            } else if (aiLogic.equals("SameName")) { // Declaration in Stone
                 return this.doSameNameLogic(aiPlayer, sa);
+            } else if (aiLogic.equals("ReanimateAll")) {
+                return SpecialCardAi.LivingDeath.consider(aiPlayer, sa);
+            } else if (aiLogic.equals("TheScarabGod")) {
+                return SpecialCardAi.TheScarabGod.consider(aiPlayer, sa);
+            } else if (aiLogic.equals("Intuition")) {
+                // This logic only fills the multiple cards array, the decision to play is made
+                // separately in hiddenOriginCanPlayAI later.
+                multipleCardsToChoose = SpecialCardAi.Intuition.considerMultiple(aiPlayer, sa);
             }
         }
         if (isHidden(sa)) {
@@ -129,6 +152,21 @@ public class ChangeZoneAi extends SpellAbilityAi {
             return doReturnCommanderLogic(sa, aiPlayer);
         }
 
+        if ("IfNotBuffed".equals(sa.getParam("AILogic"))) {
+            if (ComputerUtilCard.isUselessCreature(aiPlayer, sa.getHostCard())) {
+                return true; // debuffed by opponent's auras to the level that it becomes useless
+            }
+            int delta = 0;
+            for (Card enc : sa.getHostCard().getEnchantedBy(false)) {
+                if (enc.getController().isOpponentOf(aiPlayer)) {
+                    delta--;
+                } else {
+                    delta++;
+                }
+            }
+            return delta <= 0;
+        }
+
         if (isHidden(sa)) {
             return hiddenTriggerAI(aiPlayer, sa, mandatory);
         }
@@ -178,7 +216,7 @@ public class ChangeZoneAi extends SpellAbilityAi {
 
         if (abCost != null) {
             // AI currently disabled for these costs
-            if (!ComputerUtilCost.checkSacrificeCost(ai, abCost, source)
+            if (!ComputerUtilCost.checkSacrificeCost(ai, abCost, source, sa)
                     && !(destination.equals("Battlefield") && !source.isLand())) {
                 return false;
             }
@@ -677,6 +715,12 @@ public class ChangeZoneAi extends SpellAbilityAi {
      */
     @Override
     protected boolean checkPhaseRestrictions(Player ai, SpellAbility sa, PhaseHandler ph) {
+        String aiLogic = sa.getParamOrDefault("AILogic", "");
+
+        if (aiLogic.equals("SurvivalOfTheFittest") || aiLogic.equals("AtOppEOT")) {
+            return ph.getNextTurn().equals(ai) && ph.is(PhaseType.END_OF_TURN);
+        }
+
         if (isHidden(sa)) {
             return true;
         }
@@ -731,6 +775,10 @@ public class ChangeZoneAi extends SpellAbilityAi {
      * @return a boolean.
      */
     private static boolean knownOriginPlayDrawbackAI(final Player aiPlayer, final SpellAbility sa) {
+        if ("MimicVat".equals(sa.getParam("AILogic"))) {
+            return SpecialCardAi.MimicVat.considerExile(aiPlayer, sa);
+        }
+
         if (!sa.usesTargeting()) {
             return true;
         }
@@ -775,9 +823,18 @@ public class ChangeZoneAi extends SpellAbilityAi {
         sa.resetTargets();
         CardCollection list = CardLists.getValidCards(game.getCardsIn(origin), tgt.getValidTgts(), ai, source, sa);
         list = CardLists.getTargetableCards(list, sa);
-        if (sa.hasParam("AITgts")) {
-            list = CardLists.getValidCards(list, sa.getParam("AITgts"), ai, source);
+
+        // Filter AI-specific targets if provided
+        list = ComputerUtil.filterAITgts(sa, ai, (CardCollection)list, true);
+        if (sa.hasParam("AITgtsOnlyBetterThanSelf")) {
+            list = CardLists.filter(list, new Predicate<Card>() {
+                @Override
+                public boolean apply(Card card) {
+                    return ComputerUtilCard.evaluateCreature(card) > ComputerUtilCard.evaluateCreature(source) + 30;
+                }
+            });
         }
+
         if (source.isInZone(ZoneType.Hand)) {
             list = CardLists.filter(list, Predicates.not(CardPredicates.nameEquals(source.getName()))); // Don't get the same card back.
         }
@@ -985,18 +1042,27 @@ public class ChangeZoneAi extends SpellAbilityAi {
                 return false;
             }
 
-            list = CardLists.filterControlledBy(list, ai.getOpponents());
-            list = CardLists.filter(list, new Predicate<Card>() {
-                @Override
-                public boolean apply(final Card c) {
-                    for (Card aura : c.getEnchantedBy(false)) {
-                        if (c.getOwner().isOpponentOf(ai) && aura.getController().equals(ai)) {
-                            return false;
+
+            if (!sa.hasParam("AITgtOwnCards")) {
+                list = CardLists.filterControlledBy(list, ai.getOpponents());
+                list = CardLists.filter(list, new Predicate<Card>() {
+                    @Override
+                    public boolean apply(final Card c) {
+                        for (Card aura : c.getEnchantedBy(false)) {
+                            if (c.getOwner().isOpponentOf(ai) && aura.getController().equals(ai)) {
+                                return false;
+                            }
                         }
+                        return true;
                     }
-                    return true;
-                }
-            });
+                });
+            }
+
+            // See if maybe there's a special priority applicable for this, in case the opponent
+            // has dangerous unblockables in play
+            if (CardLists.getNotType(list, "Creature").isEmpty()) {
+                list = ComputerUtilCard.prioritizeCreaturesWorthRemovingNow(ai, list, false);
+            }
         }
 
         // Only care about combatants during combat
@@ -1011,6 +1077,10 @@ public class ChangeZoneAi extends SpellAbilityAi {
             return false;
         }
 
+        // Check if the opponent can save a creature from bounce/blink/whatever by paying
+        // the Unless cost (for example, Erratic Portal)
+        list.removeAll(getSafeTargetsIfUnlessCostPaid(ai, sa, list));
+
         if (!mandatory && list.size() < tgt.getMinTargets(sa.getHostCard(), sa)) {
             return false;
         }
@@ -1088,7 +1158,16 @@ public class ChangeZoneAi extends SpellAbilityAi {
                     return false;
                 } else {
                     if (!sa.isTrigger() && !ComputerUtil.shouldCastLessThanMax(ai, source)) {
-                        return false;
+                        boolean aiTgtsOK = false;
+                        if (sa.hasParam("AIMinTgts")) {
+                            int minTgts = Integer.parseInt(sa.getParam("AIMinTgts"));
+                            if (sa.getTargets().getNumTargeted() >= minTgts) {
+                                aiTgtsOK = true;
+                            }
+                        }
+                        if (!aiTgtsOK) {
+                            return false;
+                        }
                     }
                     break;
                 }
@@ -1295,6 +1374,12 @@ public class ChangeZoneAi extends SpellAbilityAi {
      * @return a boolean.
      */
     private static boolean knownOriginTriggerAI(final Player ai, final SpellAbility sa, final boolean mandatory) {
+        if ("DeathgorgeScavenger".equals(sa.getParam("AILogic"))) {
+            return SpecialCardAi.DeathgorgeScavenger.consider(ai, sa);
+        } else if ("ExtraplanarLens".equals(sa.getParam("AILogic"))) {
+            return SpecialCardAi.ExtraplanarLens.consider(ai, sa);
+        }
+
         if (sa.getTargetRestrictions() == null) {
             // Just in case of Defined cases
             if (!mandatory && sa.hasParam("AttachedTo")) {
@@ -1324,7 +1409,7 @@ public class ChangeZoneAi extends SpellAbilityAi {
             String logic = sa.getParam("AILogic");
             if ("NeverBounceItself".equals(logic)) {
                 Card source = sa.getHostCard();
-                if (fetchList.contains(source)) {
+                if (fetchList.contains(source) && (fetchList.size() > 1 && !sa.getTriggeringAbility().isMandatory())) {
                     // For cards that should never be bounced back to hand with their own [e.g. triggered] abilities, such as guild lands.
                     fetchList.remove(source);
                 }
@@ -1332,6 +1417,14 @@ public class ChangeZoneAi extends SpellAbilityAi {
                 return ComputerUtilCard.getWorstAI(fetchList);
             } else if ("Mairsil".equals(logic)) {
                 return SpecialCardAi.MairsilThePretender.considerCardFromList(fetchList);
+            } else if ("SurvivalOfTheFittest".equals(logic)) {
+                return SpecialCardAi.SurvivalOfTheFittest.considerCardToGet(decider, sa);
+            } else if ("Intuition".equals(logic)) {
+                if (!multipleCardsToChoose.isEmpty()) {
+                    Card choice = multipleCardsToChoose.get(0);
+                    multipleCardsToChoose.remove(0);
+                    return choice;
+                }
             }
         }
         if (fetchList.isEmpty()) {
@@ -1472,7 +1565,33 @@ public class ChangeZoneAi extends SpellAbilityAi {
         return Iterables.getFirst(options, null);
     }
 
-    private boolean doSacAndUpgradeLogic(final Player ai, SpellAbility sa) {
+    private boolean doSacAndReturnFromGraveLogic(final Player ai, final SpellAbility sa) {
+        Card source = sa.getHostCard();
+        String definedSac = StringUtils.split(source.getSVar("AIPreference"), "$")[1];
+
+        CardCollection listToSac = CardLists.filter(ai.getCardsIn(ZoneType.Battlefield), CardPredicates.restriction(definedSac.split(","), ai, source, sa));
+        listToSac.sort(Collections.reverseOrder(CardLists.CmcComparatorInv));
+
+        CardCollection listToRet = CardLists.filter(ai.getCardsIn(ZoneType.Graveyard), Presets.CREATURES);
+        listToRet.sort(CardLists.CmcComparatorInv);
+
+        if (!listToSac.isEmpty() && !listToRet.isEmpty()) {
+            Card worstSac = listToSac.getFirst();
+            Card bestRet = listToRet.getFirst();
+
+            if (bestRet.getCMC() > worstSac.getCMC()
+                    && ComputerUtilCard.evaluateCreature(bestRet) > ComputerUtilCard.evaluateCreature(worstSac)) {
+                sa.resetTargets();
+                sa.getTargets().add(bestRet);
+                source.setSVar("AIPreferenceOverride", "Creature.cmcEQ" + worstSac.getCMC());
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    private boolean doSacAndUpgradeLogic(final Player ai, final SpellAbility sa) {
         Card source = sa.getHostCard();
         PhaseHandler ph = ai.getGame().getPhaseHandler();
         String logic = sa.getParam("AILogic");
@@ -1617,7 +1736,7 @@ public class ChangeZoneAi extends SpellAbilityAi {
                 // A blink effect implemented using ChangeZone API
                 return false;
             } else if (subApi == ApiType.DelayedTrigger) {
-                SpellAbility exec = causeSub.getAdditonalAbility("Execute");
+                SpellAbility exec = causeSub.getAdditionalAbility("Execute");
                 if (exec != null && exec.getApi() == ApiType.ChangeZone) {
                     if ("Exile".equals(exec.getParam("Origin")) && "Battlefield".equals(exec.getParam("Destination"))) {
                         // A blink effect implemented using a delayed trigger
@@ -1636,6 +1755,45 @@ public class ChangeZoneAi extends SpellAbilityAi {
         return true;
     }
 
+    private static CardCollection getSafeTargetsIfUnlessCostPaid(Player ai, SpellAbility sa, Iterable<Card> potentialTgts) {
+        // Determines if the controller of each potential target can negate the ChangeZone effect
+        // by paying the Unless cost. Returns the list of targets that can be saved that way.
+        final Card source = sa.getHostCard();
+        final CardCollection canBeSaved = new CardCollection();
+
+        for (Card potentialTgt : potentialTgts) {
+            String unlessCost = sa.hasParam("UnlessCost") ? sa.getParam("UnlessCost").trim() : null;
+
+            if (unlessCost != null && !unlessCost.endsWith(">")) {
+                Player opp = potentialTgt.getController();
+                int usableManaSources = ComputerUtilMana.getAvailableManaEstimate(opp);
+
+                int toPay = 0;
+                boolean setPayX = false;
+                if (unlessCost.equals("X") && source.getSVar(unlessCost).equals("Count$xPaid")) {
+                    setPayX = true;
+                    toPay = ComputerUtilMana.determineLeftoverMana(sa, ai);
+                } else {
+                    toPay = AbilityUtils.calculateAmount(source, unlessCost, sa);
+                }
+
+                if (toPay == 0) {
+                    canBeSaved.add(potentialTgt);
+                }
+
+                if (toPay <= usableManaSources) {
+                    canBeSaved.add(potentialTgt);
+                }
+
+                if (setPayX) {
+                    source.setSVar("PayX", Integer.toString(toPay));
+                }
+            }
+        }
+
+        return canBeSaved;
+    }
+
     private static void rememberBouncedThisTurn(Player ai, Card c) {
         AiCardMemory.rememberCard(ai, c, AiCardMemory.MemorySet.BOUNCED_THIS_TURN);
     }

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

@@ -1,33 +1,23 @@
 package forge.ai.ability;
 
-import java.util.Collections;
-import java.util.Random;
-
 import com.google.common.collect.Iterables;
 import com.google.common.collect.Lists;
-
-import forge.ai.AiPlayerPredicates;
-import forge.ai.ComputerUtilAbility;
-import forge.ai.ComputerUtilCard;
-import forge.ai.ComputerUtilCost;
-import forge.ai.SpecialCardAi;
-import forge.ai.SpellAbilityAi;
+import forge.ai.*;
 import forge.game.Game;
 import forge.game.ability.AbilityUtils;
-import forge.game.card.Card;
-import forge.game.card.CardCollection;
-import forge.game.card.CardCollectionView;
-import forge.game.card.CardLists;
-import forge.game.card.CardPredicates;
+import forge.game.card.*;
 import forge.game.cost.Cost;
 import forge.game.phase.PhaseType;
 import forge.game.player.Player;
 import forge.game.player.PlayerActionConfirmMode;
+import forge.game.player.PlayerCollection;
 import forge.game.player.PlayerPredicates;
 import forge.game.spellability.SpellAbility;
 import forge.game.zone.ZoneType;
 import forge.util.MyRandom;
 
+import java.util.Collections;
+
 public class ChangeZoneAllAi extends SpellAbilityAi {
     @Override
     protected boolean canPlayAI(Player ai, SpellAbility sa) {
@@ -46,13 +36,16 @@ public class ChangeZoneAllAi extends SpellAbilityAi {
             }
 
             if (!ComputerUtilCost.checkDiscardCost(ai, abCost, source)) {
-                return false;
+                boolean aiLogicAllowsDiscard = sa.hasParam("AILogic") && sa.getParam("AILogic").startsWith("DiscardAll");
+
+                if (!aiLogicAllowsDiscard) {
+                    return false;
+                }
             }
         }
 
-        final Random r = MyRandom.getRandom();
         // prevent run-away activations - first time will always return true
-        boolean chance = r.nextFloat() <= Math.pow(.6667, sa.getActivationsThisTurn());
+        boolean chance = MyRandom.getRandom().nextFloat() <= Math.pow(.6667, sa.getActivationsThisTurn());
 
         // TODO targeting with ChangeZoneAll
         // really two types of targeting.
@@ -82,13 +75,46 @@ public class ChangeZoneAllAi extends SpellAbilityAi {
         } else if ("RetDiscardedThisTurn".equals(sa.getParam("AILogic"))) {
             // e.g. Shadow of the Grave
             return ai.getNumDiscardedThisTurn() > 0 && ai.getGame().getPhaseHandler().is(PhaseType.END_OF_TURN);
+        } else if ("ExileGraveyards".equals(sa.getParam("AILogic"))) {
+            for (Player opp : ai.getOpponents()) {
+                CardCollectionView cardsGY = opp.getCardsIn(ZoneType.Graveyard);
+                CardCollection creats = CardLists.filter(cardsGY, CardPredicates.Presets.CREATURES);
+
+                if (opp.hasDelirium() || opp.hasThreshold() || creats.size() >= 5) {
+                    return true;
+                }
+            }
+            return false;
+        } else if ("ManifestCreatsFromGraveyard".equals(sa.getParam("AILogic"))) {
+            PlayerCollection players = new PlayerCollection();
+            players.addAll(ai.getOpponents());
+            players.add(ai);
+            int maxSize = 1;
+            for (Player player : players) {
+                Player bestTgt = null;
+                if (player.canBeTargetedBy(sa)) {
+                    CardCollectionView cardsGY = CardLists.filter(player.getCardsIn(ZoneType.Graveyard),
+                            CardPredicates.Presets.CREATURES);
+                    if (cardsGY.size() > maxSize) {
+                        maxSize = cardsGY.size();
+                        bestTgt = player;
+                    }
+                }
+
+                if (bestTgt != null) {
+                    sa.resetTargets();
+                    sa.getTargets().add(bestTgt);
+                    return true;
+                }
+            }
+            return false;
         }
 
         // TODO improve restrictions on when the AI would want to use this
         // spBounceAll has some AI we can compare to.
         if (origin.equals(ZoneType.Hand) || origin.equals(ZoneType.Library)) {
             if (!sa.usesTargeting()) {
-                // TODO: improve logic for non-targeted SAs of this type (most are currently RemAIDeck, e.g. Memory Jar, Timetwister)
+                // TODO: improve logic for non-targeted SAs of this type (most are currently RemAIDeck, e.g. Memory Jar)
                 return true;
             } else {
                 // search targetable Opponents
@@ -131,15 +157,39 @@ public class ChangeZoneAllAi extends SpellAbilityAi {
                 }
                 computerType = new CardCollection();
             }
+
+            int creatureEvalThreshold = 200; // value difference (in evaluateCreatureList units)
+            int nonCreatureEvalThreshold = 3; // CMC difference
+            if (ai.getController().isAI()) {
+                AiController aic = ((PlayerControllerAi)ai.getController()).getAi();
+                if (destination == ZoneType.Hand) {
+                    creatureEvalThreshold = aic.getIntProperty(AiProps.BOUNCE_ALL_TO_HAND_CREAT_EVAL_DIFF);
+                    nonCreatureEvalThreshold = aic.getIntProperty(AiProps.BOUNCE_ALL_TO_HAND_NONCREAT_EVAL_DIFF);
+                } else {
+                    creatureEvalThreshold = aic.getIntProperty(AiProps.BOUNCE_ALL_ELSEWHERE_CREAT_EVAL_DIFF);
+                    nonCreatureEvalThreshold = aic.getIntProperty(AiProps.BOUNCE_ALL_ELSEWHERE_NONCREAT_EVAL_DIFF);
+                }
+            }
+
+            // mass zone change for creatures: if in dire danger, do it; otherwise, only do it if the opponent's
+            // creatures are better in value
             if ((CardLists.getNotType(oppType, "Creature").size() == 0)
                     && (CardLists.getNotType(computerType, "Creature").size() == 0)) {
-                if ((ComputerUtilCard.evaluateCreatureList(computerType) + 200) >= ComputerUtilCard
+                if (game.getCombat() != null && ComputerUtilCombat.lifeInSeriousDanger(ai, game.getCombat())) {
+                    if (game.getPhaseHandler().is(PhaseType.COMBAT_DECLARE_BLOCKERS)
+                            && game.getPhaseHandler().getPlayerTurn().isOpponentOf(ai)) {
+                        // Life is in serious danger, return all creatures from the battlefield to wherever
+                        // so they don't deal lethal damage
+                        return true;
+                    }
+                }
+                if ((ComputerUtilCard.evaluateCreatureList(computerType) + creatureEvalThreshold) >= ComputerUtilCard
                         .evaluateCreatureList(oppType)) {
                     return false;
                 }
-            } // otherwise evaluate both lists by CMC and pass only if human
+            } // mass zone change for non-creatures: evaluate both lists by CMC and pass only if human
               // permanents are more valuable
-            else if ((ComputerUtilCard.evaluatePermanentList(computerType) + 3) >= ComputerUtilCard
+            else if ((ComputerUtilCard.evaluatePermanentList(computerType) + nonCreatureEvalThreshold) >= ComputerUtilCard
                     .evaluatePermanentList(oppType)) {
                 return false;
             }
@@ -181,6 +231,14 @@ public class ChangeZoneAllAi extends SpellAbilityAi {
                 // minimum card advantage unless the hand will be fully reloaded
                 int minAdv = logic.contains(".minAdv") ? Integer.parseInt(logic.substring(logic.indexOf(".minAdv") + 7)) : 0;
 
+                if (numExiledWithSrc > curHandSize) {
+                    if (ComputerUtil.predictThreatenedObjects(ai, sa, true).contains(source)) {
+                        // Try to gain some card advantage if the card will die anyway
+                        // TODO: ideally, should evaluate the hand value and not discard good hands to it
+                        return true;
+                    }
+                }
+
                 return (curHandSize + minAdv - 1 < numExiledWithSrc) || (numExiledWithSrc >= ai.getMaxHandSize());
             }
         } else if (origin.equals(ZoneType.Stack)) {
@@ -223,7 +281,7 @@ public class ChangeZoneAllAi extends SpellAbilityAi {
             }
         }
 
-        return (((r.nextFloat() < .8) || sa.isTrigger()) && chance);
+        return (((MyRandom.getRandom().nextFloat() < .8) || sa.isTrigger()) && chance);
     }
 
     /**
@@ -232,8 +290,8 @@ public class ChangeZoneAllAi extends SpellAbilityAi {
      * </p>
      * @param sa
      *            a {@link forge.game.spellability.SpellAbility} object.
-     * @param af
-     *            a {@link forge.game.ability.AbilityFactory} object.
+     * @param aiPlayer
+     *            a {@link forge.game.player.Player} object.
      * 
      * @return a boolean.
      */

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

@@ -1,15 +1,7 @@
 package forge.ai.ability;
 
-import java.util.List;
-import java.util.Random;
-
 import com.google.common.collect.Lists;
-
-import forge.ai.AiController;
-import forge.ai.AiPlayDecision;
-import forge.ai.ComputerUtilAbility;
-import forge.ai.PlayerControllerAi;
-import forge.ai.SpellAbilityAi;
+import forge.ai.*;
 import forge.game.ability.effects.CharmEffect;
 import forge.game.player.Player;
 import forge.game.spellability.AbilitySub;
@@ -18,6 +10,8 @@ import forge.util.Aggregates;
 import forge.util.MyRandom;
 import forge.util.collect.FCollection;
 
+import java.util.List;
+
 public class CharmAi extends SpellAbilityAi {
     @Override
     protected boolean checkApiLogic(Player ai, SpellAbility sa) {
@@ -26,8 +20,6 @@ public class CharmAi extends SpellAbilityAi {
             return true;
         } 
 
-        final Random r = MyRandom.getRandom();
-
         final int num = Integer.parseInt(sa.hasParam("CharmNum") ? sa.getParam("CharmNum") : "1");
         final int min = sa.hasParam("MinCharmNum") ? Integer.parseInt(sa.getParam("MinCharmNum")) : num;
         boolean timingRight = sa.isTrigger(); //is there a reason to play the charm now?
@@ -70,7 +62,7 @@ public class CharmAi extends SpellAbilityAi {
         sa.setChosenList(chosenList);
 
         // prevent run-away activations - first time will always return true
-        return r.nextFloat() <= Math.pow(.6667, sa.getActivationsThisTurn());
+        return MyRandom.getRandom().nextFloat() <= Math.pow(.6667, sa.getActivationsThisTurn());
     }
 
     private List<AbilitySub> chooseOptionsAi(List<AbilitySub> choices, final Player ai, boolean isTrigger, int num,
@@ -124,6 +116,8 @@ public class CharmAi extends SpellAbilityAi {
 
     private List<AbilitySub> chooseTriskaidekaphobia(List<AbilitySub> choices, final Player ai) {
         List<AbilitySub> chosenList = Lists.newArrayList();
+        if (choices == null || choices.isEmpty()) { return chosenList; }
+
         AbilitySub gain = choices.get(0);
         AbilitySub lose = choices.get(1);
         FCollection<Player> opponents = ai.getOpponents();

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

@@ -18,6 +18,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.CardPredicates;
 import forge.game.card.CardPredicates.Presets;
 import forge.game.card.CounterType;
 import forge.game.combat.Combat;
@@ -230,6 +231,13 @@ public class ChooseCardAi extends SpellAbilityAi {
                 Collections.reverse(creats);
                 choice = creats.get(0);
             }
+        } else if ("NegativePowerFirst".equals(logic)) {
+            Card lowest = Aggregates.itemWithMin(options, CardPredicates.Accessors.fnGetNetPower);
+            if (lowest.getNetPower() <= 0) {
+                choice = lowest;
+            } else {
+                choice = ComputerUtilCard.getBestCreatureAI(options);
+            }
         } else if ("TangleWire".equals(logic)) {
             CardCollectionView betterList = CardLists.filter(options, new Predicate<Card>() {
                 @Override
@@ -261,6 +269,10 @@ public class ChooseCardAi extends SpellAbilityAi {
 
             Card chosen = ComputerUtilCard.getBestCreatureAI(aiCreatures);
             return chosen;
+        } else if (logic.equals("OrzhovAdvokist")) {
+            if (ai.equals(sa.getActivatingPlayer())) {
+                choice = ComputerUtilCard.getBestAI(options);
+            } // TODO: improve ai
         } else {
             choice = ComputerUtilCard.getBestAI(options);
         }

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

@@ -6,10 +6,7 @@ import com.google.common.collect.Iterables;
 import com.google.common.collect.Lists;
 
 import forge.StaticData;
-import forge.ai.ComputerUtil;
-import forge.ai.ComputerUtilCard;
-import forge.ai.ComputerUtilMana;
-import forge.ai.SpellAbilityAi;
+import forge.ai.*;
 import forge.card.CardDb;
 import forge.card.CardRules;
 import forge.card.CardSplitType;
@@ -17,7 +14,6 @@ import forge.card.CardStateName;
 import forge.card.ICardFace;
 import forge.game.card.Card;
 import forge.game.card.CardUtil;
-import forge.game.phase.PhaseType;
 import forge.game.player.Player;
 import forge.game.spellability.SpellAbility;
 import forge.game.spellability.TargetRestrictions;
@@ -36,22 +32,9 @@ public class ChooseCardNameAi extends SpellAbilityAi {
 
             String logic = sa.getParam("AILogic");
             if (logic.equals("MomirAvatar")) {
-                if (source.getGame().getPhaseHandler().getPhase().isBefore(PhaseType.MAIN1)) {
-                    return false;
-                }
-                // Set PayX here to maximum value.
-                int tokenSize = ComputerUtilMana.determineLeftoverMana(sa, ai);
-                
-             // Some basic strategy for Momir
-                if (tokenSize < 2) {
-                    return false;
-                }
-
-                if (tokenSize > 11) {
-                    tokenSize = 11;
-                }
-
-                source.setSVar("PayX", Integer.toString(tokenSize));
+                return SpecialCardAi.MomirVigAvatar.consider(ai, sa);
+            } else if (logic.equals("CursedScroll")) {
+                return SpecialCardAi.CursedScroll.consider(ai, sa);
             }
 
             final TargetRestrictions tgt = sa.getTargetRestrictions();
@@ -78,6 +61,7 @@ public class ChooseCardNameAi extends SpellAbilityAi {
      */
     @Override
     public Card chooseSingleCard(final Player ai, SpellAbility sa, Iterable<Card> options, boolean isOptional, Player targetedPlayer) {
+
         return ComputerUtilCard.getBestAI(options);
     }
 
@@ -104,9 +88,9 @@ public class ChooseCardNameAi extends SpellAbilityAi {
                 Card copy = CardUtil.getLKICopy(card);
                 // for calcing i need only one split side    
                 if (isOther) {
-                    copy.getCurrentState().copyFrom(card, card.getState(CardStateName.RightSplit));                    
+                    copy.getCurrentState().copyFrom(card.getState(CardStateName.RightSplit), true);
                 } else {
-                    copy.getCurrentState().copyFrom(card, card.getState(CardStateName.LeftSplit));
+                    copy.getCurrentState().copyFrom(card.getState(CardStateName.LeftSplit), true);
                 }
                 copy.updateStateForView();
 

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

@@ -196,7 +196,7 @@ public class ChooseGenericEffectAi extends SpellAbilityAi {
             }
             
             // milling against Tamiyo is pointless
-            if (owner.isCardInCommand("Tamiyo, the Moon Sage emblem")) {
+            if (owner.isCardInCommand("Emblem - Tamiyo, the Moon Sage")) {
                 return allow;
             }
             
@@ -236,6 +236,12 @@ public class ChooseGenericEffectAi extends SpellAbilityAi {
             return Aggregates.random(spells);
         } else if (logic.startsWith("Fabricate")) {
             final int n = Integer.valueOf(logic.substring("Fabricate".length()));
+            if(spells.size() < 2) {
+				// If the creature is no longer on the battlefield, the option
+				// to add counters is already removed at this point. Return the
+				// only available option: create servo tokens.
+            	return spells.get(0);
+            }
             SpellAbility counterSA = spells.get(0), tokenSA = spells.get(1);
 
             // check for something which might prevent the counters to be placed on host

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

@@ -3,6 +3,8 @@ package forge.ai.ability;
 import java.util.List;
 
 import com.google.common.base.Predicate;
+import com.google.common.base.Predicates;
+import com.google.common.collect.Iterables;
 import com.google.common.collect.Lists;
 
 import forge.ai.ComputerUtil;
@@ -17,6 +19,7 @@ import forge.game.ability.ApiType;
 import forge.game.card.Card;
 import forge.game.card.CardCollectionView;
 import forge.game.card.CardLists;
+import forge.game.card.CardPredicates;
 import forge.game.combat.Combat;
 import forge.game.cost.Cost;
 import forge.game.phase.PhaseType;
@@ -25,6 +28,7 @@ import forge.game.spellability.SpellAbility;
 import forge.game.spellability.SpellAbilityStackInstance;
 import forge.game.spellability.TargetRestrictions;
 import forge.game.zone.ZoneType;
+import forge.util.Aggregates;
 
 public class ChooseSourceAi extends SpellAbilityAi {
 
@@ -52,7 +56,7 @@ public class ChooseSourceAi extends SpellAbilityAi {
                 return false;
             }
 
-            if (!ComputerUtilCost.checkSacrificeCost(ai, abCost, source)) {
+            if (!ComputerUtilCost.checkSacrificeCost(ai, abCost, source, sa)) {
                 return false;
             }
 
@@ -133,9 +137,9 @@ public class ChooseSourceAi extends SpellAbilityAi {
             final Player ai = sa.getActivatingPlayer();
             final Game game = ai.getGame();
             if (!game.getStack().isEmpty()) {
-                Card choseCard = chooseCardOnStack(sa, ai, game);
-                if (choseCard != null) {
-                    return choseCard;
+                Card chosenCard = chooseCardOnStack(sa, ai, game);
+                if (chosenCard != null) {
+                    return chosenCard;
                 }
             }
 
@@ -151,8 +155,38 @@ public class ChooseSourceAi extends SpellAbilityAi {
                     return ComputerUtilCombat.damageIfUnblocked(c, ai, combat, true) > 0;
                 }
             });
-            return ComputerUtilCard.getBestCreatureAI(permanentSources);
 
+            // Try to choose the best creature for damage prevention.
+            Card bestCreature = ComputerUtilCard.getBestCreatureAI(permanentSources);
+            if (bestCreature != null) {
+                return bestCreature;
+            } else {
+                // No optimal creature was found above, so try to broaden the choice.
+                if (!Iterables.isEmpty(options)) {
+                    List<Card> oppCreatures = CardLists.filter(options, Predicates.and(CardPredicates.Presets.CREATURES,
+                            Predicates.not(CardPredicates.isOwner(aiChoser))));
+                    List<Card> aiNonCreatures = CardLists.filter(options, Predicates.and(Predicates.not(CardPredicates.Presets.CREATURES),
+                            CardPredicates.Presets.PERMANENTS, CardPredicates.isOwner(aiChoser)));
+
+                    if (!oppCreatures.isEmpty()) {
+                        return ComputerUtilCard.getBestCreatureAI(oppCreatures);
+                    } else if (!aiNonCreatures.isEmpty()) {
+                        return Aggregates.random(aiNonCreatures);
+                    } else {
+                        return Aggregates.random(options);
+                    }
+                } else if (!game.getStack().isEmpty()) {
+                    // No permanent for the AI to choose. Should normally not happen unless using dev mode or something,
+                    // but when it does happen, choose the top card on stack if possible (generally it'll be the SA
+                    // source) in order to choose at least something, or the game will hang.
+                    return game.getStack().peekAbility().getHostCard();
+                }
+            }
+
+            // Should never get here
+            System.err.println("Unexpected behavior: The AI was unable to choose anything for AF ChooseSource in "
+                    + sa.getHostCard() + ", the game will likely hang.");
+            return null;
         } else {
             return ComputerUtilCard.getBestAI(options);
         }

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

@@ -1,7 +1,5 @@
 package forge.ai.ability;
 
-import java.util.List;
-
 import forge.ai.ComputerUtilCard;
 import forge.ai.SpellAbilityAi;
 import forge.game.Game;
@@ -15,6 +13,9 @@ import forge.game.player.Player;
 import forge.game.player.PlayerActionConfirmMode;
 import forge.game.spellability.SpellAbility;
 import forge.game.spellability.TargetRestrictions;
+import forge.game.zone.ZoneType;
+
+import java.util.List;
 
 public class CloneAi extends SpellAbilityAi {
 
@@ -131,13 +132,19 @@ public class CloneAi extends SpellAbilityAi {
      * cloneTgtAI.
      * </p>
      * 
-     * @param af
-     *            a {@link forge.game.ability.AbilityFactory} object.
      * @param sa
      *            a {@link forge.game.spellability.SpellAbility} object.
      * @return a boolean.
      */
     private boolean cloneTgtAI(final SpellAbility sa) {
+        // Specific logic for cards
+        if ("CloneAttacker".equals(sa.getParam("AILogic"))) {
+            CardCollection valid = CardLists.getValidCards(sa.getHostCard().getController().getCardsIn(ZoneType.Battlefield), sa.getParam("ValidTgts"), sa.getHostCard().getController(), sa.getHostCard());
+            sa.getTargets().add(ComputerUtilCard.getBestCreatureAI(valid));
+            return true;
+        }
+
+        // Default:
         // This is reasonable for now. Kamahl, Fist of Krosa and a sorcery or
         // two are the only things
         // that clone a target. Those can just use SVar:RemAIDeck:True until

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

@@ -227,16 +227,18 @@ public class ControlGainAi extends SpellAbilityAi {
                     t = ComputerUtilCard.getMostExpensivePermanentAI(list, sa, true);
                 }
 
-                if (t.isCreature())
-                    creatures--;
-                if (t.isPlaneswalker())
-                    planeswalkers--;
-                if (t.isLand())
-                    lands--;
-                if (t.isArtifact())
-                    artifacts--;
-                if (t.isEnchantment())
-                    enchantments--;
+                if (t != null) {
+                    if (t.isCreature())
+                        creatures--;
+                    if (t.isPlaneswalker())
+                        planeswalkers--;
+                    if (t.isLand())
+                        lands--;
+                    if (t.isArtifact())
+                        artifacts--;
+                    if (t.isEnchantment())
+                        enchantments--;
+                }
 
                 if (!sa.canTarget(t)) {
                     list.remove(t);

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

@@ -1,26 +1,23 @@
 package forge.ai.ability;
 
-import java.util.List;
-
 import com.google.common.base.Predicate;
 import com.google.common.base.Predicates;
 import com.google.common.collect.Iterables;
-
-import forge.ai.ComputerUtil;
-import forge.ai.ComputerUtilCard;
-import forge.ai.SpellAbilityAi;
+import forge.ai.*;
+import forge.game.Game;
 import forge.game.ability.AbilityUtils;
-import forge.game.card.Card;
-import forge.game.card.CardCollection;
-import forge.game.card.CardLists;
-import forge.game.card.CardPredicates;
+import forge.game.card.*;
 import forge.game.card.CardPredicates.Presets;
-import forge.game.card.CardUtil;
+import forge.game.phase.PhaseHandler;
 import forge.game.phase.PhaseType;
 import forge.game.player.Player;
 import forge.game.player.PlayerActionConfirmMode;
 import forge.game.player.PlayerCollection;
 import forge.game.spellability.SpellAbility;
+import forge.game.zone.ZoneType;
+
+import java.util.Collection;
+import java.util.List;
 
 public class CopyPermanentAi extends SpellAbilityAi {
     @Override
@@ -28,10 +25,21 @@ public class CopyPermanentAi extends SpellAbilityAi {
         // Card source = sa.getHostCard();
         // TODO - I'm sure someone can do this AI better
 
+        PhaseHandler ph = aiPlayer.getGame().getPhaseHandler();
+        String aiLogic = sa.getParamOrDefault("AILogic", "");
+
         if (ComputerUtil.preventRunAwayActivations(sa)) {
             return false;
         }
 
+        if ("MimicVat".equals(aiLogic)) {
+            return SpecialCardAi.MimicVat.considerCopy(aiPlayer, sa);
+        } else if ("AtEOT".equals(aiLogic)) {
+            return ph.is(PhaseType.END_OF_TURN);
+        } else if ("AtOppEOT".equals(aiLogic)) {
+            return ph.is(PhaseType.END_OF_TURN) && ph.getPlayerTurn() != aiPlayer;
+        }
+
         if (sa.hasParam("AtEOT") && !aiPlayer.getGame().getPhaseHandler().is(PhaseType.MAIN1)) {
             return false;
         }
@@ -43,6 +51,13 @@ public class CopyPermanentAi extends SpellAbilityAi {
             }
         }
 
+        if (sa.hasParam("Embalm") || sa.hasParam("Eternalize")) {
+            // E.g. Vizier of Many Faces: check to make sure it makes sense to make the token now
+            if (ComputerUtilCard.checkNeedsToPlayReqs(sa.getHostCard(), sa) != AiPlayDecision.WillPlay) {
+                return false;
+            }
+        }
+
         if (sa.usesTargeting() && sa.hasParam("TargetingPlayer")) {
             sa.resetTargets();
             Player targetingPlayer = AbilityUtils.getDefinedPlayers(sa.getHostCard(), sa.getParam("TargetingPlayer"), sa).get(0);
@@ -55,6 +70,12 @@ public class CopyPermanentAi extends SpellAbilityAi {
 
     @Override
     protected boolean doTriggerAINoCost(final Player aiPlayer, SpellAbility sa, boolean mandatory) {
+        final Card host = sa.getHostCard();
+        final Player activator = sa.getActivatingPlayer();
+        final Game game = host.getGame();
+        final String sourceName = ComputerUtilAbility.getAbilitySourceName(sa);
+
+        
         // ////
         // Targeting
         if (sa.usesTargeting()) {
@@ -69,7 +90,7 @@ public class CopyPermanentAi extends SpellAbilityAi {
             }
             
             // Saheeli Rai + Felidar Guardian combo support
-            if (sa.getHostCard().getName().equals("Saheeli Rai")) {
+            if ("Saheeli Rai".equals(sourceName)) {
                 CardCollection felidarGuardian = CardLists.filter(list, CardPredicates.nameEquals("Felidar Guardian"));
                 if (felidarGuardian.size() > 0) {
                     // can copy a Felidar Guardian and combo off, so let's do it
@@ -119,6 +140,14 @@ public class CopyPermanentAi extends SpellAbilityAi {
                 list.remove(choice);
                 sa.getTargets().add(choice);
             }
+        } else if (sa.hasParam("Choices")) {
+            // only check for options, does not select there
+            CardCollectionView choices = game.getCardsIn(ZoneType.Battlefield);
+            choices = CardLists.getValidCards(choices, sa.getParam("Choices"), activator, host);
+            Collection<Card> betterChoices = getBetterOptions(aiPlayer, sa, choices, !mandatory);
+            if (betterChoices.isEmpty()) {
+                return mandatory;
+            }
         } else {
             // if no targeting, it should always be ok
         }
@@ -141,9 +170,21 @@ public class CopyPermanentAi extends SpellAbilityAi {
     @Override
     public Card chooseSingleCard(Player ai, SpellAbility sa, Iterable<Card> options, boolean isOptional, Player targetedPlayer) {
         // Select a card to attach to
+        CardCollection betterOptions = getBetterOptions(ai, sa, options, isOptional);
+        if (!betterOptions.isEmpty()) {
+            options = betterOptions;
+        }
         return ComputerUtilCard.getBestAI(options);
     }
     
+    private CardCollection getBetterOptions(Player ai, SpellAbility sa, Iterable<Card> options, boolean isOptional) {
+        final Card host = sa.getHostCard();
+        final Player ctrl = host.getController();
+        final String filter = "Permanent.YouDontCtrl,Permanent.nonLegendary";
+        // TODO add filter to not select Legendary from Other Player when ai already have a Legendary with that name
+        return CardLists.getValidCards(options, filter.split(","), ctrl, host, sa);
+    }
+
     @Override
     protected Player chooseSinglePlayer(Player ai, SpellAbility sa, Iterable<Player> options) {
         final List<Card> cards = new PlayerCollection(options).getCreaturesInPlay();

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

@@ -1,31 +1,27 @@
 package forge.ai.ability;
 
-import forge.ai.AiController;
-import forge.ai.AiProps;
-import forge.ai.ComputerUtil;
-import forge.ai.ComputerUtilAbility;
-import java.util.Iterator;
-
-import forge.ai.ComputerUtilCost;
-import forge.ai.ComputerUtilMana;
-import forge.ai.PlayerControllerAi;
-import forge.ai.SpecialCardAi;
-import forge.ai.SpellAbilityAi;
+import forge.ai.*;
 import forge.game.Game;
 import forge.game.ability.AbilityUtils;
 import forge.game.ability.ApiType;
 import forge.game.card.Card;
 import forge.game.card.CardFactoryUtil;
 import forge.game.cost.Cost;
+import forge.game.cost.CostDiscard;
+import forge.game.cost.CostExile;
+import forge.game.cost.CostSacrifice;
 import forge.game.player.Player;
 import forge.game.spellability.SpellAbility;
 import forge.game.spellability.SpellAbilityStackInstance;
 import forge.game.spellability.TargetRestrictions;
+import forge.game.zone.ZoneType;
 import forge.util.MyRandom;
 import org.apache.commons.lang3.StringUtils;
 import org.apache.commons.lang3.tuple.ImmutablePair;
 import org.apache.commons.lang3.tuple.Pair;
 
+import java.util.Iterator;
+
 public class CounterAi extends SpellAbilityAi {
 
     @Override
@@ -44,7 +40,7 @@ public class CounterAi extends SpellAbilityAi {
 
         if (abCost != null) {
             // AI currently disabled for these costs
-            if (!ComputerUtilCost.checkSacrificeCost(ai, abCost, source)) {
+            if (!ComputerUtilCost.checkSacrificeCost(ai, abCost, source, sa)) {
                 return false;
             }
             if (!ComputerUtilCost.checkLifeCost(ai, abCost, source, 4, sa)) {
@@ -67,6 +63,8 @@ public class CounterAi extends SpellAbilityAi {
                 // might as well check for player's friendliness
                 return false;
             }
+
+            // check if the top ability on the stack corresponds to the AI-specific targeting declaration, if provided
             if (sa.hasParam("AITgts") && (topSA.getHostCard() == null
                     || !topSA.getHostCard().isValid(sa.getParam("AITgts"), sa.getActivatingPlayer(), source, sa))) {
                 return false;
@@ -76,6 +74,12 @@ public class CounterAi extends SpellAbilityAi {
                 return false;
             }
 
+            if ("OppDiscardsHand".equals(sa.getParam("AILogic"))) {
+                if (topSA.getActivatingPlayer().getCardsIn(ZoneType.Hand).size() < 2) {
+                    return false;
+                }
+            }
+
             sa.resetTargets();
             if (sa.canTargetSpellAbility(topSA)) {
                 sa.getTargets().add(topSA);
@@ -94,8 +98,9 @@ public class CounterAi extends SpellAbilityAi {
         String unlessCost = sa.hasParam("UnlessCost") ? sa.getParam("UnlessCost").trim() : null;
 
         if (unlessCost != null && !unlessCost.endsWith(">")) {
-            // Is this Usable Mana Sources? Or Total Available Mana?
-            final int usableManaSources = ComputerUtilMana.getAvailableMana(ComputerUtil.getOpponentFor(ai), true).size();
+            Player opp = tgtSA.getActivatingPlayer();
+            int usableManaSources = ComputerUtilMana.getAvailableManaEstimate(opp);
+
             int toPay = 0;
             boolean setPayX = false;
             if (unlessCost.equals("X") && source.getSVar(unlessCost).equals("Count$xPaid")) {
@@ -138,6 +143,10 @@ public class CounterAi extends SpellAbilityAi {
                 if (tgtCMC < minCMC) {
                     return false;
                 }
+            } else if ("NullBrooch".equals(logic)) {
+                if (!SpecialCardAi.NullBrooch.consider(ai, sa)) {
+                    return false;
+                }
             }
         }
 
@@ -147,14 +156,31 @@ public class CounterAi extends SpellAbilityAi {
         boolean ctrCmc0ManaPerms = aic.getBooleanProperty(AiProps.ALWAYS_COUNTER_CMC_0_MANA_MAKING_PERMS);
         boolean ctrDamageSpells = aic.getBooleanProperty(AiProps.ALWAYS_COUNTER_DAMAGE_SPELLS);
         boolean ctrRemovalSpells = aic.getBooleanProperty(AiProps.ALWAYS_COUNTER_REMOVAL_SPELLS);
+        boolean ctrPumpSpells = aic.getBooleanProperty(AiProps.ALWAYS_COUNTER_PUMP_SPELLS);
+        boolean ctrAuraSpells = aic.getBooleanProperty(AiProps.ALWAYS_COUNTER_AURAS);
         boolean ctrOtherCounters = aic.getBooleanProperty(AiProps.ALWAYS_COUNTER_OTHER_COUNTERSPELLS);
+        int ctrChanceCMC1 = aic.getIntProperty(AiProps.CHANCE_TO_COUNTER_CMC_1);
+        int ctrChanceCMC2 = aic.getIntProperty(AiProps.CHANCE_TO_COUNTER_CMC_2);
+        int ctrChanceCMC3 = aic.getIntProperty(AiProps.CHANCE_TO_COUNTER_CMC_3);
         String ctrNamed = aic.getProperty(AiProps.ALWAYS_COUNTER_SPELLS_FROM_NAMED_CARDS);
+        boolean dontCounter = false;
+
+        if (tgtCMC == 1 && !MyRandom.percentTrue(ctrChanceCMC1)) {
+            dontCounter = true;
+        } else if (tgtCMC == 2 && !MyRandom.percentTrue(ctrChanceCMC2)) {
+            dontCounter = true;
+        } else if (tgtCMC == 3 && !MyRandom.percentTrue(ctrChanceCMC3)) {
+            dontCounter = true;
+        }
+
         if (tgtSA != null && tgtCMC < aic.getIntProperty(AiProps.MIN_SPELL_CMC_TO_COUNTER)) {
-            boolean dontCounter = true;
+            dontCounter = true;
             Card tgtSource = tgtSA.getHostCard();
             if ((tgtSource != null && tgtCMC == 0 && tgtSource.isPermanent() && !tgtSource.getManaAbilities().isEmpty() && ctrCmc0ManaPerms)
                     || (tgtSA.getApi() == ApiType.DealDamage || tgtSA.getApi() == ApiType.LoseLife || tgtSA.getApi() == ApiType.DamageAll && ctrDamageSpells)
                     || (tgtSA.getApi() == ApiType.Counter && ctrOtherCounters)
+                    || ((tgtSA.getApi() == ApiType.Pump || tgtSA.getApi() == ApiType.PumpAll) && ctrPumpSpells)
+                    || (tgtSA.getApi() == ApiType.Attach && ctrAuraSpells)
                     || (tgtSA.getApi() == ApiType.Destroy || tgtSA.getApi() == ApiType.DestroyAll || tgtSA.getApi() == ApiType.Sacrifice
                        || tgtSA.getApi() == ApiType.SacrificeAll && ctrRemovalSpells)) {
                 dontCounter = false;
@@ -168,14 +194,37 @@ public class CounterAi extends SpellAbilityAi {
                 }
             }
 
-            // should always counter CMC 1 with Mental Misstep despite a possible limitation by minimum CMC
-            if (tgtCMC == 1 && "Mental Misstep".equals(source.getName())) {
+            // should not refrain from countering a CMC X spell if that's the only CMC
+            // counterable with that particular counterspell type (e.g. Mental Misstep vs. CMC 1 spells)
+            if (sa.getParamOrDefault("ValidTgts", "").startsWith("Card.cmcEQ")) {
+                int validTgtCMC = AbilityUtils.calculateAmount(source, sa.getParam("ValidTgts").substring(10), sa);
+                if (tgtCMC == validTgtCMC) {
+                    dontCounter = false;
+                }
+            }
+        }
+
+        // Should ALWAYS counter if it doesn't spend a card, otherwise it wastes an opportunity
+        // to gain card advantage
+        if (sa.isAbility()
+                && (!sa.getPayCosts().hasSpecificCostType(CostDiscard.class))
+                && (!sa.getPayCosts().hasSpecificCostType(CostSacrifice.class))
+                && (!sa.getPayCosts().hasSpecificCostType(CostExile.class))) {
+            // TODO: maybe also disallow CostPayLife?
+            dontCounter = false;
+        }
+
+        // Null Brooch is special - it has a discard cost, but the AI will be
+        // discarding no cards, or is playing a deck where discarding is a benefit
+        // as defined in SpecialCardAi.NullBrooch
+        if (sa.hasParam("AILogic")) {
+            if ("NullBrooch".equals(sa.getParam("AILogic"))) {
                 dontCounter = false;
             }
+        }
 
-            if (dontCounter) {
-                return false;
-            }
+        if (dontCounter) {
+            return false;
         }
 
         return toReturn;
@@ -213,8 +262,9 @@ public class CounterAi extends SpellAbilityAi {
 
             final Card source = sa.getHostCard();
             if (unlessCost != null) {
-                // Is this Usable Mana Sources? Or Total Available Mana?
-                final int usableManaSources = ComputerUtilMana.getAvailableMana(ComputerUtil.getOpponentFor(ai), true).size();
+                Player opp = tgtSA.getActivatingPlayer();
+                int usableManaSources = ComputerUtilMana.getAvailableManaEstimate(opp);
+
                 int toPay = 0;
                 boolean setPayX = false;
                 if (unlessCost.equals("X") && source.getSVar(unlessCost).equals("Count$xPaid")) {

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

@@ -1,21 +1,13 @@
 package forge.ai.ability;
 
-import java.util.List;
-import java.util.Map;
-
 import com.google.common.base.Predicate;
 import com.google.common.collect.Iterables;
-
 import forge.ai.ComputerUtil;
 import forge.ai.ComputerUtilCard;
 import forge.ai.SpellAbilityAi;
 import forge.game.Game;
 import forge.game.ability.AbilityUtils;
-import forge.game.card.Card;
-import forge.game.card.CardLists;
-import forge.game.card.CardPredicates;
-import forge.game.card.CardUtil;
-import forge.game.card.CounterType;
+import forge.game.card.*;
 import forge.game.phase.PhaseHandler;
 import forge.game.phase.PhaseType;
 import forge.game.player.Player;
@@ -24,6 +16,9 @@ import forge.game.zone.ZoneType;
 import forge.util.MyRandom;
 import forge.util.collect.FCollection;
 
+import java.util.List;
+import java.util.Map;
+
 public class CountersMoveAi extends SpellAbilityAi {
     @Override
     protected boolean checkApiLogic(final Player ai, final SpellAbility sa) {
@@ -109,6 +104,12 @@ public class CountersMoveAi extends SpellAbilityAi {
             if (!ph.getNextTurn().equals(ai) || ph.getPhase().isBefore(PhaseType.END_OF_TURN)) {
                 return false;
             }
+            // Make sure that removing the last counter doesn't kill the creature
+            if ("Self".equals(sa.getParam("Source"))) {
+                if (host != null && host.getNetToughness() - 1 <= 0) {
+                    return false;
+                }
+            }
         }
         return true;
     }
@@ -188,6 +189,13 @@ public class CountersMoveAi extends SpellAbilityAi {
                 if (newEval < oldEval) {
                     return false;
                 }
+
+                // check for some specific AI preferences
+                if (src.hasStartOfKeyword("Graft") && "DontMoveCounterIfLethal".equals(src.getSVar("AIGraftPreference"))) {
+                    if (cType == CounterType.P1P1 && src.getNetToughness() - src.getTempToughnessBoost() - 1 <= 0) {
+                        return false;
+                    }
+                }
             }
             // no target
             return true;

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

@@ -1,14 +1,8 @@
 package forge.ai.ability;
 
-import java.util.Collections;
-import java.util.List;
-import java.util.Map;
-import java.util.Random;
-
 import com.google.common.base.Predicate;
 import com.google.common.collect.Iterables;
 import com.google.common.collect.Lists;
-
 import forge.ai.*;
 import forge.card.CardStateName;
 import forge.game.Game;
@@ -33,6 +27,10 @@ import forge.game.zone.ZoneType;
 import forge.util.Aggregates;
 import forge.util.MyRandom;
 
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+
 public class CountersPutAi extends SpellAbilityAi {
 
     /*
@@ -119,7 +117,6 @@ public class CountersPutAi extends SpellAbilityAi {
     protected boolean checkApiLogic(Player ai, final SpellAbility sa) {
         // AI needs to be expanded, since this function can be pretty complex
         // based on what the expected targets could be
-        final Random r = MyRandom.getRandom();
         final Cost abCost = sa.getPayCosts();
         final Card source = sa.getHostCard();
         final String sourceName = ComputerUtilAbility.getAbilitySourceName(sa);
@@ -226,13 +223,42 @@ public class CountersPutAi extends SpellAbilityAi {
         }
 
         if ("PayEnergyConservatively".equals(sa.getParam("AILogic"))) {
+            boolean onlyInCombat = ai.getController().isAI()
+                    && ((PlayerControllerAi) ai.getController()).getAi().getBooleanProperty(AiProps.CONSERVATIVE_ENERGY_PAYMENT_ONLY_IN_COMBAT);
+            boolean onlyDefensive = ai.getController().isAI()
+                    && ((PlayerControllerAi) ai.getController()).getAi().getBooleanProperty(AiProps.CONSERVATIVE_ENERGY_PAYMENT_ONLY_DEFENSIVELY);
+
             if (playAggro) {
                 // aggro profiles ignore conservative play for this AI logic
                 return true;
-            } else if (ai.getCounters(CounterType.ENERGY) > ComputerUtilCard.getMaxSAEnergyCostOnBattlefield(ai) + sa.getPayCosts().getCostEnergy().convertAmount()) {
-                return true;
             } else if (ai.getGame().getCombat() != null && sa.getHostCard() != null) {
-                if (ai.getGame().getCombat().isAttacking(sa.getHostCard())) {  
+                if (ai.getGame().getCombat().isAttacking(sa.getHostCard()) && !onlyDefensive) {
+                    return true;
+                } else if (ai.getGame().getCombat().isBlocking(sa.getHostCard())) {
+                    // when blocking, consider this if it's possible to save the blocker and/or kill at least one attacker
+                    CardCollection blocked = ai.getGame().getCombat().getAttackersBlockedBy(sa.getHostCard());
+                    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();
+                    if (sa.getHostCard().getNetToughness() + numActivations > totBlkPower
+                            || sa.getHostCard().getNetPower() + numActivations >= totBlkToughness) {
+                        return true;
+                    }
+                }
+            } else if (sa.getSubAbility() != null
+                        && "Self".equals(sa.getSubAbility().getParam("Defined"))
+                        && sa.getSubAbility().getParamOrDefault("KW", "").contains("Hexproof")
+                        && !AiCardMemory.isRememberedCard(ai, source, AiCardMemory.MemorySet.ANIMATED_THIS_TURN)) {
+                    // Bristling Hydra: save from death using a ping activation
+                    if (ComputerUtil.predictThreatenedObjects(sa.getActivatingPlayer(), sa).contains(source)) {
+                        AiCardMemory.rememberCard(ai, source, AiCardMemory.MemorySet.ACTIVATED_THIS_TURN);
+                        return true;
+                    }
+            } else if (ai.getCounters(CounterType.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) {
                     return true;
                 }
             }
@@ -274,26 +300,36 @@ public class CountersPutAi extends SpellAbilityAi {
             return FightAi.canFightAi(ai, sa, nPump, nPump);
         }
         
-        if (amountStr.equals("X") && source.getSVar(amountStr).equals("Count$xPaid")) {
-            // By default, set PayX here to maximum value (used for most SAs of this type).
-            amount = ComputerUtilMana.determineLeftoverMana(sa, ai);
+        if (amountStr.equals("X")) {
+            if (source.getSVar(amountStr).equals("Count$xPaid")) {
+                // By default, set PayX here to maximum value (used for most SAs of this type).
+                amount = ComputerUtilMana.determineLeftoverMana(sa, ai);
 
-            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 maxCtrs = Integer.parseInt(sa.getParam("MaxFromEffect"));
+                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 maxCtrs = Integer.parseInt(sa.getParam("MaxFromEffect"));
 
-                // This will "rewind" clockwork cards when they fall to 50% power or below, consider improving
-                if (curCtrs > Math.ceil(maxCtrs / 2.0)) {
-                    return false;
+                    // This will "rewind" clockwork cards when they fall to 50% power or below, consider improving
+                    if (curCtrs > Math.ceil(maxCtrs / 2.0)) {
+                        return false;
+                    }
+
+                    amount = Math.min(amount, maxCtrs - curCtrs);
+                    if (amount <= 0) {
+                        return false;
+                    }
                 }
 
-                amount = Math.min(amount, maxCtrs - curCtrs);
-                if (amount <= 0) { return false; }
+                source.setSVar("PayX", Integer.toString(amount));
+            } else if ("ExiledCreatureFromGraveCMC".equals(sa.getParam("AILogic"))) {
+                // e.g. Necropolis
+                amount = Aggregates.max(CardLists.filter(ai.getCardsIn(ZoneType.Graveyard), CardPredicates.Presets.CREATURES), CardPredicates.Accessors.fnGetCmc);
+                if (amount > 0 && ai.getGame().getPhaseHandler().is(PhaseType.END_OF_TURN)) {
+                    return true;
+                }
             }
-
-            source.setSVar("PayX", Integer.toString(amount));
         }
 
         // don't use it if no counters to add
@@ -327,7 +363,7 @@ public class CountersPutAi extends SpellAbilityAi {
         PhaseHandler ph = ai.getGame().getPhaseHandler();
 
         if ("AlwaysAtOppEOT".equals(sa.getParam("AILogic"))) {
-            if (ph.is(PhaseType.END_OF_TURN) && !ph.isPlayerTurn(ai)) {
+            if (ph.is(PhaseType.END_OF_TURN) && ph.getNextTurn().equals(ai)) {
                 return true;
             }
         }
@@ -476,7 +512,7 @@ public class CountersPutAi extends SpellAbilityAi {
             }
         } else {
             final List<Card> cards = AbilityUtils.getDefinedCards(sa.getHostCard(), sa.getParam("Defined"), sa);
-            // Don't activate Curse abilities on my cards and non-curse abilites
+            // Don't activate Curse abilities on my cards and non-curse abilities
             // on my opponents
             if (cards.isEmpty() || (cards.get(0).getController().isOpponentOf(ai) && !sa.isCurse())) {
                 return false;
@@ -486,7 +522,7 @@ public class CountersPutAi extends SpellAbilityAi {
             // each non +1/+1 counter on the card is a 10% chance of not
             // activating this ability.
 
-            if (!(type.equals("P1P1") || type.equals("M1M1") || type.equals("ICE")) && (r.nextFloat() < (.1 * currCounters))) {
+            if (!(type.equals("P1P1") || type.equals("M1M1") || type.equals("ICE")) && (MyRandom.getRandom().nextFloat() < (.1 * currCounters))) {
                 return false;
             }
             // Instant +1/+1
@@ -499,7 +535,7 @@ public class CountersPutAi extends SpellAbilityAi {
 
         boolean immediately = ComputerUtil.playImmediately(ai, sa);
         
-        if (abCost != null && !ComputerUtilCost.checkSacrificeCost(ai, abCost, source, immediately)) {
+        if (abCost != null && !ComputerUtilCost.checkSacrificeCost(ai, abCost, source, sa, immediately)) {
             return false;
         }
         
@@ -536,7 +572,7 @@ public class CountersPutAi extends SpellAbilityAi {
         final int amount = AbilityUtils.calculateAmount(sa.getHostCard(), amountStr, sa);
 
         final boolean isMandatoryTrigger = (sa.isTrigger() && !sa.isOptionalTrigger()) 
-                || (sa.getRootAbility().isTrigger() || !sa.getRootAbility().isOptionalTrigger());
+                || (sa.getRootAbility().isTrigger() && !sa.getRootAbility().isOptionalTrigger());
 
         if (sa.usesTargeting()) {
             CardCollection list = null;
@@ -678,6 +714,13 @@ public class CountersPutAi extends SpellAbilityAi {
                         list = CardLists.getTargetableCards(ai.getOpponents().getCardsIn(ZoneType.Battlefield), sa);
                         preferred = false;
                     }
+
+                    if (list.isEmpty()) {
+                        // Still an empty list, but we have to choose something (mandatory); expand targeting to
+                        // include AI's own cards to see if there's anything targetable (e.g. Plague Belcher).
+                        list = CardLists.getTargetableCards(ai.getCardsIn(ZoneType.Battlefield), sa);
+                        preferred = false;
+                    }
                 }
 
                 if (list.isEmpty()) {

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

@@ -1,7 +1,7 @@
 package forge.ai.ability;
 
 import com.google.common.base.Predicate;
-
+import com.google.common.collect.Lists;
 import forge.ai.ComputerUtil;
 import forge.ai.ComputerUtilCost;
 import forge.ai.ComputerUtilMana;
@@ -21,7 +21,6 @@ import forge.game.zone.ZoneType;
 import forge.util.MyRandom;
 
 import java.util.List;
-import java.util.Random;
 
 public class CountersPutAllAi extends SpellAbilityAi {
     @Override
@@ -29,7 +28,6 @@ public class CountersPutAllAi extends SpellAbilityAi {
         // AI needs to be expanded, since this function can be pretty complex
         // based on what
         // the expected targets could be
-        final Random r = MyRandom.getRandom();
         final Cost abCost = sa.getPayCosts();
         final Card source = sa.getHostCard();
         List<Card> hList;
@@ -54,7 +52,7 @@ public class CountersPutAllAi extends SpellAbilityAi {
                 return false;
             }
 
-            if (!ComputerUtilCost.checkSacrificeCost(ai, abCost, source)) {
+            if (!ComputerUtilCost.checkSacrificeCost(ai, abCost, source, sa)) {
                 return false;
             }
         }
@@ -63,6 +61,10 @@ public class CountersPutAllAi extends SpellAbilityAi {
             if (!ai.getGame().getPhaseHandler().is(PhaseType.END_OF_TURN) && !ai.getGame().getPhaseHandler().is(PhaseType.COMBAT_DECLARE_BLOCKERS)) {
                 return false;
             }
+        } else if (logic.equals("AtOppEOT")) {
+            if (!(ai.getGame().getPhaseHandler().is(PhaseType.END_OF_TURN) && ai.getGame().getPhaseHandler().getNextTurn() == ai)) {
+                return false;
+            }
         }
 
         if (tgt != null) {
@@ -85,7 +87,7 @@ public class CountersPutAllAi extends SpellAbilityAi {
         }
 
         // prevent run-away activations - first time will always return true
-        boolean chance = r.nextFloat() <= Math.pow(.6667, sa.getActivationsThisTurn());
+        boolean chance = MyRandom.getRandom().nextFloat() <= Math.pow(.6667, sa.getActivationsThisTurn());
 
         if (curse) {
             if (type.equals("M1M1")) {
@@ -135,7 +137,7 @@ public class CountersPutAllAi extends SpellAbilityAi {
             return chance;
         }
 
-        return ((r.nextFloat() < .6667) && chance);
+        return ((MyRandom.getRandom().nextFloat() < .6667) && chance);
     }
 
     @Override
@@ -149,4 +151,31 @@ public class CountersPutAllAi extends SpellAbilityAi {
     public boolean confirmAction(Player player, SpellAbility sa, PlayerActionConfirmMode mode, String message) {
         return player.getCreaturesInPlay().size() >= ComputerUtil.getOpponentFor(player).getCreaturesInPlay().size();
     }
+
+    @Override
+    protected boolean doTriggerAINoCost(final Player aiPlayer, final SpellAbility sa, final boolean mandatory) {
+        if (sa.usesTargeting()) {
+            List<Player> players = Lists.newArrayList();
+            if (!sa.isCurse()) {
+                players.add(aiPlayer);
+            }
+            players.addAll(aiPlayer.getOpponents());
+            players.addAll(aiPlayer.getAllies());
+            if (sa.isCurse()) {
+                players.add(aiPlayer);
+            }
+
+            for (final Player p : players) {
+                if (p.canBeTargetedBy(sa) && sa.canTarget(p)) {
+                    boolean preferred = false;
+                    preferred = (sa.isCurse() && p.isOpponentOf(aiPlayer)) || (!sa.isCurse() && p == aiPlayer);
+                    sa.resetTargets();
+                    sa.getTargets().add(p);
+                    return preferred || mandatory;
+                }
+            }
+        }
+
+        return mandatory;
+    }
 }

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

@@ -17,25 +17,20 @@
  */
 package forge.ai.ability;
 
-import java.util.List;
-import java.util.Map;
-
 import forge.ai.ComputerUtil;
 import forge.ai.ComputerUtilCard;
 import forge.ai.SpellAbilityAi;
 import forge.game.Game;
 import forge.game.GlobalRuleChange;
-import forge.game.card.Card;
-import forge.game.card.CardCollection;
-import forge.game.card.CardCollectionView;
-import forge.game.card.CardLists;
-import forge.game.card.CardPredicates;
-import forge.game.card.CounterType;
+import forge.game.card.*;
 import forge.game.player.Player;
 import forge.game.player.PlayerController.BinaryChoiceType;
 import forge.game.spellability.SpellAbility;
 import forge.game.spellability.TargetRestrictions;
 
+import java.util.List;
+import java.util.Map;
+
 /**
  * <p>
  * AbilityFactory_PutOrRemoveCountersAi class.
@@ -75,13 +70,8 @@ public class CountersPutOrRemoveAi extends SpellAbilityAi {
             return false;
         }
 
-        if (sa.hasParam("AITgts")) {
-            String aiTgts = sa.getParam("AITgts");
-            CardCollection prefList = CardLists.getValidCards(list, aiTgts.split(","), ai, source, sa);
-            if (!prefList.isEmpty() || sa.hasParam("AITgtsStrict")) {
-                list = prefList;
-            }
-        }
+        // Filter AI-specific targets if provided
+        list = ComputerUtil.filterAITgts(sa, ai, (CardCollection)list, false);
 
         if (sa.hasParam("CounterType")) {
             // currently only Jhoira's Timebug
@@ -122,7 +112,7 @@ public class CountersPutOrRemoveAi extends SpellAbilityAi {
                 // with one touch
                 CardCollection planeswalkerList = CardLists.filter(
                         CardLists.filterControlledBy(countersList, ai.getOpponents()),
-                        CardPredicates.Presets.PLANEWALKERS,
+                        CardPredicates.Presets.PLANESWALKERS,
                         CardPredicates.hasLessCounter(CounterType.LOYALTY, amount));
 
                 if (!planeswalkerList.isEmpty()) {

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

@@ -1,8 +1,6 @@
 package forge.ai.ability;
 
-import java.util.List;
-import java.util.Map;
-
+import com.google.common.base.Predicates;
 import forge.ai.ComputerUtil;
 import forge.ai.ComputerUtilCard;
 import forge.ai.ComputerUtilMana;
@@ -10,12 +8,7 @@ import forge.ai.SpellAbilityAi;
 import forge.game.Game;
 import forge.game.GlobalRuleChange;
 import forge.game.ability.AbilityUtils;
-import forge.game.card.Card;
-import forge.game.card.CardCollection;
-import forge.game.card.CardCollectionView;
-import forge.game.card.CardLists;
-import forge.game.card.CardPredicates;
-import forge.game.card.CounterType;
+import forge.game.card.*;
 import forge.game.phase.PhaseHandler;
 import forge.game.phase.PhaseType;
 import forge.game.player.Player;
@@ -23,6 +16,9 @@ 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 CountersRemoveAi extends SpellAbilityAi {
 
     /*
@@ -102,13 +98,8 @@ public class CountersRemoveAi extends SpellAbilityAi {
             return false;
         }
 
-        if (sa.hasParam("AITgts")) {
-            String aiTgts = sa.getParam("AITgts");
-            CardCollection prefList = CardLists.getValidCards(list, aiTgts.split(","), ai, source, sa);
-            if (!prefList.isEmpty() || sa.hasParam("AITgtsStrict")) {
-                list = prefList;
-            }
-        }
+        // Filter AI-specific targets if provided
+        list = ComputerUtil.filterAITgts(sa, ai, (CardCollection)list, false);
 
         boolean noLegendary = game.getStaticEffects().getGlobalRuleChange(GlobalRuleChange.noLegendRule);
 
@@ -130,7 +121,7 @@ public class CountersRemoveAi extends SpellAbilityAi {
             list = ai.getOpponents().getCardsIn(ZoneType.Battlefield);
             list = CardLists.filter(list, CardPredicates.isTargetableBy(sa));
 
-            CardCollection planeswalkerList = CardLists.filter(list, CardPredicates.Presets.PLANEWALKERS,
+            CardCollection planeswalkerList = CardLists.filter(list, CardPredicates.Presets.PLANESWALKERS,
                     CardPredicates.hasCounter(CounterType.LOYALTY, 5));
 
             if (!planeswalkerList.isEmpty()) {
@@ -174,10 +165,11 @@ public class CountersRemoveAi extends SpellAbilityAi {
             }
 
             // Get rid of Planeswalkers:
-            list = ai.getOpponents().getCardsIn(ZoneType.Battlefield);
+            list = game.getPlayers().getCardsIn(ZoneType.Battlefield);
             list = CardLists.filter(list, CardPredicates.isTargetableBy(sa));
 
-            CardCollection planeswalkerList = CardLists.filter(list, CardPredicates.Presets.PLANEWALKERS,
+            CardCollection planeswalkerList = CardLists.filter(list,
+                    Predicates.and(CardPredicates.Presets.PLANESWALKERS, CardPredicates.isControlledByAnyOf(ai.getOpponents())),
                     CardPredicates.hasLessCounter(CounterType.LOYALTY, amount));
 
             if (!planeswalkerList.isEmpty()) {

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

@@ -1,25 +1,68 @@
 package forge.ai.ability;
 
 import com.google.common.collect.Iterables;
-
 import forge.ai.ComputerUtil;
 import forge.ai.ComputerUtilCombat;
 import forge.ai.SpellAbilityAi;
 import forge.game.Game;
+import forge.game.card.Card;
 import forge.game.card.CardCollectionView;
 import forge.game.card.CardPredicates;
 import forge.game.phase.PhaseHandler;
 import forge.game.phase.PhaseType;
 import forge.game.player.Player;
 import forge.game.spellability.SpellAbility;
+import forge.game.trigger.Trigger;
+import forge.game.trigger.TriggerDamageDone;
 import forge.game.zone.ZoneType;
 import forge.util.MyRandom;
 
 public abstract class DamageAiBase extends SpellAbilityAi {
+    protected boolean avoidTargetP(final Player comp, final SpellAbility sa) {
+        Player enemy = ComputerUtil.getOpponentFor(comp);
+        // Logic for cards that damage owner, like Fireslinger
+        // Do not target a player if they aren't below 75% of our health.
+        // Unless Lifelink will cancel the damage to us
+        Card hostcard = sa.getHostCard();
+        boolean lifelink = hostcard.hasKeyword("Lifelink");
+        for (Card ench : hostcard.getEnchantedBy(false)) {
+            // Treat cards enchanted by older cards with "when enchanted creature deals damage, gain life" as if they had lifelink.
+            if (ench.hasSVar("LikeLifeLink")) {
+                if ("True".equals(ench.getSVar("LikeLifeLink"))) {
+                    lifelink = true;
+                }
+            }
+        }
+        if ("SelfDamage".equals(sa.getParam("AILogic"))) {
+            if (comp.getLife() * 0.75 < enemy.getLife()) {
+                if (!lifelink) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
     protected boolean shouldTgtP(final Player comp, final SpellAbility sa, final int d, final boolean noPrevention) {
+        // TODO: once the "planeswalker redirection" rule is removed completely, just remove this code and
+        // remove the "burn Planeswalkers" code in the called method.
+        return shouldTgtP(comp, sa, d, noPrevention, false);
+    }
+    protected boolean shouldTgtP(final Player comp, final SpellAbility sa, final int d, final boolean noPrevention, final boolean noPlaneswalkerRedirection) {
         int restDamage = d;
         final Game game = comp.getGame();
-        final Player enemy = ComputerUtil.getOpponentFor(comp);
+        Player enemy = ComputerUtil.getOpponentFor(comp);
+        boolean dmgByCardsInHand = false;
+
+        if ("X".equals(sa.getParam("NumDmg")) && sa.getHostCard() != null && sa.hasSVar(sa.getParam("NumDmg")) &&
+                sa.getHostCard().getSVar(sa.getParam("NumDmg")).equals("TargetedPlayer$CardsInHand")) {
+            dmgByCardsInHand = true;
+        }
+        // Not sure if type choice implemented for the AI yet but it should at least recognize this spell hits harder on larger enemy hand size
+        if ("Blood Oath".equals(sa.getHostCard().getName())) {
+            dmgByCardsInHand = true;
+        }
+
         if (!sa.canTarget(enemy)) {
             return false;
         }
@@ -27,11 +70,29 @@ public abstract class DamageAiBase extends SpellAbilityAi {
             return false;
         }
 
+        // Benefits hitting players?
+        // If has triggered ability on dealing damage to an opponent, go for it!
+        Card hostcard = sa.getHostCard();
+        for (Trigger trig : hostcard.getTriggers()) {
+            if (trig instanceof TriggerDamageDone) {
+                if (("Opponent".equals(trig.getParam("ValidTarget")))
+                        && (!"True".equals(trig.getParam("CombatDamage")))) {
+                    return true;
+                }
+            }
+        }
+
         // burn Planeswalkers
-        if (Iterables.any(enemy.getCardsIn(ZoneType.Battlefield), CardPredicates.Presets.PLANEWALKERS)) {
+        // TODO: Must be removed completely when the "planeswalker redirection" rule is removed.
+        if (!noPlaneswalkerRedirection
+                && Iterables.any(enemy.getCardsIn(ZoneType.Battlefield), CardPredicates.Presets.PLANESWALKERS)) {
             return true;
         }
 
+        if (avoidTargetP(comp, sa)) {
+            return false;
+        }
+
         if (!noPrevention) {
             restDamage = ComputerUtilCombat.predictDamageTo(enemy, restDamage, sa.getHostCard(), false);
         } else {
@@ -71,8 +132,18 @@ public abstract class DamageAiBase extends SpellAbilityAi {
                         value = 1.0f * restDamage / enemy.getLife();
                     }
                 } else {
-                    if (phase.isPlayerTurn(enemy) && phase.is(PhaseType.END_OF_TURN)) {
-                        value = 1.5f * restDamage / enemy.getLife();
+                    // If Sudden Impact type spell, and can hit at least 3 cards during draw phase
+                    // have a 100% chance to go for it, enemy hand will only lose cards over time!
+                    // But if 3 or less cards, use normal rules, just in case enemy starts holding card or plays a draw spell or we need mana for other instants.
+                    if (phase.isPlayerTurn(enemy)) {
+                        if (dmgByCardsInHand
+                                && (phase.is(PhaseType.DRAW))
+                                && (enemy.getCardsIn(ZoneType.Hand).size() > 3)) {
+                            value = 1;
+                        } else if (phase.is(PhaseType.END_OF_TURN)
+                                || ((dmgByCardsInHand && phase.getPhase().isAfter(PhaseType.UPKEEP)))) {
+                            value = 1.5f * restDamage / enemy.getLife();
+                        }
                     }
                 }
                 if (value > 0) {    //more likely to burn with larger hand

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

@@ -1,7 +1,6 @@
 package forge.ai.ability;
 
 import com.google.common.base.Predicate;
-
 import forge.ai.*;
 import forge.game.ability.AbilityUtils;
 import forge.game.card.Card;
@@ -16,8 +15,6 @@ import forge.game.spellability.TargetRestrictions;
 import forge.game.zone.ZoneType;
 import forge.util.MyRandom;
 
-import java.util.Random;
-
 public class  DamageAllAi extends SpellAbilityAi {
     @Override
     protected boolean canPlayAI(Player ai, SpellAbility sa) {
@@ -26,8 +23,7 @@ public class  DamageAllAi extends SpellAbilityAi {
         final Card source = sa.getHostCard();
 
         // prevent run-away activations - first time will always return true
-        final Random r = MyRandom.getRandom();
-        if (r.nextFloat() > Math.pow(.9, sa.getActivationsThisTurn())) {
+        if (MyRandom.getRandom().nextFloat() > Math.pow(.9, sa.getActivationsThisTurn())) {
             return false;
         }
         // abCost stuff that should probably be centralized...
@@ -56,16 +52,35 @@ public class  DamageAllAi extends SpellAbilityAi {
             x = source.getCounters(CounterType.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;
+            }
+            // look for other value in this (damaging creatures or
+            // creatures + player, e.g. Pestilence, etc.)
             return evaluateDamageAll(ai, sa, source, dmg) > 0;
         } else {
             int best = -1, best_x = -1;
-            for (int i = 0; i <= x; i++) {
-                final int value = evaluateDamageAll(ai, sa, source, i);
-                if (value > best) {
-                    best = value;
-                    best_x = i;
+            Player bestOpp = determineOppToKill(ai, sa, source, x);
+            if (bestOpp != null) {
+                // we can finish off a player, so go for it
+
+                // TODO: improve this by possibly damaging more creatures
+                // on the battlefield belonging to other opponents at the same
+                // time, if viable
+                best_x = bestOpp.getLife();
+            } else {
+                // see if it's possible to get value from killing off creatures
+                for (int i = 0; i <= x; i++) {
+                    final int value = evaluateDamageAll(ai, sa, source, i);
+                    if (value > best) {
+                        best = value;
+                        best_x = i;
+                    }
                 }
             }
+
             if (best_x > 0) {
                 if (sa.getSVar(damage).equals("Count$xPaid")) {
                     source.setSVar("PayX", Integer.toString(best_x));
@@ -79,8 +94,31 @@ public class  DamageAllAi extends SpellAbilityAi {
         }
     }
 
+    private Player determineOppToKill(Player ai, SpellAbility sa, Card source, int x) {
+        // Attempt to determine which opponent can be finished off such that the most players
+        // are killed at the same time, given X damage tops
+        final String validP = sa.hasParam("ValidPlayers") ? sa.getParam("ValidPlayers") : "";
+        int aiLife = ai.getLife();
+        Player bestOpp = null; // default opponent, if all else fails
+
+        for (int dmg = 1; dmg <= x; dmg++) {
+            // Don't kill yourself in the process
+            if (validP.equals("Player") && aiLife <= ComputerUtilCombat.predictDamageTo(ai, dmg, source, false)) {
+                break;
+            }
+            for (Player opp : ai.getOpponents()) {
+                if ((validP.equals("Player") || validP.contains("Opponent"))
+                        && (opp.getLife() <= ComputerUtilCombat.predictDamageTo(opp, dmg, source, false))) {
+                    bestOpp = opp;
+                }
+            }
+        }
+
+        return bestOpp;
+    }
+
     private int evaluateDamageAll(Player ai, SpellAbility sa, final Card source, int dmg) {
-        Player opp = ComputerUtil.getOpponentFor(ai);
+        final Player opp = ai.getWeakestOpponent();
         final CardCollection humanList = getKillableCreatures(sa, opp, dmg);
         CardCollection computerList = getKillableCreatures(sa, ai, dmg);
 
@@ -98,62 +136,56 @@ public class  DamageAllAi extends SpellAbilityAi {
             return -1;
         }
 
-        // if we can kill human, do it
-        if ((validP.equals("Player") || validP.contains("Opponent"))
-                && (opp.getLife() <= ComputerUtilCombat.predictDamageTo(opp, dmg, source, false))) {
-            return 1;
-        }
-
-		int minGain = 200; // The minimum gain in destroyed creatures
-		if (sa.getPayCosts() != null && sa.getPayCosts().isReusuableResource()) {
-			if (computerList.isEmpty()) {
-				minGain = 10; // nothing to lose
-				// no creatures to lose and player can be damaged
-				// so do it if it's helping!
-				// ----------------------------
-				// needs future improvement on pestilence : 
-				// what if we lose creatures but can win by repeated activations?
-				// that tactic only works if there are creatures left to keep pestilence in play
-				// and can kill the player in a reasonable amount of time (no more than 2-3 turns?)
-				if (validP.equals("Player")) {
-					if (ComputerUtilCombat.predictDamageTo(opp, dmg, source, false) > 0) {
-						// When using Pestilence to hurt players, do it at
-						// the end of the opponent's turn only
-						if ((!"DmgAllCreaturesAndPlayers".equals(sa.getParam("AILogic")))
-								|| ((ai.getGame().getPhaseHandler().is(PhaseType.END_OF_TURN)
-										&& (ai.getGame().getNonactivePlayers().contains(ai)))))
-						// Need further improvement : if able to kill immediately with repeated activations, do not wait
-						// for phases! Will also need to implement considering repeated activations for killed creatures!
-						// || (ai.sa.getPayCosts(). ??? )
-						{
-							// would take zero damage, and hurt opponent, do it!
-							if (ComputerUtilCombat.predictDamageTo(ai, dmg, source, false)<1) {
-								return 1;
-							}
-							// enemy is expected to die faster than AI from damage if repeated
-							if (ai.getLife() > ComputerUtilCombat.predictDamageTo(ai, dmg, source, false)
-									* ((opp.getLife() + ComputerUtilCombat.predictDamageTo(opp, dmg, source, false) - 1)
-											/ ComputerUtilCombat.predictDamageTo(opp, dmg, source, false))) {
-								// enemy below 10 life, go for it!
-								if ((opp.getLife() < 10)
-										&& (ComputerUtilCombat.predictDamageTo(opp, dmg, source, false) >= 1)) {
-									return 1;
-								}
-								// At least half enemy remaining life can be removed in one go
-								// worth doing even if enemy still has high health - one more copy of spell to win!
-								if (opp.getLife() <= 2 * ComputerUtilCombat.predictDamageTo(opp, dmg, source, false)) {
-									return 1;
-								}
-							}
-						}
-					}
-				}
-			} else {
-				minGain = 100; // safety for errors in evaluate creature
-        	}
+        int minGain = 200; // The minimum gain in destroyed creatures
+        if (sa.getPayCosts() != null && sa.getPayCosts().isReusuableResource()) {
+            if (computerList.isEmpty()) {
+                minGain = 10; // nothing to lose
+                // no creatures to lose and player can be damaged
+                // so do it if it's helping!
+                // ----------------------------
+                // needs future improvement on pestilence :
+                // what if we lose creatures but can win by repeated activations?
+                // that tactic only works if there are creatures left to keep pestilence in play
+                // and can kill the player in a reasonable amount of time (no more than 2-3 turns?)
+                if (validP.equals("Player")) {
+                    if (ComputerUtilCombat.predictDamageTo(opp, dmg, source, false) > 0) {
+                        // When using Pestilence to hurt players, do it at
+                        // the end of the opponent's turn only
+                        if ((!"DmgAllCreaturesAndPlayers".equals(sa.getParam("AILogic")))
+                                || ((ai.getGame().getPhaseHandler().is(PhaseType.END_OF_TURN)
+                                && (ai.getGame().getNonactivePlayers().contains(ai)))))
+                        // Need further improvement : if able to kill immediately with repeated activations, do not wait
+                        // for phases! Will also need to implement considering repeated activations for killed creatures!
+                        // || (ai.sa.getPayCosts(). ??? )
+                        {
+                            // would take zero damage, and hurt opponent, do it!
+                            if (ComputerUtilCombat.predictDamageTo(ai, dmg, source, false)<1) {
+                                return 1;
+                            }
+                            // enemy is expected to die faster than AI from damage if repeated
+                            if (ai.getLife() > ComputerUtilCombat.predictDamageTo(ai, dmg, source, false)
+                                    * ((opp.getLife() + ComputerUtilCombat.predictDamageTo(opp, dmg, source, false) - 1)
+                                    / ComputerUtilCombat.predictDamageTo(opp, dmg, source, false))) {
+                                // enemy below 10 life, go for it!
+                                if ((opp.getLife() < 10)
+                                        && (ComputerUtilCombat.predictDamageTo(opp, dmg, source, false) >= 1)) {
+                                    return 1;
+                                }
+                                // At least half enemy remaining life can be removed in one go
+                                // worth doing even if enemy still has high health - one more copy of spell to win!
+                                if (opp.getLife() <= 2 * ComputerUtilCombat.predictDamageTo(opp, dmg, source, false)) {
+                                    return 1;
+                                }
+                            }
+                        }
+                    }
+                }
+            } else {
+                minGain = 100; // safety for errors in evaluate creature
+            }
         } else if (sa.getSubAbility() != null && ai.getGame().getPhaseHandler().isPreCombatMain() && computerList.isEmpty()
-        		&& opp.getCreaturesInPlay().size() > 1 && !ai.getCreaturesInPlay().isEmpty()) {
-        	minGain = 126; // prepare for attack
+                && opp.getCreaturesInPlay().size() > 1 && !ai.getCreaturesInPlay().isEmpty()) {
+            minGain = 126; // prepare for attack
         }
 
         return ComputerUtilCard.evaluateCreatureList(humanList) - ComputerUtilCard.evaluateCreatureList(computerList)

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

@@ -1,22 +1,15 @@
 package forge.ai.ability;
 
-import java.util.List;
-import java.util.Map;
-
 import com.google.common.base.Predicate;
 import com.google.common.collect.Lists;
 import com.google.common.collect.Maps;
-
 import forge.ai.*;
 import forge.game.Game;
 import forge.game.GameObject;
 import forge.game.ability.AbilityUtils;
-import forge.game.card.Card;
-import forge.game.card.CardCollection;
-import forge.game.card.CardLists;
-import forge.game.card.CardPredicates;
-import forge.game.card.CounterType;
+import forge.game.card.*;
 import forge.game.cost.Cost;
+import forge.game.cost.CostRemoveCounter;
 import forge.game.phase.PhaseHandler;
 import forge.game.phase.PhaseType;
 import forge.game.player.Player;
@@ -28,6 +21,9 @@ import forge.game.spellability.TargetRestrictions;
 import forge.game.zone.ZoneType;
 import forge.util.Aggregates;
 
+import java.util.List;
+import java.util.Map;
+
 public class DamageDealAi extends DamageAiBase {
     @Override
     public boolean chkAIDrawback(SpellAbility sa, Player ai) {
@@ -98,6 +94,29 @@ public class DamageDealAi extends DamageAiBase {
                 source.setSVar("PayX", Integer.toString(dmg));
             } else if (sa.getSVar(damage).equals("Count$CardsInYourHand") && source.getZone().is(ZoneType.Hand)) {
                 dmg--; // the card will be spent casting the spell, so actual damage is 1 less
+            } else if (sa.getSVar(damage).equals("TargetedPlayer$CardsInHand")) {
+                // cards that deal damage by the number of cards in target player's hand, e.g. Sudden Impact
+                if (sa.getTargetRestrictions().canTgtPlayer()) {
+                    int maxDmg = 0;
+                    Player maxDamaged = null;
+                    for (Player p : ai.getOpponents()) {
+                        if (p.canBeTargetedBy(sa)) {
+                            if (p.getCardsIn(ZoneType.Hand).size() > maxDmg) {
+                                maxDmg = p.getCardsIn(ZoneType.Hand).size();
+                                maxDamaged = p;
+                            }
+                        }
+                    }
+                    if (maxDmg > 0 && maxDamaged != null) {
+                        if (shouldTgtP(ai, sa, maxDmg, false)) {
+                            sa.resetTargets();
+                            sa.getTargets().add(maxDamaged);
+                            return true;
+                        }
+                    } else {
+                        return false;
+                    }
+                }
             }
         }
 
@@ -105,9 +124,20 @@ public class DamageDealAi extends DamageAiBase {
             dmg += 2;
         }
         
-        String logic = sa.getParam("AILogic");
+        String logic = sa.getParamOrDefault("AILogic", "");
         if ("DiscardLands".equals(logic)) {
             dmg = 2;
+        } else if (logic.startsWith("ProcRaid.")) {
+            if (ai.getGame().getPhaseHandler().isPlayerTurn(ai) && ai.getGame().getPhaseHandler().getPhase().isBefore(PhaseType.COMBAT_DECLARE_BLOCKERS)) {
+                for (Card potentialAtkr : ai.getCreaturesInPlay()) {
+                    if (ComputerUtilCard.doesCreatureAttackAI(ai, potentialAtkr)) {
+                        return false;
+                    }
+                }
+            }
+            if (ai.getAttackedWithCreatureThisTurn()) {
+                dmg = Integer.parseInt(logic.substring(logic.indexOf(".") + 1));
+            }
         } else if ("WildHunt".equals(logic)) {
             // This dummy ability will just deal 0 damage, but holds the logic for the AI for Master of Wild Hunt
             List<Card> wolves = CardLists.getValidCards(ai.getCardsIn(ZoneType.Battlefield), "Creature.Wolf+untapped+YouCtrl+Other", ai, source);
@@ -131,6 +161,18 @@ public class DamageDealAi extends DamageAiBase {
             } else {
                 return false;
             }
+        } else if ("NinThePainArtist".equals(logic)) {
+            // Make sure not to mana lock ourselves + make the opponent draw cards into an immediate discard
+            if (ai.getGame().getPhaseHandler().is(PhaseType.END_OF_TURN)) {
+                boolean doTarget = damageTargetAI(ai, sa, dmg, true);
+                if (doTarget) {
+                    Card tgt = sa.getTargets().getFirstTargetedCard();
+                    if (tgt != null) {
+                        return ai.getGame().getPhaseHandler().getPlayerTurn() == tgt.getController();
+                    }
+                }
+            }
+            return false;
         }
         
         if (sourceName.equals("Sorin, Grim Nemesis")) {
@@ -157,7 +199,7 @@ public class DamageDealAi extends DamageAiBase {
             return false;
         }
 
-        if (!ComputerUtilCost.checkSacrificeCost(ai, abCost, source)) {
+        if (!ComputerUtilCost.checkSacrificeCost(ai, abCost, source, sa)) {
             return false;
         }
 
@@ -230,35 +272,21 @@ public class DamageDealAi extends DamageAiBase {
         final Player activator = sa.getActivatingPlayer();
         final Card source = sa.getHostCard();
         final Game game = source.getGame();
-        List<Card> hPlay = CardLists.getValidCards(game.getCardsIn(ZoneType.Battlefield), tgt.getValidTgts(), activator, source, sa);
+        List<Card> hPlay = CardLists.filter(getTargetableCards(ai, sa, pl, tgt, activator, source, game), CardPredicates.Presets.PLANESWALKERS);
 
-        if (activator.equals(ai)) {
-            hPlay = CardLists.filterControlledBy(hPlay, pl);
-        }
-
-        final List<GameObject> objects = Lists.newArrayList(sa.getTargets().getTargets());
-        if (sa.hasParam("TargetUnique")) {
-            objects.addAll(sa.getUniqueTargets());
-        }
-        for (final Object o : objects) {
-            if (o instanceof Card) {
-                final Card c = (Card) o;
-                if (hPlay.contains(c)) {
-                    hPlay.remove(c);
-                }
-            }
-        }
-        hPlay = CardLists.getTargetableCards(hPlay, sa);
-
-        final List<Card> killables = CardLists.filter(hPlay, new Predicate<Card>() {
+        List<Card> killables = CardLists.filter(hPlay, new Predicate<Card>() {
             @Override
             public boolean apply(final Card c) {
                 return c.getSVar("Targeting").equals("Dies")
-                        || (ComputerUtilCombat.getEnoughDamageToKill(c, d, source, false, noPrevention) <= d) && !ComputerUtil.canRegenerate(ai, c)
+                        || (ComputerUtilCombat.getEnoughDamageToKill(c, d, source, false, noPrevention) <= d)
+                            && !ComputerUtil.canRegenerate(ai, c)
                             && !(c.getSVar("SacMe").length() > 0);
             }
         });
 
+        // Filter AI-specific targets if provided
+        killables = ComputerUtil.filterAITgts(sa, ai, new CardCollection(killables), true);
+
         Card targetCard = null;
         if (pl.isOpponentOf(ai) && activator.equals(ai) && !killables.isEmpty()) {
             if (sa.getTargetRestrictions().canTgtPlaneswalker()) {
@@ -293,6 +321,114 @@ public class DamageDealAi extends DamageAiBase {
         return null;
     }
 
+    /**
+     * <p>
+     * dealDamageChooseTgtPW.
+     * </p>
+     *
+     * @param d
+     *            a int.
+     * @param noPrevention
+     *            a boolean.
+     * @param pl
+     *            a {@link forge.game.player.Player} object.
+     * @param mandatory
+     *            a boolean.
+     * @return a {@link forge.game.card.Card} object.
+     */
+    private Card dealDamageChooseTgtPW(final Player ai, final SpellAbility sa, final int d, final boolean noPrevention,
+                                       final Player pl, final boolean mandatory) {
+
+        final TargetRestrictions tgt = sa.getTargetRestrictions();
+        final Player activator = sa.getActivatingPlayer();
+        final Card source = sa.getHostCard();
+        final Game game = source.getGame();
+        List<Card> hPlay = CardLists.filter(getTargetableCards(ai, sa, pl, tgt, activator, source, game), CardPredicates.Presets.PLANESWALKERS);
+
+        List<Card> killables = CardLists.filter(hPlay, new Predicate<Card>() {
+            @Override
+            public boolean apply(final Card c) {
+                return c.getSVar("Targeting").equals("Dies")
+                        || (ComputerUtilCombat.getEnoughDamageToKill(c, d, source, false, noPrevention) <= d)
+                        && !ComputerUtil.canRegenerate(ai, c)
+                        && !(c.getSVar("SacMe").length() > 0);
+            }
+        });
+
+        // Filter AI-specific targets if provided
+        killables = ComputerUtil.filterAITgts(sa, ai, new CardCollection(killables), true);
+
+        // We can kill a planeswalker, so go for it
+        if (pl.isOpponentOf(ai) && activator.equals(ai) && !killables.isEmpty()) {
+            return ComputerUtilCard.getBestPlaneswalkerAI(killables);
+        }
+
+        // We can hurt a planeswalker, so rank the one which is the best target
+        if (!hPlay.isEmpty() && pl.isOpponentOf(ai) && activator.equals(ai)) {
+            return getBestPlaneswalkerToDamage(hPlay);
+        }
+
+        return null;
+    }
+
+    private Card getBestPlaneswalkerToDamage(final List<Card> pws) {
+        Card bestTgt = null;
+
+        // 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 pwScore = curLoyalty * 10;
+
+            for (SpellAbility sa : pw.getSpellAbilities()) {
+                if (sa.hasParam("Ultimate") && sa.getPayCosts() != null) {
+                    int loyaltyCost = 0;
+                    CostRemoveCounter remLoyalty = sa.getPayCosts().getCostPartByType(CostRemoveCounter.class);
+                    if (remLoyalty != null) {
+                        // if remLoyalty is null, generally there's an AddCounter<0/LOYALTY> cost, like for Gideon Jura.
+                        loyaltyCost = remLoyalty.convertAmount();
+                    }
+
+                    if (loyaltyCost != 0 && loyaltyCost - curLoyalty <= 1) {
+                        // Will ultimate soon
+                        pwScore += 10000;
+                    }
+
+                    if (pwScore > bestScore) {
+                        bestScore = pwScore;
+                        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);
+
+        if (activator.equals(ai)) {
+            hPlay = CardLists.filterControlledBy(hPlay, pl);
+        }
+
+        final List<GameObject> objects = Lists.newArrayList(sa.getTargets().getTargets());
+        if (sa.hasParam("TargetUnique")) {
+            objects.addAll(sa.getUniqueTargets());
+        }
+        for (final Object o : objects) {
+            if (o instanceof Card) {
+                final Card c = (Card) o;
+                if (hPlay.contains(c)) {
+                    hPlay.remove(c);
+                }
+            }
+        }
+        hPlay = CardLists.getTargetableCards(hPlay, sa);
+        return hPlay;
+    }
+
     /**
      * <p>
      * damageTargetAI.
@@ -366,6 +502,11 @@ public class DamageDealAi extends DamageAiBase {
         // target loop
         TargetChoices tcs = sa.getTargets();
 
+        // Do not use if would kill self
+        if (("SelfDamage".equals(sa.getParam("AILogic"))) && (ai.getLife() <= Integer.parseInt(source.getSVar("SelfDamageAmount")))) {
+            return false;
+        }
+
         if ("ChoiceBurn".equals(sa.getParam("AILogic"))) {
             // do not waste burns on player if other choices are present
             if (this.shouldTgtP(ai, sa, dmg, noPrevention)) {
@@ -425,7 +566,27 @@ public class DamageDealAi extends DamageAiBase {
                 return targetingPlayer.getController().chooseTargetsFor(sa);
             }
 
+            if (tgt.canTgtPlaneswalker()) {
+                // We can damage planeswalkers with this, consider targeting.
+                Card c = this.dealDamageChooseTgtPW(ai, sa, dmg, noPrevention, enemy, false);
+                if (c != null && !this.shouldTgtP(ai, sa, dmg, noPrevention, true)) {
+                    tcs.add(c);
+                    if (divided) {
+                        final int assignedDamage = ComputerUtilCombat.getEnoughDamageToKill(c, dmg, source, false, noPrevention);
+                        if (assignedDamage <= dmg) {
+                            tgt.addDividedAllocation(c, assignedDamage);
+                        }
+                        dmg = dmg - assignedDamage;
+                        if (dmg <= 0) {
+                            break;
+                        }
+                    }
+                    continue;
+                }
+            }
+
             if (tgt.canTgtCreatureAndPlayer()) {
+                Card c = null;
 
                 if (this.shouldTgtP(ai, sa, dmg, noPrevention)) {
                     tcs.add(enemy);
@@ -439,7 +600,8 @@ public class DamageDealAi extends DamageAiBase {
                     dmg = dmg * sa.getTargets().getNumTargeted() / (sa.getTargets().getNumTargeted() +1);
                 }
 
-                final Card c = this.dealDamageChooseTgtC(ai, sa, dmg, noPrevention, enemy, false);
+                // look for creature targets; currently also catches planeswalkers that can be killed immediately
+                c = this.dealDamageChooseTgtC(ai, sa, dmg, noPrevention, enemy, false);
                 if (c != null) {
                     //option to hold removal instead only applies for single targeted removal
                     if (sa.isSpell() && !divided && !immediately && tgt.getMaxTargets(sa.getHostCard(), sa) == 1) {
@@ -486,7 +648,7 @@ public class DamageDealAi extends DamageAiBase {
                     }
                 }
 
-                if (freePing && sa.canTarget(enemy)) {
+                if (freePing && sa.canTarget(enemy) && (!avoidTargetP(ai, sa))) {
                     tcs.add(enemy);
                     if (divided) {
                         tgt.addDividedAllocation(enemy, dmg);
@@ -528,10 +690,11 @@ public class DamageDealAi extends DamageAiBase {
             // TODO: Improve Damage, we shouldn't just target the player just
             // because we can
             else if (sa.canTarget(enemy)) {
-                if ((phase.is(PhaseType.END_OF_TURN) && phase.getNextTurn().equals(ai))
+                if (((phase.is(PhaseType.END_OF_TURN) && phase.getNextTurn().equals(ai))
                         || (SpellAbilityAi.isSorcerySpeed(sa) && phase.is(PhaseType.MAIN2))
                         || sa.getPayCosts() == null || immediately
-                        || this.shouldTgtP(ai, sa, dmg, noPrevention)) {
+                        || this.shouldTgtP(ai, sa, dmg, noPrevention)) &&
+                        (!avoidTargetP(ai, sa))) {
                 	tcs.add(enemy);
                     if (divided) {
                         tgt.addDividedAllocation(enemy, dmg);
@@ -634,10 +797,21 @@ public class DamageDealAi extends DamageAiBase {
         final boolean noPrevention = sa.hasParam("NoPrevention");
         final boolean divided = sa.hasParam("DividedAsYouChoose");
         final Player opp = ComputerUtil.getOpponentFor(ai);
-        System.out.println("damageChooseRequiredTargets " + ai + " " + sa);
 
         while (sa.getTargets().getNumTargeted() < tgt.getMinTargets(sa.getHostCard(), sa)) {
-            // TODO: Consider targeting the planeswalker
+            if (tgt.canTgtPlaneswalker()) {
+                final Card c = this.dealDamageChooseTgtPW(ai, sa, dmg, noPrevention, ai, mandatory);
+                if (c != null) {
+                    sa.getTargets().add(c);
+                    if (divided) {
+                        tgt.addDividedAllocation(c, dmg);
+                        break;
+                    }
+                    continue;
+                }
+            }
+
+            // 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);
                 if (c != null) {

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

@@ -42,7 +42,7 @@ public class DamagePreventAi extends SpellAbilityAi {
             return false;
         }
 
-        if (!ComputerUtilCost.checkSacrificeCost(ai, cost, hostCard)) {
+        if (!ComputerUtilCost.checkSacrificeCost(ai, cost, hostCard, sa)) {
             return false;
         }
 

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

@@ -30,7 +30,7 @@ public class DamagePreventAllAi extends SpellAbilityAi {
             return false;
         }
 
-        if (!ComputerUtilCost.checkSacrificeCost(ai, cost, hostCard)) {
+        if (!ComputerUtilCost.checkSacrificeCost(ai, cost, hostCard, sa)) {
             return false;
         }
 

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

@@ -43,7 +43,7 @@ public class DebuffAi extends SpellAbilityAi {
         final Cost cost = sa.getPayCosts();
 
         // temporarily disabled until AI is improved
-        if (!ComputerUtilCost.checkCreatureSacrificeCost(ai, cost, source)) {
+        if (!ComputerUtilCost.checkCreatureSacrificeCost(ai, cost, source, sa)) {
             return false;
         }
 

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

@@ -18,8 +18,12 @@ public class DelayedTriggerAi extends SpellAbilityAi {
             // TODO: improve ai
             return true;
         }
-        final String svarName = sa.getParam("Execute");
-        final SpellAbility trigsa = AbilityFactory.getAbility(sa.getHostCard().getSVar(svarName), sa.getHostCard());
+        SpellAbility trigsa = null;
+        if (sa.hasAdditionalAbility("Execute")) {
+            trigsa = sa.getAdditionalAbility("Execute");
+        } else {
+            trigsa = AbilityFactory.getAbility(sa.getHostCard(), sa.getParam("Execute"));
+        }
         trigsa.setActivatingPlayer(ai);
 
         if (trigsa instanceof AbilitySub) {
@@ -31,8 +35,12 @@ public class DelayedTriggerAi extends SpellAbilityAi {
 
     @Override
     protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
-        final String svarName = sa.getParam("Execute");
-        final SpellAbility trigsa = AbilityFactory.getAbility(sa.getHostCard().getSVar(svarName), sa.getHostCard());
+        SpellAbility trigsa = null;
+        if (sa.hasAdditionalAbility("Execute")) {
+            trigsa = sa.getAdditionalAbility("Execute");
+        } else {
+            trigsa = AbilityFactory.getAbility(sa.getHostCard(), sa.getParam("Execute"));
+        }
         AiController aic = ((PlayerControllerAi)ai.getController()).getAi();
         trigsa.setActivatingPlayer(ai);
 
@@ -45,8 +53,12 @@ public class DelayedTriggerAi extends SpellAbilityAi {
 
     @Override
     protected boolean canPlayAI(Player ai, SpellAbility sa) {
-        final String svarName = sa.getParam("Execute");
-        final SpellAbility trigsa = AbilityFactory.getAbility(sa.getSVar(svarName), sa.getHostCard());
+        SpellAbility trigsa = null;
+        if (sa.hasAdditionalAbility("Execute")) {
+            trigsa = sa.getAdditionalAbility("Execute");
+        } else {
+            trigsa = AbilityFactory.getAbility(sa.getHostCard(), sa.getParam("Execute"));
+        }
         trigsa.setActivatingPlayer(ai);
         return AiPlayDecision.WillPlay == ((PlayerControllerAi)ai.getController()).getAi().canPlaySa(trigsa);
     }

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

@@ -1,24 +1,10 @@
 package forge.ai.ability;
 
 import com.google.common.base.Predicate;
-import forge.ai.AiController;
-import forge.ai.AiProps;
-
-import forge.ai.ComputerUtil;
-import forge.ai.ComputerUtilCard;
-import forge.ai.ComputerUtilCost;
-import forge.ai.ComputerUtilMana;
-import forge.ai.PlayerControllerAi;
-import forge.ai.SpecialCardAi;
-import forge.ai.SpellAbilityAi;
+import forge.ai.*;
 import forge.game.ability.AbilityUtils;
 import forge.game.ability.ApiType;
-import forge.game.card.Card;
-import forge.game.card.CardCollection;
-import forge.game.card.CardFactoryUtil;
-import forge.game.card.CardLists;
-import forge.game.card.CardPredicates;
-import forge.game.card.CounterType;
+import forge.game.card.*;
 import forge.game.cost.Cost;
 import forge.game.cost.CostPart;
 import forge.game.cost.CostSacrifice;
@@ -49,7 +35,7 @@ public class DestroyAi extends SpellAbilityAi {
         CardCollection list;
 
         if (abCost != null) {
-            if (!ComputerUtilCost.checkSacrificeCost(ai, abCost, source)) {
+            if (!ComputerUtilCost.checkSacrificeCost(ai, abCost, source, sa)) {
                 return false;
             }
 
@@ -64,10 +50,44 @@ public class DestroyAi extends SpellAbilityAi {
             hasXCost = abCost.getCostMana() != null ? abCost.getCostMana().getAmountOfX() > 0 : false;
         }
 
+        if ("AtOpponentsCombatOrAfter".equals(sa.getParam("AILogic"))) {
+            PhaseHandler ph = ai.getGame().getPhaseHandler();
+            if (ph.getPlayerTurn() == ai || ph.getPhase().isBefore(PhaseType.COMBAT_DECLARE_ATTACKERS)) {
+                return false;
+            }
+        } else if ("AtEOT".equals(sa.getParam("AILogic"))) {
+            PhaseHandler ph = ai.getGame().getPhaseHandler();
+            if (!ph.is(PhaseType.END_OF_TURN)) {
+                return false;
+            }
+        } else if ("AtEOTIfNotAttacking".equals(sa.getParam("AILogic"))) {
+            PhaseHandler ph = ai.getGame().getPhaseHandler();
+            if (!ph.is(PhaseType.END_OF_TURN) || ai.getAttackedWithCreatureThisTurn()) {
+                return false;
+            }
+        }
+
         if (ComputerUtil.preventRunAwayActivations(sa)) {
             return false;
         }
 
+        // Ability that's intended to destroy own useless token to trigger Grave Pacts
+        // should be fired at end of turn or when under attack after blocking to make opponent sac something
+        boolean havepact = false;
+
+        // TODO replace it with look for a dies -> sacrifice trigger check
+        havepact |= ai.isCardInPlay("Grave Pact");
+        havepact |= ai.isCardInPlay("Butcher of Malakir");
+        havepact |= ai.isCardInPlay("Dictate of Erebos");
+        if ("Pactivator".equals(logic) && havepact) {
+            if ((!ai.getGame().getPhaseHandler().isPlayerTurn(ai))
+                    && ((ai.getGame().getPhaseHandler().is(PhaseType.END_OF_TURN)) || (ai.getGame().getPhaseHandler().is(PhaseType.COMBAT_DECLARE_BLOCKERS)))
+                    && (ai.getOpponents().getCreaturesInPlay().size() > 0)) {
+                ai.getController().chooseTargetsFor(sa);
+                return true;
+            }
+        }
+
         // Targeting
         if (abTgt != null) {
             sa.resetTargets();
@@ -78,6 +98,11 @@ public class DestroyAi extends SpellAbilityAi {
             }
             if ("MadSarkhanDragon".equals(logic)) {
                 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) {
+                    return false;
+                }
             } else if ("Polymorph".equals(logic)) {
                 list = CardLists.getTargetableCards(ai.getCardsIn(ZoneType.Battlefield), sa);
                 if (list.isEmpty()) {
@@ -104,26 +129,14 @@ public class DestroyAi extends SpellAbilityAi {
                 final int cmcMax = ai.hasRevolt() ? 4 : 2;
                 list = CardLists.filter(list, CardPredicates.lessCMC(cmcMax));
             }
-            if (sa.hasParam("AITgts")) {
-                if (sa.getParam("AITgts").equals("BetterThanSource")) {
-                    if (source.isEnchanted()) {
-                        if (source.getEnchantedBy(false).get(0).getController().equals(ai)) {
-                            return false;
-                        }
-                    } else {
-                        final int value = ComputerUtilCard.evaluateCreature(source);
-                        list = CardLists.filter(list, new Predicate<Card>() {
-                            @Override
-                            public boolean apply(final Card c) {
-                                return ComputerUtilCard.evaluateCreature(c) > value + 30;
-                            }
-                        });
-                    }
-                } else {
-                    list = CardLists.getValidCards(list, sa.getParam("AITgts"), sa.getActivatingPlayer(), source);
-                }
-            }
+
+            // Filter AI-specific targets if provided
+            list = ComputerUtil.filterAITgts(sa, ai, (CardCollection)list, true);
+
             list = CardLists.getNotKeyword(list, "Indestructible");
+            if (CardLists.getNotType(list, "Creature").isEmpty()) {
+                list = ComputerUtilCard.prioritizeCreaturesWorthRemovingNow(ai, list, false);
+            }
             if (!SpellAbilityAi.playReusable(ai, sa)) {
                 list = CardLists.filter(list, new Predicate<Card>() {
                     @Override
@@ -173,6 +186,11 @@ public class DestroyAi extends SpellAbilityAi {
             if (hasXCost) {
                 // TODO: currently the AI will maximize mana spent on X, trying to maximize damage. This may need improvement.
                 maxTargets = Math.min(ComputerUtilMana.determineMaxAffordableX(ai, sa), abTgt.getMaxTargets(sa.getHostCard(), sa));
+                // X can't be more than the lands we have in our hand for "discard X lands"!
+                if ("ScorchedEarth".equals(logic)) {
+                    int lands = CardLists.filter(ai.getCardsIn(ZoneType.Hand), CardPredicates.Presets.LANDS).size();
+                    maxTargets = Math.min(maxTargets, lands);
+                }
             }
             if (sa.hasParam("AIMaxTgtsCount")) {
                 // Cards that have confusing costs for the AI (e.g. Eliminate the Competition) can have forced max target constraints specified
@@ -300,6 +318,9 @@ public class DestroyAi extends SpellAbilityAi {
 
             CardCollection preferred = CardLists.getNotKeyword(list, "Indestructible");
             preferred = CardLists.filterControlledBy(preferred, ai.getOpponents());
+            if (CardLists.getNotType(preferred, "Creature").isEmpty()) {
+                preferred = ComputerUtilCard.prioritizeCreaturesWorthRemovingNow(ai, preferred, false);
+            }
 
             // If NoRegen is not set, filter out creatures that have a
             // regeneration shield
@@ -314,25 +335,8 @@ public class DestroyAi extends SpellAbilityAi {
                 });
             }
 
-            if (sa.hasParam("AITgts")) {
-            	if (sa.getParam("AITgts").equals("BetterThanSource")) {
-            		if (source.isEnchanted()) {
-            			if (source.getEnchantedBy(false).get(0).getController().equals(ai)) {
-            				preferred.clear();
-            			}
-            		} else {
-            			final int value = ComputerUtilCard.evaluateCreature(source);
-            			preferred = CardLists.filter(preferred, new Predicate<Card>() {
-                            @Override
-                            public boolean apply(final Card c) {
-                                return ComputerUtilCard.evaluateCreature(c) > value + 30;
-                            }
-                        });
-            		}
-            	} else {
-            		preferred = CardLists.getValidCards(preferred, sa.getParam("AITgts"), sa.getActivatingPlayer(), source);
-            	}
-            }
+            // Filter AI-specific targets if provided
+            preferred = ComputerUtil.filterAITgts(sa, ai, (CardCollection)preferred, true);
 
             for (final Card c : preferred) {
                 list.remove(c);
@@ -453,4 +457,5 @@ public class DestroyAi extends SpellAbilityAi {
             return tempoCheck;
         }
     }
+
 }

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

@@ -101,6 +101,19 @@ public class DestroyAllAi extends SpellAbilityAi {
             }
         }
 
+        // If effect is destroying creatures and AI is about to lose, activate effect anyway no matter what!
+        if ((!CardLists.getType(opplist, "Creature").isEmpty()) && (ai.getGame().getPhaseHandler().is(PhaseType.COMBAT_DECLARE_BLOCKERS))
+                && (ai.getGame().getCombat() != null && ComputerUtilCombat.lifeInSeriousDanger(ai, ai.getGame().getCombat()))) {
+            return true;
+        }
+
+        // If effect is destroying creatures and AI is about to get low on life, activate effect anyway if difference in lost permanents not very much
+        if ((!CardLists.getType(opplist, "Creature").isEmpty()) && (ai.getGame().getPhaseHandler().is(PhaseType.COMBAT_DECLARE_BLOCKERS))
+                && (ai.getGame().getCombat() != null && ComputerUtilCombat.lifeInDanger(ai, ai.getGame().getCombat()))
+                && ((ComputerUtilCard.evaluatePermanentList(ailist) - 6) >= ComputerUtilCard.evaluatePermanentList(opplist))) {
+            return true;
+        }
+
         // if only creatures are affected evaluate both lists and pass only if
         // human creatures are more valuable
         if (CardLists.getNotType(opplist, "Creature").isEmpty() && CardLists.getNotType(ailist, "Creature").isEmpty()) {

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

@@ -1,11 +1,6 @@
 package forge.ai.ability;
 
-import forge.ai.ComputerUtil;
-import forge.ai.ComputerUtilAbility;
-import forge.ai.ComputerUtilCard;
-import forge.ai.ComputerUtilMana;
-import forge.ai.SpecialCardAi;
-import forge.ai.SpellAbilityAi;
+import forge.ai.*;
 import forge.game.Game;
 import forge.game.ability.AbilityUtils;
 import forge.game.card.Card;
@@ -46,6 +41,8 @@ public class DigAi extends SpellAbilityAi {
 
         if ("Never".equals(sa.getParam("AILogic"))) {
             return false;
+        } else if ("AtOppEndOfTurn".equals(sa.getParam("AILogic"))) {
+            return game.getPhaseHandler().getNextTurn() == ai && game.getPhaseHandler().is(PhaseType.END_OF_TURN);
         }
 
         // don't deck yourself
@@ -127,11 +124,11 @@ public class DigAi extends SpellAbilityAi {
     
     @Override
     public Card chooseSingleCard(Player ai, SpellAbility sa, Iterable<Card> valid, boolean isOptional, Player relatedPlayer) {
-        Card chosen = ComputerUtilCard.getBestAI(valid);
         if (sa.getActivatingPlayer().isOpponentOf(ai) && relatedPlayer.isOpponentOf(ai)) {
-            return ComputerUtilCard.getWorstAI(valid);
+            return ComputerUtilCard.getWorstPermanentAI(valid, false, true, false, false);
+        } else {
+            return ComputerUtilCard.getBestAI(valid);
         }
-        return chosen;
     }
 
     /* (non-Javadoc)

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

@@ -6,6 +6,7 @@ import forge.ai.SpellAbilityAi;
 import forge.game.card.Card;
 import forge.game.card.CardLists;
 import forge.game.card.CardPredicates;
+import forge.game.phase.PhaseType;
 import forge.game.player.Player;
 import forge.game.player.PlayerActionConfirmMode;
 import forge.game.spellability.AbilitySub;
@@ -14,24 +15,50 @@ import forge.game.zone.ZoneType;
 import forge.util.MyRandom;
 
 import java.util.List;
-import java.util.Random;
 
 public class DigUntilAi extends SpellAbilityAi {
 
     @Override
     protected boolean canPlayAI(Player ai, SpellAbility sa) {
         Card source = sa.getHostCard();
+        final String logic = sa.getParamOrDefault("AILogic", "");
         double chance = .4; // 40 percent chance with instant speed stuff
         if (SpellAbilityAi.isSorcerySpeed(sa)) {
             chance = .667; // 66.7% chance for sorcery speed (since it will
                            // never activate EOT)
         }
-        final Random r = MyRandom.getRandom();
-        final boolean randomReturn = r.nextFloat() <= Math.pow(chance, sa.getActivationsThisTurn() + 1);
+        // if we don't use anything now, we wasted our opportunity.
+        if ((ai.getGame().getPhaseHandler().is(PhaseType.END_OF_TURN))
+                && (!ai.getGame().getPhaseHandler().isPlayerTurn(ai))) {
+            chance = 1;
+        }
+
+        final boolean randomReturn = MyRandom.getRandom().nextFloat() <= Math.pow(chance, sa.getActivationsThisTurn() + 1);
 
         Player libraryOwner = ai;
         Player opp = ComputerUtil.getOpponentFor(ai);
 
+        if ("DontMillSelf".equals(logic)) {
+            // A card that digs for specific things and puts everything revealed before it into graveyard
+            // (e.g. Hermit Druid) - don't use it to mill itself and also make sure there's enough playable
+            // material in the library after using it several times.
+            // TODO: maybe this should happen for any DigUntil SA with RevealedDestination$ Graveyard?
+            if (ai.getCardsIn(ZoneType.Library).size() < 20) {
+                return false;
+            }
+            if ("Land.Basic".equals(sa.getParam("Valid"))
+                    && !CardLists.filter(ai.getCardsIn(ZoneType.Hand), CardPredicates.Presets.LANDS_PRODUCING_MANA).isEmpty()) {
+                // We already have a mana-producing land in hand, so bail
+                // until opponent's end of turn phase!
+                // But we still want more (and want to fill grave) if nothing better to do then
+                // This is important for Replenish/Living Death type decks
+                if (!((ai.getGame().getPhaseHandler().is(PhaseType.END_OF_TURN))
+                        && (!ai.getGame().getPhaseHandler().isPlayerTurn(ai)))) {
+                    return false;
+                }
+            }
+        }
+
         if (sa.usesTargeting()) {
             sa.resetTargets();
             if (!sa.canTarget(opp)) {

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

@@ -1,12 +1,11 @@
 package forge.ai.ability;
 
-import forge.ai.ComputerUtil;
-import forge.ai.ComputerUtilAbility;
-import forge.ai.ComputerUtilCost;
-import forge.ai.ComputerUtilMana;
-import forge.ai.SpellAbilityAi;
+import forge.ai.*;
 import forge.game.ability.AbilityUtils;
 import forge.game.card.Card;
+import forge.game.card.CardCollectionView;
+import forge.game.card.CardLists;
+import forge.game.card.CardPredicates;
 import forge.game.cost.Cost;
 import forge.game.phase.PhaseType;
 import forge.game.player.Player;
@@ -17,7 +16,6 @@ import forge.game.zone.ZoneType;
 import forge.util.MyRandom;
 
 import java.util.List;
-import java.util.Random;
 
 public class DiscardAi extends SpellAbilityAi {
 
@@ -27,10 +25,11 @@ public class DiscardAi extends SpellAbilityAi {
         final Card source = sa.getHostCard();
         final String sourceName = ComputerUtilAbility.getAbilitySourceName(sa);
         final Cost abCost = sa.getPayCosts();
+        final String aiLogic = sa.getParamOrDefault("AILogic", "");
 
         if (abCost != null) {
             // AI currently disabled for these costs
-            if (!ComputerUtilCost.checkSacrificeCost(ai, abCost, source)) {
+            if (!ComputerUtilCost.checkSacrificeCost(ai, abCost, source, sa)) {
                 return false;
             }
 
@@ -53,6 +52,10 @@ public class DiscardAi extends SpellAbilityAi {
             return MyRandom.getRandom().nextFloat() < (1.0 / (1 + hand));
         }
 
+        if (aiLogic.equals("VolrathsShapeshifter")) {
+            return SpecialCardAi.VolrathsShapeshifter.consider(ai, sa);
+        }
+
         final boolean humanHasHand = ComputerUtil.getOpponentFor(ai).getCardsIn(ZoneType.Hand).size() > 0;
 
         if (tgt != null) {
@@ -97,7 +100,35 @@ public class DiscardAi extends SpellAbilityAi {
             }
         }
 
-        // TODO: Implement support for Discard AI for cards with AnyNumber set to true.
+        // TODO: Improve support for Discard AI for cards with AnyNumber set to true.
+        if (sa.hasParam("AnyNumber")) {
+            if ("DiscardUncastableAndExcess".equals(aiLogic)) {
+                final CardCollectionView inHand = ai.getCardsIn(ZoneType.Hand);
+                final int numLandsOTB = CardLists.filter(ai.getCardsIn(ZoneType.Hand), CardPredicates.Presets.LANDS).size();
+                int numDiscard = 0;
+                int numOppInHand = 0;
+                for (Player p : ai.getGame().getPlayers()) {
+                    if (p.getCardsIn(ZoneType.Hand).size() > numOppInHand) {
+                        numOppInHand = p.getCardsIn(ZoneType.Hand).size();
+                    }
+                }
+                for (Card c : inHand) {
+                    if (c.equals(sa.getHostCard())) { continue; }
+                    if (c.hasSVar("DoNotDiscardIfAble") || c.hasSVar("IsReanimatorCard")) { continue; }
+                    if (c.isCreature() && !ComputerUtilMana.hasEnoughManaSourcesToCast(c.getSpellPermanent(), ai)) {
+                        numDiscard++;
+                    }
+                    if ((c.isLand() && numLandsOTB >= 5) || (c.getFirstSpellAbility() != null && !ComputerUtilMana.hasEnoughManaSourcesToCast(c.getFirstSpellAbility(), ai))) {
+                        if (numDiscard + 1 <= numOppInHand) {
+                            numDiscard++;
+                        }
+                    }
+                }
+                if (numDiscard == 0) {
+                    return false;
+                }
+            }
+        }
 
         // Don't use draw abilities before main 2 if possible
         if (ai.getGame().getPhaseHandler().getPhase().isBefore(PhaseType.MAIN2)
@@ -110,8 +141,7 @@ public class DiscardAi extends SpellAbilityAi {
             return false;
         }
 
-        final Random r = MyRandom.getRandom();
-        boolean randomReturn = r.nextFloat() <= Math.pow(0.9, sa.getActivationsThisTurn());
+        boolean randomReturn = MyRandom.getRandom().nextFloat() <= Math.pow(0.9, sa.getActivationsThisTurn());
 
         // some other variables here, like handsize vs. maxHandSize
 

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

@@ -10,7 +10,6 @@ import forge.game.spellability.TargetRestrictions;
 import forge.util.MyRandom;
 
 import java.util.List;
-import java.util.Random;
 
 public class DrainManaAi extends SpellAbilityAi {
 
@@ -21,8 +20,7 @@ public class DrainManaAi extends SpellAbilityAi {
         final TargetRestrictions tgt = sa.getTargetRestrictions();
         final Card source = sa.getHostCard();
         final Player opp = ComputerUtil.getOpponentFor(ai);
-        final Random r = MyRandom.getRandom();
-        boolean randomReturn = r.nextFloat() <= Math.pow(.6667, sa.getActivationsThisTurn());
+        boolean randomReturn = MyRandom.getRandom().nextFloat() <= Math.pow(.6667, sa.getActivationsThisTurn());
 
         if (tgt == null) {
             // assume we are looking to tap human's stuff

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

@@ -86,7 +86,7 @@ public class DrawAi extends SpellAbilityAi {
      */
     @Override
     protected boolean willPayCosts(Player ai, SpellAbility sa, Cost cost, Card source) {
-        if (!ComputerUtilCost.checkCreatureSacrificeCost(ai, cost, source)) {
+        if (!ComputerUtilCost.checkCreatureSacrificeCost(ai, cost, source, sa)) {
             return false;
         }
 
@@ -126,6 +126,16 @@ public class DrawAi extends SpellAbilityAi {
      */
     @Override
     protected boolean checkPhaseRestrictions(Player ai, SpellAbility sa, PhaseHandler ph) {
+        String logic = sa.getParamOrDefault("AILogic", "");
+
+        if (logic.startsWith("LifeLessThan.")) {
+            // LifeLessThan logic presupposes activation as soon as possible in an
+            // attempt to save the AI from dying
+            return true;
+        } else if (logic.equals("AlwaysAtOppEOT")) {
+            return ph.is(PhaseType.END_OF_TURN) && ph.getNextTurn().equals(ai);
+        }
+
         // Don't use draw abilities before main 2 if possible
         if (ph.getPhase().isBefore(PhaseType.MAIN2) && !sa.hasParam("ActivationPhases")
                 && !ComputerUtil.castSpellInMain1(ai, sa)) {
@@ -170,7 +180,7 @@ public class DrawAi extends SpellAbilityAi {
 
             int numHand = ai.getCardsIn(ZoneType.Hand).size();
             if ("Jace, Vryn's Prodigy".equals(sourceName) && ai.getCardsIn(ZoneType.Graveyard).size() > 3) {
-                return CardLists.filter(ai.getCardsIn(ZoneType.Battlefield), CardPredicates.Presets.PLANEWALKERS,
+                return CardLists.filter(ai.getCardsIn(ZoneType.Battlefield), CardPredicates.Presets.PLANESWALKERS,
                         CardPredicates.isType("Jace")).size() <= 0;
             }
             if (source.isSpell() && ai.getCardsIn(ZoneType.Hand).contains(source)) {
@@ -204,6 +214,7 @@ public class DrawAi extends SpellAbilityAi {
         final Card source = sa.getHostCard();
         final boolean drawback = sa.getParent() != null;
         final Game game = ai.getGame();
+        final String logic = sa.getParamOrDefault("AILogic", "");
 
         int computerHandSize = ai.getCardsIn(ZoneType.Hand).size();
         final int computerLibrarySize = ai.getCardsIn(ZoneType.Library).size();
@@ -240,12 +251,24 @@ public class DrawAi extends SpellAbilityAi {
             }
         }
 
-        // Logic for cards that require special handling
-        if (sa.hasParam("AILogic")) {
-            if ("YawgmothsBargain".equals(sa.getParam("AILogic"))) {
-                return SpecialCardAi.YawgmothsBargain.consider(ai, sa);
+        if (num != null && num.equals("ChosenX")) {
+            // Necrologia, Pay X Life : Draw X Cards
+            if (sa.getSVar("X").equals("XChoice")) {
+                // Draw up to max hand size but leave at least 3 in library
+                numCards = Math.min(computerMaxHandSize - computerHandSize, computerLibrarySize - 3);
+                // But no more than what's "safe" and doesn't risk a near death experience
+                // Maybe would be better to check for "serious danger" and take more risk?
+                while ((ComputerUtil.aiLifeInDanger(ai, false, numCards) && (numCards > 0))) {
+                    numCards--;
+                }
+                sa.setSVar("ChosenX", Integer.toString(numCards));
+                source.setSVar("ChosenX", Integer.toString(numCards));
             }
         }
+        // Logic for cards that require special handling
+        if ("YawgmothsBargain".equals(logic)) {
+            return SpecialCardAi.YawgmothsBargain.consider(ai, sa);
+        }
 
         // Generic logic for all cards that do not need any special handling
 
@@ -312,6 +335,13 @@ public class DrawAi extends SpellAbilityAi {
                         return true;
                     }
                 }
+                // we're trying to save ourselves from death
+                // (e.g. Bargain), so target the opp anyway
+                if (logic.startsWith("LifeLessThan.")) {
+                    int threshold = Integer.parseInt(logic.substring(logic.indexOf(".") + 1));
+                    sa.getTargets().add(oppA);
+                    return ai.getLife() < threshold;
+                }
             }
             
             boolean aiTarget = sa.canTarget(ai);

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

@@ -1,9 +1,9 @@
 package forge.ai.ability;
 
 import java.util.List;
-import java.util.Random;
 
 import com.google.common.base.Predicate;
+import com.google.common.base.Predicates;
 import com.google.common.collect.Iterables;
 
 import forge.ai.ComputerUtil;
@@ -15,9 +15,7 @@ import forge.ai.SpellApiToAi;
 import forge.game.Game;
 import forge.game.GlobalRuleChange;
 import forge.game.ability.ApiType;
-import forge.game.card.Card;
-import forge.game.card.CardCollection;
-import forge.game.card.CardLists;
+import forge.game.card.*;
 import forge.game.combat.CombatUtil;
 import forge.game.phase.PhaseHandler;
 import forge.game.phase.PhaseType;
@@ -32,8 +30,7 @@ public class EffectAi extends SpellAbilityAi {
     @Override
     protected boolean canPlayAI(final Player ai,final SpellAbility sa) {
         final Game game = ai.getGame();
-        final Random r = MyRandom.getRandom();
-        boolean randomReturn = r.nextFloat() <= .6667;
+        boolean randomReturn = MyRandom.getRandom().nextFloat() <= .6667;
         String logic = "";
 
         if (sa.hasParam("AILogic")) {
@@ -49,6 +46,21 @@ public class EffectAi extends SpellAbilityAi {
                     return false;
                 }
                 randomReturn = true;
+            } else if (logic.equals("KeepOppCreatsLandsTapped")) {
+                for (Player opp : ai.getOpponents()) {
+                    boolean worthHolding = false;
+                    CardCollectionView oppCreatsLands = CardLists.filter(opp.getCardsIn(ZoneType.Battlefield),
+                        Predicates.or(CardPredicates.Presets.LANDS, CardPredicates.Presets.CREATURES));
+                    CardCollectionView oppCreatsLandsTapped = CardLists.filter(oppCreatsLands, CardPredicates.Presets.TAPPED);
+
+                    if (oppCreatsLandsTapped.size() >= 3 || oppCreatsLands.size() == oppCreatsLandsTapped.size()) {
+                        worthHolding = true;
+                    }
+                    if (!worthHolding) {
+                        return false;
+                    }
+                    randomReturn = true;
+                }
             } else if (logic.equals("Fog")) {
                 if (game.getPhaseHandler().isPlayerTurn(sa.getActivatingPlayer())) {
                     return false;
@@ -286,4 +298,35 @@ public class EffectAi extends SpellAbilityAi {
 
         return randomReturn;
     }
+
+    @Override
+    protected boolean doTriggerAINoCost(final Player aiPlayer, final SpellAbility sa, final boolean mandatory) {
+        String aiLogic = sa.getParamOrDefault("AILogic", "");
+
+        // E.g. Nova Pentacle
+        if (aiLogic.equals("RedirectFromOppToCreature")) {
+            // try to target the opponent's best targetable permanent, if able
+            CardCollection oppPerms = CardLists.getValidCards(aiPlayer.getOpponents().getCardsIn(ZoneType.Battlefield), sa.getTargetRestrictions().getValidTgts(), aiPlayer, sa.getHostCard(), sa);
+            if (!oppPerms.isEmpty()) {
+                sa.resetTargets();
+                sa.getTargets().add(ComputerUtilCard.getBestAI(oppPerms));
+                return true;
+            }
+
+            if (mandatory) {
+                // try to target the AI's worst targetable permanent, if able
+                CardCollection aiPerms = CardLists.getValidCards(aiPlayer.getCardsIn(ZoneType.Battlefield), sa.getTargetRestrictions().getValidTgts(), aiPlayer, sa.getHostCard(), sa);
+                if (!aiPerms.isEmpty()) {
+                    sa.resetTargets();
+                    sa.getTargets().add(ComputerUtilCard.getWorstAI(aiPerms));
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        return super.doTriggerAINoCost(aiPlayer, sa, mandatory);
+
+    }
 }

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

@@ -0,0 +1,63 @@
+package forge.ai.ability;
+
+
+import forge.ai.*;
+import forge.game.card.*;
+import forge.game.player.Player;
+import forge.game.spellability.SpellAbility;
+import forge.game.zone.ZoneType;
+
+public class ExploreAi 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) {
+        // Explore with a target (e.g. Enter the Unknown)
+        if (sa.usesTargeting()) {
+            Card bestCreature = ComputerUtilCard.getBestCreatureAI(aiPlayer.getCardsIn(ZoneType.Battlefield));
+            if (bestCreature == null) {
+                return false;
+            }
+
+            sa.resetTargets();
+            sa.getTargets().add(bestCreature);
+        }
+
+        return true;
+    }
+
+    public static Card shouldPutInGraveyard(CardCollection top, Player ai) {
+        int predictedMana = ComputerUtilMana.getAvailableManaSources(ai, false).size();
+        CardCollectionView cardsOTB = ai.getCardsIn(ZoneType.Battlefield);
+        CardCollectionView cardsInHand = ai.getCardsIn(ZoneType.Hand);
+        CardCollection landsOTB = CardLists.filter(cardsOTB, CardPredicates.Presets.LANDS_PRODUCING_MANA);
+        CardCollection landsInHand = CardLists.filter(cardsInHand, CardPredicates.Presets.LANDS_PRODUCING_MANA);
+
+        int maxCMCDiff = 1;
+        int numLandsToStillNeedMore = 2;
+
+        if (ai.getController().isAI()) {
+            AiController aic = ((PlayerControllerAi)ai.getController()).getAi();
+            maxCMCDiff = aic.getIntProperty(AiProps.EXPLORE_MAX_CMC_DIFF_TO_PUT_IN_GRAVEYARD);
+            numLandsToStillNeedMore = aic.getIntProperty(AiProps.EXPLORE_NUM_LANDS_TO_STILL_NEED_MORE);
+        }
+
+        if (!top.isEmpty()) {
+            Card topCard = top.getFirst();
+            if (landsInHand.isEmpty() && landsOTB.size() <= numLandsToStillNeedMore) {
+                // We need more lands to improve our mana base, explore away the non-lands
+                return topCard;
+            }
+            if (topCard.getCMC() - maxCMCDiff >= predictedMana && !topCard.hasSVar("DoNotDiscardIfAble")) {
+                // We're not casting this in foreseeable future, put it in the graveyard
+                return topCard;
+            }
+        }
+
+        // Put on top of the library (do not mark the card for placement in the graveyard)
+        return null;
+    }
+
+}
+

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

@@ -1,14 +1,6 @@
 package forge.ai.ability;
 
-import java.util.List;
-import java.util.Map;
-import java.util.Random;
-
-import forge.ai.ComputerUtil;
-import forge.ai.ComputerUtilAbility;
-import forge.ai.ComputerUtilCard;
-import forge.ai.ComputerUtilCombat;
-import forge.ai.SpellAbilityAi;
+import forge.ai.*;
 import forge.game.ability.AbilityFactory;
 import forge.game.ability.AbilityUtils;
 import forge.game.card.Card;
@@ -22,6 +14,9 @@ import forge.game.trigger.Trigger;
 import forge.game.trigger.TriggerType;
 import forge.util.MyRandom;
 
+import java.util.List;
+import java.util.Map;
+
 public class FightAi extends SpellAbilityAi {
     @Override
     protected boolean checkAiLogic(final Player ai, final SpellAbility sa, final String aiLogic) {
@@ -59,6 +54,7 @@ public class FightAi extends SpellAbilityAi {
                     return true;
                 }
             }
+            return false; // bail at this point, otherwise the AI will overtarget and waste the activation
         }
 
         if (sa.hasParam("TargetsFromDifferentZone")) {
@@ -103,6 +99,11 @@ public class FightAi extends SpellAbilityAi {
         return false;
     }
 
+    @Override
+    public boolean chkAIDrawback(final SpellAbility sa, final Player aiPlayer) {
+        return checkApiLogic(aiPlayer, sa);
+    }
+
     @Override
     protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
         if (canPlayAI(ai, sa)) {
@@ -238,8 +239,7 @@ public class FightAi extends SpellAbilityAi {
     		if (!canKill(opponent, fighter, -pumpDefense)) {	// can survive
     			return true;
     		} else {
-    			final Random r = MyRandom.getRandom();
-    			if (r.nextInt(20)<(opponent.getCMC() - fighter.getCMC())) {	// trade
+    			if (MyRandom.getRandom().nextInt(20)<(opponent.getCMC() - fighter.getCMC())) {	// trade
     				return true;
     			}
     		}

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

@@ -5,9 +5,12 @@ import forge.ai.ComputerUtil;
 import forge.ai.ComputerUtilCombat;
 import forge.ai.SpellAbilityAi;
 import forge.game.Game;
+import forge.game.card.Card;
+import forge.game.card.CardPredicates;
 import forge.game.phase.PhaseType;
 import forge.game.player.Player;
 import forge.game.spellability.SpellAbility;
+import forge.util.Aggregates;
 
 public class FogAi extends SpellAbilityAi {
 
@@ -35,6 +38,25 @@ public class FogAi extends SpellAbilityAi {
             return false;
         }
 
+        if ("SeriousDamage".equals(sa.getParam("AILogic")) && game.getCombat() != null) {
+            int dmg = 0;
+            for (Card atk : game.getCombat().getAttackersOf(ai)) {
+                if (game.getCombat().isUnblocked(atk)) {
+                    dmg += atk.getNetCombatDamage();
+                } else if (atk.hasKeyword("Trample")) {
+                    dmg += atk.getNetCombatDamage() - Aggregates.sum(game.getCombat().getBlockers(atk), CardPredicates.Accessors.fnGetNetToughness);
+                }
+            }
+
+            if (dmg > ai.getLife() / 4) {
+                return true;
+            } else if (dmg >= 5) {
+                return true;
+            } else if (ai.getLife() < ai.getStartingLife() / 3) {
+                return true;
+            }
+        }
+
         // Cast it if life is in danger
         return ComputerUtilCombat.lifeInDanger(ai, game.getCombat());
     }

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

@@ -7,8 +7,6 @@ import forge.game.spellability.SpellAbility;
 import forge.game.spellability.TargetRestrictions;
 import forge.util.MyRandom;
 
-import java.util.Random;
-
 public class LifeExchangeAi extends SpellAbilityAi {
 
     /*
@@ -21,7 +19,6 @@ public class LifeExchangeAi extends SpellAbilityAi {
      */
     @Override
     protected boolean canPlayAI(Player aiPlayer, SpellAbility sa) {
-        final Random r = MyRandom.getRandom();
         final int myLife = aiPlayer.getLife();
         Player opponent = ComputerUtil.getOpponentFor(aiPlayer);
         final int hLife = opponent.getLife();
@@ -31,7 +28,7 @@ public class LifeExchangeAi extends SpellAbilityAi {
         }
 
         // prevent run-away activations - first time will always return true
-        boolean chance = r.nextFloat() <= Math.pow(.6667, sa.getActivationsThisTurn());
+        boolean chance = MyRandom.getRandom().nextFloat() <= Math.pow(.6667, sa.getActivationsThisTurn());
 
         /*
          * TODO - There is one card that takes two targets (Soul Conduit)
@@ -58,7 +55,7 @@ public class LifeExchangeAi extends SpellAbilityAi {
         // cost includes sacrifice probably, so make sure it's worth it
         chance &= (hLife > (myLife + 8));
 
-        return ((r.nextFloat() < .6667) && chance);
+        return ((MyRandom.getRandom().nextFloat() < .6667) && chance);
     }
 
     /**

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

@@ -0,0 +1,122 @@
+package forge.ai.ability;
+
+import forge.ai.ComputerUtil;
+import forge.ai.ComputerUtilAbility;
+import forge.ai.ComputerUtilCombat;
+import forge.ai.SpellAbilityAi;
+import forge.game.Game;
+import forge.game.card.Card;
+import forge.game.player.Player;
+import forge.game.spellability.SpellAbility;
+import forge.game.spellability.TargetRestrictions;
+
+public class LifeExchangeVariantAi extends SpellAbilityAi {
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * forge.card.abilityfactory.AbilityFactoryAlterLife.SpellAiLogic#canPlayAI
+     * (forge.game.player.Player, java.util.Map,
+     * forge.card.spellability.SpellAbility)
+     */
+    @Override
+    protected boolean canPlayAI(Player ai, SpellAbility sa) {
+        final Card source = sa.getHostCard();
+        final String sourceName = ComputerUtilAbility.getAbilitySourceName(sa);
+        final Game game = ai.getGame();
+
+        if ("Tree of Redemption".equals(sourceName)) {
+            if (!ai.canGainLife())
+                return false;
+
+            // someone controls "Rain of Gore" or "Sulfuric Vortex", lifegain is bad in that case
+            if (game.isCardInPlay("Rain of Gore") || game.isCardInPlay("Sulfuric Vortex"))
+                return false;
+
+            // an opponent controls "Tainted Remedy", lifegain is bad in that case
+            for (Player op : ai.getOpponents()) {
+                if (op.isCardInPlay("Tainted Remedy"))
+                    return false;
+            }
+
+            if (ComputerUtil.waitForBlocking(sa) || ai.getLife() + 1 >= source.getNetToughness()
+                || (ai.getLife() > 5 && !ComputerUtilCombat.lifeInSeriousDanger(ai, ai.getGame().getCombat()))) {
+                return false;
+            }
+        }
+        else if ("Tree of Perdition".equals(sourceName)) {
+            boolean shouldDo = false;
+
+            if (ComputerUtil.waitForBlocking(sa))
+                return false;
+
+            for (Player op : ai.getOpponents()) {
+                // if oppoent can't be targeted, or it can't lose life, try another one
+                if (!op.canBeTargetedBy(sa) || !op.canLoseLife())
+                    continue;
+                // an opponent has more live than this toughness
+                if (op.getLife() + 1 >= source.getNetToughness()) {
+                    shouldDo = true;
+                } else {
+                    // opponent can't gain life, so "Tainted Remedy" should not work.
+                    if (!op.canGainLife()) {
+                        continue;
+                    } else if (ai.isCardInPlay("Tainted Remedy")) { // or AI has Tainted Remedy 
+                        shouldDo = true;
+                    } else {
+                        for (Player ally : ai.getAllies()) {
+                            // if an Ally has Tainted Remedy and opponent is also opponent of ally
+                            if (ally.isCardInPlay("Tainted Remedy") && op.isOpponentOf(ally))
+                                shouldDo = true;
+                        }
+                    }
+
+                }
+
+                if (shouldDo) {
+                    sa.getTargets().add(op);
+                    break;
+                }
+            }
+
+            return shouldDo;
+        }
+        else if ("Evra, Halcyon Witness".equals(sourceName)) {
+            // TODO add logic
+        }
+        return false;
+
+    }
+
+    /**
+     * <p>
+     * exchangeLifeDoTriggerAINoCost.
+     * </p>
+     * @param sa
+     *            a {@link forge.game.spellability.SpellAbility} object.
+     * @param mandatory
+     *            a boolean.
+     * @param af
+     *            a {@link forge.game.ability.AbilityFactory} object.
+     *
+     * @return a boolean.
+     */
+    @Override
+    protected boolean doTriggerAINoCost(final Player ai, final SpellAbility sa,
+    final boolean mandatory) {
+
+        final TargetRestrictions tgt = sa.getTargetRestrictions();
+        Player opp = ComputerUtil.getOpponentFor(ai);
+        if (tgt != null) {
+            sa.resetTargets();
+            if (sa.canTarget(opp) && (mandatory || ai.getLife() < opp.getLife())) {
+                sa.getTargets().add(opp);
+            } else {
+                return false;
+            }
+        }
+        return true;
+    }
+
+}

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

@@ -1,10 +1,13 @@
 package forge.ai.ability;
 
+import com.google.common.collect.Iterables;
 import forge.ai.*;
 import forge.game.Game;
 import forge.game.ability.AbilityUtils;
 import forge.game.card.Card;
 import forge.game.cost.Cost;
+import forge.game.cost.CostRemoveCounter;
+import forge.game.cost.CostSacrifice;
 import forge.game.phase.PhaseHandler;
 import forge.game.phase.PhaseType;
 import forge.game.player.Player;
@@ -35,7 +38,7 @@ public class LifeGainAi extends SpellAbilityAi {
 
         if (!lifeCritical) {
             // return super.willPayCosts(ai, sa, cost, source);
-            if (!ComputerUtilCost.checkSacrificeCost(ai, cost, source, false)) {
+            if (!ComputerUtilCost.checkSacrificeCost(ai, cost, source, sa,false)) {
                 return false;
             }
             if (!ComputerUtilCost.checkLifeCost(ai, cost, source, 4, sa)) {
@@ -60,7 +63,7 @@ public class LifeGainAi extends SpellAbilityAi {
                 skipCheck |= ComputerUtilCost.isSacrificeSelfCost(cost) && !source.isCreature();
 
                 if (!skipCheck) {
-                    if (!ComputerUtilCost.checkSacrificeCost(ai, cost, source, false)) {
+                    if (!ComputerUtilCost.checkSacrificeCost(ai, cost, source, sa,false)) {
                         return false;
                     }
                 }
@@ -80,6 +83,23 @@ public class LifeGainAi extends SpellAbilityAi {
         lifeCritical |= ph.getPhase().isBefore(PhaseType.COMBAT_DAMAGE)
                 && ComputerUtilCombat.lifeInDanger(ai, game.getCombat());
 
+        // When life is critical but there is no immediate danger, try to wait until declare blockers
+        // before using the lifegain ability if it's an ability on a creature with a detrimental activation cost
+        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();
+                if (saTop.getTargets() != null && Iterables.contains(saTop.getTargets().getTargetPlayers(), ai)) {
+                    return ComputerUtil.predictDamageFromSpell(saTop, ai) > 0;
+                }
+            }
+            if (game.getCombat() == null) { return false; }
+            if (!ph.is(PhaseType.COMBAT_DECLARE_BLOCKERS)) { return false; }
+        }
+
         // Don't use lifegain before main 2 if possible
         if (!lifeCritical && ph.getPhase().isBefore(PhaseType.MAIN2) && !sa.hasParam("ActivationPhases")
                 && !ComputerUtil.castSpellInMain1(ai, sa)) {

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

@@ -13,13 +13,10 @@ import forge.game.spellability.SpellAbility;
 import forge.game.spellability.TargetRestrictions;
 import forge.util.MyRandom;
 
-import java.util.Random;
-
 public class LifeSetAi extends SpellAbilityAi {
 
     @Override
     protected boolean canPlayAI(Player ai, SpellAbility sa) {
-        final Random r = MyRandom.getRandom();
         // Ability_Cost abCost = sa.getPayCosts();
         final Card source = sa.getHostCard();
         final int myLife = ai.getLife();
@@ -56,7 +53,7 @@ public class LifeSetAi extends SpellAbilityAi {
         }
 
         // prevent run-away activations - first time will always return true
-        final boolean chance = r.nextFloat() <= Math.pow(.6667, sa.getActivationsThisTurn());
+        final boolean chance = MyRandom.getRandom().nextFloat() <= Math.pow(.6667, sa.getActivationsThisTurn());
 
         final TargetRestrictions tgt = sa.getTargetRestrictions();
         if (tgt != null) {
@@ -94,7 +91,7 @@ public class LifeSetAi extends SpellAbilityAi {
                     }
                 }
             }
-            if (amount < myLife) {
+            if (amount <= myLife) {
                 return false;
             }
         }
@@ -104,7 +101,7 @@ public class LifeSetAi extends SpellAbilityAi {
             return true;
         }
 
-        return ((r.nextFloat() < .6667) && chance);
+        return ((MyRandom.getRandom().nextFloat() < .6667) && chance);
     }
 
     @Override
@@ -127,6 +124,12 @@ public class LifeSetAi extends SpellAbilityAi {
             amount = AbilityUtils.calculateAmount(sa.getHostCard(), amountStr, sa);
         }
 
+        // special cases when amount can't be calculated without targeting first
+        if (amount == 0 && "TargetedPlayer$StartingLife/HalfDown".equals(source.getSVar(amountStr))) {
+            // e.g. Torgaar, Famine Incarnate
+            return doHalfStartingLifeLogic(ai, opponent, sa);
+        }
+
         if (sourceName.equals("Eternity Vessel")
                 && (opponent.isCardInPlay("Vampire Hexmage") || (source.getCounters(CounterType.CHARGE) == 0))) {
             return false;
@@ -134,8 +137,7 @@ public class LifeSetAi extends SpellAbilityAi {
 
         // If the Target is gaining life, target self.
         // if the Target is modifying how much life is gained, this needs to
-        // be
-        // handled better
+        // be handled better
         final TargetRestrictions tgt = sa.getTargetRestrictions();
         if (tgt != null) {
             sa.resetTargets();
@@ -157,4 +159,36 @@ public class LifeSetAi extends SpellAbilityAi {
         return true;
     }
 
+    private boolean doHalfStartingLifeLogic(Player ai, Player opponent, SpellAbility sa) {
+        int aiAmount = ai.getStartingLife() / 2;
+        int oppAmount = opponent.getStartingLife() / 2;
+        int aiLife = ai.getLife();
+        int oppLife = opponent.getLife();
+
+        sa.resetTargets();
+
+        final TargetRestrictions tgt = sa.getTargetRestrictions();
+        if (tgt != null) {
+            if (tgt.canOnlyTgtOpponent()) {
+                if (oppLife > oppAmount) {
+                    sa.getTargets().add(opponent);
+                } else {
+                    return false;
+                }
+            } else {
+                if (aiAmount > ai.getLife() && aiLife < 5) {
+                    sa.getTargets().add(ai);
+                } else if (oppLife > oppAmount) {
+                    sa.getTargets().add(opponent);
+                } else if (aiAmount > aiLife) {
+                    sa.getTargets().add(ai);
+                } else {
+                    return false;
+                }
+            }
+        }
+
+        return true;
+    }
+
 }

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

@@ -1,26 +1,20 @@
 package forge.ai.ability;
 
 import com.google.common.base.Predicates;
-import forge.ai.AiPlayDecision;
-import forge.ai.ComputerUtil;
-import forge.ai.ComputerUtilAbility;
-import forge.ai.ComputerUtilCost;
-import forge.ai.ComputerUtilMana;
-import forge.ai.PlayerControllerAi;
-import forge.ai.SpellAbilityAi;
+import forge.ai.*;
 import forge.card.ColorSet;
 import forge.card.MagicColor;
 import forge.card.mana.ManaCost;
 import forge.game.ability.AbilityUtils;
-import forge.game.card.Card;
-import forge.game.card.CardCollection;
-import forge.game.card.CardLists;
-import forge.game.card.CardPredicates;
+import forge.game.card.*;
+import forge.game.cost.CostPart;
+import forge.game.cost.CostRemoveCounter;
 import forge.game.phase.PhaseHandler;
 import forge.game.phase.PhaseType;
 import forge.game.player.Player;
 import forge.game.spellability.SpellAbility;
 import forge.game.zone.ZoneType;
+
 import java.util.Arrays;
 import java.util.List;
 
@@ -110,13 +104,28 @@ public class ManaEffectAi extends SpellAbilityAi {
     private boolean doManaRitualLogic(Player ai, SpellAbility sa) {
         final Card host = sa.getHostCard();
           
-        CardCollection manaSources = ComputerUtilMana.getAvailableMana(ai, true);
+        CardCollection manaSources = ComputerUtilMana.getAvailableManaSources(ai, true);
         int numManaSrcs = manaSources.size();
         int manaReceived = sa.hasParam("Amount") ? AbilityUtils.calculateAmount(host, sa.getParam("Amount"), sa) : 1;
         manaReceived *= sa.getParam("Produced").split(" ").length;
 
         int selfCost = sa.getPayCosts().getCostMana() != null ? sa.getPayCosts().getCostMana().getMana().getCMC() : 0;
-        byte producedColor = MagicColor.fromName(sa.getParam("Produced"));
+
+        String produced = sa.getParam("Produced");
+        byte producedColor = produced.equals("Any") ? MagicColor.ALL_COLORS : MagicColor.fromName(produced);
+
+        if ("ChosenX".equals(sa.getParam("Amount"))
+                && sa.getPayCosts() != null && sa.getPayCosts().hasSpecificCostType(CostRemoveCounter.class)) {
+            CounterType ctrType = CounterType.KI; // Petalmane Baku
+            for (CostPart part : sa.getPayCosts().getCostParts()) {
+                if (part instanceof CostRemoveCounter) {
+                    ctrType = ((CostRemoveCounter)part).counter;
+                    break;
+                }
+            }
+            manaReceived = host.getCounters(ctrType);
+        }
+
         int searchCMC = numManaSrcs - selfCost + manaReceived;
 
         if ("X".equals(sa.getParam("Produced"))) {
@@ -156,6 +165,9 @@ public class ManaEffectAi extends SpellAbilityAi {
             }
 
             SpellAbility testSaNoCost = testSa.copyWithNoManaCost();
+            if (testSaNoCost == null) {
+                continue;
+            }
             testSaNoCost.setActivatingPlayer(ai);
             if (((PlayerControllerAi)ai.getController()).getAi().canPlaySa(testSaNoCost) == AiPlayDecision.WillPlay) {
                 if (testSa.getHostCard().isPermanent() && !testSa.getHostCard().hasKeyword("Haste") 

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

@@ -1,6 +1,9 @@
 package forge.ai.ability;
 
+import org.apache.commons.lang3.StringUtils;
+
 import com.google.common.base.Predicates;
+
 import forge.ai.ComputerUtil;
 import forge.ai.ComputerUtilCost;
 import forge.ai.ComputerUtilMana;
@@ -14,13 +17,13 @@ import forge.game.card.CardCollection;
 import forge.game.card.CardLists;
 import forge.game.card.CardPredicates;
 import forge.game.cost.Cost;
+import forge.game.keyword.KeywordInterface;
 import forge.game.mana.ManaCostBeingPaid;
 import forge.game.phase.PhaseHandler;
 import forge.game.phase.PhaseType;
 import forge.game.player.Player;
 import forge.game.spellability.SpellAbility;
 import forge.game.zone.ZoneType;
-import org.apache.commons.lang3.StringUtils;
 
 public class PermanentAi extends SpellAbilityAi {
 
@@ -62,9 +65,11 @@ public class PermanentAi extends SpellAbilityAi {
                 return false;
             }
         }
+
+        /* -- not used anymore after Ixalan (Planeswalkers are now legendary, not unique by subtype) --
         if (card.isPlaneswalker()) {
             CardCollection list = CardLists.filter(ai.getCardsIn(ZoneType.Battlefield),
-                    CardPredicates.Presets.PLANEWALKERS);
+                    CardPredicates.Presets.PLANESWALKERS);
             for (String type : card.getType().getSubtypes()) { // determine
                                                                // planewalker
                                                                // subtype
@@ -75,7 +80,7 @@ public class PermanentAi extends SpellAbilityAi {
                 }
                 break;
             }
-        }
+        }*/
 
         if (card.getType().hasSupertype(Supertype.World)) {
             CardCollection list = CardLists.getType(ai.getCardsIn(ZoneType.Battlefield), "World");
@@ -142,7 +147,8 @@ public class PermanentAi extends SpellAbilityAi {
         }
 
         // don't play cards without being able to pay the upkeep for
-        for (String ability : card.getKeywords()) {
+        for (KeywordInterface inst : card.getKeywords()) {
+            String ability = inst.getOriginal();
             if (ability.startsWith("UpkeepCost")) {
                 final String[] k = ability.split(":");
                 final String costs = k[1];
@@ -175,22 +181,44 @@ public class PermanentAi extends SpellAbilityAi {
                     if (!hasCard) {
                         dontCast = true;
                     }
-                } else if (param.equals("MaxControlled")) {
-                    // Only cast unless there are X or more cards like this on the battlefield under AI control already
-                    int numControlled = CardLists.filter(ai.getCardsIn(ZoneType.Battlefield), CardPredicates.nameEquals(card.getName())).size();
+                } else if (param.startsWith("MaxControlled")) {
+                    // Only cast unless there are X or more cards like this on the battlefield under AI control already,
+                    CardCollection ctrld = CardLists.filter(ai.getCardsIn(ZoneType.Battlefield), CardPredicates.nameEquals(card.getName()));
+
+                    int numControlled = 0;
+                    if (param.endsWith("WithoutOppAuras")) {
+                        // Check that the permanet does not have any auras attached to it by the opponent (this assumes that if
+                        // the opponent cast an aura on the opposing permanent, it's not with good intentions, and thus it might
+                        // be better to have a pristine copy of the card - might not always be a correct assumption, but sounds
+                        // like a reasonable default for some cards).
+                        for (Card c : ctrld) {
+                            if (c.getEnchantedBy(false).isEmpty()) {
+                                numControlled++;
+                            } else {
+                                for (Card att : c.getEnchantedBy(false)) {
+                                    if (!att.getController().isOpponentOf(ai)) {
+                                        numControlled++;
+                                    }
+                                }
+                            }
+                        }
+                    } else {
+                        numControlled = ctrld.size();
+                    }
+
                     if (numControlled >= Integer.parseInt(value)) {
                         dontCast = true;
                     }
                 } else if (param.equals("NumManaSources")) {
                     // Only cast if there are X or more mana sources controlled by the AI
-                    CardCollection m = ComputerUtilMana.getAvailableMana(ai, true);
+                    CardCollection m = ComputerUtilMana.getAvailableManaSources(ai, true);
                     if (m.size() < Integer.parseInt(value)) {
                         dontCast = true;
                     }
                 } else if (param.equals("NumManaSourcesNextTurn")) {
                     // Only cast if there are X or more mana sources controlled by the AI *or*
                     // if there are X-1 mana sources in play but the AI has an extra land in hand
-                    CardCollection m = ComputerUtilMana.getAvailableMana(ai, true);
+                    CardCollection m = ComputerUtilMana.getAvailableManaSources(ai, true);
                     int extraMana = CardLists.filter(ai.getCardsIn(ZoneType.Hand), CardPredicates.Presets.LANDS).size() > 0 ? 1 : 0;
                     if (card.getName().equals("Illusions of Grandeur")) {
                         // TODO: this is currently hardcoded for specific Illusions-Donate cost reduction spells, need to make this generic.

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

@@ -1,6 +1,7 @@
 package forge.ai.ability;
 
 import com.google.common.base.Predicates;
+import forge.ai.ComputerUtil;
 import forge.ai.ComputerUtilCard;
 import forge.ai.SpellAbilityAi;
 import forge.game.Game;
@@ -16,7 +17,6 @@ import forge.game.zone.ZoneType;
 import forge.util.MyRandom;
 
 import java.util.List;
-import java.util.Random;
 
 public class PhasesAi extends SpellAbilityAi {
     @Override
@@ -25,14 +25,17 @@ public class PhasesAi extends SpellAbilityAi {
         final TargetRestrictions tgt = sa.getTargetRestrictions();
         final Card source = sa.getHostCard();
 
-        final Random r = MyRandom.getRandom();
-        boolean randomReturn = r.nextFloat() <= Math.pow(.6667, sa.getActivationsThisTurn());
+        boolean randomReturn = MyRandom.getRandom().nextFloat() <= Math.pow(.6667, sa.getActivationsThisTurn());
 
         List<Card> tgtCards;
         if (tgt == null) {
             tgtCards = AbilityUtils.getDefinedCards(source, sa.getParam("Defined"), sa);
             if (tgtCards.contains(source)) {
                 // Protect it from something
+                final boolean isThreatened = ComputerUtil.predictThreatenedObjects(aiPlayer, null, true).contains(source);
+                if (isThreatened) {
+                    return true;
+                }
             } else {
                 // Card def = tgtCards.get(0);
                 // Phase this out if it might attack me, or before it can be

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

@@ -1,15 +1,11 @@
 package forge.ai.ability;
 
-import java.util.List;
-
 import com.google.common.base.Predicate;
-
-import forge.ai.AiPlayDecision;
-import forge.ai.ComputerUtil;
-import forge.ai.ComputerUtilCard;
-import forge.ai.PlayerControllerAi;
-import forge.ai.SpellAbilityAi;
+import forge.ai.*;
+import forge.card.CardStateName;
+import forge.card.CardTypeView;
 import forge.game.Game;
+import forge.game.GameType;
 import forge.game.ability.AbilityUtils;
 import forge.game.card.Card;
 import forge.game.card.CardCollection;
@@ -21,6 +17,9 @@ import forge.game.spellability.Spell;
 import forge.game.spellability.SpellAbility;
 import forge.game.spellability.TargetRestrictions;
 import forge.game.zone.ZoneType;
+import forge.util.MyRandom;
+
+import java.util.List;
 
 public class PlayAi extends SpellAbilityAi {
 
@@ -55,10 +54,34 @@ public class PlayAi extends SpellAbilityAi {
             }
         }
 
+        if (game.getRules().hasAppliedVariant(GameType.MoJhoSto) && source.getName().equals("Jhoira of the Ghitu Avatar")) {
+            // Additional logic for MoJhoSto:
+            // Do not activate Jhoira too early, usually there are few good targets
+            int numLandsForJhoira = (((PlayerControllerAi)ai.getController())).getAi().getIntProperty(AiProps.MOJHOSTO_NUM_LANDS_TO_ACTIVATE_JHOIRA);
+            if (ai.getLandsInPlay().size() < numLandsForJhoira) {
+                return false;
+            }
+            // Don't spam activate the Instant copying ability all the time to give the AI a chance to use other abilities
+            // Can probably be improved, but as random as MoJhoSto already is, probably not a huge deal for now
+            if ("Instant".equals(sa.getParam("AnySupportedCard")) && MyRandom.percentTrue(80)) {
+                return false;
+            }
+        }
+
         if ("ReplaySpell".equals(logic)) {
             return ComputerUtil.targetPlayableSpellCard(ai, cards, sa, sa.hasParam("WithoutManaCost"));                
         }
 
+        if (source != null && source.hasKeyword("Hideaway") && source.hasRemembered()) {
+            // AI is not very good at playing non-permanent spells this way, at least yet
+            // (might be possible to enable it for Sorceries in Main1/Main2 if target is available,
+            // but definitely not for most Instants)
+            Card rem = (Card) source.getFirstRemembered();
+            CardTypeView t = rem.getState(CardStateName.Original).getType();
+
+            return t.isPermanent() && !t.isLand();
+        }
+
         return true;
     }
     
@@ -105,7 +128,7 @@ public class PlayAi extends SpellAbilityAi {
         List<Card> tgtCards = CardLists.filter(options, new Predicate<Card>() {
             @Override
             public boolean apply(final Card c) {
-                for (SpellAbility s : c.getBasicSpells()) {
+                for (SpellAbility s : c.getBasicSpells(c.getState(CardStateName.Original))) {
                     Spell spell = (Spell) s;
                     s.setActivatingPlayer(ai);
                     // timing restrictions still apply

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

@@ -2,7 +2,6 @@ package forge.ai.ability;
 
 import java.util.ArrayList;
 import java.util.List;
-import java.util.Random;
 
 import com.google.common.base.Predicate;
 
@@ -151,8 +150,7 @@ public class ProtectAi extends SpellAbilityAi {
                         Combat combat = ai.getGame().getCombat();
                         int dmg = ComputerUtilCombat.damageIfUnblocked(c, opponent, combat, true);
                         float ratio = 1.0f * dmg / opponent.getLife();
-                        Random r = MyRandom.getRandom();
-                        return r.nextFloat() < ratio;
+                        return MyRandom.getRandom().nextFloat() < ratio;
                     }
                 }
                 return false;

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

@@ -29,7 +29,7 @@ public class ProtectAllAi extends SpellAbilityAi {
             return false;
         }
 
-        if (!ComputerUtilCost.checkSacrificeCost(ai, cost, hostCard)) {
+        if (!ComputerUtilCost.checkSacrificeCost(ai, cost, hostCard, sa)) {
             return false;
         }
 

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

@@ -1,32 +1,18 @@
 package forge.ai.ability;
 
-import java.util.Arrays;
-import java.util.List;
-
-import com.google.common.base.Predicates;
-import org.apache.commons.lang3.StringUtils;
-
 import com.google.common.base.Predicate;
+import com.google.common.base.Predicates;
 import com.google.common.collect.Lists;
-
-import forge.ai.ComputerUtil;
-import forge.ai.ComputerUtilAbility;
-import forge.ai.ComputerUtilCard;
-import forge.ai.ComputerUtilMana;
-import forge.ai.SpecialCardAi;
-import forge.ai.SpellAbilityAi;
+import forge.ai.*;
 import forge.game.Game;
 import forge.game.ability.AbilityUtils;
 import forge.game.ability.ApiType;
-import forge.game.card.Card;
-import forge.game.card.CardCollection;
-import forge.game.card.CardLists;
-import forge.game.card.CardPredicates;
+import forge.game.card.*;
 import forge.game.card.CardPredicates.Presets;
-import forge.game.card.CardUtil;
-import forge.game.card.CounterType;
+import forge.game.combat.Combat;
 import forge.game.cost.Cost;
 import forge.game.cost.CostPart;
+import forge.game.cost.CostRemoveCounter;
 import forge.game.cost.CostTapType;
 import forge.game.phase.PhaseHandler;
 import forge.game.phase.PhaseType;
@@ -35,7 +21,13 @@ import forge.game.player.PlayerActionConfirmMode;
 import forge.game.spellability.SpellAbility;
 import forge.game.spellability.SpellAbilityRestriction;
 import forge.game.spellability.TargetRestrictions;
+import forge.game.staticability.StaticAbility;
 import forge.game.zone.ZoneType;
+import forge.util.Aggregates;
+import org.apache.commons.lang3.StringUtils;
+
+import java.util.Arrays;
+import java.util.List;
 
 public class PumpAi extends PumpAiBase {
 
@@ -83,16 +75,19 @@ public class PumpAi extends PumpAiBase {
                 System.err.println("MoveCounter AiLogic without MoveCounter SubAbility!");
                 return false;
             }
-
-
+        } else if ("Aristocrat".equals(aiLogic)) {
+            return doAristocratLogic(sa, ai);
+        } else if (aiLogic.startsWith("AristocratCounters")) {
+            return doAristocratWithCountersLogic(sa, ai);
         }
+
         return super.checkAiLogic(ai, sa, aiLogic);
     }
 
     @Override
     protected boolean checkPhaseRestrictions(final Player ai, final SpellAbility sa, final PhaseHandler ph,
             final String logic) {
-        // special Phase check for MoveCounter
+        // special Phase check for various AI logics
         if (logic.equals("MoveCounter")) {
             if (ph.inCombat() && ph.getPlayerTurn().isOpponentOf(ai)) {
                 return true;
@@ -102,6 +97,11 @@ public class PumpAi extends PumpAiBase {
                 return false;
             }
             return true;
+        } else if (logic.equals("Aristocrat")) {
+            final boolean isThreatened = ComputerUtil.predictThreatenedObjects(ai, null, true).contains(sa.getHostCard());
+            if (!ph.is(PhaseType.COMBAT_DECLARE_BLOCKERS) && !isThreatened) {
+                return false;
+            }
         }
         return super.checkPhaseRestrictions(ai, sa, ph);
     }
@@ -113,7 +113,7 @@ public class PumpAi extends PumpAiBase {
             if (ph.getPhase().isBefore(PhaseType.COMBAT_DECLARE_ATTACKERS) && ph.isPlayerTurn(ai)) {
                 return false;
             }
-            if (ph.getPhase().isBefore(PhaseType.COMBAT_DECLARE_BLOCKERS) && ph.getPlayerTurn().isOpponentOf(ai)) {
+            if (ph.getPhase().isBefore(PhaseType.COMBAT_BEGIN) && ph.getPlayerTurn().isOpponentOf(ai)) {
                 return false;
             }
         }
@@ -137,12 +137,16 @@ public class PumpAi extends PumpAiBase {
         final String numDefense = sa.hasParam("NumDef") ? sa.getParam("NumDef") : "";
         final String numAttack = sa.hasParam("NumAtt") ? sa.getParam("NumAtt") : "";
 
-        final String aiLogic = sa.getParam("AILogic");
+        final String aiLogic = sa.getParamOrDefault("AILogic", "");
 
         final boolean isFight = "Fight".equals(aiLogic) || "PowerDmg".equals(aiLogic);
         final boolean isBerserk = "Berserk".equals(aiLogic);
 
-        if ("MoveCounter".equals(aiLogic)) {
+        if ("Pummeler".equals(aiLogic)) {
+            return SpecialCardAi.ElectrostaticPummeler.consider(ai, sa);
+        } else if (aiLogic.startsWith("AristocratCounters")) {
+            return true; // the preconditions to this are already tested in checkAiLogic
+        } else if ("MoveCounter".equals(aiLogic)) {
             final SpellAbility moveSA = sa.findSubAbilityByType(ApiType.MoveCounter);
 
             if (moveSA == null) {
@@ -334,6 +338,23 @@ public class PumpAi extends PumpAiBase {
             attack = AbilityUtils.calculateAmount(sa.getHostCard(), numAttack, sa);
         }
 
+        if ("ContinuousBonus".equals(aiLogic)) {
+            // P/T bonus in a continuous static ability
+            for (StaticAbility stAb : source.getStaticAbilities()) {
+                if ("Continuous".equals(stAb.getParam("Mode"))) {
+                    if (stAb.hasParam("AddPower")) {
+                        attack += AbilityUtils.calculateAmount(source, stAb.getParam("AddPower"), stAb);
+                    }
+                    if (stAb.hasParam("AddToughness")) {
+                        defense += AbilityUtils.calculateAmount(source, stAb.getParam("AddToughness"), stAb);
+                    }
+                    if (stAb.hasParam("AddKeyword")) {
+                        keywords.addAll(Lists.newArrayList(stAb.getParam("AddKeyword").split(" & ")));
+                    }
+                }
+            }
+        }
+
         if ((numDefense.contains("X") && defense == 0) || (numAttack.contains("X") && attack == 0 && !isBerserk)) {
             return false;
         }
@@ -360,9 +381,21 @@ public class PumpAi extends PumpAiBase {
 
                     return true;
                 }
-                if (!card.getController().isOpponentOf(ai) 
-                        && ComputerUtilCard.shouldPumpCard(ai, sa, card, defense, attack, keywords, false)) {
-                    return true;
+                if (!card.getController().isOpponentOf(ai)) {
+                    if (ComputerUtilCard.shouldPumpCard(ai, sa, card, defense, attack, keywords, false)) {
+                        return true;
+                    } else if (containsUsefulKeyword(ai, keywords, card, sa, attack)) {
+
+                        Card pumped = ComputerUtilCard.getPumpedCreature(ai, sa, card, 0, 0, keywords);
+                        if (game.getPhaseHandler().is(PhaseType.COMBAT_DECLARE_ATTACKERS, ai)
+                                || game.getPhaseHandler().is(PhaseType.COMBAT_BEGIN, ai)) {
+                            if (!ComputerUtilCard.doesSpecifiedCreatureAttackAI(ai, pumped)) {
+                                return false;
+                            }
+                        }
+
+                        return true;
+                    }
                 }
             }
             return false;
@@ -372,6 +405,21 @@ public class PumpAi extends PumpAiBase {
             return false;
         }
 
+        if ("DebuffForXCounters".equals(sa.getParam("AILogic")) && sa.getTargetCard() != null) {
+            // e.g. Skullmane Baku
+            CounterType ctrType = CounterType.KI;
+            for (CostPart part : sa.getPayCosts().getCostParts()) {
+                if (part instanceof CostRemoveCounter) {
+                    ctrType = ((CostRemoveCounter)part).counter;
+                    break;
+                }
+            }
+
+            // Do not pay more counters than necessary to kill the targeted creature
+            int chosenX = Math.min(source.getCounters(ctrType), sa.getTargetCard().getNetToughness());
+            sa.setSVar("ChosenX", String.valueOf(chosenX));
+        }
+
         return true;
     } // pumpPlayAI()
 
@@ -406,10 +454,28 @@ public class PumpAi extends PumpAiBase {
 
         CardCollection list;
         if (sa.hasParam("AILogic")) {
-            if (sa.getParam("AILogic").equals("HighestPower")) {
+            if (sa.getParam("AILogic").equals("HighestPower") || sa.getParam("AILogic").equals("ContinuousBonus")) {
                 list = CardLists.getValidCards(CardLists.filter(game.getCardsIn(ZoneType.Battlefield), Presets.CREATURES), tgt.getValidTgts(), ai, source, sa);
                 list = CardLists.getTargetableCards(list, sa);
                 CardLists.sortByPowerDesc(list);
+
+                // Try not to kill own creatures with this pump
+                CardCollection canDieToPump = new CardCollection();
+                for (Card c : list) {
+                    if (c.isCreature() && c.getController() == ai
+                            && c.getNetToughness() - c.getTempToughnessBoost() + defense <= 0) {
+                        canDieToPump.add(c);
+                    }
+                }
+                list.removeAll(canDieToPump);
+
+                // Generally, don't pump anything that your opponents control
+                if ("ContinuousBonus".equals(sa.getParam("AILogic"))) {
+                    // TODO: make it possible for the AI to use this logic to kill opposing creatures
+                    // when a toughness debuff is applied
+                    list = CardLists.filter(list, CardPredicates.isController(ai));
+                }
+
                 if (!list.isEmpty()) {
                     sa.getTargets().add(list.get(0));
                     return true;
@@ -478,6 +544,9 @@ public class PumpAi extends PumpAiBase {
             }));
         }
 
+        // Filter AI-specific targets if provided
+        list = ComputerUtil.filterAITgts(sa, ai, (CardCollection)list, true);
+
         if (list.isEmpty()) {
             if (ComputerUtil.activateForCost(sa, ai)) {
                 return pumpMandatoryTarget(ai, sa);
@@ -490,6 +559,17 @@ public class PumpAi extends PumpAiBase {
             list = ComputerUtil.getSafeTargets(ai, sa, list);
         }
 
+        if ("BetterCreatureThanSource".equals(sa.getParam("AILogic"))) {
+            // Don't target cards that are not better in value than the targeting card
+            final int sourceValue = ComputerUtilCard.evaluateCreature(source);
+            list = CardLists.filter(list, new Predicate<Card>() {
+                @Override
+                public boolean apply(Card card) {
+                    return card.isCreature() && ComputerUtilCard.evaluateCreature(card) > sourceValue + 30;
+                }
+            });
+        }
+
         if ("Snapcaster".equals(sa.getParam("AILogic"))) {
             if (!ComputerUtil.targetPlayableSpellCard(ai, list, sa, false)) {
                 return false;
@@ -712,8 +792,6 @@ public class PumpAi extends PumpAiBase {
         return true;
     } // pumpDrawbackAI()
 
-
-
     @Override
     public boolean confirmAction(Player player, SpellAbility sa, PlayerActionConfirmMode mode, String message) {
         //TODO Add logic here if necessary but I think the AI won't cast
@@ -721,4 +799,248 @@ public class PumpAi extends PumpAiBase {
         //and the pump isn't mandatory
         return true;
     }
+
+    public boolean doAristocratLogic(final SpellAbility sa, final Player ai) {
+        // A logic for cards that say "Sacrifice a creature: CARDNAME gets +X/+X until EOT"
+        final Game game = ai.getGame();
+        final Combat combat = game.getCombat();
+        final Card source = sa.getHostCard();
+        final int numOtherCreats = Math.max(0, ai.getCreaturesInPlay().size() - 1);
+        final int powerBonus = sa.hasParam("NumAtt") ? AbilityUtils.calculateAmount(source, sa.getParam("NumAtt"), sa) : 0;
+        final int toughnessBonus = sa.hasParam("NumDef") ? AbilityUtils.calculateAmount(source, sa.getParam("NumDef"), sa) : 0;
+        final boolean indestructible = sa.hasParam("KW") && sa.getParam("KW").contains("Indestructible");
+        final int selfEval = ComputerUtilCard.evaluateCreature(source);
+        final boolean isThreatened = ComputerUtil.predictThreatenedObjects(ai, null, true).contains(source);
+
+        if (numOtherCreats == 0) {
+            return false;
+        }
+
+        // Try to save the card from death by pumping it if it's threatened with a damage spell
+        if (isThreatened && (toughnessBonus > 0 || indestructible)) {
+            SpellAbility saTop = game.getStack().peekAbility();
+
+            if (saTop.getApi() == ApiType.DealDamage || saTop.getApi() == ApiType.DamageAll) {
+                int dmg = AbilityUtils.calculateAmount(saTop.getHostCard(), saTop.getParam("NumDmg"), saTop) + source.getDamage();
+                final int numCreatsToSac = indestructible ? 1 : Math.max(1, (int)Math.ceil((dmg - source.getNetToughness() + 1) / toughnessBonus));
+
+                if (numCreatsToSac > 1) { // probably not worth sacrificing too much
+                    return false;
+                }
+
+                if (indestructible || (source.getNetToughness() <= dmg && source.getNetToughness() + toughnessBonus * numCreatsToSac > dmg)) {
+                    final CardCollection sacFodder = CardLists.filter(ai.getCreaturesInPlay(),
+                            new Predicate<Card>() {
+                                @Override
+                                public boolean apply(Card card) {
+                                    return ComputerUtilCard.isUselessCreature(ai, card)
+                                            || card.hasSVar("SacMe")
+                                            || ComputerUtilCard.evaluateCreature(card) < selfEval; // Maybe around 150 is OK?
+                                }
+                            }
+                    );
+                    if (sacFodder.size() >= numCreatsToSac) {
+                        return true;
+                    }
+                }
+            }
+
+            return false;
+        }
+
+        if (combat == null) {
+            return false;
+        }
+
+        if (combat.isAttacking(source)) {
+            if (combat.getBlockers(source).isEmpty()) {
+                // Unblocked. Check if able to deal lethal, then sac'ing everything is fair game if
+                // the opponent is tapped out or if we're willing to risk it (will currently risk it
+                // in case it sacs less than half its creatures to deal lethal damage)
+
+                // TODO: also teach the AI to account for Trample, but that's trickier (needs to account fully
+                // for potential damage prevention, various effects like reducing damage to 0, etc.)
+
+                final Player defPlayer = combat.getDefendingPlayerRelatedTo(source);
+                final boolean defTappedOut = ComputerUtilMana.getAvailableManaEstimate(defPlayer) == 0;
+
+                final boolean isInfect = source.hasKeyword("Infect"); // Flesh-Eater Imp
+                int lethalDmg = isInfect ? 10 - defPlayer.getPoisonCounters() : defPlayer.getLife();
+
+                if (isInfect && !combat.getDefenderByAttacker(source).canReceiveCounters(CounterType.POISON)) {
+                    lethalDmg = Integer.MAX_VALUE; // won't be able to deal poison damage to kill the opponent
+                }
+
+                final int numCreatsToSac = indestructible ? 1 : (lethalDmg - source.getNetCombatDamage()) / powerBonus;
+
+                if (defTappedOut || numCreatsToSac < numOtherCreats / 2) {
+                    return source.getNetCombatDamage() < lethalDmg
+                            && source.getNetCombatDamage() + numOtherCreats * powerBonus >= lethalDmg;
+                } else {
+                    return false;
+                }
+            } else {
+                // We have already attacked. Thus, see if we have a creature to sac that is worse to lose
+                // than the card we attacked with.
+                final CardCollection sacTgts = CardLists.filter(ai.getCreaturesInPlay(),
+                        new Predicate<Card>() {
+                            @Override
+                            public boolean apply(Card card) {
+                                return ComputerUtilCard.isUselessCreature(ai, card)
+                                        || ComputerUtilCard.evaluateCreature(card) < selfEval;
+                            }
+                        }
+                );
+
+                if (sacTgts.isEmpty()) {
+                    return false;
+                }
+
+                final int minDefT = Aggregates.min(combat.getBlockers(source), CardPredicates.Accessors.fnGetNetToughness);
+                final int DefP = indestructible ? 0 : Aggregates.sum(combat.getBlockers(source), CardPredicates.Accessors.fnGetNetPower);
+
+                // Make sure we don't over-sacrifice, only sac until we can survive and kill a creature
+                return source.getNetToughness() - source.getDamage() <= DefP || source.getNetCombatDamage() < minDefT;
+            }
+        } else {
+            // We can't deal lethal, check if there's any sac fodder than can be used for other circumstances
+            final CardCollection sacFodder = CardLists.filter(ai.getCreaturesInPlay(),
+                    new Predicate<Card>() {
+                        @Override
+                        public boolean apply(Card card) {
+                            return ComputerUtilCard.isUselessCreature(ai, card)
+                                    || card.hasSVar("SacMe")
+                                    || ComputerUtilCard.evaluateCreature(card) < selfEval; // Maybe around 150 is OK?
+                        }
+                    }
+            );
+
+            return !sacFodder.isEmpty();
+        }
+    }
+
+    public boolean doAristocratWithCountersLogic(final SpellAbility sa, final Player ai) {
+        // A logic for cards that say "Sacrifice a creature: put X +1/+1 counters on CARDNAME" (e.g. Falkenrath Aristocrat)
+        final Card source = sa.getHostCard();
+        final String logic = sa.getParam("AILogic"); // should not even get here unless there's an Aristocrats logic applied
+        final boolean isDeclareBlockers = ai.getGame().getPhaseHandler().is(PhaseType.COMBAT_DECLARE_BLOCKERS);
+
+        final int numOtherCreats = Math.max(0, ai.getCreaturesInPlay().size() - 1);
+        if (numOtherCreats == 0) {
+            // Cut short if there's nothing to sac at all
+            return false;
+        }
+
+        // Check if the standard Aristocrats logic applies first (if in the right conditions for it)
+        final boolean isThreatened = ComputerUtil.predictThreatenedObjects(ai, null, true).contains(source);
+        if (isDeclareBlockers || isThreatened) {
+            if (doAristocratLogic(sa, ai)) {
+                return true;
+            }
+        }
+
+        // Check if anything is to be gained from the PutCounter subability
+        if (sa.getSubAbility() == null || sa.getSubAbility().getApi() != ApiType.PutCounter) {
+            // Shouldn't get here if there is no PutCounter subability (wrong AI logic specified?)
+            System.err.println("Warning: AILogic AristocratCounters was specified on " + source + ", but there was no PutCounter subability!");
+            return false;
+        }
+
+        final Game game = ai.getGame();
+        final Combat combat = game.getCombat();
+        final int selfEval = ComputerUtilCard.evaluateCreature(source);
+
+        String typeToGainCtr = "";
+        if (logic.contains(".")) {
+            typeToGainCtr = logic.substring(logic.indexOf(".") + 1);
+        }
+        CardCollection relevantCreats = typeToGainCtr.isEmpty() ? ai.getCreaturesInPlay()
+                : CardLists.filter(ai.getCreaturesInPlay(), CardPredicates.isType(typeToGainCtr));
+        relevantCreats.remove(source);
+        if (relevantCreats.isEmpty()) {
+            // No relevant creatures to sac
+            return false;
+        }
+
+        int numCtrs = AbilityUtils.calculateAmount(source, sa.getSubAbility().getParam("CounterNum"), sa.getSubAbility());
+
+        if (combat != null && combat.isAttacking(source) && isDeclareBlockers) {
+            if (combat.getBlockers(source).isEmpty()) {
+                // Unblocked. Check if we can deal lethal after receiving counters.
+                final Player defPlayer = combat.getDefendingPlayerRelatedTo(source);
+                final boolean defTappedOut = ComputerUtilMana.getAvailableManaEstimate(defPlayer) == 0;
+
+                final boolean isInfect = source.hasKeyword("Infect");
+                int lethalDmg = isInfect ? 10 - defPlayer.getPoisonCounters() : defPlayer.getLife();
+
+                if (isInfect && !combat.getDefenderByAttacker(source).canReceiveCounters(CounterType.POISON)) {
+                    lethalDmg = Integer.MAX_VALUE; // won't be able to deal poison damage to kill the opponent
+                }
+
+                // Check if there's anything that will die anyway that can be eaten to gain a perma-bonus
+                final CardCollection forcedSacTgts = CardLists.filter(relevantCreats,
+                        new Predicate<Card>() {
+                            @Override
+                            public boolean apply(Card card) {
+                                return ComputerUtil.predictThreatenedObjects(ai, null, true).contains(card)
+                                        || (combat.isAttacking(card) && combat.isBlocked(card) && ComputerUtilCombat.combatantWouldBeDestroyed(ai, card, combat));
+                            }
+                        }
+                );
+                if (!forcedSacTgts.isEmpty()) {
+                    return true;
+                }
+
+                final int numCreatsToSac = Math.max(0, (lethalDmg - source.getNetCombatDamage()) / numCtrs);
+
+                if (defTappedOut || numCreatsToSac < relevantCreats.size() / 2) {
+                    return source.getNetCombatDamage() < lethalDmg
+                            && source.getNetCombatDamage() + relevantCreats.size() * numCtrs >= lethalDmg;
+                } else {
+                    return false;
+                }
+            } else {
+                // We have already attacked. Thus, see if we have a creature to sac that is worse to lose
+                // than the card we attacked with. Since we're getting a permanent bonus, consider sacrificing
+                // things that are also threatened to be destroyed anyway.
+                final CardCollection sacTgts = CardLists.filter(relevantCreats,
+                        new Predicate<Card>() {
+                            @Override
+                            public boolean apply(Card card) {
+                                return ComputerUtilCard.isUselessCreature(ai, card)
+                                        || ComputerUtilCard.evaluateCreature(card) < selfEval
+                                        || ComputerUtil.predictThreatenedObjects(ai, null, true).contains(card);
+                            }
+                        }
+                );
+
+                if (sacTgts.isEmpty()) {
+                    return false;
+                }
+
+                final boolean sourceCantDie = ComputerUtilCombat.attackerCantBeDestroyedInCombat(ai, source);
+                final int minDefT = Aggregates.min(combat.getBlockers(source), CardPredicates.Accessors.fnGetNetToughness);
+                final int DefP = sourceCantDie ? 0 : Aggregates.sum(combat.getBlockers(source), CardPredicates.Accessors.fnGetNetPower);
+
+                // Make sure we don't over-sacrifice, only sac until we can survive and kill a creature
+                return source.getNetToughness() - source.getDamage() <= DefP || source.getNetCombatDamage() < minDefT;
+            }
+        } else {
+            // We can't deal lethal, check if there's any sac fodder than can be used for other circumstances
+            final boolean isBlocking = combat != null && combat.isBlocking(source);
+            final CardCollection sacFodder = CardLists.filter(relevantCreats,
+                    new Predicate<Card>() {
+                        @Override
+                        public boolean apply(Card card) {
+                            return ComputerUtilCard.isUselessCreature(ai, card)
+                                    || card.hasSVar("SacMe")
+                                    || (isBlocking && ComputerUtilCard.evaluateCreature(card) < selfEval)
+                                    || ComputerUtil.predictThreatenedObjects(ai, null, true).contains(card);
+                        }
+                    }
+            );
+
+            return !sacFodder.isEmpty();
+        }
+    }
 }

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

@@ -3,18 +3,13 @@ package forge.ai.ability;
 import com.google.common.base.Predicate;
 import com.google.common.base.Predicates;
 import com.google.common.collect.Iterables;
-
 import forge.ai.ComputerUtil;
 import forge.ai.ComputerUtilCard;
 import forge.ai.ComputerUtilCombat;
 import forge.ai.SpellAbilityAi;
 import forge.card.MagicColor;
 import forge.game.Game;
-import forge.game.card.Card;
-import forge.game.card.CardCollection;
-import forge.game.card.CardLists;
-import forge.game.card.CardPredicates;
-import forge.game.card.CardUtil;
+import forge.game.card.*;
 import forge.game.combat.Combat;
 import forge.game.combat.CombatUtil;
 import forge.game.phase.PhaseHandler;
@@ -207,6 +202,19 @@ public abstract class PumpAiBase extends SpellAbilityAi {
                 return true;
             }
             Predicate<Card> flyingOrReach = Predicates.or(CardPredicates.hasKeyword("Flying"), CardPredicates.hasKeyword("Reach"));
+            if (ph.isPlayerTurn(opp) && combat != null
+                    && Iterables.any(combat.getAttackers(), CardPredicates.hasKeyword("Flying"))
+                    && CombatUtil.canBlock(card)) {
+                // Use defensively to destroy the opposing Flying creature when possible, or to block with an indestructible
+                // creature buffed with Flying
+                for (Card c : CardLists.filter(combat.getAttackers(), CardPredicates.hasKeyword("Flying"))) {
+                    if (!ComputerUtilCombat.attackerCantBeDestroyedInCombat(c.getController(), c)
+                            && (card.getNetPower() >= c.getNetToughness() && card.getNetToughness() > c.getNetPower()
+                            || ComputerUtilCombat.attackerCantBeDestroyedInCombat(ai, card))) {
+                        return true;
+                    }
+                }
+            }
             if (ph.isPlayerTurn(opp) || !(CombatUtil.canAttack(card, opp) || (combat != null && combat.isAttacking(card)))
                     || ph.getPhase().isAfter(PhaseType.COMBAT_DECLARE_ATTACKERS)
                     || newPower <= 0
@@ -254,6 +262,13 @@ public abstract class PumpAiBase extends SpellAbilityAi {
                 return false;
             }
         } else if (keyword.endsWith("Indestructible")) {
+            // Predicting threatened objects in relevant non-combat situations happens elsewhere,
+            // so we are only worrying about combat relevance of Indestructible at this point.
+            if (combat == null
+                    || !((combat.isBlocked(card) || combat.isBlocking(card))
+                    && ComputerUtilCombat.combatantWouldBeDestroyed(ai, card, combat))) {
+                return false;
+            }
             return true;
         } else if (keyword.endsWith("Deathtouch")) {
             if (ph.isPlayerTurn(opp) && ph.getPhase().equals(PhaseType.COMBAT_DECLARE_ATTACKERS)) {
@@ -371,7 +386,7 @@ public abstract class PumpAiBase extends SpellAbilityAi {
                     || !CombatUtil.canBlock(card)) {
                 return false;
             }
-        } else if (keyword.endsWith("CARDNAME can block an additional creature.")) {
+        } else if (keyword.endsWith("CARDNAME can block an additional creature each combat.")) {
             if (ph.isPlayerTurn(ai)
                     || !ph.getPhase().equals(PhaseType.COMBAT_DECLARE_ATTACKERS)) {
                 return false;
@@ -532,6 +547,15 @@ public abstract class PumpAiBase extends SpellAbilityAi {
         else {
             final boolean addsKeywords = !keywords.isEmpty();
             if (addsKeywords) {
+
+                // If the keyword can prevent a creature from attacking, see if there's some kind of viable prioritization
+                if (keywords.contains("CARDNAME can't attack.") || keywords.contains("CARDNAME can't attack or block.")
+                        || keywords.contains("HIDDEN CARDNAME can't attack.") || keywords.contains("HIDDEN CARDNAME can't attack or block.")) {
+                    if (CardLists.getNotType(list, "Creature").isEmpty()) {
+                        list = ComputerUtilCard.prioritizeCreaturesWorthRemovingNow(ai, list, true);
+                    }
+                }
+
                 list = CardLists.filter(list, new Predicate<Card>() {
                     @Override
                     public boolean apply(final Card c) {

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

@@ -48,7 +48,7 @@ public class PumpAllAi extends PumpAiBase {
         }
 
         if (abCost != null && source.hasSVar("AIPreference")) {
-            if (!ComputerUtilCost.checkSacrificeCost(ai, abCost, source, true)) {
+            if (!ComputerUtilCost.checkSacrificeCost(ai, abCost, source, sa, true)) {
                 return false;
             }
         }

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

@@ -17,6 +17,12 @@ public class RemoveFromCombatAi extends SpellAbilityAi {
     public boolean chkAIDrawback(SpellAbility sa, Player aiPlayer) {
         // AI should only activate this during Human's turn
 
+        if ("RemoveBestAttacker".equals(sa.getParam("AILogic"))) {
+            if (aiPlayer.getGame().getCombat() != null && aiPlayer.getGame().getCombat().getDefenders().contains(aiPlayer)) {
+                return true;
+            }
+        }
+
         // TODO - implement AI
         return false;
     }

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

@@ -1,12 +1,9 @@
 package forge.ai.ability;
 
 
-import forge.ai.AiController;
-import forge.ai.ComputerUtil;
-import forge.ai.ComputerUtilMana;
-import forge.ai.PlayerControllerAi;
-import forge.ai.SpellAbilityAi;
+import forge.ai.*;
 import forge.game.card.Card;
+import forge.game.phase.PhaseType;
 import forge.game.player.Player;
 import forge.game.player.PlayerActionConfirmMode;
 import forge.game.spellability.SpellAbility;
@@ -28,7 +25,10 @@ public class RepeatAi extends SpellAbilityAi {
             sa.getTargets().add(opp);
         }
         String logic = sa.getParam("AILogic");
-        if ("MaxX".equals(logic)) {
+        if ("MaxX".equals(logic) || "MaxXAtOppEOT".equals(logic)) {
+            if ("MaxXAtOppEOT".equals(logic) && !(ai.getGame().getPhaseHandler().is(PhaseType.END_OF_TURN) && ai.getGame().getPhaseHandler().getNextTurn() == ai)) {
+                return false;
+            }
             // Set PayX here to maximum value.
             final int max = ComputerUtilMana.determineLeftoverMana(sa, ai);
             source.setSVar("PayX", Integer.toString(max));
@@ -60,10 +60,10 @@ public class RepeatAi extends SpellAbilityAi {
          }
 
     	// setup subability to repeat
-        final SpellAbility repeat = sa.getAdditonalAbility("RepeatSubAbility");
+        final SpellAbility repeat = sa.getAdditionalAbility("RepeatSubAbility");
 
         if (repeat == null) {
-        	return false;
+        	return mandatory;
         }
 
         AiController aic = ((PlayerControllerAi)ai.getController()).getAi();

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

@@ -1,10 +1,8 @@
 package forge.ai.ability;
 
-import java.util.List;
-
 import com.google.common.base.Predicate;
-
 import forge.ai.ComputerUtilCard;
+import forge.ai.SpecialCardAi;
 import forge.ai.SpellAbilityAi;
 import forge.game.ability.AbilityUtils;
 import forge.game.card.Card;
@@ -15,6 +13,9 @@ import forge.game.player.Player;
 import forge.game.spellability.AbilitySub;
 import forge.game.spellability.SpellAbility;
 import forge.game.zone.ZoneType;
+import forge.util.TextUtil;
+
+import java.util.List;
 
 
 public class RepeatEachAi extends SpellAbilityAi {
@@ -26,7 +27,9 @@ public class RepeatEachAi extends SpellAbilityAi {
     protected boolean canPlayAI(Player aiPlayer, SpellAbility sa) {
         String logic = sa.getParam("AILogic");
 
-        if ("Never".equals(logic)) {
+        if ("PriceOfProgress".equals(logic)) {
+            return SpecialCardAi.PriceOfProgress.consider(aiPlayer, sa);
+        } else if ("Never".equals(logic)) {
             return false;
         } else if ("CloneMyTokens".equals(logic)) {
             if (CardLists.filter(aiPlayer.getCreaturesInPlay(), Presets.TOKEN).size() < 2) {
@@ -66,12 +69,12 @@ public class RepeatEachAi extends SpellAbilityAi {
                 }
             }
         } else if ("OpponentHasCreatures".equals(logic)) {
-        	for (Player opp : aiPlayer.getOpponents()) {
-        		if (!opp.getCreaturesInPlay().isEmpty()){
-        			return true;
-        		}
-        	}
-        	return false;
+            for (Player opp : aiPlayer.getOpponents()) {
+                if (!opp.getCreaturesInPlay().isEmpty()){
+                    return true;
+                }
+            }
+            return false;
         } else if ("OpponentHasMultipleCreatures".equals(logic)) {
             for (Player opp : aiPlayer.getOpponents()) {
                 if (opp.getCreaturesInPlay().size() > 1){
@@ -81,11 +84,11 @@ public class RepeatEachAi extends SpellAbilityAi {
             return false;
         } else if ("AllPlayerLoseLife".equals(logic)) {
             final Card source = sa.getHostCard();
-            AbilitySub repeat = sa.getAdditonalAbility("RepeatSubAbility");
+            AbilitySub repeat = sa.getAdditionalAbility("RepeatSubAbility");
 
             String svar = repeat.getSVar(repeat.getParam("LifeAmount"));
             // replace RememberedPlayerCtrl with YouCtrl
-            String svarYou = svar.replace("RememberedPlayer", "You");
+            String svarYou = TextUtil.fastReplace(svar, "RememberedPlayer", "You");
 
             // Currently all Cards with that are affect all player, including AI
             if (aiPlayer.canLoseLife()) {

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

@@ -1,7 +1,5 @@
 package forge.ai.ability;
 
-import java.util.Random;
-
 import forge.ai.AiPlayDecision;
 import forge.ai.PlayerControllerAi;
 import forge.ai.SpellAbilityAi;
@@ -23,8 +21,7 @@ public class RevealAi extends RevealAiBase {
             return false;
         }
 
-        final Random r = MyRandom.getRandom();
-        boolean randomReturn = r.nextFloat() <= Math.pow(.667, sa.getActivationsThisTurn() + 1);
+        boolean randomReturn = MyRandom.getRandom().nextFloat() <= Math.pow(.667, sa.getActivationsThisTurn() + 1);
 
         if (SpellAbilityAi.playReusable(ai, sa)) {
             randomReturn = true;
@@ -34,7 +31,7 @@ public class RevealAi extends RevealAiBase {
 
     @Override
     protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
-        // logic to see if it should reveal Mircacle Card
+        // logic to see if it should reveal Miracle Card
         if (sa.hasParam("MiracleCost")) {
             final Card c = sa.getHostCard();
             for (SpellAbility s : c.getBasicSpells()) {

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

@@ -1,7 +1,5 @@
 package forge.ai.ability;
 
-import java.util.Random;
-
 import forge.ai.SpellAbilityAi;
 import forge.game.player.Player;
 import forge.game.spellability.SpellAbility;
@@ -20,8 +18,7 @@ public class RevealHandAi extends RevealAiBase {
             return false;
         }
 
-        final Random r = MyRandom.getRandom();
-        boolean randomReturn = r.nextFloat() <= Math.pow(.667, sa.getActivationsThisTurn() + 1);
+        boolean randomReturn = MyRandom.getRandom().nextFloat() <= Math.pow(.667, sa.getActivationsThisTurn() + 1);
 
         if (SpellAbilityAi.playReusable(ai, sa)) {
             randomReturn = true;

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

@@ -11,6 +11,7 @@ import forge.game.player.Player;
 import forge.game.spellability.SpellAbility;
 import forge.game.zone.ZoneType;
 import forge.util.MyRandom;
+import forge.util.TextUtil;
 
 public class RollPlanarDiceAi extends SpellAbilityAi {
     /* (non-Javadoc)
@@ -107,7 +108,7 @@ public class RollPlanarDiceAi extends SpellAbilityAi {
                         }
                         break;
                     default:
-                        System.out.println(String.format("Unexpected AI hint parameter in card %s in RollPlanarDiceAi: %s.", plane.getName(), paramName));
+                        System.out.println(TextUtil.concatNoSpace("Unexpected AI hint parameter in card ", plane.getName(), " in RollPlanarDiceAi: ", paramName, "."));
                         break;
                 }
             }

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

@@ -13,8 +13,7 @@ import forge.game.player.Player;
 import forge.game.spellability.SpellAbility;
 import forge.game.zone.ZoneType;
 import forge.util.MyRandom;
-
-import java.util.Random;
+import forge.util.TextUtil;
 
 public class SacrificeAllAi extends SpellAbilityAi {
 
@@ -22,7 +21,6 @@ public class SacrificeAllAi extends SpellAbilityAi {
     protected boolean canPlayAI(Player ai, SpellAbility sa) {
         // AI needs to be expanded, since this function can be pretty complex
         // based on what the expected targets could be
-        final Random r = MyRandom.getRandom();
         final Cost abCost = sa.getPayCosts();
         final Card source = sa.getHostCard();
         String valid = "";
@@ -35,7 +33,7 @@ public class SacrificeAllAi extends SpellAbilityAi {
             // Set PayX here to maximum value.
             final int xPay = ComputerUtilMana.determineLeftoverMana(sa, ai);
             source.setSVar("PayX", Integer.toString(xPay));
-            valid = valid.replace("X", Integer.toString(xPay));
+            valid = TextUtil.fastReplace(valid, "X", Integer.toString(xPay));
         }
 
         CardCollection humanlist =
@@ -51,7 +49,7 @@ public class SacrificeAllAi extends SpellAbilityAi {
         }
 
         // prevent run-away activations - first time will always return true
-        boolean chance = r.nextFloat() <= Math.pow(.6667, sa.getActivationsThisTurn());
+        boolean chance = MyRandom.getRandom().nextFloat() <= Math.pow(.6667, sa.getActivationsThisTurn());
 
         // if only creatures are affected evaluate both lists and pass only if
         // human creatures are more valuable
@@ -73,7 +71,7 @@ public class SacrificeAllAi extends SpellAbilityAi {
             return false;
         }
 
-        return ((r.nextFloat() < .9667) && chance);
+        return ((MyRandom.getRandom().nextFloat() < .9667) && chance);
     }
 
     @Override

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

@@ -1,14 +1,13 @@
 package forge.ai.ability;
 
+import com.google.common.base.Predicates;
+import forge.ai.ComputerUtilMana;
 import forge.ai.SpellAbilityAi;
-import forge.game.card.Card;
+import forge.game.ability.ApiType;
+import forge.game.card.*;
 import forge.game.card.Card.SplitCMCMode;
 import forge.game.phase.PhaseHandler;
 import forge.game.phase.PhaseType;
-import forge.game.card.CardCollection;
-import forge.game.card.CardLists;
-import forge.game.card.CardPredicates;
-import forge.game.card.CounterType;
 import forge.game.player.Player;
 import forge.game.player.PlayerActionConfirmMode;
 import forge.game.spellability.SpellAbility;
@@ -16,10 +15,6 @@ import forge.game.spellability.TargetRestrictions;
 import forge.game.zone.ZoneType;
 import forge.util.MyRandom;
 
-import java.util.Random;
-
-import com.google.common.base.Predicates;
-
 public class ScryAi extends SpellAbilityAi {
 
     /* (non-Javadoc)
@@ -49,6 +44,24 @@ public class ScryAi extends SpellAbilityAi {
      */
     @Override
     protected boolean checkPhaseRestrictions(final Player ai, final SpellAbility sa, final PhaseHandler ph) {
+        // if the Scry ability requires tapping and has a mana cost, it's best done at the end of opponent's turn
+        // 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)
+        if ("BestOpportunity".equals(sa.getParam("AILogic"))) {
+            return doBestOpportunityLogic(ai, sa, ph);
+        }
+
         // in the playerturn Scry should only be done in Main1 or in upkeep if able
         if (ph.isPlayerTurn(ai)) {
             if (SpellAbilityAi.isSorcerySpeed(sa)) {
@@ -60,6 +73,27 @@ public class ScryAi extends SpellAbilityAi {
         return true;
     }
 
+    private boolean doBestOpportunityLogic(Player ai, SpellAbility sa, PhaseHandler ph) {
+        // Check to see if there are any cards in hand that may be worth casting
+        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()
+                        && ComputerUtilMana.hasEnoughManaSourcesToCast(ab, ai)) {
+                    // TODO: currently looks for non-Scry cards, can most certainly be made smarter.
+                    if (ab.getApi() != ApiType.Scry) {
+                        hasSomethingElse = true;
+                        break;
+                    }
+                }
+            }
+        }
+
+        return (!hasSomethingElse && ph.getPlayerTurn() == ai && ph.getPhase().isAfter(PhaseType.DRAW))
+                || (ph.getNextTurn() == ai && ph.is(PhaseType.END_OF_TURN));
+    }
+
     /**
      * Checks if the AI will play a SpellAbility with the specified AiLogic
      */
@@ -135,8 +169,7 @@ public class ScryAi extends SpellAbilityAi {
             chance = .667; // 66.7% chance for sorcery speed (since it will
                            // never activate EOT)
         }
-        final Random r = MyRandom.getRandom();
-        boolean randomReturn = r.nextFloat() <= Math.pow(chance, sa.getActivationsThisTurn() + 1);
+        boolean randomReturn = MyRandom.getRandom().nextFloat() <= Math.pow(chance, sa.getActivationsThisTurn() + 1);
 
         if (SpellAbilityAi.playReusable(ai, sa)) {
             randomReturn = true;

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

@@ -13,6 +13,7 @@ import forge.game.card.CardPredicates.Presets;
 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;
 import forge.game.spellability.TargetRestrictions;
 import forge.game.zone.ZoneType;
@@ -62,6 +63,13 @@ public class SetStateAi extends SpellAbilityAi {
         return false;
     }
 
+    @Override
+    protected boolean checkAiLogic(final Player aiPlayer, final SpellAbility sa, final String aiLogic) {
+        final Card source = sa.getHostCard();
+
+        return super.checkAiLogic(aiPlayer, sa, aiLogic);
+    }
+
     @Override
     public boolean chkAIDrawback(SpellAbility sa, Player aiPlayer) {
         // Gross generalization, but this always considers alternate
@@ -73,6 +81,7 @@ public class SetStateAi extends SpellAbilityAi {
     protected boolean checkPhaseRestrictions(Player ai, SpellAbility sa, PhaseHandler ph) {
         final String mode = sa.getParam("Mode");
         final Card source = sa.getHostCard();
+        final String logic = sa.getParamOrDefault("AILogic", "");
         final Game game = source.getGame();
 
         if("Transform".equals(mode)) {
@@ -81,7 +90,7 @@ public class SetStateAi extends SpellAbilityAi {
                 if (source.hasKeyword("CARDNAME can't transform")) {
                     return false;
                 }
-                return shouldTransformCard(source, ai, ph);
+                return shouldTransformCard(source, ai, ph) || "Always".equals(logic);
             } else {
                 final TargetRestrictions tgt = sa.getTargetRestrictions();
                 sa.resetTargets();
@@ -103,7 +112,7 @@ public class SetStateAi extends SpellAbilityAi {
                 }
 
                 for (final Card c : list) {
-                    if (shouldTransformCard(c, ai, ph)) {
+                    if (shouldTransformCard(c, ai, ph) || "Always".equals(logic)) {
                         sa.getTargets().add(c);
                         if (sa.getTargets().getNumTargeted() == tgt.getMaxTargets(source, sa)) {
                             break;
@@ -121,7 +130,7 @@ public class SetStateAi extends SpellAbilityAi {
                 if (list.isEmpty()) {
                     return false;
                 }
-                return shouldTurnFace(list.get(0), ai, ph);
+                return shouldTurnFace(list.get(0), ai, ph) || "Always".equals(logic);
             } else {
                 final TargetRestrictions tgt = sa.getTargetRestrictions();
                 sa.resetTargets();
@@ -134,7 +143,7 @@ public class SetStateAi extends SpellAbilityAi {
                 }
 
                 for (final Card c : list) {
-                    if (shouldTurnFace(c, ai, ph)) {
+                    if (shouldTurnFace(c, ai, ph) || "Always".equals(logic)) {
                         sa.getTargets().add(c);
                         if (sa.getTargets().getNumTargeted() == tgt.getMaxTargets(source, sa)) {
                             break;
@@ -158,9 +167,11 @@ public class SetStateAi extends SpellAbilityAi {
 
         // need a copy for evaluation
         Card transformed = CardUtil.getLKICopy(card);
-        transformed.getCurrentState().copyFrom(card, card.getAlternateState());
+        transformed.getCurrentState().copyFrom(card.getAlternateState(), true);
         transformed.updateStateForView();
 
+        // TODO: compareCards assumes that a creature will transform into a creature. Need to improve this
+        // for other things potentially transforming.
         return compareCards(card, transformed, ai, ph);
 
     }
@@ -248,4 +259,9 @@ public class SetStateAi extends SpellAbilityAi {
         // but for more cleaner way use Evaluate for check
         return valueCard <= valueTransformed;
     }
+
+    public boolean confirmAction(Player player, SpellAbility sa, PlayerActionConfirmMode mode, String message) {
+        // TODO: improve the AI for when it may want to transform something that's optional to transform
+        return true;
+    }
 }

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

@@ -1,8 +1,5 @@
 package forge.ai.ability;
 
-import forge.ai.ComputerUtil;
-import forge.ai.ComputerUtilAbility;
-import forge.ai.ComputerUtilCombat;
 import forge.ai.ComputerUtilMana;
 import forge.ai.SpellAbilityAi;
 import forge.game.Game;
@@ -25,7 +22,6 @@ public class StoreSVarAi extends SpellAbilityAi {
     @Override
     protected boolean canPlayAI(Player ai, SpellAbility sa) {
         final Card source = sa.getHostCard();
-        final String sourceName = ComputerUtilAbility.getAbilitySourceName(sa);
         final Game game = ai.getGame();
         final Combat combat = game.getCombat();
         final PhaseHandler ph = game.getPhaseHandler();
@@ -69,62 +65,7 @@ public class StoreSVarAi extends SpellAbilityAi {
             }
             return false;
         }
-        else if ("Tree of Redemption".equals(sourceName)) {
-            if (!ai.canGainLife())
-                return false;
 
-            // someone controls "Rain of Gore" or "Sulfuric Vortex", lifegain is bad in that case
-            if (game.isCardInPlay("Rain of Gore") || game.isCardInPlay("Sulfuric Vortex"))
-                return false;
-
-            // an opponent controls "Tainted Remedy", lifegain is bad in that case
-            for (Player op : ai.getOpponents()) {
-                if (op.isCardInPlay("Tainted Remedy"))
-                    return false;
-            }
-
-            if (ComputerUtil.waitForBlocking(sa) || ai.getLife() + 1 >= source.getNetToughness()
-                || (ai.getLife() > 5 && !ComputerUtilCombat.lifeInSeriousDanger(ai, ai.getGame().getCombat()))) {
-                return false;
-            }
-        }
-        else if ("Tree of Perdition".equals(sourceName)) {
-            boolean shouldDo = false;
-
-            if (ComputerUtil.waitForBlocking(sa))
-                return false;
-
-            for (Player op : ai.getOpponents()) {
-                // if oppoent can't be targeted, or it can't lose life, try another one
-                if (!op.canBeTargetedBy(sa) || !op.canLoseLife())
-                    continue;
-                // an opponent has more live than this toughness
-                if (op.getLife() + 1 >= source.getNetToughness()) {
-                    shouldDo = true;
-                } else {
-                    // opponent can't gain life, so "Tainted Remedy" should not work.
-                    if (!op.canGainLife()) {
-                        continue;
-                    } else if (ai.isCardInPlay("Tainted Remedy")) { // or AI has Tainted Remedy 
-                        shouldDo = true;
-                    } else {
-                        for (Player ally : ai.getAllies()) {
-                            // if an Ally has Tainted Remedy and opponent is also opponent of ally
-                            if (ally.isCardInPlay("Tainted Remedy") && op.isOpponentOf(ally))
-                                shouldDo = true;
-                        }
-                    }
-
-                }
-
-                if (shouldDo) {
-                    sa.getTargets().add(op);
-                    break;
-                }
-            }
-
-            return shouldDo;
-        }
 
         return true;
     }

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

@@ -5,7 +5,10 @@ import forge.ai.ComputerUtilCost;
 import forge.ai.SpellAbilityAi;
 import forge.game.ability.AbilityUtils;
 import forge.game.card.Card;
+import forge.game.card.CounterType;
 import forge.game.cost.Cost;
+import forge.game.cost.CostPart;
+import forge.game.cost.CostRemoveCounter;
 import forge.game.phase.PhaseHandler;
 import forge.game.phase.PhaseType;
 import forge.game.player.Player;
@@ -58,6 +61,20 @@ public class TapAi extends TapAiBase {
                 return false;
             }
         } else {
+            if ("TapForXCounters".equals(sa.getParam("AILogic"))) {
+                // e.g. Waxmane Baku
+                CounterType ctrType = CounterType.KI;
+                for (CostPart part : sa.getPayCosts().getCostParts()) {
+                    if (part instanceof CostRemoveCounter) {
+                        ctrType = ((CostRemoveCounter)part).counter;
+                        break;
+                    }
+                }
+
+                int numTargetable = Math.min(sa.getHostCard().getCounters(ctrType), ai.getOpponents().getCreaturesInPlay().size());
+                sa.setSVar("ChosenX", String.valueOf(numTargetable));
+            }
+
             sa.resetTargets();
             if (!tapPrefTargeting(ai, source, tgt, sa, false)) {
                 return false;

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

@@ -2,11 +2,12 @@ package forge.ai.ability;
 
 import com.google.common.base.Predicate;
 import com.google.common.collect.Iterables;
-
 import forge.ai.ComputerUtil;
+import forge.ai.ComputerUtilAbility;
 import forge.ai.ComputerUtilCard;
 import forge.ai.SpellAbilityAi;
 import forge.game.Game;
+import forge.game.ability.ApiType;
 import forge.game.card.Card;
 import forge.game.card.CardCollection;
 import forge.game.card.CardLists;
@@ -155,6 +156,11 @@ public abstract class TapAiBase extends SpellAbilityAi  {
             });
         }
 
+        //try to exclude things that will already be tapped due to something on stack or because something is
+        //already targeted in a parent or sub SA
+        CardCollection toExclude = ComputerUtilAbility.getCardsTargetedWithApi(ai, tapList, sa, ApiType.Tap);
+        tapList.removeAll(toExclude);
+
         if (tapList.isEmpty()) {
         	return false;
         }

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

@@ -21,7 +21,6 @@ import forge.game.zone.ZoneType;
 import forge.util.MyRandom;
 
 import java.util.List;
-import java.util.Random;
 
 public class TapAllAi extends SpellAbilityAi {
     @Override
@@ -64,8 +63,7 @@ public class TapAllAi extends SpellAbilityAi {
             }
         }
 
-        final Random r = MyRandom.getRandom();
-        if (r.nextFloat() > Math.pow(.6667, sa.getActivationsThisTurn())) {
+        if (MyRandom.getRandom().nextFloat() > Math.pow(.6667, sa.getActivationsThisTurn())) {
             return false;
         }
 
@@ -135,9 +133,8 @@ public class TapAllAi extends SpellAbilityAi {
             return true;
         }
 
-        final Random r = MyRandom.getRandom();
         boolean rr = false;
-        if (r.nextFloat() <= Math.pow(.6667, sa.getActivationsThisTurn())) {
+        if (MyRandom.getRandom().nextFloat() <= Math.pow(.6667, sa.getActivationsThisTurn())) {
             rr = true;
         }
 

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

@@ -8,7 +8,6 @@ import forge.game.spellability.TargetRestrictions;
 import forge.util.MyRandom;
 
 import java.util.List;
-import java.util.Random;
 
 public class TapOrUntapAi extends TapAiBase {
 
@@ -20,8 +19,7 @@ public class TapOrUntapAi extends TapAiBase {
         final TargetRestrictions tgt = sa.getTargetRestrictions();
         final Card source = sa.getHostCard();
 
-        final Random r = MyRandom.getRandom();
-        boolean randomReturn = r.nextFloat() <= Math.pow(.6667, sa.getActivationsThisTurn());
+        boolean randomReturn = MyRandom.getRandom().nextFloat() <= Math.pow(.6667, sa.getActivationsThisTurn());
 
         if (tgt == null) {
             // assume we are looking to tap human's stuff

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

@@ -1,27 +1,15 @@
 package forge.ai.ability;
 
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
-
 import com.google.common.base.Predicate;
 import com.google.common.collect.Iterables;
-
-import forge.ai.ComputerUtil;
-import forge.ai.ComputerUtilCard;
-import forge.ai.ComputerUtilMana;
-import forge.ai.SpellAbilityAi;
-import forge.ai.SpellApiToAi;
+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;
-import forge.game.card.CardCollection;
-import forge.game.card.CardFactory;
-import forge.game.card.CardLists;
-import forge.game.card.CardPredicates;
+import forge.game.card.*;
+import forge.game.card.token.TokenInfo;
 import forge.game.combat.Combat;
 import forge.game.cost.CostPart;
 import forge.game.cost.CostPutCounter;
@@ -38,6 +26,11 @@ 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;
 
 /**
  * <p>
@@ -233,7 +226,29 @@ public class TokenAi extends SpellAbilityAi {
                 }
             }
         }
-        return MyRandom.getRandom().nextFloat() < .8;
+
+        double chance = 1.0F; // 100%
+        boolean alwaysFromPW = true;
+        boolean alwaysOnOppAttack = true;
+
+        if (ai.getController().isAI()) {
+            AiController aic = ((PlayerControllerAi) ai.getController()).getAi();
+            chance = (double)aic.getIntProperty(AiProps.TOKEN_GENERATION_ABILITY_CHANCE) / 100;
+            alwaysFromPW = aic.getBooleanProperty(AiProps.TOKEN_GENERATION_ALWAYS_IF_FROM_PLANESWALKER);
+            alwaysOnOppAttack = aic.getBooleanProperty(AiProps.TOKEN_GENERATION_ALWAYS_IF_OPP_ATTACKS);
+        }
+
+        if (sa.getRestrictions() != null && sa.getRestrictions().isPwAbility() && alwaysFromPW) {
+            return true;
+        } else if (ai.getGame().getPhaseHandler().is(PhaseType.COMBAT_DECLARE_ATTACKERS)
+                && ai.getGame().getPhaseHandler().getPlayerTurn().isOpponentOf(ai)
+                && ai.getGame().getCombat() != null
+                && !ai.getGame().getCombat().getAttackers().isEmpty()
+                && alwaysOnOppAttack) {
+            return true;
+        }
+
+        return MyRandom.getRandom().nextFloat() <= chance;
     }
 
     /**
@@ -414,7 +429,7 @@ public class TokenAi extends SpellAbilityAi {
         
         final List<String> imageNames = new ArrayList<String>(1);
         if (tokenImage.equals("")) {
-            imageNames.add(PaperToken.makeTokenFileName(colorDesc.replace(" ", ""), tokenPower, tokenToughness, tokenName));
+            imageNames.add(PaperToken.makeTokenFileName(TextUtil.fastReplace(colorDesc, " ", ""), tokenPower, tokenToughness, tokenName));
         } else {
             imageNames.add(0, tokenImage);
         }
@@ -436,9 +451,9 @@ public class TokenAi extends SpellAbilityAi {
         }
         final String substitutedName = tokenName.equals("ChosenType") ? host.getChosenType() : tokenName;
         final String imageName = imageNames.get(MyRandom.getRandom().nextInt(imageNames.size()));
-        final CardFactory.TokenInfo tokenInfo = new CardFactory.TokenInfo(substitutedName, imageName,
+        final TokenInfo tokenInfo = new TokenInfo(substitutedName, imageName,
                 cost, substitutedTypes, tokenKeywords, finalPower, finalToughness);
-        Card token = CardFactory.makeOneToken(tokenInfo, ai);
+        Card token = tokenInfo.makeOneToken(ai);
 
         if (token == null) {
             return null;

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

@@ -16,7 +16,6 @@ import forge.util.MyRandom;
 
 import java.util.ArrayList;
 import java.util.List;
-import java.util.Random;
 
 public class UnattachAllAi extends SpellAbilityAi {
 
@@ -25,7 +24,6 @@ public class UnattachAllAi extends SpellAbilityAi {
      */
     @Override
     protected boolean canPlayAI(Player ai, SpellAbility sa) {
-        final Random r = MyRandom.getRandom();
         final Cost abCost = sa.getPayCosts();
         final Card source = sa.getHostCard();
 
@@ -34,7 +32,7 @@ public class UnattachAllAi extends SpellAbilityAi {
         }
 
         // prevent run-away activations - first time will always return true
-        boolean chance = r.nextFloat() <= .9;
+        boolean chance = MyRandom.getRandom().nextFloat() <= .9;
 
         // Attach spells always have a target
         final TargetRestrictions tgt = sa.getTargetRestrictions();

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

@@ -1,17 +1,21 @@
 package forge.ai.ability;
 
-import forge.ai.ComputerUtil;
-import forge.ai.ComputerUtilCard;
-import forge.ai.ComputerUtilCost;
-import forge.ai.SpellAbilityAi;
+import com.google.common.base.Predicate;
+import com.google.common.base.Predicates;
+import forge.ai.*;
+import forge.card.mana.ManaCostShard;
+import forge.game.Game;
 import forge.game.ability.AbilityUtils;
 import forge.game.ability.ApiType;
 import forge.game.card.Card;
 import forge.game.card.CardCollection;
 import forge.game.card.CardLists;
+import forge.game.card.CardPredicates;
 import forge.game.card.CardPredicates.Presets;
 import forge.game.cost.Cost;
 import forge.game.cost.CostTap;
+import forge.game.mana.ManaCostBeingPaid;
+import forge.game.phase.PhaseHandler;
 import forge.game.phase.PhaseType;
 import forge.game.player.Player;
 import forge.game.player.PlayerCollection;
@@ -25,9 +29,11 @@ public class UntapAi extends SpellAbilityAi {
     @Override
     protected boolean checkAiLogic(final Player ai, final SpellAbility sa, final String aiLogic) {
         final Card source = sa.getHostCard();
-        if ("EOT".equals(sa.getParam("AILogic")) && (source.getGame().getPhaseHandler().getNextTurn() != ai
+        if ("EOT".equals(aiLogic) && (source.getGame().getPhaseHandler().getNextTurn() != ai
                 || !source.getGame().getPhaseHandler().getPhase().equals(PhaseType.END_OF_TURN))) {
             return false;
+        } else if ("PoolExtraMana".equals(aiLogic)) {
+            return doPoolExtraManaLogic(ai, sa);
         }
 
         return !("Never".equals(aiLogic));
@@ -143,7 +149,16 @@ public class UntapAi extends SpellAbilityAi {
             return false;
         }
 
-        CardCollection untapList = CardLists.filter(list, Presets.TAPPED);
+        // For some abilities, it may be worth to target even an untapped card if we're targeting mostly for the subability
+        boolean targetUntapped = false;
+        if (sa.getSubAbility() != null) {
+            SpellAbility subSa = sa.getSubAbility();
+            if (subSa.getApi() == ApiType.RemoveFromCombat && "RemoveBestAttacker".equals(subSa.getParam("AILogic"))) {
+                targetUntapped = true;
+            }
+        }
+
+        CardCollection untapList = targetUntapped ? list : CardLists.filter(list, Presets.TAPPED);
         // filter out enchantments and planeswalkers, their tapped state doesn't
         // matter.
         final String[] tappablePermanents = {"Creature", "Land", "Artifact"};
@@ -167,12 +182,17 @@ public class UntapAi extends SpellAbilityAi {
             untapList.removeAll(toRemove);
         }
 
+        //try to exclude things that will already be untapped due to something on stack or because something is
+        //already targeted in a parent or sub SA
+        CardCollection toExclude = ComputerUtilAbility.getCardsTargetedWithApi(ai, untapList, sa, ApiType.Untap);
+        untapList.removeAll(toExclude);
+
         sa.resetTargets();
         while (sa.getTargets().getNumTargeted() < tgt.getMaxTargets(sa.getHostCard(), sa)) {
             Card choice = null;
 
             if (untapList.isEmpty()) {
-                // Animate untapped lands (Koth of the Hamer)
+                // Animate untapped lands (Koth of the Hammer)
                 if (sa.getSubAbility() != null && sa.getSubAbility().getApi() == ApiType.Animate && !list.isEmpty()
                         && ai.getGame().getPhaseHandler().getPhase().isBefore(PhaseType.COMBAT_DECLARE_ATTACKERS)) {
                     choice = ComputerUtilCard.getWorstPermanentAI(list, false, false, false, false);
@@ -184,17 +204,13 @@ public class UntapAi extends SpellAbilityAi {
                     break;
                 }
             } else {
-                //Untap Time Vault? - Yes please!
-                for (Card c : untapList) {
-                    if (c.getName().equals("Time Vault")) {
-                        choice = c;
-                        break;
-                    }
-                }
+                choice = detectPriorityUntapTargets(untapList);
+
                 if (choice == null) {
                     if (CardLists.getNotType(untapList, "Creature").isEmpty()) {
                         choice = ComputerUtilCard.getBestCreatureAI(untapList); // if only creatures take the best
-                    } else if (!sa.getPayCosts().hasManaCost() || sa.getRootAbility().isTrigger()) {
+                    } else if (!sa.getPayCosts().hasManaCost() || sa.getRootAbility().isTrigger()
+                            || "Always".equals(sa.getParam("AILogic"))) {
                         choice = ComputerUtilCard.getMostExpensivePermanentAI(untapList, sa, false);
                     }
                 }
@@ -319,4 +335,116 @@ public class UntapAi extends SpellAbilityAi {
         pl.addAll(ai.getAllies());
         return ComputerUtilCard.getBestAI(CardLists.filterControlledBy(list, pl));
     }
+
+    private static Card detectPriorityUntapTargets(final List<Card> untapList) {
+        // untap Time Vault or another broken card? - Yes please!
+        String[] priorityList = {"Time Vault", "Mana Vault", "Icy Manipulator", "Steel Overseer", "Grindclock", "Prototype Portal"};
+        for (String name : priorityList) {
+            for (Card c : untapList) {
+                if (c.getName().equals(name)) {
+                    return c;
+                }
+            }
+        }
+
+        // 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, CardPredicates.hasKeyword("CARDNAME doesn't untap during your untap step."));
+        if (!noAutoUntap.isEmpty()) {
+            return ComputerUtilCard.getBestAI(noAutoUntap);
+        }
+
+        return null;
+    }
+
+    private boolean doPoolExtraManaLogic(final Player ai, final SpellAbility sa) {
+        final Card source = sa.getHostCard();
+        final PhaseHandler ph = source.getGame().getPhaseHandler();
+        final Game game = ai.getGame();
+
+        if (sa.getHostCard().isTapped()) {
+            return true;
+        }
+
+        // Check if something is playable if we untap for an additional mana with this, then proceed
+        CardCollection inHand = CardLists.filter(ai.getCardsIn(ZoneType.Hand), Predicates.not(CardPredicates.Presets.LANDS));
+        // The AI is not very good at timing non-permanent spells this way, so filter them out
+        // (it may actually be possible to enable this for sorceries, but that'll need some canPlay shenanigans)
+        CardCollection playable = CardLists.filter(inHand, Presets.PERMANENTS);
+
+        CardCollection untappingCards = CardLists.filter(ai.getCardsIn(ZoneType.Battlefield), new Predicate<Card>() {
+            @Override
+            public boolean apply(Card card) {
+                boolean hasUntapLandLogic = false;
+                for (SpellAbility sa : card.getSpellAbilities()) {
+                    if ("PoolExtraMana".equals(sa.getParam("AILogic"))) {
+                        hasUntapLandLogic = true;
+                        break;
+                    }
+                }
+                return hasUntapLandLogic && card.isUntapped();
+            }
+        });
+
+        // TODO: currently limited to Main 2, somehow improve to let the AI use this SA at other time?
+        if (ph.is(PhaseType.MAIN2, ai)) {
+            for (Card c : playable) {
+                for (SpellAbility ab : c.getBasicSpells()) {
+                    if (!ComputerUtilMana.hasEnoughManaSourcesToCast(ab, ai)) {
+                        // TODO: Currently limited to predicting something that can be paid with any color,
+                        // can ideally be improved to work by color.
+                        ManaCostBeingPaid reduced = new ManaCostBeingPaid(ab.getPayCosts().getCostMana().getManaCostFor(ab), ab.getPayCosts().getCostMana().getRestiction());
+                        reduced.decreaseShard(ManaCostShard.GENERIC, untappingCards.size());
+                        if (ComputerUtilMana.canPayManaCost(reduced, ab, ai)) {
+                            CardCollection manaLandsTapped = CardLists.filter(ai.getCardsIn(ZoneType.Battlefield),
+                                    Predicates.and(Presets.LANDS_PRODUCING_MANA, Presets.TAPPED));
+                            manaLandsTapped = CardLists.filter(manaLandsTapped, new Predicate<Card>() {
+                                @Override
+                                public boolean apply(Card card) {
+                                    return card.isValid(sa.getParam("ValidTgts"), ai, source, null);
+                                }
+                            });
+
+                            if (!manaLandsTapped.isEmpty()) {
+                                // already have a tapped land, so agree to proceed with untapping it
+                                return true;
+                            }
+
+                            // pool one additional mana by tapping a land to try to ramp to something
+                            CardCollection manaLands = CardLists.filter(ai.getCardsIn(ZoneType.Battlefield),
+                                    Predicates.and(Presets.LANDS_PRODUCING_MANA, Presets.UNTAPPED));
+                            manaLands = CardLists.filter(manaLands, new Predicate<Card>() {
+                                @Override
+                                public boolean apply(Card card) {
+                                    return card.isValid(sa.getParam("ValidTgts"), ai, source, null);
+                                }
+                            });
+
+                            if (manaLands.isEmpty()) {
+                                // nothing to untap
+                                return false;
+                            }
+
+                            Card landToPool = manaLands.getFirst();
+                            SpellAbility manaAb = landToPool.getManaAbilities().getFirst();
+
+                            ComputerUtil.playNoStack(ai, manaAb, game);
+
+                            return true;
+                        }
+                    }
+                }
+            }
+        }
+
+        // no harm in doing this past declare blockers during the opponent's turn and right before our turn,
+        // maybe we'll serendipitously untap into something like a removal spell or burn spell that'll help
+        if (ph.getNextTurn() == ai
+                && (ph.is(PhaseType.COMBAT_DECLARE_BLOCKERS) || ph.getPhase().isAfter(PhaseType.COMBAT_DECLARE_BLOCKERS))) {
+            return true;
+        }
+
+        // haven't found any immediate playable options
+        return false;
+    }
+
 }

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

@@ -22,12 +22,13 @@ import forge.game.card.Card;
 import forge.game.card.CardFactory;
 import forge.game.card.CardFactoryUtil;
 import forge.game.card.CounterType;
+import forge.game.card.token.TokenInfo;
 import forge.game.combat.Combat;
+import forge.game.keyword.KeywordInterface;
 import forge.game.phase.PhaseHandler;
 import forge.game.phase.PhaseType;
 import forge.game.player.Player;
 import forge.game.player.RegisteredPlayer;
-import forge.game.spellability.AbilityActivated;
 import forge.game.spellability.SpellAbility;
 import forge.game.spellability.SpellAbilityRestriction;
 import forge.game.spellability.SpellAbilityStackInstance;
@@ -96,7 +97,7 @@ public class GameCopier {
 
         PhaseHandler origPhaseHandler = origGame.getPhaseHandler();
         Player newPlayerTurn = playerMap.get(origPhaseHandler.getPlayerTurn());
-        newGame.getPhaseHandler().devModeSet(origPhaseHandler.getPhase(), newPlayerTurn);
+        newGame.getPhaseHandler().devModeSet(origPhaseHandler.getPhase(), newPlayerTurn, origPhaseHandler.getTurn());
         newGame.getTriggerHandler().suppressMode(TriggerType.ChangesZone);
         for (Player p : newGame.getPlayers()) {
             ((PlayerZoneBattlefield) p.getZone(ZoneType.Battlefield)).setTriggers(false);
@@ -236,10 +237,8 @@ public class GameCopier {
     private static final boolean USE_FROM_PAPER_CARD = true;
     private Card createCardCopy(Game newGame, Player newOwner, Card c) {
         if (c.isToken() && !c.isEmblem()) {
-            String tokenStr = new CardFactory.TokenInfo(c).toString();
-            Card result = CardFactory.makeOneToken(CardFactory.TokenInfo.fromString(tokenStr), newOwner);
+            Card result = new TokenInfo(c).makeOneToken(newOwner);
             CardFactory.copyCopiableCharacteristics(c, result);
-            CardFactory.copyCopiableAbilities(c, result);
             return result;
         }
         if (USE_FROM_PAPER_CARD && !c.isEmblem()) {
@@ -263,15 +262,8 @@ public class GameCopier {
             newCard.addStaticAbility(stAb);
         }
         for (SpellAbility sa : c.getSpellAbilities()) {
-            SpellAbility saCopy;
-
-            if (sa instanceof AbilityActivated) {
-                saCopy = ((AbilityActivated)sa).getCopy();
-            } else {
-                saCopy = sa.copy();
-            }
+            SpellAbility saCopy = sa.copy(newCard, true);
             if (saCopy != null) {
-                saCopy.setHostCard(newCard);
                 newCard.addSpellAbility(saCopy);
             } else {
                 System.err.println(sa.toString());
@@ -306,7 +298,7 @@ public class GameCopier {
             newCard.setChangedCardTypes(c.getChangedCardTypesMap());
             newCard.setChangedCardKeywords(c.getChangedCardKeywords());
             // TODO: Is this correct? Does it not duplicate keywords from enchantments and such?
-            for (String kw : c.getHiddenExtrinsicKeywords())
+            for (KeywordInterface kw : c.getHiddenExtrinsicKeywords())
                 newCard.addHiddenExtrinsicKeyword(kw);
             newCard.setExtrinsicKeyword(Lists.newArrayList(c.getExtrinsicKeyword()));
             if (c.isTapped()) {

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

@@ -17,6 +17,7 @@ import forge.game.player.Player;
 import forge.game.spellability.SpellAbility;
 import forge.game.spellability.TargetChoices;
 import forge.game.spellability.TargetRestrictions;
+import forge.util.TextUtil;
 
 public class GameSimulator {
     public static boolean COPY_STACK = false;
@@ -136,7 +137,7 @@ public class GameSimulator {
             System.err.println(sa.getDescription() + "->" + desc);
         }
         // FIXME: This is a hack that makes testManifest pass - figure out why it's needed.
-        desc = desc.replace("Unmanifest {0}", "Unmanifest no cost");
+        desc = TextUtil.fastReplace(desc, "Unmanifest {0}", "Unmanifest no cost");
         for (SpellAbility cSa : hostCard.getSpellAbilities()) {
             if (desc.equals(cSa.getDescription())) {
                 return cSa;

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

@@ -1,30 +1,28 @@
 package forge.ai.simulation;
 
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-
 import forge.ai.AiPlayDecision;
 import forge.ai.ComputerUtil;
 import forge.ai.ComputerUtilAbility;
 import forge.ai.ComputerUtilCost;
 import forge.ai.ability.ChangeZoneAi;
+import forge.ai.ability.ExploreAi;
 import forge.ai.simulation.GameStateEvaluator.Score;
 import forge.game.Game;
+import forge.game.ability.ApiType;
 import forge.game.ability.effects.CharmEffect;
-import forge.game.card.Card;
-import forge.game.card.CardCollection;
-import forge.game.card.CardCollectionView;
-import forge.game.card.CardLists;
-import forge.game.card.CardPredicates;
-import forge.game.cost.Cost;
+import forge.game.card.*;
 import forge.game.phase.PhaseType;
 import forge.game.player.Player;
-import forge.game.spellability.Ability;
 import forge.game.spellability.AbilitySub;
+import forge.game.spellability.LandAbility;
 import forge.game.spellability.SpellAbility;
 import forge.game.spellability.SpellAbilityCondition;
 import forge.game.zone.ZoneType;
+import forge.util.TextUtil;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
 
 public class SpellAbilityPicker {
     private Game game;
@@ -116,18 +114,10 @@ public class SpellAbilityPicker {
         printPhaseInfo();
         SpellAbility sa = getPlannedSpellAbility(origGameScore, candidateSAs);
         if (sa != null) {
-            return transformSA(sa);
+            return sa;
         }
         createNewPlan(origGameScore, candidateSAs);
-        return transformSA(getPlannedSpellAbility(origGameScore, candidateSAs));
-    }
-
-    private SpellAbility transformSA(SpellAbility sa) {
-        if (sa instanceof PlayLandAbility) {
-            game.PLAY_LAND_SURROGATE.setHostCard(sa.getHostCard());
-            return game.PLAY_LAND_SURROGATE;
-        }
-        return sa;
+        return getPlannedSpellAbility(origGameScore, candidateSAs);
     }
 
     private Plan formulatePlanWithPhase(Score origGameScore, List<SpellAbility> candidateSAs, PhaseType phase) {
@@ -285,7 +275,7 @@ public class SpellAbilityPicker {
             saString = sa.toString();
             String cardName = sa.getHostCard().getName();
             if (!cardName.isEmpty()) {
-                saString = saString.replace(cardName, "<$>");
+                saString = TextUtil.fastReplace(saString, cardName, "<$>");
             }
             if (saString.length() > 40) {
                 saString = saString.substring(0, 40) + "...";
@@ -431,7 +421,11 @@ public class SpellAbilityPicker {
                 return card;
             }
         }
-        return ChangeZoneAi.chooseCardToHiddenOriginChangeZone(destination, origin, sa, fetchList, player2, decider);
+        if (sa.getApi() == ApiType.Explore) {
+            return ExploreAi.shouldPutInGraveyard(fetchList, decider);
+        } else {
+            return ChangeZoneAi.chooseCardToHiddenOriginChangeZone(destination, origin, sa, fetchList, player2, decider);
+        }
     }
 
     public CardCollectionView chooseSacrificeType(String type, SpellAbility ability, int amount) {
@@ -453,20 +447,11 @@ public class SpellAbilityPicker {
         return ComputerUtil.chooseSacrificeType(player, type, ability, ability.getTargetCard(), amount);
     }
 
-    public static class PlayLandAbility extends Ability {
+    public static class PlayLandAbility extends LandAbility {
         public PlayLandAbility(Card land) {
-            super(null, (Cost) null);
-            setHostCard(land);
+            super(land);
         }
 
-        @Override
-        public boolean canPlay() {
-            return true; //if this ability is added anywhere, it can be assumed that land can be played
-        }
-        @Override
-        public void resolve() {
-            throw new RuntimeException("This ability is intended to indicate \"land to play\" choice only");
-        }
         @Override
         public String toUnsuppressedString() { return "Play land " + (getHostCard() != null ? getHostCard().getName() : ""); }
     }

forge-ai/src/test/java/.gitignore

@@ -0,0 +1,4 @@
+# Ignore everything in this directory
+*
+# Except this file
+!.gitignore

forge-core/.classpath

@@ -2,8 +2,8 @@
 <classpath>
 	<classpathentry kind="src" output="target/classes" path="src/main/java"/>
 	<classpathentry kind="src" output="target/test-classes" path="src/test/java"/>
-	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.7"/>
 	<classpathentry kind="con" path="org.eclipse.m2e.MAVEN2_CLASSPATH_CONTAINER"/>
 	<classpathentry kind="con" path="org.testng.TESTNG_CONTAINER"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
 	<classpathentry kind="output" path="target/classes"/>
 </classpath>

forge-core/pom.xml

@@ -6,7 +6,7 @@
     <parent>
         <artifactId>forge</artifactId>
         <groupId>forge</groupId>
-        <version>1.6.2</version>
+        <version>1.6.9</version>
     </parent>
 
     <artifactId>forge-core</artifactId>
@@ -21,7 +21,7 @@
         <dependency>
             <groupId>org.apache.commons</groupId>
             <artifactId>commons-lang3</artifactId>
-            <version>3.3</version>
+            <version>3.7</version>
         </dependency>
     </dependencies>
 </project>

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

@@ -43,7 +43,7 @@ import java.util.zip.ZipFile;
 
 import forge.util.BuildInfo;
 import org.apache.commons.lang3.time.StopWatch;
-
+import com.google.common.io.Files;
 import forge.card.CardRules;
 import forge.util.FileUtil;
 import forge.util.Localizer;
@@ -71,6 +71,7 @@ public class CardStorageReader {
     }
 
     private static final String CARD_FILE_DOT_EXTENSION = ".txt";
+    private static final String UPCOMING = "upcoming";
 
     /** Default charset when loading from files. */
     public static final String DEFAULT_CHARSET_NAME = "UTF-8";
@@ -80,6 +81,7 @@ public class CardStorageReader {
 
     private final ProgressObserver progressObserver;
 
+    private final boolean loadingTokens;
     private transient File cardsfolder;
 
     private transient ZipFile zip;
@@ -91,6 +93,9 @@ public class CardStorageReader {
     public CardStorageReader(final String cardDataDir, final CardStorageReader.ProgressObserver progressObserver, boolean loadCardsLazily) {
         this.progressObserver = progressObserver != null ? progressObserver : CardStorageReader.ProgressObserver.emptyObserver;
         this.cardsfolder = new File(cardDataDir);
+
+        this.loadingTokens = cardDataDir.contains("token");
+
         this.loadCardsLazily = loadCardsLazily;
 
         // These read data for lightweight classes.
@@ -240,6 +245,9 @@ public class CardStorageReader {
         final Set<CardRules> result = new TreeSet<>(new Comparator<CardRules>() {
             @Override
             public int compare(final CardRules o1, final CardRules o2) {
+                if (loadingTokens) {
+                    return String.CASE_INSENSITIVE_ORDER.compare(o1.getNormalizedName(), o2.getNormalizedName());
+                }
                 return String.CASE_INSENSITIVE_ORDER.compare(o1.getName(), o2.getName());
             }
         });
@@ -252,7 +260,7 @@ public class CardStorageReader {
         if (!allFiles.isEmpty()) {
             int fileParts = zip == null ? NUMBER_OF_PARTS : 1 + NUMBER_OF_PARTS / 3;
             if (allFiles.size() < fileParts * 100) {
-                fileParts = allFiles.size() / 100; // to avoid creation of many threads for a dozen of files
+                fileParts = Math.max(1, allFiles.size() / 100); // to avoid creation of many threads for a dozen of files
             }
             final CountDownLatch cdlFiles = new CountDownLatch(fileParts);
             final List<Callable<List<CardRules>>> taskFiles = makeTaskListForFiles(allFiles, cdlFiles);
@@ -377,7 +385,7 @@ public class CardStorageReader {
                 continue;
             }
 
-            if (filename.equalsIgnoreCase("upcoming") && !BuildInfo.isDevelopmentVersion()) {
+            if (filename.equalsIgnoreCase(CardStorageReader.UPCOMING) && !BuildInfo.isDevelopmentVersion()) {
                 // If upcoming folder exits, only load these cards on development builds
                 continue;
             }
@@ -402,7 +410,7 @@ public class CardStorageReader {
             fileInputStream = new FileInputStream(file);
             reader.reset();
             final List<String> lines = readScript(fileInputStream);
-            return reader.readCard(lines);
+            return reader.readCard(lines, Files.getNameWithoutExtension(file.getName()));
         } catch (final FileNotFoundException ex) {
             throw new RuntimeException("CardReader : run error -- file not found: " + file.getPath(), ex);
         } finally {
@@ -430,7 +438,7 @@ public class CardStorageReader {
             zipInputStream = this.zip.getInputStream(entry);
             rulesReader.reset();
 
-            return rulesReader.readCard(readScript(zipInputStream));
+            return rulesReader.readCard(readScript(zipInputStream), Files.getNameWithoutExtension(entry.getName()));
         } catch (final IOException exn) {
             throw new RuntimeException(exn);
             // PM

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

@@ -3,6 +3,7 @@ package forge;
 import forge.item.*;
 import forge.util.FileUtil;
 import forge.util.ImageUtil;
+import forge.util.TextUtil;
 import org.apache.commons.lang3.StringUtils;
 
 import java.io.File;
@@ -104,27 +105,36 @@ public final class ImageKeys {
         // AE -> Ae and Ae -> AE for older cards with different file names 
         // on case-sensitive file systems
         if (filename.contains("Ae")) {
-            file = findFile(dir, filename.replace("Ae", "AE"));
+            file = findFile(dir, TextUtil.fastReplace(filename, "Ae", "AE"));
             if (file != null) { return file; }
         } else if (filename.contains("AE")) {
-            file = findFile(dir, filename.replace("AE", "Ae"));
+            file = findFile(dir, TextUtil.fastReplace(filename, "AE", "Ae"));
             if (file != null) { return file; }
         }
 
         // some S00 cards are really part of 6ED
         String s2kAlias = getSetFolder("S00");
         if (filename.startsWith(s2kAlias)) {
-            file = findFile(dir, filename.replace(s2kAlias, getSetFolder("6ED")));
+            file = findFile(dir, TextUtil.fastReplace(filename, s2kAlias, getSetFolder("6ED")));
             if (file != null) { return file; }
         }
 
-        // try without set name
         if (dir.equals(CACHE_TOKEN_PICS_DIR)) {
             int index = filename.lastIndexOf('_');
             if (index != -1) {
                 String setlessFilename = filename.substring(0, index);
+                String setCode = filename.substring(index + 1, filename.length());
+                // try with upper case set
+                file = findFile(dir, setlessFilename + "_" + setCode.toUpperCase());
+                if (file != null) { return file; }
+                // try without set name
                 file = findFile(dir, setlessFilename);
                 if (file != null) { return file; }
+                // if there's an art variant try without it
+                if (setlessFilename.matches(".*[0-9]*$")) {
+                    file = findFile(dir, setlessFilename.replaceAll("[0-9]*$", ""));
+                    if (file != null) { return file; }
+                }
             }
         } else if (filename.contains("/")) {
             String setlessFilename = filename.substring(filename.indexOf('/') + 1);