Merge remote-tracking branch 'core/master' into rollback_Phase_dev

# Conflicts:
#	forge-gui-desktop/src/main/java/forge/screens/match/CMatchUI.java
#	forge-gui-mobile/src/forge/screens/match/MatchController.java
#	forge-gui/src/main/java/forge/gamemodes/net/server/NetGuiGame.java
#	forge-gui/src/main/java/forge/gui/interfaces/IGuiGame.java

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

@@ -17,16 +17,26 @@
  */
 package forge.ai;
 
+import java.util.ArrayList;
+import java.util.List;
+
 import com.google.common.base.Predicate;
 import com.google.common.base.Predicates;
 import com.google.common.collect.Lists;
+
 import forge.ai.ability.AnimateAi;
 import forge.card.CardTypeView;
 import forge.game.GameEntity;
 import forge.game.ability.AbilityUtils;
 import forge.game.ability.ApiType;
 import forge.game.ability.effects.ProtectEffect;
-import forge.game.card.*;
+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.combat.Combat;
 import forge.game.combat.CombatUtil;
 import forge.game.combat.GlobalAttackRestrictions;
@@ -43,9 +53,6 @@ import forge.util.MyRandom;
 import forge.util.TextUtil;
 import forge.util.collect.FCollectionView;
 
-import java.util.ArrayList;
-import java.util.List;
-
 
 //doesHumanAttackAndWin() uses the global variable AllZone.getComputerPlayer()
 /**

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

@@ -17,12 +17,23 @@
  */
 package forge.ai;
 
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Map;
+
 import com.google.common.base.Predicate;
 import com.google.common.base.Predicates;
+
 import forge.card.CardStateName;
-import forge.game.CardTraitBase;
 import forge.game.GameEntity;
-import forge.game.card.*;
+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.CounterEnumType;
 import forge.game.combat.Combat;
 import forge.game.combat.CombatUtil;
 import forge.game.keyword.Keyword;
@@ -33,8 +44,6 @@ import forge.game.zone.ZoneType;
 import forge.util.MyRandom;
 import forge.util.collect.FCollectionView;
 
-import java.util.*;
-
 
 /**
  * <p>
@@ -263,14 +272,14 @@ public class AiBlockController {
 
                         if (mode == TriggerType.DamageDone) {
                             if ((!trigParams.containsKey("ValidSource")
-                                        || CardTraitBase.matchesValid(attacker, trigParams.get("ValidSource").split(","), attacker))
+                                        || trigger.matchesValid(attacker, trigParams.get("ValidSource").split(",")))
                                     && attacker.getNetCombatDamage() > 0
                                     && (!trigParams.containsKey("ValidTarget")
-                                            || CardTraitBase.matchesValid(combat.getDefenderByAttacker(attacker), trigParams.get("ValidTarget").split(","), attacker))) {
+                                            || trigger.matchesValid(combat.getDefenderByAttacker(attacker), trigParams.get("ValidTarget").split(",")))) {
                                 value += 50;
                             }
                         } else if (mode == TriggerType.AttackerUnblocked) {
-                            if (CardTraitBase.matchesValid(attacker, trigParams.get("ValidCard").split(","), attacker)) {
+                            if (trigger.matchesValid(attacker, trigParams.get("ValidCard").split(","))) {
                                 value += 50;
                             }
                         }

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

@@ -18,13 +18,13 @@
 
 package forge.ai;
 
-import forge.game.card.Card;
-import forge.game.player.Player;
-
 import java.util.HashSet;
 import java.util.Iterator;
 import java.util.Set;
 
+import forge.game.card.Card;
+import forge.game.player.Player;
+
 /**
  * <p>
  * AiCardMemory class.

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

@@ -17,11 +17,19 @@
  */
 package forge.ai;
 
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+
 import com.esotericsoftware.minlog.Log;
 import com.google.common.base.Predicate;
 import com.google.common.base.Predicates;
 import com.google.common.collect.Iterables;
 import com.google.common.collect.Lists;
+
 import forge.ai.ability.ChangeZoneAi;
 import forge.ai.ability.ExploreAi;
 import forge.ai.simulation.SpellAbilityPicker;
@@ -30,16 +38,38 @@ import forge.card.mana.ManaCost;
 import forge.deck.CardPool;
 import forge.deck.Deck;
 import forge.deck.DeckSection;
-import forge.game.*;
+import forge.game.CardTraitBase;
+import forge.game.CardTraitPredicates;
+import forge.game.Direction;
+import forge.game.Game;
+import forge.game.GameActionUtil;
+import forge.game.GameEntity;
+import forge.game.GlobalRuleChange;
 import forge.game.ability.AbilityUtils;
 import forge.game.ability.ApiType;
 import forge.game.ability.SpellApiBased;
-import forge.game.card.*;
+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.CardPlayOption;
+import forge.game.card.CardPredicates;
 import forge.game.card.CardPredicates.Accessors;
 import forge.game.card.CardPredicates.Presets;
+import forge.game.card.CardUtil;
+import forge.game.card.CounterEnumType;
 import forge.game.combat.Combat;
 import forge.game.combat.CombatUtil;
-import forge.game.cost.*;
+import forge.game.cost.Cost;
+import forge.game.cost.CostAdjustment;
+import forge.game.cost.CostDiscard;
+import forge.game.cost.CostPart;
+import forge.game.cost.CostPayEnergy;
+import forge.game.cost.CostPayLife;
+import forge.game.cost.CostPutCounter;
+import forge.game.cost.CostRemoveCounter;
+import forge.game.cost.CostSacrifice;
 import forge.game.keyword.Keyword;
 import forge.game.mana.ManaCostBeingPaid;
 import forge.game.phase.PhaseType;
@@ -48,7 +78,15 @@ import forge.game.player.PlayerActionConfirmMode;
 import forge.game.replacement.ReplaceMoved;
 import forge.game.replacement.ReplacementEffect;
 import forge.game.replacement.ReplacementType;
-import forge.game.spellability.*;
+import forge.game.spellability.AbilitySub;
+import forge.game.spellability.LandAbility;
+import forge.game.spellability.OptionalCost;
+import forge.game.spellability.OptionalCostValue;
+import forge.game.spellability.Spell;
+import forge.game.spellability.SpellAbility;
+import forge.game.spellability.SpellAbilityCondition;
+import forge.game.spellability.SpellAbilityPredicates;
+import forge.game.spellability.SpellPermanent;
 import forge.game.staticability.StaticAbility;
 import forge.game.trigger.Trigger;
 import forge.game.trigger.TriggerType;
@@ -56,16 +94,13 @@ import forge.game.trigger.WrappedAbility;
 import forge.game.zone.ZoneType;
 import forge.item.PaperCard;
 import forge.util.Aggregates;
+import forge.util.ComparatorUtil;
 import forge.util.Expressions;
 import forge.util.MyRandom;
-import forge.util.ComparatorUtil;
 import forge.util.collect.FCollectionView;
 import io.sentry.Sentry;
 import io.sentry.event.BreadcrumbBuilder;
 
-import java.util.*;
-import java.util.Map.Entry;
-
 /**
  * <p>
  * AiController class.

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

@@ -1,5 +1,7 @@
 package forge.ai;
 
+import static forge.ai.ComputerUtilCard.getBestCreatureAI;
+
 import java.util.Collections;
 import java.util.List;
 import java.util.Map;
@@ -21,7 +23,36 @@ import forge.game.card.CardLists;
 import forge.game.card.CardPredicates;
 import forge.game.card.CounterEnumType;
 import forge.game.card.CounterType;
-import forge.game.cost.*;
+import forge.game.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;
@@ -31,8 +62,6 @@ import forge.util.Aggregates;
 import forge.util.TextUtil;
 import forge.util.collect.FCollectionView;
 
-import static forge.ai.ComputerUtilCard.getBestCreatureAI;
-
 public class AiCostDecision extends CostDecisionMakerBase {
     private final SpellAbility ability;
     private final Card source;

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

@@ -17,19 +17,19 @@
  */
 package forge.ai;
 
-import forge.LobbyPlayer;
-import forge.util.Aggregates;
-import forge.util.FileUtil;
-
-import forge.util.TextUtil;
-import org.apache.commons.lang3.ArrayUtils;
-
 import java.io.File;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 
+import org.apache.commons.lang3.ArrayUtils;
+
+import forge.LobbyPlayer;
+import forge.util.Aggregates;
+import forge.util.FileUtil;
+import forge.util.TextUtil;
+
 /**
  * Holds default AI personality profile values in an enum.
  * Loads profile from the given text file when setProfile is called.

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

@@ -17,12 +17,22 @@
  */
 package forge.ai;
 
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+
+import org.apache.commons.lang3.StringUtils;
+
 import com.google.common.base.Predicate;
 import com.google.common.base.Predicates;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.Iterables;
 import com.google.common.collect.Lists;
 import com.google.common.collect.Multimap;
+
 import forge.ai.ability.ChooseGenericEffectAi;
 import forge.ai.ability.ProtectAi;
 import forge.ai.ability.TokenAi;
@@ -30,16 +40,33 @@ import forge.card.CardStateName;
 import forge.card.CardType;
 import forge.card.ColorSet;
 import forge.card.MagicColor;
-import forge.game.*;
+import forge.game.CardTraitPredicates;
+import forge.game.Game;
+import forge.game.GameActionUtil;
+import forge.game.GameObject;
+import forge.game.GameType;
 import forge.game.ability.AbilityKey;
 import forge.game.ability.AbilityUtils;
 import forge.game.ability.ApiType;
 import forge.game.ability.effects.CharmEffect;
-import forge.game.card.*;
+import forge.game.card.Card;
+import forge.game.card.CardCollection;
+import forge.game.card.CardCollectionView;
+import forge.game.card.CardLists;
+import forge.game.card.CardPredicates;
 import forge.game.card.CardPredicates.Presets;
+import forge.game.card.CardState;
+import forge.game.card.CardUtil;
+import forge.game.card.CounterEnumType;
+import forge.game.card.CounterType;
 import forge.game.combat.Combat;
 import forge.game.combat.CombatUtil;
-import forge.game.cost.*;
+import forge.game.cost.Cost;
+import forge.game.cost.CostDiscard;
+import forge.game.cost.CostPart;
+import forge.game.cost.CostPayment;
+import forge.game.cost.CostPutCounter;
+import forge.game.cost.CostSacrifice;
 import forge.game.keyword.Keyword;
 import forge.game.phase.PhaseHandler;
 import forge.game.phase.PhaseType;
@@ -61,9 +88,6 @@ import forge.util.Aggregates;
 import forge.util.MyRandom;
 import forge.util.TextUtil;
 import forge.util.collect.FCollection;
-import org.apache.commons.lang3.StringUtils;
-
-import java.util.*;
 
 
 /**
@@ -2056,8 +2080,8 @@ public class ComputerUtil {
         final CardCollection candidates = new CardCollection();
         final CardCollectionView handList = ai.getCardsIn(ZoneType.Hand);
 
-        final CardCollection lands = CardLists.getValidCards(handList, "Card.Land", ai, null);
+        final CardCollection lands = CardLists.getValidCards(handList, "Card.Land", ai, null, null);
-        final CardCollection nonLands = CardLists.getValidCards(handList, "Card.nonLand", ai, null);
+        final CardCollection nonLands = CardLists.getValidCards(handList, "Card.nonLand", ai, null, null);
         CardLists.sortByCmcDesc(nonLands);
 
         if (lands.size() >= 3 && lands.size() <= 4) {
@@ -2996,7 +3020,7 @@ public class ComputerUtil {
                     }
                 });
             } else {
-                list = CardLists.getValidCards(srcList, sa.getParam("AITgts"), sa.getActivatingPlayer(), source);
+                list = CardLists.getValidCards(srcList, sa.getParam("AITgts"), sa.getActivatingPlayer(), source, sa);
             }
 
             if (!list.isEmpty() || sa.hasParam("AITgtsStrict") || alwaysStrict) {

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

@@ -1,7 +1,11 @@
 package forge.ai;
 
+import java.util.Iterator;
+import java.util.List;
+
 import com.google.common.base.Predicate;
 import com.google.common.collect.Lists;
+
 import forge.card.CardStateName;
 import forge.game.Game;
 import forge.game.GameActionUtil;
@@ -17,9 +21,6 @@ import forge.game.spellability.SpellAbility;
 import forge.game.spellability.SpellAbilityStackInstance;
 import forge.game.zone.ZoneType;
 
-import java.util.Iterator;
-import java.util.List;
-
 public class ComputerUtilAbility {
     public static CardCollection getAvailableLandsToPlay(final Game game, final Player player) {
         if (!game.getStack().isEmpty() || !game.getPhaseHandler().getPhase().isMain()) {

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

@@ -1,5 +1,20 @@
 package forge.ai;
 
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Set;
+
+import org.apache.commons.lang3.StringUtils;
+import org.apache.commons.lang3.tuple.MutablePair;
+import org.apache.commons.lang3.tuple.Pair;
+
 import com.google.common.base.Predicate;
 import com.google.common.base.Predicates;
 import com.google.common.collect.Iterables;
@@ -18,7 +33,16 @@ import forge.game.Game;
 import forge.game.GameObject;
 import forge.game.ability.AbilityUtils;
 import forge.game.ability.ApiType;
-import forge.game.card.*;
+import forge.game.card.Card;
+import forge.game.card.CardCollection;
+import forge.game.card.CardCollectionView;
+import forge.game.card.CardFactory;
+import forge.game.card.CardFactoryUtil;
+import forge.game.card.CardLists;
+import forge.game.card.CardPredicates;
+import forge.game.card.CardUtil;
+import forge.game.card.CounterEnumType;
+import forge.game.card.CounterType;
 import forge.game.combat.Combat;
 import forge.game.combat.CombatUtil;
 import forge.game.cost.Cost;
@@ -40,12 +64,6 @@ import forge.item.PaperCard;
 import forge.util.Aggregates;
 import forge.util.Expressions;
 import forge.util.MyRandom;
-import org.apache.commons.lang3.StringUtils;
-import org.apache.commons.lang3.tuple.MutablePair;
-import org.apache.commons.lang3.tuple.Pair;
-
-import java.util.*;
-import java.util.Map.Entry;
 
 public class ComputerUtilCard {
     public static Card getMostExpensivePermanentAI(final CardCollectionView list, final SpellAbility spell, final boolean targeted) {

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

@@ -25,13 +25,19 @@ import com.google.common.collect.Iterables;
 import com.google.common.collect.Lists;
 import com.google.common.collect.Maps;
 
-import forge.game.CardTraitBase;
 import forge.game.Game;
 import forge.game.GameEntity;
 import forge.game.ability.AbilityKey;
 import forge.game.ability.AbilityUtils;
 import forge.game.ability.ApiType;
-import forge.game.card.*;
+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;
+import forge.game.card.CounterEnumType;
 import forge.game.combat.Combat;
 import forge.game.combat.CombatUtil;
 import forge.game.cost.CostPayment;
@@ -790,9 +796,9 @@ public class ComputerUtilCombat {
                 return false; // The trigger should have triggered already
             }
             if (trigParams.containsKey("ValidCard")) {
-                if (!CardTraitBase.matchesValid(attacker, trigParams.get("ValidCard").split(","), source)
+                if (!trigger.matchesValid(attacker, trigParams.get("ValidCard").split(","))
-                        && !(combat.isAttacking(source) && CardTraitBase.matchesValid(source,
+                        && !(combat.isAttacking(source) && trigger.matchesValid(source,
-                        trigParams.get("ValidCard").split(","), source)
+                        trigParams.get("ValidCard").split(","))
                             && !trigParams.containsKey("Alone"))) {
                     return false;
                 }
@@ -800,7 +806,7 @@ public class ComputerUtilCombat {
             if (trigParams.containsKey("Attacked")) {
             	if (combat.isAttacking(attacker)) {
 	            	GameEntity attacked = combat.getDefenderByAttacker(attacker);
-	                if (!CardTraitBase.matchesValid(attacked, trigParams.get("Attacked").split(","), source)) {
+	                if (!trigger.matchesValid(attacked, trigParams.get("Attacked").split(","))) {
 	                    return false;
 	                }
             	} else {
@@ -820,7 +826,7 @@ public class ComputerUtilCombat {
         if ((defender == null) && mode == TriggerType.AttackerUnblocked) {
             willTrigger = true;
             if (trigParams.containsKey("ValidCard")) {
-                if (!CardTraitBase.matchesValid(attacker, trigParams.get("ValidCard").split(","), source)) {
+                if (!trigger.matchesValid(attacker, trigParams.get("ValidCard").split(","))) {
                     return false;
                 }
             }
@@ -842,7 +848,7 @@ public class ComputerUtilCombat {
                         return false;
                     }
                 }
-                if (!CardTraitBase.matchesValid(attacker, validBlocked.split(","), source)) {
+                if (!trigger.matchesValid(attacker, validBlocked.split(","))) {
                     return false;
                 }
             }
@@ -856,35 +862,35 @@ public class ComputerUtilCombat {
                         return false;
                     }
                 }
-                if (!CardTraitBase.matchesValid(defender, validBlocker.split(","), source)) {
+                if (!trigger.matchesValid(defender, validBlocker.split(","))) {
                     return false;
                 }
             }
         } else if (mode == TriggerType.AttackerBlocked || mode == TriggerType.AttackerBlockedByCreature) {
             willTrigger = true;
             if (trigParams.containsKey("ValidBlocker")) {
-                if (!CardTraitBase.matchesValid(defender, trigParams.get("ValidBlocker").split(","), source)) {
+                if (!trigger.matchesValid(defender, trigParams.get("ValidBlocker").split(","))) {
                     return false;
                 }
             }
             if (trigParams.containsKey("ValidCard")) {
-                if (!CardTraitBase.matchesValid(attacker, trigParams.get("ValidCard").split(","), source)) {
+                if (!trigger.matchesValid(attacker, trigParams.get("ValidCard").split(","))) {
                     return false;
                 }
             }
         } else if (mode == TriggerType.DamageDone) {
             willTrigger = true;
             if (trigParams.containsKey("ValidSource")) {
-                if (!(CardTraitBase.matchesValid(defender, trigParams.get("ValidSource").split(","), source)
+                if (!(trigger.matchesValid(defender, trigParams.get("ValidSource").split(","))
                         && defender.getNetCombatDamage() > 0
                         && (!trigParams.containsKey("ValidTarget")
-                                || CardTraitBase.matchesValid(attacker, trigParams.get("ValidTarget").split(","), source)))) {
+                                || trigger.matchesValid(attacker, trigParams.get("ValidTarget").split(","))))) {
                     return false;
                 }
-                if (!(CardTraitBase.matchesValid(attacker, trigParams.get("ValidSource").split(","), source)
+                if (!(trigger.matchesValid(attacker, trigParams.get("ValidSource").split(","))
                         && attacker.getNetCombatDamage() > 0
                         && (!trigParams.containsKey("ValidTarget")
-                        || CardTraitBase.matchesValid(defender, trigParams.get("ValidTarget").split(","), source)))) {
+                        || trigger.matchesValid(defender, trigParams.get("ValidTarget").split(","))))) {
                     return false;
                 }
             }

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

@@ -1,16 +1,41 @@
 package forge.ai;
 
+import java.util.List;
+import java.util.Set;
+
+import org.apache.commons.lang3.ObjectUtils;
+import org.apache.commons.lang3.StringUtils;
+
 import com.google.common.base.Predicate;
 import com.google.common.collect.Lists;
 import com.google.common.collect.Sets;
+
 import forge.ai.ability.AnimateAi;
 import forge.card.ColorSet;
 import forge.game.Game;
 import forge.game.ability.AbilityUtils;
-import forge.game.card.*;
+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.Presets;
+import forge.game.card.CardUtil;
+import forge.game.card.CounterEnumType;
+import forge.game.card.CounterType;
 import forge.game.combat.Combat;
-import forge.game.cost.*;
+import forge.game.cost.Cost;
+import forge.game.cost.CostDamage;
+import forge.game.cost.CostDiscard;
+import forge.game.cost.CostPart;
+import forge.game.cost.CostPayLife;
+import forge.game.cost.CostPayment;
+import forge.game.cost.CostPutCounter;
+import forge.game.cost.CostRemoveAnyCounter;
+import forge.game.cost.CostRemoveCounter;
+import forge.game.cost.CostSacrifice;
+import forge.game.cost.CostTapType;
+import forge.game.cost.PaymentDecision;
 import forge.game.keyword.Keyword;
 import forge.game.player.Player;
 import forge.game.spellability.Spell;
@@ -20,12 +45,6 @@ import forge.util.MyRandom;
 import forge.util.TextUtil;
 import forge.util.collect.FCollectionView;
 
-import org.apache.commons.lang3.ObjectUtils;
-import org.apache.commons.lang3.StringUtils;
-
-import java.util.List;
-import java.util.Set;
-
 
 public class ComputerUtilCost {
 

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

@@ -1,8 +1,26 @@
 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.*;
+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 forge.ai.ability.AnimateAi;
 import forge.card.ColorSet;
 import forge.card.MagicColor;
@@ -13,11 +31,23 @@ import forge.card.mana.ManaCostShard;
 import forge.game.CardTraitPredicates;
 import forge.game.Game;
 import forge.game.GameActionUtil;
-import forge.game.ability.*;
+import forge.game.ability.AbilityKey;
-import forge.game.card.*;
+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.combat.Combat;
 import forge.game.combat.CombatUtil;
-import forge.game.cost.*;
+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.keyword.Keyword;
 import forge.game.mana.Mana;
 import forge.game.mana.ManaCostBeingPaid;
@@ -37,10 +67,6 @@ 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;

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

@@ -1,9 +1,25 @@
 package forge.ai;
 
+import java.io.BufferedReader;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.EnumMap;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Set;
+
+import 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;
@@ -13,7 +29,12 @@ import forge.game.GameObject;
 import forge.game.ability.AbilityFactory;
 import forge.game.ability.AbilityKey;
 import forge.game.ability.effects.DetachedCardEffect;
-import forge.game.card.*;
+import forge.game.card.Card;
+import forge.game.card.CardCloneStates;
+import forge.game.card.CardCollection;
+import forge.game.card.CardCollectionView;
+import forge.game.card.CardFactory;
+import forge.game.card.CounterType;
 import forge.game.card.token.TokenInfo;
 import forge.game.combat.Combat;
 import forge.game.combat.CombatUtil;
@@ -32,13 +53,6 @@ import forge.item.IPaperCard;
 import forge.item.PaperCard;
 import forge.util.TextUtil;
 import forge.util.collect.FCollectionView;
-import org.apache.commons.lang3.StringUtils;
-
-import java.io.BufferedReader;
-import java.io.InputStream;
-import java.io.InputStreamReader;
-import java.util.*;
-import java.util.Map.Entry;
 
 public abstract class GameState {
     private static final Map<ZoneType, String> ZONES = new HashMap<>();

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

@@ -1,11 +1,24 @@
 package forge.ai;
 
+import java.security.InvalidParameterException;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+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;
+
 import com.google.common.base.Predicate;
 import com.google.common.base.Predicates;
 import com.google.common.collect.Iterables;
 import com.google.common.collect.ListMultimap;
 import com.google.common.collect.Lists;
 import com.google.common.collect.Multimap;
+
 import forge.LobbyPlayer;
 import forge.ai.ability.ProtectAi;
 import forge.card.CardStateName;
@@ -21,19 +34,43 @@ import forge.game.GameObject;
 import forge.game.GameType;
 import forge.game.ability.AbilityUtils;
 import forge.game.ability.ApiType;
-import forge.game.card.*;
+import forge.game.card.Card;
+import forge.game.card.CardCollection;
+import forge.game.card.CardCollectionView;
+import forge.game.card.CardLists;
+import forge.game.card.CardPredicates;
 import forge.game.card.CardPredicates.Presets;
+import forge.game.card.CardUtil;
+import forge.game.card.CardView;
+import forge.game.card.CounterType;
 import forge.game.combat.Combat;
-import forge.game.cost.*;
+import forge.game.cost.Cost;
+import forge.game.cost.CostAdjustment;
+import forge.game.cost.CostExile;
+import forge.game.cost.CostPart;
+import forge.game.cost.CostPartMana;
 import forge.game.keyword.KeywordInterface;
 import forge.game.mana.Mana;
 import forge.game.mana.ManaConversionMatrix;
 import forge.game.mana.ManaCostBeingPaid;
 import forge.game.phase.PhaseHandler;
 import forge.game.phase.PhaseType;
-import forge.game.player.*;
+import forge.game.player.DelayedReveal;
+import forge.game.player.Player;
+import forge.game.player.PlayerActionConfirmMode;
+import forge.game.player.PlayerController;
+import forge.game.player.PlayerView;
 import forge.game.replacement.ReplacementEffect;
-import forge.game.spellability.*;
+import forge.game.spellability.Ability;
+import forge.game.spellability.AbilityStatic;
+import forge.game.spellability.AbilitySub;
+import forge.game.spellability.LandAbility;
+import forge.game.spellability.OptionalCost;
+import forge.game.spellability.OptionalCostValue;
+import forge.game.spellability.Spell;
+import forge.game.spellability.SpellAbility;
+import forge.game.spellability.SpellAbilityStackInstance;
+import forge.game.spellability.TargetChoices;
 import forge.game.trigger.WrappedAbility;
 import forge.game.zone.ZoneType;
 import forge.item.PaperCard;
@@ -42,12 +79,6 @@ import forge.util.ITriggerEvent;
 import forge.util.MyRandom;
 import forge.util.collect.FCollection;
 import forge.util.collect.FCollectionView;
-import org.apache.commons.lang3.StringUtils;
-import org.apache.commons.lang3.tuple.ImmutablePair;
-import org.apache.commons.lang3.tuple.Pair;
-
-import java.security.InvalidParameterException;
-import java.util.*;
 
 
 /** 
@@ -1159,7 +1190,7 @@ public class PlayerControllerAi extends PlayerController {
             } else if (logic.equals("MostProminentInHumanDeck")) {
                 return ComputerUtilCard.getMostProminentCardName(oppLibrary);
             } else if (logic.equals("MostProminentCreatureInComputerDeck")) {
-                CardCollectionView cards = CardLists.getValidCards(aiLibrary, "Creature", player, sa.getHostCard());
+                CardCollectionView cards = CardLists.getValidCards(aiLibrary, "Creature", player, sa.getHostCard(), sa);
                 return ComputerUtilCard.getMostProminentCardName(cards);
             } else if (logic.equals("BestCreatureInComputerDeck")) {
                 Card bestCreature = ComputerUtilCard.getBestCreatureAI(aiLibrary);
@@ -1167,7 +1198,7 @@ public class PlayerControllerAi extends PlayerController {
             } else if (logic.equals("RandomInComputerDeck")) {
                 return Aggregates.random(aiLibrary).getName();
             } else if (logic.equals("MostProminentSpellInComputerDeck")) {
-                CardCollectionView cards = CardLists.getValidCards(aiLibrary, "Card.Instant,Card.Sorcery", player, sa.getHostCard());
+                CardCollectionView cards = CardLists.getValidCards(aiLibrary, "Card.Instant,Card.Sorcery", player, sa.getHostCard(), sa);
                 return ComputerUtilCard.getMostProminentCardName(cards);
             } else if (logic.equals("CursedScroll")) {
                 return SpecialCardAi.CursedScroll.chooseCard(player, sa);

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

@@ -9,7 +9,13 @@ import forge.ai.ability.TokenAi;
 import forge.game.Game;
 import forge.game.ability.AbilityUtils;
 import forge.game.ability.ApiType;
-import forge.game.card.*;
+import forge.game.card.Card;
+import forge.game.card.CardCollection;
+import forge.game.card.CardLists;
+import forge.game.card.CardPredicates;
+import forge.game.card.CardUtil;
+import forge.game.card.CounterEnumType;
+import forge.game.card.CounterType;
 import forge.game.combat.Combat;
 import forge.game.keyword.Keyword;
 import forge.game.phase.PhaseHandler;

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

@@ -17,10 +17,17 @@
  */
 package forge.ai;
 
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+import org.apache.commons.lang3.tuple.Pair;
+
 import com.google.common.base.Predicate;
 import com.google.common.base.Predicates;
 import com.google.common.collect.Iterables;
 import com.google.common.collect.Lists;
+
 import forge.ai.ability.AnimateAi;
 import forge.card.ColorSet;
 import forge.card.MagicColor;
@@ -29,7 +36,14 @@ import forge.game.Game;
 import forge.game.GameType;
 import forge.game.ability.AbilityUtils;
 import forge.game.ability.ApiType;
-import forge.game.card.*;
+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;
+import forge.game.card.CounterEnumType;
 import forge.game.combat.Combat;
 import forge.game.combat.CombatUtil;
 import forge.game.cost.CostPart;
@@ -50,11 +64,6 @@ import forge.util.MyRandom;
 import forge.util.TextUtil;
 import forge.util.maps.LinkedHashMapToAmount;
 import forge.util.maps.MapToAmount;
-import org.apache.commons.lang3.tuple.Pair;
-
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.List;
 
 /**
  * Special logic for individual cards

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

@@ -1,7 +1,12 @@
 package forge.ai;
 
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+
 import com.google.common.collect.Iterables;
 import com.google.common.collect.Lists;
+
 import forge.card.CardStateName;
 import forge.card.ICardFace;
 import forge.card.mana.ManaCost;
@@ -21,10 +26,6 @@ import forge.game.spellability.SpellAbility;
 import forge.game.spellability.SpellAbilityCondition;
 import forge.util.MyRandom;
 
-import java.util.Collection;
-import java.util.List;
-import java.util.Map;
-
 /**
  * Base class for API-specific AI logic
  * <p>

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

@@ -1,13 +1,14 @@
 package forge.ai;
 
+import java.util.Map;
+
 import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.Maps;
+
 import forge.ai.ability.*;
 import forge.game.ability.ApiType;
 import forge.util.ReflectionUtil;
 
-import java.util.Map;
-
 public enum SpellApiToAi {
     Converter;
 
@@ -152,8 +153,8 @@ public enum SpellApiToAi {
             .put(ApiType.SetLife, LifeSetAi.class)
             .put(ApiType.SetState, SetStateAi.class)
             .put(ApiType.Shuffle, ShuffleAi.class)
+            .put(ApiType.SkipPhase, SkipPhaseAi.class)
             .put(ApiType.SkipTurn, SkipTurnAi.class)
-            .put(ApiType.StoreMap, StoreMapAi.class)
             .put(ApiType.StoreSVar, StoreSVarAi.class)
             .put(ApiType.Subgame, AlwaysPlayAi.class)
             .put(ApiType.Surveil, SurveilAi.class)

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

@@ -1,5 +1,8 @@
 package forge.ai.ability;
 
+import java.util.List;
+import java.util.Map;
+
 import forge.ai.SpellAbilityAi;
 import forge.game.ability.AbilityUtils;
 import forge.game.card.Card;
@@ -10,9 +13,6 @@ import forge.game.spellability.TargetRestrictions;
 import forge.game.zone.ZoneType;
 import forge.util.MyRandom;
 
-import java.util.List;
-import java.util.Map;
-
 public class ActivateAbilityAi extends SpellAbilityAi {
 
     @Override

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

@@ -17,15 +17,15 @@
  */
 package forge.ai.ability;
 
+import java.util.List;
+
+import org.apache.commons.lang3.StringUtils;
+
 import forge.ai.SpellAbilityAi;
 import forge.game.ability.AbilityUtils;
 import forge.game.player.Player;
 import forge.game.spellability.SpellAbility;
 
-import java.util.List;
-
-import org.apache.commons.lang3.StringUtils;
-
 /**
  * <p>
  * AbilityFactory_Turns class.

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

@@ -9,7 +9,11 @@ import forge.ai.ComputerUtilCard;
 import forge.ai.SpellAbilityAi;
 import forge.game.Game;
 import forge.game.ability.AbilityUtils;
-import forge.game.card.*;
+import forge.game.card.Card;
+import forge.game.card.CardCollection;
+import forge.game.card.CardLists;
+import forge.game.card.CardPredicates;
+import forge.game.card.CounterEnumType;
 import forge.game.card.token.TokenInfo;
 import forge.game.phase.PhaseHandler;
 import forge.game.player.Player;

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

@@ -1,14 +1,31 @@
 package forge.ai.ability;
 
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+
 import com.google.common.collect.Iterables;
 import com.google.common.collect.Lists;
 import com.google.common.collect.Maps;
-import forge.ai.*;
+
+import forge.ai.AiCardMemory;
+import forge.ai.ComputerUtil;
+import forge.ai.ComputerUtilCard;
+import forge.ai.ComputerUtilCost;
+import forge.ai.ComputerUtilMana;
+import forge.ai.SpellAbilityAi;
 import forge.card.CardType;
 import forge.game.Game;
 import forge.game.ability.AbilityUtils;
 import forge.game.ability.ApiType;
-import forge.game.card.*;
+import forge.game.ability.effects.AnimateEffectBase;
+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.CardTraitChanges;
+import forge.game.card.CardUtil;
 import forge.game.cost.CostPutCounter;
 import forge.game.phase.PhaseHandler;
 import forge.game.phase.PhaseType;
@@ -19,12 +36,6 @@ import forge.game.staticability.StaticAbilityContinuous;
 import forge.game.staticability.StaticAbilityLayer;
 import forge.game.zone.ZoneType;
 
-import java.util.Arrays;
-import java.util.List;
-import java.util.Map;
-
-import forge.game.ability.effects.AnimateEffectBase;
-
 /**
  * <p>
  * AbilityFactoryAnimate class.

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

@@ -1,17 +1,39 @@
 package forge.ai.ability;
 
+import java.util.ArrayList;
+import java.util.Arrays;
+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;
 import com.google.common.collect.Sets;
-import forge.ai.*;
+
+import forge.ai.AiCardMemory;
+import forge.ai.AiController;
+import forge.ai.AiProps;
+import forge.ai.ComputerUtil;
+import forge.ai.ComputerUtilAbility;
+import forge.ai.ComputerUtilCard;
+import forge.ai.ComputerUtilCombat;
+import forge.ai.ComputerUtilCost;
+import forge.ai.PlayerControllerAi;
+import forge.ai.SpecialCardAi;
+import forge.ai.SpellAbilityAi;
 import forge.game.Game;
 import forge.game.GameObject;
 import forge.game.GlobalRuleChange;
 import forge.game.ability.AbilityFactory;
 import forge.game.ability.AbilityUtils;
 import forge.game.ability.ApiType;
-import forge.game.card.*;
+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.combat.Combat;
 import forge.game.combat.CombatUtil;
 import forge.game.cost.Cost;
@@ -31,8 +53,6 @@ import forge.game.trigger.TriggerType;
 import forge.game.zone.ZoneType;
 import forge.util.MyRandom;
 
-import java.util.*;
-
 public class AttachAi extends SpellAbilityAi {
 
     /* (non-Javadoc)

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

@@ -1,13 +1,13 @@
 package forge.ai.ability;
 
 
+import java.util.List;
+import java.util.Map;
+
 import forge.ai.SpellAbilityAi;
 import forge.game.player.Player;
 import forge.game.spellability.SpellAbility;
 
-import java.util.List;
-import java.util.Map;
-
 public class CanPlayAsDrawbackAi extends SpellAbilityAi {
 
     /* (non-Javadoc)

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

@@ -1,5 +1,8 @@
 package forge.ai.ability;
 
+import java.util.Collection;
+import java.util.Map;
+
 import forge.ai.SpellAbilityAi;
 import forge.game.GameEntity;
 import forge.game.player.Player;
@@ -7,9 +10,6 @@ import forge.game.player.PlayerCollection;
 import forge.game.player.PlayerPredicates;
 import forge.game.spellability.SpellAbility;
 
-import java.util.Collection;
-import java.util.Map;
-
 public class ChangeCombatantsAi extends SpellAbilityAi {
     /* (non-Javadoc)
      * @see forge.card.abilityfactory.SpellAiLogic#canPlayAI(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility)

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

@@ -1,11 +1,35 @@
 package forge.ai.ability;
 
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Map;
+
+import org.apache.commons.lang3.StringUtils;
+
 import com.google.common.base.Predicate;
 import com.google.common.base.Predicates;
 import com.google.common.collect.Iterables;
 import com.google.common.collect.Lists;
 import com.google.common.collect.Maps;
-import forge.ai.*;
+
+import forge.ai.AiBlockController;
+import forge.ai.AiCardMemory;
+import forge.ai.AiController;
+import forge.ai.AiProps;
+import forge.ai.ComputerUtil;
+import forge.ai.ComputerUtilAbility;
+import forge.ai.ComputerUtilCard;
+import forge.ai.ComputerUtilCombat;
+import forge.ai.ComputerUtilCost;
+import forge.ai.ComputerUtilMana;
+import forge.ai.PlayerControllerAi;
+import forge.ai.SpecialAiLogic;
+import forge.ai.SpecialCardAi;
+import forge.ai.SpellAbilityAi;
+import forge.ai.SpellApiToAi;
 import forge.card.MagicColor;
 import forge.game.Game;
 import forge.game.GameObject;
@@ -13,8 +37,14 @@ import forge.game.GlobalRuleChange;
 import forge.game.ability.AbilityKey;
 import forge.game.ability.AbilityUtils;
 import forge.game.ability.ApiType;
-import forge.game.card.*;
+import forge.game.card.Card;
+import forge.game.card.CardCollection;
+import forge.game.card.CardCollectionView;
+import forge.game.card.CardLists;
+import forge.game.card.CardPredicates;
 import forge.game.card.CardPredicates.Presets;
+import forge.game.card.CardUtil;
+import forge.game.card.CounterEnumType;
 import forge.game.combat.Combat;
 import forge.game.cost.Cost;
 import forge.game.cost.CostDiscard;
@@ -29,9 +59,6 @@ import forge.game.spellability.SpellAbility;
 import forge.game.spellability.TargetRestrictions;
 import forge.game.zone.ZoneType;
 import forge.util.MyRandom;
-import org.apache.commons.lang3.StringUtils;
-
-import java.util.*;
 
 public class ChangeZoneAi extends SpellAbilityAi {
     /*
@@ -357,7 +384,7 @@ public class ChangeZoneAi extends SpellAbilityAi {
 
             if (type != null && p == ai) {
                 // AI only "knows" about his information
-                list = CardLists.getValidCards(list, type, source.getController(), source);
+                list = CardLists.getValidCards(list, type, source.getController(), source, sa);
                 list = CardLists.filter(list, new Predicate<Card>() {
                     @Override
                     public boolean apply(final Card c) {
@@ -370,7 +397,7 @@ public class ChangeZoneAi extends SpellAbilityAi {
             }
             // TODO: prevent ai seaching its own library when Ob Nixilis, Unshackled is in play
             if (origin != null && origin.isKnown()) {
-                list = CardLists.getValidCards(list, type, source.getController(), source);
+                list = CardLists.getValidCards(list, type, source.getController(), source, sa);
             }
 
             if (!activateForCost && list.isEmpty()) {
@@ -1107,7 +1134,7 @@ public class ChangeZoneAi extends SpellAbilityAi {
 
         // Only care about combatants during combat
         if (game.getPhaseHandler().inCombat() && origin.contains(ZoneType.Battlefield)) {
-            CardCollection newList = CardLists.getValidCards(list, "Card.attacking,Card.blocking", null, null);
+            CardCollection newList = CardLists.getValidCards(list, "Card.attacking,Card.blocking", null, null, null);
             if (!newList.isEmpty() || !sa.isTrigger()) {
                 list = newList;
             }
@@ -1705,7 +1732,7 @@ public class ChangeZoneAi extends SpellAbilityAi {
         Card source = sa.getHostCard();
         String definedSac = StringUtils.split(source.getSVar("AIPreference"), "$")[1];
 
-        CardCollection listToSac = CardLists.filter(ai.getCardsIn(ZoneType.Battlefield), CardPredicates.restriction(definedSac.split(","), ai, source, sa));
+        CardCollection listToSac = CardLists.getValidCards(ai.getCardsIn(ZoneType.Battlefield), definedSac, ai, source, sa);
         listToSac.sort(Collections.reverseOrder(CardLists.CmcComparatorInv));
 
         CardCollection listToRet = CardLists.filter(ai.getCardsIn(ZoneType.Graveyard), Presets.CREATURES);
@@ -1742,7 +1769,7 @@ public class ChangeZoneAi extends SpellAbilityAi {
         String definedGoal = sa.getParam("ChangeType");
         boolean anyCMC = !definedGoal.contains(".cmc");
 
-        CardCollection listToSac = CardLists.filter(ai.getCardsIn(ZoneType.Battlefield), CardPredicates.restriction(definedSac.split(","), ai, source, sa));
+        CardCollection listToSac = CardLists.getValidCards(ai.getCardsIn(ZoneType.Battlefield), definedSac, ai, source, sa);
         listToSac.sort(!sacWorst ? CardLists.CmcComparatorInv : Collections.reverseOrder(CardLists.CmcComparatorInv));
 
         for (Card sacCandidate : listToSac) {
@@ -1756,12 +1783,12 @@ public class ChangeZoneAi extends SpellAbilityAi {
                 curGoal = definedGoal.replace("X", String.format("%d", goalCMC));
             }
 
-            CardCollection listGoal = CardLists.filter(ai.getCardsIn(ZoneType.Library), CardPredicates.restriction(curGoal.split(","), ai, source, sa));
+            CardCollection listGoal = CardLists.getValidCards(ai.getCardsIn(ZoneType.Library), curGoal, ai, source, sa);
 
             if (!anyCMC) {
-                listGoal = CardLists.getValidCards(listGoal, curGoal, source.getController(), source);
+                listGoal = CardLists.getValidCards(listGoal, curGoal, source.getController(), source, sa);
             } else {
-                listGoal = CardLists.getValidCards(listGoal, curGoal + (curGoal.contains(".") ? "+" : ".") + "cmcGE" + goalCMC, source.getController(), source);
+                listGoal = CardLists.getValidCards(listGoal, curGoal + (curGoal.contains(".") ? "+" : ".") + "cmcGE" + goalCMC, source.getController(), source, sa);
             }
 
             listGoal = CardLists.filter(listGoal, new Predicate<Card>() {

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

@@ -1,12 +1,29 @@
 package forge.ai.ability;
 
+import java.util.Collections;
+
 import com.google.common.base.Predicates;
 import com.google.common.collect.Iterables;
 import com.google.common.collect.Lists;
-import forge.ai.*;
+
+import forge.ai.AiController;
+import forge.ai.AiPlayerPredicates;
+import forge.ai.AiProps;
+import forge.ai.ComputerUtil;
+import forge.ai.ComputerUtilAbility;
+import forge.ai.ComputerUtilCard;
+import forge.ai.ComputerUtilCombat;
+import forge.ai.ComputerUtilCost;
+import forge.ai.PlayerControllerAi;
+import forge.ai.SpecialCardAi;
+import forge.ai.SpellAbilityAi;
 import forge.game.Game;
 import forge.game.ability.AbilityUtils;
-import forge.game.card.*;
+import forge.game.card.Card;
+import forge.game.card.CardCollection;
+import forge.game.card.CardCollectionView;
+import forge.game.card.CardLists;
+import forge.game.card.CardPredicates;
 import forge.game.cost.Cost;
 import forge.game.phase.PhaseType;
 import forge.game.player.Player;
@@ -17,8 +34,6 @@ import forge.game.spellability.SpellAbility;
 import forge.game.zone.ZoneType;
 import forge.util.MyRandom;
 
-import java.util.Collections;
-
 public class ChangeZoneAllAi extends SpellAbilityAi {
     @Override
     protected boolean canPlayAI(Player ai, SpellAbility sa) {

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

@@ -1,7 +1,15 @@
 package forge.ai.ability;
 
+import java.util.List;
+import java.util.Map;
+
 import com.google.common.collect.Lists;
-import forge.ai.*;
+
+import forge.ai.AiController;
+import forge.ai.AiPlayDecision;
+import forge.ai.ComputerUtilAbility;
+import forge.ai.PlayerControllerAi;
+import forge.ai.SpellAbilityAi;
 import forge.game.ability.AbilityUtils;
 import forge.game.ability.effects.CharmEffect;
 import forge.game.card.Card;
@@ -12,9 +20,6 @@ import forge.util.Aggregates;
 import forge.util.MyRandom;
 import forge.util.collect.FCollection;
 
-import java.util.List;
-import java.util.Map;
-
 public class CharmAi extends SpellAbilityAi {
     @Override
     protected boolean checkApiLogic(Player ai, SpellAbility sa) {

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

@@ -10,7 +10,6 @@ import com.google.common.collect.Iterables;
 import com.google.common.collect.Lists;
 
 import forge.ai.ComputerUtilAbility;
-
 import forge.ai.ComputerUtilCard;
 import forge.ai.ComputerUtilCombat;
 import forge.ai.SpellAbilityAi;
@@ -66,7 +65,7 @@ public class ChooseCardAi extends SpellAbilityAi {
         }
         CardCollectionView choices = ai.getGame().getCardsIn(choiceZone);
         if (sa.hasParam("Choices")) {
-            choices = CardLists.getValidCards(choices, sa.getParam("Choices"), host.getController(), host);
+            choices = CardLists.getValidCards(choices, sa.getParam("Choices"), host.getController(), host, sa);
         }
         if (sa.hasParam("TargetControls")) {
             choices = CardLists.filterControlledBy(choices, ai.getOpponents());
@@ -79,7 +78,7 @@ public class ChooseCardAi extends SpellAbilityAi {
             final String filter = aiLogic.equals("Clone") ? "Permanent.YouDontCtrl,Permanent.nonLegendary"
                     : "Permanent.YouDontCtrl+notnamedVesuva,Permanent.nonLegendary+notnamedVesuva";
 
-            choices = CardLists.getValidCards(choices, filter, host.getController(), host);
+            choices = CardLists.getValidCards(choices, filter, host.getController(), host, sa);
             return !choices.isEmpty();
         } else if (aiLogic.equals("Never")) {
             return false;
@@ -112,7 +111,7 @@ public class ChooseCardAi extends SpellAbilityAi {
 
             return !choices.isEmpty();
         } else if (aiLogic.equals("RandomNonLand")) {
-            return !CardLists.getValidCards(choices, "Card.nonLand", host.getController(), host).isEmpty();
+            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();
@@ -186,7 +185,7 @@ public class ChooseCardAi extends SpellAbilityAi {
                 choice = null;
             }
         } else if ("RandomNonLand".equals(logic)) {
-            options = CardLists.getValidCards(options, "Card.nonLand", host.getController(), host);
+            options = CardLists.getValidCards(options, "Card.nonLand", host.getController(), host, sa);
             choice = Aggregates.random(options);
         } else if (logic.equals("Untap")) {
             final String filter = "Permanent.YouCtrl,Permanent.tapped";

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

@@ -7,7 +7,10 @@ import com.google.common.collect.Iterables;
 import com.google.common.collect.Lists;
 
 import forge.StaticData;
-import forge.ai.*;
+import forge.ai.ComputerUtil;
+import forge.ai.ComputerUtilCard;
+import forge.ai.SpecialCardAi;
+import forge.ai.SpellAbilityAi;
 import forge.card.CardDb;
 import forge.card.CardRules;
 import forge.card.CardSplitType;

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

@@ -8,7 +8,9 @@ import forge.ai.SpecialCardAi;
 import forge.ai.SpellAbilityAi;
 import forge.card.MagicColor;
 import forge.game.Game;
-import forge.game.card.*;
+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;

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

@@ -1,15 +1,16 @@
 package forge.ai.ability;
 
-import com.google.common.collect.Lists;
-import forge.ai.SpellAbilityAi;
-import forge.game.card.Card;
-import forge.game.player.Player;
-import forge.game.spellability.SpellAbility;
-
 import java.util.Collections;
 import java.util.List;
 import java.util.Map;
 
+import com.google.common.collect.Lists;
+
+import forge.ai.SpellAbilityAi;
+import forge.game.card.Card;
+import forge.game.player.Player;
+import forge.game.spellability.SpellAbility;
+
 public class ChooseCompanionAi extends SpellAbilityAi {
 
     /* (non-Javadoc)

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

@@ -1,14 +1,28 @@
 package forge.ai.ability;
 
+import java.util.List;
+import java.util.Map;
+
 import com.google.common.base.Predicate;
 import com.google.common.collect.Iterables;
 import com.google.common.collect.Lists;
 import com.google.common.collect.Sets;
-import forge.ai.*;
+
+import forge.ai.ComputerUtilAbility;
+import forge.ai.ComputerUtilCard;
+import forge.ai.ComputerUtilCost;
+import forge.ai.SpecialCardAi;
+import forge.ai.SpellAbilityAi;
+import forge.ai.SpellApiToAi;
 import forge.card.MagicColor;
 import forge.game.Game;
-import forge.game.card.*;
+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.Presets;
+import forge.game.card.CardUtil;
+import forge.game.card.CounterEnumType;
 import forge.game.combat.Combat;
 import forge.game.combat.CombatUtil;
 import forge.game.cost.Cost;
@@ -21,9 +35,6 @@ import forge.game.zone.ZoneType;
 import forge.util.Aggregates;
 import forge.util.collect.FCollection;
 
-import java.util.List;
-import java.util.Map;
-
 
 public class ChooseGenericEffectAi extends SpellAbilityAi {
 
@@ -159,10 +170,10 @@ public class ChooseGenericEffectAi extends SpellAbilityAi {
                 }
             }
             // FatespinnerSkipDraw,FatespinnerSkipMain,FatespinnerSkipCombat
-            if (player.hasKeyword("Skip your draw step.")) {
+            if (game.getReplacementHandler().wouldPhaseBeSkipped(player, "Draw")) {
                 return skipDraw;
             }
-            if (player.hasKeyword("Skip your next combat phase.")) {
+            if (game.getReplacementHandler().wouldPhaseBeSkipped(player, "BeginCombat")) {
                 return skipCombat;
             }
 

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

@@ -1,16 +1,17 @@
 package forge.ai.ability;
 
+import java.util.List;
+import java.util.Map;
+
 import com.google.common.collect.Iterables;
 import com.google.common.collect.Lists;
+
 import forge.ai.ComputerUtil;
 import forge.ai.SpellAbilityAi;
 import forge.game.player.Player;
 import forge.game.spellability.SpellAbility;
 import forge.game.zone.ZoneType;
 
-import java.util.List;
-import java.util.Map;
-
 public class ChoosePlayerAi extends SpellAbilityAi {
     @Override
     protected boolean canPlayAI(Player ai, SpellAbility sa) {

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

@@ -105,7 +105,7 @@ public class ChooseSourceAi extends SpellAbilityAi {
                 }
                 CardCollectionView choices = game.getCardsIn(ZoneType.Battlefield);
                 if (sa.hasParam("Choices")) {
-                    choices = CardLists.getValidCards(choices, sa.getParam("Choices"), host.getController(), host);
+                    choices = CardLists.getValidCards(choices, sa.getParam("Choices"), host.getController(), host, sa);
                 }
                 final Combat combat = game.getCombat();
                 choices = CardLists.filter(choices, new Predicate<Card>() {

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

@@ -1,11 +1,23 @@
 package forge.ai.ability;
 
+import java.util.HashSet;
+import java.util.Set;
+
 import com.google.common.base.Predicates;
-import forge.ai.*;
+
+import forge.ai.AiCardMemory;
+import forge.ai.ComputerUtilAbility;
+import forge.ai.ComputerUtilCard;
+import forge.ai.ComputerUtilMana;
+import forge.ai.SpellAbilityAi;
 import forge.card.CardType;
 import forge.game.ability.AbilityUtils;
 import forge.game.ability.ApiType;
-import forge.game.card.*;
+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.keyword.Keyword;
 import forge.game.phase.PhaseType;
 import forge.game.player.Player;
@@ -13,9 +25,6 @@ import forge.game.spellability.SpellAbility;
 import forge.game.zone.ZoneType;
 import forge.util.Aggregates;
 
-import java.util.HashSet;
-import java.util.Set;
-
 public class ChooseTypeAi extends SpellAbilityAi {
     @Override
     protected boolean canPlayAI(Player aiPlayer, SpellAbility sa) {

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

@@ -4,8 +4,8 @@ package forge.ai.ability;
 import java.util.Map;
 
 import com.google.common.collect.Iterables;
-import forge.ai.ComputerUtilCard;
 
+import forge.ai.ComputerUtilCard;
 import forge.ai.SpellAbilityAi;
 import forge.game.card.Card;
 import forge.game.card.CardCollectionView;

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

@@ -1,5 +1,8 @@
 package forge.ai.ability;
 
+import java.util.List;
+import java.util.Map;
+
 import forge.ai.ComputerUtilCard;
 import forge.ai.SpellAbilityAi;
 import forge.game.Game;
@@ -14,9 +17,6 @@ import forge.game.player.PlayerActionConfirmMode;
 import forge.game.spellability.SpellAbility;
 import forge.game.zone.ZoneType;
 
-import java.util.List;
-import java.util.Map;
-
 public class CloneAi extends SpellAbilityAi {
 
     @Override
@@ -124,11 +124,11 @@ public class CloneAi extends SpellAbilityAi {
     private boolean cloneTgtAI(final SpellAbility sa) {
         // Specific logic for cards
         if ("CloneAttacker".equals(sa.getParam("AILogic"))) {
-            CardCollection valid = CardLists.getValidCards(sa.getHostCard().getController().getCardsIn(ZoneType.Battlefield), sa.getParam("ValidTgts"), sa.getHostCard().getController(), sa.getHostCard());
+            CardCollection valid = CardLists.getValidCards(sa.getHostCard().getController().getCardsIn(ZoneType.Battlefield), sa.getParam("ValidTgts"), sa.getHostCard().getController(), sa.getHostCard(), sa);
             sa.getTargets().add(ComputerUtilCard.getBestCreatureAI(valid));
             return true;
         } else if ("CloneBestCreature".equals(sa.getParam("AILogic"))) {
-            CardCollection valid = CardLists.getValidCards(sa.getHostCard().getController().getGame().getCardsIn(ZoneType.Battlefield), sa.getParam("ValidTgts"), sa.getHostCard().getController(), sa.getHostCard());
+            CardCollection valid = CardLists.getValidCards(sa.getHostCard().getController().getGame().getCardsIn(ZoneType.Battlefield), sa.getParam("ValidTgts"), sa.getHostCard().getController(), sa.getHostCard(), sa);
             sa.getTargets().add(ComputerUtilCard.getBestCreatureAI(valid));
             return true;
         }

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

@@ -1,14 +1,29 @@
 package forge.ai.ability;
 
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+
 import com.google.common.base.Predicate;
 import com.google.common.base.Predicates;
 import com.google.common.collect.Iterables;
-import forge.ai.*;
+
+import forge.ai.AiPlayDecision;
+import forge.ai.ComputerUtil;
+import forge.ai.ComputerUtilAbility;
+import forge.ai.ComputerUtilCard;
+import forge.ai.SpecialCardAi;
+import forge.ai.SpellAbilityAi;
 import forge.game.Game;
 import forge.game.ability.AbilityKey;
 import forge.game.ability.AbilityUtils;
-import forge.game.card.*;
+import forge.game.card.Card;
+import forge.game.card.CardCollection;
+import forge.game.card.CardCollectionView;
+import forge.game.card.CardLists;
+import forge.game.card.CardPredicates;
 import forge.game.card.CardPredicates.Presets;
+import forge.game.card.CardUtil;
 import forge.game.phase.PhaseHandler;
 import forge.game.phase.PhaseType;
 import forge.game.player.Player;
@@ -17,10 +32,6 @@ import forge.game.player.PlayerCollection;
 import forge.game.spellability.SpellAbility;
 import forge.game.zone.ZoneType;
 
-import java.util.Collection;
-import java.util.List;
-import java.util.Map;
-
 public class CopyPermanentAi extends SpellAbilityAi {
     @Override
     protected boolean canPlayAI(Player aiPlayer, SpellAbility sa) {
@@ -173,7 +184,7 @@ public class CopyPermanentAi extends SpellAbilityAi {
         } else if (sa.hasParam("Choices")) {
             // only check for options, does not select there
             CardCollectionView choices = game.getCardsIn(ZoneType.Battlefield);
-            choices = CardLists.getValidCards(choices, sa.getParam("Choices"), activator, host);
+            choices = CardLists.getValidCards(choices, sa.getParam("Choices"), activator, host, sa);
             Collection<Card> betterChoices = getBetterOptions(aiPlayer, sa, choices, !mandatory);
             if (betterChoices.isEmpty()) {
                 return mandatory;

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

@@ -1,6 +1,15 @@
 package forge.ai.ability;
 
-import forge.ai.*;
+import java.util.List;
+import java.util.Map;
+
+import forge.ai.AiCardMemory;
+import forge.ai.AiPlayDecision;
+import forge.ai.AiProps;
+import forge.ai.ComputerUtilCard;
+import forge.ai.PlayerControllerAi;
+import forge.ai.SpecialCardAi;
+import forge.ai.SpellAbilityAi;
 import forge.game.Game;
 import forge.game.ability.ApiType;
 import forge.game.player.Player;
@@ -10,9 +19,6 @@ import forge.game.spellability.SpellAbility;
 import forge.game.spellability.TargetRestrictions;
 import forge.util.MyRandom;
 
-import java.util.List;
-import java.util.Map;
-
 public class CopySpellAbilityAi extends SpellAbilityAi {
 
     @Override

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

@@ -1,6 +1,19 @@
 package forge.ai.ability;
 
-import forge.ai.*;
+import java.util.Iterator;
+
+import org.apache.commons.lang3.StringUtils;
+import org.apache.commons.lang3.tuple.ImmutablePair;
+import org.apache.commons.lang3.tuple.Pair;
+
+import forge.ai.AiController;
+import forge.ai.AiProps;
+import forge.ai.ComputerUtilAbility;
+import forge.ai.ComputerUtilCost;
+import forge.ai.ComputerUtilMana;
+import forge.ai.PlayerControllerAi;
+import forge.ai.SpecialCardAi;
+import forge.ai.SpellAbilityAi;
 import forge.game.Game;
 import forge.game.ability.AbilityUtils;
 import forge.game.ability.ApiType;
@@ -16,11 +29,6 @@ import forge.game.spellability.SpellAbilityStackInstance;
 import forge.game.spellability.TargetRestrictions;
 import forge.game.zone.ZoneType;
 import forge.util.MyRandom;
-import org.apache.commons.lang3.StringUtils;
-import org.apache.commons.lang3.tuple.ImmutablePair;
-import org.apache.commons.lang3.tuple.Pair;
-
-import java.util.Iterator;
 
 public class CounterAi extends SpellAbilityAi {
 

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

@@ -22,7 +22,12 @@ import java.util.List;
 import com.google.common.base.Predicate;
 
 import forge.ai.ComputerUtilCard;
-import forge.game.card.*;
+import forge.game.card.Card;
+import forge.game.card.CardCollection;
+import forge.game.card.CardCollectionView;
+import forge.game.card.CardLists;
+import forge.game.card.CounterEnumType;
+import forge.game.card.CounterType;
 import forge.game.keyword.Keyword;
 import forge.util.Aggregates;
 

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

@@ -1,13 +1,22 @@
 package forge.ai.ability;
 
+import java.util.List;
+import java.util.Map;
+
 import com.google.common.base.Predicate;
 import com.google.common.collect.Iterables;
+
 import forge.ai.ComputerUtil;
 import forge.ai.ComputerUtilCard;
 import forge.ai.SpellAbilityAi;
 import forge.game.Game;
 import forge.game.ability.AbilityUtils;
-import forge.game.card.*;
+import forge.game.card.Card;
+import forge.game.card.CardLists;
+import forge.game.card.CardPredicates;
+import forge.game.card.CardUtil;
+import forge.game.card.CounterEnumType;
+import forge.game.card.CounterType;
 import forge.game.keyword.Keyword;
 import forge.game.phase.PhaseHandler;
 import forge.game.phase.PhaseType;
@@ -17,9 +26,6 @@ import forge.game.zone.ZoneType;
 import forge.util.MyRandom;
 import forge.util.collect.FCollection;
 
-import java.util.List;
-import java.util.Map;
-
 public class CountersMoveAi extends SpellAbilityAi {
     @Override
     protected boolean checkApiLogic(final Player ai, final SpellAbility sa) {

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

@@ -1,19 +1,43 @@
 package forge.ai.ability;
 
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+
 import com.google.common.base.Predicate;
 import com.google.common.base.Predicates;
 import com.google.common.collect.Iterables;
 import com.google.common.collect.Lists;
-import forge.ai.*;
+
+import forge.ai.AiCardMemory;
+import forge.ai.AiProps;
+import forge.ai.ComputerUtil;
+import forge.ai.ComputerUtilAbility;
+import forge.ai.ComputerUtilCard;
+import forge.ai.ComputerUtilCombat;
+import forge.ai.ComputerUtilCost;
+import forge.ai.PlayerControllerAi;
+import forge.ai.SpecialAiLogic;
+import forge.ai.SpecialCardAi;
+import forge.ai.SpellAbilityAi;
 import forge.card.CardStateName;
 import forge.game.Game;
 import forge.game.GameEntity;
 import forge.game.ability.AbilityUtils;
 import forge.game.ability.ApiType;
-import forge.game.card.*;
+import forge.game.card.Card;
+import forge.game.card.CardCollection;
+import forge.game.card.CardLists;
+import forge.game.card.CardPredicates;
+import forge.game.card.CounterEnumType;
+import forge.game.card.CounterType;
 import forge.game.combat.Combat;
 import forge.game.combat.CombatUtil;
-import forge.game.cost.*;
+import forge.game.cost.Cost;
+import forge.game.cost.CostPart;
+import forge.game.cost.CostPutCounter;
+import forge.game.cost.CostRemoveCounter;
+import forge.game.cost.CostSacrifice;
 import forge.game.keyword.Keyword;
 import forge.game.phase.PhaseHandler;
 import forge.game.phase.PhaseType;
@@ -27,10 +51,6 @@ import forge.game.zone.ZoneType;
 import forge.util.Aggregates;
 import forge.util.MyRandom;
 
-import java.util.Collections;
-import java.util.List;
-import java.util.Map;
-
 public class CountersPutAi extends SpellAbilityAi {
 
     /*

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

@@ -1,7 +1,10 @@
 package forge.ai.ability;
 
+import java.util.List;
+
 import com.google.common.base.Predicate;
 import com.google.common.collect.Lists;
+
 import forge.ai.ComputerUtilCost;
 import forge.ai.SpellAbilityAi;
 import forge.game.ability.AbilityUtils;
@@ -18,8 +21,6 @@ import forge.game.spellability.TargetRestrictions;
 import forge.game.zone.ZoneType;
 import forge.util.MyRandom;
 
-import java.util.List;
-
 public class CountersPutAllAi extends SpellAbilityAi {
     @Override
     protected boolean canPlayAI(Player ai, SpellAbility sa) {
@@ -38,11 +39,11 @@ public class CountersPutAllAi extends SpellAbilityAi {
         final TargetRestrictions tgt = sa.getTargetRestrictions();
 
         if ("OwnCreatsAndOtherPWs".equals(sa.getParam("AILogic"))) {
-            hList = CardLists.getValidCards(ai.getWeakestOpponent().getCardsIn(ZoneType.Battlefield), "Creature.YouCtrl,Planeswalker.YouCtrl+Other", source.getController(), source);
+            hList = CardLists.getValidCards(ai.getWeakestOpponent().getCardsIn(ZoneType.Battlefield), "Creature.YouCtrl,Planeswalker.YouCtrl+Other", source.getController(), source, sa);
-            cList = CardLists.getValidCards(ai.getCardsIn(ZoneType.Battlefield), "Creature.YouCtrl,Planeswalker.YouCtrl+Other", source.getController(), source);
+            cList = CardLists.getValidCards(ai.getCardsIn(ZoneType.Battlefield), "Creature.YouCtrl,Planeswalker.YouCtrl+Other", source.getController(), source, sa);
         } else {
-            hList = CardLists.getValidCards(ai.getWeakestOpponent().getCardsIn(ZoneType.Battlefield), valid, source.getController(), source);
+            hList = CardLists.getValidCards(ai.getWeakestOpponent().getCardsIn(ZoneType.Battlefield), valid, source.getController(), source, sa);
-            cList = CardLists.getValidCards(ai.getCardsIn(ZoneType.Battlefield), valid, source.getController(), source);
+            cList = CardLists.getValidCards(ai.getCardsIn(ZoneType.Battlefield), valid, source.getController(), source, sa);
         }
 
         if (abCost != null) {

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

@@ -17,21 +17,27 @@
  */
 package forge.ai.ability;
 
+import java.util.List;
+import java.util.Map;
+
 import forge.ai.ComputerUtil;
 import forge.ai.ComputerUtilCard;
 import forge.ai.SpellAbilityAi;
 import forge.game.Game;
 import forge.game.GlobalRuleChange;
-import forge.game.card.*;
+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.CounterEnumType;
+import forge.game.card.CounterType;
 import forge.game.keyword.Keyword;
 import forge.game.player.Player;
 import forge.game.player.PlayerController.BinaryChoiceType;
 import forge.game.spellability.SpellAbility;
 import forge.game.spellability.TargetRestrictions;
 
-import java.util.List;
-import java.util.Map;
-
 /**
  * <p>
  * AbilityFactory_PutOrRemoveCountersAi class.

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

@@ -1,6 +1,10 @@
 package forge.ai.ability;
 
+import java.util.List;
+import java.util.Map;
+
 import com.google.common.base.Predicates;
+
 import forge.ai.ComputerUtil;
 import forge.ai.ComputerUtilCard;
 import forge.ai.ComputerUtilCost;
@@ -9,7 +13,13 @@ import forge.game.Game;
 import forge.game.GameEntity;
 import forge.game.GlobalRuleChange;
 import forge.game.ability.AbilityUtils;
-import forge.game.card.*;
+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.CounterEnumType;
+import forge.game.card.CounterType;
 import forge.game.keyword.Keyword;
 import forge.game.phase.PhaseHandler;
 import forge.game.phase.PhaseType;
@@ -18,9 +28,6 @@ import forge.game.spellability.SpellAbility;
 import forge.game.spellability.TargetRestrictions;
 import forge.game.zone.ZoneType;
 
-import java.util.List;
-import java.util.Map;
-
 public class CountersRemoveAi extends SpellAbilityAi {
 
     @Override

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

@@ -1,6 +1,7 @@
 package forge.ai.ability;
 
 import com.google.common.collect.Iterables;
+
 import forge.ai.ComputerUtilCombat;
 import forge.ai.SpellAbilityAi;
 import forge.game.Game;

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

@@ -1,7 +1,12 @@
 package forge.ai.ability;
 
 import com.google.common.base.Predicate;
-import forge.ai.*;
+
+import forge.ai.ComputerUtilCard;
+import forge.ai.ComputerUtilCombat;
+import forge.ai.ComputerUtilCost;
+import forge.ai.ComputerUtilMana;
+import forge.ai.SpellAbilityAi;
 import forge.game.ability.AbilityUtils;
 import forge.game.card.Card;
 import forge.game.card.CardCollection;

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

@@ -1,16 +1,39 @@
 package forge.ai.ability;
 
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+
+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.Lists;
 import com.google.common.collect.Maps;
-import forge.ai.*;
+
+import forge.ai.AiController;
+import forge.ai.AiProps;
+import forge.ai.ComputerUtil;
+import forge.ai.ComputerUtilAbility;
+import forge.ai.ComputerUtilCard;
+import forge.ai.ComputerUtilCombat;
+import forge.ai.ComputerUtilCost;
+import forge.ai.ComputerUtilMana;
+import forge.ai.PlayerControllerAi;
+import forge.ai.SpecialCardAi;
+import forge.ai.SpellAbilityAi;
 import forge.card.mana.ManaCost;
 import forge.game.Game;
 import forge.game.GameObject;
 import forge.game.ability.AbilityUtils;
 import forge.game.ability.ApiType;
-import forge.game.card.*;
+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;
@@ -26,12 +49,6 @@ import forge.game.spellability.TargetRestrictions;
 import forge.game.zone.ZoneType;
 import forge.util.Aggregates;
 import forge.util.MyRandom;
-import org.apache.commons.lang3.StringUtils;
-import org.apache.commons.lang3.tuple.Pair;
-
-import java.util.Arrays;
-import java.util.List;
-import java.util.Map;
 
 public class DamageDealAi extends DamageAiBase {
     @Override
@@ -161,7 +178,7 @@ public class DamageDealAi extends DamageAiBase {
             }
         } else if ("WildHunt".equals(logic)) {
             // This dummy ability will just deal 0 damage, but holds the logic for the AI for Master of Wild Hunt
-            List<Card> wolves = CardLists.getValidCards(ai.getCardsIn(ZoneType.Battlefield), "Creature.Wolf+untapped+YouCtrl+Other", ai, source);
+            List<Card> wolves = CardLists.getValidCards(ai.getCardsIn(ZoneType.Battlefield), "Creature.Wolf+untapped+YouCtrl+Other", ai, source, sa);
             dmg = Aggregates.sum(wolves, CardPredicates.Accessors.fnGetNetPower);
         } else if ("Triskelion".equals(logic)) {
             final int n = source.getCounters(CounterEnumType.P1P1);

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

@@ -1,6 +1,13 @@
 package forge.ai.ability;
 
-import forge.ai.*;
+import java.util.ArrayList;
+import java.util.List;
+
+import forge.ai.ComputerUtil;
+import forge.ai.ComputerUtilCard;
+import forge.ai.ComputerUtilCombat;
+import forge.ai.ComputerUtilCost;
+import forge.ai.SpellAbilityAi;
 import forge.game.Game;
 import forge.game.GameObject;
 import forge.game.ability.AbilityUtils;
@@ -19,9 +26,6 @@ import forge.game.spellability.TargetChoices;
 import forge.game.spellability.TargetRestrictions;
 import forge.game.zone.ZoneType;
 
-import java.util.ArrayList;
-import java.util.List;
-
 public class DamagePreventAi extends SpellAbilityAi {
 
     @Override

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

@@ -1,5 +1,9 @@
 package forge.ai.ability;
 
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
 import com.google.common.base.Predicate;
 import com.google.common.collect.Iterables;
 import com.google.common.collect.Lists;
@@ -21,10 +25,6 @@ import forge.game.spellability.SpellAbility;
 import forge.game.spellability.TargetRestrictions;
 import forge.game.zone.ZoneType;
 
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
-
 public class DebuffAi extends SpellAbilityAi {
     // *************************************************************************
     // ***************************** Debuff ************************************

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

@@ -1,7 +1,14 @@
 package forge.ai.ability;
 
 import com.google.common.base.Predicate;
-import forge.ai.*;
+
+import forge.ai.AiController;
+import forge.ai.AiPlayDecision;
+import forge.ai.ComputerUtilAbility;
+import forge.ai.ComputerUtilMana;
+import forge.ai.PlayerControllerAi;
+import forge.ai.SpellAbilityAi;
+import forge.ai.SpellApiToAi;
 import forge.card.mana.ManaCost;
 import forge.game.ability.ApiType;
 import forge.game.card.Card;

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

@@ -1,10 +1,23 @@
 package forge.ai.ability;
 
 import com.google.common.base.Predicate;
-import forge.ai.*;
+
+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.game.ability.AbilityUtils;
 import forge.game.ability.ApiType;
-import forge.game.card.*;
+import forge.game.card.Card;
+import forge.game.card.CardCollection;
+import forge.game.card.CardLists;
+import forge.game.card.CardPredicates;
+import forge.game.card.CounterEnumType;
 import forge.game.cost.Cost;
 import forge.game.cost.CostPart;
 import forge.game.cost.CostSacrifice;

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

@@ -2,7 +2,13 @@ package forge.ai.ability;
 
 import com.google.common.base.Predicate;
 import com.google.common.base.Predicates;
-import forge.ai.*;
+
+import forge.ai.AiBlockController;
+import forge.ai.ComputerUtil;
+import forge.ai.ComputerUtilCard;
+import forge.ai.ComputerUtilCombat;
+import forge.ai.ComputerUtilCost;
+import forge.ai.SpellAbilityAi;
 import forge.card.MagicColor;
 import forge.game.card.Card;
 import forge.game.card.CardCollection;

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

@@ -5,7 +5,12 @@ import java.util.Map;
 import com.google.common.base.Predicate;
 import com.google.common.collect.Iterables;
 
-import forge.ai.*;
+import forge.ai.ComputerUtil;
+import forge.ai.ComputerUtilAbility;
+import forge.ai.ComputerUtilCard;
+import forge.ai.ComputerUtilCost;
+import forge.ai.SpecialCardAi;
+import forge.ai.SpellAbilityAi;
 import forge.game.Game;
 import forge.game.ability.AbilityUtils;
 import forge.game.card.Card;

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

@@ -1,5 +1,7 @@
 package forge.ai.ability;
 
+import java.util.List;
+
 import forge.ai.ComputerUtilCost;
 import forge.ai.SpellAbilityAi;
 import forge.game.card.Card;
@@ -12,8 +14,6 @@ import forge.game.spellability.SpellAbility;
 import forge.game.zone.ZoneType;
 import forge.util.MyRandom;
 
-import java.util.List;
-
 public class DigUntilAi extends SpellAbilityAi {
 
     @Override

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

@@ -1,6 +1,13 @@
 package forge.ai.ability;
 
-import forge.ai.*;
+import java.util.List;
+
+import forge.ai.ComputerUtil;
+import forge.ai.ComputerUtilAbility;
+import forge.ai.ComputerUtilCost;
+import forge.ai.ComputerUtilMana;
+import forge.ai.SpecialCardAi;
+import forge.ai.SpellAbilityAi;
 import forge.game.ability.AbilityUtils;
 import forge.game.card.Card;
 import forge.game.card.CardCollectionView;
@@ -15,8 +22,6 @@ import forge.game.spellability.TargetRestrictions;
 import forge.game.zone.ZoneType;
 import forge.util.MyRandom;
 
-import java.util.List;
-
 public class DiscardAi extends SpellAbilityAi {
 
     @Override

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

@@ -1,5 +1,7 @@
 package forge.ai.ability;
 
+import java.util.List;
+
 import forge.ai.SpellAbilityAi;
 import forge.game.ability.AbilityUtils;
 import forge.game.card.Card;
@@ -8,8 +10,6 @@ import forge.game.spellability.SpellAbility;
 import forge.game.spellability.TargetRestrictions;
 import forge.util.MyRandom;
 
-import java.util.List;
-
 public class DrainManaAi extends SpellAbilityAi {
 
     @Override

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

@@ -18,14 +18,24 @@
  */
 package forge.ai.ability;
 
-import forge.ai.*;
+import forge.ai.AiCostDecision;
+import forge.ai.ComputerUtil;
+import forge.ai.ComputerUtilAbility;
+import forge.ai.ComputerUtilCost;
+import forge.ai.ComputerUtilMana;
+import forge.ai.SpecialCardAi;
+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.CounterEnumType;
 import forge.game.card.CounterType;
-import forge.game.cost.*;
+import forge.game.cost.Cost;
+import forge.game.cost.CostDiscard;
+import forge.game.cost.CostPart;
+import forge.game.cost.CostPayLife;
+import forge.game.cost.PaymentDecision;
 import forge.game.phase.PhaseHandler;
 import forge.game.phase.PhaseType;
 import forge.game.player.Player;

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

@@ -1,12 +1,28 @@
 package forge.ai.ability;
 
+import java.util.List;
+
 import com.google.common.base.Predicate;
 import com.google.common.base.Predicates;
 import com.google.common.collect.Iterables;
-import forge.ai.*;
+
+import forge.ai.AiCardMemory;
+import forge.ai.AiController;
+import forge.ai.ComputerUtil;
+import forge.ai.ComputerUtilCard;
+import forge.ai.ComputerUtilCombat;
+import forge.ai.ComputerUtilMana;
+import forge.ai.PlayerControllerAi;
+import forge.ai.SpecialCardAi;
+import forge.ai.SpellAbilityAi;
+import forge.ai.SpellApiToAi;
 import forge.game.Game;
 import forge.game.ability.ApiType;
-import forge.game.card.*;
+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.combat.Combat;
 import forge.game.combat.CombatUtil;
 import forge.game.phase.PhaseHandler;
@@ -18,8 +34,6 @@ import forge.game.spellability.TargetRestrictions;
 import forge.game.zone.ZoneType;
 import forge.util.MyRandom;
 
-import java.util.List;
-
 public class EffectAi extends SpellAbilityAi {
     @Override
     protected boolean canPlayAI(final Player ai,final SpellAbility sa) {

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

@@ -1,8 +1,17 @@
 package forge.ai.ability;
 
 
-import forge.ai.*;
+import forge.ai.AiController;
-import forge.game.card.*;
+import forge.ai.AiProps;
+import forge.ai.ComputerUtilCard;
+import forge.ai.ComputerUtilMana;
+import forge.ai.PlayerControllerAi;
+import forge.ai.SpellAbilityAi;
+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.player.Player;
 import forge.game.spellability.SpellAbility;
 import forge.game.zone.ZoneType;

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

@@ -1,6 +1,13 @@
 package forge.ai.ability;
 
-import forge.ai.*;
+import java.util.List;
+import java.util.Map;
+
+import forge.ai.ComputerUtil;
+import forge.ai.ComputerUtilAbility;
+import forge.ai.ComputerUtilCard;
+import forge.ai.ComputerUtilCombat;
+import forge.ai.SpellAbilityAi;
 import forge.game.ability.AbilityFactory;
 import forge.game.ability.AbilityUtils;
 import forge.game.ability.ApiType;
@@ -16,9 +23,6 @@ import forge.game.trigger.Trigger;
 import forge.game.trigger.TriggerType;
 import forge.util.MyRandom;
 
-import java.util.List;
-import java.util.Map;
-
 public class FightAi extends SpellAbilityAi {
     @Override
     protected boolean checkAiLogic(final Player ai, final SpellAbility sa, final String aiLogic) {

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

@@ -1,7 +1,13 @@
 package forge.ai.ability;
 
 
-import forge.ai.*;
+import java.util.List;
+
+import forge.ai.AiCardMemory;
+import forge.ai.ComputerUtil;
+import forge.ai.ComputerUtilCombat;
+import forge.ai.PlayerControllerAi;
+import forge.ai.SpellAbilityAi;
 import forge.game.Game;
 import forge.game.GameObject;
 import forge.game.card.Card;
@@ -12,8 +18,6 @@ import forge.game.player.Player;
 import forge.game.spellability.SpellAbility;
 import forge.util.Aggregates;
 
-import java.util.List;
-
 public class FogAi extends SpellAbilityAi {
 
     /* (non-Javadoc)

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

@@ -1,6 +1,11 @@
 package forge.ai.ability;
 
-import forge.ai.*;
+import forge.ai.AiController;
+import forge.ai.AiPlayDecision;
+import forge.ai.ComputerUtilCost;
+import forge.ai.PlayerControllerAi;
+import forge.ai.SpellAbilityAi;
+import forge.ai.SpellApiToAi;
 import forge.game.player.Player;
 import forge.game.spellability.AbilitySub;
 import forge.game.spellability.SpellAbility;

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

@@ -3,6 +3,7 @@ package forge.ai.ability;
 import java.util.Map;
 
 import com.google.common.collect.Iterables;
+
 import forge.ai.SpellAbilityAi;
 import forge.game.card.Card;
 import forge.game.card.CounterEnumType;

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

@@ -1,6 +1,11 @@
 package forge.ai.ability;
 
-import forge.ai.*;
+import forge.ai.AiProps;
+import forge.ai.ComputerUtil;
+import forge.ai.ComputerUtilAbility;
+import forge.ai.ComputerUtilCombat;
+import forge.ai.PlayerControllerAi;
+import forge.ai.SpellAbilityAi;
 import forge.game.Game;
 import forge.game.card.Card;
 import forge.game.keyword.Keyword;

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

@@ -1,7 +1,12 @@
 package forge.ai.ability;
 
 import com.google.common.collect.Iterables;
-import forge.ai.*;
+
+import forge.ai.ComputerUtil;
+import forge.ai.ComputerUtilAbility;
+import forge.ai.ComputerUtilCombat;
+import forge.ai.ComputerUtilCost;
+import forge.ai.SpellAbilityAi;
 import forge.game.Game;
 import forge.game.ability.AbilityUtils;
 import forge.game.card.Card;

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

@@ -1,12 +1,27 @@
 package forge.ai.ability;
 
+import java.util.Arrays;
+import java.util.List;
+
 import com.google.common.base.Predicates;
-import forge.ai.*;
+
+import forge.ai.AiPlayDecision;
+import forge.ai.ComputerUtil;
+import forge.ai.ComputerUtilAbility;
+import forge.ai.ComputerUtilCost;
+import forge.ai.ComputerUtilMana;
+import forge.ai.PlayerControllerAi;
+import forge.ai.SpellAbilityAi;
 import forge.card.ColorSet;
 import forge.card.MagicColor;
 import forge.card.mana.ManaCost;
 import forge.game.ability.AbilityUtils;
-import forge.game.card.*;
+import forge.game.card.Card;
+import forge.game.card.CardCollection;
+import forge.game.card.CardLists;
+import forge.game.card.CardPredicates;
+import forge.game.card.CounterEnumType;
+import forge.game.card.CounterType;
 import forge.game.cost.CostPart;
 import forge.game.cost.CostRemoveCounter;
 import forge.game.keyword.Keyword;
@@ -17,9 +32,6 @@ import forge.game.spellability.SpellAbility;
 import forge.game.zone.ZoneType;
 import forge.util.Aggregates;
 
-import java.util.Arrays;
-import java.util.List;
-
 public class ManaEffectAi extends SpellAbilityAi {
 
     /*

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

@@ -1,7 +1,11 @@
 package forge.ai.ability;
 
+import java.util.List;
+import java.util.Map;
+
 import com.google.common.base.Predicate;
 import com.google.common.collect.Iterables;
+
 import forge.ai.ComputerUtil;
 import forge.ai.ComputerUtilCard;
 import forge.ai.ComputerUtilCost;
@@ -24,9 +28,6 @@ import forge.game.spellability.SpellAbility;
 import forge.game.zone.ZoneType;
 import forge.util.MyRandom;
 
-import java.util.List;
-import java.util.Map;
-
 /**
  * Created by friarsol on 1/23/15.
  */
@@ -141,7 +142,7 @@ public class ManifestAi extends SpellAbilityAi {
             }
             CardCollection choices = new CardCollection(game.getCardsIn(choiceZone));
             if (sa.hasParam("Choices")) {
-                choices = CardLists.getValidCards(choices, sa.getParam("Choices"), ai, host);
+                choices = CardLists.getValidCards(choices, sa.getParam("Choices"), ai, host, sa);
             }
             if (choices.isEmpty()) {
                 return false;

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

@@ -1,6 +1,7 @@
 package forge.ai.ability;
 
 import com.google.common.base.Predicates;
+
 import forge.ai.SpellAbilityAi;
 import forge.game.card.CardCollectionView;
 import forge.game.card.CardLists;

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

@@ -1,7 +1,13 @@
 package forge.ai.ability;
 
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Map;
+
 import com.google.common.collect.Lists;
 import com.google.common.collect.Maps;
+
 import forge.ai.ComputerUtil;
 import forge.ai.ComputerUtilCost;
 import forge.ai.SpecialCardAi;
@@ -19,11 +25,6 @@ import forge.game.spellability.SpellAbility;
 import forge.game.spellability.TargetRestrictions;
 import forge.game.zone.ZoneType;
 
-import java.util.Collections;
-import java.util.Comparator;
-import java.util.List;
-import java.util.Map;
-
 public class MillAi extends SpellAbilityAi {
 
     @Override

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

@@ -1,9 +1,16 @@
 package forge.ai.ability;
 
+import java.util.List;
+import java.util.Map;
+
 import com.google.common.base.Predicate;
 import com.google.common.collect.Iterables;
 import com.google.common.collect.Lists;
-import forge.ai.*;
+
+import forge.ai.AiCardMemory;
+import forge.ai.ComputerUtilCard;
+import forge.ai.ComputerUtilCombat;
+import forge.ai.SpellAbilityAi;
 import forge.game.Game;
 import forge.game.ability.AbilityUtils;
 import forge.game.card.Card;
@@ -17,9 +24,6 @@ import forge.game.player.Player;
 import forge.game.spellability.SpellAbility;
 import forge.game.zone.ZoneType;
 
-import java.util.List;
-import java.util.Map;
-
 public class MustBlockAi extends SpellAbilityAi {
 
     @Override

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

@@ -1,7 +1,10 @@
 package forge.ai.ability;
 
+import java.util.Map;
+
 import com.google.common.base.Predicate;
 import com.google.common.base.Predicates;
+
 import forge.ai.ComputerUtilCard;
 import forge.ai.SpellAbilityAi;
 import forge.game.card.Card;
@@ -13,8 +16,6 @@ import forge.game.player.Player;
 import forge.game.player.PlayerActionConfirmMode;
 import forge.game.spellability.SpellAbility;
 
-import java.util.Map;
-
 public class MutateAi extends SpellAbilityAi {
     @Override
     protected boolean canPlayAI(Player aiPlayer, SpellAbility sa) {

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

@@ -1,6 +1,5 @@
 package forge.ai.ability;
 
-import forge.game.card.*;
 import org.apache.commons.lang3.StringUtils;
 
 import com.google.common.base.Predicates;
@@ -13,6 +12,11 @@ import forge.card.CardType.Supertype;
 import forge.card.mana.ManaCost;
 import forge.game.Game;
 import forge.game.GlobalRuleChange;
+import forge.game.card.Card;
+import forge.game.card.CardCollection;
+import forge.game.card.CardCollectionView;
+import forge.game.card.CardLists;
+import forge.game.card.CardPredicates;
 import forge.game.cost.Cost;
 import forge.game.keyword.KeywordInterface;
 import forge.game.mana.ManaCostBeingPaid;

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

@@ -1,7 +1,14 @@
 package forge.ai.ability;
 
 import com.google.common.base.Predicate;
-import forge.ai.*;
+
+import forge.ai.AiController;
+import forge.ai.AiProps;
+import forge.ai.ComputerUtil;
+import forge.ai.ComputerUtilCard;
+import forge.ai.ComputerUtilCombat;
+import forge.ai.ComputerUtilCost;
+import forge.ai.PlayerControllerAi;
 import forge.card.mana.ManaCost;
 import forge.game.Game;
 import forge.game.ability.ApiType;
@@ -59,7 +66,7 @@ public class PermanentCreatureAi extends PermanentAi {
         if (sa.isDash()) {
             //only checks that the dashed creature will attack
             if (ph.isPlayerTurn(ai) && ph.getPhase().isBefore(PhaseType.COMBAT_DECLARE_ATTACKERS)) {
-                if (ai.hasKeyword("Skip your next combat phase."))
+                if (game.getReplacementHandler().wouldPhaseBeSkipped(ai, "BeginCombat"))
                     return false;
                 if (ComputerUtilCost.canPayCost(sa.getHostCard().getSpellPermanent(), ai)) {
                     //do not dash if creature can be played normally
@@ -77,7 +84,7 @@ public class PermanentCreatureAi extends PermanentAi {
         // after attacking
         if (card.hasSVar("EndOfTurnLeavePlay")
                 && (!ph.isPlayerTurn(ai) || ph.getPhase().isAfter(PhaseType.COMBAT_DECLARE_ATTACKERS)
-                || ai.hasKeyword("Skip your next combat phase."))) {
+                || game.getReplacementHandler().wouldPhaseBeSkipped(ai, "BeginCombat"))) {
             // AiPlayDecision.AnotherTime
             return false;
         }

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

@@ -1,6 +1,9 @@
 package forge.ai.ability;
 
+import java.util.List;
+
 import com.google.common.base.Predicates;
+
 import forge.ai.ComputerUtil;
 import forge.ai.ComputerUtilCard;
 import forge.ai.SpellAbilityAi;
@@ -16,8 +19,6 @@ import forge.game.spellability.TargetRestrictions;
 import forge.game.zone.ZoneType;
 import forge.util.MyRandom;
 
-import java.util.List;
-
 public class PhasesAi extends SpellAbilityAi {
     @Override
     protected boolean canPlayAI(Player aiPlayer, SpellAbility sa) {

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

@@ -1,16 +1,30 @@
 package forge.ai.ability;
 
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+
 import com.google.common.base.Predicate;
 import com.google.common.collect.Iterables;
 import com.google.common.collect.Lists;
 
-import forge.ai.*;
+import forge.ai.AiController;
+import forge.ai.AiPlayDecision;
+import forge.ai.AiProps;
+import forge.ai.ComputerUtil;
+import forge.ai.ComputerUtilCard;
+import forge.ai.PlayerControllerAi;
+import forge.ai.SpellAbilityAi;
 import forge.card.CardStateName;
 import forge.card.CardTypeView;
 import forge.game.Game;
 import forge.game.GameType;
 import forge.game.ability.AbilityUtils;
-import forge.game.card.*;
+import forge.game.card.Card;
+import forge.game.card.CardCollection;
+import forge.game.card.CardCollectionView;
+import forge.game.card.CardLists;
+import forge.game.card.CardPredicates;
 import forge.game.cost.Cost;
 import forge.game.keyword.Keyword;
 import forge.game.player.Player;
@@ -23,10 +37,6 @@ import forge.game.spellability.TargetRestrictions;
 import forge.game.zone.ZoneType;
 import forge.util.MyRandom;
 
-import java.util.Iterator;
-import java.util.List;
-import java.util.Map;
-
 public class PlayAi extends SpellAbilityAi {
 
     @Override

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

@@ -1,5 +1,8 @@
 package forge.ai.ability;
 
+import java.util.Collections;
+import java.util.List;
+
 import com.google.common.base.Predicate;
 
 import forge.ai.ComputerUtilCard;
@@ -14,9 +17,6 @@ import forge.game.spellability.TargetRestrictions;
 import forge.game.zone.ZoneType;
 import forge.util.MyRandom;
 
-import java.util.Collections;
-import java.util.List;
-
 public class PowerExchangeAi extends SpellAbilityAi {
 
 /* (non-Javadoc)

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

@@ -5,7 +5,12 @@ import java.util.List;
 
 import com.google.common.base.Predicate;
 
-import forge.ai.*;
+import forge.ai.AiAttackController;
+import forge.ai.ComputerUtil;
+import forge.ai.ComputerUtilCard;
+import forge.ai.ComputerUtilCombat;
+import forge.ai.ComputerUtilCost;
+import forge.ai.SpellAbilityAi;
 import forge.card.MagicColor;
 import forge.game.Game;
 import forge.game.GameObject;

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

@@ -1,14 +1,32 @@
 package forge.ai.ability;
 
+import java.util.Arrays;
+import java.util.List;
+
+import org.apache.commons.lang3.StringUtils;
+
 import com.google.common.base.Predicate;
 import com.google.common.base.Predicates;
 import com.google.common.collect.Lists;
-import forge.ai.*;
+
+import forge.ai.ComputerUtil;
+import forge.ai.ComputerUtilAbility;
+import forge.ai.ComputerUtilCard;
+import forge.ai.ComputerUtilCost;
+import forge.ai.SpecialAiLogic;
+import forge.ai.SpecialCardAi;
+import forge.ai.SpellAbilityAi;
 import forge.game.Game;
 import forge.game.ability.AbilityUtils;
 import forge.game.ability.ApiType;
-import forge.game.card.*;
+import forge.game.card.Card;
+import forge.game.card.CardCollection;
+import forge.game.card.CardLists;
+import forge.game.card.CardPredicates;
 import forge.game.card.CardPredicates.Presets;
+import forge.game.card.CardUtil;
+import forge.game.card.CounterEnumType;
+import forge.game.card.CounterType;
 import forge.game.cost.Cost;
 import forge.game.cost.CostTapType;
 import forge.game.keyword.Keyword;
@@ -20,10 +38,6 @@ import forge.game.spellability.SpellAbility;
 import forge.game.spellability.TargetRestrictions;
 import forge.game.staticability.StaticAbility;
 import forge.game.zone.ZoneType;
-import org.apache.commons.lang3.StringUtils;
-
-import java.util.Arrays;
-import java.util.List;
 
 public class PumpAi extends PumpAiBase {
 

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

@@ -1,8 +1,11 @@
 package forge.ai.ability;
 
+import java.util.List;
+
 import com.google.common.base.Predicate;
 import com.google.common.base.Predicates;
 import com.google.common.collect.Iterables;
+
 import forge.ai.ComputerUtil;
 import forge.ai.ComputerUtilCard;
 import forge.ai.ComputerUtilCombat;
@@ -10,7 +13,12 @@ import forge.ai.SpellAbilityAi;
 import forge.card.MagicColor;
 import forge.game.Game;
 import forge.game.ability.AbilityUtils;
-import forge.game.card.*;
+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.combat.Combat;
 import forge.game.combat.CombatUtil;
 import forge.game.keyword.Keyword;
@@ -21,8 +29,6 @@ import forge.game.player.Player;
 import forge.game.spellability.SpellAbility;
 import forge.game.zone.ZoneType;
 
-import java.util.List;
-
 public abstract class PumpAiBase extends SpellAbilityAi {
 
     public boolean containsUsefulKeyword(final Player ai, final List<String> keywords, final Card card, final SpellAbility sa, final int attack) {

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

@@ -1,5 +1,9 @@
 package forge.ai.ability;
 
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
 import com.google.common.base.Predicate;
 
 import forge.ai.ComputerUtil;
@@ -22,10 +26,6 @@ import forge.game.spellability.SpellAbility;
 import forge.game.spellability.TargetRestrictions;
 import forge.game.zone.ZoneType;
 
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
-
 public class PumpAllAi extends PumpAiBase {
 
     /* (non-Javadoc)
@@ -69,8 +69,8 @@ public class PumpAllAi extends PumpAiBase {
         }
 
         final Player opp = ai.getWeakestOpponent();
-        CardCollection comp = CardLists.getValidCards(ai.getCardsIn(ZoneType.Battlefield), valid, source.getController(), source);
+        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);
+        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")) {
@@ -144,7 +144,7 @@ public class PumpAllAi extends PumpAiBase {
             return (ComputerUtilCard.evaluateCreatureList(comp) + 200) < ComputerUtilCard.evaluateCreatureList(human);
         } // end Curse
 
-        return !CardLists.getValidCards(getPumpCreatures(ai, sa, defense, power, keywords, false), valid, source.getController(), source).isEmpty();
+        return !CardLists.getValidCards(getPumpCreatures(ai, sa, defense, power, keywords, false), valid, source.getController(), source, sa).isEmpty();
     } // pumpAllCanPlayAI()
 
     @Override

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

@@ -1,7 +1,12 @@
 package forge.ai.ability;
 
 
-import forge.ai.*;
+import forge.ai.AiCardMemory;
+import forge.ai.AiController;
+import forge.ai.AiProps;
+import forge.ai.ComputerUtilMana;
+import forge.ai.PlayerControllerAi;
+import forge.ai.SpellAbilityAi;
 import forge.game.ability.AbilityUtils;
 import forge.game.card.Card;
 import forge.game.card.CardLists;

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

@@ -17,7 +17,13 @@
  */
 package forge.ai.ability;
 
-import forge.ai.*;
+import java.util.ArrayList;
+import java.util.List;
+
+import forge.ai.ComputerUtil;
+import forge.ai.ComputerUtilCard;
+import forge.ai.ComputerUtilCombat;
+import forge.ai.SpellAbilityAi;
 import forge.game.Game;
 import forge.game.GameObject;
 import forge.game.ability.AbilityUtils;
@@ -33,9 +39,6 @@ import forge.game.spellability.SpellAbility;
 import forge.game.spellability.TargetRestrictions;
 import forge.game.zone.ZoneType;
 
-import java.util.ArrayList;
-import java.util.List;
-
 /**
  * <p>
  * AbilityFactory_Regenerate class.

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

@@ -1,5 +1,7 @@
 package forge.ai.ability;
 
+import java.util.List;
+
 import forge.ai.ComputerUtil;
 import forge.ai.ComputerUtilCombat;
 import forge.ai.SpellAbilityAi;
@@ -15,8 +17,6 @@ import forge.game.player.Player;
 import forge.game.spellability.SpellAbility;
 import forge.game.zone.ZoneType;
 
-import java.util.List;
-
 public class RegenerateAllAi extends SpellAbilityAi {
 
     @Override

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

@@ -1,7 +1,10 @@
 package forge.ai.ability;
 
 
-import forge.ai.*;
+import forge.ai.AiController;
+import forge.ai.ComputerUtilCost;
+import forge.ai.PlayerControllerAi;
+import forge.ai.SpellAbilityAi;
 import forge.game.phase.PhaseType;
 import forge.game.player.Player;
 import forge.game.player.PlayerActionConfirmMode;

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

@@ -1,6 +1,10 @@
 package forge.ai.ability;
 
+import java.util.List;
+import java.util.Map;
+
 import com.google.common.base.Predicate;
+
 import forge.ai.ComputerUtilCard;
 import forge.ai.SpecialCardAi;
 import forge.ai.SpellAbilityAi;
@@ -17,9 +21,6 @@ import forge.game.spellability.SpellAbility;
 import forge.game.zone.ZoneType;
 import forge.util.TextUtil;
 
-import java.util.List;
-import java.util.Map;
-
 
 public class RepeatEachAi extends SpellAbilityAi {
 

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

@@ -1,6 +1,14 @@
 package forge.ai.ability;
 
+import com.google.common.collect.Iterables;
+
+import forge.ai.ComputerUtil;
+import forge.ai.ComputerUtilCard;
 import forge.ai.SpellAbilityAi;
+import forge.game.card.Card;
+import forge.game.card.CardCollection;
+import forge.game.card.CardLists;
+import forge.game.card.CardPredicates.Presets;
 import forge.game.player.Player;
 import forge.game.spellability.SpellAbility;
 
@@ -16,15 +24,20 @@ public class RestartGameAi extends SpellAbilityAi {
      */
     @Override
     protected boolean canPlayAI(Player ai, SpellAbility sa) {
-        // The only card that uses this is Karn Liberated
+        if (ComputerUtil.aiLifeInDanger(ai, true, 0)) {
-
-        // TODO Add Logic, check if AI is losing game state, or life
-
-        // TODO Add Logic, check if any good cards will be available to be returned
-
             return true;
         }
 
+        // check if enough good permanents will be available to be returned, so AI can "autowin"
+        CardCollection exiled = new CardCollection(Iterables.filter(sa.getHostCard().getRemembered(), Card.class));
+        exiled = CardLists.filter(exiled, Presets.PERMANENTS);
+        if (ComputerUtilCard.evaluatePermanentList(exiled) > 20) {
+            return true;
+        }
+
+        return false;
+    }
+
     @Override
     protected boolean doTriggerAINoCost(Player aiPlayer, SpellAbility sa, boolean mandatory) {
         // This trigger AI is completely unused, but return true just in case

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

@@ -1,5 +1,7 @@
 package forge.ai.ability;
 
+import java.util.List;
+
 import forge.ai.ComputerUtilCard;
 import forge.ai.ComputerUtilCost;
 import forge.ai.ComputerUtilMana;
@@ -17,8 +19,6 @@ import forge.game.spellability.SpellAbility;
 import forge.game.spellability.TargetRestrictions;
 import forge.game.zone.ZoneType;
 
-import java.util.List;
-
 public class SacrificeAi extends SpellAbilityAi {
     // **************************************************************
     // *************************** Sacrifice ***********************

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

@@ -1,11 +1,16 @@
 package forge.ai.ability;
 
 import com.google.common.base.Predicates;
+
 import forge.ai.ComputerUtilMana;
 import forge.ai.SpellAbilityAi;
 import forge.game.ability.ApiType;
-import forge.game.card.*;
+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;

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

@@ -1,14 +1,20 @@
 package forge.ai.ability;
 
 import com.google.common.base.Predicate;
+
 import forge.ai.ComputerUtilCard;
 import forge.ai.SpellAbilityAi;
 import forge.card.CardStateName;
 import forge.game.Game;
 import forge.game.GlobalRuleChange;
 import forge.game.ability.AbilityUtils;
-import forge.game.card.*;
+import forge.game.card.Card;
+import forge.game.card.CardCollection;
+import forge.game.card.CardLists;
 import forge.game.card.CardPredicates.Presets;
+import forge.game.card.CardState;
+import forge.game.card.CardUtil;
+import forge.game.card.CounterEnumType;
 import forge.game.phase.PhaseHandler;
 import forge.game.phase.PhaseType;
 import forge.game.player.Player;

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

@@ -0,0 +1,23 @@
+package forge.ai.ability;
+
+import forge.ai.SpellAbilityAi;
+import forge.game.player.Player;
+import forge.game.player.PlayerActionConfirmMode;
+import forge.game.spellability.SpellAbility;
+
+public class SkipPhaseAi extends SpellAbilityAi {
+    @Override
+    protected boolean canPlayAI(Player aiPlayer, SpellAbility sa) {
+        return true;
+    }
+
+    @Override
+    protected boolean doTriggerAINoCost(Player aiPlayer, SpellAbility sa, boolean mandatory) {
+        return mandatory || canPlayAI(aiPlayer, sa);
+    }
+
+    @Override
+    public boolean confirmAction(Player player, SpellAbility sa, PlayerActionConfirmMode mode, String message) {
+        return true;
+    }
+}

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

@@ -1,21 +0,0 @@
-package forge.ai.ability;
-
-import forge.ai.SpellAbilityAi;
-import forge.game.player.Player;
-import forge.game.spellability.SpellAbility;
-
-public class StoreMapAi extends SpellAbilityAi {
-
-    @Override
-    protected boolean canPlayAI(Player ai, SpellAbility sa) {
-
-        return true;
-    }
-
-    @Override
-    protected boolean doTriggerAINoCost(Player aiPlayer, SpellAbility sa, boolean mandatory) {
-
-        return true;
-    }
-
-}

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

@@ -1,5 +1,8 @@
 package forge.ai.ability;
 
+import java.util.ArrayList;
+import java.util.List;
+
 import forge.ai.ComputerUtilMana;
 import forge.ai.SpellAbilityAi;
 import forge.game.Game;
@@ -14,9 +17,6 @@ import forge.game.player.Player;
 import forge.game.spellability.SpellAbility;
 import forge.game.trigger.WrappedAbility;
 
-import java.util.ArrayList;
-import java.util.List;
-
 public class StoreSVarAi extends SpellAbilityAi {
 
     @Override

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

@@ -1,6 +1,10 @@
 package forge.ai.ability;
 
-import forge.ai.*;
+import forge.ai.AiCardMemory;
+import forge.ai.AiProps;
+import forge.ai.ComputerUtilCost;
+import forge.ai.PlayerControllerAi;
+import forge.ai.SpellAbilityAi;
 import forge.game.card.Card;
 import forge.game.cost.Cost;
 import forge.game.cost.CostPayLife;

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

@@ -1,6 +1,11 @@
 package forge.ai.ability;
 
-import forge.ai.*;
+import forge.ai.AiController;
+import forge.ai.AiProps;
+import forge.ai.ComputerUtil;
+import forge.ai.ComputerUtilCost;
+import forge.ai.PlayerControllerAi;
+import forge.ai.SpellAbilityAi;
 import forge.game.ability.AbilityUtils;
 import forge.game.card.Card;
 import forge.game.cost.Cost;

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

@@ -1,7 +1,10 @@
 package forge.ai.ability;
 
+import java.util.List;
+
 import com.google.common.base.Predicate;
 import com.google.common.collect.Iterables;
+
 import forge.ai.ComputerUtil;
 import forge.ai.ComputerUtilAbility;
 import forge.ai.ComputerUtilCard;
@@ -20,8 +23,6 @@ import forge.game.player.Player;
 import forge.game.spellability.SpellAbility;
 import forge.game.zone.ZoneType;
 
-import java.util.List;
-
 public abstract class TapAiBase extends SpellAbilityAi {
 
     /**

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

@@ -1,5 +1,7 @@
 package forge.ai.ability;
 
+import java.util.List;
+
 import com.google.common.base.Predicate;
 import com.google.common.collect.Iterables;
 
@@ -19,8 +21,6 @@ import forge.game.spellability.TargetRestrictions;
 import forge.game.zone.ZoneType;
 import forge.util.MyRandom;
 
-import java.util.List;
-
 public class TapAllAi extends SpellAbilityAi {
     @Override
     protected boolean canPlayAI(final Player ai, SpellAbility sa) {
@@ -48,7 +48,7 @@ public class TapAllAi extends SpellAbilityAi {
             validTappables = opp.getCardsIn(ZoneType.Battlefield);
         }
 
-        validTappables = CardLists.getValidCards(validTappables, valid, source.getController(), source);
+        validTappables = CardLists.getValidCards(validTappables, valid, source.getController(), source, sa);
         validTappables = CardLists.filter(validTappables, Presets.UNTAPPED);
 
         if (sa.hasParam("AILogic")) {
@@ -98,10 +98,10 @@ public class TapAllAi extends SpellAbilityAi {
         return true;
     }
 
-    private CardCollectionView getTapAllTargets(final String valid, final Card source) {
+    private CardCollectionView getTapAllTargets(final String valid, final Card source, SpellAbility sa) {
         final Game game = source.getGame();
         CardCollectionView tmpList = game.getCardsIn(ZoneType.Battlefield);
-        tmpList = CardLists.getValidCards(tmpList, valid, source.getController(), source);
+        tmpList = CardLists.getValidCards(tmpList, valid, source.getController(), source, sa);
         tmpList = CardLists.filter(tmpList, Presets.UNTAPPED);
         return tmpList;
     }
@@ -115,7 +115,7 @@ public class TapAllAi extends SpellAbilityAi {
             valid = sa.getParam("ValidCards");
         }
 
-        CardCollectionView validTappables = getTapAllTargets(valid, source);
+        CardCollectionView validTappables = getTapAllTargets(valid, source, sa);
 
         final TargetRestrictions tgt = sa.getTargetRestrictions();
 

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

@@ -4,7 +4,16 @@ import java.util.Map;
 
 import com.google.common.base.Predicate;
 import com.google.common.collect.Iterables;
-import forge.ai.*;
+
+import forge.ai.AiController;
+import forge.ai.AiProps;
+import forge.ai.ComputerUtil;
+import forge.ai.ComputerUtilCard;
+import forge.ai.ComputerUtilCost;
+import forge.ai.ComputerUtilMana;
+import forge.ai.PlayerControllerAi;
+import forge.ai.SpellAbilityAi;
+import forge.ai.SpellApiToAi;
 import forge.game.Game;
 import forge.game.GameEntity;
 import forge.game.ability.AbilityUtils;
@@ -27,7 +36,6 @@ import forge.game.spellability.AbilitySub;
 import forge.game.spellability.SpellAbility;
 import forge.game.spellability.TargetRestrictions;
 import forge.game.zone.ZoneType;
-
 import forge.util.MyRandom;
 
 /**