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

AFC edition tokens fixes

See merge request core-developers/forge!5055

.gitignore

@@ -17,6 +17,7 @@
 
 .vscode/settings.json
 .vscode/launch.json
+.factorypath
 
 
 # Ignore NetBeans config files
@@ -32,6 +33,8 @@ bin
 gen
 *.log
 
+# Ignore macOS Spotlight rubbish
+.DS_Store
 
 # TODO: specify what these ignores are for (releasing?)
 

README.md

@@ -1,15 +1,15 @@
 # Forge
 
-Gitlab repo is found [here](https://git.cardforge.org/core-developers/forge).
+[Official GitLab repo](https://git.cardforge.org/core-developers/forge).
 
-Dev instructions here: [Getting Started](https://www.slightlymagic.net/wiki/Forge:How_to_Get_Started_Developing_Forge) (Somewhat outdated)
+Dev instructions here: [Getting Started](https://git.cardforge.org/core-developers/forge/-/wikis/(SM-autoconverted)-how-to-get-started-developing-forge) (Somewhat outdated)
 
 Discord channel [here](https://discordapp.com/channels/267367946135928833/267742313390931968)
 
-# Requirements / Tools
+## Requirements / Tools
 
-- Java IDE such as IntelliJ or Eclipse
-- Java JDK 8 or later
+- you favourite Java IDE (IntelliJ, Eclipse, VSCodium, Emacs, Vi...)
+- Java JDK 8 or later (some IDEs such as Eclipse require JDK11+, whereas the Android build currently only works with JDK8)
 - Git
 - Git client (optional)
 - Maven
@@ -18,7 +18,7 @@ Discord channel [here](https://discordapp.com/channels/267367946135928833/267742
 - Android SDK (optional: for Android releases)
 - RoboVM (optional: for iOS releases) (TBD: Current status of support by libgdx)
 
-# Project Quick Setup
+## Project Quick Setup
 
 - Log in to gitlab with your user account and fork the project.
 
@@ -26,11 +26,11 @@ Discord channel [here](https://discordapp.com/channels/267367946135928833/267742
 
 - Go to the project location on your machine.  Run Maven to download all dependencies and build a snapshot.  Example for Windows & Linux: `mvn -U -B clean -P windows-linux install`
 
-# Eclipse
+## Eclipse
 
 Eclipse includes Maven integration so a separate install is not necessary.  For other IDEs, your mileage may vary.
 
-## Project Setup
+### Project Setup
 
 - Follow the instructions for cloning from Gitlab.  You'll need a Gitlab account setup and an SSH key defined.
 
@@ -55,9 +55,9 @@ Eclipse includes Maven integration so a separate install is not necessary.  For
 
 - Once everything builds, all errors should disappear.  You can now advance to Project launch.
 
-## Project Launch
+### Project Launch
 
-### Desktop
+#### Desktop
 
 This is the standard configuration used for releasing to Windows / Linux / MacOS.
 
@@ -65,7 +65,7 @@ This is the standard configuration used for releasing to Windows / Linux / MacOS
 
 - The familiar Forge splash screen, etc. should appear.  Enjoy!
 
-### Mobile (Desktop dev)
+#### Mobile (Desktop dev)
 
 This is the configuration used for doing mobile development using the Windows / Linux / MacOS front-end.  Knowledge of libgdx is helpful here.
 
@@ -73,24 +73,24 @@ This is the configuration used for doing mobile development using the Windows /
 
 - A view similar to a mobile phone should appear.  Enjoy!
 
-## Eclipse / Android SDK Integration
+### Eclipse / Android SDK Integration
 
 Google no longer supports Android SDK releases for Eclipse.  That said, it is still possible to build and debug Android platforms.
 
-### Android SDK
+#### Android SDK
 
 Reference SO for obtaining a specific release: https://stackoverflow.com/questions/27043522/where-can-i-download-an-older-version-of-the-android-sdk
 
-#### Windows 
+##### Windows
 
 Download the following archived version of the Android SDK: http://dl-ssl.google.com/android/repository/tools_r25.2.3-windows.zip. Install it somewhere on your machine.  This is referenced
 in the following instructions as your 'Android SDK Install' path.
 
-#### Linux / Mac OSX
+##### Linux / Mac OSX
 
 TBD
 
-### Android Plugin for Eclipse
+#### Android Plugin for Eclipse
 
 Google's last plugin release does not work completely with target's running Android 7.0 or later.  Download the ADT-24.2.0-20160729.zip plugin
 from: https://github.com/khaledev/ADT/releases
@@ -98,25 +98,24 @@ from: https://github.com/khaledev/ADT/releases
 In Eclipse go to: Help > Install New Software... > Add > Name: ADT Update, Click on the "Archive:" button and navigate to the downloaded ADT-24.2.0-20160729.zip file > Add.  Install all "Developer Tools".  Eclipse
 should restart and prompt you to run the SDK Manager.  Launch it and continue to the next steps below.
 
-### Android Platform
+#### Android Platform
 
 In Eclipse, if the SDK Manager is not already running, go to Window > Android SDK Manager.  Install the following options / versions:
 
 - Android SDK Build-tools 26.0.1
-- Android 7.1.1 (API 25) SDK Platform
-- Google USB Driver 11
+- Android 8.0.0 (API 26) SDK Platform
+- Google USB Driver (in case your phone is not detected by ADB)
 
 Note that this will populate additional tools in the Android SDK install path extracted above.
 
-### Proguard update
+#### Proguard update
 
-The Proguard included with the Android SDK Build-tools is outdated and does not work with Java 1.8.  Download Proguard 6.0.3 from https://sourceforge.net/projects/proguard/files/proguard/6.0/.  
+The Proguard included with the Android SDK Build-tools is outdated and does not work with Java 1.8.  Download Proguard 6.0.3 or later (last tested with 7.0.1) from https://github.com/Guardsquare/proguard
+- Go to the Android SDK install path.  Rename the tools/proguard/ path to tools/proguard-4.7/.
 
-- Go to the Android SDK install path.  Rename the tools/proguard/ path to tools/proguard4.7/.
+- Extract your Proguard version to the Android SDK install path under tools/.  You will need to either rename the dir proguard-<your-version> to proguard/ or, if your filesystem supports it, use a symbolic link (the later is highly recommended), such as `ln -s proguard proguard-<your-version>`.
 
-- Extract Proguard 6.0.3 to the Android SDK install path under tools/.  You will need to rename the dir proguard6.0.3/ to proguard/.
-
-### Android Build
+#### Android Build
 
 The Eclipse plug-ins do NOT support building things for Android.  They do however allow you to use the debugger so you can still set breakpoints and trace
 things out.  The steps below show how to generate a debug Android build.
@@ -135,7 +134,7 @@ things out.  The steps below show how to generate a debug Android build.
 
 Assuming you got this far, you should have an Android forge-android-[version].apk in the forge-gui-android/target path.
 
-### Android Deploy
+#### Android Deploy
 
 You'll need to have the Android SDK install path platform-tools/ path in your command search path to easily deploy builds.
 
@@ -149,14 +148,14 @@ You'll need to have the Android SDK install path platform-tools/ path in your co
 
 - Install the new apk: `adb install forge-android-[version].apk`
 
-### Android Debugging
+#### Android Debugging
 
 Assuming the apk is installed, launch it from the device.
 
 In Eclipse, launch the DDMS.  Window > Perspective > Open Perspective > Other... > DDMS.  You should see the forge app in the list.  Highlight the app, click on the green debug button and a
 green debug button should appear next to the app's name.  You can now set breakpoints and step through the source code.
 
-## Windows / Linux SNAPSHOT build
+### Windows / Linux SNAPSHOT build
 
 SNAPSHOT builds can be built via the Maven integration in Eclipse.
 
@@ -167,19 +166,19 @@ SNAPSHOT builds can be built via the Maven integration in Eclipse.
 
 The resulting snapshot will be found at: forge-gui-desktop/target/forge-gui-desktop-[version]-SNAPSHOT
 
-# IntelliJ
+## IntelliJ
 
-Quick start guide for [setting up the Forge project within IntelliJ](https://git.cardforge.org/core-developers/forge/wikis/intellij-setup).
+Quick start guide for [setting up the Forge project within IntelliJ](https://git.cardforge.org/core-developers/forge/-/wikis/Development/intellij-setup).
 
-# Card Scripting
+## Card Scripting
 
-Visit [this page](https://www.slightlymagic.net/wiki/Forge_API) for information on scripting.
+Visit [this page](https://git.cardforge.org/core-developers/forge/-/wikis/Card-scripting-API/Card-scripting-API) for information on scripting.
 
 Card scripting resources are found in the forge-gui/res/ path.
 
-# General Notes
+## General Notes
 
-## Project Hierarchy
+### Project Hierarchy
 
 Forge is divided into 4 primary projects with additional projects that target specific platform releases.  The primary projects are:
 
@@ -196,35 +195,34 @@ The platform-specific projects are:
 - forge-gui-mobile
 - forge-gui-mobile-dev
 
-### forge-ai
+#### forge-ai
 
-### forge-core
+#### forge-core
 
-### forge-game
+#### forge-game
 
-### forge-gui
+#### forge-gui
 
 The forge-gui project includes the scripting resource definitions in the res/ path.
 
-### forge-gui-android
+#### forge-gui-android
 
 Libgdx-based backend targeting Android.  Requires Android SDK and relies on forge-gui-mobile for GUI logic.
 
-### forge-gui-desktop
+#### forge-gui-desktop
 
 Java Swing based GUI targeting desktop machines.
 
 Screen layout and game logic revolving around the GUI is found here.  For example, the overlay arrows (when enabled) that indicate attackers and blockers, or the targets of the stack are defined and drawn by this.
 
-### forge-gui-ios
+#### forge-gui-ios
 
 Libgdx-based backend targeting iOS.  Relies on forge-gui-mobile for GUI logic.
 
-### forge-gui-mobile
+#### forge-gui-mobile
 
 Mobile GUI game logic utilizing [libgdx](https://libgdx.badlogicgames.com/) library.  Screen layout and game logic revolving around the GUI for the mobile platforms is found here.
 
-### forge-gui-mobile-dev
+#### forge-gui-mobile-dev
 
 Libgdx backend for desktop development for mobile backends.  Utilizes LWJGL.  Relies on forge-gui-mobile for GUI logic.
- 

forge-ai/pom.xml

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

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

@@ -18,6 +18,7 @@
 package forge.ai;
 
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.List;
 
 import com.google.common.base.Predicate;
@@ -43,6 +44,7 @@ import forge.game.combat.GlobalAttackRestrictions;
 import forge.game.keyword.Keyword;
 import forge.game.keyword.KeywordInterface;
 import forge.game.player.Player;
+import forge.game.player.PlayerPredicates;
 import forge.game.spellability.SpellAbility;
 import forge.game.trigger.Trigger;
 import forge.game.trigger.TriggerType;
@@ -54,7 +56,6 @@ import forge.util.TextUtil;
 import forge.util.collect.FCollectionView;
 
 
-//doesHumanAttackAndWin() uses the global variable AllZone.getComputerPlayer()
 /**
  * <p>
  * ComputerUtil_Attack2 class.
@@ -91,7 +92,7 @@ public class AiAttackController {
 
     public AiAttackController(final Player ai, boolean nextTurn) {
         this.ai = ai;
-        this.defendingOpponent = choosePreferredDefenderPlayer();
+        this.defendingOpponent = choosePreferredDefenderPlayer(ai);
         this.oppList = getOpponentCreatures(this.defendingOpponent);
         this.myList = ai.getCreaturesInPlay();
         this.attackers = new ArrayList<>();
@@ -107,7 +108,7 @@ public class AiAttackController {
 
     public AiAttackController(final Player ai, Card attacker) {
         this.ai = ai;
-        this.defendingOpponent = choosePreferredDefenderPlayer();       
+        this.defendingOpponent = choosePreferredDefenderPlayer(ai);       
         this.oppList = getOpponentCreatures(this.defendingOpponent);
         this.myList = ai.getCreaturesInPlay();
         this.attackers = new ArrayList<>();
@@ -156,13 +157,12 @@ public class AiAttackController {
     }
 
     /** Choose opponent for AI to attack here. Expand as necessary. */
-    private Player choosePreferredDefenderPlayer() {
-        Player defender = ai.getWeakestOpponent(); //Gets opponent with the least life
+    public static Player choosePreferredDefenderPlayer(Player ai) {
+        Player defender = ai.getWeakestOpponent(); //Concentrate on opponent within easy kill range
 
-        if (defender.getLife() < 8) { //Concentrate on opponent within easy kill range
-            return defender;
-        } else { //Otherwise choose a random opponent to ensure no ganging up on players
-            defender = ai.getOpponents().get(MyRandom.getRandom().nextInt(ai.getOpponents().size()));
+        if (defender.getLife() > 8) { //Otherwise choose a random opponent to ensure no ganging up on players
+            // TODO should we cache the random for each turn? some functions like shouldPumpCard base their decisions on the assumption who will be attacked
+            return ai.getOpponents().get(MyRandom.getRandom().nextInt(ai.getOpponents().size()));
         }
         return defender;
     }
@@ -393,7 +393,7 @@ public class AiAttackController {
 
         //Calculate the amount of creatures necessary
         for (int i = 0; i < list.size(); i++) {
-            if (!this.doesHumanAttackAndWin(ai, i)) {
+            if (!doesHumanAttackAndWin(ai, i)) {
                 blockersNeeded = i;
                 break;
             }
@@ -413,12 +413,10 @@ public class AiAttackController {
 
         final Player opp = this.defendingOpponent;
 
-        // Increase the total number of blockers needed by 1 if Finest Hour in
-        // play
+        // Increase the total number of blockers needed by 1 if Finest Hour in play
         // (human will get an extra first attack with a creature that untaps)
         // In addition, if the computer guesses it needs no blockers, make sure
-        // that
-        // it won't be surprised by Exalted
+        // that it won't be surprised by Exalted
         final int humanExaltedBonus = opp.countExaltedBonus();
 
         if (humanExaltedBonus > 0) {
@@ -428,8 +426,7 @@ public class AiAttackController {
                 // total attack = biggest creature + exalted, *2 if Rafiq is in play
                 int humanBasePower = getAttack(this.oppList.get(0)) + humanExaltedBonus;
                 if (finestHour) {
-                    // For Finest Hour, one creature could attack and get the
-                    // bonus TWICE
+                    // For Finest Hour, one creature could attack and get the bonus TWICE
                     humanBasePower = humanBasePower + humanExaltedBonus;
                 }
                 final int totalExaltedAttack = opp.isCardInPlay("Rafiq of the Many") ? 2 * humanBasePower
@@ -450,7 +447,6 @@ public class AiAttackController {
         return notNeededAsBlockers;
     }
 
-    // this uses a global variable, which isn't perfect
     public final boolean doesHumanAttackAndWin(final Player ai, final int nBlockingCreatures) {
         int totalAttack = 0;
         int totalPoison = 0;
@@ -624,7 +620,7 @@ public class AiAttackController {
         int totalCombatDamage = ComputerUtilCombat.sumDamageIfUnblocked(unblockedAttackers, opp) + trampleDamage;
         int totalPoisonDamage = ComputerUtilCombat.sumPoisonIfUnblocked(unblockedAttackers, opp);
 
-        if (totalCombatDamage + ComputerUtil.possibleNonCombatDamage(ai) >= opp.getLife()
+        if (totalCombatDamage + ComputerUtil.possibleNonCombatDamage(ai, opp) >= opp.getLife()
                 && !((opp.cantLoseForZeroOrLessLife() || ai.cantWin()) && opp.getLife() < 1)) {
             return true;
         }
@@ -641,7 +637,7 @@ public class AiAttackController {
         if (defs.size() == 1) {
             return defs.getFirst();
         }
-        Player prefDefender = (Player) (defs.contains(this.defendingOpponent) ? this.defendingOpponent : defs.get(0));
+        GameEntity prefDefender = defs.contains(this.defendingOpponent) ? this.defendingOpponent : defs.get(0);
 
         // Attempt to see if there's a defined entity that must be attacked strictly this turn...
         GameEntity entity = ai.getMustAttackEntityThisTurn();
@@ -665,7 +661,8 @@ public class AiAttackController {
             // 2. attack planeswalkers
             List<Card> pwDefending = c.getDefendingPlaneswalkers();
             if (!pwDefending.isEmpty()) {
-                return pwDefending.get(0);
+                final Card pwNearUlti = ComputerUtilCard.getBestPlaneswalkerToDamage(pwDefending);
+                return pwNearUlti != null ? pwNearUlti : ComputerUtilCard.getBestPlaneswalkerAI(pwDefending);
             } else {
                 return prefDefender;
             }
@@ -682,7 +679,6 @@ public class AiAttackController {
      * @return a {@link forge.game.combat.Combat} object.
      */
     public final void declareAttackers(final Combat combat) {
-
         if (this.attackers.isEmpty()) {
             return;
         }
@@ -702,14 +698,14 @@ public class AiAttackController {
             tradeIfLowerLifePressure = aic.getBooleanProperty(AiProps.RANDOMLY_ATKTRADE_ONLY_ON_LOWER_LIFE_PRESSURE);
         }
 
-        final boolean bAssault = this.doAssault(ai);
+        final boolean bAssault = doAssault(ai);
         // TODO: detect Lightmine Field by presence of a card with a specific trigger
         final boolean lightmineField = ComputerUtilCard.isPresentOnBattlefield(ai.getGame(), "Lightmine Field");
         // TODO: detect Season of the Witch by presence of a card with a specific trigger
         final boolean seasonOfTheWitch = ComputerUtilCard.isPresentOnBattlefield(ai.getGame(), "Season of the Witch");
 
         // Determine who will be attacked
-        GameEntity defender = this.chooseDefender(combat, bAssault);
+        GameEntity defender = chooseDefender(combat, bAssault);
         List<Card> attackersLeft = new ArrayList<>(this.attackers);
 
         // TODO probably use AttackConstraints instead of only GlobalAttackRestrictions?
@@ -717,7 +713,7 @@ public class AiAttackController {
         int attackMax = restrict.getMax();
         if (attackMax == -1) {
             // check with the local limitations vs. the chosen defender
-            attackMax = ComputerUtilCombat.getMaxAttackersFor(defender);
+            attackMax = restrict.getDefenderMax().get(defender) == null ? -1 : restrict.getDefenderMax().get(defender);
         }
 
         if (attackMax == 0) {
@@ -777,7 +773,6 @@ public class AiAttackController {
             return;
         }
 
-
         if (bAssault) {
             if (LOG_AI_ATTACKS)
                 System.out.println("Assault");
@@ -852,7 +847,6 @@ public class AiAttackController {
             return;
         }
 
-
         // *******************
         // Evaluate the creature forces
         // *******************
@@ -919,7 +913,7 @@ public class AiAttackController {
         // find the potential damage ratio the AI can cause
         double humanLifeToDamageRatio = 1000000;
         if (candidateUnblockedDamage > 0) {
-            humanLifeToDamageRatio = (double) (opp.getLife() - ComputerUtil.possibleNonCombatDamage(ai)) / candidateUnblockedDamage;
+            humanLifeToDamageRatio = (double) (opp.getLife() - ComputerUtil.possibleNonCombatDamage(ai, opp)) / candidateUnblockedDamage;
         }
 
         // determine if the ai outnumbers the player
@@ -936,12 +930,9 @@ public class AiAttackController {
 
         // *********************
         // if outnumber and superior ratio work out whether attritional all out
-        // attacking will work
-        // attritional attack will expect some creatures to die but to achieve
-        // victory by sheer weight
-        // of numbers attacking turn after turn. It's not calculate very
-        // carefully, the accuracy
-        // can probably be improved
+        // attacking will work  attritional attack will expect some creatures to die but to achieve
+        // victory by sheer weight of numbers attacking turn after turn. It's not calculate very
+        // carefully, the accuracy can probably be improved
         // *********************
         boolean doAttritionalAttack = false;
         // get list of attackers ordered from low power to high
@@ -975,7 +966,6 @@ public class AiAttackController {
                 doAttritionalAttack = true;
             }
         }
-        // System.out.println(doAttritionalAttack + " = do attritional attack");
         // *********************
         // end attritional attack calculation
         // *********************
@@ -1025,11 +1015,9 @@ public class AiAttackController {
         // end see how long until unblockable attackers will be fatal
         // *****************
 
-
         // decide on attack aggression based on a comparison of forces, life
-        // totals and other considerations
-        // some bad "magic numbers" here, TODO replace with nice descriptive
-        // variable names
+        // totals and other considerations some bad "magic numbers" here
+        // TODO replace with nice descriptive variable names
         if (ratioDiff > 0 && doAttritionalAttack) {
             this.aiAggression = 5; // attack at all costs
         } else if ((ratioDiff >= 1 && this.attackers.size() > 1 && (humanLifeToDamageRatio < 2 || outNumber > 0))
@@ -1105,17 +1093,18 @@ public class AiAttackController {
                     // if enough damage: switch to next planeswalker or player
                     if (damage >= pw.getCounters(CounterEnumType.LOYALTY)) {
                         List<Card> pwDefending = combat.getDefendingPlaneswalkers();
-                        boolean found = false;
                         // look for next planeswalker
-                        for (Card walker : pwDefending) {
-                            if (combat.getAttackersOf(walker).isEmpty()) {
-                                defender = walker;
-                                found = true;
-                                break;
+                        for (Card walker : Lists.newArrayList(pwDefending)) {
+                            if (!combat.getAttackersOf(walker).isEmpty()) {
+                                pwDefending.remove(walker);
                             }
                         }
-                        if (!found) {
-                            defender = combat.getDefendingPlayers().get(0);
+                        if (pwDefending.isEmpty()) {
+                            defender = Collections.min(Lists.newArrayList(combat.getDefendingPlayers()), PlayerPredicates.compareByLife());
+                        }
+                        else {
+                            final Card pwNearUlti = ComputerUtilCard.getBestPlaneswalkerToDamage(pwDefending);
+                            defender = pwNearUlti != null ? pwNearUlti : ComputerUtilCard.getBestPlaneswalkerAI(pwDefending);
                         }
                     }
                 }
@@ -1224,9 +1213,8 @@ public class AiAttackController {
         }
 
         // look at the attacker in relation to the blockers to establish a
-        // number of factors about the attacking
-        // context that will be relevant to the attackers decision according to
-        // the selected strategy
+        // number of factors about the attacking  context that will be relevant
+        // to the attackers decision according to the selected strategy
         for (final Card defender : validBlockers) {
             // if both isWorthLessThanAllKillers and canKillAllDangerous are false there's nothing more to check
             if (isWorthLessThanAllKillers || canKillAllDangerous || numberOfPossibleBlockers < 2) {
@@ -1300,14 +1288,11 @@ public class AiAttackController {
         }
 
         if (numberOfPossibleBlockers > 2 
-                || (numberOfPossibleBlockers >= 1 && CombatUtil.canAttackerBeBlockedWithAmount(attacker, 1, combat))
-                || (numberOfPossibleBlockers == 2 && CombatUtil.canAttackerBeBlockedWithAmount(attacker, 2, combat))) {
+                || (numberOfPossibleBlockers >= 1 && CombatUtil.canAttackerBeBlockedWithAmount(attacker, 1, this.defendingOpponent))
+                || (numberOfPossibleBlockers == 2 && CombatUtil.canAttackerBeBlockedWithAmount(attacker, 2, this.defendingOpponent))) {
             canBeBlocked = true;
         }
-        /*System.out.println(attacker + " canBeKilledByOne: " + canBeKilledByOne + " canKillAll: "
-                + canKillAll + " isWorthLessThanAllKillers: " + isWorthLessThanAllKillers + " canBeBlocked: " + canBeBlocked);*/
-        // decide if the creature should attack based on the prevailing strategy
-        // choice in aiAggression
+        // decide if the creature should attack based on the prevailing strategy choice in aiAggression
         switch (this.aiAggression) {
         case 6: // Exalted: expecting to at least kill a creature of equal value or not be blocked
             if ((canKillAll && isWorthLessThanAllKillers) || !canBeBlocked) {
@@ -1373,8 +1358,7 @@ public class AiAttackController {
             }
 
             // if card has a Exert Trigger which would target,
-            // but there are no creatures it can target, no need to exert with
-            // it
+            // but there are no creatures it can target, no need to exert with it
             boolean missTarget = false;
             for (Trigger t : c.getTriggers()) {
                 if (!TriggerType.Exerted.equals(t.getMode())) {
@@ -1442,7 +1426,7 @@ public class AiAttackController {
     public String toProtectAttacker(SpellAbility sa) {
         //AiAttackController is created with the selected attacker as the only entry in "attackers"
         if (sa.getApi() != ApiType.Protection || oppList.isEmpty() || getPossibleBlockers(oppList, attackers).isEmpty()) {
-            return null;    //not protection sa or attacker is already unblockable
+            return null; //not protection sa or attacker is already unblockable
         }
         final List<String> choices = ProtectEffect.getProtectionList(sa);
         String color = ComputerUtilCard.getMostProminentColor(getPossibleBlockers(oppList, attackers)), artifact = null;
@@ -1452,7 +1436,7 @@ public class AiAttackController {
         if (!choices.contains(color)) {
             color = null;
         }
-        for (Card c : oppList) {   //find a blocker that ignores the currently selected protection
+        for (Card c : oppList) { //find a blocker that ignores the currently selected protection
             if (artifact != null && !c.isArtifact()) {
                 artifact = null;
             }
@@ -1485,7 +1469,7 @@ public class AiAttackController {
                     break;
                 }
             }
-            if (color == null && artifact == null) {  //nothing can make the attacker unblockable
+            if (color == null && artifact == null) { //nothing can make the attacker unblockable
                 return null;
             }
         }
@@ -1563,4 +1547,4 @@ public class AiAttackController {
         return true;
     }
 
-} // end class ComputerUtil_Attack2
+}

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

@@ -180,11 +180,9 @@ public class AiBlockController {
 
     // Good Blocks means a good trade or no trade
     private void makeGoodBlocks(final Combat combat) {
-
         List<Card> currentAttackers = new ArrayList<>(attackersLeft);
 
         for (final Card attacker : attackersLeft) {
-
             if (attacker.hasStartOfKeyword("CantBeBlockedByAmount LT")
                     || attacker.hasKeyword("CARDNAME can't be blocked unless all creatures defending player controls block it.")
                     || attacker.hasKeyword(Keyword.MENACE)) {
@@ -192,7 +190,6 @@ public class AiBlockController {
             }
 
             Card blocker = null;
-
             final List<Card> blockers = getPossibleBlockers(combat, attacker, blockersLeft, true);
 
             final List<Card> safeBlockers = getSafeBlockers(combat, attacker, blockers);
@@ -305,7 +302,6 @@ public class AiBlockController {
             }
 
             Card blocker = null;
-
             final List<Card> blockers = getPossibleBlockers(combat, attacker, blockersLeft, true);
 
             for (Card b : blockers) {
@@ -366,10 +362,9 @@ public class AiBlockController {
                         final int damageNeeded = ComputerUtilCombat.getDamageToKill(attacker)
                                 + ComputerUtilCombat.predictToughnessBonusOfAttacker(attacker, blocker, combat, false);
                         // if the total damage of the blockgang was not enough
-                        // without but is enough with this blocker finish the
-                        // blockgang
+                        // without but is enough with this blocker finish the blockgang
                         if (ComputerUtilCombat.totalFirstStrikeDamageOfBlockers(attacker, blockGang) < damageNeeded
-                                || CombatUtil.needsBlockers(attacker) > blockGang.size()) {
+                                || CombatUtil.getMinNumBlockersForAttacker(attacker, ai) > blockGang.size()) {
                             blockGang.add(blocker);
                             if (ComputerUtilCombat.totalFirstStrikeDamageOfBlockers(attacker, blockGang) >= damageNeeded) {
                                 currentAttackers.remove(attacker);
@@ -407,7 +402,7 @@ public class AiBlockController {
             boolean foundDoubleBlock = false; // if true, a good double block is found
 
             // AI can't handle good blocks with more than three creatures yet
-            if (CombatUtil.needsBlockers(attacker) > (considerTripleBlock ? 3 : 2)) {
+            if (CombatUtil.getMinNumBlockersForAttacker(attacker, ai) > (considerTripleBlock ? 3 : 2)) {
                 continue;
             }
 
@@ -444,7 +439,7 @@ public class AiBlockController {
                 final int addedValue = ComputerUtilCard.evaluateCreature(blocker);
                 final int damageNeeded = ComputerUtilCombat.getDamageToKill(attacker)
                         + ComputerUtilCombat.predictToughnessBonusOfAttacker(attacker, blocker, combat, false);
-                if ((damageNeeded > currentDamage || CombatUtil.needsBlockers(attacker) > blockGang.size())
+                if ((damageNeeded > currentDamage || CombatUtil.getMinNumBlockersForAttacker(attacker, ai) > blockGang.size())
                         && !(damageNeeded > currentDamage + additionalDamage)
                         // The attacker will be killed
                         && (absorbedDamage2 + absorbedDamage > attacker.getNetCombatDamage()
@@ -454,8 +449,7 @@ public class AiBlockController {
                         || (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
-                    // more than 1
+                    // this is needed for attackers that can't be blocked by more than 1
                     currentAttackers.remove(attacker);
                     combat.addBlocker(attacker, blocker);
                     if (CombatUtil.canBlock(attacker, leader, combat)) {
@@ -496,7 +490,7 @@ public class AiBlockController {
                     final int addedValue3 = ComputerUtilCard.evaluateCreature(secondBlocker);
                     final int netCombatDamage = attacker.getNetCombatDamage();
 
-                    if ((damageNeeded > currentDamage || CombatUtil.needsBlockers(attacker) > blockGang.size())
+                    if ((damageNeeded > currentDamage || CombatUtil.getMinNumBlockersForAttacker(attacker, ai) > blockGang.size())
                             && !(damageNeeded > currentDamage + additionalDamage2 + additionalDamage3)
                             // The attacker will be killed
                             && ((absorbedDamage2 + absorbedDamage > netCombatDamage && absorbedDamage3 + absorbedDamage > netCombatDamage
@@ -510,8 +504,7 @@ public class AiBlockController {
                             // or life is in danger
                             && CombatUtil.canBlock(attacker, secondBlocker, combat)
                             && CombatUtil.canBlock(attacker, thirdBlocker, combat)) {
-                        // this is needed for attackers that can't be blocked by
-                        // more than 1
+                        // this is needed for attackers that can't be blocked by more than 1
                         currentAttackers.remove(attacker);
                         combat.addBlocker(attacker, thirdBlocker);
                         if (CombatUtil.canBlock(attacker, secondBlocker, combat)) {
@@ -587,12 +580,10 @@ public class AiBlockController {
      * @param combat a {@link forge.game.combat.Combat} object.
      */
     private void makeTradeBlocks(final Combat combat) {
-
         List<Card> currentAttackers = new ArrayList<>(attackersLeft);
         List<Card> killingBlockers;
 
         for (final Card attacker : attackersLeft) {
-
             if (attacker.hasStartOfKeyword("CantBeBlockedByAmount LT")
                     || attacker.hasKeyword(Keyword.MENACE)
                     || attacker.hasKeyword("CARDNAME can't be blocked unless all creatures defending player controls block it.")) {
@@ -628,7 +619,6 @@ public class AiBlockController {
 
     // Chump Blocks (should only be made if life is in danger)
     private void makeChumpBlocks(final Combat combat) {
-
         List<Card> currentAttackers = new ArrayList<>(attackersLeft);
 
         makeChumpBlocks(combat, currentAttackers);
@@ -639,7 +629,6 @@ public class AiBlockController {
     }
 
     private void makeChumpBlocks(final Combat combat, List<Card> attackers) {
-
         if (attackers.isEmpty() || !ComputerUtilCombat.lifeInDanger(ai, combat)) {
             return;
         }
@@ -694,11 +683,9 @@ public class AiBlockController {
 
     // Block creatures with "can't be blocked except by two or more creatures"
     private void makeMultiChumpBlocks(final Combat combat) {
-
         List<Card> currentAttackers = new ArrayList<>(attackersLeft);
 
         for (final Card attacker : currentAttackers) {
-
             if (!attacker.hasStartOfKeyword("CantBeBlockedByAmount LT")
                     && !attacker.hasKeyword(Keyword.MENACE)
                     && !attacker.hasKeyword("CARDNAME can't be blocked unless all creatures defending player controls block it.")) {
@@ -730,14 +717,12 @@ public class AiBlockController {
 
     /** Reinforce blockers blocking attackers with trample (should only be made if life is in danger) */
     private void reinforceBlockersAgainstTrample(final Combat combat) {
-
         List<Card> chumpBlockers;
 
         List<Card> tramplingAttackers = CardLists.getKeyword(attackers, Keyword.TRAMPLE);
         tramplingAttackers = CardLists.filter(tramplingAttackers, Predicates.not(rampagesOrNeedsManyToBlock));
 
-        // TODO - should check here for a "rampage-like" trigger that replaced
-        // the keyword:
+        // TODO - should check here for a "rampage-like" trigger that replaced the keyword:
         // "Whenever CARDNAME becomes blocked, it gets +1/+1 until end of turn for each creature blocking it."
 
         for (final Card attacker : tramplingAttackers) {
@@ -764,7 +749,6 @@ public class AiBlockController {
 
     /** Support blockers not destroying the attacker with more blockers to try to kill the attacker */
     private void reinforceBlockersToKill(final Combat combat) {
-
         List<Card> safeBlockers;
         List<Card> blockers;
         List<Card> targetAttackers = CardLists.filter(blockedButUnkilled, Predicates.not(rampagesOrNeedsManyToBlock));
@@ -1036,27 +1020,21 @@ public class AiBlockController {
             } else {
                 lifeInDanger = false;
             }
-            // if life is still in danger
-            // Reinforce blockers blocking attackers with trample if life is
-            // still
-            // in danger
+            // Reinforce blockers blocking attackers with trample if life is still in danger
             if (lifeInDanger && ComputerUtilCombat.lifeInDanger(ai, combat)) {
                 reinforceBlockersAgainstTrample(combat);
             } else {
                 lifeInDanger = false;
             }
             // Support blockers not destroying the attacker with more blockers
-            // to
-            // try to kill the attacker
+            // to try to kill the attacker
             if (!lifeInDanger) {
                 reinforceBlockersToKill(combat);
             }
 
-            // == 2. If the AI life would still be in danger make a safer
-            // approach ==
+            // == 2. If the AI life would still be in danger make a safer approach ==
             if (lifeInDanger && ComputerUtilCombat.lifeInDanger(ai, combat)) {
-                clearBlockers(combat, possibleBlockers); // reset every block
-                                                         // assignment
+                clearBlockers(combat, possibleBlockers); // reset every block assignment
                 makeTradeBlocks(combat); // choose necessary trade blocks
                 // if life is in danger
                 makeGoodBlocks(combat);
@@ -1066,8 +1044,7 @@ public class AiBlockController {
                 } else {
                     lifeInDanger = false;
                 }
-                // Reinforce blockers blocking attackers with trample if life is
-                // still in danger
+                // Reinforce blockers blocking attackers with trample if life is still in danger
                 if (lifeInDanger && ComputerUtilCombat.lifeInDanger(ai, combat)) {
                     reinforceBlockersAgainstTrample(combat);
                 } else {
@@ -1077,11 +1054,9 @@ public class AiBlockController {
                 reinforceBlockersToKill(combat);
             }
 
-            // == 3. If the AI life would be in serious danger make an even
-            // safer approach ==
+            // == 3. If the AI life would be in serious danger make an even safer approach ==
             if (lifeInDanger && ComputerUtilCombat.lifeInSeriousDanger(ai, combat)) {
-                clearBlockers(combat, possibleBlockers); // reset every block
-                                                         // assignment
+                clearBlockers(combat, possibleBlockers); // reset every block assignment
                 makeChumpBlocks(combat); // choose chump blocks
                 if (ComputerUtilCombat.lifeInDanger(ai, combat)) {
                     makeTradeBlocks(combat); // choose necessary trade
@@ -1090,15 +1065,13 @@ public class AiBlockController {
                 if (!ComputerUtilCombat.lifeInDanger(ai, combat)) {
                     makeGoodBlocks(combat);
                 }
-                // Reinforce blockers blocking attackers with trample if life is
-                // still in danger
+                // Reinforce blockers blocking attackers with trample if life is still in danger
                 else {
                     reinforceBlockersAgainstTrample(combat);
                 }
                 makeGangBlocks(combat);
                 // Support blockers not destroying the attacker with more
-                // blockers
-                // to try to kill the attacker
+                // blockers to try to kill the attacker
                 reinforceBlockersToKill(combat);
             }
         }
@@ -1108,7 +1081,7 @@ public class AiBlockController {
         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)) {
+            if (CombatUtil.mustBlockAnAttacker(blocker, combat, null)) {
                 chumpBlockers.add(blocker);
             }
         }
@@ -1118,7 +1091,7 @@ public class AiBlockController {
                 blockers = getPossibleBlockers(combat, attacker, chumpBlockers, false);
                 for (final Card blocker : blockers) {
                     if (CombatUtil.canBlock(attacker, blocker, combat) && blockersLeft.contains(blocker)
-                            && (CombatUtil.mustBlockAnAttacker(blocker, combat)
+                            && (CombatUtil.mustBlockAnAttacker(blocker, combat, null)
                                     || blocker.hasKeyword("CARDNAME blocks each turn if able.")
                                     || blocker.hasKeyword("CARDNAME blocks each combat if able."))) {
                         combat.addBlocker(attacker, blocker);
@@ -1137,7 +1110,6 @@ 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)) {

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

@@ -32,7 +32,9 @@ import com.google.common.collect.Lists;
 
 import forge.ai.ability.ChangeZoneAi;
 import forge.ai.ability.ExploreAi;
+import forge.ai.ability.LearnAi;
 import forge.ai.simulation.SpellAbilityPicker;
+import forge.card.CardStateName;
 import forge.card.MagicColor;
 import forge.card.mana.ManaCost;
 import forge.deck.CardPool;
@@ -45,6 +47,7 @@ import forge.game.Game;
 import forge.game.GameActionUtil;
 import forge.game.GameEntity;
 import forge.game.GlobalRuleChange;
+import forge.game.ability.AbilityKey;
 import forge.game.ability.AbilityUtils;
 import forge.game.ability.ApiType;
 import forge.game.ability.SpellApiBased;
@@ -77,6 +80,7 @@ import forge.game.player.Player;
 import forge.game.player.PlayerActionConfirmMode;
 import forge.game.replacement.ReplaceMoved;
 import forge.game.replacement.ReplacementEffect;
+import forge.game.replacement.ReplacementLayer;
 import forge.game.replacement.ReplacementType;
 import forge.game.spellability.AbilitySub;
 import forge.game.spellability.LandAbility;
@@ -88,6 +92,7 @@ import forge.game.spellability.SpellAbilityCondition;
 import forge.game.spellability.SpellAbilityPredicates;
 import forge.game.spellability.SpellPermanent;
 import forge.game.staticability.StaticAbility;
+import forge.game.staticability.StaticAbilityMustTarget;
 import forge.game.trigger.Trigger;
 import forge.game.trigger.TriggerType;
 import forge.game.trigger.WrappedAbility;
@@ -305,6 +310,8 @@ public class AiController {
             }
 
             exSA.setTrigger(tr);
+            // need to set TriggeredObject
+            exSA.setTriggeringObject(AbilityKey.Card, card);
 
             // for trigger test, need to ignore the conditions
             SpellAbilityCondition cons = exSA.getConditions();
@@ -430,17 +437,22 @@ public class AiController {
                     }
                 }
 
-                // don't play the land if it has cycling and enough lands are available
-                final FCollectionView<SpellAbility> spellAbilities = c.getSpellAbilities();
-
                 final CardCollectionView hand = player.getCardsIn(ZoneType.Hand);
                 CardCollection lands = new CardCollection(battlefield);
                 lands.addAll(hand);
                 lands = CardLists.filter(lands, CardPredicates.Presets.LANDS);
                 int maxCmcInHand = Aggregates.max(hand, CardPredicates.Accessors.fnGetCmc);
-                for (final SpellAbility sa : spellAbilities) {
-                    if (sa.isCycling()) {
-                        if (lands.size() >= Math.max(maxCmcInHand, 6)) {
+
+                if (lands.size() >= Math.max(maxCmcInHand, 6)) {
+                    // don't play MDFC land if other side is spell and enough lands are available
+                    if (!c.isLand() || (c.isModal() && !c.getState(CardStateName.Modal).getType().isLand())) {
+                        return false;
+                    }
+
+                    // don't play the land if it has cycling and enough lands are available
+                    final FCollectionView<SpellAbility> spellAbilities = c.getSpellAbilities();
+                    for (final SpellAbility sa : spellAbilities) {
+                        if (sa.isCycling()) {
                             return false;
                         }
                     }
@@ -498,23 +510,38 @@ public class AiController {
             landList = unreflectedLands;
         }
 
-
         //try to skip lands that enter the battlefield tapped
         if (!nonLandsInHand.isEmpty()) {
-            CardCollection nonTappeddLands = new CardCollection();
+            CardCollection nonTappedLands = new CardCollection();
             for (Card land : landList) {
-                // Is this the best way to check if a land ETB Tapped?
-                if (land.hasSVar("ETBTappedSVar")) {
+                // check replacement effects if land would enter tapped or not
+                final Map<AbilityKey, Object> repParams = AbilityKey.mapFromAffected(land);
+                repParams.put(AbilityKey.Origin, land.getZone().getZoneType());
+                repParams.put(AbilityKey.Destination, ZoneType.Battlefield);
+                repParams.put(AbilityKey.Source, land);
+
+                boolean foundTapped = false;
+                for (ReplacementEffect re : player.getGame().getReplacementHandler().getReplacementList(ReplacementType.Moved, repParams, ReplacementLayer.Other)) {
+                    SpellAbility reSA = re.ensureAbility();
+                    if (reSA == null || !ApiType.Tap.equals(reSA.getApi())) {
+                        continue;
+                    }
+                    reSA.setActivatingPlayer(reSA.getHostCard().getController());
+                    if (reSA.metConditions()) {
+                        foundTapped = true;
+                        break;
+                    }
+                }
+
+                // TODO if this is the only source for a color we need badly prioritize it instead
+                if (foundTapped) {
                     continue;
                 }
-                // Glacial Fortress and friends
-                if (land.hasSVar("ETBCheckSVar") && CardFactoryUtil.xCount(land, land.getSVar("ETBCheckSVar")) == 0) {
-                    continue;
-                }
-                nonTappeddLands.add(land);
+
+                nonTappedLands.add(land);
             }
-            if (!nonTappeddLands.isEmpty()) {
-                landList = nonTappeddLands;
+            if (!nonTappedLands.isEmpty()) {
+                landList = nonTappedLands;
             }
         }
 
@@ -586,7 +613,6 @@ public class AiController {
             sa.setActivatingPlayer(player);
             // check everything necessary
 
-            
             AiPlayDecision opinion = canPlayAndPayFor(currentSA);
             //PhaseHandler ph = game.getPhaseHandler();
             // System.out.printf("Ai thinks '%s' of %s @ %s %s >>> \n", opinion, sa, Lang.getPossesive(ph.getPlayerTurn().getName()), ph.getPhase());
@@ -787,10 +813,10 @@ public class AiController {
         }
         else {
             Cost payCosts = sa.getPayCosts();
-            if(payCosts != null) {
+            if (payCosts != null) {
                 ManaCost mana = payCosts.getTotalMana();
                 if (mana != null) {
-                    if(mana.countX() > 0) {
+                    if (mana.countX() > 0) {
                         // Set PayX here to maximum value.
                         final int xPay = ComputerUtilCost.getMaxXValue(sa, player);
                         if (xPay <= 0) {
@@ -826,8 +852,11 @@ public class AiController {
             }
             return canPlayFromEffectAI((SpellPermanent)sa, false, true);
         }
-        if (sa.usesTargeting() && !sa.isTargetNumberValid()) {
-            if (!sa.getTargetRestrictions().hasCandidates(sa, true)) {
+        if (sa.usesTargeting()) {
+            if (!sa.isTargetNumberValid() && !sa.getTargetRestrictions().hasCandidates(sa, true)) {
+                return AiPlayDecision.TargetingFailed;
+            }
+            if (!StaticAbilityMustTarget.meetsMustTargetRestriction(sa)) {
                 return AiPlayDecision.TargetingFailed;
             }
         }
@@ -1110,12 +1139,18 @@ public class AiController {
         final CardCollection discardList = new CardCollection();
         int count = 0;
         if (sa != null) {
+            String logic = sa.getParamOrDefault("AILogic", "");
             sourceCard = sa.getHostCard();
-            if ("Always".equals(sa.getParam("AILogic")) && !validCards.isEmpty()) {
+            if ("Always".equals(logic) && !validCards.isEmpty()) {
                 min = 1;
-            } else if ("VolrathsShapeshifter".equals(sa.getParam("AILogic"))) {
+            } else if (logic.startsWith("UnlessAtLife.")) {
+                int threshold = AbilityUtils.calculateAmount(sourceCard, logic.substring(logic.indexOf(".") + 1), sa);
+                if (player.getLife() <= threshold) {
+                    min = 1;
+                }
+            } else if ("VolrathsShapeshifter".equals(logic)) {
                 return SpecialCardAi.VolrathsShapeshifter.targetBestCreature(player, sa);
-            } else if ("DiscardCMCX".equals(sa.getParam("AILogic"))) {
+            } else if ("DiscardCMCX".equals(logic)) {
                 final int cmc = sa.getXManaCostPaid();
                 CardCollection discards = CardLists.filter(player.getCardsIn(ZoneType.Hand), CardPredicates.hasCMC(cmc));
                 if (discards.isEmpty()) {
@@ -1290,15 +1325,6 @@ public class AiController {
     }
 
     public boolean confirmStaticApplication(Card hostCard, GameEntity affected, String logic, String message) {
-        if (logic.equalsIgnoreCase("ProtectFriendly")) {
-            final Player controller = hostCard.getController();
-            if (affected instanceof Player) {
-                return !((Player) affected).isOpponentOf(controller);
-            }
-            if (affected instanceof Card) {
-                return !((Card) affected).getController().isOpponentOf(controller);
-            }
-        }
         return true;
     }
 
@@ -1328,7 +1354,7 @@ public class AiController {
 
     public AiPlayDecision canPlayFromEffectAI(Spell spell, boolean mandatory, boolean withoutPayingManaCost) {
         int damage = ComputerUtil.getDamageForPlaying(player, spell);
-        if (damage >= player.getLife() && !player.cantLoseForZeroOrLessLife() && player.canLoseLife()) {
+        if (!mandatory && damage >= player.getLife() && !player.cantLoseForZeroOrLessLife() && player.canLoseLife()) {
             return AiPlayDecision.CurseEffects;
         }
 
@@ -1397,8 +1423,6 @@ public class AiController {
     private List<SpellAbility> singleSpellAbilityList(SpellAbility sa) {
         if (sa == null) { return null; }
 
-        // System.out.println("Chosen to play: " + sa);
-
         final List<SpellAbility> abilities = Lists.newArrayList();
         abilities.add(sa);
         return abilities;
@@ -1443,6 +1467,13 @@ public class AiController {
                     if (!game.getPhaseHandler().is(PhaseType.MAIN1) || !isSafeToHoldLandDropForMain2(land)) {
                         final List<SpellAbility> abilities = Lists.newArrayList();
 
+                        // TODO extend this logic to evaluate MDFC with both sides land
+                        // this can only happen if its a MDFC land
+                        if (!land.isLand()) {
+                            land.setState(CardStateName.Modal, true);
+                            land.setBackSide(true);
+                        }
+
                         LandAbility la = new LandAbility(land, player, null);
                         la.setCardState(land.getCurrentState());
                         if (la.canPlay()) {
@@ -1693,10 +1724,8 @@ public class AiController {
         for (int i = 0; i < numToExile; i++) {
             Card chosen = null;
             for (final Card c : grave) { // Exile noncreatures first in
-                // case we can revive. Might
-                // wanna do some additional
-                // checking here for Flashback
-                // and the like.
+                // case we can revive. Might wanna do some additional
+                // checking here for Flashback and the like.
                 if (!c.isCreature()) {
                     chosen = c;
                     break;
@@ -1735,12 +1764,21 @@ public class AiController {
      * @param sa the sa
      * @return true, if successful
      */
-    public final boolean aiShouldRun(final ReplacementEffect effect, final SpellAbility sa) {
+    public final boolean aiShouldRun(final ReplacementEffect effect, final SpellAbility sa, GameEntity affected) {
         Card hostCard = effect.getHostCard();
         if (hostCard.hasAlternateState()) {
             hostCard = game.getCardState(hostCard);
         }
 
+        if (effect.hasParam("AILogic") && effect.getParam("AILogic").equalsIgnoreCase("ProtectFriendly")) {
+            final Player controller = hostCard.getController();
+            if (affected instanceof Player) {
+                return !((Player) affected).isOpponentOf(controller);
+            }
+            if (affected instanceof Card) {
+                return !((Card) affected).getController().isOpponentOf(controller);
+            }
+        }
         if (effect.hasParam("AICheckSVar")) {
             System.out.println("aiShouldRun?" + sa);
             final String svarToCheck = effect.getParam("AICheckSVar");
@@ -1755,7 +1793,7 @@ public class AiController {
                     compareTo = Integer.parseInt(strCmpTo);
                 } catch (final Exception ignored) {
                     if (sa == null) {
-                        compareTo = CardFactoryUtil.xCount(hostCard, hostCard.getSVar(strCmpTo));
+                        compareTo = AbilityUtils.calculateAmount(hostCard, hostCard.getSVar(strCmpTo), effect);
                     } else {
                         compareTo = AbilityUtils.calculateAmount(hostCard, hostCard.getSVar(strCmpTo), sa);
                     }
@@ -1765,7 +1803,7 @@ public class AiController {
             int left = 0;
 
             if (sa == null) {
-                left = CardFactoryUtil.xCount(hostCard, hostCard.getSVar(svarToCheck));
+                left = AbilityUtils.calculateAmount(hostCard, svarToCheck, effect);
             } else {
                 left = AbilityUtils.calculateAmount(hostCard, svarToCheck, sa);
             }
@@ -1781,7 +1819,7 @@ public class AiController {
         // AI would play everything. But limits to one copy of (Leyline of Singularity) and (Gemstone Caverns)
         
         List<SpellAbility> result = Lists.newArrayList();
-        for(SpellAbility sa : usableFromOpeningHand) {
+        for (SpellAbility sa : usableFromOpeningHand) {
             // Is there a better way for the AI to decide this?
             if (doTrigger(sa, false)) {
                 result.add(sa);
@@ -1792,7 +1830,7 @@ public class AiController {
         SpellAbility saGemstones = null;
 
         List<SpellAbility> toRemove = Lists.newArrayList();
-        for(SpellAbility sa : result) {
+        for (SpellAbility sa : result) {
             String srcName = sa.getHostCard().getName();
             if ("Gemstone Caverns".equals(srcName)) {
                 if (saGemstones == null)
@@ -1855,11 +1893,13 @@ public class AiController {
         } else if ("LowestLoseLife".equals(logic)) {
             return MyRandom.getRandom().nextInt(Math.min(player.getLife() / 3, player.getWeakestOpponent().getLife())) + 1;
         } else if ("HighestLoseLife".equals(logic)) {
-            return MyRandom.getRandom().nextInt(Math.max(player.getLife() / 3, player.getWeakestOpponent().getLife())) + 1;
+            return Math.min(player.getLife() -1,MyRandom.getRandom().nextInt(Math.max(player.getLife() / 3, player.getWeakestOpponent().getLife())) + 1);
         } else if ("HighestGetCounter".equals(logic)) {
             return MyRandom.getRandom().nextInt(3);
         } else if (source.hasSVar("EnergyToPay")) {
             return AbilityUtils.calculateAmount(source, source.getSVar("EnergyToPay"), sa);
+        } else if ("Vermin".equals(logic)) {
+            return MyRandom.getRandom().nextInt(Math.max(player.getLife() - 5, 0));
         }
         return max;
     }
@@ -1876,7 +1916,7 @@ public class AiController {
         if (sa.hasParam("AIMaxAmount")) {
             max = AbilityUtils.calculateAmount(sa.getHostCard(), sa.getParam("AIMaxAmount"), sa);
         }
-        switch(sa.getApi()) {
+        switch (sa.getApi()) {
             case TwoPiles:
                 // TODO: improve AI
                 Card biggest = null;
@@ -1954,7 +1994,6 @@ public class AiController {
         return result;
     }
 
-
     // this is where the computer cheats
     // changes AllZone.getComputerPlayer().getZone(Zone.Library)
     
@@ -2007,11 +2046,6 @@ public class AiController {
             }
         }
 
-        // check
-        for (int i = 0; i < library.size(); i++) {
-            System.out.println(library.get(i));
-        }
-    
         return library;
     } // smoothComputerManaCurve()
 
@@ -2089,8 +2123,11 @@ public class AiController {
         if (useSimulation) {
             return simPicker.chooseCardToHiddenOriginChangeZone(destination, origin, sa, fetchList, player2, decider);
         }
+
         if (sa.getApi() == ApiType.Explore) {
             return ExploreAi.shouldPutInGraveyard(fetchList, decider);
+        } else if (sa.getApi() == ApiType.Learn) {
+            return LearnAi.chooseCardToLearn(fetchList, decider, sa);
         } else {
             return ChangeZoneAi.chooseCardToHiddenOriginChangeZone(destination, origin, sa, fetchList, player2, decider);
         }
@@ -2231,10 +2268,8 @@ public class AiController {
             }
         }
 
-        // AI logic for choosing which replacement effect to apply
-        // happens here.
+        // AI logic for choosing which replacement effect to apply happens here.
         return Iterables.getFirst(list, null);
     }
 
 }
-

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

@@ -6,9 +6,11 @@ import java.util.Collections;
 import java.util.List;
 import java.util.Map;
 
+import forge.game.cost.*;
+import org.apache.commons.lang3.ObjectUtils;
+
 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.card.CardType;
@@ -22,43 +24,12 @@ import forge.game.card.CardLists;
 import forge.game.card.CardPredicates;
 import forge.game.card.CounterEnumType;
 import forge.game.card.CounterType;
-import forge.game.cost.CostAddMana;
-import forge.game.cost.CostChooseCreatureType;
-import forge.game.cost.CostDamage;
-import forge.game.cost.CostDecisionMakerBase;
-import forge.game.cost.CostDiscard;
-import forge.game.cost.CostDraw;
-import forge.game.cost.CostExert;
-import forge.game.cost.CostExile;
-import forge.game.cost.CostExileFromStack;
-import forge.game.cost.CostExiledMoveToGrave;
-import forge.game.cost.CostFlipCoin;
-import forge.game.cost.CostGainControl;
-import forge.game.cost.CostGainLife;
-import forge.game.cost.CostMill;
-import forge.game.cost.CostPartMana;
-import forge.game.cost.CostPayEnergy;
-import forge.game.cost.CostPayLife;
-import forge.game.cost.CostPutCardToLib;
-import forge.game.cost.CostPutCounter;
-import forge.game.cost.CostRemoveAnyCounter;
-import forge.game.cost.CostRemoveCounter;
-import forge.game.cost.CostReturn;
-import forge.game.cost.CostReveal;
-import forge.game.cost.CostSacrifice;
-import forge.game.cost.CostTap;
-import forge.game.cost.CostTapType;
-import forge.game.cost.CostUnattach;
-import forge.game.cost.CostUntap;
-import forge.game.cost.CostUntapType;
-import forge.game.cost.PaymentDecision;
 import forge.game.keyword.Keyword;
 import forge.game.player.Player;
 import forge.game.spellability.SpellAbility;
 import forge.game.spellability.SpellAbilityStackInstance;
 import forge.game.zone.ZoneType;
 import forge.util.Aggregates;
-import forge.util.Localizer;
 import forge.util.TextUtil;
 import forge.util.collect.FCollectionView;
 
@@ -92,15 +63,9 @@ public class AiCostDecision extends CostDecisionMakerBase {
 
     @Override
     public PaymentDecision visit(CostChooseCreatureType cost) {
-        Integer amount = cost.convertAmount();
-        Iterable<String> choices = player.getController().chooseSomeType(
-                Localizer.getInstance().getMessage("lblCreature"), ability, amount, amount, Lists.newArrayList(CardType.getAllCreatureTypes()));
-
-        if (choices == null || Iterables.isEmpty(choices)) {
-            return null;
-        }
-
-        return PaymentDecision.types(choices);
+        String choice = player.getController().chooseSomeType("Creature", ability, CardType.getAllCreatureTypes(),
+                Lists.newArrayList());
+        return PaymentDecision.type(choice);
     }
 
     @Override
@@ -302,6 +267,15 @@ public class AiCostDecision extends CostDecisionMakerBase {
         return PaymentDecision.number(c);
     }
 
+    @Override
+    public PaymentDecision visit(CostRollDice cost) {
+        Integer c = cost.convertAmount();
+        if (c == null) {
+            c = AbilityUtils.calculateAmount(source, cost.getAmount(), ability);
+        }
+        return PaymentDecision.number(c);
+    }
+
     @Override
     public PaymentDecision visit(CostGainControl cost) {
         if (cost.payCostFromSource()) {
@@ -389,7 +363,6 @@ public class AiCostDecision extends CostDecisionMakerBase {
         return PaymentDecision.number(c);
     }
 
-
     @Override
     public PaymentDecision visit(CostPutCardToLib cost) {
         if (cost.payCostFromSource()) {
@@ -569,7 +542,7 @@ public class AiCostDecision extends CostDecisionMakerBase {
             return null;
         }
 
-        if (cost.getRevealFrom().equals(ZoneType.Exile)) {
+        if (cost.getRevealFrom().get(0).equals(ZoneType.Exile)) {
             hand = CardLists.getValidCards(hand, type.split(";"), player, source, ability);
             return PaymentDecision.card(getBestCreatureAI(hand));
         }
@@ -583,6 +556,11 @@ public class AiCostDecision extends CostDecisionMakerBase {
         return PaymentDecision.card(aic.getCardsToDiscard(c, type.split(";"), ability));
     }
 
+    @Override
+    public PaymentDecision visit(CostRevealChosenPlayer cost) {
+        return PaymentDecision.number(1);
+    }
+
     protected int removeCounter(GameEntityCounterTable table, List<Card> prefs, CounterEnumType cType, int stillToRemove) {
         int removed = 0;
         if (!prefs.isEmpty() && stillToRemove > 0) {
@@ -596,7 +574,7 @@ public class AiCostDecision extends CostDecisionMakerBase {
                 int thisRemove = Math.min(prefCard.getCounters(cType), stillToRemove);
                 if (thisRemove > 0) {
                     removed += thisRemove;
-                    table.put(prefCard, CounterType.get(cType), thisRemove);
+                    table.put(null, prefCard, CounterType.get(cType), thisRemove);
                 }
             }
         }
@@ -607,7 +585,7 @@ public class AiCostDecision extends CostDecisionMakerBase {
     public PaymentDecision visit(CostRemoveAnyCounter cost) {
         final String amount = cost.getAmount();
         final int c = AbilityUtils.calculateAmount(source, amount, ability);
-        final Card originalHost = ability.getOriginalOrHost();
+        final Card originalHost = ObjectUtils.defaultIfNull(ability.getOriginalHost(), source);
 
         if (c <= 0) {
             return null;
@@ -662,7 +640,7 @@ public class AiCostDecision extends CostDecisionMakerBase {
                     int thisRemove = Math.min(card.getCounters(ctype), c - toRemove);
                     if (thisRemove > 0) {
                         toRemove += thisRemove;
-                        table.put(card, ctype, thisRemove);
+                        table.put(null, card, ctype, thisRemove);
                     }
                 }
             }
@@ -690,7 +668,7 @@ public class AiCostDecision extends CostDecisionMakerBase {
                             int over = Math.min(e.getValue(), c - toRemove);
                             if (over > 0) {
                                 toRemove += over;
-                                table.put(crd, e.getKey(), over);
+                                table.put(null, crd, e.getKey(), over);
                             }
                         }
                     }
@@ -720,7 +698,7 @@ public class AiCostDecision extends CostDecisionMakerBase {
                             int over = Math.min(e.getValue(), c - toRemove);
                             if (over > 0) {
                                 toRemove += over;
-                                table.put(crd, e.getKey(), over);
+                                table.put(null, crd, e.getKey(), over);
                             }
                         }
                     }
@@ -760,7 +738,7 @@ public class AiCostDecision extends CostDecisionMakerBase {
                 int over = Math.min(crd.getCounters(CounterEnumType.QUEST) - e, c - toRemove);
                 if (over > 0) {
                     toRemove += over;
-                    table.put(crd, CounterType.get(CounterEnumType.QUEST), over);
+                    table.put(null, crd, CounterType.get(CounterEnumType.QUEST), over);
                 }
             }
         }
@@ -784,7 +762,7 @@ public class AiCostDecision extends CostDecisionMakerBase {
                 int thisRemove = Math.min(card.getCounters(cost.counter), c - toRemove);
                 if (thisRemove > 0) {
                     toRemove += thisRemove;
-                    table.put(card, cost.counter, thisRemove);
+                    table.put(null, card, cost.counter, thisRemove);
                 }
             }
         }
@@ -798,7 +776,7 @@ public class AiCostDecision extends CostDecisionMakerBase {
                     int thisRemove = Math.min(e.getValue(), c - toRemove);
                     if (thisRemove > 0) {
                         toRemove += thisRemove;
-                        table.put(card, e.getKey(), thisRemove);
+                        table.put(null, card, e.getKey(), thisRemove);
                     }
                 }
             }

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

@@ -188,7 +188,6 @@ public class ComputerUtil {
         final Card source = sa.getHostCard();
         final TargetRestrictions tgt = sa.getTargetRestrictions();
 
-
         // Play higher costing spells first?
         final Cost cost = sa.getPayCosts();
 
@@ -213,7 +212,8 @@ public class ComputerUtil {
         if (unless != null && !unless.endsWith(">")) {
             final int amount = AbilityUtils.calculateAmount(source, unless, sa);
 
-            final int usableManaSources = ComputerUtilMana.getAvailableManaSources(ComputerUtil.getOpponentFor(ai), true).size();
+            // this is enough as long as the AI is only smart enough to target top of stack
+            final int usableManaSources = ComputerUtilMana.getAvailableManaSources(ComputerUtilAbility.getTopSpellAbilityOnStack(ai.getGame(), sa).getActivatingPlayer(), true).size();
 
             // If the Unless isn't enough, this should be less likely to be used
             if (amount > usableManaSources) {
@@ -280,7 +280,7 @@ public class ComputerUtil {
         SpellAbility newSA = sa.copyWithNoManaCost();
         newSA.setActivatingPlayer(ai);
 
-        if (!CostPayment.canPayAdditionalCosts(newSA.getPayCosts(), newSA)) {
+        if (!CostPayment.canPayAdditionalCosts(newSA.getPayCosts(), newSA) || !ComputerUtilMana.canPayManaCost(newSA, ai, 0)) {
             return false;
         }
 
@@ -331,11 +331,14 @@ public class ComputerUtil {
     }
 
     public static Card getCardPreference(final Player ai, final Card activate, final String pref, final CardCollection typeList) {
+        return getCardPreference(ai, activate, pref, typeList, null);
+    }
+    public static Card getCardPreference(final Player ai, final Card activate, final String pref, final CardCollection typeList, SpellAbility sa) {
         final Game game = ai.getGame();
         String prefDef = "";
         if (activate != null) {
             prefDef = activate.getSVar("AIPreference");
-            final String[] prefGroups = activate.getSVar("AIPreference").split("\\|");
+            final String[] prefGroups = prefDef.split("\\|");
             for (String prefGroup : prefGroups) {
                 final String[] prefValid = prefGroup.trim().split("\\$");
                 if (prefValid[0].equals(pref) && !prefValid[1].startsWith("Special:")) {
@@ -346,8 +349,8 @@ public class ComputerUtil {
 
                     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");
+                        int threshold = getAIPreferenceParameter(activate, "CreatureEvalThreshold", sa);
+                        int minNeeded = getAIPreferenceParameter(activate, "MinCreaturesBelowThreshold", sa);
 
                         if (threshold != -1) {
                             List<Card> toRemove = Lists.newArrayList();
@@ -390,7 +393,7 @@ public class ComputerUtil {
                 final CardCollection sacMeList = CardLists.filter(typeList, new Predicate<Card>() {
                     @Override
                     public boolean apply(final Card c) {
-                        return (c.hasSVar("SacMe") && (Integer.parseInt(c.getSVar("SacMe")) == priority));
+                        return c.hasSVar("SacMe") && (Integer.parseInt(c.getSVar("SacMe")) == priority);
                     }
                 });
                 if (!sacMeList.isEmpty()) {
@@ -419,6 +422,7 @@ public class ComputerUtil {
                 if (!nonCreatures.isEmpty()) {
                     return ComputerUtilCard.getWorstAI(nonCreatures);
                 } else if (!typeList.isEmpty()) {
+                    // TODO make sure survival is possible in case the creature blocks a trampler
                     return ComputerUtilCard.getWorstAI(typeList);
                 }
             }
@@ -505,7 +509,7 @@ public class ComputerUtil {
         return null;
     }
 
-    public static int getAIPreferenceParameter(final Card c, final String paramName) {
+    public static int getAIPreferenceParameter(final Card c, final String paramName, SpellAbility sa) {
         if (!c.hasSVar("AIPreferenceParams")) {
             return -1;
         }
@@ -520,7 +524,21 @@ public class ComputerUtil {
                 case "CreatureEvalThreshold":
                     // Threshold of 150 is just below the level of a 1/1 mana dork or a 2/2 baseline creature with no keywords
                     if (paramName.equals(parName)) {
-                        return Integer.parseInt(parValue);
+                        int num = 0;
+                        try {
+                            num = Integer.parseInt(parValue);
+                        } catch (NumberFormatException nfe) {
+                            String[] valParts = StringUtils.split(parValue, "/");
+                            CardCollection foundCards  = AbilityUtils.getDefinedCards(c, valParts[0], sa);
+                            if (!foundCards.isEmpty()) {
+                                num = ComputerUtilCard.evaluateCreature(foundCards.get(0));
+                            }
+                            valParts[0] = Integer.toString(num);
+                            if (valParts.length > 1) {
+                                num = AbilityUtils.doXMath(num, valParts[1], c, sa);
+                            }
+                        }
+                        return num;
                     }
                     break;
                 case "MinCreaturesBelowThreshold":
@@ -543,9 +561,8 @@ public class ComputerUtil {
 
         typeList = CardLists.filter(typeList, CardPredicates.canBeSacrificedBy(ability));
 
-        if ((target != null) && target.getController() == ai) {
-            typeList.remove(target); // don't sacrifice the card we're pumping
-        }
+        // don't sacrifice the card we're pumping
+        typeList = ComputerUtilCost.paymentChoicesWithoutTargets(typeList, ability, ai);
 
         if (typeList.size() < amount) {
             return null;
@@ -573,9 +590,8 @@ public class ComputerUtil {
             final Card target, final int amount, SpellAbility sa) {
         CardCollection typeList = CardLists.getValidCards(ai.getCardsIn(zone), type.split(";"), activate.getController(), activate, sa);
 
-        if ((target != null) && target.getController() == ai) {
-            typeList.remove(target); // don't exile the card we're pumping
-        }
+        // don't exile the card we're pumping
+        typeList = ComputerUtilCost.paymentChoicesWithoutTargets(typeList, sa, ai);
 
         if (typeList.size() < amount) {
             return null;
@@ -594,9 +610,8 @@ public class ComputerUtil {
             final Card target, final int amount, SpellAbility sa) {
         CardCollection typeList = CardLists.getValidCards(ai.getCardsIn(zone), type.split(";"), activate.getController(), activate, sa);
 
-        if ((target != null) && target.getController() == ai) {
-            typeList.remove(target); // don't move the card we're pumping
-        }
+        // don't move the card we're pumping
+        typeList = ComputerUtilCost.paymentChoicesWithoutTargets(typeList, sa, ai);
 
         if (typeList.size() < amount) {
             return null;
@@ -718,12 +733,10 @@ public class ComputerUtil {
     }
 
     public static CardCollection chooseReturnType(final Player ai, final String type, final Card activate, final Card target, final int amount, SpellAbility sa) {
-        final CardCollection typeList =
-                CardLists.getValidCards(ai.getCardsIn(ZoneType.Battlefield), type.split(";"), activate.getController(), activate, sa);
-        if ((target != null) && target.getController() == ai) {
-            // don't bounce the card we're pumping
-            typeList.remove(target);
-        }
+        CardCollection typeList = CardLists.getValidCards(ai.getCardsIn(ZoneType.Battlefield), type.split(";"), activate.getController(), activate, sa);
+
+        // don't bounce the card we're pumping
+        typeList = ComputerUtilCost.paymentChoicesWithoutTargets(typeList, sa, ai);
 
         if (typeList.size() < amount) {
             return new CardCollection();
@@ -743,7 +756,7 @@ public class ComputerUtil {
         CardCollection remaining = new CardCollection(cardlist);
         final CardCollection sacrificed = new CardCollection();
         final Card host = source.getHostCard();
-        final int considerSacThreshold = getAIPreferenceParameter(host, "CreatureEvalThreshold");
+        final int considerSacThreshold = getAIPreferenceParameter(host, "CreatureEvalThreshold", source);
 
         if ("OpponentOnly".equals(source.getParam("AILogic"))) {
             if(!source.getActivatingPlayer().isOpponentOf(ai)) {
@@ -1068,9 +1081,6 @@ public class ComputerUtil {
                     return true;
                 }
             }
-            if (card.isEquipment() && buffedcard.isCreature() && CombatUtil.canAttack(buffedcard, ComputerUtil.getOpponentFor(ai))) {
-                return true;
-            }
             if (card.isCreature()) {
                 if (buffedcard.hasKeyword(Keyword.SOULBOND) && !buffedcard.isPaired()) {
                     return true;
@@ -1093,8 +1103,8 @@ public class ComputerUtil {
 
         } // BuffedBy
 
-        // get all cards the human controls with AntiBuffedBy
-        final CardCollectionView antibuffed = ComputerUtil.getOpponentFor(ai).getCardsIn(ZoneType.Battlefield);
+        // there's a good chance AI will attack weak target
+        final CardCollectionView antibuffed = ai.getWeakestOpponent().getCardsIn(ZoneType.Battlefield);
         for (Card buffedcard : antibuffed) {
             if (buffedcard.hasSVar("AntiBuffedBy")) {
                 final String buffedby = buffedcard.getSVar("AntiBuffedBy");
@@ -1128,7 +1138,7 @@ public class ComputerUtil {
                     creatures2.add(creatures.get(i));
                 }
             }
-            if (((creatures2.size() + CardUtil.getThisTurnCast("Creature.YouCtrl", vengevines.get(0)).size()) > 1)
+            if (((creatures2.size() + CardUtil.getThisTurnCast("Creature.YouCtrl", vengevines.get(0), null).size()) > 1)
                     && card.isCreature() && card.getManaCost().getCMC() <= 3) {
                 return true;
             }
@@ -1142,27 +1152,16 @@ public class ComputerUtil {
      * @return true if it's OK to cast this Card for less than the max targets
      */
     public static boolean shouldCastLessThanMax(final Player ai, final Card source) {
-        boolean ret = true;
-        if (source.getManaCost().countX() > 0) {
-            // If TargetMax is MaxTgts (i.e., an "X" cost), this is fine because AI is limited by mana available.
-            return ret;
-        } else {
-            // Otherwise, if life is possibly in danger, then this is fine.
-            Combat combat = new Combat(ComputerUtil.getOpponentFor(ai));
-            CardCollectionView attackers = ComputerUtil.getOpponentFor(ai).getCreaturesInPlay();
-            for (Card att : attackers) {
-                if (ComputerUtilCombat.canAttackNextTurn(att, ai)) {
-                    combat.addAttacker(att, ComputerUtil.getOpponentFor(att.getController()));
-                }
-            }
-            AiBlockController aiBlock = new AiBlockController(ai);
-            aiBlock.assignBlockersForCombat(combat);
-            if (!ComputerUtilCombat.lifeInDanger(ai, combat)) {
-                // Otherwise, return false. Do not play now.
-                ret = false;
-            }
+        if (source.getXManaCostPaid() > 0) {
+            // If TargetMax is MaxTgts (i.e., an "X" cost), this is fine because AI is limited by payment resources available.
+            return true;
         }
-        return ret;
+        if (aiLifeInDanger(ai, false, 0)) {
+            // Otherwise, if life is possibly in danger, then this is fine.
+            return true;
+        }
+        // do not play now.
+        return false;
     }
 
     /**
@@ -1266,8 +1265,8 @@ public class ComputerUtil {
             }
         }
 
-        // get all cards the human controls with AntiBuffedBy
-        final CardCollectionView antibuffed = ComputerUtil.getOpponentFor(ai).getCardsIn(ZoneType.Battlefield);
+        // there's a good chance AI will attack weak target
+        final CardCollectionView antibuffed = ai.getWeakestOpponent().getCardsIn(ZoneType.Battlefield);
         for (Card buffedcard : antibuffed) {
             if (buffedcard.hasSVar("AntiBuffedBy")) {
                 final String buffedby = buffedcard.getSVar("AntiBuffedBy");
@@ -1463,7 +1462,7 @@ public class ComputerUtil {
         return false;
     }
 
-    public static int possibleNonCombatDamage(Player ai) {
+    public static int possibleNonCombatDamage(Player ai, Player enemy) {
         int damage = 0;
         final CardCollection all = new CardCollection(ai.getCardsIn(ZoneType.Battlefield));
         all.addAll(ai.getCardsActivableInExternalZones(true));
@@ -1483,7 +1482,6 @@ public class ComputerUtil {
                 if (tgt == null) {
                     continue;
                 }
-                final Player enemy = ComputerUtil.getOpponentFor(ai);
                 if (!sa.canTarget(enemy)) {
                     continue;
                 }
@@ -1556,7 +1554,7 @@ public class ComputerUtil {
                 Iterables.addAll(objects, ComputerUtil.predictThreatenedObjects(ai, sa, spell));
             }
             if (top) {
-                break;  // only evaluate top-stack
+                break; // only evaluate top-stack
             }
         }
 
@@ -2256,42 +2254,40 @@ public class ComputerUtil {
         return getCardsToDiscardFromOpponent(aiChooser, p, sa, validCards, min, max);
     }
 
-    public static List<String> chooseSomeType(Player ai, String kindOfType, String logic, int min, int max, Collection<String> validTypes) {
+    public static String chooseSomeType(Player ai, String kindOfType, String logic, Collection<String> validTypes, List<String> invalidTypes) {
+        if (invalidTypes == null) {
+            invalidTypes = ImmutableList.of();
+        }
         if (validTypes == null) {
             validTypes = ImmutableList.of();
         }
 
         final Game game = ai.getGame();
-        List<String> chosenList = Lists.newArrayList();
+        String chosen = "";
         if (kindOfType.equals("Card")) {
-            String chosen = "";
-
             // TODO
-            // computer will need to choose a type
-            // based on whether it needs a creature or land,
-            // otherwise, lib search for most common type left
-            // then, reveal chosenType to Human
+            // computer will need to choose a type based on whether it needs a creature or land,
+            // otherwise, lib search for most common type left then, reveal chosenType to Human
             if (game.getPhaseHandler().is(PhaseType.UNTAP) && logic == null) { // Storage Matrix
                 double amount = 0;
-                for (String type : validTypes) {
-                    CardCollection list = CardLists.filter(ai.getCardsIn(ZoneType.Battlefield), CardPredicates.isType(type), Presets.TAPPED);
-                    double i = type.equals("Creature") ? list.size() * 1.5 : list.size();
-                    if (i > amount) {
-                        amount = i;
-                        chosen = type;
+                for (String type : CardType.getAllCardTypes()) {
+                    if (!invalidTypes.contains(type)) {
+                        CardCollection list = CardLists.filter(ai.getCardsIn(ZoneType.Battlefield), CardPredicates.isType(type), Presets.TAPPED);
+                        double i = type.equals("Creature") ? list.size() * 1.5 : list.size();
+                        if (i > amount) {
+                            amount = i;
+                            chosen = type;
+                        }
                     }
                 }
-            } else if (logic == "MostProminentInComputerDeck") {
-                chosen = ComputerUtilCard.getMostProminentType(ai.getAllCards(), validTypes);
             }
             if (StringUtils.isEmpty(chosen)) {
                 chosen = validTypes.isEmpty() ? "Creature" : Aggregates.random(validTypes);
             }
-            chosenList.add(chosen);
         } else if (kindOfType.equals("Creature")) {
-            String chosen = "";
             if (logic != null) {
-                List <String> valid = Lists.newArrayList(validTypes);
+                List <String> valid = Lists.newArrayList(CardType.getAllCreatureTypes());
+                valid.removeAll(invalidTypes);
 
                 if (logic.equals("MostProminentOnBattlefield")) {
                     chosen = ComputerUtilCard.getMostProminentType(game.getCardsIn(ZoneType.Battlefield), valid);
@@ -2302,7 +2298,7 @@ public class ComputerUtil {
                 else if (logic.equals("MostProminentOppControls")) {
                     CardCollection list = CardLists.filterControlledBy(game.getCardsIn(ZoneType.Battlefield), ai.getOpponents());
                     chosen = ComputerUtilCard.getMostProminentType(list, valid);
-                    if (!CardType.isACreatureType(chosen) || !validTypes.contains(chosen)) {
+                    if (!CardType.isACreatureType(chosen) || invalidTypes.contains(chosen)) {
                         list = CardLists.filterControlledBy(game.getCardsInGame(), ai.getOpponents());
                         chosen = ComputerUtilCard.getMostProminentType(list, valid);
                     }
@@ -2314,17 +2310,16 @@ public class ComputerUtil {
                     chosen = ComputerUtilCard.getMostProminentType(ai.getCardsIn(ZoneType.Graveyard), valid);
                 }
             }
-            if (!CardType.isACreatureType(chosen) || !validTypes.contains(chosen)) {
-                chosen = Iterables.getFirst(validTypes, null);
+            if (!CardType.isACreatureType(chosen) || invalidTypes.contains(chosen)) {
+                chosen = "Sliver";
             }
 
-            chosenList.add(chosen);
         } else if (kindOfType.equals("Basic Land")) {
-            String chosen = "";
             if (logic != null) {
                 if (logic.equals("MostProminentOppControls")) {
                     CardCollection list = CardLists.filterControlledBy(game.getCardsIn(ZoneType.Battlefield), ai.getOpponents());
-                    List<String> valid = Lists.newArrayList(validTypes);
+                    List<String> valid = Lists.newArrayList(CardType.getBasicTypes());
+                    valid.removeAll(invalidTypes);
 
                     chosen = ComputerUtilCard.getMostProminentType(list, valid);
                 } else  if (logic.equals("MostNeededType")) {
@@ -2347,9 +2342,9 @@ public class ComputerUtil {
                     }
                 }
                 else if (logic.equals("ChosenLandwalk")) {
-                    for (Card c : ai.getWeakestOpponent().getLandsInPlay()) {
+                    for (Card c : AiAttackController.choosePreferredDefenderPlayer(ai).getLandsInPlay()) {
                         for (String t : c.getType()) {
-                            if (validTypes.contains(t) && CardType.isABasicLandType(t)) {
+                            if (!invalidTypes.contains(t) && CardType.isABasicLandType(t)) {
                                 chosen = t;
                                 break;
                             }
@@ -2358,28 +2353,16 @@ public class ComputerUtil {
                 }
             }
 
-            if (!CardType.isABasicLandType(chosen) || !validTypes.contains(chosen)) {
-                chosen = Iterables.getFirst(validTypes, null);
-            }
-            chosenList.add(chosen);
-            // the only one with choosing two types is Illusionary Terrain
-            // and it needs other AI logic
-            while (chosenList.size() < min) {
-                validTypes.remove(chosen);
-                chosen = Iterables.getFirst(validTypes, null);
-                if (chosen == null) {
-                    return Lists.newArrayList();
-                }
-                chosenList.add(chosen);
+            if (!CardType.isABasicLandType(chosen) || invalidTypes.contains(chosen)) {
+                chosen = "Island";
             }
         }
         else if (kindOfType.equals("Land")) {
-            String chosen = "";
             if (logic != null) {
                 if (logic.equals("ChosenLandwalk")) {
-                    for (Card c : ai.getWeakestOpponent().getLandsInPlay()) {
+                    for (Card c : AiAttackController.choosePreferredDefenderPlayer(ai).getLandsInPlay()) {
                         for (String t : c.getType().getLandTypes()) {
-                            if (validTypes.contains(t)) {
+                            if (!invalidTypes.contains(t)) {
                                 chosen = t;
                                 break;
                             }
@@ -2388,11 +2371,10 @@ public class ComputerUtil {
                 }
             }
             if (StringUtils.isEmpty(chosen)) {
-                chosen = Iterables.getFirst(validTypes, null);
+                chosen = "Island";
             }
-            chosenList.add(chosen);
         }
-        return chosenList;
+        return chosen;
     }
 
     public static Object vote(Player ai, List<Object> options, SpellAbility sa, Multimap<Object, Player> votes, Player forPlayer) {
@@ -2413,23 +2395,26 @@ public class ComputerUtil {
         case "Torture":
             return "Torture";
         case "GraceOrCondemnation":
-            return ai.getCreaturesInPlay().size() > ComputerUtil.getOpponentFor(ai).getCreaturesInPlay().size() ? "Grace"
-                    : "Condemnation";
+            List<ZoneType> graceZones = new ArrayList<ZoneType>();
+            graceZones.add(ZoneType.Battlefield);
+            graceZones.add(ZoneType.Graveyard);
+            CardCollection graceCreatures = CardLists.getType(sa.getHostCard().getGame().getCardsIn(graceZones), "Creature");
+            int humanGrace = CardLists.filterControlledBy(graceCreatures, ai.getOpponents()).size();
+            int aiGrace = CardLists.filterControlledBy(graceCreatures, ai).size();
+            return aiGrace > humanGrace ? "Grace" : "Condemnation";
         case "CarnageOrHomage":
-            CardCollection cardsInPlay = CardLists
-                    .getNotType(sa.getHostCard().getGame().getCardsIn(ZoneType.Battlefield), "Land");
+            CardCollection cardsInPlay = CardLists.getNotType(sa.getHostCard().getGame().getCardsIn(ZoneType.Battlefield), "Land");
             CardCollection humanlist = CardLists.filterControlledBy(cardsInPlay, ai.getOpponents());
-            CardCollection computerlist = CardLists.filterControlledBy(cardsInPlay, ai);
-            return (ComputerUtilCard.evaluatePermanentList(computerlist) + 3) < ComputerUtilCard
-                    .evaluatePermanentList(humanlist) ? "Carnage" : "Homage";
+            CardCollection computerlist = ai.getCreaturesInPlay();
+            return (ComputerUtilCard.evaluatePermanentList(computerlist) + 3) < ComputerUtilCard.evaluatePermanentList(humanlist) ? "Carnage" : "Homage";
         case "Judgment":
             if (votes.isEmpty()) {
                 CardCollection list = new CardCollection();
                 for (Object o : options) {
                     if (o instanceof Card) {
                         list.add((Card) o);
-                        }
                     }
+                }
                 return ComputerUtilCard.getBestAI(list);
             } else {
                 return Iterables.getFirst(votes.keySet(), null);
@@ -2460,8 +2445,7 @@ public class ComputerUtil {
             if (!source.canReceiveCounters(p1p1Type)) {
                 return opponent ? "Feather" : "Quill";
             }
-            // if source is not on the battlefield anymore, choose +1/+1
-            // ones
+            // if source is not on the battlefield anymore, choose +1/+1 ones
             if (!game.getCardState(source).isInZone(ZoneType.Battlefield)) {
                 return opponent ? "Feather" : "Quill";
             }
@@ -2503,8 +2487,7 @@ public class ComputerUtil {
                 return opponent ? "Numbers" : "Strength";
             }
 
-            // TODO check for ETB to +1/+1 counters
-            // or over another trigger like lifegain
+            // TODO check for ETB to +1/+1 counters or over another trigger like lifegain
 
             int tokenScore = ComputerUtilCard.evaluateCreature(token);
 
@@ -2582,8 +2565,7 @@ public class ComputerUtil {
                 return "Taxes";
             } else {
                 // ai is first voter or ally of controller
-                // both are not affected, but if opponents controll creatures,
-                // sacrifice is worse
+                // both are not affected, but if opponents control creatures, sacrifice is worse
                 return controller.getOpponents().getCreaturesInPlay().isEmpty() ? "Taxes" : "Death";
             }
         default:
@@ -2667,7 +2649,7 @@ public class ComputerUtil {
                 continue;
             }
             if (trigger.hasParam("ValidCard")) {
-                if (!card.isValid(trigger.getParam("ValidCard"), source.getController(), source, sa)) {
+                if (!card.isValid(trigger.getParam("ValidCard").split(","), source.getController(), source, sa)) {
                     continue;
                 }
             }
@@ -2880,7 +2862,6 @@ public class ComputerUtil {
     }
 
     public static boolean lifegainNegative(final Player player, final Card source, final int n) {
-
         if (!player.canGainLife()) {
             return false;
         }
@@ -2948,23 +2929,6 @@ public class ComputerUtil {
         return true;
     }
 
-
-    @Deprecated
-    public static final Player getOpponentFor(final Player player) {
-        // 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;
@@ -3047,33 +3011,34 @@ public class ComputerUtil {
     // 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;
+        for (Player opponent: ai.getOpponents()) {
+            // 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;
             }
         }
-        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

@@ -171,8 +171,12 @@ public class ComputerUtilAbility {
         return sa;
     }
 
+    public static Card getAbilitySource(SpellAbility sa) {
+        return sa.getOriginalHost() != null ? sa.getOriginalHost() : sa.getHostCard();
+    }
+
     public static String getAbilitySourceName(SpellAbility sa) {
-        final Card c = sa.getOriginalOrHost();
+        final Card c = getAbilitySource(sa);
         return c != null ? c.getName() : "";
     }
 

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

@@ -47,6 +47,7 @@ import forge.game.combat.Combat;
 import forge.game.combat.CombatUtil;
 import forge.game.cost.Cost;
 import forge.game.cost.CostPayEnergy;
+import forge.game.cost.CostRemoveCounter;
 import forge.game.keyword.Keyword;
 import forge.game.keyword.KeywordCollection;
 import forge.game.keyword.KeywordInterface;
@@ -76,7 +77,7 @@ public class ComputerUtilCard {
                 }
             });
         }
-        return ComputerUtilCard.getMostExpensivePermanentAI(all);
+        return getMostExpensivePermanentAI(all);
     }
 
     /**
@@ -137,6 +138,56 @@ public class ComputerUtilCard {
         return Aggregates.itemWithMin(all, CardPredicates.Accessors.fnGetCmc);
     }
 
+    public static 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(CounterEnumType.LOYALTY);
+            int pwScore = curLoyalty * 10;
+
+            for (SpellAbility sa : pw.getSpellAbilities()) {
+                if (sa.hasParam("Ultimate")) {
+                    Integer 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 != null && loyaltyCost != 0 && loyaltyCost - curLoyalty <= 1) {
+                        // Will ultimate soon
+                        pwScore += 10000;
+                    }
+
+                    if (pwScore > bestScore) {
+                        bestScore = pwScore;
+                        bestTgt = pw;
+                    }
+                }
+            }
+        }
+
+        return bestTgt;
+    }
+
+    public static Card getWorstPlaneswalkerToDamage(final List<Card> pws) {
+        Card bestTgt = null;
+
+        int bestScore = Integer.MAX_VALUE;
+        for (Card pw : pws) {
+            int curLoyalty = pw.getCounters(CounterEnumType.LOYALTY);
+
+            if (curLoyalty < bestScore) {
+                bestScore = curLoyalty;
+                bestTgt = pw;
+            }
+        }
+
+        return bestTgt;
+    }
+
     // The AI doesn't really pick the best enchantment, just the most expensive.
     /**
      * <p>
@@ -217,6 +268,63 @@ public class ComputerUtilCard {
         return Aggregates.random(bLand); // random tapped land of least represented type
     }
 
+    /**
+     * <p>
+     * getWorstLand.
+     * </p>
+     * 
+     * @param lands
+     * @return a {@link forge.game.card.Card} object.
+     */
+    public static Card getWorstLand(final List<Card> lands) {
+        Card worstLand = null;
+        int maxScore = Integer.MIN_VALUE;
+        // first, check for tapped, basic lands
+        for (Card tmp : lands) {
+            int score = tmp.isTapped() ? 2 : 0;
+            score += tmp.isBasicLand() ? 1 : 0;
+            score -= tmp.isCreature() ? 4 : 0;
+            for (Card aura : tmp.getEnchantedBy()) {
+                if (aura.getController().isOpponentOf(tmp.getController())) {
+                    score += 5;
+                } else {
+                    score -= 5;
+                }
+            }
+            if (score == maxScore &&
+                    CardLists.count(lands, CardPredicates.sharesNameWith(tmp)) > CardLists.count(lands, CardPredicates.sharesNameWith(worstLand))) {
+                worstLand = tmp;
+            }
+            if (score > maxScore) {
+                worstLand = tmp;
+                maxScore = score;
+            }
+        }
+        return worstLand;
+    }
+
+    public static Card getBestLandToAnimate(final Iterable<Card> lands) {
+        Card land = null;
+        int maxScore = Integer.MIN_VALUE;
+        // first, check for tapped, basic lands
+        for (Card tmp : lands) {
+            int score = tmp.isTapped() ? 0 : 2;
+            score += tmp.isBasicLand() ? 2 : 0;
+            score -= tmp.isCreature() ? 4 : 0;
+            score -= 5 * tmp.getEnchantedBy().size();
+
+            if (score == maxScore &&
+                    CardLists.count(lands, CardPredicates.sharesNameWith(tmp)) > CardLists.count(lands, CardPredicates.sharesNameWith(land))) {
+                land = tmp;
+            }
+            if (score > maxScore) {
+                land = tmp;
+                maxScore = score;
+            }
+        }
+        return land;
+    }
+
     /**
      * <p>
      * getCheapestPermanentAI.
@@ -265,16 +373,14 @@ public class ComputerUtilCard {
      * @return a {@link forge.game.card.Card} object.
      */
     public static Card getBestAI(final Iterable<Card> list) {
-        // Get Best will filter by appropriate getBest list if ALL of the list
-        // is of that type
+        // Get Best will filter by appropriate getBest list if ALL of the list is of that type
         if (Iterables.all(list, CardPredicates.Presets.CREATURES)) {
             return ComputerUtilCard.getBestCreatureAI(list);
         }
         if (Iterables.all(list, CardPredicates.Presets.LANDS)) {
             return getBestLandAI(list);
         }
-        // TODO - Once we get an EvaluatePermanent this should call
-        // getBestPermanent()
+        // TODO - Once we get an EvaluatePermanent this should call getBestPermanent()
         return ComputerUtilCard.getMostExpensivePermanentAI(list);
     }
 
@@ -383,7 +489,7 @@ public class ComputerUtilCard {
         }
 
         if (biasLand && Iterables.any(list, CardPredicates.Presets.LANDS)) {
-            return ComputerUtilCard.getWorstLand(CardLists.filter(list, CardPredicates.Presets.LANDS));
+            return getWorstLand(CardLists.filter(list, CardPredicates.Presets.LANDS));
         }
     
         final boolean hasCreatures = Iterables.any(list, CardPredicates.Presets.CREATURES);
@@ -393,7 +499,7 @@ public class ComputerUtilCard {
     
         List<Card> lands = CardLists.filter(list, CardPredicates.Presets.LANDS);
         if (lands.size() > 6) {
-            return ComputerUtilCard.getWorstLand(lands);
+            return getWorstLand(lands);
         }
     
         if (hasEnchantmants || hasArtifacts) {
@@ -410,8 +516,7 @@ public class ComputerUtilCard {
             return getWorstCreatureAI(CardLists.filter(list, CardPredicates.Presets.CREATURES));
         }
     
-        // Planeswalkers fall through to here, lands will fall through if there
-        // aren't very many
+        // Planeswalkers fall through to here, lands will fall through if there aren't very many
         return getCheapestPermanentAI(list, null, false);
     }
 
@@ -444,7 +549,7 @@ public class ComputerUtilCard {
     public static final Comparator<Card> EvaluateCreatureComparator = new Comparator<Card>() {
         @Override
         public int compare(final Card a, final Card b) {
-            return ComputerUtilCard.evaluateCreature(b) - ComputerUtilCard.evaluateCreature(a);
+            return evaluateCreature(b) - evaluateCreature(a);
         }
     };
 
@@ -550,7 +655,7 @@ public class ComputerUtilCard {
      */
     public static CardCollectionView getLikelyBlockers(final Player ai, final CardCollectionView blockers) {
         AiBlockController aiBlk = new AiBlockController(ai);
-        final Player opp = ai.getWeakestOpponent();
+        final Player opp = AiAttackController.choosePreferredDefenderPlayer(ai);
         Combat combat = new Combat(opp);
         //Use actual attackers if available, else consider all possible attackers
         Combat currentCombat = ai.getGame().getCombat();
@@ -828,69 +933,19 @@ public class ComputerUtilCard {
         return result;
     }
 
-
-    /**
-     * <p>
-     * getWorstLand.
-     * </p>
-     * 
-     * @param lands
-     * @return a {@link forge.game.card.Card} object.
-     */
-    public static Card getWorstLand(final List<Card> lands) {
-        Card worstLand = null;
-        int maxScore = Integer.MIN_VALUE;
-        // first, check for tapped, basic lands
-        for (Card tmp : lands) {
-            int score = tmp.isTapped() ? 2 : 0;
-            score += tmp.isBasicLand() ? 1 : 0;
-            score -= tmp.isCreature() ? 4 : 0;
-            for (Card aura : tmp.getEnchantedBy()) {
-            	if (aura.getController().isOpponentOf(tmp.getController())) {
-            		score += 5;
-            	} else {
-            		score -= 5;
-            	}
-            }
-            if (score >= maxScore) {
-                worstLand = tmp;
-                maxScore = score;
-            }
-        }
-        return worstLand;
-    } // end getWorstLand
-
-    public static Card getBestLandToAnimate(final Iterable<Card> lands) {
-        Card land = null;
-        int maxScore = Integer.MIN_VALUE;
-        // first, check for tapped, basic lands
-        for (Card tmp : lands) {
-            // TODO Improve this by choosing basic lands that I have plenty of mana in
-            int score = tmp.isTapped() ? 0 : 2;
-            score += tmp.isBasicLand() ? 2 : 0;
-            score -= tmp.isCreature() ? 4 : 0;
-            score -= 5 * tmp.getEnchantedBy().size();
-
-            if (score >= maxScore) {
-                land = tmp;
-                maxScore = score;
-            }
-        }
-        return land;
-    } // end getBestLandToAnimate
-
     public static final Predicate<Deck> AI_KNOWS_HOW_TO_PLAY_ALL_CARDS = new Predicate<Deck>() {
         @Override
         public boolean apply(Deck d) {
-            for(Entry<DeckSection, CardPool> cp: d) {
-                for(Entry<PaperCard, Integer> e : cp.getValue()) {
-                    if ( e.getKey().getRules().getAiHints().getRemAIDecks() )
+            for (Entry<DeckSection, CardPool> cp: d) {
+                for (Entry<PaperCard, Integer> e : cp.getValue()) {
+                    if (e.getKey().getRules().getAiHints().getRemAIDecks())
                         return false;
                 }
             }
             return true;
         }
     };
+
     public static List<String> chooseColor(SpellAbility sa, int min, int max, List<String> colorChoices) {
         List<String> chosen = new ArrayList<>();
         Player ai = sa.getActivatingPlayer();
@@ -1198,7 +1253,7 @@ public class ComputerUtilCard {
                     }
                     String kws = params.get("AddKeyword");
                     if (kws != null) {
-                        bonusPT += 4 * (1 + StringUtils.countMatches(kws, "&"));    //treat each added keyword as a +2/+2 for now
+                        bonusPT += 4 * (1 + StringUtils.countMatches(kws, "&")); //treat each added keyword as a +2/+2 for now
                     }
                     if (bonusPT > 0) {
                         threat = bonusPT * (1 + opp.getCreaturesInPlay().size()) / 10.0f;
@@ -1212,7 +1267,7 @@ public class ComputerUtilCard {
         }
         
         final float valueNow = Math.max(valueTempo, threat);
-        if (valueNow < 0.2) {   //hard floor to reduce ridiculous odds for instants over time
+        if (valueNow < 0.2) { //hard floor to reduce ridiculous odds for instants over time
             return false;
         }
         final float chance = MyRandom.getRandom().nextFloat();
@@ -1310,7 +1365,7 @@ public class ComputerUtilCard {
                     threat *= 2;
                 }
                 if (c.getNetPower() == 0 && c == sa.getHostCard() && power > 0 ) {
-                    threat *= 4;    //over-value self +attack for 0 power creatures which may be pumped further after attacking 
+                    threat *= 4; //over-value self +attack for 0 power creatures which may be pumped further after attacking 
                 }
                 chance += threat;
 
@@ -1595,7 +1650,7 @@ public class ComputerUtilCard {
      */
     public static Card getPumpedCreature(final Player ai, final SpellAbility sa,
             final Card c, int toughness, int power, final List<String> keywords) {
-        Card pumped = CardFactory.copyCard(c, true);
+        Card pumped = CardFactory.copyCard(c, false);
         pumped.setSickness(c.hasSickness());
         final long timestamp = c.getGame().getNextTimestamp();
         final List<String> kws = new ArrayList<>();
@@ -1633,7 +1688,7 @@ public class ComputerUtilCard {
         pumped.addChangedCardKeywords(kws, null, false, false, timestamp);
         Set<CounterType> types = c.getCounters().keySet();
         for(CounterType ct : types) {
-            pumped.addCounterFireNoEvents(ct, c.getCounters(ct), ai, true, null);
+            pumped.addCounterFireNoEvents(ct, c.getCounters(ct), ai, sa, true, null);
         }
         //Copies tap-state and extra keywords (auras, equipment, etc.) 
         if (c.isTapped()) {
@@ -1644,11 +1699,12 @@ public class ComputerUtilCard {
         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);
+            KeywordInterface copiedKI = k.copy(c, true);
+            if (!copiedKeywords.contains(copiedKI.getOriginal())) {
+                if (copiedKI.getHidden()) {
+                    pumped.addHiddenExtrinsicKeyword(copiedKI);
                 } else {
-                    toCopy.add(k);
+                    toCopy.add(copiedKI);
                 }
             }
         }
@@ -1678,37 +1734,27 @@ public class ComputerUtilCard {
             // remove old boost that might be copied
             for (final StaticAbility stAb : c.getStaticAbilities()) {
                 vCard.removePTBoost(c.getTimestamp(), stAb.getId());
-                final Map<String, String> params = stAb.getMapParams();
-                if (!params.get("Mode").equals("Continuous")) {
+                if (!stAb.getParam("Mode").equals("Continuous")) {
                     continue;
                 }
-                if (!params.containsKey("Affected")) {
+                if (!stAb.hasParam("Affected")) {
                     continue;
                 }
-                if (!params.containsKey("AddPower") && !params.containsKey("AddToughness")) {
+                if (!stAb.hasParam("AddPower") && !stAb.hasParam("AddToughness")) {
                     continue;
                 }
-                final String valid = params.get("Affected");
-                if (!vCard.isValid(valid, c.getController(), c, null)) {
+                if (!vCard.isValid(stAb.getParam("Affected").split(","), c.getController(), c, stAb)) {
                     continue;
                 }
                 int att = 0;
-                if (params.containsKey("AddPower")) {
-                    String addP = params.get("AddPower");
-                    if (addP.equals("AffectedX")) {
-                        att = CardFactoryUtil.xCount(vCard, AbilityUtils.getSVar(stAb, addP));
-                    } else {
-                        att = AbilityUtils.calculateAmount(c, addP, stAb);
-                    }
+                if (stAb.hasParam("AddPower")) {
+                    String addP = stAb.getParam("AddPower");
+                    att = AbilityUtils.calculateAmount(addP.startsWith("Affected") ? vCard : c, addP, stAb, true);
                 }
                 int def = 0;
-                if (params.containsKey("AddToughness")) {
-                    String addT = params.get("AddToughness");
-                    if (addT.equals("AffectedY")) {
-                        def = CardFactoryUtil.xCount(vCard, AbilityUtils.getSVar(stAb, addT));
-                    } else {
-                        def = AbilityUtils.calculateAmount(c, addT, stAb);
-                    }
+                if (stAb.hasParam("AddToughness")) {
+                    String addT = stAb.getParam("AddToughness");
+                    def = AbilityUtils.calculateAmount(addT.startsWith("Affected") ? vCard : c, addT, stAb, true);
                 }
                 vCard.addPTBoost(att, def, c.getTimestamp(), stAb.getId());
             }

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

@@ -33,7 +33,6 @@ 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.CardPredicates;
 import forge.game.card.CardUtil;
@@ -97,34 +96,39 @@ public class ComputerUtilCombat {
      * canAttackNextTurn.
      * </p>
      *
-     * @param atacker
+     * @param attacker
      *            a {@link forge.game.card.Card} object.
      * @param defender
      *            the defending {@link GameEntity}.
      * @return a boolean.
      */
-    public static boolean canAttackNextTurn(final Card atacker, final GameEntity defender) {
-        if (!atacker.isCreature()) {
+    public static boolean canAttackNextTurn(final Card attacker, final GameEntity defender) {
+        if (!attacker.isCreature()) {
             return false;
         }
-        if (!CombatUtil.canAttackNextTurn(atacker, defender)) {
+        if (!CombatUtil.canAttackNextTurn(attacker, defender)) {
             return false;
         }
 
-        for (final KeywordInterface inst : atacker.getKeywords()) {
+        for (final KeywordInterface inst : attacker.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);
+                final Player player = AbilityUtils.getDefinedPlayers(attacker, defined, null).get(0);
                 if (!defender.equals(player)) {
                     return false;
                 }
             }
         }
 
+        // TODO this should be a factor but needs some alignment with AttachAi
+        //boolean leavesPlay = !ComputerUtilCard.hasActiveUndyingOrPersist(attacker)
+        //        && ((attacker.hasKeyword(Keyword.VANISHING) && attacker.getCounters(CounterEnumType.TIME) == 1)
+        //        || (attacker.hasKeyword(Keyword.FADING) && attacker.getCounters(CounterEnumType.FADE) == 0)
+        //        || attacker.hasSVar("EndOfTurnLeavePlay"));
         // The creature won't untap next turn
-        return !atacker.isTapped() || Untap.canUntap(atacker);
-    } // canAttackNextTurn(Card, GameEntity)
+        return !attacker.isTapped() || Untap.canUntap(attacker);
+    }
 
     /**
      * <p>
@@ -330,7 +334,7 @@ public class ComputerUtilCombat {
      */
     public static int resultingPoison(final Player ai, final Combat combat) {
 
-        // ai can't get poision counters, so the value can't change
+        // ai can't get poison counters, so the value can't change
         if (!ai.canReceiveCounters(CounterEnumType.POISON)) {
             return ai.getPoisonCounters();
         }
@@ -408,7 +412,6 @@ public class ComputerUtilCombat {
             return false;
         }
 
-
         // check for creatures that must be blocked
         final List<Card> attackers = combat.getAttackersOf(ai);
 
@@ -469,7 +472,6 @@ public class ComputerUtilCombat {
      * @return a boolean.
      */
     public static boolean wouldLoseLife(final Player ai, final Combat combat) {
-
         return (ComputerUtilCombat.lifeThatWouldRemain(ai, combat) < ai.getLife());
     }
 
@@ -488,8 +490,7 @@ public class ComputerUtilCombat {
     }
 
     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
+        // life in danger only cares about the player's life. Not about a Planeswalkers life
         if (ai.cantLose() || combat == null) {
             return false;
         }
@@ -564,8 +565,7 @@ public class ComputerUtilCombat {
         return damage;
     }
 
-    // This calculates the amount of damage a blocker in a blockgang can deal to
-    // the attacker
+    // This calculates the amount of damage a blocker in a blockgang can deal to the attacker
     /**
      * <p>
      * dealsDamageAsBlocker.
@@ -578,7 +578,6 @@ public class ComputerUtilCombat {
      * @return a int.
      */
     public static int dealsDamageAsBlocker(final Card attacker, final Card defender) {
-
         int defenderDamage = predictDamageByBlockerWithoutDoubleStrike(attacker, defender);
 
         if (defender.hasKeyword(Keyword.DOUBLE_STRIKE)) {
@@ -643,7 +642,6 @@ public class ComputerUtilCombat {
      * @return a int.
      */
     public static int totalShieldDamage(final Card attacker, final List<Card> defenders) {
-
         int defenderDefense = 0;
 
         for (final Card defender : defenders) {
@@ -667,7 +665,6 @@ public class ComputerUtilCombat {
      * @return a int.
      */
     public static int shieldDamage(final Card attacker, final Card blocker) {
-
         if (ComputerUtilCombat.canDestroyBlockerBeforeFirstStrike(blocker, attacker, false)) {
         	return 0;
         }
@@ -772,7 +769,6 @@ public class ComputerUtilCombat {
     public static boolean combatTriggerWillTrigger(final Card attacker, final Card defender, final Trigger trigger,
             Combat combat, final List<Card> plannedAttackers) {
         final Game game = attacker.getGame();
-        final Map<String, String> trigParams = trigger.getMapParams();
         boolean willTrigger = false;
         final Card source = trigger.getHostCard();
         if (combat == null) {
@@ -795,29 +791,27 @@ public class ComputerUtilCombat {
             if (combat.isAttacking(attacker)) {
                 return false; // The trigger should have triggered already
             }
-            if (trigParams.containsKey("ValidCard")) {
-                if (!trigger.matchesValid(attacker, trigParams.get("ValidCard").split(","))
-                        && !(combat.isAttacking(source) && trigger.matchesValid(source,
-                        trigParams.get("ValidCard").split(","))
-                            && !trigParams.containsKey("Alone"))) {
+            if (trigger.hasParam("ValidCard")) {
+                if (!trigger.matchesValidParam("ValidCard", attacker)
+                        && !(combat.isAttacking(source) && trigger.matchesValidParam("ValidCard", source)
+                            && !trigger.hasParam("Alone"))) {
                     return false;
                 }
             }
-            if (trigParams.containsKey("Attacked")) {
-            	if (combat.isAttacking(attacker)) {
-	            	GameEntity attacked = combat.getDefenderByAttacker(attacker);
-	                if (!trigger.matchesValid(attacked, trigParams.get("Attacked").split(","))) {
-	                    return false;
-	                }
-            	} else {
-            		if ("You,Planeswalker.YouCtrl".equals(trigParams.get("Attacked"))) {
-            			if (source.getController() == attacker.getController()) {
-            				return false;
-            			}
-            		}
-            	}
+            if (trigger.hasParam("Attacked")) {
+                if (combat.isAttacking(attacker)) {
+                    if (!trigger.matchesValidParam("Attacked", combat.getDefenderByAttacker(attacker))) {
+                        return false;
+                    }
+                } else {
+                    if ("You,Planeswalker.YouCtrl".equals(trigger.getParam("Attacked"))) {
+                        if (source.getController() == attacker.getController()) {
+                            return false;
+                        }
+                    }
+                }
             }
-            if (trigParams.containsKey("Alone") && plannedAttackers != null && plannedAttackers.size() != 1) {
+            if (trigger.hasParam("Alone") && plannedAttackers != null && plannedAttackers.size() != 1) {
                 return false; // won't trigger since the AI is planning to attack with more than one creature
             }
         }
@@ -825,10 +819,8 @@ public class ComputerUtilCombat {
         // defender == null means unblocked
         if ((defender == null) && mode == TriggerType.AttackerUnblocked) {
             willTrigger = true;
-            if (trigParams.containsKey("ValidCard")) {
-                if (!trigger.matchesValid(attacker, trigParams.get("ValidCard").split(","))) {
-                    return false;
-                }
+            if (!trigger.matchesValidParam("ValidCard", attacker)) {
+                return false;
             }
         }
 
@@ -838,8 +830,8 @@ public class ComputerUtilCombat {
 
         if (mode == TriggerType.Blocks) {
             willTrigger = true;
-            if (trigParams.containsKey("ValidBlocked")) {
-                String validBlocked = trigParams.get("ValidBlocked");
+            if (trigger.hasParam("ValidBlocked")) {
+                String validBlocked = trigger.getParam("ValidBlocked");
                 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
@@ -852,8 +844,8 @@ public class ComputerUtilCombat {
                     return false;
                 }
             }
-            if (trigParams.containsKey("ValidCard")) {
-                String validBlocker = trigParams.get("ValidCard");
+            if (trigger.hasParam("ValidCard")) {
+                String validBlocker = trigger.getParam("ValidCard");
                 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
@@ -868,29 +860,23 @@ public class ComputerUtilCombat {
             }
         } else if (mode == TriggerType.AttackerBlocked || mode == TriggerType.AttackerBlockedByCreature) {
             willTrigger = true;
-            if (trigParams.containsKey("ValidBlocker")) {
-                if (!trigger.matchesValid(defender, trigParams.get("ValidBlocker").split(","))) {
-                    return false;
-                }
+            if (!trigger.matchesValidParam("ValidBlocker", defender)) {
+                return false;
             }
-            if (trigParams.containsKey("ValidCard")) {
-                if (!trigger.matchesValid(attacker, trigParams.get("ValidCard").split(","))) {
-                    return false;
-                }
+            if (!trigger.matchesValidParam("ValidCard", attacker)) {
+                return false;
             }
         } else if (mode == TriggerType.DamageDone) {
             willTrigger = true;
-            if (trigParams.containsKey("ValidSource")) {
-                if (!(trigger.matchesValid(defender, trigParams.get("ValidSource").split(","))
+            if (trigger.hasParam("ValidSource")) {
+                if (!(trigger.matchesValidParam("ValidSource", defender)
                         && defender.getNetCombatDamage() > 0
-                        && (!trigParams.containsKey("ValidTarget")
-                                || trigger.matchesValid(attacker, trigParams.get("ValidTarget").split(","))))) {
+                        && trigger.matchesValidParam("ValidTarget", attacker))) {
                     return false;
                 }
-                if (!(trigger.matchesValid(attacker, trigParams.get("ValidSource").split(","))
+                if (!(trigger.matchesValidParam("ValidSource", attacker)
                         && attacker.getNetCombatDamage() > 0
-                        && (!trigParams.containsKey("ValidTarget")
-                        || trigger.matchesValid(defender, trigParams.get("ValidTarget").split(","))))) {
+                        && trigger.matchesValidParam("ValidTarget", defender))) {
                     return false;
                 }
             }
@@ -939,30 +925,22 @@ public class ComputerUtilCombat {
         }
 
         final Game game = attacker.getGame();
-        // look out for continuous static abilities that only care for blocking
-        // creatures
+        // look out for continuous static abilities that only care for blocking 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")) {
+                if (!stAb.getParam("Mode").equals("Continuous")) {
                     continue;
                 }
-                if (!params.containsKey("Affected") || !params.get("Affected").contains("blocking")) {
+                if (!stAb.hasParam("Affected") || !stAb.getParam("Affected").contains("blocking")) {
                     continue;
                 }
-                final String valid = TextUtil.fastReplace(params.get("Affected"), "blocking", "Creature");
-                if (!blocker.isValid(valid, card.getController(), card, null)) {
+                final String valid = TextUtil.fastReplace(stAb.getParam("Affected"), "blocking", "Creature");
+                if (!blocker.isValid(valid, card.getController(), card, stAb)) {
                     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 (stAb.hasParam("AddPower")) {
+                    power += AbilityUtils.calculateAmount(card, stAb.getParam("AddPower"), stAb);
                 }
             }
         }
@@ -1247,31 +1225,23 @@ public class ComputerUtilCombat {
             theTriggers.addAll(blocker.getTriggers());
         }
 
-        // look out for continuous static abilities that only care for attacking
-        // creatures
+        // look out for continuous static abilities that only care for attacking creatures
         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")) {
+                    if (!stAb.getParam("Mode").equals("Continuous")) {
                         continue;
                     }
-                    if (!params.containsKey("Affected") || !params.get("Affected").contains("attacking")) {
+                    if (!stAb.hasParam("Affected") || !stAb.getParam("Affected").contains("attacking")) {
                         continue;
                     }
-                    final String valid = TextUtil.fastReplace(params.get("Affected"), "attacking", "Creature");
-                    if (!attacker.isValid(valid, card.getController(), card, null)) {
+                    final String valid = TextUtil.fastReplace(stAb.getParam("Affected"), "attacking", "Creature");
+                    if (!attacker.isValid(valid, card.getController(), card, stAb)) {
                         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 (stAb.hasParam("AddPower")) {
+                        power += AbilityUtils.calculateAmount(card, stAb.getParam("AddPower"), stAb);
                     }
                 }
             }
@@ -1345,7 +1315,7 @@ public class ComputerUtilCombat {
                 } else if (bonus.contains("TriggeredAttacker$CardToughness")) {
                     bonus = TextUtil.fastReplace(bonus, "TriggeredAttacker$CardToughness", TextUtil.concatNoSpace("Number$", String.valueOf(attacker.getNetToughness())));
                 }
-                power += CardFactoryUtil.xCount(source, bonus);
+                power += AbilityUtils.calculateAmount(source, bonus, sa);
 
             }
         }
@@ -1442,8 +1412,7 @@ public class ComputerUtilCombat {
             theTriggers.addAll(blocker.getTriggers());
         }
 
-        // look out for continuous static abilities that only care for attacking
-        // creatures
+        // look out for continuous static abilities that only care for attacking creatures
         if (!withoutCombatStaticAbilities) {
             final CardCollectionView cardList = game.getCardsIn(ZoneType.Battlefield);
             for (final Card card : cardList) {
@@ -1535,7 +1504,7 @@ public class ComputerUtilCombat {
                     } else if (bonus.contains("TriggeredPlayersDefenders$Amount")) { // for Melee
                         bonus = TextUtil.fastReplace(bonus, "TriggeredPlayersDefenders$Amount", "Number$1");
                     }
-                    toughness += CardFactoryUtil.xCount(source, bonus);
+                    toughness += AbilityUtils.calculateAmount(source, bonus, sa);
                 }
             } else if (ApiType.PumpAll.equals(sa.getApi())) {
 
@@ -1568,7 +1537,7 @@ public class ComputerUtilCombat {
                     } else if (bonus.contains("TriggeredPlayersDefenders$Amount")) { // for Melee
                         bonus = TextUtil.fastReplace(bonus, "TriggeredPlayersDefenders$Amount", "Number$1");
                     }
-                    toughness += CardFactoryUtil.xCount(source, bonus);
+                    toughness += AbilityUtils.calculateAmount(source, bonus, sa);
                 }
             }
         }
@@ -1633,8 +1602,8 @@ public class ComputerUtilCombat {
 
         //Check triggers that deal damage or shrink the attacker
         if (ComputerUtilCombat.getDamageToKill(attacker)
-        		+ ComputerUtilCombat.predictToughnessBonusOfAttacker(attacker, blocker, combat, withoutAbilities) <= 0) {
-        	return true;
+                + ComputerUtilCombat.predictToughnessBonusOfAttacker(attacker, blocker, combat, withoutAbilities) <= 0) {
+            return true;
         }
 
         // check Destroy triggers (Cockatrice and friends)
@@ -2251,11 +2220,12 @@ public class ComputerUtilCombat {
      * @return a int.
      */
     public final static int getDamageToKill(final Card c) {
-        int killDamage = c.getLethalDamage() + c.getPreventNextDamageTotalShields();
+        int damageShield = c.getPreventNextDamageTotalShields();
+        int killDamage = c.getLethalDamage() + damageShield;
 
-        if ((killDamage > c.getPreventNextDamageTotalShields())
+        if ((killDamage > damageShield)
                 && c.hasSVar("DestroyWhenDamaged")) {
-            killDamage = 1 + c.getPreventNextDamageTotalShields();
+            killDamage = 1 + damageShield;
         }
 
         return killDamage;
@@ -2277,7 +2247,6 @@ public class ComputerUtilCombat {
      */
 
     public final static int predictDamageTo(final Player target, final int damage, final Card source, final boolean isCombat) {
-
         final Game game = target.getGame();
         int restDamage = damage;
 
@@ -2286,39 +2255,38 @@ public class ComputerUtilCombat {
         // Predict replacement effects
         for (final Card ca : game.getCardsIn(ZoneType.STATIC_ABILITIES_SOURCE_ZONES)) {
             for (final ReplacementEffect re : ca.getReplacementEffects()) {
-                Map<String, String> params = re.getMapParams();
-                if (!re.getMode().equals(ReplacementType.DamageDone) || !params.containsKey("PreventionEffect")) {
+                if (!re.getMode().equals(ReplacementType.DamageDone) ||
+                        (!re.hasParam("PreventionEffect") && !re.hasParam("Prevent"))) {
                     continue;
                 }
                 // Immortal Coil prevents the damage but has a similar negative effect
                 if ("Immortal Coil".equals(ca.getName())) {
                     continue;
                 }
-                if (params.containsKey("ValidSource")
-                        && !source.isValid(params.get("ValidSource"), ca.getController(), ca, null)) {
+                if (!re.matchesValidParam("ValidSource", source)) {
                     continue;
                 }
-                if (params.containsKey("ValidTarget")
-                        && !target.isValid(params.get("ValidTarget"), ca.getController(), ca, null)) {
+                if (!re.matchesValidParam("ValidTarget", source)) {
                     continue;
                 }
-                if (params.containsKey("IsCombat")) {
-                    if (params.get("IsCombat").equals("True")) {
-                        if (!isCombat) {
-                            continue;
-                        }
-                    } else {
-                        if (isCombat) {
-                            continue;
-                        }
+                if (re.hasParam("IsCombat")) {
+                    if (re.getParam("IsCombat").equals("True") != isCombat) {
+                        continue;
+                    }
+                }
+                if (re.hasParam("Prevent")) {
+                    return 0;
+                } else if (re.getOverridingAbility() != null) {
+                    SpellAbility repSA = re.getOverridingAbility();
+                    if (repSA.getApi() == ApiType.ReplaceDamage) {
+                        return Math.max(0, restDamage - AbilityUtils.calculateAmount(ca, repSA.getParam("Amount"), repSA));
                     }
-
                 }
                 return 0;
             }
         }
 
-        restDamage = target.staticDamagePrevention(restDamage, source, isCombat, true);
+        restDamage = target.staticDamagePrevention(restDamage, 0, source, isCombat);
 
         return restDamage;
     }
@@ -2339,13 +2307,7 @@ public class ComputerUtilCombat {
     // This function helps the AI calculate the actual amount of damage an
     // effect would deal
     public final static int predictDamageTo(final Card target, final int damage, final Card source, final boolean isCombat) {
-
-        int restDamage = damage;
-
-        restDamage = target.staticReplaceDamage(restDamage, source, isCombat);
-        restDamage = target.staticDamagePrevention(restDamage, source, isCombat, true);
-
-        return restDamage;
+        return predictDamageTo(target, damage, 0, source, isCombat);
     }
 
 
@@ -2367,7 +2329,6 @@ public class ComputerUtilCombat {
      * @return a int.
      */
     public final static int predictDamageTo(final Card target, final int damage, final int possiblePrevention, final Card source, final boolean isCombat) {
-
         int restDamage = damage;
 
         restDamage = target.staticReplaceDamage(restDamage, source, isCombat);
@@ -2377,7 +2338,6 @@ public class ComputerUtilCombat {
     }
 
     public final static boolean dealsFirstStrikeDamage(final Card combatant, final boolean withoutAbilities, final Combat combat) {
-
         if (combatant.hasKeyword(Keyword.DOUBLE_STRIKE) || combatant.hasKeyword(Keyword.FIRST_STRIKE)) {
             return true;
         }
@@ -2485,7 +2445,14 @@ public class ComputerUtilCombat {
         List<ReplacementEffect> list = game.getReplacementHandler().getReplacementList(
                 ReplacementType.DamageDone, repParams, ReplacementLayer.Other);
 
-        return !list.isEmpty();
+        for (final ReplacementEffect re : list) {
+            Map<String, String> params = re.getMapParams();
+            if (params.containsKey("Prevent") ||
+                    (re.getOverridingAbility() != null && re.getOverridingAbility().getApi() != ApiType.ReplaceDamage && re.getOverridingAbility().getApi() != ApiType.ReplaceEffect)) {
+                return true;
+            }
+        }
+        return false;
     }
 
     public static boolean attackerHasThreateningAfflict(Card attacker, Player aiDefender) {
@@ -2494,20 +2461,6 @@ public class ComputerUtilCombat {
         return afflictDmg > attacker.getNetPower() || afflictDmg >= aiDefender.getLife();
     }
 
-    public static int getMaxAttackersFor(final GameEntity defender) {
-        if (defender instanceof Player) {
-            for (final Card card : ((Player) defender).getCardsIn(ZoneType.Battlefield)) {
-                if (card.hasKeyword("No more than one creature can attack you each combat.")) {
-                    return 1;
-                } else if (card.hasKeyword("No more than two creatures can attack you each combat.")) {
-                    return 2;
-                }
-            }
-        }
-
-        return -1;
-    }
-
     public static List<Card> categorizeAttackersByEvasion(List<Card> attackers) {
         List<Card> categorizedAttackers = Lists.newArrayList();
 
@@ -2597,5 +2550,3 @@ public class ComputerUtilCombat {
         return false;
     }
 }
-
-

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

@@ -3,10 +3,13 @@ package forge.ai;
 import java.util.List;
 import java.util.Set;
 
+import forge.game.ability.ApiType;
 import org.apache.commons.lang3.ObjectUtils;
 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.Sets;
 
@@ -19,6 +22,7 @@ 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.CardPredicates.Presets;
 import forge.game.card.CardUtil;
 import forge.game.card.CounterEnumType;
@@ -137,9 +141,8 @@ public class ComputerUtilCost {
      *            the source
      * @return true, if successful
      */
-
     public static boolean checkDiscardCost(final Player ai, final Cost cost, final Card source, SpellAbility sa) {
-        if (cost == null || source.hasSVar("AISkipDiscardCostCheck") /* FIXME: should not be needed! */ ) {
+        if (cost == null) {
             return true;
         }
 
@@ -157,7 +160,7 @@ public class ComputerUtilCost {
                 if (typeList.size() > ai.getMaxHandSize()) {
                     continue;
                 }
-                int num = AbilityUtils.calculateAmount(source, disc.getAmount(), null);
+                int num = AbilityUtils.calculateAmount(source, disc.getAmount(), sa);
 
                 for (int i = 0; i < num; i++) {
                     Card pref = ComputerUtil.getCardPreference(ai, source, "DiscardCost", typeList);
@@ -270,7 +273,10 @@ public class ComputerUtilCost {
                 }
 
                 final CardCollection sacList = new CardCollection();
-                final CardCollection typeList = CardLists.getValidCards(ai.getCardsIn(ZoneType.Battlefield), type.split(";"), source.getController(), source, sourceAbility);
+                CardCollection typeList = CardLists.getValidCards(ai.getCardsIn(ZoneType.Battlefield), type.split(";"), source.getController(), source, sourceAbility);
+
+                // don't sacrifice the card we're pumping
+                typeList = paymentChoicesWithoutTargets(typeList, sourceAbility, ai);
 
                 int count = 0;
                 while (count < amount) {
@@ -320,11 +326,14 @@ public class ComputerUtilCost {
                 }
 
                 final CardCollection sacList = new CardCollection();
-                final CardCollection typeList = CardLists.getValidCards(ai.getCardsIn(ZoneType.Battlefield), type.split(";"), source.getController(), source, sourceAbility);
+                CardCollection typeList = CardLists.getValidCards(ai.getCardsIn(ZoneType.Battlefield), type.split(";"), source.getController(), source, sourceAbility);
+
+                // don't sacrifice the card we're pumping
+                typeList = paymentChoicesWithoutTargets(typeList, sourceAbility, ai);
 
                 int count = 0;
                 while (count < amount) {
-                    Card prefCard = ComputerUtil.getCardPreference(ai, source, "SacCost", typeList);
+                    Card prefCard = ComputerUtil.getCardPreference(ai, source, "SacCost", typeList, sourceAbility);
                     if (prefCard == null) {
                         return false;
                     }
@@ -337,18 +346,31 @@ public class ComputerUtilCost {
         return true;
     }
 
+    /**
+     * Check sacrifice cost.
+     *
+     * @param cost
+     *            the cost
+     * @param source
+     *            the source
+     * @return true, if successful
+     */
+    public static boolean checkSacrificeCost(final Player ai, final Cost cost, final Card source, final SpellAbility sourceAbility) {
+        return checkSacrificeCost(ai, cost, source, sourceAbility, true);
+    }
+
     public static boolean isSacrificeSelfCost(final Cost cost) {
-    	 if (cost == null) {
-             return false;
-         }
-         for (final CostPart part : cost.getCostParts()) {
-             if (part instanceof CostSacrifice) {
-                 if ("CARDNAME".equals(part.getType())) {
-                	 return true;
-                 }
-             }
-         }
-         return false;
+        if (cost == null) {
+            return false;
+        }
+        for (final CostPart part : cost.getCostParts()) {
+            if (part instanceof CostSacrifice) {
+                if ("CARDNAME".equals(part.getType())) {
+                    return true;
+                }
+            }
+        }
+        return false;
     }
 
     /**
@@ -374,7 +396,7 @@ public class ComputerUtilCost {
                  * - break board stall by racing with evasive vehicle
                  */
                 if (sa.hasParam("Crew")) {
-                	Card vehicle = AnimateAi.becomeAnimated(source, sa);
+                    Card vehicle = AnimateAi.becomeAnimated(source, sa);
                     final int vehicleValue = ComputerUtilCard.evaluateCreature(vehicle);
                     String type = part.getType();
                     String totalP = type.split("withTotalPowerGE")[1];
@@ -391,25 +413,12 @@ public class ComputerUtilCost {
                     return ComputerUtil.chooseTapTypeAccumulatePower(ai, type, sa, true,
                             Integer.parseInt(totalP), exclude) != null;
                 }
-            	return false;
+                return false;
             }
         }
         return true;
     }
 
-    /**
-     * Check sacrifice cost.
-     *
-     * @param cost
-     *            the cost
-     * @param source
-     *            the source
-     * @return true, if successful
-     */
-    public static boolean checkSacrificeCost(final Player ai, final Cost cost, final Card source, final SpellAbility sourceAbility) {
-        return checkSacrificeCost(ai, cost, source, sourceAbility,true);
-    }
-
     /**
      * <p>
      * shouldPayCost.
@@ -420,8 +429,8 @@ public class ComputerUtilCost {
      * @param cost
      * @return a boolean.
      */
+    @Deprecated
     public static boolean shouldPayCost(final Player ai, final Card hostCard, final Cost cost) {
-
         for (final CostPart part : cost.getCostParts()) {
             if (part instanceof CostPayLife) {
                 if (!ai.cantLoseForZeroOrLessLife()) {
@@ -479,9 +488,9 @@ public class ComputerUtilCost {
                 }
             }
             for (Card c : player.getCardsIn(ZoneType.Command)) {
-            	if (cannotBeCountered) {
-            	    continue;
-            	}
+                if (cannotBeCountered) {
+                    continue;
+                }
                 final String snem = c.getSVar("SpellsNeedExtraManaEffect");
                 if (!StringUtils.isBlank(snem)) {
                     if (StringUtils.isNumeric(snem)) {
@@ -549,7 +558,7 @@ public class ComputerUtilCost {
         }
 
         return ComputerUtilMana.canPayManaCost(sa, player, extraManaNeeded)
-            && CostPayment.canPayAdditionalCosts(sa.getPayCosts(), sa);
+                && CostPayment.canPayAdditionalCosts(sa.getPayCosts(), sa);
     } // canPayCost()
 
     public static boolean willPayUnlessCost(SpellAbility sa, Player payer, Cost cost, boolean alreadyPaid, FCollectionView<Player> payers) {
@@ -558,7 +567,6 @@ public class ComputerUtilCost {
         boolean payForOwnOnly = "OnlyOwn".equals(aiLogic);
         boolean payOwner = sa.hasParam("UnlessAI") && aiLogic.startsWith("Defined");
         boolean payNever = "Never".equals(aiLogic);
-        boolean shockland = "Shockland".equals(aiLogic);
         boolean isMine = sa.getActivatingPlayer().equals(payer);
 
         if (payNever) { return false; }
@@ -573,26 +581,6 @@ public class ComputerUtilCost {
             if (sa.getHostCard() == null || payer.equals(sa.getHostCard().getController())) {
                 return false;
             }
-        } else if (shockland) {
-            if (payer.getLife() > 3 && payer.canPayLife(2)) {
-                final int landsize = payer.getLandsInPlay().size() + 1;
-                for (Card c : payer.getCardsIn(ZoneType.Hand)) {
-                    // if the new land size would equal the CMC of a card in AIs hand, consider playing it untapped,
-                    // otherwise don't bother running other checks
-                    if (landsize != c.getCMC()) {
-                        continue;
-                    }
-                    // try to determine in the AI is actually planning to play a spell ability from the card
-                    boolean willPlay = ComputerUtil.hasReasonToPlayCardThisTurn(payer, c);
-                    // try to determine if the mana shards provided by the lands would be applicable to pay the mana cost
-                    boolean canPay = c.getManaCost().canBePaidWithAvaliable(ColorSet.fromNames(getAvailableManaColors(payer, source)).getColor());
-
-                    if (canPay && willPlay) {
-                        return true;
-                    }
-                }
-            }
-            return false;
         } else if ("Paralyze".equals(aiLogic)) {
             final Card c = source.getEnchantingCard();
             if (c == null || c.isUntapped()) {
@@ -610,10 +598,10 @@ public class ComputerUtilCost {
                 return false;
             }
         } else if (aiLogic != null && aiLogic.startsWith("LifeLE")) {
-        	// if payer can't lose life its no need to pay unless
-        	if (!payer.canLoseLife())
-        		return false;
-        	else if (payer.getLife() <= Integer.valueOf(aiLogic.substring(6))) {
+            // if payer can't lose life its no need to pay unless
+            if (!payer.canLoseLife())
+                return false;
+            else if (payer.getLife() <= AbilityUtils.calculateAmount(source, aiLogic.substring(6), sa)) {
                 return true;
             }
         } else if ("WillAttack".equals(aiLogic)) {
@@ -630,6 +618,29 @@ public class ComputerUtilCost {
             return false;
         }
 
+        // Check for shocklands and similar ETB replacement effects
+        if (sa.hasParam("ETB") && sa.getApi().equals(ApiType.Tap)) {
+            for (final CostPart part : cost.getCostParts()) {
+                if (part instanceof CostPayLife) {
+                    final CostPayLife lifeCost = (CostPayLife) part;
+                    Integer amount = lifeCost.convertAmount();
+                    if (payer.getLife() > (amount + 1) && payer.canPayLife(amount)) {
+                        final int landsize = payer.getLandsInPlay().size() + 1;
+                        for (Card c : payer.getCardsIn(ZoneType.Hand)) {
+                            // Check if the AI has enough lands to play the card
+                            if (landsize != c.getCMC()) {
+                                continue;
+                            }
+                            // Check if the AI intends to play the card and if it can pay for it with the mana it has
+                            boolean willPlay = ComputerUtil.hasReasonToPlayCardThisTurn(payer, c);
+                            boolean canPay = c.getManaCost().canBePaidWithAvaliable(ColorSet.fromNames(getAvailableManaColors(payer, source)).getColor());
+                            return canPay && willPlay;
+                        }
+                    }
+                }
+            }
+        }
+
         // AI will only pay when it's not already payed and only opponents abilities
         if (alreadyPaid || (payers.size() > 1 && (isMine && !payForOwnOnly))) {
             return false;
@@ -639,13 +650,13 @@ public class ComputerUtilCost {
         // Didn't have any of the data on the original SA to pay dependant costs
 
         return checkLifeCost(payer, cost, source, 4, sa)
-            && checkDamageCost(payer, cost, source, 4)
-            && (isMine || checkSacrificeCost(payer, cost, source, sa))
-            && (isMine || checkDiscardCost(payer, cost, source, sa))
-            && (!source.getName().equals("Tyrannize") || payer.getCardsIn(ZoneType.Hand).size() > 2)
-            && (!source.getName().equals("Perplex") || payer.getCardsIn(ZoneType.Hand).size() < 2)
-            && (!source.getName().equals("Breaking Point") || payer.getCreaturesInPlay().size() > 1)
-            && (!source.getName().equals("Chain of Vapor") || (payer.getWeakestOpponent().getCreaturesInPlay().size() > 0 && payer.getLandsInPlay().size() > 3));
+                && checkDamageCost(payer, cost, source, 4)
+                && (isMine || checkSacrificeCost(payer, cost, source, sa))
+                && (isMine || checkDiscardCost(payer, cost, source, sa))
+                && (!source.getName().equals("Tyrannize") || payer.getCardsIn(ZoneType.Hand).size() > 2)
+                && (!source.getName().equals("Perplex") || payer.getCardsIn(ZoneType.Hand).size() < 2)
+                && (!source.getName().equals("Breaking Point") || payer.getCreaturesInPlay().size() > 1)
+                && (!source.getName().equals("Chain of Vapor") || (payer.getWeakestOpponent().getCreaturesInPlay().size() > 0 && payer.getLandsInPlay().size() > 3));
     }
 
     public static Set<String> getAvailableManaColors(Player ai, Card additionalLand) {
@@ -685,14 +696,14 @@ public class ComputerUtilCost {
     public static int getMaxXValue(SpellAbility sa, Player ai) {
         final Card source = sa.getHostCard();
         final SpellAbility root = sa.getRootAbility();
-        final Cost abCost = sa.getPayCosts();
+        final Cost abCost = root.getPayCosts();
         if (abCost == null || !abCost.hasXInAnyCostPart()) {
             return 0;
         }
 
         Integer val = null;
 
-        if (sa.costHasManaX()) {
+        if (root.costHasManaX()) {
             val = ComputerUtilMana.determineLeftoverMana(root, ai);
         }
 
@@ -739,4 +750,12 @@ public class ComputerUtilCost {
         }
         return ObjectUtils.defaultIfNull(val, 0);
     }
+
+    public static CardCollection paymentChoicesWithoutTargets(Iterable<Card> choices, SpellAbility source, Player ai) {
+        if (source.usesTargeting()) {
+            final CardCollection targets = new CardCollection(source.getTargets().getTargetCards());
+            choices = Iterables.filter(choices, Predicates.not(Predicates.and(CardPredicates.isController(ai), Predicates.in(targets))));
+        }
+        return new CardCollection(choices);
+    }
 }

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

@@ -1,26 +1,8 @@
 package forge.ai;
 
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.Comparator;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-
-import org.apache.commons.lang3.StringUtils;
-import org.apache.commons.lang3.tuple.Pair;
-
 import com.google.common.base.Predicate;
 import com.google.common.base.Predicates;
-import com.google.common.collect.ArrayListMultimap;
-import com.google.common.collect.Iterables;
-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.collect.*;
 import forge.ai.ability.AnimateAi;
 import forge.card.ColorSet;
 import forge.card.MagicColor;
@@ -34,20 +16,10 @@ import forge.game.GameActionUtil;
 import forge.game.ability.AbilityKey;
 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.CounterEnumType;
+import forge.game.card.*;
 import forge.game.combat.Combat;
 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.cost.*;
 import forge.game.keyword.Keyword;
 import forge.game.mana.Mana;
 import forge.game.mana.ManaCostBeingPaid;
@@ -67,6 +39,10 @@ import forge.game.trigger.TriggerType;
 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;
+
+import java.util.*;
 
 public class ComputerUtilMana {
     private final static boolean DEBUG_MANA_PAYMENT = false;
@@ -272,28 +248,87 @@ public class ComputerUtilMana {
 
     public static SpellAbility chooseManaAbility(ManaCostBeingPaid cost, SpellAbility sa, Player ai, ManaCostShard toPay,
             Collection<SpellAbility> saList, boolean checkCosts) {
+        Card saHost = sa.getHostCard();
+
+        // CastTotalManaSpent (AIPreference:ManaFrom$Type or AIManaPref$ Type)
+        String manaSourceType = "";
+        if (saHost.hasSVar("AIPreference")) {
+            String condition = saHost.getSVar("AIPreference");
+            if (condition.startsWith("ManaFrom")) {
+                manaSourceType = TextUtil.split(condition, '$')[1];
+            }
+        } else if (sa.hasParam("AIManaPref")) {
+            manaSourceType = sa.getParam("AIManaPref");
+        }
+        if (manaSourceType != "") {
+            List<SpellAbility> filteredList = Lists.newArrayList(saList);
+            switch (manaSourceType) {
+                case "Snow":
+                    filteredList.sort(new Comparator<SpellAbility>() {
+                        @Override
+                        public int compare(SpellAbility ab1, SpellAbility ab2) {
+                            return ab1.getHostCard() != null && ab1.getHostCard().isSnow()
+                                    && ab2.getHostCard() != null && !ab2.getHostCard().isSnow() ? -1 : 1;
+                        }
+                    });
+                    saList = filteredList;
+                    break;
+                case "Treasure":
+                    // Try to spend only one Treasure if possible
+                    filteredList.sort(new Comparator<SpellAbility>() {
+                        @Override
+                        public int compare(SpellAbility ab1, SpellAbility ab2) {
+                            return ab1.getHostCard() != null && ab1.getHostCard().getType().hasSubtype("Treasure")
+                                    && ab2.getHostCard() != null && !ab2.getHostCard().getType().hasSubtype("Treasure") ? -1 : 1;
+                        }
+                    });
+                    SpellAbility first = filteredList.get(0);
+                    if (first.getHostCard() != null && first.getHostCard().getType().hasSubtype("Treasure")) {
+                        saList.remove(first);
+                        List<SpellAbility> updatedList = Lists.newArrayList();
+                        updatedList.add(first);
+                        updatedList.addAll(saList);
+                        saList = updatedList;
+                    }
+                    break;
+                case "TreasureMax":
+                    // Ok to spend as many Treasures as possible
+                    filteredList.sort(new Comparator<SpellAbility>() {
+                        @Override
+                        public int compare(SpellAbility ab1, SpellAbility ab2) {
+                            return ab1.getHostCard() != null && ab1.getHostCard().getType().hasSubtype("Treasure")
+                                    && ab2.getHostCard() != null && !ab2.getHostCard().getType().hasSubtype("Treasure") ? -1 : 1;
+                        }
+                    });
+                    saList = filteredList;
+                    break;
+                default:
+                    break;
+            }
+        }
+
         for (final SpellAbility ma : saList) {
-            if (ma.getHostCard() == sa.getHostCard()) {
+            if (ma.getHostCard() == saHost) {
                 continue;
             }
 
-            if (sa.getHostCard() != null) {
+            if (saHost != 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()
+                    if (saHost.isAura() && "Enchanted".equals(sa.getParam("Defined"))
+                            && ma.getHostCard() == saHost.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()
+                    if (saHost.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())
+                    if ((saHost.isInstant() || saHost.isSorcery())
                             && ma.getHostCard().isCreature()
                             && ai.getController().isAI()
                             && ma.getPayCosts().hasTapCost()
@@ -303,7 +338,7 @@ public class ComputerUtilMana {
                         continue;
                     }
                 } else if (sa.getApi() == ApiType.Attach
-                        && "AvoidPayingWithAttachTarget".equals(sa.getHostCard().getSVar("AIPaymentPreference"))) {
+                        && "AvoidPayingWithAttachTarget".equals(saHost.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())) {
@@ -319,8 +354,8 @@ public class ComputerUtilMana {
 
             // Exception: when paying generic mana with Cavern of Souls, prefer the colored mana producing ability
             // to attempt to make the spell uncounterable when possible.
-            if (ComputerUtilAbility.getAbilitySourceName(ma).equals("Cavern of Souls") && ma.hasChosenType()
-                    && sa.getHostCard().getType().getCreatureTypes().contains(ma.getChosenType(0))) {
+            if (ComputerUtilAbility.getAbilitySourceName(ma).equals("Cavern of Souls")
+                    && saHost.getType().getCreatureTypes().contains(ma.getHostCard().getChosenType())) {
                 if (toPay == ManaCostShard.COLORLESS && cost.getUnpaidShards().contains(ManaCostShard.GENERIC)) {
                     // Deprioritize Cavern of Souls, try to pay generic mana with it instead to use the NoCounter ability
                     continue;
@@ -341,7 +376,7 @@ public class ComputerUtilMana {
                 continue;
             }
 
-            if (canPayShardWithSpellAbility(toPay, ai, paymentChoice, sa, checkCosts)) {
+            if (canPayShardWithSpellAbility(toPay, ai, paymentChoice, sa, checkCosts, cost.getXManaCostPaidByColor())) {
                 return paymentChoice;
             }
         }
@@ -414,6 +449,7 @@ public class ComputerUtilMana {
         // then apply this one
         if (!replaceType.isEmpty()) {
             for (SpellAbility saMana : replaceAmount) {
+                Card card = saMana.getHostCard();
                 if (saMana.hasParam("ReplaceType")) {
                     // replace color and colorless
                     String color = saMana.getParam("ReplaceType");
@@ -435,8 +471,8 @@ public class ComputerUtilMana {
                     // replace color
                     String color = saMana.getParam("ReplaceColor");
                     if ("Chosen".equals(color)) {
-                        if (saMana.hasChosenColor()) {
-                            color = MagicColor.toShortString(saMana.getChosenColor());
+                        if (card.hasChosenColor()) {
+                            color = MagicColor.toShortString(card.getChosenColor());
                         }
                     }
                     if (saMana.hasParam("ReplaceOnly")) {
@@ -488,7 +524,7 @@ public class ComputerUtilMana {
                 int pAmount = AbilityUtils.calculateAmount(trSA.getHostCard(), trSA.getParamOrDefault("Amount",  "1"), trSA);
                 String produced = trSA.getParam("Produced");
                 if (produced.equals("Chosen")) {
-                    produced = MagicColor.toShortString(trSA.getHostCard().getChosenColor(trSA));
+                    produced = MagicColor.toShortString(trSA.getHostCard().getChosenColor());
                 }
                 manaProduced += " " + StringUtils.repeat(produced, pAmount);
             } else if (ApiType.ManaReflected.equals(trSA.getApi())) {
@@ -546,7 +582,7 @@ public class ComputerUtilMana {
                 }
 
                 // get a mana of this type from floating, bail if none available
-                final Mana mana = getMana(ai, part, sa, cost.getSourceRestriction(), (byte) -1);
+                final Mana mana = getMana(ai, part, sa, cost.getSourceRestriction(), (byte) -1, cost.getXManaCostPaidByColor());
                 if (mana != null) {
                     if (ai.getManaPool().tryPayCostWithMana(sa, cost, mana, false)) {
                         manaSpentToPay.add(0, mana);
@@ -608,7 +644,6 @@ public class ComputerUtilMana {
 
             String manaProduced = predictManafromSpellAbility(saPayment, ai, toPay);
 
-            //System.out.println(manaProduced);
             payMultipleMana(cost, manaProduced, ai);
 
             // remove from available lists
@@ -788,7 +823,6 @@ public class ComputerUtilMana {
                 String manaProduced = ignoreColor || ignoreType ? MagicColor.toShortString(toPay.getColorMask())
                         : predictManafromSpellAbility(saPayment, ai, toPay);
 
-                // System.out.println(manaProduced);
                 payMultipleMana(cost, manaProduced, ai);
 
                 // remove from available lists
@@ -935,7 +969,7 @@ public class ComputerUtilMana {
                 }
 
                 // get a mana of this type from floating, bail if none available
-                final Mana mana = getMana(ai, part, sa, cost.getSourceRestriction(), hasConverge ? cost.getColorsPaid() : -1);
+                final Mana mana = getMana(ai, part, sa, cost.getSourceRestriction(), hasConverge ? cost.getColorsPaid() : -1, cost.getXManaCostPaidByColor());
                 if (mana != null) {
                     if (ai.getManaPool().tryPayCostWithMana(sa, cost, mana, test)) {
                         manaSpentToPay.add(0, mana);
@@ -964,8 +998,10 @@ public class ComputerUtilMana {
      *            a {@link forge.game.spellability.SpellAbility} object.
      * @return a {@link forge.game.mana.Mana} object.
      */
-    private static Mana getMana(final Player ai, final ManaCostShard shard, final SpellAbility saBeingPaidFor, String restriction, final byte colorsPaid) {
-        final List<Pair<Mana, Integer>> weightedOptions = selectManaToPayFor(ai.getManaPool(), shard, saBeingPaidFor, restriction, colorsPaid);
+    private static Mana getMana(final Player ai, final ManaCostShard shard, final SpellAbility saBeingPaidFor,
+            String restriction, final byte colorsPaid, Map<String, Integer> xManaCostPaidByColor) {
+        final List<Pair<Mana, Integer>> weightedOptions = selectManaToPayFor(ai.getManaPool(), shard,
+            saBeingPaidFor, restriction, colorsPaid, xManaCostPaidByColor);
 
         // Exclude border case
         if (weightedOptions.isEmpty()) {
@@ -1014,9 +1050,13 @@ public class ComputerUtilMana {
     }
 
     private static List<Pair<Mana, Integer>> selectManaToPayFor(final ManaPool manapool, final ManaCostShard shard,
-            final SpellAbility saBeingPaidFor, String restriction, final byte colorsPaid) {
+            final SpellAbility saBeingPaidFor, String restriction, final byte colorsPaid, Map<String, Integer> xManaCostPaidByColor) {
         final List<Pair<Mana, Integer>> weightedOptions = new ArrayList<>();
         for (final Mana thisMana : manapool) {
+            if (shard == ManaCostShard.COLORED_X && !ManaCostBeingPaid.canColoredXShardBePaidByColor(MagicColor.toShortString(thisMana.getColor()), xManaCostPaidByColor)) {
+                continue;
+            }
+
             if (!manapool.canPayForShardWithColor(shard, thisMana.getColor())) {
                 continue;
             }
@@ -1066,7 +1106,6 @@ public class ComputerUtilMana {
             getComboManaChoice(ai, saPayment, sa, cost);
         }
         else if (saPayment.getApi() == ApiType.ManaReflected) {
-            //System.out.println("Evaluate reflected mana of: " + saPayment.getHostCard());
             Set<String> reflected = CardUtil.getReflectableManaColors(saPayment);
 
             for (byte c : MagicColor.WUBRG) {
@@ -1092,7 +1131,7 @@ public class ComputerUtilMana {
         }
     }
 
-    private static boolean canPayShardWithSpellAbility(ManaCostShard toPay, Player ai, SpellAbility ma, SpellAbility sa, boolean checkCosts) {
+    private static boolean canPayShardWithSpellAbility(ManaCostShard toPay, Player ai, SpellAbility ma, SpellAbility sa, boolean checkCosts, Map<String, Integer> xManaCostPaidByColor) {
         final Card sourceCard = ma.getHostCard();
 
         if (isManaSourceReserved(ai, sourceCard, sa)) {
@@ -1130,6 +1169,10 @@ public class ComputerUtilMana {
 
         if (m.isComboMana()) {
             for (String s : m.getComboColors().split(" ")) {
+                if (toPay == ManaCostShard.COLORED_X && !ManaCostBeingPaid.canColoredXShardBePaidByColor(s, xManaCostPaidByColor)) {
+                    continue;
+                }
+
                 if ("Any".equals(s) || ai.getManaPool().canPayForShardWithColor(toPay, ManaAtom.fromName(s)))
                     return true;
             }
@@ -1140,6 +1183,9 @@ public class ComputerUtilMana {
             Set<String> reflected = CardUtil.getReflectableManaColors(ma);
 
             for (byte c : MagicColor.WUBRG) {
+                if (toPay == ManaCostShard.COLORED_X && !ManaCostBeingPaid.canColoredXShardBePaidByColor(MagicColor.toShortString(c), xManaCostPaidByColor)) {
+                    continue;
+                }
                 if (ai.getManaPool().canPayForShardWithColor(toPay, c) && reflected.contains(MagicColor.toLongString(c))) {
                     m.setExpressChoice(MagicColor.toShortString(c));
                     return true;
@@ -1147,6 +1193,16 @@ public class ComputerUtilMana {
             }
             return false;
         }
+
+        if (toPay == ManaCostShard.COLORED_X) {
+            for (String s : m.mana().split(" ")) {
+                if (ManaCostBeingPaid.canColoredXShardBePaidByColor(s, xManaCostPaidByColor)) {
+                    return true;
+                }
+            }
+            return false;
+        }
+
         return true;
     }
 
@@ -1258,7 +1314,7 @@ public class ComputerUtilMana {
         final AbilityManaPart abMana = manaAb.getManaPart();
 
         if (abMana.isComboMana()) {
-            int amount = manaAb.hasParam("Amount") ? AbilityUtils.calculateAmount(source, manaAb.getParam("Amount"), saRoot) : 1;
+            int amount = manaAb.hasParam("Amount") ? AbilityUtils.calculateAmount(source, manaAb.getParam("Amount"), manaAb) : 1;
             final ManaCostBeingPaid testCost = new ManaCostBeingPaid(cost);
             final String[] comboColors = abMana.getComboColors().split(" ");
             for (int nMana = 1; nMana <= amount; nMana++) {
@@ -1278,7 +1334,7 @@ public class ComputerUtilMana {
                 if (!testCost.isPaid()) {
                     // Loop over combo colors
                     for (String color : comboColors) {
-                        if (satisfiesColorChoice(abMana, choiceString, choice) && testCost.isAnyPartPayableWith(ManaAtom.fromName(color), ai.getManaPool())) {
+                        if (satisfiesColorChoice(abMana, choiceString, choice) && testCost.needsColor(ManaAtom.fromName(color), ai.getManaPool())) {
                             payMultipleMana(testCost, color, ai);
                             if (nMana != 1) {
                                 choiceString.append(" ");
@@ -1426,24 +1482,33 @@ public class ComputerUtilMana {
 
         String restriction = null;
         if (payCosts != null && payCosts.getCostMana() != null) {
-            restriction = payCosts.getCostMana().getRestiction();
+            restriction = payCosts.getCostMana().getRestriction();
         }
         ManaCostBeingPaid cost = new ManaCostBeingPaid(mana, restriction);
 
         // Tack xMana Payments into mana here if X is a set value
         if (cost.getXcounter() > 0 || extraMana > 0) {
             int manaToAdd = 0;
+            int xCounter = cost.getXcounter();
             if (test && extraMana > 0) {
-                final int multiplicator = Math.max(cost.getXcounter(), 1);
+                final int multiplicator = Math.max(xCounter, 1);
                 manaToAdd = extraMana * multiplicator;
             } else {
-                manaToAdd = AbilityUtils.calculateAmount(card, "X", sa) * cost.getXcounter();
+                manaToAdd = AbilityUtils.calculateAmount(card, "X", sa) * xCounter;
             }
 
-            cost.increaseShard(ManaCostShard.parseNonGeneric(sa.getParamOrDefault("XColor", "1")), manaToAdd);
+            String xColor = sa.getParamOrDefault("XColor", "1");
+            if (card.hasKeyword("Spend only colored mana on X. No more than one mana of each color may be spent this way.")) {
+                xColor = "WUBRGX";
+            }
+            if (xCounter > 0) {
+                cost.setXManaCostPaid(manaToAdd / xCounter, xColor);
+            } else {
+                cost.increaseShard(ManaCostShard.parseNonGeneric(xColor), manaToAdd);
+            }
 
             if (!test) {
-                sa.setXManaCostPaid(manaToAdd / cost.getXcounter());
+                sa.setXManaCostPaid(manaToAdd / xCounter);
             }
         }
 
@@ -1530,7 +1595,7 @@ public class ComputerUtilMana {
             public boolean apply(final Card c) {
                 for (final SpellAbility am : getAIPlayableMana(c)) {
                     am.setActivatingPlayer(ai);
-                    if (!checkPlayable || am.canPlay()) {
+                    if (!checkPlayable || (am.canPlay() && am.checkRestrictions(ai))) {
                         return true;
                     }
                 }
@@ -1834,8 +1899,7 @@ public class ComputerUtilMana {
             if (!res.contains(a)) {
                 if (cost.isReusuableResource()) {
                     res.add(0, a);
-                }
-                else {
+                } else {
                     res.add(res.size(), a);
                 }
             }
@@ -1848,7 +1912,7 @@ public class ComputerUtilMana {
             final Card offering = sa.getSacrificedAsOffering();
             offering.setUsedToPay(false);
             if (costIsPaid && !test) {
-                sa.getHostCard().getGame().getAction().sacrifice(offering, sa, null);
+                sa.getHostCard().getGame().getAction().sacrifice(offering, sa, null, null);
             }
             sa.resetSacrificedAsOffering();
         }
@@ -1856,7 +1920,7 @@ public class ComputerUtilMana {
             final Card emerge = sa.getSacrificedAsEmerge();
             emerge.setUsedToPay(false);
             if (costIsPaid && !test) {
-                sa.getHostCard().getGame().getAction().sacrifice(emerge, sa, null);
+                sa.getHostCard().getGame().getAction().sacrifice(emerge, sa, null, null);
             }
             sa.resetSacrificedAsEmerge();
         }

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

@@ -162,9 +162,9 @@ public class CreatureEvaluator implements Function<Card, Integer> {
             value -= subValue(10, "must-attack");
         } else if (c.hasStartOfKeyword("CARDNAME attacks specific player each combat if able")) {
             value -= subValue(10, "must-attack-player");
-        } else if (c.hasKeyword("CARDNAME can block only creatures with flying.")) {
+        }/* else if (c.hasKeyword("CARDNAME can block only creatures with flying.")) {
             value -= subValue(toughness * 5, "reverse-reach");
-        }
+        }//*/
     
         if (c.hasSVar("DestroyWhenDamaged")) {
             value -= subValue((toughness - 1) * 9, "dies-to-dmg");

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

@@ -3,23 +3,12 @@ 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.*;
 import java.util.Map.Entry;
-import java.util.Set;
 
+import com.google.common.collect.*;
 import org.apache.commons.lang3.StringUtils;
 
-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.card.MagicColor;
@@ -27,7 +16,6 @@ import forge.game.Game;
 import forge.game.GameEntity;
 import forge.game.GameObject;
 import forge.game.ability.AbilityFactory;
-import forge.game.ability.AbilityKey;
 import forge.game.ability.effects.DetachedCardEffect;
 import forge.game.card.Card;
 import forge.game.card.CardCloneStates;
@@ -44,9 +32,7 @@ import forge.game.mana.ManaPool;
 import forge.game.phase.PhaseType;
 import forge.game.player.Player;
 import forge.game.spellability.AbilityManaPart;
-import forge.game.spellability.AbilitySub;
 import forge.game.spellability.SpellAbility;
-import forge.game.trigger.TriggerType;
 import forge.game.zone.PlayerZone;
 import forge.game.zone.ZoneType;
 import forge.item.IPaperCard;
@@ -63,6 +49,7 @@ public abstract class GameState {
         ZONES.put(ZoneType.Library, "library");
         ZONES.put(ZoneType.Exile, "exile");
         ZONES.put(ZoneType.Command, "command");
+        ZONES.put(ZoneType.Sideboard, "sideboard");
     }
 
     private int humanLife = -1;
@@ -89,7 +76,8 @@ public abstract class GameState {
     private final Map<Card, Integer> markedDamage = new HashMap<>();
     private final Map<Card, List<String>> cardToChosenClrs = new HashMap<>();
     private final Map<Card, CardCollection> cardToChosenCards = new HashMap<>();
-    private final Map<Card, List<String>> cardToChosenTypes = new HashMap<>();
+    private final Map<Card, String> cardToChosenType = new HashMap<>();
+    private final Map<Card, String> cardToChosenType2 = new HashMap<>();
     private final Map<Card, List<String>> cardToRememberedId = new HashMap<>();
     private final Map<Card, List<String>> cardToImprintedId = new HashMap<>();
     private final Map<Card, List<String>> cardToMergedCards = new HashMap<>();
@@ -340,16 +328,15 @@ public abstract class GameState {
                 newText.append("|Damage:").append(c.getDamage());
             }
 
-            SpellAbility first = c.getFirstSpellAbility();
-            if (first != null) {
-                if (first.hasChosenColor()) {
-                    newText.append("|ChosenColor:").append(TextUtil.join(first.getChosenColors(), ","));
-                }
-                if (first.hasChosenType()) {
-                    newText.append("|ChosenType:").append(TextUtil.join(first.getChosenType(), ","));
-                }
+            if (!c.getChosenColor().isEmpty()) {
+                newText.append("|ChosenColor:").append(TextUtil.join(c.getChosenColors(), ","));
+            }
+            if (!c.getChosenType().isEmpty()) {
+                newText.append("|ChosenType:").append(c.getChosenType());
+            }
+            if (!c.getChosenType2().isEmpty()) {
+                newText.append("|ChosenType2:").append(c.getChosenType2());
             }
-
             if (!c.getNamedCard().isEmpty()) {
                 newText.append("|NamedCard:").append(c.getNamedCard());
             }
@@ -412,6 +399,12 @@ public abstract class GameState {
                 // Need to figure out a better way to detect if it's actually on adventure.
                 newText.append("|OnAdventure");
             }
+            if (c.isForetold()) {
+                newText.append("|Foretold");
+            }
+            if (c.isForetoldThisTurn()) {
+                newText.append("|ForetoldThisTurn");
+            }
 
         }
 
@@ -579,6 +572,13 @@ public abstract class GameState {
                 aiCardTexts.put(ZoneType.Command, categoryValue);
         }
 
+        else if (categoryName.endsWith("sideboard")) {
+            if (isHuman)
+                humanCardTexts.put(ZoneType.Sideboard, categoryValue);
+            else
+                aiCardTexts.put(ZoneType.Sideboard, categoryValue);
+        }
+
         else if (categoryName.startsWith("ability")) {
             abilityString.put(categoryName.substring("ability".length()), categoryValue);
         }
@@ -638,7 +638,8 @@ public abstract class GameState {
         markedDamage.clear();
         cardToChosenClrs.clear();
         cardToChosenCards.clear();
-        cardToChosenTypes.clear();
+        cardToChosenType.clear();
+        cardToChosenType2.clear();
         cardToMergedCards.clear();
         cardToScript.clear();
         cardAttackMap.clear();
@@ -733,7 +734,7 @@ public abstract class GameState {
             if (persistent) {
                 produced.put("PersistentMana", "True");
             }
-            final AbilityManaPart abMana = new AbilityManaPart(dummy, null, produced);
+            final AbilityManaPart abMana = new AbilityManaPart(dummy, produced);
             game.getAction().invoke(new Runnable() {
                 @Override
                 public void run() {
@@ -769,23 +770,10 @@ public abstract class GameState {
         }
         game.fireEvent(new GameEventAttackersDeclared(attackingPlayer, attackersMap));
 
-        if (!combat.getAttackers().isEmpty()) {
-            List<GameEntity> attackedTarget = Lists.newArrayList();
-            for (final Card c : combat.getAttackers()) {
-                attackedTarget.add(combat.getDefenderByAttacker(c));
-            }
-            final Map<AbilityKey, Object> runParams = Maps.newEnumMap(AbilityKey.class);
-            runParams.put(AbilityKey.Attackers, combat.getAttackers());
-            runParams.put(AbilityKey.AttackingPlayer, combat.getAttackingPlayer());
-            runParams.put(AbilityKey.AttackedTarget, attackedTarget);
-            game.getTriggerHandler().runTrigger(TriggerType.AttackersDeclared, runParams, false);
-        }
-
         for (final Card c : combat.getAttackers()) {
-            CombatUtil.checkDeclaredAttacker(game, c, combat);
+            CombatUtil.checkDeclaredAttacker(game, c, combat, false);
         }
 
-        game.getTriggerHandler().resetActiveTriggers();
         game.updateCombatForView();
         game.fireEvent(new GameEventCombatChanged());
 
@@ -828,7 +816,6 @@ public abstract class GameState {
             Card exiledWith = idToCard.get(Integer.parseInt(id));
             c.setExiledWith(exiledWith);
             c.setExiledBy(exiledWith.getController());
-            exiledWith.addExiledWith(c);
         }
     }
 
@@ -1087,13 +1074,19 @@ public abstract class GameState {
             Card c = entry.getKey();
             List<String> colors = entry.getValue();
 
-            c.setChosenColors(colors, c.getFirstSpellAbility());
+            c.setChosenColors(colors);
         }
 
         // Chosen type
-        for (Entry<Card, List<String>> entry : cardToChosenTypes.entrySet()) {
+        for (Entry<Card, String> entry : cardToChosenType.entrySet()) {
             Card c = entry.getKey();
-            c.setChosenType(entry.getValue(), c.getFirstSpellAbility());
+            c.setChosenType(entry.getValue());
+        }
+
+        // Chosen type 2
+        for (Entry<Card, String> entry : cardToChosenType2.entrySet()) {
+            Card c = entry.getKey();
+            c.setChosenType2(entry.getValue());
         }
 
         // Named card
@@ -1196,7 +1189,7 @@ public abstract class GameState {
         String[] allCounterStrings = counterString.split(",");
         for (final String counterPair : allCounterStrings) {
             String[] pair = counterPair.split("=", 2);
-            entity.addCounter(CounterType.getType(pair[0]), Integer.parseInt(pair[1]), null, false, false, null);
+            entity.addCounter(CounterType.getType(pair[0]), Integer.parseInt(pair[1]), null, null, false, false, null);
         }
     }
 
@@ -1236,8 +1229,7 @@ public abstract class GameState {
                     boolean tapped = c.isTapped();
                     boolean sickness = c.hasSickness();
                     Map<CounterType, Integer> counters = c.getCounters();
-                    // Note: Not clearCounters() since we want to keep the counters
-                    // var as-is.
+                    // Note: Not clearCounters() since we want to keep the counters var as-is.
                     c.setCounters(Maps.newHashMap());
                     if (c.isAura()) {
                         // dummy "enchanting" to indicate that the card will be force-attached elsewhere
@@ -1340,7 +1332,7 @@ public abstract class GameState {
                 } 
                 else if (info.startsWith("OnAdventure")) {
                     String abAdventure = "DB$ Effect | RememberObjects$ Self | StaticAbilities$ Play | ExileOnMoved$ Exile | Duration$ Permanent | ConditionDefined$ Self | ConditionPresent$ Card.nonCopiedSpell";
-                    AbilitySub saAdventure = (AbilitySub)AbilityFactory.getAbility(abAdventure, c);
+                    SpellAbility saAdventure = AbilityFactory.getAbility(abAdventure, c);
                     StringBuilder sbPlay = new StringBuilder();
                     sbPlay.append("Mode$ Continuous | MayPlay$ True | EffectZone$ Command | Affected$ Card.IsRemembered+nonAdventure");
                     sbPlay.append(" | AffectedZone$ Exile | Description$ You may cast the card.");
@@ -1379,7 +1371,9 @@ public abstract class GameState {
                 } else if (info.startsWith("ChosenColor:")) {
                     cardToChosenClrs.put(c, Arrays.asList(info.substring(info.indexOf(':') + 1).split(",")));
                 } else if (info.startsWith("ChosenType:")) {
-                    cardToChosenTypes.put(c, Arrays.asList(info.substring(info.indexOf(':') + 1).split(",")));
+                    cardToChosenType.put(c, info.substring(info.indexOf(':') + 1));
+                } else if (info.startsWith("ChosenType2:")) {
+                    cardToChosenType2.put(c, info.substring(info.indexOf(':') + 1));
                 } else if (info.startsWith("ChosenCards:")) {
                     CardCollection chosen = new CardCollection();
                     String[] idlist = info.substring(info.indexOf(':') + 1).split(",");
@@ -1411,6 +1405,14 @@ public abstract class GameState {
                     }
                 } else if (info.equals("NoETBTrigs")) {
                     cardsWithoutETBTrigs.add(c);
+                } else if (info.equals("Foretold")) {
+                    c.setForetold(true);
+                    c.turnFaceDown(true);
+                    c.addMayLookTemp(c.getOwner());
+                } else if (info.equals("ForetoldThisTurn")) {
+                    c.setForetoldThisTurn(true);
+                } else if (info.equals("IsToken")) {
+                    c.setToken(true);
                 }
             }
 

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

@@ -8,6 +8,7 @@ import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 
+import org.apache.commons.lang3.StringUtils;
 import org.apache.commons.lang3.tuple.ImmutablePair;
 import org.apache.commons.lang3.tuple.Pair;
 
@@ -79,6 +80,7 @@ import forge.util.MyRandom;
 import forge.util.collect.FCollection;
 import forge.util.collect.FCollectionView;
 
+
 /**
  * A prototype for player controller class
  *
@@ -129,6 +131,29 @@ public class PlayerControllerAi extends PlayerController {
         return ComputerUtilCombat.distributeAIDamage(attacker, blockers, damageDealt, defender, overrideOrder);
     }
 
+    @Override
+    public Map<GameEntity, Integer> divideShield(Card effectSource, Map<GameEntity, Integer> affected, int shieldAmount) {
+        // TODO: AI current can't use this so this is not implemented.
+        return new HashMap<>();
+    }
+
+    @Override
+    public Map<Byte, Integer> specifyManaCombo(SpellAbility sa, ColorSet colorSet, int manaAmount, boolean different) {
+        Map<Byte, Integer> result = new HashMap<>();
+        for (int i = 0; i < manaAmount; ++i) {
+            Byte chosen = chooseColor("", sa, colorSet);
+            if (result.containsKey(chosen)) {
+                result.put(chosen, result.get(chosen) + 1);
+            } else {
+                result.put(chosen, 1);
+            }
+            if (different) {
+                colorSet = ColorSet.fromMask(colorSet.getColor() - chosen);
+            }
+        }
+        return result;
+    }
+
     @Override
     public Integer announceRequirements(SpellAbility ability, String announce) {
         // For now, these "announcements" are made within the AI classes of the appropriate SA effects
@@ -528,7 +553,14 @@ public class PlayerControllerAi extends PlayerController {
 
     @Override
     public CardCollectionView chooseCardsToDiscardUnlessType(int num, CardCollectionView hand, String uType, SpellAbility sa) {
-        final CardCollectionView cardsOfType = CardLists.getType(hand, uType);
+        String [] splitUTypes = uType.split(",");
+        CardCollection cardsOfType = new CardCollection();
+        for (String part : splitUTypes) {
+            CardCollection partCards = CardLists.getType(hand, part);
+            if (!partCards.isEmpty()) {
+                cardsOfType.addAll(partCards);
+            }
+        }
         if (!cardsOfType.isEmpty()) {
             Card toDiscard = Aggregates.itemWithMin(cardsOfType, CardPredicates.Accessors.fnGetCmc);
             return new CardCollection(toDiscard);
@@ -543,12 +575,13 @@ public class PlayerControllerAi extends PlayerController {
     }
 
     @Override
-    public List<String> chooseSomeType(String kindOfType, SpellAbility sa, int min, int max, List<String> validTypes) {
-        List<String> chosen = ComputerUtil.chooseSomeType(player, kindOfType, sa.getParam("AILogic"), min, max, validTypes);
-        if (chosen.isEmpty()) {
-            return validTypes.subList(0, min);
+    public String chooseSomeType(String kindOfType, SpellAbility sa, Collection<String> validTypes, List<String> invalidTypes, boolean isOptional) {
+        String chosen = ComputerUtil.chooseSomeType(player, kindOfType, sa.getParam("AILogic"), validTypes, invalidTypes);
+        if (StringUtils.isBlank(chosen) && !validTypes.isEmpty()) {
+            chosen = validTypes.iterator().next();
+            System.err.println("AI has no idea how to choose " + kindOfType +", defaulting to arbitrary element: chosen");
         }
-        getGame().getAction().notifyOfValue(sa, player, chosen.toString(), player);
+        getGame().getAction().notifyOfValue(sa, player, chosen, player);
         return chosen;
     }
 
@@ -558,8 +591,8 @@ public class PlayerControllerAi extends PlayerController {
     }
 
     @Override
-    public boolean confirmReplacementEffect(ReplacementEffect replacementEffect, SpellAbility effectSA, String question) {
-        return brains.aiShouldRun(replacementEffect, effectSA);
+    public boolean confirmReplacementEffect(ReplacementEffect replacementEffect, SpellAbility effectSA, GameEntity affected, String question) {
+        return brains.aiShouldRun(replacementEffect, effectSA, affected);
     }
 
     @Override
@@ -639,7 +672,6 @@ public class PlayerControllerAi extends PlayerController {
 
     @Override
     public boolean playChosenSpellAbility(SpellAbility sa) {
-        // System.out.println("Playing sa: " + sa);
         if (sa instanceof LandAbility) {
             if (sa.canPlay()) {
                 sa.resolve();
@@ -778,7 +810,8 @@ public class PlayerControllerAi extends PlayerController {
                         case "BetterTgtThanRemembered":
                             if (source.getRememberedCount() > 0) {
                                 Card rem = (Card) source.getFirstRemembered();
-                                if (!rem.isInZone(ZoneType.Battlefield)) {
+                                //  avoid pumping opponent creature
+                                if (!rem.isInZone(ZoneType.Battlefield) || rem.getController().isOpponentOf(source.getController())) {
                                     return true;
                                 }
                                 for (Card c : source.getController().getCreaturesInPlay()) {
@@ -988,6 +1021,7 @@ public class PlayerControllerAi extends PlayerController {
         emptyAbility.setActivatingPlayer(player);
         emptyAbility.setTriggeringObjects(sa.getTriggeringObjects());
         emptyAbility.setSVars(sa.getSVars());
+        emptyAbility.setXManaCostPaid(sa.getRootAbility().getXManaCostPaid());
         if (ComputerUtilCost.willPayUnlessCost(sa, player, cost, alreadyPaid, allPayers) && ComputerUtilCost.canPayCost(emptyAbility, player)) {
             ComputerUtil.playNoStack(player, emptyAbility, getGame()); // AI needs something to resolve to pay that cost
             return true;
@@ -1019,7 +1053,7 @@ public class PlayerControllerAi extends PlayerController {
                     */
                     if (sa.isMayChooseNewTargets() && !sa.setupTargets()) {
                         if (sa.isSpell()) {
-                            sa.getHostCard().ceaseToExist();
+                            player.getGame().getAction().ceaseToExist(sa.getHostCard(), false);
                         }
                         continue;
                     }
@@ -1053,14 +1087,13 @@ public class PlayerControllerAi extends PlayerController {
         boolean noManaCost = tgtSA.hasParam("WithoutManaCost");
         if (tgtSA instanceof Spell) { // Isn't it ALWAYS a spell?
             Spell spell = (Spell) tgtSA;
-            if (brains.canPlayFromEffectAI(spell, !optional, noManaCost) == AiPlayDecision.WillPlay || !optional) {
+            if (tgtSA.checkRestrictions(brains.getPlayer()) && (brains.canPlayFromEffectAI(spell, !optional, noManaCost) == AiPlayDecision.WillPlay || !optional)) {
                 if (noManaCost) {
                     return ComputerUtil.playSpellAbilityWithoutPayingManaCost(player, tgtSA, getGame());
-                } else {
-                    return ComputerUtil.playStack(tgtSA, player, getGame());
                 }
-            } else 
-                return false; // didn't play spell
+                return ComputerUtil.playStack(tgtSA, player, getGame());
+            }
+            return false; // didn't play spell
         }
         return true;
     }
@@ -1083,7 +1116,6 @@ public class PlayerControllerAi extends PlayerController {
             boolean allCreatures = Iterables.all(Iterables.concat(pile1, pile2), CardPredicates.Presets.CREATURES);
             int cmc1 = allCreatures ? ComputerUtilCard.evaluateCreatureList(pile1) : ComputerUtilCard.evaluatePermanentList(pile1);
             int cmc2 = allCreatures ? ComputerUtilCard.evaluateCreatureList(pile2) : ComputerUtilCard.evaluatePermanentList(pile2);
-            System.out.println("value:" + cmc1 + " " + cmc2);
 
             // for now, this assumes that the outcome will be bad
             // TODO: This should really have a ChooseLogic param to

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

@@ -39,7 +39,6 @@ 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.CardPredicates;
 import forge.game.card.CardUtil;
@@ -112,6 +111,63 @@ public class SpecialCardAi {
         }
     }
 
+    // Brain in a Jar
+    public static class BrainInAJar {
+        public static boolean consider(final Player ai, final SpellAbility sa) {
+            final Card source = sa.getHostCard();
+
+            int counterNum = source.getCounters(CounterEnumType.CHARGE);
+            // no need for logic
+            if (counterNum == 0) {
+                return false;
+            }
+            int libsize = ai.getCardsIn(ZoneType.Library).size();
+
+            final CardCollection hand = CardLists.filter(ai.getCardsIn(ZoneType.Hand), Predicates.or(
+                    CardPredicates.isType("Instant"), CardPredicates.isType("Sorcery")));
+            if (!hand.isEmpty()) {
+                // has spell that can be cast in hand with put ability
+                if (!CardLists.filter(hand, CardPredicates.hasCMC(counterNum + 1)).isEmpty()) {
+                    return false;
+                }
+                // has spell that can be cast if one counter is removed
+                if (!CardLists.filter(hand, CardPredicates.hasCMC(counterNum)).isEmpty()) {
+                    sa.setXManaCostPaid(1);
+                    return true;
+                }
+            }
+            final CardCollection library = CardLists.filter(ai.getCardsIn(ZoneType.Library), Predicates.or(
+                    CardPredicates.isType("Instant"), CardPredicates.isType("Sorcery")));
+            if (!library.isEmpty()) {
+                // get max cmc of instant or sorceries in the libary
+                int maxCMC = 0;
+                for (final Card c : library) {
+                    int v = c.getCMC();
+                    if (c.isSplitCard()) {
+                        v = Math.max(c.getCMC(Card.SplitCMCMode.LeftSplitCMC), c.getCMC(Card.SplitCMCMode.RightSplitCMC));
+                    }
+                    if (v > maxCMC) {
+                        maxCMC = v;
+                    }
+                }
+                // there is a spell with more CMC, no need to remove counter
+                if (counterNum + 1 < maxCMC) {
+                    return false;
+                }
+                int maxToRemove = counterNum - maxCMC + 1;
+                // no Scry 0, even if its catched from later stuff
+                if (maxToRemove <= 0) {
+                    return false;
+                }
+                sa.setXManaCostPaid(maxToRemove);
+            } else {
+                // no Instant or Sorceries anymore, just scry
+                sa.setXManaCostPaid(Math.min(counterNum, libsize));
+            }
+            return true;
+        }
+    }
+
     // Chain of Acid
     public static class ChainOfAcid {
         public static boolean consider(final Player ai, final SpellAbility sa) {
@@ -159,10 +215,9 @@ public class SpecialCardAi {
             final PhaseHandler ph = ai.getGame().getPhaseHandler();
             final Combat combat = ai.getGame().getCombat();
 
-            Card animated = AnimateAi.becomeAnimated(sa.getHostCard(), sa);
-            animated.addType("Creature");
+            Card animated = AnimateAi.becomeAnimated(sa.getHostCard(), sa.getSubAbility());
             if (sa.getHostCard().canReceiveCounters(CounterEnumType.P1P1)) {
-                animated.addCounter(CounterEnumType.P1P1, 2, ai, false, null);
+                animated.addCounter(CounterEnumType.P1P1, 2, ai, sa.getSubAbility(), false, null);
             }
             boolean isOppEOT = ph.is(PhaseType.END_OF_TURN) && ph.getNextTurn() == ai;
             boolean isValuableAttacker = ph.is(PhaseType.MAIN1, ai) && ComputerUtilCard.doesSpecifiedCreatureAttackAI(ai, animated);
@@ -170,10 +225,6 @@ public class SpecialCardAi {
 
             return isOppEOT || isValuableAttacker || isValuableBlocker;
         }
-
-        public static SpellAbility considerAnimating(final Player ai, final SpellAbility sa, final List<SpellAbility> options) {
-            return ai.getGame().getPhaseHandler().getPhase().isBefore(PhaseType.MAIN2) ? options.get(0) : options.get(1);
-        }
     }
 
     // Cursed Scroll
@@ -327,7 +378,7 @@ public class SpecialCardAi {
             }
 
             // Do not activate if damage will be prevented
-            if (source.staticDamagePrevention(predictedPT.getLeft(), source, true, true) == 0) {
+            if (source.staticDamagePrevention(predictedPT.getLeft(), 0, source, true) == 0) {
                 return false;
             }
 
@@ -911,6 +962,39 @@ public class SpecialCardAi {
         }
     }
 
+    // Multiple Choice
+    public static class MultipleChoice {
+        public static boolean consider(final Player ai, final SpellAbility sa) {
+            int maxX = ComputerUtilCost.getMaxXValue(sa, ai);
+
+            if (maxX == 0) {
+                return false;
+            }
+
+            boolean canScryDraw = maxX >= 1 && ai.getCardsIn(ZoneType.Library).size() >= 3; // TODO: generalize / use profile values
+            boolean canBounce = maxX >= 2 && !ai.getOpponents().getCreaturesInPlay().isEmpty();
+            boolean shouldBounce = canBounce && ComputerUtilCard.evaluateCreature(ComputerUtilCard.getWorstCreatureAI(ai.getOpponents().getCreaturesInPlay())) > 210; // 180 is the level of a 4/4 token creature
+            boolean canMakeToken = maxX >= 3;
+            boolean canDoAll = maxX >= 4 && canScryDraw && shouldBounce;
+
+            if (canDoAll) {
+                sa.setXManaCostPaid(4);
+                return true;
+            } else if (canMakeToken) {
+                sa.setXManaCostPaid(3);
+                return true;
+            } else if (shouldBounce) {
+                sa.setXManaCostPaid(2);
+                return true;
+            } else if (canScryDraw) {
+                sa.setXManaCostPaid(1);
+                return true;
+            }
+
+            return false;
+        }
+    }
+
     // Necropotence
     public static class Necropotence {
         public static boolean consider(final Player ai, final SpellAbility sa) {

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

@@ -58,6 +58,11 @@ public abstract class SpellAbilityAi {
         final Card source = sa.getHostCard();
         final Cost cost = sa.getPayCosts();
 
+        if (sa.hasParam("AICheckCanPlayWithDefinedX")) {
+            // FIXME: can this somehow be simplified without the need for an extra AI hint?
+            sa.setXManaCostPaid(ComputerUtilCost.getMaxXValue(sa, ai));
+        }
+
         if (!checkConditions(ai, sa, sa.getConditions())) {
             SpellAbility sub = sa.getSubAbility();
             if (sub != null && !checkConditions(ai, sub, sub.getConditions())) {
@@ -157,7 +162,7 @@ public abstract class SpellAbilityAi {
         if (ComputerUtil.preventRunAwayActivations(sa)) {
             return false;   // prevent infinite loop
         }
-        return MyRandom.getRandom().nextFloat() < .8f;   // random success
+        return MyRandom.getRandom().nextFloat() < .8f; // random success
     }
     
     public final boolean doTriggerAI(final Player aiPlayer, final SpellAbility sa, final boolean mandatory) {
@@ -188,7 +193,7 @@ public abstract class SpellAbilityAi {
      * Handles the AI decision to play a triggered SpellAbility
      */
     protected boolean doTriggerAINoCost(final Player aiPlayer, final SpellAbility sa, final boolean mandatory) {
-        if (canPlayWithoutRestrict(aiPlayer, sa)) {
+        if (canPlayWithoutRestrict(aiPlayer, sa) && (!mandatory || sa.isTargetNumberValid())) {
             return true;
         }
 
@@ -285,7 +290,6 @@ public abstract class SpellAbilityAi {
             return false;
         }
 
-
         return phase.is(PhaseType.END_OF_TURN) && phase.getNextTurn().equals(ai);
     }
 

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

@@ -34,6 +34,7 @@ public enum SpellApiToAi {
             .put(ApiType.BidLife, BidLifeAi.class)
             .put(ApiType.Bond, BondAi.class)
             .put(ApiType.Branch, AlwaysPlayAi.class)
+            .put(ApiType.Camouflage, ChooseCardAi.class)
             .put(ApiType.ChangeCombatants, ChangeCombatantsAi.class)
             .put(ApiType.ChangeTargets, ChangeTargetsAi.class)
             .put(ApiType.ChangeX, AlwaysPlayAi.class)
@@ -49,6 +50,7 @@ public enum SpellApiToAi {
             .put(ApiType.ChooseSource, ChooseSourceAi.class)
             .put(ApiType.ChooseType, ChooseTypeAi.class)
             .put(ApiType.Clash, ClashAi.class)
+            .put(ApiType.ClassLevelUp, AlwaysPlayAi.class)
             .put(ApiType.Cleanup, AlwaysPlayAi.class)
             .put(ApiType.Clone, CloneAi.class)
             .put(ApiType.CopyPermanent, CopyPermanentAi.class)
@@ -94,8 +96,10 @@ public enum SpellApiToAi {
             .put(ApiType.Haunt, HauntAi.class)
             .put(ApiType.ImmediateTrigger, ImmediateTriggerAi.class)
             .put(ApiType.Investigate, InvestigateAi.class)
+            .put(ApiType.Learn, LearnAi.class)
             .put(ApiType.LoseLife, LifeLoseAi.class)
             .put(ApiType.LosesGame, GameLossAi.class)
+            .put(ApiType.MakeCard, AlwaysPlayAi.class)
             .put(ApiType.Mana, ManaEffectAi.class)
             .put(ApiType.ManaReflected, CannotPlayAi.class)
             .put(ApiType.Manifest, ManifestAi.class)
@@ -139,6 +143,7 @@ public enum SpellApiToAi {
             .put(ApiType.ReplaceEffect, AlwaysPlayAi.class)
             .put(ApiType.ReplaceDamage, AlwaysPlayAi.class)
             .put(ApiType.ReplaceSplitDamage, AlwaysPlayAi.class)
+            .put(ApiType.ReplaceToken, AlwaysPlayAi.class)
             .put(ApiType.RestartGame, RestartGameAi.class)
             .put(ApiType.Reveal, RevealAi.class)
             .put(ApiType.RevealHand, RevealHandAi.class)
@@ -168,6 +173,7 @@ public enum SpellApiToAi {
             .put(ApiType.UnattachAll, UnattachAllAi.class)
             .put(ApiType.Untap, UntapAi.class)
             .put(ApiType.UntapAll, UntapAllAi.class)
+            .put(ApiType.Venture, VentureAi.class)
             .put(ApiType.Vote, VoteAi.class)
             .put(ApiType.WinsGame, GameWinAi.class)
 

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

@@ -21,8 +21,7 @@ public class ActivateAbilityAi extends SpellAbilityAi {
 
         final TargetRestrictions tgt = sa.getTargetRestrictions();
         final Card source = sa.getHostCard();
-        final Player opp = ai.getWeakestOpponent();
-        boolean randomReturn = MyRandom.getRandom().nextFloat() <= Math.pow(.6667, sa.getActivationsThisTurn());
+        final Player opp = ai.getStrongestOpponent();
 
         List<Card> list = CardLists.getType(opp.getCardsIn(ZoneType.Battlefield), sa.getParamOrDefault("Type", "Card"));
         if (list.isEmpty()) {
@@ -40,12 +39,13 @@ public class ActivateAbilityAi extends SpellAbilityAi {
             sa.getTargets().add(opp);
         }
 
+        boolean randomReturn = MyRandom.getRandom().nextFloat() <= Math.pow(.6667, sa.getActivationsThisTurn());
         return randomReturn;
     }
 
     @Override
     protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
-        final Player opp = ai.getWeakestOpponent();
+        final Player opp = ai.getStrongestOpponent();
 
         final TargetRestrictions tgt = sa.getTargetRestrictions();
         final Card source = sa.getHostCard();

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

@@ -34,7 +34,7 @@ public class AmassAi extends SpellAbilityAi {
         final String tokenScript = "b_0_0_zombie_army";
         final int amount = AbilityUtils.calculateAmount(host, sa.getParamOrDefault("Num", "1"), sa);
 
-        Card token = TokenInfo.getProtoType(tokenScript, sa, false);
+        Card token = TokenInfo.getProtoType(tokenScript, sa, ai, false);
 
         if (token == null) {
             return false;

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

@@ -30,6 +30,7 @@ import forge.game.cost.CostPutCounter;
 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.staticability.StaticAbility;
 import forge.game.staticability.StaticAbilityContinuous;
@@ -99,30 +100,30 @@ public class AnimateAi extends SpellAbilityAi {
         }
         // Don't use instant speed animate abilities before AI's COMBAT_BEGIN
         if (!ph.is(PhaseType.COMBAT_BEGIN) && ph.isPlayerTurn(ai) && !SpellAbilityAi.isSorcerySpeed(sa)
-                && !sa.hasParam("ActivationPhases") && !sa.hasParam("Permanent")) {
+                && !sa.hasParam("ActivationPhases") && !"Permanent".equals(sa.getParam("Duration"))) {
             return false;
         }
         // Don't use instant speed animate abilities outside human's
         // COMBAT_DECLARE_ATTACKERS or if no attackers
-        if (ph.getPlayerTurn().isOpponentOf(ai) && !sa.hasParam("Permanent")
+        if (ph.getPlayerTurn().isOpponentOf(ai) && !"Permanent".equals(sa.getParam("Duration"))
                 && (!ph.is(PhaseType.COMBAT_DECLARE_ATTACKERS)
                         || game.getCombat() != null && game.getCombat().getAttackersOf(ai).isEmpty())) {
             return false;
         }
         // Don't activate during MAIN2 unless this effect is permanent
-        if (ph.is(PhaseType.MAIN2) && !sa.hasParam("Permanent") && !sa.hasParam("UntilYourNextTurn")) {
+        if (ph.is(PhaseType.MAIN2) && !"Permanent".equals(sa.getParam("Duration")) && !"UntilYourNextTurn".equals(sa.getParam("Duration"))) {
             return false;
         }
         // Don't animate if the AI won't attack anyway or use as a potential blocker
         Player opponent = ai.getWeakestOpponent();
         // Activating as a potential blocker is only viable if it's an ability activated from a permanent, otherwise
         // the AI will waste resources
-        boolean activateAsPotentialBlocker = sa.hasParam("UntilYourNextTurn")
+        boolean activateAsPotentialBlocker = "UntilYourNextTurn".equals(sa.getParam("Duration"))
                 && ai.getGame().getPhaseHandler().getNextTurn() != ai
                 && source.isPermanent();
         if (ph.isPlayerTurn(ai) && ai.getLife() < 6 && opponent.getLife() > 6
                 && Iterables.any(opponent.getCardsIn(ZoneType.Battlefield), CardPredicates.Presets.CREATURES)
-                && !sa.hasParam("AILogic") && !sa.hasParam("Permanent") && !activateAsPotentialBlocker) {
+                && !sa.hasParam("AILogic") && !"Permanent".equals(sa.getParam("Duration")) && !activateAsPotentialBlocker) {
             return false;
         }
         return true;
@@ -155,7 +156,7 @@ public class AnimateAi extends SpellAbilityAi {
                         && !c.isEquipping();
                 
                 // for creatures that could be improved (like Figure of Destiny)
-                if (!bFlag && c.isCreature() && (sa.hasParam("Permanent") || (!c.isTapped() && !c.isSick()))) {
+                if (!bFlag && c.isCreature() && ("Permanent".equals(sa.getParam("Duration")) || (!c.isTapped() && !c.isSick()))) {
                     int power = -5;
                     if (sa.hasParam("Power")) {
                         power = AbilityUtils.calculateAmount(c, sa.getParam("Power"), sa);
@@ -178,7 +179,7 @@ public class AnimateAi extends SpellAbilityAi {
                     }
                 }
 
-                if (!SpellAbilityAi.isSorcerySpeed(sa) && !sa.hasParam("Permanent")) {
+                if (!SpellAbilityAi.isSorcerySpeed(sa) && !"Permanent".equals(sa.getParam("Duration"))) {
                     if (sa.hasParam("Crew") && c.isCreature()) {
                         // Do not try to crew a vehicle which is already a creature
                         return false;
@@ -243,6 +244,11 @@ public class AnimateAi extends SpellAbilityAi {
         return true;
     }
 
+    @Override
+    public boolean confirmAction(Player player, SpellAbility sa, PlayerActionConfirmMode mode, String message) {
+        return player.getGame().getPhaseHandler().getPhase().isBefore(PhaseType.MAIN2);
+    }
+    
     private boolean animateTgtAI(final SpellAbility sa) {
         final Player ai = sa.getActivatingPlayer();
         final PhaseHandler ph = ai.getGame().getPhaseHandler();
@@ -272,7 +278,7 @@ public class AnimateAi extends SpellAbilityAi {
             Map<Card, Integer> data = Maps.newHashMap();
             for (final Card c : list) {
                 // don't use Permanent animate on something that would leave the field
-                if (c.hasSVar("EndOfTurnLeavePlay") && sa.hasParam("Permanent")) {
+                if (c.hasSVar("EndOfTurnLeavePlay") && "Permanent".equals(sa.getParam("Duration"))) {
                     continue;
                 }
 
@@ -306,9 +312,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")
+                    if (!"Permanent".equals(sa.getParam("Duration"))
                             && !ComputerUtilCard.doesSpecifiedCreatureAttackAI(ai, animatedCopy)
-                            && !sa.hasParam("UntilHostLeavesPlay")) {
+                            && !"UntilHostLeavesPlay".equals(sa.getParam("Duration"))) {
                         continue;
                     }
                 }
@@ -354,8 +360,7 @@ public class AnimateAi extends SpellAbilityAi {
         // This is reasonable for now. Kamahl, Fist of Krosa and a sorcery or
         // two are the only things
         // that animate a target. Those can just use AI:RemoveDeck:All until
-        // this can do a reasonably
-        // good job of picking a good target
+        // this can do a reasonably good job of picking a good target
         return false;
     }
 
@@ -401,7 +406,7 @@ public class AnimateAi extends SpellAbilityAi {
         // allow ChosenType - overrides anything else specified
         if (types.hasSubtype("ChosenType")) {
             types.clear();
-            types.addAll(sa.getChosenType());
+            types.add(source.getChosenType());
         }
 
         final List<String> keywords = Lists.newArrayList();
@@ -432,7 +437,7 @@ public class AnimateAi extends SpellAbilityAi {
         if (sa.hasParam("Colors")) {
             final String colors = sa.getParam("Colors");
             if (colors.equals("ChosenColor")) {
-                tmpDesc = CardUtil.getShortColorsString(sa.getChosenColors());
+                tmpDesc = CardUtil.getShortColorsString(source.getChosenColors());
             } else {
                 tmpDesc = CardUtil.getShortColorsString(Lists.newArrayList(Arrays.asList(colors.split(","))));
             }

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

@@ -6,6 +6,7 @@ import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
 
+
 import com.google.common.base.Predicate;
 import com.google.common.base.Predicates;
 import com.google.common.collect.Lists;
@@ -554,12 +555,7 @@ public class AttachAi extends SpellAbilityAi {
         	if (!evenBetterList.isEmpty()) {
         		betterList = evenBetterList;
         	}
-        	evenBetterList = CardLists.filter(betterList, new Predicate<Card>() {
-                @Override
-                public boolean apply(final Card c) {
-                    return c.isUntapped();
-                }
-            });
+        	evenBetterList = CardLists.filter(betterList, CardPredicates.Presets.UNTAPPED);
         	if (!evenBetterList.isEmpty()) {
         		betterList = evenBetterList;
         	}
@@ -733,17 +729,15 @@ public class AttachAi extends SpellAbilityAi {
      */
     private static Card attachAISpecificCardPreference(final SpellAbility sa, final List<Card> list, final boolean mandatory,
             final Card attachSource) {
-        // I know this isn't much better than Hardcoding, but some cards need it for now
         final Player ai = sa.getActivatingPlayer();
         final String sourceName = ComputerUtilAbility.getAbilitySourceName(sa);
         Card chosen = null;
 
         if ("Guilty Conscience".equals(sourceName)) {
             chosen = SpecialCardAi.GuiltyConscience.getBestAttachTarget(ai, sa, list);
-        } else if ("Bonds of Faith".equals(sourceName)) {
-            chosen = doPumpOrCurseAILogic(ai, sa, list, "Human");
-        } else if ("Clutch of Undeath".equals(sourceName)) {
-            chosen = doPumpOrCurseAILogic(ai, sa, list, "Zombie");
+        } else if (sa.hasParam("AIValid")) {
+            // TODO: Make the AI recognize which cards to pump based on the card's abilities alone
+            chosen = doPumpOrCurseAILogic(ai, sa, list, sa.getParam("AIValid"));
         }
 
         // If Mandatory (brought directly into play without casting) gotta
@@ -767,7 +761,7 @@ public class AttachAi extends SpellAbilityAi {
         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);
+                powerBuff = AbilityUtils.calculateAmount(sa.getHostCard(), stAb.getParam("AddPower"), stAb);
             }
         }
         if (combat != null && combat.isAttacking(equipped) && ph.is(PhaseType.COMBAT_DECLARE_BLOCKERS, sa.getActivatingPlayer())) {
@@ -990,7 +984,7 @@ public class AttachAi extends SpellAbilityAi {
         List<GameObject> targets = new ArrayList<>();
         final TargetRestrictions tgt = sa.getTargetRestrictions();
         if (tgt == null) {
-            targets = AbilityUtils.getDefinedObjects(sa.getHostCard(), sa.getParam("Defined"), sa);
+            targets = AbilityUtils.getDefinedObjects(card, sa.getParam("Defined"), sa);
         } else {
             AttachAi.attachPreference(sa, tgt, mandatory);
             targets = sa.getTargets();
@@ -1129,8 +1123,7 @@ public class AttachAi extends SpellAbilityAi {
                 for (Card target : list) {
                     for (Trigger t : target.getTriggers()) {
                         if (t.getMode() == TriggerType.SpellCast) {
-                            final Map<String, String> params = t.getMapParams();
-                            if ("Card.Self".equals(params.get("TargetsValid")) && "You".equals(params.get("ValidActivatingPlayer"))) {
+                            if ("Card.Self".equals(t.getParam("TargetsValid")) && "You".equals(t.getParam("ValidActivatingPlayer"))) {
                                 magnetList.add(target);
                                 break;
                             }
@@ -1351,7 +1344,7 @@ public class AttachAi extends SpellAbilityAi {
 
         CardCollection list = null;
         if (tgt == null) {
-            list = AbilityUtils.getDefinedCards(sa.getHostCard(), sa.getParam("Defined"), sa);
+            list = AbilityUtils.getDefinedCards(attachSource, sa.getParam("Defined"), sa);
         } else {
             list = CardLists.getValidCards(aiPlayer.getGame().getCardsIn(tgt.getZone()), tgt.getValidTgts(), sa.getActivatingPlayer(), attachSource, sa);
 
@@ -1646,7 +1639,7 @@ public class AttachAi extends SpellAbilityAi {
             return ComputerUtilCombat.canAttackNextTurn(card) && card.getNetCombatDamage() >= 1;
         } else if (keyword.endsWith("CARDNAME attacks each turn if able.") || keyword.endsWith("CARDNAME attacks each combat if able.")) {
             return ComputerUtilCombat.canAttackNextTurn(card) && CombatUtil.canBlock(card, true) && !ai.getCreaturesInPlay().isEmpty();
-        } else if (keyword.endsWith("CARDNAME can't block.") || keyword.contains("CantBlock")) {
+        } else if (keyword.endsWith("CARDNAME can't block.")) {
             return CombatUtil.canBlock(card, true);
         } else if (keyword.endsWith("CARDNAME's activated abilities can't be activated.")) {
             for (SpellAbility ability : card.getSpellAbilities()) {
@@ -1699,7 +1692,7 @@ public class AttachAi extends SpellAbilityAi {
                 if (!c.getController().equals(ai)) {
                     return false;
                 }
-                return c.getType().hasCreatureType(type);
+                return c.isValid(type, ai, sa.getHostCard(), sa);
             }
         });
         List<Card> oppNonType = CardLists.filter(list, new Predicate<Card>() {
@@ -1709,7 +1702,7 @@ public class AttachAi extends SpellAbilityAi {
                 if (c.getController().equals(ai)) {
                     return false;
                 }
-                return !c.getType().hasCreatureType(type) && !ComputerUtilCard.isUselessCreature(ai, c);
+                return !c.isValid(type, ai, sa.getHostCard(), sa) && !ComputerUtilCard.isUselessCreature(ai, c);
             }
         });
 

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

@@ -13,18 +13,21 @@ public class BalanceAi extends SpellAbilityAi {
     @Override
     protected boolean canPlayAI(Player aiPlayer, SpellAbility sa) {
         String logic = sa.getParam("AILogic");
-
         int diff = 0;
-        // TODO Add support for multiplayer logic
-        final Player opp = aiPlayer.getWeakestOpponent();
-        final CardCollectionView humPerms = opp.getCardsIn(ZoneType.Battlefield);
+        Player opp = aiPlayer.getWeakestOpponent();
         final CardCollectionView compPerms = aiPlayer.getCardsIn(ZoneType.Battlefield);
+        for (Player min : aiPlayer.getOpponents()) {
+            if (min.getCardsIn(ZoneType.Battlefield).size() < opp.getCardsIn(ZoneType.Battlefield).size()) {
+                opp = min;
+            }
+        }
+        final CardCollectionView humPerms = opp.getCardsIn(ZoneType.Battlefield);
         
         if ("BalanceCreaturesAndLands".equals(logic)) {
-            // Copied over from hardcoded Balance. We should be checking value of the lands/creatures not just counting
+            // TODO Copied over from hardcoded Balance. We should be checking value of the lands/creatures for each opponent, not just counting
             diff += CardLists.filter(humPerms, CardPredicates.Presets.LANDS).size() - 
                     CardLists.filter(compPerms, CardPredicates.Presets.LANDS).size();
-            diff += 1.5 * ( CardLists.filter(humPerms, CardPredicates.Presets.CREATURES).size() - 
+            diff += 1.5 * (CardLists.filter(humPerms, CardPredicates.Presets.CREATURES).size() - 
                     CardLists.filter(compPerms, CardPredicates.Presets.CREATURES).size());
         }
         else if ("BalancePermanents".equals(logic)) {

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

@@ -2,6 +2,7 @@ package forge.ai.ability;
 
 import java.util.List;
 
+import forge.ai.AiAttackController;
 import forge.ai.ComputerUtilCard;
 import forge.ai.SpellAbilityAi;
 import forge.game.Game;
@@ -24,7 +25,7 @@ public class BidLifeAi extends SpellAbilityAi {
         if (tgt != null) {
             sa.resetTargets();
             if (tgt.canTgtCreature()) {
-                List<Card> list = CardLists.getTargetableCards(aiPlayer.getWeakestOpponent().getCardsIn(ZoneType.Battlefield), sa);
+                List<Card> list = CardLists.getTargetableCards(AiAttackController.choosePreferredDefenderPlayer(aiPlayer).getCardsIn(ZoneType.Battlefield), sa);
                 list = CardLists.getValidCards(list, tgt.getValidTgts(), source.getController(), source, sa);
                 if (list.isEmpty()) {
                     return false;

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

@@ -10,6 +10,7 @@ import forge.game.card.Card;
 import forge.game.mana.ManaCostBeingPaid;
 import forge.game.player.Player;
 import forge.game.spellability.SpellAbility;
+import forge.game.spellability.TargetChoices;
 
 public class ChangeTargetsAi extends SpellAbilityAi {
 
@@ -40,18 +41,20 @@ public class ChangeTargetsAi extends SpellAbilityAi {
             // nothing on stack, so nothing to target
             return false;
         }
+        final TargetChoices topTargets = topSa.getTargets();
+        final Card topHost = topSa.getHostCard();
 
-        if (sa.getTargets().size() != 0) {
+        if (sa.getTargets().size() != 0 && sa.isTrigger()) {
             // something was already chosen before (e.g. in response to a trigger - Mizzium Meddler), so just proceed
             return true;
         }
 
-        if (!topSa.usesTargeting() || topSa.getTargets().getTargetCards().contains(sa.getHostCard())) {
+        if (!topSa.usesTargeting() || topTargets.getTargetCards().contains(sa.getHostCard())) {
             // if this does not target at all or already targets host, no need to redirect it again
             return false;
         }
 
-        for (Card tgt : topSa.getTargets().getTargetCards()) {
+        for (Card tgt : topTargets.getTargetCards()) {
             if (ComputerUtilAbility.getAbilitySourceName(sa).equals(tgt.getName()) && tgt.getController().equals(aiPlayer)) {
                 // We are already targeting at least one card with the same name (e.g. in presence of 2+ Spellskites),
                 // no need to retarget again to another one
@@ -59,7 +62,7 @@ public class ChangeTargetsAi extends SpellAbilityAi {
             }
         }
 
-        if (topSa.getHostCard() != null && !topSa.getHostCard().getController().isOpponentOf(aiPlayer)) {
+        if (topHost != null && !topHost.getController().isOpponentOf(aiPlayer)) {
             // make sure not to redirect our own abilities
             return false;
         }
@@ -80,12 +83,22 @@ public class ChangeTargetsAi extends SpellAbilityAi {
             ManaCost normalizedMana = manaCost.getNormalizedMana();
             boolean canPay = ComputerUtilMana.canPayManaCost(new ManaCostBeingPaid(normalizedMana), sa, aiPlayer);
             if (potentialDmg != -1 && potentialDmg <= payDamage && !canPay
-                    && topSa.getTargets().contains(aiPlayer)) {
+                    && topTargets.contains(aiPlayer)) {
                 // do not pay Phyrexian mana if the spell is a damaging one but it deals less damage or the same damage as we'll pay life
                 return false;
             }
         }
 
+        Card firstCard = topTargets.getFirstTargetedCard();
+        // if we're not the target don't intervene unless we can steal a buff
+        if (firstCard != null && !aiPlayer.equals(firstCard.getController()) && !topHost.getController().equals(firstCard.getController()) && !topHost.getController().getAllies().contains(firstCard.getController())) {
+            return false;
+        }
+        Player firstPlayer = topTargets.getFirstTargetedPlayer();
+        if (firstPlayer != null && !aiPlayer.equals(firstPlayer)) {
+            return false;
+        }
+
         sa.resetTargets();
         sa.getTargets().add(topSa);
         return true;

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

@@ -15,6 +15,7 @@ import com.google.common.collect.Iterables;
 import com.google.common.collect.Lists;
 import com.google.common.collect.Maps;
 
+import forge.ai.AiAttackController;
 import forge.ai.AiBlockController;
 import forge.ai.AiCardMemory;
 import forge.ai.AiController;
@@ -57,6 +58,7 @@ import forge.game.player.PlayerActionConfirmMode;
 import forge.game.spellability.AbilitySub;
 import forge.game.spellability.SpellAbility;
 import forge.game.spellability.TargetRestrictions;
+import forge.game.staticability.StaticAbilityMustTarget;
 import forge.game.zone.ZoneType;
 import forge.util.MyRandom;
 
@@ -74,11 +76,9 @@ public class ChangeZoneAi extends SpellAbilityAi {
 
     @Override
     protected boolean checkAiLogic(final Player ai, final SpellAbility sa, final String aiLogic) {
-        Card host = sa.getHostCard();
-
-        if (host != null && host.hasSVar("AIPreferenceOverride")) {
+        if (sa.getHostCard() != null && sa.getHostCard().hasSVar("AIPreferenceOverride")) {
             // currently used by SacAndUpgrade logic, might need simplification
-            host.removeSVar("AIPreferenceOverride");
+            sa.getHostCard().removeSVar("AIPreferenceOverride");
         }
 
         if (aiLogic.equals("BeforeCombat")) {
@@ -92,7 +92,7 @@ public class ChangeZoneAi extends SpellAbilityAi {
         } 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(host.getName())).size() > 1;
+            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());
@@ -127,40 +127,6 @@ public class ChangeZoneAi extends SpellAbilityAi {
             return true;
         } else if (aiLogic.equals("Pongify")) {
             return SpecialAiLogic.doPongifyLogic(ai, sa);
-        } else if (aiLogic.equals("Ashiok")) {
-            final int loyalty = host.getCurrentLoyalty() - 1;
-            CardCollectionView choices = new CardCollection();
-            for (int i = loyalty; i >= 0; i--) {
-                sa.setXManaCostPaid(i);
-                choices = ai.getGame().getCardsIn(ZoneType.listValueOf(sa.getParam("Origin")));
-                choices = CardLists.getValidCards(choices, sa.getParam("ChangeType"), host.getController(), host, sa);
-                if (!choices.isEmpty()) {
-                    return true;
-                }
-            }
-            return false;
-        } else if (aiLogic.equals("BestCard")) {
-            CardCollectionView choices = ai.getGame().getCardsIn(ZoneType.listValueOf(sa.getParam("Origin")));
-            choices = CardLists.getValidCards(choices, sa.getParam("ChangeType"), host.getController(), host, sa);
-            if (!choices.isEmpty()) {
-                return true;
-            }
-        } else if (aiLogic.startsWith("DiscardAllAndRetExiled")) {
-            int numExiledWithSrc = CardLists.filter(ai.getCardsIn(ZoneType.Exile), CardPredicates.isExiledWith(host)).size();
-            int curHandSize = ai.getCardsIn(ZoneType.Hand).size();
-
-            // minimum card advantage unless the hand will be fully reloaded
-            int minAdv = aiLogic.contains(".minAdv") ? Integer.parseInt(aiLogic.substring(aiLogic.indexOf(".minAdv") + 7)) : 0;
-
-            if (numExiledWithSrc > curHandSize) {
-                if (ComputerUtil.predictThreatenedObjects(ai, sa, true).contains(host)) {
-                    // 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());
         }
 
         return super.checkAiLogic(ai, sa, aiLogic);
@@ -197,16 +163,9 @@ public class ChangeZoneAi extends SpellAbilityAi {
                 return SpecialCardAi.MazesEnd.consider(aiPlayer, sa);
             } else if (aiLogic.equals("Pongify")) {
                 return sa.isTargetNumberValid(); // Pre-targeted in checkAiLogic
-            } else if (aiLogic.equals("Ashiok")) {
-                return true; // If checkAiLogic returns true, then we should be good to go
-            } else if (aiLogic.equals("BestCard")) {
-                return true; // If checkAiLogic returns true, then we should be good to go
-            } else if (aiLogic.startsWith("DiscardAllAndRetExiled")) {
-                return true; // If checkAiLogic returns true, then we should be good to go
             }
         }
-
-        if (isHidden(sa)) {
+        if (sa.isHidden()) {
             return hiddenOriginCanPlayAI(aiPlayer, sa);
         }
         return knownOriginCanPlayAI(aiPlayer, sa);
@@ -223,21 +182,12 @@ public class ChangeZoneAi extends SpellAbilityAi {
      */
     @Override
     public boolean chkAIDrawback(SpellAbility sa, Player aiPlayer) {
-        if (isHidden(sa)) {
+        if (sa.isHidden()) {
             return hiddenOriginPlayDrawbackAI(aiPlayer, sa);
         }
         return knownOriginPlayDrawbackAI(aiPlayer, sa);
     }
 
-
-    private static boolean isHidden(SpellAbility sa) {
-        boolean hidden = sa.hasParam("Hidden");
-        if (!hidden && sa.hasParam("Origin")) {
-            hidden = ZoneType.isHidden(sa.getParam("Origin"));
-        }
-        return hidden;
-    }
-
     /**
      * <p>
      * changeZoneTriggerAINoCost.
@@ -273,7 +223,7 @@ public class ChangeZoneAi extends SpellAbilityAi {
             return delta <= 0;
         }
 
-        if (isHidden(sa)) {
+        if (sa.isHidden()) {
             return hiddenTriggerAI(aiPlayer, sa, mandatory);
         }
         return knownOriginTriggerAI(aiPlayer, sa, mandatory);
@@ -306,7 +256,7 @@ public class ChangeZoneAi extends SpellAbilityAi {
         final Card source = sa.getHostCard();
         final String sourceName = ComputerUtilAbility.getAbilitySourceName(sa);
         ZoneType origin = null;
-        final Player opponent = ai.getWeakestOpponent();
+        final Player opponent = AiAttackController.choosePreferredDefenderPlayer(ai);
         boolean activateForCost = ComputerUtil.activateForCost(sa, ai);
 
         if (sa.hasParam("Origin")) {
@@ -514,7 +464,7 @@ public class ChangeZoneAi extends SpellAbilityAi {
         // if putting cards from hand to library and parent is drawing cards
         // make sure this will actually do something:
         final TargetRestrictions tgt = sa.getTargetRestrictions();
-        final Player opp = aiPlayer.getWeakestOpponent();
+        final Player opp = AiAttackController.choosePreferredDefenderPlayer(aiPlayer);
         if (tgt != null && tgt.canTgtPlayer()) {
             boolean isCurse = sa.isCurse();
             if (isCurse && sa.canTarget(opp)) {
@@ -573,7 +523,7 @@ public class ChangeZoneAi extends SpellAbilityAi {
         Iterable<Player> pDefined;
         final TargetRestrictions tgt = sa.getTargetRestrictions();
         if ((tgt != null) && tgt.canTgtPlayer()) {
-            final Player opp = ai.getWeakestOpponent();
+            final Player opp = AiAttackController.choosePreferredDefenderPlayer(ai);
             if (sa.isCurse()) {
                 if (sa.canTarget(opp)) {
                     sa.getTargets().add(opp);
@@ -829,7 +779,7 @@ public class ChangeZoneAi extends SpellAbilityAi {
             return ph.getNextTurn().equals(ai) && ph.is(PhaseType.END_OF_TURN);
         }
 
-        if (isHidden(sa)) {
+        if (sa.isHidden()) {
             return true;
         }
 
@@ -935,7 +885,6 @@ public class ChangeZoneAi extends SpellAbilityAi {
 
             // TODO need to set XManaCostPaid for targets, maybe doesn't need PayX anymore?
             sa.setXManaCostPaid(xPay);
-            // TODO since change of PayX. the shouldCastLessThanMax logic might be faulty
         }
         CardCollection list = CardLists.getTargetableCards(game.getCardsIn(origin), sa);
 
@@ -956,9 +905,7 @@ public class ChangeZoneAi extends SpellAbilityAi {
         if (sa.isSpell()) {
             list.remove(source); // spells can't target their own source, because it's actually in the stack zone
         }
-        //System.out.println("isPreferredTarget " + list);
         if (sa.hasParam("AttachedTo")) {
-            //System.out.println("isPreferredTarget att " + list);
             list = CardLists.filter(list, new Predicate<Card>() {
                 @Override
                 public boolean apply(final Card c) {
@@ -970,7 +917,6 @@ public class ChangeZoneAi extends SpellAbilityAi {
                     return false;
                 }
             });
-            //System.out.println("isPreferredTarget ok " + list);
         }
 
         if (list.size() < sa.getMinTargets()) {
@@ -1206,6 +1152,10 @@ public class ChangeZoneAi extends SpellAbilityAi {
 
             if (!list.isEmpty()) {
                 if (destination.equals(ZoneType.Battlefield) || origin.contains(ZoneType.Battlefield)) {
+                    // filter by MustTarget requirement
+                    CardCollection originalList = new CardCollection(list);
+                    boolean mustTargetFiltered = StaticAbilityMustTarget.filterMustTargetCards(ai, list, sa);
+
                     final Card mostExpensive = ComputerUtilCard.getMostExpensivePermanentAI(list, sa, false);
                     if (mostExpensive.isCreature()) {
                         // if a creature is most expensive take the best one
@@ -1234,6 +1184,11 @@ public class ChangeZoneAi extends SpellAbilityAi {
                             return false;
                         }
                     }
+
+                    // Restore original list for next loop if filtered by MustTarget requirement
+                    if (mustTargetFiltered) {
+                        list = originalList;
+                    }
                 } else if (destination.equals(ZoneType.Hand) || destination.equals(ZoneType.Library)) {
                     List<Card> nonLands = CardLists.getNotType(list, "Land");
                     // Prefer to pull a creature, generally more useful for AI.
@@ -1352,8 +1307,7 @@ public class ChangeZoneAi extends SpellAbilityAi {
     private static Card canBouncePermanent(final Player ai, SpellAbility sa, CardCollectionView list) {
         Game game = ai.getGame();
         // filter out untargetables
-        CardCollectionView aiPermanents = CardLists
-                .filterControlledBy(list, ai);
+        CardCollectionView aiPermanents = CardLists.filterControlledBy(list, ai);
         CardCollection aiPlaneswalkers = CardLists.filter(aiPermanents, Presets.PLANESWALKERS);
 
         // Felidar Guardian + Saheeli Rai combo support
@@ -1525,9 +1479,11 @@ public class ChangeZoneAi extends SpellAbilityAi {
 
         if ("DeathgorgeScavenger".equals(logic)) {
             return SpecialCardAi.DeathgorgeScavenger.consider(ai, sa);
-        } else if ("ExtraplanarLens".equals(logic)) {
+        }
+        if ("ExtraplanarLens".equals(logic)) {
             return SpecialCardAi.ExtraplanarLens.consider(ai, sa);
-        } else if ("ExileCombatThreat".equals(logic)) {
+        }
+        if ("ExileCombatThreat".equals(logic)) {
             return doExileCombatThreatLogic(ai, sa);
         }
 
@@ -1753,7 +1709,6 @@ public class ChangeZoneAi extends SpellAbilityAi {
         return true;
     }
 
-
     @Override
     public Card chooseSingleCard(Player ai, SpellAbility sa, Iterable<Card> options, boolean isOptional, Player targetedPlayer, Map<String, Object> params) {
         // Called when looking for creature to attach aura or equipment
@@ -1904,23 +1859,25 @@ public class ChangeZoneAi extends SpellAbilityAi {
             }));
         }
 
-        // JAVA 1.8 use Map.Entry.comparingByValue() somehow
-        Map.Entry<Player, Map.Entry<String, Integer>> max = Collections.max(data.entrySet(), new Comparator<Map.Entry<Player, Map.Entry<String, Integer>>>() {
-            @Override
-            public int compare(Map.Entry<Player, Map.Entry<String, Integer>> o1, Map.Entry<Player, Map.Entry<String, Integer>> o2) {
-                return o1.getValue().getValue() - o2.getValue().getValue();
+        if (!data.isEmpty()) {
+            // JAVA 1.8 use Map.Entry.comparingByValue() somehow
+            Map.Entry<Player, Map.Entry<String, Integer>> max = Collections.max(data.entrySet(), new Comparator<Map.Entry<Player, Map.Entry<String, Integer>>>() {
+                @Override
+                public int compare(Map.Entry<Player, Map.Entry<String, Integer>> o1, Map.Entry<Player, Map.Entry<String, Integer>> o2) {
+                    return o1.getValue().getValue() - o2.getValue().getValue();
+                }
+            });
+
+            // filter list again by the opponent and a creature of the wanted name that can be targeted
+            list = CardLists.filter(CardLists.filterControlledBy(list, max.getKey()),
+                    CardPredicates.nameEquals(max.getValue().getKey()), CardPredicates.isTargetableBy(sa));
+
+            // list should contain only one element or zero
+            sa.resetTargets();
+            for (Card c : list) {
+                sa.getTargets().add(c);
+                return true;
             }
-        });
-
-        // filter list again by the opponent and a creature of the wanted name that can be targeted
-        list = CardLists.filter(CardLists.filterControlledBy(list, max.getKey()),
-                CardPredicates.nameEquals(max.getValue().getKey()), CardPredicates.isTargetableBy(sa));
-
-        // list should contain only one element or zero
-        sa.resetTargets();
-        for (Card c : list) {
-            sa.getTargets().add(c);
-            return true;
         }
 
         return false;
@@ -2021,17 +1978,12 @@ public class ChangeZoneAi extends SpellAbilityAi {
                 boolean setPayX = false;
                 if (unlessCost.equals("X") && sa.getSVar(unlessCost).equals("Count$xPaid")) {
                     setPayX = true;
-                    // TODO use ComputerUtilCost.getMaxXValue if able
-                    toPay = ComputerUtilMana.determineLeftoverMana(sa, ai);
+                    toPay = ComputerUtilCost.getMaxXValue(sa, ai);
                 } else {
                     toPay = AbilityUtils.calculateAmount(source, unlessCost, sa);
                 }
 
-                if (toPay == 0) {
-                    canBeSaved.add(potentialTgt);
-                }
-
-                if (toPay <= usableManaSources) {
+                if (toPay == 0 || toPay <= usableManaSources) {
                     canBeSaved.add(potentialTgt);
                 }
 

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

@@ -245,8 +245,25 @@ public class ChangeZoneAllAi extends SpellAbilityAi {
                         && !ComputerUtil.isPlayingReanimator(ai);
             }
         } else if (origin.equals(ZoneType.Exile)) {
-            // TODO: nothing to do here at the moment
-            return false;
+            String logic = sa.getParam("AILogic");
+
+            if (logic != null && logic.startsWith("DiscardAllAndRetExiled")) {
+                int numExiledWithSrc = CardLists.filter(ai.getCardsIn(ZoneType.Exile), CardPredicates.isExiledWith(source)).size();
+                int curHandSize = ai.getCardsIn(ZoneType.Hand).size();
+            
+                // 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)) {
             // time stop can do something like this:
             // Origin$ Stack | Destination$ Exile | SubAbility$ DBSkip

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

@@ -23,21 +23,23 @@ import forge.util.collect.FCollection;
 public class CharmAi extends SpellAbilityAi {
     @Override
     protected boolean checkApiLogic(Player ai, SpellAbility sa) {
-        // sa is Entwined, no need for extra logic
-        if (sa.isEntwine()) {
-            return true;
-        }
-
         final Card source = sa.getHostCard();
+        List<AbilitySub> choices = CharmEffect.makePossibleOptions(sa);
 
-        final int num = AbilityUtils.calculateAmount(source, sa.getParamOrDefault("CharmNum", "1"), sa);
-        final int min = sa.hasParam("MinCharmNum") ? AbilityUtils.calculateAmount(source, sa.getParamOrDefault("MinCharmNum", "1"), sa) : num;
+        final int num;
+        final int min;
+        if (sa.isEntwine()) {
+            num = min = choices.size();
+        }
+        else {
+            num = AbilityUtils.calculateAmount(source, sa.getParamOrDefault("CharmNum", "1"), sa);
+            min = sa.hasParam("MinCharmNum") ? AbilityUtils.calculateAmount(source, sa.getParamOrDefault("MinCharmNum", "1"), sa) : num;
+        }
 
         boolean timingRight = sa.isTrigger(); //is there a reason to play the charm now?
 
         // Reset the chosen list otherwise it will be locked in forever by earlier calls
         sa.setChosenList(null);
-        List<AbilitySub> choices = CharmEffect.makePossibleOptions(sa);
         List<AbilitySub> chosenList;
         
         if (!ai.equals(sa.getActivatingPlayer())) {
@@ -159,7 +161,7 @@ public class CharmAi extends SpellAbilityAi {
             chosenList.add(allyTainted ? gain : lose);
         } else if (oppTainted || ai.getGame().isCardInPlay("Rain of Gore")) {
             // Rain of Gore does negate lifegain, so don't benefit the others
-            // same for if a oppoent does control Tainted Remedy
+            // same for if a opponent does control Tainted Remedy
             // but if ai cant gain life, the effects are negated
             chosenList.add(ai.canGainLife() ? lose : gain);
         } else if (ai.getGame().isCardInPlay("Sulfuric Vortex")) {
@@ -177,13 +179,13 @@ public class CharmAi extends SpellAbilityAi {
             chosenList.add(gain);
         } else if(!ai.canGainLife() && aiLife == 14 ) {
             // ai cant gain life, but try to avoid falling to 13
-            // but if a oppoent does control Tainted Remedy its irrelevant
+            // but if a opponent does control Tainted Remedy its irrelevant
             chosenList.add(oppTainted ? lose : gain);
         } else if (allyTainted) {
             // Tainted Remedy negation logic, try gain instead of lose
             // because negation does turn it into lose for opponents
             boolean oppCritical = false;
-            // an oppoent is Critical = 14, and can't gain life, try to lose life instead
+            // an opponent is Critical = 14, and can't gain life, try to lose life instead
             // but only if ai doesn't kill itself with that.
             if (aiLife != 14) {
                 for (Player p : opponents) {
@@ -197,7 +199,7 @@ public class CharmAi extends SpellAbilityAi {
         } else {
             // normal logic, try to gain life if its critical
             boolean oppCritical = false;
-            // an oppoent is Critical = 12, and can gain life, try to gain life instead
+            // an opponent is Critical = 12, and can gain life, try to gain life instead
             // but only if ai doesn't kill itself with that.
             if (aiLife != 12) {
                 for (Player p : opponents) {
@@ -224,10 +226,12 @@ public class CharmAi extends SpellAbilityAi {
                 goodChoice = sub;
             } else {
                 // Standard canPlayAi()
+                sub.setActivatingPlayer(ai);
+                sub.getRestrictions().setZone(sub.getParent().getRestrictions().getZone());
                 if (AiPlayDecision.WillPlay == aic.canPlaySa(sub)) {
                     chosenList.add(sub);
                     if (chosenList.size() == min) {
-                        break;  // enough choices
+                        break; // enough choices
                     }
                 }
             }

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

@@ -9,6 +9,7 @@ import com.google.common.base.Predicates;
 import com.google.common.collect.Iterables;
 import com.google.common.collect.Lists;
 
+import forge.ai.AiAttackController;
 import forge.ai.ComputerUtilAbility;
 import forge.ai.ComputerUtilCard;
 import forge.ai.ComputerUtilCombat;
@@ -20,6 +21,7 @@ import forge.game.card.CardCollectionView;
 import forge.game.card.CardLists;
 import forge.game.card.CardPredicates;
 import forge.game.card.CardPredicates.Presets;
+import forge.game.card.CounterEnumType;
 import forge.game.combat.Combat;
 import forge.game.keyword.Keyword;
 import forge.game.phase.PhaseType;
@@ -73,10 +75,8 @@ public class ChooseCardAi extends SpellAbilityAi {
             return !choices.isEmpty();
         } else if (aiLogic.equals("AtLeast2") || aiLogic.equals("BestBlocker")) {
             return choices.size() >= 2;
-        } else if (aiLogic.equals("Clone") || aiLogic.equals("Vesuva")) {
-            final String filter = aiLogic.equals("Clone") ? "Permanent.YouDontCtrl,Permanent.nonLegendary"
-                    : "Permanent.YouDontCtrl+notnamedVesuva,Permanent.nonLegendary+notnamedVesuva";
-
+        } else if (aiLogic.equals("Clone")) {
+            final String filter = "Permanent.YouDontCtrl,Permanent.nonLegendary";
             choices = CardLists.getValidCards(choices, filter, host.getController(), host, sa);
             return !choices.isEmpty();
         } else if (aiLogic.equals("Never")) {
@@ -96,12 +96,24 @@ public class ChooseCardAi extends SpellAbilityAi {
                     return ComputerUtilCombat.damageIfUnblocked(c, ai, combat, true) > ref;
                 }
             });
+            return !choices.isEmpty();
+        } else if (aiLogic.equals("Ashiok")) {
+            final int loyalty = host.getCounters(CounterEnumType.LOYALTY) - 1;
+            for (int i = loyalty; i >= 0; i--) {
+                sa.setXManaCostPaid(i);
+                choices = ai.getGame().getCardsIn(choiceZone);
+                choices = CardLists.getValidCards(choices, sa.getParam("Choices"), host.getController(), host, sa);
+                if (!choices.isEmpty()) {
+                    return true;
+                }
+            }
+
             return !choices.isEmpty();
         } else if (aiLogic.equals("RandomNonLand")) {
             return !CardLists.getValidCards(choices, "Card.nonLand", host.getController(), host, sa).isEmpty();
         } else if (aiLogic.equals("Duneblast")) {
             CardCollection aiCreatures = ai.getCreaturesInPlay();
-            CardCollection oppCreatures = ai.getWeakestOpponent().getCreaturesInPlay();
+            CardCollection oppCreatures = AiAttackController.choosePreferredDefenderPlayer(ai).getCreaturesInPlay();
             aiCreatures = CardLists.getNotKeyword(aiCreatures, Keyword.INDESTRUCTIBLE);
             oppCreatures = CardLists.getNotKeyword(oppCreatures, Keyword.INDESTRUCTIBLE);
 
@@ -159,18 +171,13 @@ public class ChooseCardAi extends SpellAbilityAi {
                 options = CardLists.filter(options, Presets.UNTAPPED);
             }
             choice = ComputerUtilCard.getBestCreatureAI(options);
-        } else if (logic.equals("Clone") || logic.equals("Vesuva")) {
-            final String filter = logic.equals("Clone") ? "Permanent.YouDontCtrl,Permanent.nonLegendary" :
-                    "Permanent.YouDontCtrl+notnamedVesuva,Permanent.nonLegendary+notnamedVesuva";
-
+        } else if (logic.equals("Clone")) {
+            final String filter = "Permanent.YouDontCtrl,Permanent.nonLegendary";
             CardCollection newOptions = CardLists.getValidCards(options, filter.split(","), ctrl, host, sa);
             if (!newOptions.isEmpty()) {
                 options = newOptions;
             }
             choice = ComputerUtilCard.getBestAI(options);
-            if (logic.equals("Vesuva") && "Vesuva".equals(choice.getName())) {
-                choice = null;
-            }
         } else if ("RandomNonLand".equals(logic)) {
             options = CardLists.getValidCards(options, "Card.nonLand", host.getController(), host, sa);
             choice = Aggregates.random(options);
@@ -239,7 +246,6 @@ public class ChooseCardAi extends SpellAbilityAi {
                     return true;
                 }
             });
-            System.out.println("Tangle Wire" + options + " - " + betterList);
             if (!betterList.isEmpty()) {
                 choice = betterList.get(0);
             } else {

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

@@ -7,6 +7,7 @@ import com.google.common.collect.Iterables;
 import com.google.common.collect.Lists;
 
 import forge.StaticData;
+import forge.ai.AiAttackController;
 import forge.ai.ComputerUtil;
 import forge.ai.ComputerUtilCard;
 import forge.ai.SpecialCardAi;
@@ -34,9 +35,7 @@ public class ChooseCardNameAi extends SpellAbilityAi {
             }
 
             String logic = sa.getParam("AILogic");
-            if (logic.equals("MomirAvatar")) {
-                return SpecialCardAi.MomirVigAvatar.consider(ai, sa);
-            } else if (logic.equals("CursedScroll")) {
+            if (logic.equals("CursedScroll")) {
                 return SpecialCardAi.CursedScroll.consider(ai, sa);
             }
 
@@ -44,7 +43,7 @@ public class ChooseCardNameAi extends SpellAbilityAi {
             if (tgt != null) {
                 sa.resetTargets();
                 if (tgt.canOnlyTgtOpponent()) {
-                    sa.getTargets().add(ai.getWeakestOpponent());
+                    sa.getTargets().add(AiAttackController.choosePreferredDefenderPlayer(ai));
                 } else {
                     sa.getTargets().add(ai);
                 }
@@ -64,7 +63,6 @@ public class ChooseCardNameAi extends SpellAbilityAi {
      */
     @Override
     public Card chooseSingleCard(final Player ai, SpellAbility sa, Iterable<Card> options, boolean isOptional, Player targetedPlayer, Map<String, Object> params) {
-
         return ComputerUtilCard.getBestAI(options);
     }
 

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

@@ -1,5 +1,6 @@
 package forge.ai.ability;
 
+import forge.ai.AiAttackController;
 import forge.ai.SpellAbilityAi;
 import forge.game.player.Player;
 import forge.game.spellability.SpellAbility;
@@ -16,7 +17,7 @@ public class ChooseEvenOddAi extends SpellAbilityAi {
         TargetRestrictions tgt = sa.getTargetRestrictions();
         if (tgt != null) {
             sa.resetTargets();
-            Player opp = aiPlayer.getWeakestOpponent();
+            Player opp = AiAttackController.choosePreferredDefenderPlayer(aiPlayer);
             if (sa.canTarget(opp)) {
                 sa.getTargets().add(opp);
             } else {

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

@@ -8,7 +8,6 @@ import com.google.common.collect.Iterables;
 import com.google.common.collect.Lists;
 import com.google.common.collect.Sets;
 
-
 import forge.ai.ComputerUtilAbility;
 import forge.ai.ComputerUtilCard;
 import forge.ai.ComputerUtilCost;
@@ -32,7 +31,6 @@ import forge.game.phase.PhaseType;
 import forge.game.player.Player;
 import forge.game.spellability.AbilitySub;
 import forge.game.spellability.SpellAbility;
-import forge.game.staticability.StaticAbilityCantBeCast;
 import forge.game.zone.ZoneType;
 import forge.util.Aggregates;
 import forge.util.collect.FCollection;
@@ -54,8 +52,6 @@ public class ChooseGenericEffectAi extends SpellAbilityAi {
             }
         } else if ("GideonBlackblade".equals(aiLogic)) {
             return SpecialCardAi.GideonBlackblade.consider(ai, sa);
-        } else if ("SoulEcho".equals(aiLogic)) {
-            return doTriggerAINoCost(ai, sa, true);
         } else if ("Always".equals(aiLogic)) {
             return true;
         }
@@ -72,7 +68,7 @@ public class ChooseGenericEffectAi extends SpellAbilityAi {
      */
     @Override
     public boolean chkAIDrawback(SpellAbility sa, Player aiPlayer) {
-        return checkApiLogic(aiPlayer, sa);
+        return sa.isTrigger() ? doTriggerAINoCost(aiPlayer, sa, sa.isMandatory()) : checkApiLogic(aiPlayer, sa);
     }
 
     @Override
@@ -160,6 +156,22 @@ public class ChooseGenericEffectAi extends SpellAbilityAi {
                 }
             }
             return others;
+        } else if ("Counters".equals(logic)) {
+            // TODO: this code will need generalization if this logic is used for cards other
+            // than Elspeth Conquers Death with different choice parameters
+            SpellAbility p1p1 = null, loyalty = null;
+            for (final SpellAbility sp : spells) {
+                if (("P1P1").equals(sp.getParam("CounterType"))) {
+                    p1p1 = sp;
+                } else {
+                    loyalty = sp;
+                }
+            }
+            if (sa.getParent().getTargetCard() != null && sa.getParent().getTargetCard().getType().isPlaneswalker()) {
+                return loyalty;
+            } else {
+                return p1p1;
+            }
         } else if ("Fatespinner".equals(logic)) {
             SpellAbility skipDraw = null, /*skipMain = null,*/ skipCombat = null;
             for (final SpellAbility sp : spells) {
@@ -230,10 +242,11 @@ public class ChooseGenericEffectAi extends SpellAbilityAi {
                 return allow;
             }
 
-            SpellAbility firstSpell = imprinted.getFirstSpellAbility();
-            // check if something would prevent it from casting
-            if (firstSpell == null || StaticAbilityCantBeCast.cantBeCastAbility(firstSpell, imprinted, owner)) {
-                return allow;
+            //if Iona does prevent from casting, allow it to draw
+            for (final Card io : player.getCardsIn(ZoneType.Battlefield, "Iona, Shield of Emeria")) {
+                if (CardUtil.getColors(imprinted).hasAnyColor(MagicColor.fromName(io.getChosenColor()))) {
+                    return allow;
+                }
             }
 
             if (dmg == 0) {
@@ -364,8 +377,6 @@ public class ChooseGenericEffectAi extends SpellAbilityAi {
         } else if ("Riot".equals(logic)) {
             SpellAbility counterSA = spells.get(0), hasteSA = spells.get(1);
             return preferHasteForRiot(sa, player) ? hasteSA : counterSA;
-        } else if ("CrawlingBarrens".equals(logic)) {
-            return SpecialCardAi.CrawlingBarrens.considerAnimating(player, sa, spells);
         }
         return spells.get(0);   // return first choice if no logic found
     }

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

@@ -1,5 +1,6 @@
 package forge.ai.ability;
 
+import forge.ai.AiAttackController;
 import forge.ai.SpellAbilityAi;
 import forge.game.player.Player;
 import forge.game.spellability.SpellAbility;
@@ -16,7 +17,7 @@ public class ChooseNumberAi extends SpellAbilityAi {
         TargetRestrictions tgt = sa.getTargetRestrictions();
         if (tgt != null) {
             sa.resetTargets();
-            Player opp = aiPlayer.getWeakestOpponent();
+            Player opp = AiAttackController.choosePreferredDefenderPlayer(aiPlayer);
             if (sa.canTarget(opp)) {
                 sa.getTargets().add(opp);
             } else {

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

@@ -8,6 +8,7 @@ import com.google.common.base.Predicates;
 import com.google.common.collect.Iterables;
 import com.google.common.collect.Lists;
 
+import forge.ai.AiAttackController;
 import forge.ai.ComputerUtilCard;
 import forge.ai.ComputerUtilCombat;
 import forge.ai.SpellAbilityAi;
@@ -54,7 +55,7 @@ public class ChooseSourceAi extends SpellAbilityAi {
         final TargetRestrictions tgt = sa.getTargetRestrictions();
         if (tgt != null) {
             sa.resetTargets();
-            Player opp = ai.getWeakestOpponent();
+            Player opp = AiAttackController.choosePreferredDefenderPlayer(ai);
             if (sa.canTarget(opp)) {
                 sa.getTargets().add(opp);
             } else {

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

@@ -34,6 +34,7 @@ public class ChooseTypeAi extends SpellAbilityAi {
             if (ComputerUtilAbility.getAbilitySourceName(sa).equals("Mirror Entity Avatar")) {
                 return doMirrorEntityLogic(aiPlayer, sa);
             }
+            return !chooseType(sa, aiPlayer.getCardsIn(ZoneType.Battlefield)).isEmpty();
         } else if ("MostProminentOppControls".equals(sa.getParam("AILogic"))) {
             return !chooseType(sa, aiPlayer.getOpponents().getCardsIn(ZoneType.Battlefield)).isEmpty();
         }

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

@@ -3,13 +3,17 @@ package forge.ai.ability;
 import java.util.List;
 import java.util.Map;
 
+import com.google.common.base.Predicates;
+
 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.CardCollection;
+import forge.game.card.CardCollectionView;
 import forge.game.card.CardLists;
+import forge.game.card.CardPredicates;
 import forge.game.phase.PhaseHandler;
 import forge.game.phase.PhaseType;
 import forge.game.player.Player;
@@ -52,7 +56,7 @@ public class CloneAi extends SpellAbilityAi {
                 bFlag |= (!c.isCreature() && !c.isTapped() && !(c.getTurnInZone() == phase.getTurn()));
 
                 // for creatures that could be improved (like Figure of Destiny)
-                if (c.isCreature() && (sa.hasParam("Permanent") || (!c.isTapped() && !c.isSick()))) {
+                if (c.isCreature() && (!sa.hasParam("Duration") || (!c.isTapped() && !c.isSick()))) {
                     int power = -5;
                     if (sa.hasParam("Power")) {
                         power = AbilityUtils.calculateAmount(source, sa.getParam("Power"), sa);
@@ -68,8 +72,7 @@ public class CloneAi extends SpellAbilityAi {
 
             }
 
-            if (!bFlag) { // All of the defined stuff is cloned, not very
-                          // useful
+            if (!bFlag) { // All of the defined stuff is cloned, not very useful
                 return false;
             }
         } else {
@@ -95,11 +98,18 @@ public class CloneAi extends SpellAbilityAi {
 
     @Override
     protected boolean doTriggerAINoCost(Player aiPlayer, SpellAbility sa, boolean mandatory) {
-
+        Card host = sa.getHostCard();
         boolean chance = true;
 
         if (sa.usesTargeting()) {
             chance = cloneTgtAI(sa);
+        } else {
+            if (sa.hasParam("Choices")) {
+                CardCollectionView choices = CardLists.getValidCards(host.getGame().getCardsIn(ZoneType.Battlefield),
+                        sa.getParam("Choices"), host.getController(), host, sa);
+
+                chance = !choices.isEmpty();
+            }
         }
 
         // Improve AI for triggers. If source is a creature with:
@@ -171,18 +181,18 @@ public class CloneAi extends SpellAbilityAi {
     @Override
     protected Card chooseSingleCard(Player ai, SpellAbility sa, Iterable<Card> options, boolean isOptional,
             Player targetedPlayer, Map<String, Object> params) {
-
         final Card host = sa.getHostCard();
+        final String name = host.getName();
         final Player ctrl = host.getController();
 
         final Card cloneTarget = getCloneTarget(sa);
         final boolean isOpp = cloneTarget.getController().isOpponentOf(sa.getActivatingPlayer());
 
-        final boolean isVesuva = "Vesuva".equals(host.getName());
+        final boolean isVesuva = "Vesuva".equals(name) || "Sculpting Steel".equals(name);
         final boolean canCloneLegendary = "True".equalsIgnoreCase(sa.getParam("NonLegendary"));
 
         String filter = !isVesuva ? "Permanent.YouDontCtrl,Permanent.nonLegendary"
-                : "Permanent.YouDontCtrl+notnamedVesuva,Permanent.nonLegendary+notnamedVesuva";
+                : "Permanent.YouDontCtrl+notnamed" + name + ",Permanent.nonLegendary+notnamed" + name;
 
         // TODO: rewrite this block so that this is done somehow more elegantly
         if (canCloneLegendary) {
@@ -201,12 +211,13 @@ public class CloneAi extends SpellAbilityAi {
             }
         }
 
-        Card choice = isOpp ? ComputerUtilCard.getWorstAI(options) : ComputerUtilCard.getBestAI(options);
-
-        if (isVesuva && "Vesuva".equals(choice.getName())) {
-            choice = null;
+        // prevent loop of choosing copy of same card
+        if (isVesuva) {
+            options = CardLists.filter(options, Predicates.not(CardPredicates.sharesNameWith(host)));
         }
 
+        Card choice = isOpp ? ComputerUtilCard.getWorstAI(options) : ComputerUtilCard.getBestAI(options);
+
         return choice;
     }
 
@@ -234,7 +245,7 @@ public class CloneAi extends SpellAbilityAi {
         // Combat_Begin step
         if (!ph.is(PhaseType.COMBAT_BEGIN)
                 && ph.isPlayerTurn(ai) && !SpellAbilityAi.isSorcerySpeed(sa)
-                && !sa.hasParam("ActivationPhases") && !sa.hasParam("Permanent")) {
+                && !sa.hasParam("ActivationPhases") && sa.hasParam("Duration")) {
             return false;
         }
 
@@ -245,6 +256,6 @@ public class CloneAi extends SpellAbilityAi {
         }
 
         // don't activate during main2 unless this effect is permanent
-        return !ph.is(PhaseType.MAIN2) || sa.hasParam("Permanent");
+        return !ph.is(PhaseType.MAIN2) || !sa.hasParam("Duration");
     }
 }

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

@@ -3,6 +3,7 @@ package forge.ai.ability;
 import com.google.common.base.Predicate;
 import com.google.common.collect.Lists;
 
+import forge.ai.AiAttackController;
 import forge.ai.ComputerUtilCard;
 import forge.ai.SpellAbilityAi;
 import forge.game.ability.AbilityUtils;
@@ -29,9 +30,8 @@ public class ControlExchangeAi extends SpellAbilityAi {
         sa.resetTargets();
 
         CardCollection list =
-                CardLists.getValidCards(ai.getWeakestOpponent().getCardsIn(ZoneType.Battlefield), tgt.getValidTgts(), ai, sa.getHostCard(), sa);
-        // AI won't try to grab cards that are filtered out of AI decks on
-        // purpose
+                CardLists.getValidCards(AiAttackController.choosePreferredDefenderPlayer(ai).getCardsIn(ZoneType.Battlefield), tgt.getValidTgts(), ai, sa.getHostCard(), sa);
+        // AI won't try to grab cards that are filtered out of AI decks on purpose
         list = CardLists.filter(list, new Predicate<Card>() {
             @Override
             public boolean apply(final Card c) {                

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

@@ -39,6 +39,7 @@ import forge.game.player.PlayerCollection;
 import forge.game.player.PlayerPredicates;
 import forge.game.spellability.SpellAbility;
 import forge.game.spellability.TargetRestrictions;
+import forge.game.staticability.StaticAbilityMustTarget;
 import forge.game.zone.ZoneType;
 import forge.util.Aggregates;
 
@@ -67,7 +68,6 @@ import forge.util.Aggregates;
 public class ControlGainAi extends SpellAbilityAi {
     @Override
     protected boolean canPlayAI(final Player ai, final SpellAbility sa) {
-
         final List<String> lose = Lists.newArrayList();
 
         if (sa.hasParam("LoseControl")) {
@@ -109,8 +109,7 @@ public class ControlGainAi extends SpellAbilityAi {
             }
         }
 
-        // Don't steal something if I can't Attack without, or prevent it from
-        // blocking at least
+        // Don't steal something if I can't Attack without, or prevent it from blocking at least
         if (lose.contains("EOT")
                 && ai.getGame().getPhaseHandler().getPhase().isAfter(PhaseType.COMBAT_DECLARE_ATTACKERS)
                 && !sa.isTrigger()) {
@@ -210,7 +209,12 @@ public class ControlGainAi extends SpellAbilityAi {
                 }
             }
 
+            // TODO check life of controller and consider stealing from another opponent so the risk of your army disappearing is spread out
             while (t == null) {
+                // filter by MustTarget requirement
+                CardCollection originalList = new CardCollection(list);
+                boolean mustTargetFiltered = StaticAbilityMustTarget.filterMustTargetCards(ai, list, sa);
+
                 if (planeswalkers > 0) {
                     t = ComputerUtilCard.getBestPlaneswalkerAI(list);
                 } else if (creatures > 0) {
@@ -238,6 +242,11 @@ public class ControlGainAi extends SpellAbilityAi {
                         enchantments--;
                 }
 
+                // Restore original list for next loop if filtered by MustTarget requirement
+                if (mustTargetFiltered) {
+                    list = originalList;
+                }
+
                 if (!sa.canTarget(t)) {
                     list.remove(t);
                     t = null;
@@ -254,7 +263,6 @@ public class ControlGainAi extends SpellAbilityAi {
         }
 
         return true;
-
     }
 
     @Override

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

@@ -44,7 +44,9 @@ public class CopyPermanentAi extends SpellAbilityAi {
             return false;
         }
 
-        if ("MimicVat".equals(aiLogic)) {
+        if ("MomirAvatar".equals(aiLogic)) {
+                return SpecialCardAi.MomirVigAvatar.consider(aiPlayer, sa);
+        } else if ("MimicVat".equals(aiLogic)) {
             return SpecialCardAi.MimicVat.considerCopy(aiPlayer, sa);
         } else if ("AtEOT".equals(aiLogic)) {
             return ph.is(PhaseType.END_OF_TURN);

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

@@ -113,8 +113,7 @@ public class CounterAi extends SpellAbilityAi {
             boolean setPayX = false;
             if (unlessCost.equals("X") && sa.getSVar(unlessCost).equals("Count$xPaid")) {
                 setPayX = true;
-                // TODO use ComputerUtilCost.getMaxXValue
-                toPay = Math.min(ComputerUtilMana.determineLeftoverMana(sa, ai), usableManaSources + 1);
+                toPay = Math.min(ComputerUtilCost.getMaxXValue(sa, ai), usableManaSources + 1);
             } else {
                 toPay = AbilityUtils.calculateAmount(source, unlessCost, sa);
             }
@@ -124,8 +123,7 @@ public class CounterAi extends SpellAbilityAi {
             }
 
             if (toPay <= usableManaSources) {
-                // If this is a reusable Resource, feel free to play it most of
-                // the time
+                // If this is a reusable Resource, feel free to play it most of the time
                 if (!SpellAbilityAi.playReusable(ai,sa)) {
                     return false;
                 }

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

@@ -29,7 +29,6 @@ import forge.util.collect.FCollection;
 public class CountersMoveAi extends SpellAbilityAi {
     @Override
     protected boolean checkApiLogic(final Player ai, final SpellAbility sa) {
-
         if (sa.usesTargeting()) {
             sa.resetTargets();
             if (!moveTgtAI(ai, sa)) {
@@ -83,8 +82,7 @@ public class CountersMoveAi extends SpellAbilityAi {
                                 return true;
                             }
 
-                            // something you can't block, try to reduce its
-                            // attack
+                            // something you can't block, try to reduce its attack
                             if (!ComputerUtilCard.canBeBlockedProfitably(ai, cpy)) {
                                 return true;
                             }
@@ -119,7 +117,6 @@ public class CountersMoveAi extends SpellAbilityAi {
 
     @Override
     protected boolean doTriggerAINoCost(final Player ai, SpellAbility sa, boolean mandatory) {
-
         if (sa.usesTargeting()) {
             sa.resetTargets();
 
@@ -237,7 +234,6 @@ public class CountersMoveAi extends SpellAbilityAi {
     }
 
     private boolean moveTgtAI(final Player ai, final SpellAbility sa) {
-
         final Card host = sa.getHostCard();
         final Game game = ai.getGame();
         final String type = sa.getParam("CounterType");
@@ -283,8 +279,7 @@ public class CountersMoveAi extends SpellAbilityAi {
                         // cant use substract on Copy
                         srcCardCpy.setCounters(cType, srcCardCpy.getCounters(cType) - amount);
 
-                        // do not steal a P1P1 from Undying if it would die
-                        // this way
+                        // do not steal a P1P1 from Undying if it would die this way
                         if (cType != null && cType.is(CounterEnumType.P1P1) && srcCardCpy.getNetToughness() <= 0) {
                             return srcCardCpy.getCounters(cType) > 0 || !card.hasKeyword(Keyword.UNDYING) || card.isToken();
                         }
@@ -372,54 +367,68 @@ public class CountersMoveAi extends SpellAbilityAi {
                 }
             }
 
-            List<Card> aiList = CardLists.filterControlledBy(tgtCards, ai);
-            if (!aiList.isEmpty()) {
-                List<Card> best = CardLists.filter(aiList, new Predicate<Card>() {
+            Card lki = CardUtil.getLKICopy(src);
+            if (cType == null) {
+                lki.clearCounters();
+            }
+            else {
+                lki.setCounters(cType, 0);
+            }
+            // go for opponent when higher value implies debuff
+            if (ComputerUtilCard.evaluateCreature(src) > ComputerUtilCard.evaluateCreature(lki)) {
+                List<Card> aiList = CardLists.filterControlledBy(tgtCards, ai);
+                if (!aiList.isEmpty()) {
+                    List<Card> best = CardLists.filter(aiList, new Predicate<Card>() {
 
-                    @Override
-                    public boolean apply(Card card) {
-                        // gain from useless
-                        if (ComputerUtilCard.isUselessCreature(ai, card)) {
-                            return false;
-                        }
-
-                        // source would leave the game
-                        if (card.hasSVar("EndOfTurnLeavePlay")) {
-                            return false;
-                        }
-
-                        if (cType != null) {
-                            if (cType.is(CounterEnumType.P1P1) && card.hasKeyword(Keyword.UNDYING)) {
-                                return false;
-                            }
-                            if (cType.is(CounterEnumType.M1M1) && card.hasKeyword(Keyword.PERSIST)) {
+                        @Override
+                        public boolean apply(Card card) {
+                            // gain from useless
+                            if (ComputerUtilCard.isUselessCreature(ai, card)) {
                                 return false;
                             }
 
-                            if (!card.canReceiveCounters(cType)) {
+                            // source would leave the game
+                            if (card.hasSVar("EndOfTurnLeavePlay")) {
                                 return false;
                             }
+
+                            if (cType != null) {
+                                if (cType.is(CounterEnumType.P1P1) && card.hasKeyword(Keyword.UNDYING)) {
+                                    return false;
+                                }
+                                if (cType.is(CounterEnumType.M1M1)) {
+                                    return false;
+                                }
+
+                                if (!card.canReceiveCounters(cType)) {
+                                    return false;
+                                }
+                            }
+                            return true;
                         }
+                    });
+
+                    if (best.isEmpty()) {
+                        best = aiList;
+                    }
+
+                    Card card = ComputerUtilCard.getBestCreatureAI(best);
+
+                    if (card != null) {
+                        sa.getTargets().add(card);
                         return true;
                     }
-                });
-
-                if (best.isEmpty()) {
-                    best = aiList;
                 }
-
-                Card card = ComputerUtilCard.getBestCreatureAI(best);
-
-                if (card != null) {
-                    sa.getTargets().add(card);
-                    return true;
+                final boolean isMandatoryTrigger = (sa.isTrigger() && !sa.isOptionalTrigger())
+                        || (sa.getRootAbility().isTrigger() && !sa.getRootAbility().isOptionalTrigger());
+                if (!isMandatoryTrigger) {
+                    // no good target
+                    return false;
                 }
             }
 
-            // move counter to opponents creature but only if you can not steal
-            // them
-            // try to move to something useless or something that would leave
-            // play
+            // move counter to opponents creature but only if you can not steal them
+            // try to move to something useless or something that would leave play
             List<Card> oppList = CardLists.filterControlledBy(tgtCards, ai.getOpponents());
             if (!oppList.isEmpty()) {
                 List<Card> best = CardLists.filter(oppList, new Predicate<Card>() {
@@ -441,7 +450,7 @@ public class CountersMoveAi extends SpellAbilityAi {
                 });
 
                 if (best.isEmpty()) {
-                    best = aiList;
+                    best = oppList;
                 }
 
                 Card card = ComputerUtilCard.getBestCreatureAI(best);
@@ -455,7 +464,7 @@ public class CountersMoveAi extends SpellAbilityAi {
         }
     }
 
-    // used for multiple sources -> defied
+    // used for multiple sources -> defined
     // or for source -> multiple defined
     @Override
     protected Card chooseSingleCard(Player ai, SpellAbility sa, Iterable<Card> options, boolean isOptional,

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

@@ -120,8 +120,7 @@ public class CountersMultiplyAi extends SpellAbilityAi {
 
         CardCollection list = CardLists.getTargetableCards(game.getCardsIn(ZoneType.Battlefield), sa);
 
-        // pre filter targetable cards with counters and can receive one of
-        // them
+        // pre filter targetable cards with counters and can receive one of them
         list = CardLists.filter(list, new Predicate<Card>() {
 
             @Override

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

@@ -8,8 +8,10 @@ import com.google.common.base.Predicate;
 import com.google.common.collect.Iterables;
 import com.google.common.collect.Lists;
 
+import forge.ai.AiProps;
 import forge.ai.ComputerUtil;
 import forge.ai.ComputerUtilCard;
+import forge.ai.PlayerControllerAi;
 import forge.ai.SpellAbilityAi;
 import forge.game.GameEntity;
 import forge.game.card.Card;
@@ -121,6 +123,7 @@ public class CountersProliferateAi extends SpellAbilityAi {
 
         final CounterType poison = CounterType.get(CounterEnumType.POISON);
 
+        boolean aggroAI = (((PlayerControllerAi) ai.getController()).getAi()).getBooleanProperty(AiProps.PLAY_AGGRO);
         // because countertype can't be chosen anymore, only look for posion counters
         for (final Player p : Iterables.filter(options, Player.class)) {
             if (p.isOpponentOf(ai)) {
@@ -128,7 +131,8 @@ public class CountersProliferateAi extends SpellAbilityAi {
                     return (T)p;
                 }
             } else {
-                if (p.getCounters(poison) <= 5 || p.canReceiveCounters(poison)) {
+                // poison is risky, should not proliferate them in most cases
+                if ((p.getCounters(poison) <= 5 && aggroAI && p.getCounters(CounterEnumType.EXPERIENCE) + p.getCounters(CounterEnumType.ENERGY) >= 1) || !p.canReceiveCounters(poison)) {
                     return (T)p;
                 }
             }

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

@@ -47,6 +47,8 @@ import forge.game.player.PlayerCollection;
 import forge.game.player.PlayerPredicates;
 import forge.game.spellability.SpellAbility;
 import forge.game.spellability.TargetRestrictions;
+import forge.game.trigger.Trigger;
+import forge.game.trigger.TriggerType;
 import forge.game.zone.ZoneType;
 import forge.util.Aggregates;
 import forge.util.MyRandom;
@@ -62,11 +64,9 @@ public class CountersPutAi extends SpellAbilityAi {
      */
     @Override
     protected boolean willPayCosts(Player ai, SpellAbility sa, Cost cost, Card source) {
-
         final String type = sa.getParam("CounterType");
         final String aiLogic = sa.getParamOrDefault("AILogic", "");
 
-        // TODO Auto-generated method stub
         if (!super.willPayCosts(ai, sa, cost, source)) {
             return false;
         }
@@ -223,8 +223,7 @@ public class CountersPutAi extends SpellAbilityAi {
                 }
 
                 if (sa.canTarget(ai)) {
-                    // don't target itself when its forced to add poison
-                    // counters too
+                    // don't target itself when its forced to add poison counters too
                     if (!ai.getCounters().isEmpty()) {
                         if (!eachExisting || ai.getPoisonCounters() < 5) {
                             sa.getTargets().add(ai);
@@ -313,7 +312,12 @@ public class CountersPutAi extends SpellAbilityAi {
         } else if (logic.startsWith("MoveCounter")) {
             return doMoveCounterLogic(ai, sa, ph);
         } else if (logic.equals("CrawlingBarrens")) {
-            return SpecialCardAi.CrawlingBarrens.consider(ai, sa);
+            boolean willActivate = SpecialCardAi.CrawlingBarrens.consider(ai, sa);
+            if (willActivate && ph.getPhase().isBefore(PhaseType.MAIN2)) {
+                // don't use this for mana until after combat
+                AiCardMemory.rememberCard(ai, source, AiCardMemory.MemorySet.HELD_MANA_SOURCES_FOR_MAIN2);
+            }
+            return willActivate;
         }
 
         if (!sa.metConditions() && sa.getSubAbility() == null) {
@@ -401,19 +405,37 @@ public class CountersPutAi extends SpellAbilityAi {
         }
 
         if ("Polukranos".equals(logic)) {
+            boolean found = false;
+            for (Trigger tr : source.getTriggers()) {
+                if (!tr.getMode().equals(TriggerType.BecomeMonstrous)) {
+                    continue;
+                }
+                SpellAbility oa = tr.ensureAbility();
+                if (oa == null) {
+                    continue;
+                }
 
-            CardCollection targets = CardLists.getTargetableCards(ai.getOpponents().getCreaturesInPlay(), sa);
+                // need to set Activating player
+                oa.setActivatingPlayer(ai);
+                CardCollection targets = CardLists.getTargetableCards(ai.getOpponents().getCreaturesInPlay(), oa);
 
-            if (!targets.isEmpty()){
-                boolean canSurvive = false;
-                for (Card humanCreature : targets) {
-                    if (!FightAi.canKill(humanCreature, source, 0)){
-                        canSurvive = true;
+                if (!targets.isEmpty()){
+                    boolean canSurvive = false;
+                    for (Card humanCreature : targets) {
+                        if (!FightAi.canKill(humanCreature, source, 0)){
+                            canSurvive = true;
+                            break;
+                        }
                     }
-                }
-                if (!canSurvive){
-                    return false;
-                }
+                    if (!canSurvive){
+                        return false;
+                    }
+                };
+                found = true;
+                break;
+            }
+            if (!found) {
+                return false;
             }
         }
 
@@ -455,7 +477,6 @@ public class CountersPutAi extends SpellAbilityAi {
             list = CardLists.filter(list, new Predicate<Card>() {
                 @Override
                 public boolean apply(final Card c) {
-
                     // don't put the counter on the dead creature
                     if (sacSelf && c.equals(source)) {
                         return false;
@@ -468,6 +489,8 @@ public class CountersPutAi extends SpellAbilityAi {
                 Card sacTarget = ComputerUtil.getCardPreference(ai, source, "SacCost", list);
                 // this card is planned to be sacrificed during cost payment, so don't target it
                 // (otherwise the AI can cheat by activating this SA and not paying the sac cost, e.g. Extruder)
+                // TODO needs update if amount > 1 gets printed, 
+                // maybe also check putting the counter on that exact creature is more important than sacrificing it (though unlikely?)
                 list.remove(sacTarget);
             }
 
@@ -592,7 +615,7 @@ public class CountersPutAi extends SpellAbilityAi {
             // Instant +1/+1
             if (type.equals("P1P1") && !SpellAbilityAi.isSorcerySpeed(sa)) {
                 if (!(ph.getNextTurn() == ai && ph.is(PhaseType.END_OF_TURN) && abCost.isReusuableResource())) {
-                    return false;   // only if next turn and cost is reusable
+                    return false; // only if next turn and cost is reusable
                 }
             }
         }
@@ -841,17 +864,16 @@ public class CountersPutAi extends SpellAbilityAi {
                             choice = Aggregates.random(list);
                         }
                     }
-                    if (choice != null && divided) {
-                        int alloc = Math.max(amount / totalTargets, 1);
-                        if (sa.getTargets().size() == Math.min(totalTargets, sa.getMaxTargets()) - 1) {
-                            sa.addDividedAllocation(choice, left);
-                        } else {
-                            sa.addDividedAllocation(choice, alloc);
-                            left -= alloc;
-                        }
+                }
+                if (choice != null && divided) {
+                    int alloc = Math.max(amount / totalTargets, 1);
+                    if (sa.getTargets().size() == Math.min(totalTargets, sa.getMaxTargets()) - 1) {
+                        sa.addDividedAllocation(choice, left);
+                    } else {
+                        sa.addDividedAllocation(choice, alloc);
+                        left -= alloc;
                     }
                 }
-
                 if (choice != null) {
                     sa.getTargets().add(choice);
                     list.remove(choice);

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

@@ -195,7 +195,6 @@ public class CountersPutOrRemoveAi extends SpellAbilityAi {
      */
     @Override
     public CounterType chooseCounterType(List<CounterType> options, SpellAbility sa, Map<String, Object> params) {
-
         if (options.size() > 1) {
             final Player ai = sa.getActivatingPlayer();
             final Game game = ai.getGame();

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

@@ -81,7 +81,6 @@ public class CountersRemoveAi extends SpellAbilityAi {
      */
     @Override
     protected boolean checkApiLogic(Player ai, SpellAbility sa) {
-
         final String type = sa.getParam("CounterType");
 
         if (sa.usesTargeting()) {

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

@@ -14,7 +14,7 @@ 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.trigger.TriggerType;
 import forge.game.zone.ZoneType;
 import forge.util.MyRandom;
 
@@ -56,7 +56,7 @@ public abstract class DamageAiBase extends SpellAbilityAi {
         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")) {
+                sa.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
@@ -75,7 +75,7 @@ public abstract class DamageAiBase extends SpellAbilityAi {
         // 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 (trig.getMode() == TriggerType.DamageDone) {
                 if (("Opponent".equals(trig.getParam("ValidTarget")))
                         && (!"True".equals(trig.getParam("CombatDamage")))) {
                     return true;
@@ -111,8 +111,7 @@ public abstract class DamageAiBase extends SpellAbilityAi {
         final CardCollectionView hand = comp.getCardsIn(ZoneType.Hand);
 
         if ((enemy.getLife() - restDamage) < 5) {
-            // drop the human to less than 5
-            // life
+            // drop the human to less than 5 life
             return true;
         }
 
@@ -147,12 +146,12 @@ public abstract class DamageAiBase extends SpellAbilityAi {
                         }
                     }
                 }
-                if (value > 0) {    //more likely to burn with larger hand
+                if (value > 0) { //more likely to burn with larger hand
                     for (int i = 3; i < hand.size(); i++) {
                         value *= 1.1f;
                     }
                 }
-                if (value < 0.2f) {   //hard floor to reduce ridiculous odds for instants over time
+                if (value < 0.2f) { //hard floor to reduce ridiculous odds for instants over time
                     return false;
                 } else {
                     final float chance = MyRandom.getRandom().nextFloat();

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

@@ -46,7 +46,7 @@ public class  DamageAllAi extends SpellAbilityAi {
 
         int x = -1;
         final String damage = sa.getParam("NumDmg");
-        int dmg = AbilityUtils.calculateAmount(sa.getHostCard(), damage, sa);
+        int dmg = AbilityUtils.calculateAmount(source, damage, sa);
         if (damage.equals("X") && sa.getSVar(damage).equals("Count$Converge")) {
         	dmg = ComputerUtilMana.getConvergeCount(sa, ai);
         }
@@ -202,7 +202,7 @@ public class  DamageAllAi extends SpellAbilityAi {
             dmg = ComputerUtilCost.getMaxXValue(sa, ai);
             sa.setXManaCostPaid(dmg);
         } else {
-            dmg = AbilityUtils.calculateAmount(sa.getHostCard(), damage, sa);
+            dmg = AbilityUtils.calculateAmount(source, damage, sa);
         }
 
         if (sa.hasParam("ValidPlayers")) {
@@ -286,7 +286,7 @@ public class  DamageAllAi extends SpellAbilityAi {
             dmg = ComputerUtilCost.getMaxXValue(sa, ai);
             sa.setXManaCostPaid(dmg);
         } else {
-            dmg = AbilityUtils.calculateAmount(sa.getHostCard(), damage, sa);
+            dmg = AbilityUtils.calculateAmount(source, damage, sa);
         }
 
         if (sa.hasParam("ValidPlayers")) {

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

@@ -30,22 +30,21 @@ 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.CounterEnumType;
 import forge.game.cost.Cost;
 import forge.game.cost.CostPartMana;
-import forge.game.cost.CostRemoveCounter;
 import forge.game.keyword.Keyword;
 import forge.game.phase.PhaseHandler;
 import forge.game.phase.PhaseType;
 import forge.game.player.Player;
-import forge.game.player.PlayerPredicates;
+import forge.game.player.PlayerCollection;
 import forge.game.spellability.AbilitySub;
 import forge.game.spellability.SpellAbility;
 import forge.game.spellability.TargetChoices;
 import forge.game.spellability.TargetRestrictions;
+import forge.game.staticability.StaticAbilityMustTarget;
 import forge.game.zone.ZoneType;
 import forge.util.Aggregates;
 import forge.util.MyRandom;
@@ -54,10 +53,9 @@ public class DamageDealAi extends DamageAiBase {
     @Override
     public boolean chkAIDrawback(SpellAbility sa, Player ai) {
         final String damage = sa.getParam("NumDmg");
-        int dmg = AbilityUtils.calculateAmount(sa.getHostCard(), damage, sa);
-        final String logic = sa.getParam("AILogic");
-
         Card source = sa.getHostCard();
+        int dmg = AbilityUtils.calculateAmount(source, damage, sa);
+        final String logic = sa.getParam("AILogic");
 
         if ("MadSarkhanDigDmg".equals(logic)) {
             return SpecialCardAi.SarkhanTheMad.considerDig(ai, sa);
@@ -102,13 +100,12 @@ public class DamageDealAi extends DamageAiBase {
 
     @Override
     protected boolean canPlayAI(Player ai, SpellAbility sa) {
-
         final Cost abCost = sa.getPayCosts();
         final Card source = sa.getHostCard();
         final String sourceName = ComputerUtilAbility.getAbilitySourceName(sa);
 
         final String damage = sa.getParam("NumDmg");
-        int dmg = AbilityUtils.calculateAmount(sa.getHostCard(), damage, sa);
+        int dmg = AbilityUtils.calculateAmount(source, damage, sa);
 
         if (damage.equals("X")) {
             if (sa.getSVar(damage).equals("Count$xPaid") || sourceName.equals("Crater's Claws")) {
@@ -131,7 +128,7 @@ public class DamageDealAi extends DamageAiBase {
                 // Set PayX here to maximum value. It will be adjusted later depending on the target.
                 sa.setXManaCostPaid(dmg);
             } else if (sa.getSVar(damage).contains("InYourHand") && source.isInZone(ZoneType.Hand)) {
-                dmg = CardFactoryUtil.xCount(source, sa.getSVar(damage)) - 1; // the card will be spent casting the spell, so actual damage is 1 less
+                dmg = AbilityUtils.calculateAmount(source, damage, sa) - 1; // 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()) {
@@ -343,6 +340,9 @@ public class DamageDealAi extends DamageAiBase {
         final Game game = source.getGame();
         List<Card> hPlay = getTargetableCards(ai, sa, pl, tgt, activator, source, game);
 
+        // Filter MustTarget requirements
+        StaticAbilityMustTarget.filterMustTargetCards(ai, hPlay, sa);
+
         CardCollection killables = CardLists.filter(hPlay, new Predicate<Card>() {
             @Override
             public boolean apply(final Card c) {
@@ -437,63 +437,12 @@ public class DamageDealAi extends DamageAiBase {
 
         // 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 ComputerUtilCard.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(CounterEnumType.LOYALTY);
-            int pwScore = curLoyalty * 10;
-
-            for (SpellAbility sa : pw.getSpellAbilities()) {
-                if (sa.hasParam("Ultimate")) {
-                    Integer 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 != null && loyaltyCost != 0 && loyaltyCost - curLoyalty <= 1) {
-                        // Will ultimate soon
-                        pwScore += 10000;
-                    }
-
-                    if (pwScore > bestScore) {
-                        bestScore = pwScore;
-                        bestTgt = pw;
-                    }
-                }
-            }
-        }
-
-        return bestTgt;
-    }
-
-    private Card getWorstPlaneswalkerToDamage(final List<Card> pws) {
-        Card bestTgt = null;
-
-        int bestScore = Integer.MAX_VALUE;
-        for (Card pw : pws) {
-            int curLoyalty = pw.getCounters(CounterEnumType.LOYALTY);
-
-            if (curLoyalty < bestScore) {
-                bestScore = curLoyalty;
-                bestTgt = pw;
-            }
-        }
-
-        return bestTgt;
-    }
-
-
     private List<Card> getTargetableCards(Player ai, SpellAbility sa, Player pl, TargetRestrictions tgt, Player activator, Card source, Game game) {
         List<Card> hPlay = CardLists.getValidCards(game.getCardsIn(ZoneType.Battlefield), tgt.getValidTgts(), activator, source, sa);
 
@@ -582,7 +531,7 @@ public class DamageDealAi extends DamageAiBase {
                 && "P1P1".equals(sa.getParent().getParam("CounterType"))) {
             // assuming the SA parent is of PutCounter type. Perhaps it's possible to predict counter multipliers here somehow?
             final String amountStr = sa.getParent().getParamOrDefault("CounterNum", "1");
-            final int amount = AbilityUtils.calculateAmount(sa.getHostCard(), amountStr, sa);
+            final int amount = AbilityUtils.calculateAmount(source, amountStr, sa);
             dmg += amount;
         }
 
@@ -730,12 +679,10 @@ public class DamageDealAi extends DamageAiBase {
                 }
 
                 // When giving priority to targeting Creatures for mandatory
-                // triggers
-                // feel free to add the Human after we run out of good targets
+                // triggers feel free to add the Human after we run out of good targets
 
                 // TODO: add check here if card is about to die from something
-                // on the stack
-                // or from taking combat damage
+                // on the stack or from taking combat damage
 
                 final Cost abCost = sa.getPayCosts();
                 boolean freePing = immediately || abCost == null
@@ -792,8 +739,7 @@ public class DamageDealAi extends DamageAiBase {
                     }
                 }
             }
-            // TODO: Improve Damage, we shouldn't just target the player just
-            // because we can
+            // TODO: Improve Damage, we shouldn't just target the player just because we can
             if (sa.canTarget(enemy) && tcs.size() < tgt.getMaxTargets(source, sa)) {
                 if (((phase.is(PhaseType.END_OF_TURN) && phase.getNextTurn().equals(ai))
                         || (SpellAbilityAi.isSorcerySpeed(sa) && phase.is(PhaseType.MAIN2))
@@ -898,7 +844,7 @@ public class DamageDealAi extends DamageAiBase {
         // this is for Triggered targets that are mandatory
         final boolean noPrevention = sa.hasParam("NoPrevention");
         final boolean divided = sa.isDividedAsYouChoose();
-        final Player opp = ai.getWeakestOpponent();
+        PlayerCollection opps = ai.getOpponents();
 
         while (sa.canAddMoreTarget()) {
             if (tgt.canTgtPlaneswalker()) {
@@ -926,13 +872,17 @@ public class DamageDealAi extends DamageAiBase {
                 }
             }
 
-            if (sa.canTarget(opp)) {
-                if (sa.getTargets().add(opp)) {
-                    if (divided) {
-                        sa.addDividedAllocation(opp, dmg);
-                        break;
+            if (!opps.isEmpty()) {
+                Player opp = opps.getFirst();
+                opps.remove(opp);
+                if (sa.canTarget(opp)) {
+                    if (sa.getTargets().add(opp)) {
+                        if (divided) {
+                            sa.addDividedAllocation(opp, dmg);
+                            break;
+                        }
+                        continue;
                     }
-                    continue;
                 }
             }
 
@@ -951,7 +901,7 @@ public class DamageDealAi extends DamageAiBase {
             }
             else if (tgt.canTgtPlaneswalker()) {
                 // Second pass for planeswalkers: choose AI's worst planeswalker
-                final Card c = getWorstPlaneswalkerToDamage(CardLists.filter(ai.getCardsIn(ZoneType.Battlefield), Predicates.and(CardPredicates.Presets.PLANESWALKERS), CardPredicates.isTargetableBy(sa)));
+                final Card c = ComputerUtilCard.getWorstPlaneswalkerToDamage(CardLists.filter(ai.getCardsIn(ZoneType.Battlefield), Predicates.and(CardPredicates.Presets.PLANESWALKERS), CardPredicates.isTargetableBy(sa)));
                 if (c != null) {
                     sa.getTargets().add(c);
                     if (divided) {
@@ -981,7 +931,6 @@ public class DamageDealAi extends DamageAiBase {
 
     @Override
     protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
-
         final Card source = sa.getHostCard();
         final String damage = sa.getParam("NumDmg");
         int dmg = AbilityUtils.calculateAmount(source, damage, sa);
@@ -1038,7 +987,7 @@ public class DamageDealAi extends DamageAiBase {
             saTgt = saTgt.getParent();
         }
 
-        Player opponent = ai.getOpponents().min(PlayerPredicates.compareByLife());
+        Player opponent = ai.getWeakestOpponent();
 
         // TODO: somehow account for the possible cost reduction?
         int dmg = ComputerUtilMana.determineLeftoverMana(sa, ai, saTgt.getParam("XColor"));
@@ -1081,7 +1030,7 @@ public class DamageDealAi extends DamageAiBase {
         saTgt.resetTargets();
         saTgt.getTargets().add(tgtCreature != null && dmg < opponent.getLife() ? tgtCreature : opponent);
 
-        sa.setXManaCostPaid(dmg);
+        saTgt.setXManaCostPaid(dmg);
         return true;
     }
 

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

@@ -8,6 +8,7 @@ import com.google.common.base.Predicate;
 import com.google.common.collect.Iterables;
 import com.google.common.collect.Lists;
 
+import forge.ai.AiAttackController;
 import forge.ai.ComputerUtilCard;
 import forge.ai.ComputerUtilCost;
 import forge.ai.SpellAbilityAi;
@@ -26,9 +27,6 @@ import forge.game.spellability.TargetRestrictions;
 import forge.game.zone.ZoneType;
 
 public class DebuffAi extends SpellAbilityAi {
-    // *************************************************************************
-    // ***************************** Debuff ************************************
-    // *************************************************************************
 
     @Override
     protected boolean canPlayAI(final Player ai, final SpellAbility sa) {
@@ -140,7 +138,6 @@ public class DebuffAi extends SpellAbilityAi {
 
         while (sa.getTargets().size() < tgt.getMaxTargets(sa.getHostCard(), sa)) {
             Card t = null;
-            // boolean goodt = false;
 
             if (list.isEmpty()) {
                 if ((sa.getTargets().size() < tgt.getMinTargets(sa.getHostCard(), sa)) || (sa.getTargets().size() == 0)) {
@@ -176,19 +173,18 @@ public class DebuffAi extends SpellAbilityAi {
      * @return a CardCollection.
      */
     private CardCollection getCurseCreatures(final Player ai, final SpellAbility sa, final List<String> kws) {
-        final Player opp = ai.getWeakestOpponent();
+        final Player opp = AiAttackController.choosePreferredDefenderPlayer(ai);
         CardCollection list = CardLists.getTargetableCards(opp.getCreaturesInPlay(), sa);
         if (!list.isEmpty()) {
             list = CardLists.filter(list, new Predicate<Card>() {
                 @Override
                 public boolean apply(final Card c) {
-                    return c.hasAnyKeyword(kws); // don't add duplicate negative
-                                                 // keywords
+                    return c.hasAnyKeyword(kws); // don't add duplicate negative keywords
                 }
             });
         }
         return list;
-    } // getCurseCreatures()
+    }
 
     /**
      * <p>
@@ -216,7 +212,7 @@ public class DebuffAi extends SpellAbilityAi {
             list.remove(c);
         }
 
-        final CardCollection pref = CardLists.filterControlledBy(list, ai.getWeakestOpponent());
+        final CardCollection pref = CardLists.filterControlledBy(list, ai.getOpponents());
         final CardCollection forced = CardLists.filterControlledBy(list, ai);
         final Card source = sa.getHostCard();
 
@@ -242,8 +238,7 @@ public class DebuffAi extends SpellAbilityAi {
                 break;
             }
 
-            // TODO - if forced targeting, just pick something without the given
-            // keyword
+            // TODO - if forced targeting, just pick something without the given keyword
             Card c;
             if (CardLists.getNotType(forced, "Creature").size() == 0) {
                 c = ComputerUtilCard.getWorstCreatureAI(forced);

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

@@ -2,15 +2,7 @@ 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.PlayerControllerAi;
-import forge.ai.SpecialAiLogic;
-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;
@@ -26,12 +18,13 @@ import forge.game.phase.PhaseHandler;
 import forge.game.phase.PhaseType;
 import forge.game.player.Player;
 import forge.game.spellability.SpellAbility;
+import forge.game.staticability.StaticAbilityMustTarget;
 import forge.game.zone.ZoneType;
 
 public class DestroyAi extends SpellAbilityAi {
     @Override
     public boolean chkAIDrawback(SpellAbility sa, Player ai) {
-        return canPlayAI(ai, sa);
+        return checkApiLogic(ai, sa);
     }
 
     @Override
@@ -122,17 +115,21 @@ public class DestroyAi extends SpellAbilityAi {
 
         CardCollection list;
 
-
-
         if (ComputerUtil.preventRunAwayActivations(sa)) {
             return false;
         }
 
-
         // Targeting
         if (sa.usesTargeting()) {
+            // If there's X in payment costs and it's tied to targeting, make sure we set the XManaCostPaid first
+            // (e.g. Heliod's Intervention)
+            if ("X".equals(sa.getTargetRestrictions().getMinTargets()) && sa.getSVar("X").equals("Count$xPaid")) {
+                int xPay = ComputerUtilCost.getMaxXValue(sa, ai);
+                sa.getRootAbility().setXManaCostPaid(xPay);
+            }
+
             // Assume there where already enough targets chosen by AI Logic Above
-            if (!sa.canAddMoreTarget() && sa.isTargetNumberValid()) {
+            if (sa.hasParam("AILogic") && !sa.canAddMoreTarget() && sa.isTargetNumberValid()) {
                 return true;
             }
 
@@ -140,11 +137,11 @@ public class DestroyAi extends SpellAbilityAi {
             sa.resetTargets();
             int maxTargets;
 
-            if (sa.costHasManaX()) {
+            if (sa.getRootAbility().costHasManaX()) {
                 // TODO: currently the AI will maximize mana spent on X, trying to maximize damage. This may need improvement.
                 maxTargets = ComputerUtilCost.getMaxXValue(sa, ai);
                 // need to set XPaid to get the right number for
-                sa.setXManaCostPaid(maxTargets);
+                sa.getRootAbility().setXManaCostPaid(maxTargets);
                 // need to check for maxTargets
                 maxTargets = Math.min(maxTargets, sa.getMaxTargets());
             } else {
@@ -226,6 +223,10 @@ public class DestroyAi extends SpellAbilityAi {
             // target loop
             // TODO use can add more Targets
             while (sa.getTargets().size() < maxTargets) {
+                // filter by MustTarget requirement
+                CardCollection originalList = new CardCollection(list);
+                boolean mustTargetFiltered = StaticAbilityMustTarget.filterMustTargetCards(ai, list, sa);
+
                 if (list.isEmpty()) {
                     if (!sa.isMinTargetChosen() || sa.isZeroTargets()) {
                         sa.resetTargets();
@@ -286,6 +287,12 @@ public class DestroyAi extends SpellAbilityAi {
                         }
                     }
                 }
+
+                // Restore original list for next loop if filtered by MustTarget requirement
+                if (mustTargetFiltered) {
+                    list = originalList;
+                }
+
                 list.remove(choice);
                 sa.getTargets().add(choice);
             }

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

@@ -70,12 +70,12 @@ public class DestroyAllAi extends SpellAbilityAi {
         return doMassRemovalLogic(ai, sa);
     }
 
-    public boolean doMassRemovalLogic(Player ai, SpellAbility sa) {
+    public static boolean doMassRemovalLogic(Player ai, SpellAbility sa) {
         final Card source = sa.getHostCard();
         final String logic = sa.getParamOrDefault("AILogic", "");
-        Player opponent = ai.getWeakestOpponent(); // TODO: how should this AI logic work for multiplayer and getOpponents()?
 
-        final int CREATURE_EVAL_THRESHOLD = 200;
+        // if we hit the whole board, the other opponents who are not the reason to cast this probably still suffer a bit too
+        final int CREATURE_EVAL_THRESHOLD = 200 / (!sa.usesTargeting() ? ai.getOpponents().size() : 1);
 
         if (logic.equals("Always")) {
             return true; // e.g. Tetzimoc, Primal Death, where we want to cast the permanent even if the removal trigger does nothing
@@ -93,99 +93,101 @@ public class DestroyAllAi extends SpellAbilityAi {
             valid = valid.replace("X", Integer.toString(xPay));
         }
 
-        CardCollection opplist = CardLists.getValidCards(opponent.getCardsIn(ZoneType.Battlefield),
-                valid.split(","), source.getController(), source, sa);
-        CardCollection ailist = CardLists.getValidCards(ai.getCardsIn(ZoneType.Battlefield), valid.split(","),
-                source.getController(), source, sa);
+        // TODO should probably sort results when targeted to use on biggest threat instead of first match
+        for (Player opponent: ai.getOpponents()) {
+            CardCollection opplist = CardLists.getValidCards(opponent.getCardsIn(ZoneType.Battlefield), valid.split(","), source.getController(), source, sa);
+            CardCollection ailist = CardLists.getValidCards(ai.getCardsIn(ZoneType.Battlefield), valid.split(","), source.getController(), source, sa);
 
-        opplist = CardLists.filter(opplist, predicate);
-        ailist = CardLists.filter(ailist, predicate);
-        if (opplist.isEmpty()) {
-            return false;
-        }
-
-        if (sa.usesTargeting()) {
-            sa.resetTargets();
-            if (sa.canTarget(opponent)) {
-                sa.getTargets().add(opponent);
-                ailist.clear();
-            } else {
+            opplist = CardLists.filter(opplist, predicate);
+            ailist = CardLists.filter(ailist, predicate);
+            if (opplist.isEmpty()) {
                 return false;
             }
-        }
 
-        // Special handling for Raiding Party
-        if (logic.equals("RaidingParty")) {
-            int numAiCanSave = Math.min(CardLists.filter(ai.getCreaturesInPlay(), Predicates.and(CardPredicates.isColor(MagicColor.WHITE), CardPredicates.Presets.UNTAPPED)).size() * 2, ailist.size());
-            int numOppsCanSave = Math.min(CardLists.filter(ai.getOpponents().getCreaturesInPlay(), Predicates.and(CardPredicates.isColor(MagicColor.WHITE), CardPredicates.Presets.UNTAPPED)).size() * 2, opplist.size());
-
-            return numOppsCanSave < opplist.size() && (ailist.size() - numAiCanSave < opplist.size() - numOppsCanSave);
-        }
-
-        // 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()) {
-            if (ComputerUtilCard.evaluateCreatureList(ailist) + CREATURE_EVAL_THRESHOLD < ComputerUtilCard.evaluateCreatureList(opplist)) {
-                return true;
-            }
-            
-            if (ai.getGame().getPhaseHandler().getPhase().isBefore(PhaseType.MAIN2)) {
-            	return false;
-            }
-            
-            // 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 = containsAttacker | opplist.contains(att);
-            	}
-            }
-            if (!containsAttacker) {
-            	return false;
-            }
-            AiBlockController block = new AiBlockController(ai);
-            block.assignBlockersForCombat(combat);
-
-            if (ComputerUtilCombat.lifeInSeriousDanger(ai, combat)) {
-                return true;
-            }
-            return false;
-        } // only lands involved
-        else if (CardLists.getNotType(opplist, "Land").isEmpty() && CardLists.getNotType(ailist, "Land").isEmpty()) {
-        	if (ai.isCardInPlay("Crucible of Worlds") && !opponent.isCardInPlay("Crucible of Worlds") && !opplist.isEmpty()) {
-        		return true;
-        	}
-            // evaluate the situation with creatures on the battlefield separately, as that's where the AI typically makes mistakes
-            CardCollection aiCreatures = ai.getCreaturesInPlay();
-            CardCollection oppCreatures = opponent.getCreaturesInPlay();
-            if (!oppCreatures.isEmpty()) {
-                if (ComputerUtilCard.evaluateCreatureList(aiCreatures) < ComputerUtilCard.evaluateCreatureList(oppCreatures) + CREATURE_EVAL_THRESHOLD) {
+            if (sa.usesTargeting()) {
+                sa.resetTargets();
+                if (sa.canTarget(opponent)) {
+                    sa.getTargets().add(opponent);
+                    ailist.clear();
+                } else {
                     return false;
                 }
             }
-            // check if the AI would lose more lands than the opponent would
-            if (ComputerUtilCard.evaluatePermanentList(ailist) > ComputerUtilCard.evaluatePermanentList(opplist) + 1) {
+
+            // Special handling for Raiding Party
+            if (logic.equals("RaidingParty")) {
+                int numAiCanSave = Math.min(CardLists.filter(ai.getCreaturesInPlay(), Predicates.and(CardPredicates.isColor(MagicColor.WHITE), CardPredicates.Presets.UNTAPPED)).size() * 2, ailist.size());
+                int numOppsCanSave = Math.min(CardLists.filter(ai.getOpponents().getCreaturesInPlay(), Predicates.and(CardPredicates.isColor(MagicColor.WHITE), CardPredicates.Presets.UNTAPPED)).size() * 2, opplist.size());
+
+                return numOppsCanSave < opplist.size() && (ailist.size() - numAiCanSave < opplist.size() - numOppsCanSave);
+            }
+
+            // 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()) {
+                if (ComputerUtilCard.evaluateCreatureList(ailist) + CREATURE_EVAL_THRESHOLD < ComputerUtilCard.evaluateCreatureList(opplist)) {
+                    return true;
+                }
+
+                if (ai.getGame().getPhaseHandler().getPhase().isBefore(PhaseType.MAIN2)) {
+                    return false;
+                }
+
+                // 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 = containsAttacker | opplist.contains(att);
+                    }
+                }
+                if (!containsAttacker) {
+                    return false;
+                }
+                AiBlockController block = new AiBlockController(ai);
+                block.assignBlockersForCombat(combat);
+
+                if (ComputerUtilCombat.lifeInSeriousDanger(ai, combat)) {
+                    return true;
+                }
+                return false;
+            } // only lands involved
+            else if (CardLists.getNotType(opplist, "Land").isEmpty() && CardLists.getNotType(ailist, "Land").isEmpty()) {
+                if (ai.isCardInPlay("Crucible of Worlds") && !opponent.isCardInPlay("Crucible of Worlds")) {
+                    return true;
+                }
+                // evaluate the situation with creatures on the battlefield separately, as that's where the AI typically makes mistakes
+                CardCollection aiCreatures = ai.getCreaturesInPlay();
+                CardCollection oppCreatures = opponent.getCreaturesInPlay();
+                if (!oppCreatures.isEmpty()) {
+                    if (ComputerUtilCard.evaluateCreatureList(aiCreatures) < ComputerUtilCard.evaluateCreatureList(oppCreatures) + CREATURE_EVAL_THRESHOLD) {
+                        return false;
+                    }
+                }
+                // check if the AI would lose more lands than the opponent would
+                if (ComputerUtilCard.evaluatePermanentList(ailist) > ComputerUtilCard.evaluatePermanentList(opplist) + 1) {
+                    return false;
+                }
+            } // otherwise evaluate both lists by CMC and pass only if human permanents are more valuable
+            else if ((ComputerUtilCard.evaluatePermanentList(ailist) + 3) >= ComputerUtilCard.evaluatePermanentList(opplist)) {
                 return false;
             }
-        } // otherwise evaluate both lists by CMC and pass only if human permanents are more valuable
-        else if ((ComputerUtilCard.evaluatePermanentList(ailist) + 3) >= ComputerUtilCard.evaluatePermanentList(opplist)) {
-            return false;
+            return true;
         }
-        return true;
+        return false;
     }
+    
 }

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

@@ -5,6 +5,7 @@ import java.util.Map;
 import com.google.common.base.Predicate;
 import com.google.common.collect.Iterables;
 
+import forge.ai.AiAttackController;
 import forge.ai.ComputerUtil;
 import forge.ai.ComputerUtilAbility;
 import forge.ai.ComputerUtilCard;
@@ -32,7 +33,7 @@ public class DigAi extends SpellAbilityAi {
     @Override
     protected boolean canPlayAI(Player ai, SpellAbility sa) {
         final Game game = ai.getGame();
-        Player opp = ai.getWeakestOpponent();
+        Player opp = AiAttackController.choosePreferredDefenderPlayer(ai);
         final Card host = sa.getHostCard();
         Player libraryOwner = ai;
 
@@ -44,9 +45,8 @@ public class DigAi extends SpellAbilityAi {
             sa.resetTargets();
             if (!opp.canBeTargetedBy(sa)) {
                 return false;
-            } else {
-                sa.getTargets().add(opp);
             }
+            sa.getTargets().add(opp);
             libraryOwner = opp;
         }
 
@@ -120,7 +120,7 @@ public class DigAi extends SpellAbilityAi {
     @Override
     protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
         final SpellAbility root = sa.getRootAbility();
-        final Player opp = ai.getWeakestOpponent();
+        final Player opp = AiAttackController.choosePreferredDefenderPlayer(ai);
         if (sa.usesTargeting()) {
             sa.resetTargets();
             if (mandatory && sa.canTarget(opp)) {

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

@@ -1,5 +1,6 @@
 package forge.ai.ability;
 
+import forge.ai.AiAttackController;
 import forge.ai.ComputerUtil;
 import forge.ai.SpellAbilityAi;
 import forge.game.Game;
@@ -19,7 +20,7 @@ public class DigMultipleAi extends SpellAbilityAi {
     @Override
     protected boolean canPlayAI(Player ai, SpellAbility sa) {
         final Game game = ai.getGame();
-        Player opp = ai.getWeakestOpponent();
+        Player opp = AiAttackController.choosePreferredDefenderPlayer(ai);
         final Card host = sa.getHostCard();
         Player libraryOwner = ai;
 
@@ -27,9 +28,8 @@ public class DigMultipleAi extends SpellAbilityAi {
             sa.resetTargets();
             if (!opp.canBeTargetedBy(sa)) {
                 return false;
-            } else {
-                sa.getTargets().add(opp);
             }
+            sa.getTargets().add(opp);
             libraryOwner = opp;
         }
 
@@ -77,7 +77,7 @@ public class DigMultipleAi extends SpellAbilityAi {
 
     @Override
     protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
-        final Player opp = ai.getWeakestOpponent();
+        final Player opp = AiAttackController.choosePreferredDefenderPlayer(ai);
         if (sa.usesTargeting()) {
             sa.resetTargets();
             if (mandatory && sa.canTarget(opp)) {

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

@@ -2,6 +2,7 @@ package forge.ai.ability;
 
 import java.util.List;
 
+import forge.ai.AiAttackController;
 import forge.ai.ComputerUtilCost;
 import forge.ai.SpellAbilityAi;
 import forge.game.card.Card;
@@ -31,10 +32,8 @@ public class DigUntilAi extends SpellAbilityAi {
             chance = 1;
         }
 
-        final boolean randomReturn = MyRandom.getRandom().nextFloat() <= Math.pow(chance, sa.getActivationsThisTurn() + 1);
-
         Player libraryOwner = ai;
-        Player opp = ai.getWeakestOpponent();
+        Player opp = AiAttackController.choosePreferredDefenderPlayer(ai);
 
         if ("DontMillSelf".equals(logic)) {
             // A card that digs for specific things and puts everything revealed before it into graveyard
@@ -61,9 +60,8 @@ public class DigUntilAi extends SpellAbilityAi {
             sa.resetTargets();
             if (!sa.canTarget(opp)) {
                 return false;
-            } else {
-                sa.getTargets().add(opp);
             }
+            sa.getTargets().add(opp);
             libraryOwner = opp;
         } else {
             if (sa.hasParam("Valid")) {
@@ -92,12 +90,12 @@ public class DigUntilAi extends SpellAbilityAi {
             return false;
         }
 
+        final boolean randomReturn = MyRandom.getRandom().nextFloat() <= Math.pow(chance, sa.getActivationsThisTurn() + 1);
         return randomReturn;
     }
 
     @Override
     protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
-
         if (sa.usesTargeting()) {
             sa.resetTargets();
             if (sa.isCurse()) {

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

@@ -2,6 +2,7 @@ package forge.ai.ability;
 
 import java.util.List;
 
+import forge.ai.AiAttackController;
 import forge.ai.ComputerUtil;
 import forge.ai.ComputerUtilAbility;
 import forge.ai.ComputerUtilCost;
@@ -60,11 +61,9 @@ public class DiscardAi extends SpellAbilityAi {
                 if (players.get(0) == ai) {
                     // the ai should only be using something like this if he has
                     // few cards in hand,
-                    // cards like this better have a good drawback to be in the
-                    // AIs deck
+                    // cards like this better have a good drawback to be in the AIs deck
                 } else {
-                    // defined to the human, so that's fine as long the human
-                    // has cards
+                    // defined to the human, so that's fine as long the human has cards
                     if (!humanHasHand) {
                         return false;
                     }
@@ -170,7 +169,7 @@ public class DiscardAi extends SpellAbilityAi {
     protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
         final TargetRestrictions tgt = sa.getTargetRestrictions();
         if (tgt != null) {
-            Player opp = ai.getWeakestOpponent();
+            Player opp = AiAttackController.choosePreferredDefenderPlayer(ai);
             if (!discardTargetAI(ai, sa)) {
                 if (mandatory && sa.canTarget(opp)) {
                     sa.getTargets().add(opp);

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

@@ -23,8 +23,7 @@ public class DrainManaAi extends SpellAbilityAi {
 
         if (tgt == null) {
             // assume we are looking to tap human's stuff
-            // TODO - check for things with untap abilities, and don't tap
-            // those.
+            // TODO - check for things with untap abilities, and don't tap those.
             final List<Player> defined = AbilityUtils.getDefinedPlayers(source, sa.getParam("Defined"), sa);
 
             if (!defined.contains(opp)) {

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

@@ -244,7 +244,7 @@ public class DrawAi extends SpellAbilityAi {
 
         int numCards = 1;
         if (sa.hasParam("NumCards")) {
-            numCards = AbilityUtils.calculateAmount(sa.getHostCard(), sa.getParam("NumCards"), sa);
+            numCards = AbilityUtils.calculateAmount(source, sa.getParam("NumCards"), sa);
         }
 
         boolean xPaid = false;
@@ -257,7 +257,7 @@ public class DrawAi extends SpellAbilityAi {
                 } else {
                     numCards = ComputerUtilCost.getMaxXValue(sa, ai);
                     // try not to overdraw
-                    int safeDraw = Math.min(computerMaxHandSize - computerHandSize, computerLibrarySize - 3);
+                    int safeDraw = Math.abs(Math.min(computerMaxHandSize - computerHandSize, computerLibrarySize - 3));
                     if (sa.getHostCard().isInstant() || sa.getHostCard().isSorcery()) { safeDraw++; } // card will be spent
                     numCards = Math.min(numCards, safeDraw);
 
@@ -377,7 +377,7 @@ public class DrawAi extends SpellAbilityAi {
             // checks what the ai prevent from casting it on itself
             // if spell is not mandatory
             if (aiTarget && !ai.cantLose()) {
-                if (numCards >= computerLibrarySize) {
+                if (numCards >= computerLibrarySize - 3) {
                     if (xPaid) {
                         numCards = computerLibrarySize - 1;
                         if (numCards <= 0 && !mandatory) {
@@ -422,8 +422,7 @@ public class DrawAi extends SpellAbilityAi {
                         }
                         root.setXManaCostPaid(numCards);
                     } else {
-                        // Don't draw too many cards and then risk discarding
-                        // cards at EOT
+                        // Don't draw too many cards and then risk discarding cards at EOT
                         if (!drawback && !mandatory) {
                             return false;
                         }
@@ -441,7 +440,7 @@ public class DrawAi extends SpellAbilityAi {
                     continue;
                 }
 
-                // use xPaid abilties only for itself
+                // use xPaid abilities only for itself
                 if (xPaid) {
                     continue;
                 }
@@ -493,7 +492,7 @@ public class DrawAi extends SpellAbilityAi {
             // TODO: consider if human is the defined player
 
             // ability is not targeted
-            if (numCards >= computerLibrarySize) {
+            if (numCards >= computerLibrarySize - 3) {
                 if (ai.isCardInPlay("Laboratory Maniac")) {
                     return true;
                 }
@@ -509,8 +508,7 @@ public class DrawAi extends SpellAbilityAi {
                     && game.getPhaseHandler().isPlayerTurn(ai)
                     && !sa.isTrigger()
                     && !assumeSafeX) {
-                // Don't draw too many cards and then risk discarding cards at
-                // EOT
+                // Don't draw too many cards and then risk discarding cards at EOT
                 if (!drawback) {
                     return false;
                 }

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

@@ -79,7 +79,7 @@ public class EffectAi extends SpellAbilityAi {
                 if (!game.getStack().isEmpty()) {
                     return false;
                 }
-                if (game.getPhaseHandler().isPreventCombatDamageThisTurn()) {
+                if (game.getReplacementHandler().isPreventCombatDamageThisTurn()) {
                     return false;
                 }
                 if (!ComputerUtilCombat.lifeInDanger(ai, game.getCombat())) {

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

@@ -19,6 +19,7 @@ import forge.game.keyword.Keyword;
 import forge.game.player.Player;
 import forge.game.spellability.AbilitySub;
 import forge.game.spellability.SpellAbility;
+import forge.game.staticability.StaticAbilityMustTarget;
 import forge.game.trigger.Trigger;
 import forge.game.trigger.TriggerType;
 import forge.util.MyRandom;
@@ -50,6 +51,9 @@ public class FightAi extends SpellAbilityAi {
         aiCreatures = ComputerUtil.getSafeTargets(ai, sa, aiCreatures);
         List<Card> humCreatures = ai.getOpponents().getCreaturesInPlay();
         humCreatures = CardLists.getTargetableCards(humCreatures, sa);
+        // Filter MustTarget requirements
+        StaticAbilityMustTarget.filterMustTargetCards(ai, humCreatures, sa);
+
         if (humCreatures.isEmpty())
             return false; //prevent IndexOutOfBoundsException on MOJHOSTO variant
 
@@ -63,8 +67,7 @@ public class FightAi extends SpellAbilityAi {
             for (Card humanCreature : humCreatures) {
                 if (ComputerUtilCombat.getDamageToKill(humanCreature) <= fighter1.getNetPower()
                         && humanCreature.getNetPower() < ComputerUtilCombat.getDamageToKill(fighter1)) {
-                    // todo: check min/max targets; see if we picked the best
-                    // matchup
+                    // todo: check min/max targets; see if we picked the best matchup
                     sa.getTargets().add(humanCreature);
                     return true;
                 } else if (humanCreature.getSVar("Targeting").equals("Dies")) {
@@ -81,8 +84,7 @@ public class FightAi extends SpellAbilityAi {
                     for (Card aiCreature : aiCreatures) {
                         if (ComputerUtilCombat.getDamageToKill(humanCreature) <= aiCreature.getNetPower()
                                 && humanCreature.getNetPower() < ComputerUtilCombat.getDamageToKill(aiCreature)) {
-                            // todo: check min/max targets; see if we picked the
-                            // best matchup
+                            // todo: check min/max targets; see if we picked the best matchup
                             sa.getTargets().add(humanCreature);
                             sa.getTargets().add(aiCreature);
                             return true;

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

@@ -16,14 +16,32 @@ public class FlipACoinAi extends SpellAbilityAi {
     protected boolean canPlayAI(Player ai, SpellAbility sa) {
 
         if (sa.hasParam("AILogic")) {
-            String AILogic = sa.getParam("AILogic");
-            if (AILogic.equals("Never")) {
+            String ailogic = sa.getParam("AILogic");
+            if (ailogic.equals("Never")) {
                 return false;
-            } else if (AILogic.equals("PhaseOut")) {
+            } else if (ailogic.equals("PhaseOut")) {
                 if (!ComputerUtil.predictThreatenedObjects(sa.getActivatingPlayer(), sa).contains(sa.getHostCard())) {
                     return false;
                 }
-            } else if (AILogic.equals("KillOrcs")) {
+            } else if (ailogic.equals("Bangchuckers")) {
+                if (ai.getGame().getPhaseHandler().getPhase().isBefore(PhaseType.END_OF_TURN) ) {
+                    return false;
+                }
+                sa.resetTargets();
+                for (Player o : ai.getOpponents()) {
+                    if (sa.canTarget(o) && o.canLoseLife() && !o.cantLose()) {
+                        sa.getTargets().add(o);
+                        return true;
+                    }
+                }
+                for (Card c : ai.getOpponents().getCreaturesInPlay()) {
+                    if (sa.canTarget(c)) {
+                        sa.getTargets().add(c);
+                        return true;
+                    }
+                }
+                return false;
+            } else if (ailogic.equals("KillOrcs")) {
             	if (ai.getGame().getPhaseHandler().getPhase().isBefore(PhaseType.END_OF_TURN) ) {
                     return false;
             	}

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

@@ -29,7 +29,7 @@ public class FogAi extends SpellAbilityAi {
         final Card hostCard = sa.getHostCard();
 
         // Don't cast it, if the effect is already in place
-        if (game.getPhaseHandler().isPreventCombatDamageThisTurn()) {
+        if (game.getReplacementHandler().isPreventCombatDamageThisTurn()) {
             return false;
         }
 

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

@@ -13,8 +13,7 @@ public class GameLossAi extends SpellAbilityAi {
             return false;
         }
 
-        // Only one SA Lose the Game card right now, which is Door to
-        // Nothingness
+        // Only one SA Lose the Game card right now, which is Door to Nothingness
 
         final TargetRestrictions tgt = sa.getTargetRestrictions();
         if (tgt != null) {
@@ -29,20 +28,23 @@ public class GameLossAi extends SpellAbilityAi {
 
     @Override
     protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
+        Player loser = ai;
         
         // Phage the Untouchable
         // (Final Fortune would need to attach it's delayed trigger to a
         // specific turn, which can't be done yet)
-        Player opp = ai.getWeakestOpponent();
+        if (ai.getGame().getCombat() != null) {
+            loser = ai.getGame().getCombat().getDefenderPlayerByAttacker(sa.getHostCard());
+        }
 
-        if (!mandatory && opp.cantLose()) {
+        if (!mandatory && loser.cantLose()) {
             return false;
         }
 
         final TargetRestrictions tgt = sa.getTargetRestrictions();
         if (tgt != null) {
             sa.resetTargets();
-            sa.getTargets().add(opp);
+            sa.getTargets().add(loser);
         }
 
         return true;

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

@@ -0,0 +1,56 @@
+package forge.ai.ability;
+
+
+import forge.ai.ComputerUtilCard;
+import forge.ai.PlayerControllerAi;
+import forge.ai.SpellAbilityAi;
+import forge.game.card.Card;
+import forge.game.card.CardCollection;
+import forge.game.card.CardLists;
+import forge.game.card.CardPredicates;
+import forge.game.player.Player;
+import forge.game.player.PlayerActionConfirmMode;
+import forge.game.spellability.SpellAbility;
+import forge.game.zone.ZoneType;
+
+public class LearnAi extends SpellAbilityAi {
+    @Override
+    protected boolean canPlayAI(Player aiPlayer, SpellAbility sa) {
+        // For the time being, Learn is treated as universally positive due to being optional
+
+        return true;
+    }
+
+    @Override
+    protected boolean doTriggerAINoCost(Player aiPlayer, SpellAbility sa, boolean mandatory) {
+        return mandatory || canPlayAI(aiPlayer, sa);
+    }
+
+    @Override
+    public boolean chkAIDrawback(SpellAbility sa, Player aiPlayer) {
+        return canPlayAI(aiPlayer, sa);
+    }
+
+    @Override
+    public boolean confirmAction(Player player, SpellAbility sa, PlayerActionConfirmMode mode, String message) {
+        return true;
+    }
+
+    public static Card chooseCardToLearn(CardCollection options, Player ai, SpellAbility sa) {
+        CardCollection sideboard = CardLists.filter(options, CardPredicates.inZone(ZoneType.Sideboard));
+        CardCollection hand = CardLists.filter(options, CardPredicates.inZone(ZoneType.Hand));
+        hand.remove(sa.getHostCard()); // this card will be used in the process, don't consider it for discard
+
+        CardCollection lessons = CardLists.filter(sideboard, CardPredicates.isType("Lesson"));
+        CardCollection goodDiscards = ((PlayerControllerAi)ai.getController()).getAi().getCardsToDiscard(1, 1, hand, sa);
+
+        if (!lessons.isEmpty()) {
+            return ComputerUtilCard.getBestAI(lessons);
+        } else if (!goodDiscards.isEmpty()) {
+            return ComputerUtilCard.getWorstAI(goodDiscards);
+        }
+
+        // Don't choose anything if there's no good option
+        return null;
+    }
+}

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

@@ -1,5 +1,6 @@
 package forge.ai.ability;
 
+import forge.ai.AiAttackController;
 import forge.ai.SpellAbilityAi;
 import forge.game.player.Player;
 import forge.game.spellability.SpellAbility;
@@ -19,7 +20,7 @@ public class LifeExchangeAi extends SpellAbilityAi {
     @Override
     protected boolean canPlayAI(Player aiPlayer, SpellAbility sa) {
         final int myLife = aiPlayer.getLife();
-        Player opponent = aiPlayer.getWeakestOpponent();
+        Player opponent = AiAttackController.choosePreferredDefenderPlayer(aiPlayer);
         final int hLife = opponent.getLife();
 
         if (!aiPlayer.canGainLife()) {
@@ -75,7 +76,7 @@ public class LifeExchangeAi extends SpellAbilityAi {
     final boolean mandatory) {
 
         final TargetRestrictions tgt = sa.getTargetRestrictions();
-        Player opp = ai.getWeakestOpponent();
+        Player opp = AiAttackController.choosePreferredDefenderPlayer(ai);
         if (tgt != null) {
             sa.resetTargets();
             if (sa.canTarget(opp) && (mandatory || ai.getLife() < opp.getLife())) {

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

@@ -1,5 +1,6 @@
 package forge.ai.ability;
 
+import forge.ai.AiAttackController;
 import forge.ai.AiProps;
 import forge.ai.ComputerUtil;
 import forge.ai.ComputerUtilAbility;
@@ -154,7 +155,7 @@ public class LifeExchangeVariantAi extends SpellAbilityAi {
     final boolean mandatory) {
 
         final TargetRestrictions tgt = sa.getTargetRestrictions();
-        Player opp = ai.getWeakestOpponent();
+        Player opp = AiAttackController.choosePreferredDefenderPlayer(ai);
         if (tgt != null) {
             sa.resetTargets();
             if (sa.canTarget(opp) && (mandatory || ai.getLife() < opp.getLife())) {

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

@@ -266,8 +266,7 @@ public class LifeGainAi extends SpellAbilityAi {
             }
             if (!hasTgt && mandatory) {
                 // need to target something but its neither negative against
-                // opponents,
-                // nor posive against allies
+                // opponents, nor positive against allies
 
                 // hurting ally is probably better than healing opponent
                 // look for Lifegain not Negative (case of lifegain negated)
@@ -295,8 +294,7 @@ public class LifeGainAi extends SpellAbilityAi {
                     sa.getTargets().add(ally);
                     hasTgt = true;
                 }
-                // better heal opponent which most life then the one with the
-                // lowest
+                // better heal opponent which most life then the one with the lowest
                 if (!hasTgt) {
                     Player opp = opps.max(PlayerPredicates.compareByLife());
                     sa.getTargets().add(opp);

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

@@ -28,7 +28,6 @@ public class LifeLoseAi extends SpellAbilityAi {
      */
     @Override
     public boolean chkAIDrawback(SpellAbility sa, Player ai) {
-
         final PlayerCollection tgtPlayers = getPlayers(ai, sa);
 
         final Card source = sa.getHostCard();
@@ -60,7 +59,6 @@ public class LifeLoseAi extends SpellAbilityAi {
         return true;
     }
 
-
     /*
      * (non-Javadoc)
      * 
@@ -123,12 +121,12 @@ public class LifeLoseAi extends SpellAbilityAi {
             return false;
         }
 
-        final PlayerCollection tgtPlayers = getPlayers(ai, sa);
-
         if (ComputerUtil.playImmediately(ai, sa)) {
             return true;
         }
 
+        final PlayerCollection tgtPlayers = getPlayers(ai, sa);
+         // TODO: check against the amount we could obtain when multiple activations are possible
         PlayerCollection filteredPlayer = tgtPlayers
                 .filter(Predicates.and(PlayerPredicates.isOpponentOf(ai), PlayerPredicates.lifeLessOrEqualTo(amount)));
         // killing opponents asap

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

@@ -17,7 +17,7 @@ public class LifeSetAi extends SpellAbilityAi {
     @Override
     protected boolean canPlayAI(Player ai, SpellAbility sa) {
         final int myLife = ai.getLife();
-        final Player opponent = ai.getWeakestOpponent();
+        final Player opponent = ai.getStrongestOpponent();
         final int hlife = opponent.getLife();
         final String amountStr = sa.getParam("LifeAmount");
 
@@ -36,8 +36,7 @@ public class LifeSetAi extends SpellAbilityAi {
             return false;
         }
 
-        // TODO handle proper calculation of X values based on Cost and what
-        // would be paid
+        // TODO handle proper calculation of X values based on Cost and what would be paid
         int amount;
         // we shouldn't have to worry too much about PayX for SetLife
         if (amountStr.equals("X") && sa.getSVar(amountStr).equals("Count$xPaid")) {
@@ -58,11 +57,9 @@ public class LifeSetAi extends SpellAbilityAi {
             if (tgt.canOnlyTgtOpponent()) {
                 sa.getTargets().add(opponent);
                 // if we can only target the human, and the Human's life
-                // would
-                // go up, don't play it.
+                // would go up, don't play it.
                 // possibly add a combo here for Magister Sphinx and
-                // Higedetsu's
-                // (sp?) Second Rite
+                // Higedetsu's (sp?) Second Rite
                 if ((amount > hlife) || !opponent.canLoseLife()) {
                     return false;
                 }
@@ -81,8 +78,7 @@ public class LifeSetAi extends SpellAbilityAi {
             if (sa.getParam("Defined").equals("Player")) {
                 if (amount == 0) {
                     return false;
-                } else if (myLife > amount) { // will decrease computer's
-                                              // life
+                } else if (myLife > amount) { // will decrease computer's life
                     if ((myLife < 5) || ((myLife - amount) > (hlife - amount))) {
                         return false;
                     }
@@ -104,7 +100,7 @@ public class LifeSetAi extends SpellAbilityAi {
     @Override
     protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
         final int myLife = ai.getLife();
-        final Player opponent = ai.getWeakestOpponent();
+        final Player opponent = ai.getStrongestOpponent();
         final int hlife = opponent.getLife();
         final Card source = sa.getHostCard();
         final String sourceName = ComputerUtilAbility.getAbilitySourceName(sa);
@@ -118,7 +114,7 @@ public class LifeSetAi extends SpellAbilityAi {
             sa.setXManaCostPaid(xPay);
             amount = xPay;
         } else {
-            amount = AbilityUtils.calculateAmount(sa.getHostCard(), amountStr, sa);
+            amount = AbilityUtils.calculateAmount(source, amountStr, sa);
         }
 
         // special cases when amount can't be calculated without targeting first
@@ -133,8 +129,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
+        // if the Target is modifying how much life is gained, this needs to be handled better
         final TargetRestrictions tgt = sa.getTargetRestrictions();
         if (tgt != null) {
             sa.resetTargets();

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

@@ -21,6 +21,7 @@ import forge.game.phase.PhaseHandler;
 import forge.game.phase.PhaseType;
 import forge.game.player.Player;
 import forge.game.player.PlayerActionConfirmMode;
+import forge.game.player.PlayerPredicates;
 import forge.game.spellability.SpellAbility;
 import forge.game.spellability.TargetRestrictions;
 import forge.game.zone.ZoneType;
@@ -214,13 +215,7 @@ public class MillAi extends SpellAbilityAi {
         }
 
         // get targeted or defined Player with largest library 
-        // TODO in Java 8 find better way
-        final Player m = Collections.max(list, new Comparator<Player>() {
-            @Override
-            public int compare(Player arg0, Player arg1) {
-                return arg0.getCardsIn(ZoneType.Library).size() - arg1.getCardsIn(ZoneType.Library).size();
-            }
-        });
+        final Player m = Collections.max(list, PlayerPredicates.compareByZoneSize(ZoneType.Library));
 
         int cardsToDiscard =  m.getCardsIn(ZoneType.Library).size();
 

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

@@ -78,7 +78,7 @@ public class MustBlockAi extends SpellAbilityAi {
 
         Card attacker = null;
         if (sa.hasParam("DefinedAttacker")) {
-            final List<Card> cards = AbilityUtils.getDefinedCards(sa.getHostCard(), sa.getParam("DefinedAttacker"), sa);
+            final List<Card> cards = AbilityUtils.getDefinedCards(source, sa.getParam("DefinedAttacker"), sa);
             if (cards.isEmpty()) {
                 return false;
             }

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

@@ -33,7 +33,6 @@ public class PermanentAi extends SpellAbilityAi {
      */
     @Override
     protected boolean checkPhaseRestrictions(final Player ai, final SpellAbility sa, final PhaseHandler ph) {
-
         final Card card = sa.getHostCard();
 
         if (card.hasKeyword("MayFlashSac") && !ai.couldCastSorcery(sa)) {
@@ -51,7 +50,6 @@ public class PermanentAi extends SpellAbilityAi {
      */
     @Override
     protected boolean checkApiLogic(final Player ai, final SpellAbility sa) {
-
         final Card card = sa.getHostCard();
         final Game game = ai.getGame();
 
@@ -297,7 +295,7 @@ public class PermanentAi extends SpellAbilityAi {
         if (!checkPhaseRestrictions(ai, sa, ai.getGame().getPhaseHandler())) {
             return false;
         }
-        return checkApiLogic(ai, sa);
+        return checkApiLogic(ai, sa) || mandatory;
     }
 
 }

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

@@ -58,7 +58,6 @@ public class PermanentCreatureAi extends PermanentAi {
      */
     @Override
     protected boolean checkPhaseRestrictions(final Player ai, final SpellAbility sa, final PhaseHandler ph) {
-
         final Card card = sa.getHostCard();
         final Game game = ai.getGame();
 
@@ -176,7 +175,6 @@ public class PermanentCreatureAi extends PermanentAi {
             }
         }
 
-
         if (hasFloatMana || willDiscardNow || willDieNow) {
             // Will lose mana in pool or about to discard a card in cleanup or about to die in combat, so use this opportunity
             return true;
@@ -207,7 +205,6 @@ public class PermanentCreatureAi extends PermanentAi {
 
     @Override
     protected boolean checkApiLogic(Player ai, SpellAbility sa) {
-
         if (!super.checkApiLogic(ai, sa)) {
             return false;
         }

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

@@ -8,7 +8,6 @@ import forge.game.card.CardCollection;
 import forge.game.card.CardLists;
 import forge.game.player.Player;
 import forge.game.spellability.SpellAbility;
-import forge.game.spellability.TargetRestrictions;
 import forge.game.zone.ZoneType;
 
 /** 
@@ -28,7 +27,6 @@ public class PermanentNoncreatureAi extends PermanentAi {
      */
     @Override
     protected boolean checkApiLogic(final Player ai, final SpellAbility sa) {
-
         if (!super.checkApiLogic(ai, sa))
             return false;
 
@@ -40,10 +38,8 @@ public class PermanentNoncreatureAi extends PermanentAi {
         if (host.hasSVar("OblivionRing")) {
             SpellAbility effectExile = AbilityFactory.getAbility(host.getSVar("TrigExile"), host);
             final ZoneType origin = ZoneType.listValueOf(effectExile.getParam("Origin")).get(0);
-            final TargetRestrictions tgt = effectExile.getTargetRestrictions();
-            final CardCollection list = CardLists.getValidCards(game.getCardsIn(origin), tgt.getValidTgts(), ai, host,
-                    effectExile);
-            CardCollection targets = CardLists.getTargetableCards(list, sa);
+            effectExile.setActivatingPlayer(ai);
+            CardCollection targets = CardLists.getTargetableCards(game.getCardsIn(origin), effectExile);
             if (sourceName.equals("Suspension Field") 
                     || sourceName.equals("Detention Sphere")) {
                 // existing "exile until leaves" enchantments only target

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

@@ -64,7 +64,7 @@ public class PlayAi extends SpellAbilityAi {
                 return false;
             }
         } else if (!sa.hasParam("Valid")) {
-            cards = AbilityUtils.getDefinedCards(sa.getHostCard(), sa.getParam("Defined"), sa);
+            cards = AbilityUtils.getDefinedCards(source, sa.getParam("Defined"), sa);
             if (cards.isEmpty()) {
                 return false;
             }
@@ -159,12 +159,8 @@ public class PlayAi extends SpellAbilityAi {
         return true;
     }
 
-    /* (non-Javadoc)
-     * @see forge.card.ability.SpellAbilityAi#confirmAction(forge.game.player.Player, forge.card.spellability.SpellAbility, forge.game.player.PlayerActionConfirmMode, java.lang.String)
-     */
     @Override
-    public boolean confirmAction(Player player, SpellAbility sa, PlayerActionConfirmMode mode, String message) {
-        // as called from PlayEffect:173
+    public boolean confirmAction(Player ai, SpellAbility sa, PlayerActionConfirmMode mode, String message) {
         return true;
     }
 
@@ -202,7 +198,7 @@ public class PlayAi extends SpellAbilityAi {
 
                         spell = (Spell) spell.copyWithDefinedCost(abCost);
                     }
-                    if( AiPlayDecision.WillPlay == ((PlayerControllerAi)ai.getController()).getAi().canPlayFromEffectAI(spell, !isOptional, true)) {
+                    if (AiPlayDecision.WillPlay == ((PlayerControllerAi)ai.getController()).getAi().canPlayFromEffectAI(spell, !(isOptional || sa.hasParam("Optional")), true)) {
                         // Before accepting, see if the spell has a valid number of targets (it should at this point).
                         // Proceeding past this point if the spell is not correctly targeted will result
                         // in "Failed to add to stack" error and the card disappearing from the game completely.

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

@@ -30,13 +30,12 @@ public class PowerExchangeAi extends SpellAbilityAi {
         sa.resetTargets();
 
         List<Card> list =
-                CardLists.getValidCards(ai.getWeakestOpponent().getCardsIn(ZoneType.Battlefield), tgt.getValidTgts(), ai, sa.getHostCard(), sa);
-        // AI won't try to grab cards that are filtered out of AI decks on
-        // purpose
+                CardLists.getValidCards(ai.getGame().getCardsIn(ZoneType.Battlefield), tgt.getValidTgts(), ai, sa.getHostCard(), sa);
+        // AI won't try to grab cards that are filtered out of AI decks on purpose
         list = CardLists.filter(list, new Predicate<Card>() {
             @Override
             public boolean apply(final Card c) {
-                return !ComputerUtilCard.isCardRemAIDeck(c) && c.canBeTargetedBy(sa);
+                return !ComputerUtilCard.isCardRemAIDeck(c) && c.canBeTargetedBy(sa) && c.getController() != ai;
             }
         });
         CardLists.sortByPowerAsc(list);

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

@@ -202,11 +202,10 @@ public class ProtectAi extends SpellAbilityAi {
         sa.resetTargets();
         CardCollection list = getProtectCreatures(ai, sa);
 
-        list = CardLists.getValidCards(list, tgt.getValidTgts(), sa.getActivatingPlayer(), sa.getHostCard(), sa);
+        list = CardLists.getValidCards(list, tgt.getValidTgts(), sa.getActivatingPlayer(), source, sa);
 
         if (game.getStack().isEmpty()) {
-            // If the cost is tapping, don't activate before declare
-            // attack/block
+            // If the cost is tapping, don't activate before declare attack/block
             if (sa.getPayCosts().hasTapCost()) {
                 if (game.getPhaseHandler().getPhase().isBefore(PhaseType.COMBAT_DECLARE_ATTACKERS)
                         && game.getPhaseHandler().isPlayerTurn(ai)) {
@@ -341,7 +340,7 @@ public class ProtectAi extends SpellAbilityAi {
             sa.getTargets().add(c);
         }
 
-        if (sa.getTargets().size() < tgt.getMinTargets(sa.getHostCard(), sa)) {
+        if (sa.getTargets().size() < tgt.getMinTargets(source, sa)) {
             sa.resetTargets();
             return false;
         }

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

@@ -382,8 +382,7 @@ public class PumpAi extends PumpAiBase {
                 return false;
             }
 
-            // when this happens we need to expand AI to consider if its ok for
-            // everything?
+            // when this happens we need to expand AI to consider if its ok for everything?
             for (final Card card : cards) {
                 if (sa.isCurse()) {
                     if (!card.getController().isOpponentOf(ai)) {
@@ -400,7 +399,6 @@ public class PumpAi extends PumpAiBase {
                     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)) {
@@ -438,7 +436,7 @@ public class PumpAi extends PumpAiBase {
                 && game.getPhaseHandler().getPhase().isAfter(PhaseType.COMBAT_DECLARE_BLOCKERS)
                 && !(sa.isCurse() && defense < 0)
                 && !containsNonCombatKeyword(keywords)
-                && !sa.hasParam("UntilYourNextTurn")
+                && !"UntilYourNextTurn".equals(sa.getParam("Duration"))
                 && !"Snapcaster".equals(sa.getParam("AILogic"))
                 && !isFight) {
             return false;
@@ -489,7 +487,31 @@ public class PumpAi extends PumpAiBase {
                 // each player sacrifices one permanent, e.g. Vaevictis, Asmadi the Dire - grab the worst for allied and
                 // the best for opponents
                 return SacrificeAi.doSacOneEachLogic(ai, sa);
+            } else if (sa.getParam("AILogic").equals("Destroy")) {
+                List<Card> tgts = CardLists.getTargetableCards(game.getCardsIn(ZoneType.Battlefield), sa);
+                if (tgts.isEmpty()) {
+                    return false;
+                }
+
+                List<Card> alliedTgts = CardLists.filter(tgts, Predicates.or(CardPredicates.isControlledByAnyOf(ai.getAllies()), CardPredicates.isController(ai)));
+                List<Card> oppTgts = CardLists.filter(tgts, CardPredicates.isControlledByAnyOf(ai.getRegisteredOpponents()));
+
+                Card destroyTgt = null;
+                if (!oppTgts.isEmpty()) {
+                    destroyTgt = ComputerUtilCard.getBestAI(oppTgts);
+                } else {
+                    // TODO: somehow limit this so that the AI doesn't always destroy own stuff when able?
+                    destroyTgt = ComputerUtilCard.getWorstAI(alliedTgts);
+                }
+
+                if (destroyTgt != null) {
+                    sa.getTargets().add(destroyTgt);
+                    return true;
+                }
+
+                return false;
             }
+
             if (isFight) {
                 return FightAi.canFightAi(ai, sa, attack, defense);
             }
@@ -518,8 +540,7 @@ public class PumpAi extends PumpAiBase {
 
         list = CardLists.getValidCards(list, tgt.getValidTgts(), ai, source, sa);
         if (game.getStack().isEmpty()) {
-            // If the cost is tapping, don't activate before declare
-            // attack/block
+            // If the cost is tapping, don't activate before declare attack/block
             if (sa.getPayCosts().hasTapCost()) {
                 if (game.getPhaseHandler().getPhase().isBefore(PhaseType.COMBAT_DECLARE_ATTACKERS)
                         && game.getPhaseHandler().isPlayerTurn(ai)) {

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

@@ -6,6 +6,7 @@ import com.google.common.base.Predicate;
 import com.google.common.base.Predicates;
 import com.google.common.collect.Iterables;
 
+import forge.ai.AiAttackController;
 import forge.ai.ComputerUtil;
 import forge.ai.ComputerUtilCard;
 import forge.ai.ComputerUtilCombat;
@@ -43,7 +44,6 @@ public abstract class PumpAiBase extends SpellAbilityAi {
         return false;
     }
 
-
     public boolean grantsUsefulExtraBlockOpts(final Player ai, final SpellAbility sa, final Card card, List<String> keywords) {
         PhaseHandler ph = ai.getGame().getPhaseHandler();
         Card pumped = ComputerUtilCard.getPumpedCreature(ai, sa, card, 0, 0, keywords);
@@ -109,7 +109,7 @@ public abstract class PumpAiBase extends SpellAbilityAi {
                     && (card.getNetCombatDamage() > 0)
                     && !ph.getPhase().isAfter(PhaseType.COMBAT_DECLARE_ATTACKERS);
         } else if (keyword.endsWith("CARDNAME can't attack or block.")) {
-            if (sa.hasParam("UntilYourNextTurn")) {
+            if ("UntilYourNextTurn".equals(sa.getParam("Duration"))) {
                 return CombatUtil.canAttack(card, ai) || CombatUtil.canBlock(card, true);
             }
             if (!ph.isPlayerTurn(ai)) {
@@ -153,14 +153,6 @@ public abstract class PumpAiBase extends SpellAbilityAi {
                 }
             });
             return CombatUtil.canBlockAtLeastOne(card, attackers);
-        } else if (keyword.endsWith("CantBlockCardUIDSource")) {    // can't block CARDNAME this turn
-            if (!ph.isPlayerTurn(ai) || ph.getPhase().isAfter(PhaseType.COMBAT_DECLARE_BLOCKERS)
-                    || ph.getPhase().isBefore(PhaseType.MAIN1) || !CombatUtil.canBlock(sa.getHostCard(), card)) {
-                return false;
-            }
-            // target needs to be a creature, controlled by the player which is attacked
-            return !sa.getHostCard().isTapped() || (combat != null && combat.isAttacking(sa.getHostCard())
-                    && card.getController().equals(combat.getDefenderPlayerByAttacker(sa.getHostCard())));
         } else if (keyword.endsWith("This card doesn't untap during your next untap step.")) {
             return !ph.getPhase().isBefore(PhaseType.MAIN2) && !card.isUntapped() && ph.isPlayerTurn(ai)
                     && Untap.canUntap(card);
@@ -201,7 +193,7 @@ public abstract class PumpAiBase extends SpellAbilityAi {
         final Game game = ai.getGame();
         final Combat combat = game.getCombat();
         final PhaseHandler ph = game.getPhaseHandler();
-        final Player opp = ai.getWeakestOpponent();
+        final Player opp = AiAttackController.choosePreferredDefenderPlayer(ai);
         final int newPower = card.getNetCombatDamage() + attack;
         //int defense = getNumDefense(sa);
         if (!CardUtil.isStackingKeyword(keyword) && card.hasKeyword(keyword)) {
@@ -479,7 +471,7 @@ public abstract class PumpAiBase extends SpellAbilityAi {
                 }
             }); // leaves all creatures that will be destroyed
         } // -X/-X end
-        else if (attack < 0 && !game.getPhaseHandler().isPreventCombatDamageThisTurn()) {
+        else if (attack < 0 && !game.getReplacementHandler().isPreventCombatDamageThisTurn()) {
             // spells that give -X/0
             boolean isMyTurn = game.getPhaseHandler().isPlayerTurn(ai);
             if (isMyTurn) {
@@ -513,7 +505,6 @@ 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.")) {
@@ -539,8 +530,7 @@ public abstract class PumpAiBase extends SpellAbilityAi {
 
     protected boolean containsNonCombatKeyword(final List<String> keywords) {
         for (final String keyword : keywords) {
-            // since most keywords are combat relevant check for those that are
-            // not
+            // since most keywords are combat relevant check for those that are not
             if (keyword.endsWith("This card doesn't untap during your next untap step.")
                     || keyword.endsWith("Shroud") || keyword.endsWith("Hexproof")) {
                 return true;

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

@@ -48,12 +48,6 @@ public class PumpAllAi extends PumpAiBase {
             }
         }
 
-        final int power = AbilityUtils.calculateAmount(sa.getHostCard(), sa.getParam("NumAtt"), sa);
-        final int defense = AbilityUtils.calculateAmount(sa.getHostCard(), sa.getParam("NumDef"), sa);
-        final List<String> keywords = sa.hasParam("KW") ? Arrays.asList(sa.getParam("KW").split(" & ")) : new ArrayList<>();
-
-        final PhaseType phase = game.getPhaseHandler().getPhase();
-
         if (ComputerUtil.preventRunAwayActivations(sa)) {
             return false;
         }
@@ -64,31 +58,34 @@ public class PumpAllAi extends PumpAiBase {
             }
         }
         
-        if (sa.hasParam("ValidCards")) {
-            valid = sa.getParam("ValidCards");
-        }
-
-        final Player opp = ai.getWeakestOpponent();
-        CardCollection comp = CardLists.getValidCards(ai.getCardsIn(ZoneType.Battlefield), valid, source.getController(), source, sa);
-        CardCollection human = CardLists.getValidCards(opp.getCardsIn(ZoneType.Battlefield), valid, source.getController(), source, sa);
-
         final TargetRestrictions tgt = sa.getTargetRestrictions();
-        if (tgt != null && sa.canTarget(opp) && sa.hasParam("IsCurse")) {
+        final Player opp = ai.getStrongestOpponent();
+
+        if (tgt != null && sa.canTarget(opp) && sa.isCurse()) {
             sa.resetTargets();
             sa.getTargets().add(opp);
             return true;
         }
         
-        if (tgt != null && sa.canTarget(ai) && !sa.hasParam("IsCurse")) {
+        if (tgt != null && sa.canTarget(ai) && !sa.isCurse()) {
             sa.resetTargets();
             sa.getTargets().add(ai);
             return true;
         }
 
-        if (!game.getStack().isEmpty() && !sa.isCurse()) {
-            return pumpAgainstRemoval(ai, sa, comp);
+        final int power = AbilityUtils.calculateAmount(source, sa.getParam("NumAtt"), sa);
+        final int defense = AbilityUtils.calculateAmount(source, sa.getParam("NumDef"), sa);
+        final List<String> keywords = sa.hasParam("KW") ? Arrays.asList(sa.getParam("KW").split(" & ")) : new ArrayList<>();
+        final PhaseType phase = game.getPhaseHandler().getPhase();
+
+        if (sa.hasParam("ValidCards")) {
+            valid = sa.getParam("ValidCards");
         }
-        if (sa.hasParam("IsCurse")) {
+
+        CardCollection comp = CardLists.getValidCards(ai.getCardsIn(ZoneType.Battlefield), valid, source.getController(), source, sa);
+        CardCollection human = CardLists.getValidCards(opp.getCardsIn(ZoneType.Battlefield), valid, source.getController(), source, sa);
+
+        if (sa.isCurse()) {
             if (defense < 0) { // try to destroy creatures
                 comp = CardLists.filter(comp, new Predicate<Card>() {
                     @Override
@@ -113,7 +110,7 @@ public class PumpAllAi extends PumpAiBase {
                 if (phase.isAfter(PhaseType.COMBAT_DECLARE_BLOCKERS)
                         || phase.isBefore(PhaseType.COMBAT_DECLARE_ATTACKERS)
                         || game.getPhaseHandler().isPlayerTurn(sa.getActivatingPlayer())
-                        || game.getPhaseHandler().isPreventCombatDamageThisTurn()) {
+                        || game.getReplacementHandler().isPreventCombatDamageThisTurn()) {
                     return false;
                 }
                 int totalPower = 0;
@@ -139,11 +136,14 @@ public class PumpAllAi extends PumpAiBase {
             	return true;
             }
 
-            // evaluate both lists and pass only if human creatures are more
-            // valuable
+            // evaluate both lists and pass only if human creatures are more valuable
             return (ComputerUtilCard.evaluateCreatureList(comp) + 200) < ComputerUtilCard.evaluateCreatureList(human);
         } // end Curse
 
+        if (!game.getStack().isEmpty()) {
+            return pumpAgainstRemoval(ai, sa, comp);
+        }
+
         return !CardLists.getValidCards(getPumpCreatures(ai, sa, defense, power, keywords, false), valid, source.getController(), source, sa).isEmpty();
     } // pumpAllCanPlayAI()
 
@@ -152,6 +152,17 @@ public class PumpAllAi extends PumpAiBase {
         return true;
     }
 
+    @Override
+    protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
+        // it might help so take it
+        if (!sa.usesTargeting() && !sa.isCurse() && sa.getParam("ValidCards") != null && sa.getParam("ValidCards").contains("YouCtrl")) {
+            return true;
+        }
+
+        // important to call canPlay first so targets are added if needed
+        return canPlayAI(ai, sa) || mandatory;
+    }
+
     boolean pumpAgainstRemoval(Player ai, SpellAbility sa, List<Card> comp) {
         final List<GameObject> objects = ComputerUtil.predictThreatenedObjects(sa.getActivatingPlayer(), sa, true);
         for (final Card c : comp) {

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

@@ -49,14 +49,6 @@ import forge.game.zone.ZoneType;
  */
 public class RegenerateAi extends SpellAbilityAi {
 
-    // Ex: A:SP$Regenerate | Cost$W | ValidTgts$ Creature | TgtPrompt$ Select target creature | SpellDescription$Regenerate
-    // target creature.
-    // http://www.slightlymagic.net/wiki/Forge_AbilityFactory#Regenerate
-
-    // **************************************************************
-    // ********************* Regenerate ****************************
-    // **************************************************************
-
     @Override
     protected boolean checkApiLogic(final Player ai, final SpellAbility sa) {
         final Game game = ai.getGame();
@@ -65,8 +57,7 @@ public class RegenerateAi extends SpellAbilityAi {
         boolean chance = false;
         final TargetRestrictions tgt = sa.getTargetRestrictions();
         if (tgt == null) {
-            // As far as I can tell these Defined Cards will only have one of
-            // them
+            // As far as I can tell these Defined Cards will only have one of them
             final List<Card> list = AbilityUtils.getDefinedCards(hostCard, sa.getParam("Defined"), sa);
 
             if (!game.getStack().isEmpty()) {
@@ -105,8 +96,7 @@ public class RegenerateAi extends SpellAbilityAi {
             }
 
             if (!game.getStack().isEmpty()) {
-                // check stack for something on the stack will kill anything i
-                // control
+                // check stack for something on the stack will kill anything i control
                 final List<GameObject> objects = ComputerUtil.predictThreatenedObjects(sa.getActivatingPlayer(), sa, true);
 
                 final List<Card> threatenedTargets = new ArrayList<>();
@@ -191,8 +181,7 @@ public class RegenerateAi extends SpellAbilityAi {
                 }
             }
 
-            // TODO see if something on the stack is about to kill something i
-            // can target
+            // TODO see if something on the stack is about to kill something i can target
 
             // choose my best X without regen
             if (CardLists.getNotType(compTargetables, "Creature").isEmpty()) {

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

@@ -1,6 +1,7 @@
 package forge.ai.ability;
 
 
+import forge.ai.AiAttackController;
 import forge.ai.AiController;
 import forge.ai.ComputerUtilCost;
 import forge.ai.PlayerControllerAi;
@@ -14,10 +15,10 @@ public class RepeatAi extends SpellAbilityAi {
 
     @Override
     protected boolean canPlayAI(Player ai, SpellAbility sa) {
-        final Player opp = ai.getWeakestOpponent();
+        final Player opp = AiAttackController.choosePreferredDefenderPlayer(ai);
 
         if (sa.usesTargeting()) {
-            if (!opp.canBeTargetedBy(sa)) {
+            if (!sa.canTarget(opp)) {
                 return false;
             }
             sa.resetTargets();
@@ -44,9 +45,8 @@ public class RepeatAi extends SpellAbilityAi {
 
     @Override
     protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
-    	
     	 if (sa.usesTargeting()) {
-         	final Player opp = ai.getWeakestOpponent();
+         	final Player opp = AiAttackController.choosePreferredDefenderPlayer(ai);
              if (sa.canTarget(opp)) {
                  sa.resetTargets();
                  sa.getTargets().add(opp);

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

@@ -16,7 +16,6 @@ import forge.game.card.CardPredicates.Presets;
 import forge.game.card.CardUtil;
 import forge.game.phase.PhaseType;
 import forge.game.player.Player;
-import forge.game.spellability.AbilitySub;
 import forge.game.spellability.SpellAbility;
 import forge.game.zone.ZoneType;
 import forge.util.TextUtil;
@@ -67,7 +66,7 @@ public class RepeatEachAi extends SpellAbilityAi {
             return false;
         } else if ("AllPlayerLoseLife".equals(logic)) {
             final Card source = sa.getHostCard();
-            AbilitySub repeat = sa.getAdditionalAbility("RepeatSubAbility");
+            SpellAbility repeat = sa.getAdditionalAbility("RepeatSubAbility");
 
             String svar = repeat.getSVar(repeat.getParam("LifeAmount"));
             // replace RememberedPlayerCtrl with YouCtrl

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

@@ -20,13 +20,9 @@ import forge.game.spellability.TargetRestrictions;
 import forge.game.zone.ZoneType;
 
 public class SacrificeAi extends SpellAbilityAi {
-    // **************************************************************
-    // *************************** Sacrifice ***********************
-    // **************************************************************
 
     @Override
     protected boolean canPlayAI(Player ai, SpellAbility sa) {
-
         return sacrificeTgtAI(ai, sa);
     }
 
@@ -48,8 +44,7 @@ public class SacrificeAi extends SpellAbilityAi {
         }
 
         // Improve AI for triggers. If source is a creature with:
-        // When ETB, sacrifice a creature. Check to see if the AI has something
-        // to sacrifice
+        // When ETB, sacrifice a creature. Check to see if the AI has something to sacrifice
 
         // Eventually, we can call the trigger of ETB abilities with not
         // mandatory as part of the checks to cast something
@@ -58,12 +53,11 @@ public class SacrificeAi extends SpellAbilityAi {
     }
 
     private boolean sacrificeTgtAI(final Player ai, final SpellAbility sa) {
-
         final Card source = sa.getHostCard();
         final TargetRestrictions tgt = sa.getTargetRestrictions();
         final boolean destroy = sa.hasParam("Destroy");
 
-        Player opp = ai.getWeakestOpponent();
+        Player opp = ai.getStrongestOpponent();
 
         if (tgt != null) {
             sa.resetTargets();
@@ -109,8 +103,7 @@ public class SacrificeAi extends SpellAbilityAi {
                 sa.setXManaCostPaid(Math.min(ComputerUtilCost.getMaxXValue(sa, ai), amount));
             }
 
-            final int half = (amount / 2) + (amount % 2); // Half of amount
-                                                          // rounded up
+            final int half = (amount / 2) + (amount % 2); // Half of amount rounded up
 
             // If the Human has at least half rounded up of the amount to be
             // sacrificed, cast the spell
@@ -130,8 +123,7 @@ public class SacrificeAi extends SpellAbilityAi {
             // If Sacrifice hits both players:
             // Only cast it if Human has the full amount of valid
             // Only cast it if AI doesn't have the full amount of Valid
-            // TODO: Cast if the type is favorable: my "worst" valid is
-            // worse than his "worst" valid
+            // TODO: Cast if the type is favorable: my "worst" valid is worse than his "worst" valid
             final String num = sa.hasParam("Amount") ? sa.getParam("Amount") : "1";
             int amount = AbilityUtils.calculateAmount(source, num, sa);
 

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

@@ -2,17 +2,12 @@ package forge.ai.ability;
 
 import forge.ai.ComputerUtilCard;
 import forge.ai.ComputerUtilCost;
-import forge.ai.ComputerUtilMana;
 import forge.ai.SpellAbilityAi;
 import forge.game.card.Card;
-import forge.game.card.CardCollection;
-import forge.game.card.CardLists;
 import forge.game.cost.Cost;
 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 SacrificeAllAi extends SpellAbilityAi {
 
@@ -22,22 +17,7 @@ public class SacrificeAllAi extends SpellAbilityAi {
         // based on what the expected targets could be
         final Cost abCost = sa.getPayCosts();
         final Card source = sa.getHostCard();
-        String valid = "";
-
-        if (sa.hasParam("ValidCards")) {
-            valid = sa.getParam("ValidCards");
-        }
-
-        if (valid.contains("X") && sa.getSVar("X").equals("Count$xPaid")) {
-            // Set PayX here to maximum value.
-            final int xPay = ComputerUtilMana.determineLeftoverMana(sa, ai);
-            valid = TextUtil.fastReplace(valid, "X", Integer.toString(xPay));
-        }
-
-        CardCollection humanlist =
-                CardLists.getValidCards(ai.getWeakestOpponent().getCardsIn(ZoneType.Battlefield), valid.split(","), source.getController(), source, sa);
-        CardCollection computerlist =
-                CardLists.getValidCards(ai.getCardsIn(ZoneType.Battlefield), valid.split(","), source.getController(), source, sa);
+        final String logic = sa.getParamOrDefault("AILogic", "");
 
         if (abCost != null) {
             // AI currently disabled for some costs
@@ -46,29 +26,19 @@ public class SacrificeAllAi extends SpellAbilityAi {
             }
         }
         
-        // prevent run-away activations - first time will always return true
-        boolean chance = MyRandom.getRandom().nextFloat() <= Math.pow(.6667, sa.getActivationsThisTurn());
+        if (logic.equals("HellionEruption")) {
+            if (ai.getCreaturesInPlay().size() < 5 || ai.getCreaturesInPlay().size() * 150 < ComputerUtilCard.evaluateCreatureList(ai.getCreaturesInPlay())) {
+                return false;
+            }
+        }
         
-        // if only creatures are affected evaluate both lists and pass only if
-        // human creatures are more valuable
-        if ((CardLists.getNotType(humanlist, "Creature").size() == 0) && (CardLists.getNotType(computerlist, "Creature").size() == 0)) {
-            if ((ComputerUtilCard.evaluateCreatureList(computerlist) + 200) >= ComputerUtilCard
-                    .evaluateCreatureList(humanlist)) {
-                return false;
-            }
-        } // only lands involved
-        else if ((CardLists.getNotType(humanlist, "Land").size() == 0) && (CardLists.getNotType(computerlist, "Land").size() == 0)) {
-            if ((ComputerUtilCard.evaluatePermanentList(computerlist) + 1) >= ComputerUtilCard
-                    .evaluatePermanentList(humanlist)) {
-                return false;
-            }
-        } // otherwise evaluate both lists by CMC and pass only if human
-          // permanents are more valuable
-        else if ((ComputerUtilCard.evaluatePermanentList(computerlist) + 3) >= ComputerUtilCard
-                .evaluatePermanentList(humanlist)) {
+        if (!DestroyAllAi.doMassRemovalLogic(ai, sa)) {
             return false;
         }
 
+        // prevent run-away activations - first time will always return true
+        boolean chance = MyRandom.getRandom().nextFloat() <= Math.pow(.6667, sa.getActivationsThisTurn());
+
         return ((MyRandom.getRandom().nextFloat() < .9667) && chance);
     }
 

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

@@ -3,14 +3,12 @@ package forge.ai.ability;
 import com.google.common.base.Predicates;
 
 import forge.ai.ComputerUtilMana;
+import forge.ai.SpecialCardAi;
 import forge.ai.SpellAbilityAi;
 import forge.game.ability.ApiType;
 import forge.game.card.Card;
-import forge.game.card.Card.SplitCMCMode;
-import forge.game.card.CardCollection;
 import forge.game.card.CardLists;
 import forge.game.card.CardPredicates;
-import forge.game.card.CounterEnumType;
 import forge.game.phase.PhaseHandler;
 import forge.game.phase.PhaseType;
 import forge.game.player.Player;
@@ -47,6 +45,11 @@ public class ScryAi extends SpellAbilityAi {
      */
     @Override
     protected boolean checkPhaseRestrictions(final Player ai, final SpellAbility sa, final PhaseHandler ph) {
+        // For Brain in a Jar, avoid competing against the other ability in the opponent's EOT.
+        if ("BrainJar".equals(sa.getParam("AILogic"))) {
+            return ph.getPhase().isAfter(PhaseType.MAIN2);
+        }
+
         // 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,
@@ -102,56 +105,9 @@ public class ScryAi extends SpellAbilityAi {
         if ("Never".equals(aiLogic)) {
             return false;
         } else if ("BrainJar".equals(aiLogic)) {
-            final Card source = sa.getHostCard();
-            
-            int counterNum = source.getCounters(CounterEnumType.CHARGE);
-            // no need for logic
-            if (counterNum == 0) {
-                return false;
-            }
-            int libsize = ai.getCardsIn(ZoneType.Library).size();
-            
-            final CardCollection hand = CardLists.filter(ai.getCardsIn(ZoneType.Hand), Predicates.or( 
-                    CardPredicates.isType("Instant"), CardPredicates.isType("Sorcery")));
-            if (!hand.isEmpty()) {
-                // has spell that can be cast in hand with put ability
-                if (!CardLists.filter(hand, CardPredicates.hasCMC(counterNum + 1)).isEmpty()) {
-                    return false;
-                }
-                // has spell that can be cast if one counter is removed
-                if (!CardLists.filter(hand, CardPredicates.hasCMC(counterNum)).isEmpty()) {
-                    sa.setXManaCostPaid(1);
-                    return true;
-                }
-            }
-            final CardCollection library = CardLists.filter(ai.getCardsIn(ZoneType.Library), Predicates.or( 
-                    CardPredicates.isType("Instant"), CardPredicates.isType("Sorcery")));
-            if (!library.isEmpty()) {
-                // get max cmc of instant or sorceries in the libary 
-                int maxCMC = 0;
-                for (final Card c : library) {
-                    int v = c.getCMC(); 
-                    if (c.isSplitCard()) {
-                        v = Math.max(c.getCMC(SplitCMCMode.LeftSplitCMC), c.getCMC(SplitCMCMode.RightSplitCMC));
-                    }
-                    if (v > maxCMC) {
-                        maxCMC = v;
-                    }
-                }
-                // there is a spell with more CMC, no need to remove counter
-                if (counterNum + 1 < maxCMC) {
-                    return false;
-                }
-                int maxToRemove = counterNum - maxCMC + 1;
-                // no Scry 0, even if its catched from later stuff 
-                if (maxToRemove <= 0) {
-                    return false;
-                }
-                sa.setXManaCostPaid(maxToRemove);
-            } else {
-                // no Instant or Sorceries anymore, just scry
-                sa.setXManaCostPaid(Math.min(counterNum, libsize));
-            }
+            return SpecialCardAi.BrainInAJar.consider(ai, sa);
+        } else if ("MultipleChoice".equals(aiLogic)) {
+            return SpecialCardAi.MultipleChoice.consider(ai, sa);
         }
         return true;
     }
@@ -163,11 +119,9 @@ public class ScryAi extends SpellAbilityAi {
             return false;
         }
 
-        double chance = .4; // 40 percent chance of milling with instant speed
-                            // stuff
+        double chance = .4; // 40 percent chance of milling with instant speed stuff
         if (SpellAbilityAi.isSorcerySpeed(sa)) {
-            chance = .667; // 66.7% chance for sorcery speed (since it will
-                           // never activate EOT)
+            chance = .667; // 66.7% chance for sorcery speed (since it will never activate EOT)
         }
         boolean randomReturn = MyRandom.getRandom().nextFloat() <= Math.pow(chance, sa.getActivationsThisTurn() + 1);
 

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

@@ -52,8 +52,7 @@ public class SetStateAi extends SpellAbilityAi {
 
     @Override
     public boolean chkAIDrawback(SpellAbility sa, Player aiPlayer) {
-        // Gross generalization, but this always considers alternate
-        // states more powerful
+        // Gross generalization, but this always considers alternate states more powerful
         return !sa.getHostCard().isInAlternateState();
     }
 

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

@@ -17,8 +17,7 @@ public class ShuffleAi extends SpellAbilityAi {
             return aiPlayer.getGame().getPhaseHandler().is(PhaseType.MAIN2, aiPlayer);
         }
 
-        // not really sure when the compy would use this; maybe only after a
-        // human
+        // not really sure when the compy would use this; maybe only after a human
         // deliberately put a card on top of their library
         return false;
         /*

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

@@ -1,5 +1,6 @@
 package forge.ai.ability;
 
+import forge.ai.AiAttackController;
 import forge.ai.SpellAbilityAi;
 import forge.game.player.Player;
 import forge.game.player.PlayerActionConfirmMode;
@@ -8,16 +9,33 @@ import forge.game.spellability.SpellAbility;
 public class SkipPhaseAi extends SpellAbilityAi {
     @Override
     protected boolean canPlayAI(Player aiPlayer, SpellAbility sa) {
-        return true;
+        return targetPlayer(aiPlayer, sa, false);
     }
 
     @Override
     protected boolean doTriggerAINoCost(Player aiPlayer, SpellAbility sa, boolean mandatory) {
-        return mandatory || canPlayAI(aiPlayer, sa);
+        return targetPlayer(aiPlayer, sa, mandatory);
     }
 
     @Override
     public boolean confirmAction(Player player, SpellAbility sa, PlayerActionConfirmMode mode, String message) {
         return true;
     }
+    
+    public boolean targetPlayer(Player ai, SpellAbility sa, boolean mandatory) {
+        if (sa.usesTargeting()) {
+            final Player opp = AiAttackController.choosePreferredDefenderPlayer(ai);
+            sa.resetTargets();
+            if (sa.canTarget(opp)) {
+                sa.getTargets().add(opp);
+            }
+            else if (mandatory && sa.canTarget(ai)) {
+                sa.getTargets().add(ai); 
+            }
+            else {
+                return false;
+            }
+        }
+        return true;
+    }
 }

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

@@ -1,6 +1,5 @@
 package forge.ai.ability;
 
-
 import forge.ai.SpellAbilityAi;
 import forge.game.player.Player;
 import forge.game.spellability.SpellAbility;

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

@@ -66,7 +66,6 @@ public class TapAi extends TapAiBase {
                 // Set PayX here to maximum value.
                 // TODO need to set XManaCostPaid for targets, maybe doesn't need PayX anymore?
                 sa.setXManaCostPaid(ComputerUtilCost.getMaxXValue(sa, ai));
-                // TODO since change of PayX. the shouldCastLessThanMax logic might be faulty
             }
 
             sa.resetTargets();

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

@@ -5,11 +5,13 @@ import java.util.List;
 import com.google.common.base.Predicate;
 import com.google.common.collect.Iterables;
 
+import forge.ai.AiAttackController;
 import forge.ai.ComputerUtil;
 import forge.ai.ComputerUtilAbility;
 import forge.ai.ComputerUtilCard;
 import forge.ai.SpellAbilityAi;
 import forge.game.Game;
+import forge.game.ability.AbilityUtils;
 import forge.game.ability.ApiType;
 import forge.game.card.Card;
 import forge.game.card.CardCollection;
@@ -109,7 +111,7 @@ public abstract class TapAiBase extends SpellAbilityAi {
      * @return a boolean.
      */
     protected boolean tapPrefTargeting(final Player ai, final Card source, final SpellAbility sa, final boolean mandatory) {
-        final Player opp = ai.getWeakestOpponent();
+        final Player opp = AiAttackController.choosePreferredDefenderPlayer(ai);
         final Game game = ai.getGame();
         CardCollection tapList = CardLists.filterControlledBy(game.getCardsIn(ZoneType.Battlefield), ai.getOpponents());
         tapList = CardLists.getTargetableCards(tapList, sa);
@@ -308,9 +310,8 @@ public abstract class TapAiBase extends SpellAbilityAi {
                 return true;
             }
 
-            // TODO: use Defined to determine, if this is an unfavorable result
-
-            return true;
+            final List<Card> pDefined = AbilityUtils.getDefinedCards(sa.getHostCard(), sa.getParam("Defined"), sa);
+            return pDefined.isEmpty() || (pDefined.get(0).isUntapped() && pDefined.get(0).getController() != ai);
         } else {
             sa.resetTargets();
             if (tapPrefTargeting(ai, source, sa, mandatory)) {

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

@@ -12,7 +12,7 @@ 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.Presets;
+import forge.game.card.CardPredicates;
 import forge.game.combat.CombatUtil;
 import forge.game.phase.PhaseType;
 import forge.game.player.Player;
@@ -49,7 +49,7 @@ public class TapAllAi extends SpellAbilityAi {
         }
 
         validTappables = CardLists.getValidCards(validTappables, valid, source.getController(), source, sa);
-        validTappables = CardLists.filter(validTappables, Presets.UNTAPPED);
+        validTappables = CardLists.filter(validTappables, CardPredicates.Presets.UNTAPPED);
 
         if (sa.hasParam("AILogic")) {
             String logic = sa.getParam("AILogic");
@@ -69,18 +69,8 @@ public class TapAllAi extends SpellAbilityAi {
             return false;
         }
 
-        final List<Card> human = CardLists.filter(validTappables, new Predicate<Card>() {
-            @Override
-            public boolean apply(final Card c) {
-                return c.getController().equals(opp);
-            }
-        });
-        final List<Card> compy = CardLists.filter(validTappables, new Predicate<Card>() {
-            @Override
-            public boolean apply(final Card c) {
-                return c.getController().equals(ai);
-            }
-        });
+        final List<Card> human = CardLists.filterControlledBy(validTappables, opp);
+        final List<Card> compy = CardLists.filterControlledBy(validTappables, ai);
         if (human.size() <= compy.size()) {
             return false;
         }
@@ -102,7 +92,7 @@ public class TapAllAi extends SpellAbilityAi {
         final Game game = source.getGame();
         CardCollectionView tmpList = game.getCardsIn(ZoneType.Battlefield);
         tmpList = CardLists.getValidCards(tmpList, valid, source.getController(), source, sa);
-        tmpList = CardLists.filter(tmpList, Presets.UNTAPPED);
+        tmpList = CardLists.filter(tmpList, CardPredicates.Presets.UNTAPPED);
         return tmpList;
     }
 

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

@@ -19,8 +19,7 @@ public class TapOrUntapAi extends TapAiBase {
 
         if (!sa.usesTargeting()) {
             // assume we are looking to tap human's stuff
-            // TODO - check for things with untap abilities, and don't tap
-            // those.
+            // TODO - check for things with untap abilities, and don't tap those.
 
             boolean bFlag = false;
             for (final Card c : AbilityUtils.getDefinedCards(source, sa.getParam("Defined"), sa)) {
@@ -40,6 +39,4 @@ public class TapOrUntapAi extends TapAiBase {
         return randomReturn;
     }
 
-
-
 }

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

@@ -50,7 +50,6 @@ public class TokenAi extends SpellAbilityAi {
 
     @Override
     protected boolean checkPhaseRestrictions(final Player ai, final SpellAbility sa, final PhaseHandler ph) {
-
         final Card source = sa.getHostCard();
         // Planeswalker-related flags
         boolean pwMinus = false;
@@ -96,7 +95,7 @@ public class TokenAi extends SpellAbilityAi {
             if (sa.getSVar("X").equals("Count$xPaid")) {
                 // Set PayX here to maximum value.
                 x = ComputerUtilCost.getMaxXValue(sa, ai);
-                sa.setXManaCostPaid(x);
+                sa.getRootAbility().setXManaCostPaid(x);
             }
             if (x <= 0) {
                 return false; // 0 tokens or 0 toughness token(s)
@@ -143,7 +142,7 @@ public class TokenAi extends SpellAbilityAi {
         final Player opp = ai.getWeakestOpponent();
 
         if (ComputerUtil.preventRunAwayActivations(sa)) {
-            return false;   // prevent infinite tokens?
+            return false; // prevent infinite tokens?
         }
         Card actualToken = spawnToken(ai, sa);
 
@@ -359,7 +358,7 @@ public class TokenAi extends SpellAbilityAi {
         if (!sa.hasParam("TokenScript")) {
             throw new RuntimeException("Spell Ability has no TokenScript: " + sa);
         }
-        Card result = TokenInfo.getProtoType(sa.getParam("TokenScript"), sa);
+        Card result = TokenInfo.getProtoType(sa.getParam("TokenScript"), sa, ai);
 
         if (result == null) {
             throw new RuntimeException("don't find Token for TokenScript: " + sa.getParam("TokenScript"));

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

@@ -2,6 +2,7 @@ package forge.ai.ability;
 
 import java.util.List;
 
+import forge.ai.AiAttackController;
 import forge.ai.SpellAbilityAi;
 import forge.game.ability.AbilityUtils;
 import forge.game.card.Card;
@@ -28,7 +29,7 @@ public class TwoPilesAi extends SpellAbilityAi {
             valid = sa.getParam("ValidCards");
         }
 
-        final Player opp = ai.getWeakestOpponent();
+        final Player opp = AiAttackController.choosePreferredDefenderPlayer(ai);
 
         final TargetRestrictions tgt = sa.getTargetRestrictions();
         if (tgt != null) {

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

@@ -56,7 +56,6 @@ public class UnattachAllAi extends SpellAbilityAi {
     @Override
     protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
         final Card card = sa.getHostCard();
-        final Player opp = ai.getWeakestOpponent();
         // Check if there are any valid targets
         List<GameObject> targets = new ArrayList<>();
         final TargetRestrictions tgt = sa.getTargetRestrictions();
@@ -66,8 +65,8 @@ public class UnattachAllAi extends SpellAbilityAi {
 
         if (!mandatory && card.isEquipment() && !targets.isEmpty()) {
             Card newTarget = (Card) targets.get(0);
-            //don't equip human creatures
-            if (newTarget.getController().equals(opp)) {
+            //don't equip opponent creatures
+            if (!newTarget.getController().equals(ai)) {
                 return false;
             }
 

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

@@ -6,6 +6,7 @@ import java.util.Map;
 import com.google.common.base.Predicate;
 import com.google.common.base.Predicates;
 
+import forge.ai.AiAttackController;
 import forge.ai.ComputerUtil;
 import forge.ai.ComputerUtilAbility;
 import forge.ai.ComputerUtilCard;
@@ -65,7 +66,7 @@ public class UntapAi extends SpellAbilityAi {
 
         if (!sa.usesTargeting()) {
             final List<Card> pDefined = AbilityUtils.getDefinedCards(source, sa.getParam("Defined"), sa);
-            return pDefined == null || !pDefined.get(0).isUntapped() || pDefined.get(0).getController() != ai;
+            return pDefined.isEmpty() || (pDefined.get(0).isTapped() && pDefined.get(0).getController() == ai);
         } else {
             return untapPrefTargeting(ai, sa, false);
         }
@@ -81,9 +82,8 @@ public class UntapAi extends SpellAbilityAi {
                 return false;
             }
 
-            // TODO: use Defined to determine, if this is an unfavorable result
             final List<Card> pDefined = AbilityUtils.getDefinedCards(sa.getHostCard(), sa.getParam("Defined"), sa);
-            return pDefined == null || !pDefined.get(0).isUntapped() || pDefined.get(0).getController() != ai;
+            return pDefined.isEmpty() || (pDefined.get(0).isTapped() && pDefined.get(0).getController() == ai);
         } else {
             if (untapPrefTargeting(ai, sa, mandatory)) {
                 return true;
@@ -130,7 +130,8 @@ public class UntapAi extends SpellAbilityAi {
         Player targetController = ai;
 
         if (sa.isCurse()) {
-            targetController = ai.getWeakestOpponent();
+            // TODO search through all opponents, may need to check if different controllers allowed
+            targetController = AiAttackController.choosePreferredDefenderPlayer(ai);
         }
 
         CardCollection list = CardLists.getTargetableCards(targetController.getCardsIn(ZoneType.Battlefield), sa);
@@ -149,8 +150,7 @@ public class UntapAi extends SpellAbilityAi {
         }
 
         CardCollection untapList = targetUntapped ? list : CardLists.filter(list, Presets.TAPPED);
-        // filter out enchantments and planeswalkers, their tapped state doesn't
-        // matter.
+        // filter out enchantments and planeswalkers, their tapped state doesn't matter.
         final String[] tappablePermanents = {"Creature", "Land", "Artifact"};
         untapList = CardLists.getValidCards(untapList, tappablePermanents, source.getController(), source, sa);
 
@@ -374,7 +374,7 @@ public class UntapAi extends SpellAbilityAi {
                     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());
+                        ManaCostBeingPaid reduced = new ManaCostBeingPaid(ab.getPayCosts().getCostMana().getManaCostFor(ab), ab.getPayCosts().getCostMana().getRestriction());
                         reduced.decreaseShard(ManaCostShard.GENERIC, untappingCards.size());
                         if (ComputerUtilMana.canPayManaCost(reduced, ab, ai)) {
                             CardCollection manaLandsTapped = CardLists.filter(ai.getCardsIn(ZoneType.Battlefield),

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

@@ -8,6 +8,7 @@ import forge.game.card.CardLists;
 import forge.game.card.CardPredicates;
 import forge.game.phase.PhaseType;
 import forge.game.player.Player;
+import forge.game.player.PlayerCollection;
 import forge.game.spellability.AbilitySub;
 import forge.game.spellability.SpellAbility;
 import forge.game.zone.ZoneType;
@@ -29,6 +30,10 @@ public class UntapAllAi extends SpellAbilityAi {
                 valid = sa.getParam("ValidCards");
             }
             list = CardLists.getValidCards(list, valid.split(","), source.getController(), source, sa);
+            // don't untap if only opponent benefits
+            PlayerCollection goodControllers = aiPlayer.getAllies();
+            goodControllers.add(aiPlayer);
+            list = CardLists.filter(list, CardPredicates.isControlledByAnyOf(goodControllers));
             return !list.isEmpty();
         }
         return false;