Limit edition range for Adventure drafts

prevent NPE

.github/workflows/maven-publish.yml

@@ -129,7 +129,9 @@ jobs:
           makeLatest: true
 
       - name: 🔧 Install XML tools
-        run: sudo apt-get install -y libxml2-utils
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y libxml2-utils
 
       - name: 🔼 Bump versionCode in root POM
         id: bump_version

.github/workflows/test-build.yaml

@@ -7,7 +7,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        java: [ '17' ]
+        java: ['17', '21']
     name: Test with Java ${{ matrix.Java }}
     steps:
       - uses: actions/checkout@v3

.gitignore

@@ -66,6 +66,9 @@ forge-gui-mobile-dev/testAssets
 
 forge-gui/res/cardsfolder/*.bat
 
+# Generated changelog file
+forge-gui/release-files/CHANGES.txt
+
 forge-gui/res/PerSetTrackingResults
 forge-gui/res/decks
 forge-gui/res/layouts
@@ -87,3 +90,7 @@ forge-gui/tools/PerSetTrackingResults
 *.tiled-session
 /forge-gui/res/adventure/*.tiled-project
 /forge-gui/res/adventure/*.tiled-session
+
+# Ignore python temporaries
+__pycache__
+*.pyc

.gitlab/issue_templates/Bug.md

@@ -1,33 +0,0 @@
-Summary
-
-(Summarize the bug encountered concisely)
-
-
-Steps to reproduce
-
-(How one can reproduce the issue - this is very important. Specific cards and specific actions especially)
-
-
-Which version of Forge are you on (Release, Snapshot? Desktop, Android?)
-
-
-What is the current bug behavior?
-
-(What actually happens)
-
-
-What is the expected correct behavior?
-
-(What you should see instead)
-
-
-Relevant logs and/or screenshots
-
-(Paste/Attach your game.log from the crash - please use code blocks (```)) Also, provide screenshots of the current state.
-
-
-Possible fixes
-
-(If you can, link to the line of code that might be responsible for the problem)
-
-/label ~needs-investigation

.gitlab/issue_templates/Feature.md

@@ -1,15 +0,0 @@
-Summary
-
-(Summarize the feature you wish concisely)
-
-
-Example screenshots
-
-(If this is a UI change, please provide an example screenshot of how this feature might work)
-
-
-Feature type
-
-(Where in Forge does this belong? e.g. Quest Mode, Deck Editor, Limited, Constructed, etc.)
-
-/label ~feature request

adventure-editor/src/main/java/forge/adventure/Main.java

@@ -15,7 +15,7 @@ public class Main {
 
     public static void main(String[] args) {
         GuiBase.setInterface(new GuiMobile(Files.exists(Paths.get("./res"))?"./":"../forge-gui/"));
-        GuiBase.setDeviceInfo("", "", 0, 0);
+        GuiBase.setDeviceInfo(null, 0, 0, System.getProperty("user.home") + "/Downloads/");
         new EditorMainWindow(Config.instance());
     }
 }

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

@@ -59,7 +59,6 @@ public class AiCardMemory {
         ATTACHED_THIS_TURN, // These equipments were attached to something already this turn
         ANIMATED_THIS_TURN, // These cards had their AF Animate effect activated this turn
         BOUNCED_THIS_TURN, // These cards were bounced this turn
-        ACTIVATED_THIS_TURN, // These cards had their ability activated this turn
         CHOSEN_FOG_EFFECT, // These cards are marked as the Fog-like effect the AI is planning to cast this turn
         MARKED_TO_AVOID_REENTRY, // These cards may cause a stack smash when processed recursively, and are thus marked to avoid a crash
         PAYS_TAP_COST, // These cards will be tapped as part of a cost and cannot be chosen in another part

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

@@ -66,13 +66,11 @@ import io.sentry.Breadcrumb;
 import io.sentry.Sentry;
 
 import java.util.*;
+import java.util.concurrent.FutureTask;
 import java.util.function.Function;
 import java.util.function.Predicate;
 import java.util.stream.Collectors;
 import java.util.concurrent.ExecutionException;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
-import java.util.concurrent.Future;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.TimeoutException;
 
@@ -99,6 +97,7 @@ public class AiController {
     private int lastAttackAggression;
     private boolean useLivingEnd;
     private List<SpellAbility> skipped;
+    private boolean timeoutReached;
 
     public AiController(final Player computerPlayer, final Game game0) {
         player = computerPlayer;
@@ -483,7 +482,7 @@ public class AiController {
 
             if (lands.size() >= Math.max(maxCmcInHand, 6)) {
                 // don't play MDFC land if other side is spell and enough lands are available
-                if (!c.isLand() || (c.isModal() && !c.getState(CardStateName.Modal).getType().isLand())) {
+                if (!c.isLand() || (c.isModal() && !c.getState(CardStateName.Backside).getType().isLand())) {
                     return false;
                 }
 
@@ -888,27 +887,8 @@ public class AiController {
     private AiPlayDecision canPlayAndPayForFace(final SpellAbility sa) {
         final Card host = sa.getHostCard();
 
-        // Check a predefined condition
-        if (sa.hasParam("AICheckSVar")) {
-            final String svarToCheck = sa.getParam("AICheckSVar");
-            String comparator = "GE";
-            int compareTo = 1;
-
-            if (sa.hasParam("AISVarCompare")) {
-                final String fullCmp = sa.getParam("AISVarCompare");
-                comparator = fullCmp.substring(0, 2);
-                final String strCmpTo = fullCmp.substring(2);
-                try {
-                    compareTo = Integer.parseInt(strCmpTo);
-                } catch (final Exception ignored) {
-                    compareTo = AbilityUtils.calculateAmount(host, host.getSVar(strCmpTo), sa);
-                }
-            }
-
-            int left = AbilityUtils.calculateAmount(host, svarToCheck, sa);
-            if (!Expressions.compare(left, comparator, compareTo)) {
-                return AiPlayDecision.AnotherTime;
-            }
+        if (sa.hasParam("AICheckSVar") && !aiShouldRun(sa, sa, host, null)) {
+            return AiPlayDecision.AnotherTime;
         }
 
         // this is the "heaviest" check, which also sets up targets, defines X, etc.
@@ -926,7 +906,7 @@ public class AiController {
 
         // check if enough left (pass memory indirectly because we don't want to include those)
         Set<Card> tappedForMana = AiCardMemory.getMemorySet(player, MemorySet.PAYS_TAP_COST);
-        if (tappedForMana != null && tappedForMana.isEmpty() &&
+        if (tappedForMana != null && !tappedForMana.isEmpty() &&
                 !ComputerUtilCost.checkTapTypeCost(player, sa.getPayCosts(), host, sa, new CardCollection(tappedForMana))) {
             return AiPlayDecision.CantAfford;
         }
@@ -1666,8 +1646,10 @@ public class AiController {
             Sentry.captureMessage(ex.getMessage() + "\nAssertionError [verifyTransitivity]: " + assertex);
         }
 
-        final ExecutorService executor = Executors.newSingleThreadExecutor();
-        Future<SpellAbility> future = executor.submit(() -> {
+        // in case of infinite loop reset below would not be reached
+        timeoutReached = false;
+
+        FutureTask<SpellAbility> future = new FutureTask<>(() -> {
             //avoid ComputerUtil.aiLifeInDanger in loops as it slows down a lot.. call this outside loops will generally be fast...
             boolean isLifeInDanger = useLivingEnd && ComputerUtil.aiLifeInDanger(player, true, 0);
             for (final SpellAbility sa : ComputerUtilAbility.getOriginalAndAltCostAbilities(all, player)) {
@@ -1676,6 +1658,11 @@ public class AiController {
                     continue;
                 }
 
+                if (timeoutReached) {
+                    timeoutReached = false;
+                    break;
+                }
+
                 if (sa.getHostCard().hasKeyword(Keyword.STORM)
                         && sa.getApi() != ApiType.Counter // AI would suck at trying to deliberately proc a Storm counterspell
                         && player.getZone(ZoneType.Hand).contains(
@@ -1745,11 +1732,21 @@ public class AiController {
             return null;
         });
 
-        // instead of computing all available concurrently just add a simple timeout depending on the user prefs
+        Thread t = new Thread(future);
+        t.start();
         try {
+            // instead of computing all available concurrently just add a simple timeout depending on the user prefs
             return future.get(game.getAITimeout(), TimeUnit.SECONDS);
         } catch (InterruptedException | ExecutionException | TimeoutException e) {
-            future.cancel(true);
+            try {
+                t.stop();
+            } catch (UnsupportedOperationException ex) {
+                // Android and Java 20 dropped support to stop so sadly thread will keep running
+                timeoutReached = true;
+                future.cancel(true);
+                // TODO wait a few more seconds to try and exit at a safe point before letting the engine continue
+                // TODO mark some as skipped to increase chance to find something playable next priority
+            }
             return null;
         }
     }
@@ -1801,14 +1798,9 @@ public class AiController {
      * @param sa the sa
      * @return true, if successful
      */
-    public final boolean aiShouldRun(final ReplacementEffect effect, final SpellAbility sa, GameEntity affected) {
-        Card hostCard = effect.getHostCard();
-        if (hostCard.hasAlternateState()) {
-            hostCard = game.getCardState(hostCard);
-        }
-
+    public final boolean aiShouldRun(final CardTraitBase effect, final SpellAbility sa, final Card host, final GameEntity affected) {
         if (effect.hasParam("AILogic") && effect.getParam("AILogic").equalsIgnoreCase("ProtectFriendly")) {
-            final Player controller = hostCard.getController();
+            final Player controller = host.getController();
             if (affected instanceof Player) {
                 return !((Player) affected).isOpponentOf(controller);
             }
@@ -1817,7 +1809,6 @@ public class AiController {
             }
         }
         if (effect.hasParam("AICheckSVar")) {
-            System.out.println("aiShouldRun?" + sa);
             final String svarToCheck = effect.getParam("AICheckSVar");
             String comparator = "GE";
             int compareTo = 1;
@@ -1830,9 +1821,9 @@ public class AiController {
                     compareTo = Integer.parseInt(strCmpTo);
                 } catch (final Exception ignored) {
                     if (sa == null) {
-                        compareTo = AbilityUtils.calculateAmount(hostCard, hostCard.getSVar(strCmpTo), effect);
+                        compareTo = AbilityUtils.calculateAmount(host, host.getSVar(strCmpTo), effect);
                     } else {
-                        compareTo = AbilityUtils.calculateAmount(hostCard, hostCard.getSVar(strCmpTo), sa);
+                        compareTo = AbilityUtils.calculateAmount(host, host.getSVar(strCmpTo), sa);
                     }
                 }
             }
@@ -1840,13 +1831,12 @@ public class AiController {
             int left = 0;
 
             if (sa == null) {
-                left = AbilityUtils.calculateAmount(hostCard, svarToCheck, effect);
+                left = AbilityUtils.calculateAmount(host, svarToCheck, effect);
             } else {
-                left = AbilityUtils.calculateAmount(hostCard, svarToCheck, sa);
+                left = AbilityUtils.calculateAmount(host, svarToCheck, sa);
             }
-            System.out.println("aiShouldRun?" + left + comparator + compareTo);
             return Expressions.compare(left, comparator, compareTo);
-        } else if (effect.hasParam("AICheckDredge")) {
+        } else if (effect.isKeyword(Keyword.DREDGE)) {
             return player.getCardsIn(ZoneType.Library).size() > 8 || player.isCardInPlay("Laboratory Maniac");
         } else return sa != null && doTrigger(sa, false);
     }

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

@@ -29,12 +29,15 @@ public class AiCostDecision extends CostDecisionMakerBase {
     private final CardCollection tapped;
 
     public AiCostDecision(Player ai0, SpellAbility sa, final boolean effect) {
+        this(ai0, sa, effect, false);
+    }
+    public AiCostDecision(Player ai0, SpellAbility sa, final boolean effect, final boolean payMana) {
         super(ai0, effect, sa, sa.getHostCard());
 
         discarded = new CardCollection();
         tapped = new CardCollection();
         Set<Card> tappedForMana = AiCardMemory.getMemorySet(ai0, MemorySet.PAYS_TAP_COST);
-        if (tappedForMana != null) {
+        if (!payMana && tappedForMana != null) {
             tapped.addAll(tappedForMana);
         }
     }
@@ -110,7 +113,7 @@ public class AiCostDecision extends CostDecisionMakerBase {
                 randomSubset = ability.getActivatingPlayer().getController().orderMoveToZoneList(randomSubset, ZoneType.Graveyard, ability);
             }
             return PaymentDecision.card(randomSubset);
-        } else if (type.equals("DifferentNames")) {
+        } else if (type.contains("+WithDifferentNames")) {
             CardCollection differentNames = new CardCollection();
             CardCollection discardMe = CardLists.filter(hand, CardPredicates.hasSVar("DiscardMe"));
             while (c > 0) {
@@ -563,7 +566,7 @@ public class AiCostDecision extends CostDecisionMakerBase {
                 int thisRemove = Math.min(prefCard.getCounters(cType), stillToRemove);
                 if (thisRemove > 0) {
                     removed += thisRemove;
-                    table.put(null, prefCard, CounterType.get(cType), thisRemove);
+                    table.put(null, prefCard, cType, thisRemove);
                 }
             }
         }
@@ -573,7 +576,7 @@ public class AiCostDecision extends CostDecisionMakerBase {
     @Override
     public PaymentDecision visit(CostRemoveAnyCounter cost) {
         final int c = cost.getAbilityAmount(ability);
-        final Card originalHost = ObjectUtils.defaultIfNull(ability.getOriginalHost(), source);
+        final Card originalHost = ObjectUtils.getIfNull(ability.getOriginalHost(), source);
 
         if (c <= 0) {
             return null;
@@ -716,7 +719,7 @@ public class AiCostDecision extends CostDecisionMakerBase {
                 int over = Math.min(crd.getCounters(CounterEnumType.QUEST) - e, c - toRemove);
                 if (over > 0) {
                     toRemove += over;
-                    table.put(null, crd, CounterType.get(CounterEnumType.QUEST), over);
+                    table.put(null, crd, CounterEnumType.QUEST, over);
                 }
             }
         }

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

@@ -19,7 +19,7 @@ public enum AiPlayDecision {
     StackNotEmpty,
     AnotherTime,
 
-    // Don't play decision reasons,
+    // Don't play decision reasons
     CantPlaySa,
     CantPlayAi,
     CantAfford,

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

@@ -767,7 +767,7 @@ public class ComputerUtil {
     public static CardCollection chooseUntapType(final Player ai, final String type, final Card activate, final boolean untap, final int amount, SpellAbility sa) {
         CardCollection typeList = CardLists.getValidCards(ai.getCardsIn(ZoneType.Battlefield), type.split(";"), activate.getController(), activate, sa);
 
-        typeList = CardLists.filter(typeList, CardPredicates.TAPPED, c -> c.getCounters(CounterEnumType.STUN) == 0 || c.canRemoveCounters(CounterType.get(CounterEnumType.STUN)));
+        typeList = CardLists.filter(typeList, CardPredicates.TAPPED, c -> c.getCounters(CounterEnumType.STUN) == 0 || c.canRemoveCounters(CounterEnumType.STUN));
 
         if (untap) {
             typeList.remove(activate);
@@ -1074,6 +1074,80 @@ public class ComputerUtil {
         return prevented;
     }
 
+    /**
+     * Is it OK to cast this for less than the Max Targets?
+     * @param source the source Card
+     * @return true if it's OK to cast this Card for less than the max targets
+     */
+    public static boolean shouldCastLessThanMax(final Player ai, final Card source) {
+        if (source.getXManaCostPaid() > 0) {
+            // If TargetMax is MaxTgts (i.e., an "X" cost), this is fine because AI is limited by payment resources available.
+            return true;
+        }
+        if (aiLifeInDanger(ai, false, 0)) {
+            // Otherwise, if life is possibly in danger, then this is fine.
+            return true;
+        }
+        // do not play now.
+        return false;
+    }
+
+    /**
+     * Is this discard probably worse than a random draw?
+     * @param discard Card to discard
+     * @return boolean
+     */
+    public static boolean isWorseThanDraw(final Player ai, Card discard) {
+        if (discard.hasSVar("DiscardMe")) {
+            return true;
+        }
+
+        final Game game = ai.getGame();
+        final CardCollection landsInPlay = CardLists.filter(ai.getCardsIn(ZoneType.Battlefield), CardPredicates.LANDS_PRODUCING_MANA);
+        final CardCollection landsInHand = CardLists.filter(ai.getCardsIn(ZoneType.Hand), CardPredicates.LANDS);
+        final CardCollection nonLandsInHand = CardLists.getNotType(ai.getCardsIn(ZoneType.Hand), "Land");
+        final int highestCMC = Math.max(6, Aggregates.max(nonLandsInHand, Card::getCMC));
+        final int discardCMC = discard.getCMC();
+        if (discard.isLand()) {
+            if (landsInPlay.size() >= highestCMC
+                    || (landsInPlay.size() + landsInHand.size() > 6 && landsInHand.size() > 1)
+                    || (landsInPlay.size() > 3 && nonLandsInHand.size() == 0)) {
+                // Don't need more land.
+                return true;
+            }
+        } else { //non-land
+            if (discardCMC > landsInPlay.size() + landsInHand.size() + 2) {
+                // not castable for some time.
+                return true;
+            } else if (!game.getPhaseHandler().isPlayerTurn(ai)
+                    && game.getPhaseHandler().getPhase().isAfter(PhaseType.MAIN2)
+                    && discardCMC > landsInPlay.size() + landsInHand.size()
+                    && discardCMC > landsInPlay.size() + 1
+                    && nonLandsInHand.size() > 1) {
+                // not castable for at least one other turn.
+                return true;
+            } else if (landsInPlay.size() > 5 && discard.getCMC() <= 1
+                    && !discard.hasProperty("hasXCost", ai, null, null)) {
+                // Probably don't need small stuff now.
+                return true;
+            }
+        }
+        return false;
+    }
+
+    // returns true if it's better to wait until blockers are declared
+    public static boolean waitForBlocking(final SpellAbility sa) {
+        final Game game = sa.getActivatingPlayer().getGame();
+        final PhaseHandler ph = game.getPhaseHandler();
+
+        return sa.getHostCard().isCreature()
+                && sa.getPayCosts().hasTapCost()
+                && (ph.getPhase().isBefore(PhaseType.COMBAT_DECLARE_BLOCKERS)
+                        && !ph.getNextTurn().equals(sa.getActivatingPlayer()))
+                && !sa.getHostCard().hasSVar("EndOfTurnLeavePlay")
+                && !sa.hasParam("ActivationPhases");
+    }
+
     public static boolean castPermanentInMain1(final Player ai, final SpellAbility sa) {
         final Card card = sa.getHostCard();
         final CardState cardState = card.isFaceDown() ? card.getState(CardStateName.Original) : card.getCurrentState();
@@ -1245,80 +1319,6 @@ public class ComputerUtil {
         return false;
     }
 
-    /**
-     * Is it OK to cast this for less than the Max Targets?
-     * @param source the source Card
-     * @return true if it's OK to cast this Card for less than the max targets
-     */
-    public static boolean shouldCastLessThanMax(final Player ai, final Card source) {
-        if (source.getXManaCostPaid() > 0) {
-            // If TargetMax is MaxTgts (i.e., an "X" cost), this is fine because AI is limited by payment resources available.
-            return true;
-        }
-        if (aiLifeInDanger(ai, false, 0)) {
-            // Otherwise, if life is possibly in danger, then this is fine.
-            return true;
-        }
-        // do not play now.
-        return false;
-    }
-
-    /**
-     * Is this discard probably worse than a random draw?
-     * @param discard Card to discard
-     * @return boolean
-     */
-    public static boolean isWorseThanDraw(final Player ai, Card discard) {
-        if (discard.hasSVar("DiscardMe")) {
-            return true;
-        }
-
-        final Game game = ai.getGame();
-        final CardCollection landsInPlay = CardLists.filter(ai.getCardsIn(ZoneType.Battlefield), CardPredicates.LANDS_PRODUCING_MANA);
-        final CardCollection landsInHand = CardLists.filter(ai.getCardsIn(ZoneType.Hand), CardPredicates.LANDS);
-        final CardCollection nonLandsInHand = CardLists.getNotType(ai.getCardsIn(ZoneType.Hand), "Land");
-        final int highestCMC = Math.max(6, Aggregates.max(nonLandsInHand, Card::getCMC));
-        final int discardCMC = discard.getCMC();
-        if (discard.isLand()) {
-            if (landsInPlay.size() >= highestCMC
-                    || (landsInPlay.size() + landsInHand.size() > 6 && landsInHand.size() > 1)
-                    || (landsInPlay.size() > 3 && nonLandsInHand.size() == 0)) {
-                // Don't need more land.
-                return true;
-            }
-        } else { //non-land
-            if (discardCMC > landsInPlay.size() + landsInHand.size() + 2) {
-                // not castable for some time.
-                return true;
-            } else if (!game.getPhaseHandler().isPlayerTurn(ai)
-                    && game.getPhaseHandler().getPhase().isAfter(PhaseType.MAIN2)
-                    && discardCMC > landsInPlay.size() + landsInHand.size()
-                    && discardCMC > landsInPlay.size() + 1
-                    && nonLandsInHand.size() > 1) {
-                // not castable for at least one other turn.
-                return true;
-            } else if (landsInPlay.size() > 5 && discard.getCMC() <= 1
-                    && !discard.hasProperty("hasXCost", ai, null, null)) {
-                // Probably don't need small stuff now.
-                return true;
-            }
-        }
-        return false;
-    }
-
-    // returns true if it's better to wait until blockers are declared
-    public static boolean waitForBlocking(final SpellAbility sa) {
-        final Game game = sa.getActivatingPlayer().getGame();
-        final PhaseHandler ph = game.getPhaseHandler();
-
-        return sa.getHostCard().isCreature()
-                && sa.getPayCosts().hasTapCost()
-                && (ph.getPhase().isBefore(PhaseType.COMBAT_DECLARE_BLOCKERS)
-                        && !ph.getNextTurn().equals(sa.getActivatingPlayer()))
-                && !sa.getHostCard().hasSVar("EndOfTurnLeavePlay")
-                && !sa.hasParam("ActivationPhases");
-    }
-
     public static boolean castSpellInMain1(final Player ai, final SpellAbility sa) {
         final Card source = sa.getHostCard();
         final SpellAbility sub = sa.getSubAbility();
@@ -1327,7 +1327,6 @@ public class ComputerUtil {
             return true;
         }
 
-        // Cipher spells
         if (sub != null) {
             final ApiType api = sub.getApi();
             if (ApiType.Encode == api && !ai.getCreaturesInPlay().isEmpty()) {
@@ -1622,7 +1621,6 @@ public class ComputerUtil {
                 damage = dmg;
             }
 
-            // Triggered abilities
             if (c.isCreature() && c.isInPlay() && CombatUtil.canAttack(c)) {
                 for (final Trigger t : c.getTriggers()) {
                     if (TriggerType.Attacks.equals(t.getMode())) {
@@ -2544,7 +2542,7 @@ public class ComputerUtil {
 
         boolean opponent = controller.isOpponentOf(ai);
 
-        final CounterType p1p1Type = CounterType.get(CounterEnumType.P1P1);
+        final CounterType p1p1Type = CounterEnumType.P1P1;
 
         if (!sa.hasParam("AILogic")) {
             return Aggregates.random(options);
@@ -2553,7 +2551,7 @@ public class ComputerUtil {
         String logic = sa.getParam("AILogic");
         switch (logic) {
         case "Torture":
-            return "Torture";
+            return options.get(1);
         case "GraceOrCondemnation":
             List<ZoneType> graceZones = new ArrayList<ZoneType>();
             graceZones.add(ZoneType.Battlefield);
@@ -2561,12 +2559,12 @@ public class ComputerUtil {
             CardCollection graceCreatures = CardLists.getType(game.getCardsIn(graceZones), "Creature");
             int humanGrace = CardLists.filterControlledBy(graceCreatures, ai.getOpponents()).size();
             int aiGrace = CardLists.filterControlledBy(graceCreatures, ai).size();
-            return aiGrace > humanGrace ? "Grace" : "Condemnation";
+            return options.get(aiGrace > humanGrace ? 0 : 1);
         case "CarnageOrHomage":
             CardCollection cardsInPlay = CardLists.getNotType(game.getCardsIn(ZoneType.Battlefield), "Land");
             CardCollection humanlist = CardLists.filterControlledBy(cardsInPlay, ai.getOpponents());
             CardCollection computerlist = ai.getCreaturesInPlay();
-            return ComputerUtilCard.evaluatePermanentList(computerlist) + 3 < ComputerUtilCard.evaluatePermanentList(humanlist) ? "Carnage" : "Homage";
+            return options.get(ComputerUtilCard.evaluatePermanentList(computerlist) + 3 < ComputerUtilCard.evaluatePermanentList(humanlist) ? 0 : 1);
         case "Judgment":
             if (votes.isEmpty()) {
                 CardCollection list = new CardCollection();
@@ -2580,68 +2578,71 @@ public class ComputerUtil {
             return Iterables.getFirst(votes.keySet(), null);
         case "Protection":
             if (votes.isEmpty()) {
-                List<String> restrictedToColors = Lists.newArrayList();
+                Map<String, SpellAbility> restrictedToColors = Maps.newHashMap();
                 for (Object o : options) {
-                    if (o instanceof String) {
-                        restrictedToColors.add((String) o);
-                        }
+                    if (o instanceof SpellAbility sp) { // TODO check for Color Word Changes
+                        restrictedToColors.put(sp.getOriginalDescription(), sp);
                     }
+                }
                 CardCollection lists = CardLists.filterControlledBy(game.getCardsInGame(), ai.getOpponents());
-                return StringUtils.capitalize(ComputerUtilCard.getMostProminentColor(lists, restrictedToColors));
+                return restrictedToColors.get(StringUtils.capitalize(ComputerUtilCard.getMostProminentColor(lists, restrictedToColors.keySet())));
             }
             return Iterables.getFirst(votes.keySet(), null);
         case "FeatherOrQuill":
+            SpellAbility feather = (SpellAbility)options.get(0);
+            SpellAbility quill = (SpellAbility)options.get(1);
             // try to mill opponent with Quill vote
             if (opponent && !controller.cantLoseCheck(GameLossReason.Milled)) {
-                int numQuill = votes.get("Quill").size();
+                int numQuill = votes.get(quill).size();
                 if (numQuill + 1 >= controller.getCardsIn(ZoneType.Library).size()) {
-                    return controller.isCardInPlay("Laboratory Maniac") ? "Feather" : "Quill";
+                    return controller.isCardInPlay("Laboratory Maniac") ? feather : quill;
                 }
             }
             // is it can't receive counters, choose +1/+1 ones
             if (!source.canReceiveCounters(p1p1Type)) {
-                return opponent ? "Feather" : "Quill";
+                return opponent ? feather : quill;
             }
             // if source is not on the battlefield anymore, choose +1/+1 ones
             if (!game.getCardState(source).isInPlay()) {
-                return opponent ? "Feather" : "Quill";
+                return opponent ? feather : quill;
             }
             // if no hand cards, try to mill opponent
             if (controller.getCardsIn(ZoneType.Hand).isEmpty()) {
-                return opponent ? "Quill" : "Feather";
+                return opponent ? quill : feather;
             }
 
             // AI has something to discard
             if (ai.equals(controller)) {
                 CardCollectionView aiCardsInHand = ai.getCardsIn(ZoneType.Hand);
                 if (CardLists.count(aiCardsInHand, CardPredicates.hasSVar("DiscardMe")) >= 1) {
-                    return "Quill";
+                    return quill;
                 }
             }
 
             // default card draw and discard are better than +1/+1 counter
-            return opponent ? "Feather" : "Quill";
+            return opponent ? feather : quill;
         case "StrengthOrNumbers":
+            SpellAbility strength = (SpellAbility)options.get(0);
+            SpellAbility numbers = (SpellAbility)options.get(1);
             // similar to fabricate choose +1/+1 or Token
-            final SpellAbility saToken = sa.findSubAbilityByType(ApiType.Token);
-            int numStrength = votes.get("Strength").size();
-            int numNumbers = votes.get("Numbers").size();
+            int numStrength = votes.get(strength).size();
+            int numNumbers = votes.get(numbers).size();
 
-            Card token = TokenAi.spawnToken(controller, saToken);
+            Card token = TokenAi.spawnToken(controller, numbers);
 
             // is it can't receive counters, choose +1/+1 ones
             if (!source.canReceiveCounters(p1p1Type)) {
-                return opponent ? "Strength" : "Numbers";
+                return opponent ? strength : numbers;
             }
 
             // if source is not on the battlefield anymore
             if (!game.getCardState(source).isInPlay()) {
-                return opponent ? "Strength" : "Numbers";
+                return opponent ? strength : numbers;
             }
 
             // token would not survive
             if (token == null || !token.isCreature()  || token.getNetToughness() < 1) {
-                return opponent ? "Numbers" : "Strength";
+                return opponent ? numbers : strength;
             }
 
             // TODO check for ETB to +1/+1 counters or over another trigger like lifegain
@@ -2662,35 +2663,40 @@ public class ComputerUtil {
             int scoreStrength = ComputerUtilCard.evaluateCreature(sourceStrength) + tokenScore * numNumbers;
             int scoreNumbers = ComputerUtilCard.evaluateCreature(sourceNumbers) + tokenScore * (numNumbers + 1);
 
-            return (scoreNumbers >= scoreStrength) != opponent ? "Numbers" : "Strength";
+            return (scoreNumbers >= scoreStrength) != opponent ? numbers : strength;
         case "SproutOrHarvest":
+            SpellAbility sprout = (SpellAbility)options.get(0);
+            SpellAbility harvest = (SpellAbility)options.get(1);
             // lifegain would hurt or has no effect
             if (opponent) {
                 if (lifegainNegative(controller, source)) {
-                    return "Harvest";
+                    return harvest;
                 }
             } else {
                 if (lifegainNegative(controller, source)) {
-                    return "Sprout";
+                    return sprout;
                 }
             }
 
             // is it can't receive counters, choose +1/+1 ones
             if (!source.canReceiveCounters(p1p1Type)) {
-                return opponent ? "Sprout" : "Harvest";
+                return opponent ? sprout : harvest;
             }
 
             // if source is not on the battlefield anymore
             if (!game.getCardState(source).isInPlay()) {
-                return opponent ? "Sprout" : "Harvest";
+                return opponent ? sprout : harvest;
             }
             // TODO add Lifegain to +1/+1 counters trigger
 
             // for now +1/+1 counters are better
-            return opponent ? "Harvest" : "Sprout";
+            return opponent ? harvest : sprout;
         case "DeathOrTaxes":
-            int numDeath = votes.get("Death").size();
-            int numTaxes = votes.get("Taxes").size();
+            SpellAbility death = (SpellAbility)options.get(0);
+            SpellAbility taxes = (SpellAbility)options.get(1);
+
+            int numDeath = votes.get(death).size();
+            int numTaxes = votes.get(taxes).size();
 
             if (opponent) {
                 CardCollection aiCreatures = ai.getCreaturesInPlay();
@@ -2698,29 +2704,29 @@ public class ComputerUtil {
                 // would need to sacrifice more creatures than AI has
                 // sacrifice even more
                 if (aiCreatures.size() <= numDeath) {
-                    return "Death";
+                    return death;
                 }
                 // would need to discard more cards than it has
                 if (aiCardsInHand.size() <= numTaxes) {
-                    return "Taxes";
+                    return taxes;
                 }
 
                 // has cards with SacMe or Token
                 if (CardLists.count(aiCreatures, CardPredicates.hasSVar("SacMe").or(CardPredicates.TOKEN)) >= numDeath) {
-                    return "Death";
+                    return death;
                 }
 
                 // has cards with DiscardMe
                 if (CardLists.count(aiCardsInHand, CardPredicates.hasSVar("DiscardMe")) >= numTaxes) {
-                    return "Taxes";
+                    return taxes;
                 }
 
                 // discard is probably less worse than sacrifice
-                return "Taxes";
+                return taxes;
             } else {
                 // ai is first voter or ally of controller
                 // both are not affected, but if opponents control creatures, sacrifice is worse
-                return controller.getOpponents().getCreaturesInPlay().isEmpty() ? "Taxes" : "Death";
+                return controller.getOpponents().getCreaturesInPlay().isEmpty() ? taxes : death;
             }
         default:
             return Iterables.getFirst(options, null);
@@ -2737,7 +2743,7 @@ public class ComputerUtil {
         return safeCards;
     }
 
-    public static Card getKilledByTargeting(final SpellAbility sa, Iterable<Card> validCards) {
+    public static Card getKilledByTargeting(final SpellAbility sa, CardCollectionView validCards) {
         CardCollection killables = CardLists.filter(validCards, c -> c.getController() != sa.getActivatingPlayer() && c.getSVar("Targeting").equals("Dies"));
         return ComputerUtilCard.getBestCreatureAI(killables);
     }
@@ -3098,41 +3104,38 @@ public class ComputerUtil {
 
     public static CardCollection filterAITgts(SpellAbility sa, Player ai, CardCollection srcList, boolean alwaysStrict) {
         final Card source = sa.getHostCard();
-        if (source == null) { return srcList; }
-
-        if (sa.hasParam("AITgts")) {
-            CardCollection list;
-            String aiTgts = sa.getParam("AITgts");
-            if (aiTgts.startsWith("BetterThan")) {
-                int value = 0;
-                if (aiTgts.endsWith("Source")) {
-                    value = ComputerUtilCard.evaluateCreature(source);
-                    if (source.isEnchanted()) {
-                        for (Card enc : source.getEnchantedBy()) {
-                            if (enc.getController().equals(ai)) {
-                                value += 100; // is 100 per AI's own aura enough?
-                            }
-                        }
-                    }
-                } else if (aiTgts.contains("EvalRating.")) {
-                    value = AbilityUtils.calculateAmount(source, aiTgts.substring(aiTgts.indexOf(".") + 1), sa);
-                } else {
-                    System.err.println("Warning: Unspecified AI target evaluation rating for SA " + sa);
-                    value = ComputerUtilCard.evaluateCreature(source);
-                }
-                final int totalValue = value;
-                list = CardLists.filter(srcList, c -> ComputerUtilCard.evaluateCreature(c) > totalValue + 30);
-            } else {
-                list = CardLists.getValidCards(srcList, sa.getParam("AITgts"), sa.getActivatingPlayer(), source, sa);
-            }
-
-            if (!list.isEmpty() || sa.hasParam("AITgtsStrict") || alwaysStrict) {
-                return list;
-            } else {
-                return srcList;
-            }
+        if (source == null || !sa.hasParam("AITgts")) {
+            return srcList;
         }
 
+        CardCollection list;
+        String aiTgts = sa.getParam("AITgts");
+        if (aiTgts.startsWith("BetterThan")) {
+            int value = 0;
+            if (aiTgts.endsWith("Source")) {
+                value = ComputerUtilCard.evaluateCreature(source);
+                if (source.isEnchanted()) {
+                    for (Card enc : source.getEnchantedBy()) {
+                        if (enc.getController().equals(ai)) {
+                            value += 100; // is 100 per AI's own aura enough?
+                        }
+                    }
+                }
+            } else if (aiTgts.contains("EvalRating.")) {
+                value = AbilityUtils.calculateAmount(source, aiTgts.substring(aiTgts.indexOf(".") + 1), sa);
+            } else {
+                System.err.println("Warning: Unspecified AI target evaluation rating for SA " + sa);
+                value = ComputerUtilCard.evaluateCreature(source);
+            }
+            final int totalValue = value;
+            list = CardLists.filter(srcList, c -> ComputerUtilCard.evaluateCreature(c) > totalValue + 30);
+        } else {
+            list = CardLists.getValidCards(srcList, sa.getParam("AITgts"), sa.getActivatingPlayer(), source, sa);
+        }
+
+        if (!list.isEmpty() || sa.hasParam("AITgtsStrict") || alwaysStrict) {
+            return list;
+        }
         return srcList;
     }
 

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

@@ -919,14 +919,14 @@ public class ComputerUtilCard {
         return MagicColor.Constant.WHITE; // no difference, there was no prominent color
     }
 
-    public static String getMostProminentColor(final CardCollectionView list, final List<String> restrictedToColors) {
+    public static String getMostProminentColor(final CardCollectionView list, final Iterable<String> restrictedToColors) {
         byte colors = CardFactoryUtil.getMostProminentColorsFromList(list, restrictedToColors);
         for (byte c : MagicColor.WUBRG) {
             if ((colors & c) != 0) {
                 return MagicColor.toLongString(c);
             }
         }
-        return restrictedToColors.get(0); // no difference, there was no prominent color
+        return Iterables.get(restrictedToColors, 0); // no difference, there was no prominent color
     }
 
     public static List<String> getColorByProminence(final List<Card> list) {

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

@@ -974,17 +974,13 @@ public class ComputerUtilCombat {
                 continue;
             }
 
+            int pBonus = 0;
             if (ability.getApi() == ApiType.Pump) {
                 if (!ability.hasParam("NumAtt")) {
                     continue;
                 }
 
-                if (ComputerUtilCost.canPayCost(ability, blocker.getController(), false)) {
-                    int pBonus = AbilityUtils.calculateAmount(ability.getHostCard(), ability.getParam("NumAtt"), ability);
-                    if (pBonus > 0) {
-                        power += pBonus;
-                    }
-                }
+                pBonus = AbilityUtils.calculateAmount(ability.getHostCard(), ability.getParam("NumAtt"), ability);
             } else if (ability.getApi() == ApiType.PutCounter) {
                 if (!ability.hasParam("CounterType") || !ability.getParam("CounterType").equals("P1P1")) {
                     continue;
@@ -998,12 +994,11 @@ public class ComputerUtilCombat {
                     continue;
                 }
 
-                if (ComputerUtilCost.canPayCost(ability, blocker.getController(), false)) {
-                    int pBonus = AbilityUtils.calculateAmount(ability.getHostCard(), ability.getParamOrDefault("CounterNum", "1"), ability);
-                    if (pBonus > 0) {
-                        power += pBonus;
-                    }
-                }
+                pBonus = AbilityUtils.calculateAmount(ability.getHostCard(), ability.getParamOrDefault("CounterNum", "1"), ability);
+            }
+
+            if (pBonus > 0 && ComputerUtilCost.canPayCost(ability, blocker.getController(), false)) {
+                power += pBonus;
             }
         }
 
@@ -1107,17 +1102,13 @@ public class ComputerUtilCombat {
                 continue;
             }
 
+            int tBonus = 0;
             if (ability.getApi() == ApiType.Pump) {
                 if (!ability.hasParam("NumDef")) {
                     continue;
                 }
 
-                if (ComputerUtilCost.canPayCost(ability, blocker.getController(), false)) {
-                    int tBonus = AbilityUtils.calculateAmount(ability.getHostCard(), ability.getParam("NumDef"), ability);
-                    if (tBonus > 0) {
-                        toughness += tBonus;
-                    }
-                }
+                tBonus = AbilityUtils.calculateAmount(ability.getHostCard(), ability.getParam("NumDef"), ability);
             } else if (ability.getApi() == ApiType.PutCounter) {
                 if (!ability.hasParam("CounterType") || !ability.getParam("CounterType").equals("P1P1")) {
                     continue;
@@ -1131,12 +1122,11 @@ public class ComputerUtilCombat {
                     continue;
                 }
 
-                if (ComputerUtilCost.canPayCost(ability, blocker.getController(), false)) {
-                    int tBonus = AbilityUtils.calculateAmount(ability.getHostCard(), ability.getParamOrDefault("CounterNum", "1"), ability);
-                    if (tBonus > 0) {
-                        toughness += tBonus;
-                    }
-                }
+                tBonus = AbilityUtils.calculateAmount(ability.getHostCard(), ability.getParamOrDefault("CounterNum", "1"), ability);
+            }
+
+            if (tBonus > 0 && ComputerUtilCost.canPayCost(ability, blocker.getController(), false)) {
+                toughness += tBonus;
             }
         }
         return toughness;
@@ -1305,6 +1295,7 @@ public class ComputerUtilCombat {
                 continue;
             }
 
+            int pBonus = 0;
             if (ability.getApi() == ApiType.Pump) {
                 if (!ability.hasParam("NumAtt")) {
                     continue;
@@ -1314,11 +1305,8 @@ public class ComputerUtilCombat {
                     continue;
                 }
 
-                if (!ability.getPayCosts().hasTapCost() && ComputerUtilCost.canPayCost(ability, attacker.getController(), false)) {
-                    int pBonus = AbilityUtils.calculateAmount(ability.getHostCard(), ability.getParam("NumAtt"), ability);
-                    if (pBonus > 0) {
-                        power += pBonus;
-                    }
+                if (!ability.getPayCosts().hasTapCost()) {
+                    pBonus = AbilityUtils.calculateAmount(ability.getHostCard(), ability.getParam("NumAtt"), ability);
                 }
             } else if (ability.getApi() == ApiType.PutCounter) {
                 if (!ability.hasParam("CounterType") || !ability.getParam("CounterType").equals("P1P1")) {
@@ -1333,13 +1321,14 @@ public class ComputerUtilCombat {
                     continue;
                 }
 
-                if (!ability.getPayCosts().hasTapCost() && ComputerUtilCost.canPayCost(ability, attacker.getController(), false)) {
-                    int pBonus = AbilityUtils.calculateAmount(ability.getHostCard(), ability.getParamOrDefault("CounterNum", "1"), ability);
-                    if (pBonus > 0) {
-                        power += pBonus;
-                    }
+                if (!ability.getPayCosts().hasTapCost()) {
+                    pBonus = AbilityUtils.calculateAmount(ability.getHostCard(), ability.getParamOrDefault("CounterNum", "1"), ability);
                 }
             }
+
+            if (pBonus > 0 && ComputerUtilCost.canPayCost(ability, attacker.getController(), false)) {
+                power += pBonus;
+            }
         }
         return power;
     }
@@ -1530,16 +1519,14 @@ public class ComputerUtilCombat {
             if (ability.getPayCosts().hasTapCost() && !attacker.hasKeyword(Keyword.VIGILANCE)) {
                 continue;
             }
-            if (!ComputerUtilCost.canPayCost(ability, attacker.getController(), false)) {
-                continue;
-            }
 
+            int tBonus = 0;
             if (ability.getApi() == ApiType.Pump) {
                 if (!ability.hasParam("NumDef")) {
                     continue;
                 }
 
-                toughness += AbilityUtils.calculateAmount(ability.getHostCard(), ability.getParam("NumDef"), ability, true);
+                tBonus = AbilityUtils.calculateAmount(ability.getHostCard(), ability.getParam("NumDef"), ability, true);
             } else if (ability.getApi() == ApiType.PutCounter) {
                 if (!ability.hasParam("CounterType") || !ability.getParam("CounterType").equals("P1P1")) {
                     continue;
@@ -1553,10 +1540,11 @@ public class ComputerUtilCombat {
                     continue;
                 }
 
-                int tBonus = AbilityUtils.calculateAmount(ability.getHostCard(), ability.getParamOrDefault("CounterNum", "1"), ability);
-                if (tBonus > 0) {
-                    toughness += tBonus;
-                }
+                tBonus = AbilityUtils.calculateAmount(ability.getHostCard(), ability.getParamOrDefault("CounterNum", "1"), ability);
+            }
+
+            if (tBonus > 0 && ComputerUtilCost.canPayCost(ability, attacker.getController(), false)) {
+                toughness += tBonus;
             }
         }
         return toughness;

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

@@ -287,7 +287,9 @@ public class ComputerUtilMana {
                 continue;
             }
 
-            if (!ComputerUtilCost.checkTapTypeCost(ai, ma.getPayCosts(), ma.getHostCard(), sa, AiCardMemory.getMemorySet(ai, MemorySet.PAYS_TAP_COST))) {
+            int amount = ma.hasParam("Amount") ? AbilityUtils.calculateAmount(ma.getHostCard(), ma.getParam("Amount"), ma) : 1;
+            if (amount <= 0) {
+                // wrong gamestate for variable amount
                 continue;
             }
 
@@ -351,9 +353,14 @@ public class ComputerUtilMana {
                 continue;
             }
 
+            // these should come last since they reserve the paying cards
+            // (this means if a mana ability has both parts it doesn't currently undo reservations if the second part fails)
             if (!ComputerUtilCost.checkForManaSacrificeCost(ai, ma.getPayCosts(), ma, ma.isTrigger())) {
                 continue;
             }
+            if (!ComputerUtilCost.checkTapTypeCost(ai, ma.getPayCosts(), ma.getHostCard(), sa, AiCardMemory.getMemorySet(ai, MemorySet.PAYS_TAP_COST))) {
+                continue;
+            }
 
             return paymentChoice;
         }
@@ -443,7 +450,6 @@ public class ComputerUtilMana {
                         manaProduced = manaProduced.replace(s, color);
                     }
                 } else if (saMana.hasParam("ReplaceColor")) {
-                    // replace color
                     String color = saMana.getParam("ReplaceColor");
                     if ("Chosen".equals(color)) {
                         if (card.hasChosenColor()) {
@@ -735,7 +741,8 @@ public class ComputerUtilMana {
 
             if (saPayment != null && ComputerUtilCost.isSacrificeSelfCost(saPayment.getPayCosts())) {
                 if (sa.getTargets() != null && sa.getTargets().contains(saPayment.getHostCard())) {
-                    saExcludeList.add(saPayment); // not a good idea to sac a card that you're targeting with the SA you're paying for
+                    // not a good idea to sac a card that you're targeting with the SA you're paying for
+                    saExcludeList.add(saPayment);
                     continue;
                 }
             }
@@ -809,11 +816,11 @@ public class ComputerUtilMana {
                 String manaProduced = predictManafromSpellAbility(saPayment, ai, toPay);
                 payMultipleMana(cost, manaProduced, ai);
 
-                // remove from available lists
+                // remove to prevent re-usage since resources don't get consumed
                 sourcesForShards.values().removeIf(CardTraitPredicates.isHostCard(saPayment.getHostCard()));
             } else {
                 final CostPayment pay = new CostPayment(saPayment.getPayCosts(), saPayment);
-                if (!pay.payComputerCosts(new AiCostDecision(ai, saPayment, effect))) {
+                if (!pay.payComputerCosts(new AiCostDecision(ai, saPayment, effect, true))) {
                     saList.remove(saPayment);
                     continue;
                 }
@@ -822,8 +829,10 @@ public class ComputerUtilMana {
                 // subtract mana from mana pool
                 manapool.payManaFromAbility(sa, cost, saPayment);
 
-                // no need to remove abilities from resource map,
-                // once their costs are paid and consume resources, they can not be used again
+                // need to consider if another use is now prevented
+                if (!cost.isPaid() && saPayment.isActivatedAbility() && !saPayment.getRestrictions().canPlay(saPayment.getHostCard(), saPayment)) {
+                    sourcesForShards.values().removeIf(s -> s == saPayment);
+                }
 
                 if (hasConverge) {
                     // hack to prevent converge re-using sources
@@ -1496,7 +1505,7 @@ public class ComputerUtilMana {
                     }
 
                     if (!cost.isReusuableResource()) {
-                        for(CostPart part : cost.getCostParts()) {
+                        for (CostPart part : cost.getCostParts()) {
                             if (part instanceof CostSacrifice && !part.payCostFromSource()) {
                                 unpreferredCost = true;
                             }
@@ -1587,10 +1596,8 @@ public class ComputerUtilMana {
 
                 // don't use abilities with dangerous drawbacks
                 AbilitySub sub = m.getSubAbility();
-                if (sub != null) {
-                    if (!SpellApiToAi.Converter.get(sub).chkDrawbackWithSubs(ai, sub).willingToPlay()) {
-                        continue;
-                    }
+                if (sub != null && !SpellApiToAi.Converter.get(sub).chkDrawbackWithSubs(ai, sub).willingToPlay()) {
+                    continue;
                 }
 
                 manaMap.get(ManaAtom.GENERIC).add(m); // add to generic source list
@@ -1658,7 +1665,6 @@ public class ComputerUtilMana {
                                 if (replaced.contains("C")) {
                                     manaMap.put(ManaAtom.COLORLESS, m);
                                 }
-
                             }
                         }
                     }

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

@@ -264,12 +264,14 @@ public abstract class GameState {
             }
 
             if (c.hasMergedCard()) {
+                String suffix = c.getTopMergedCard().hasPaperFoil() ? "+" : "";
                 // we have to go by the current top card name here
-                newText.append(c.getTopMergedCard().getPaperCard().getName()).append("|Set:")
+                newText.append(c.getTopMergedCard().getPaperCard().getName()).append(suffix).append("|Set:")
                         .append(c.getTopMergedCard().getPaperCard().getEdition()).append("|Art:")
                         .append(c.getTopMergedCard().getPaperCard().getArtIndex());
             } else {
-                newText.append(c.getPaperCard().getName()).append("|Set:").append(c.getPaperCard().getEdition())
+                String suffix = c.hasPaperFoil() ? "+" : "";
+                newText.append(c.getPaperCard().getName()).append(suffix).append("|Set:").append(c.getPaperCard().getEdition())
                         .append("|Art:").append(c.getPaperCard().getArtIndex());
             }
         }
@@ -319,18 +321,21 @@ public abstract class GameState {
                     newText.append(":Cloaked");
                 }
             }
-            if (c.getCurrentStateName().equals(CardStateName.Transformed)) {
-                newText.append("|Transformed");
-            } else if (c.getCurrentStateName().equals(CardStateName.Flipped)) {
+            if (c.getCurrentStateName().equals(CardStateName.Flipped)) {
                 newText.append("|Flipped");
             } else if (c.getCurrentStateName().equals(CardStateName.Meld)) {
                 newText.append("|Meld");
                 if (c.getMeldedWith() != null) {
+                    String suffix = c.getMeldedWith().hasPaperFoil() ? "+" : "";
                     newText.append(":");
-                    newText.append(c.getMeldedWith().getName());
+                    newText.append(c.getMeldedWith().getName()).append(suffix);
+                }
+            } else if (c.getCurrentStateName().equals(CardStateName.Backside)) {
+                if (c.isModal()) {
+                    newText.append("|Modal");
+                } else {
+                    newText.append("|Transformed");
                 }
-            } else if (c.getCurrentStateName().equals(CardStateName.Modal)) {
-                newText.append("|Modal");
             }
 
             if (c.getPlayerAttachedTo() != null) {
@@ -1311,8 +1316,8 @@ public abstract class GameState {
                     if (info.endsWith("Cloaked")) {
                         c.setCloaked(new SpellAbility.EmptySa(ApiType.Cloak, c));
                     }
-                } else if (info.startsWith("Transformed")) {
-                    c.setState(CardStateName.Transformed, true);
+                } else if (info.startsWith("Transformed") || info.startsWith("Modal")) {
+                    c.setState(CardStateName.Backside, true);
                     c.setBackSide(true);
                 } else if (info.startsWith("Flipped")) {
                     c.setState(CardStateName.Flipped, true);
@@ -1330,9 +1335,6 @@ public abstract class GameState {
                     }
                     c.setState(CardStateName.Meld, true);
                     c.setBackSide(true);
-                } else if (info.startsWith("Modal")) {
-                    c.setState(CardStateName.Modal, true);
-                    c.setBackSide(true);
                 }
                 else if (info.startsWith("OnAdventure")) {
                     String abAdventure = "DB$ Effect | RememberObjects$ Self | StaticAbilities$ Play | ForgetOnMoved$ Exile | Duration$ Permanent | ConditionDefined$ Self | ConditionPresent$ Card.!copiedSpell";

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

@@ -460,7 +460,11 @@ public class PlayerControllerAi extends PlayerController {
 
     @Override
     public boolean confirmReplacementEffect(ReplacementEffect replacementEffect, SpellAbility effectSA, GameEntity affected, String question) {
-        return brains.aiShouldRun(replacementEffect, effectSA, affected);
+        Card host = replacementEffect.getHostCard();
+        if (host.hasAlternateState()) {
+            host = host.getGame().getCardState(host);
+        }
+        return brains.aiShouldRun(replacementEffect, effectSA, host, affected);
     }
 
     @Override
@@ -1347,6 +1351,11 @@ public class PlayerControllerAi extends PlayerController {
         // Ai won't understand that anyway
     }
 
+    @Override
+    public void revealUnsupported(Map<Player, List<PaperCard>> unsupported) {
+        // Ai won't understand that anyway
+    }
+
     @Override
     public Map<DeckSection, List<? extends PaperCard>> complainCardsCantPlayWell(Deck myDeck) {
         // TODO check if profile detection set to Auto

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

@@ -171,7 +171,7 @@ public class SpecialAiLogic {
                 final boolean isInfect = source.hasKeyword(Keyword.INFECT); // Flesh-Eater Imp
                 int lethalDmg = isInfect ? 10 - defPlayer.getPoisonCounters() : defPlayer.getLife();
 
-                if (isInfect && !combat.getDefenderByAttacker(source).canReceiveCounters(CounterType.get(CounterEnumType.POISON))) {
+                if (isInfect && !combat.getDefenderByAttacker(source).canReceiveCounters(CounterEnumType.POISON)) {
                     lethalDmg = Integer.MAX_VALUE; // won't be able to deal poison damage to kill the opponent
                 }
 
@@ -277,7 +277,7 @@ public class SpecialAiLogic {
                 final boolean isInfect = source.hasKeyword(Keyword.INFECT);
                 int lethalDmg = isInfect ? 10 - defPlayer.getPoisonCounters() : defPlayer.getLife();
 
-                if (isInfect && !combat.getDefenderByAttacker(source).canReceiveCounters(CounterType.get(CounterEnumType.POISON))) {
+                if (isInfect && !combat.getDefenderByAttacker(source).canReceiveCounters(CounterEnumType.POISON)) {
                     lethalDmg = Integer.MAX_VALUE; // won't be able to deal poison damage to kill the opponent
                 }
 

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

@@ -144,7 +144,7 @@ public abstract class SpellAbilityAi {
             return false;
         }
         if (!"Once".equals(aiLogic)) {
-            return !AiCardMemory.isRememberedCard(ai, sa.getHostCard(), AiCardMemory.MemorySet.ACTIVATED_THIS_TURN);
+            return !sa.getHostCard().getAbilityActivatedThisTurn().getActivators(sa).contains(ai);
         }
         return true;
     }
@@ -153,7 +153,7 @@ public abstract class SpellAbilityAi {
      * The rest of the logic not covered by the canPlayAI template is defined here
      */
     protected AiAbilityDecision checkApiLogic(final Player ai, final SpellAbility sa) {
-        if (MyRandom.getRandom().nextFloat() < .8f) {
+        if (sa.getActivationsThisTurn() == 0 || MyRandom.getRandom().nextFloat() < .8f) {
             // 80% chance to play the ability
             return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
         }

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

@@ -77,7 +77,6 @@ public enum SpellApiToAi {
             .put(ApiType.DelayedTrigger, DelayedTriggerAi.class)
             .put(ApiType.Destroy, DestroyAi.class)
             .put(ApiType.DestroyAll, DestroyAllAi.class)
-            .put(ApiType.Detain, DetainAi.class)
             .put(ApiType.Dig, DigAi.class)
             .put(ApiType.DigMultiple, DigMultipleAi.class)
             .put(ApiType.DigUntil, DigUntilAi.class)

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

@@ -83,7 +83,7 @@ public class AddTurnAi extends SpellAbilityAi {
      */
     @Override
     protected AiAbilityDecision canPlay(Player aiPlayer, SpellAbility sa) {
-        return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+        return doTriggerNoCost(aiPlayer, sa, false);
     }
 
 }

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

@@ -159,81 +159,78 @@ public class AnimateAi extends SpellAbilityAi {
         }
 
         if (sa.costHasManaX() && sa.getSVar("X").equals("Count$xPaid")) {
-            // Set PayX here to maximum value.
             final int xPay = ComputerUtilCost.getMaxXValue(sa, aiPlayer, sa.isTrigger());
-
             sa.setXManaCostPaid(xPay);
         }
 
-        if (!sa.usesTargeting()) {
-            final List<Card> defined = AbilityUtils.getDefinedCards(source, sa.getParam("Defined"), sa);
-            boolean bFlag = false;
-            boolean givesHaste = sa.hasParam("Keywords") && sa.getParam("Keywords").contains("Haste");
-            for (final Card c : defined) {
-                bFlag |= !c.isCreature() && !c.isTapped()
-                        && (!c.hasSickness() || givesHaste || !ph.isPlayerTurn(aiPlayer))
-                        && !c.isEquipping();
+        if (sa.usesTargeting()) {
+            sa.resetTargets();
+            return animateTgtAI(sa);
+        }
 
-                // for creatures that could be improved (like Figure of Destiny)
-                if (!bFlag && c.isCreature() && ("Permanent".equals(sa.getParam("Duration")) || (!c.isTapped() && !c.isSick()))) {
-                    int power = -5;
-                    if (sa.hasParam("Power")) {
-                        power = AbilityUtils.calculateAmount(c, sa.getParam("Power"), sa);
-                    }
-                    int toughness = -5;
-                    if (sa.hasParam("Toughness")) {
-                        toughness = AbilityUtils.calculateAmount(c, sa.getParam("Toughness"), sa);
-                    }
-                    if (sa.hasParam("Keywords")) {
-                        for (String keyword : sa.getParam("Keywords").split(" & ")) {
-                            if (!c.hasKeyword(keyword)) {
-                                bFlag = true;
-                            }
+        final List<Card> defined = AbilityUtils.getDefinedCards(source, sa.getParam("Defined"), sa);
+        boolean bFlag = false;
+        boolean givesHaste = sa.hasParam("Keywords") && sa.getParam("Keywords").contains("Haste");
+        for (final Card c : defined) {
+            bFlag |= !c.isCreature() && !c.isTapped()
+                    && (!c.hasSickness() || givesHaste || !ph.isPlayerTurn(aiPlayer))
+                    && !c.isEquipping();
+
+            // for creatures that could be improved (like Figure of Destiny)
+            if (!bFlag && c.isCreature() && ("Permanent".equals(sa.getParam("Duration")) || (!c.isTapped() && !c.isSick()))) {
+                int power = -5;
+                if (sa.hasParam("Power")) {
+                    power = AbilityUtils.calculateAmount(c, sa.getParam("Power"), sa);
+                }
+                int toughness = -5;
+                if (sa.hasParam("Toughness")) {
+                    toughness = AbilityUtils.calculateAmount(c, sa.getParam("Toughness"), sa);
+                }
+                if (sa.hasParam("Keywords")) {
+                    for (String keyword : sa.getParam("Keywords").split(" & ")) {
+                        if (!c.hasKeyword(keyword)) {
+                            bFlag = true;
                         }
                     }
-                    if (power + toughness > c.getCurrentPower() + c.getCurrentToughness()) {
+                }
+                if (power + toughness > c.getCurrentPower() + c.getCurrentToughness()) {
+                    if (!c.isTapped() || (ph.inCombat() && game.getCombat().isAttacking(c))) {
+                        bFlag = true;
+                    }
+                }
+            }
+
+            if (!isSorcerySpeed(sa, aiPlayer) && !"Permanent".equals(sa.getParam("Duration"))) {
+                if (sa.isCrew() && c.isCreature()) {
+                    // Do not try to crew a vehicle which is already a creature
+                    return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+                }
+                Card animatedCopy = becomeAnimated(c, sa);
+                if (ph.isPlayerTurn(aiPlayer)
+                        && !ComputerUtilCard.doesSpecifiedCreatureAttackAI(aiPlayer, animatedCopy)) {
+                    return new AiAbilityDecision(0, AiPlayDecision.DoesntImpactCombat);
+                }
+                if (ph.getPlayerTurn().isOpponentOf(aiPlayer)
+                        && !ComputerUtilCard.doesSpecifiedCreatureBlock(aiPlayer, animatedCopy)) {
+                    return new AiAbilityDecision(0, AiPlayDecision.DoesntImpactCombat);
+                }
+                // also check if maybe there are static effects applied to the animated copy that would matter
+                // (e.g. Myth Realized)
+                if (animatedCopy.getCurrentPower() + animatedCopy.getCurrentToughness() >
+                        c.getCurrentPower() + c.getCurrentToughness()) {
+                    if (!isAnimatedThisTurn(aiPlayer, source)) {
                         if (!c.isTapped() || (ph.inCombat() && game.getCombat().isAttacking(c))) {
                             bFlag = true;
                         }
                     }
                 }
-
-                if (!isSorcerySpeed(sa, aiPlayer) && !"Permanent".equals(sa.getParam("Duration"))) {
-                    if (sa.isCrew() && c.isCreature()) {
-                        // Do not try to crew a vehicle which is already a creature
-                        return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
-                    }
-                    Card animatedCopy = becomeAnimated(c, sa);
-                    if (ph.isPlayerTurn(aiPlayer)
-                            && !ComputerUtilCard.doesSpecifiedCreatureAttackAI(aiPlayer, animatedCopy)) {
-                        return new AiAbilityDecision(0, AiPlayDecision.DoesntImpactCombat);
-                    }
-                    if (ph.getPlayerTurn().isOpponentOf(aiPlayer)
-                            && !ComputerUtilCard.doesSpecifiedCreatureBlock(aiPlayer, animatedCopy)) {
-                        return new AiAbilityDecision(0, AiPlayDecision.DoesntImpactCombat);
-                    }
-                    // also check if maybe there are static effects applied to the animated copy that would matter
-                    // (e.g. Myth Realized)
-                    if (animatedCopy.getCurrentPower() + animatedCopy.getCurrentToughness() >
-                            c.getCurrentPower() + c.getCurrentToughness()) {
-                        if (!isAnimatedThisTurn(aiPlayer, sa.getHostCard())) {
-                            if (!c.isTapped() || (ph.inCombat() && game.getCombat().isAttacking(c))) {
-                                bFlag = true;
-                            }
-                        }
-                    }
-                }
             }
-            if (bFlag) {
-                rememberAnimatedThisTurn(aiPlayer, sa.getHostCard());
-                return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
-            }
-            return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
-        } else {
-            sa.resetTargets();
-            return animateTgtAI(sa);
         }
-
+        if (bFlag) {
+            rememberAnimatedThisTurn(aiPlayer, source);
+            return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+        }
+        return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
     }
 
     @Override
@@ -255,8 +252,7 @@ public class AnimateAi extends SpellAbilityAi {
                 return decision;
             } else if (!mandatory) {
                 return decision;
-            }
-            else {
+            } else {
                 // fallback if animate is mandatory
                 sa.resetTargets();
                 List<Card> list = CardUtil.getValidCardsToTarget(sa);
@@ -277,8 +273,13 @@ public class AnimateAi extends SpellAbilityAi {
     }
 
     private AiAbilityDecision animateTgtAI(final SpellAbility sa) {
+        if (sa.getMaxTargets() == 0) {
+            // this happens if an optional cost is skipped, e.g. Brave the Wilds
+            return new AiAbilityDecision(80, AiPlayDecision.WillPlay);
+        }
         final Player ai = sa.getActivatingPlayer();
-        final PhaseHandler ph = ai.getGame().getPhaseHandler();
+        final Game game = ai.getGame();
+        final PhaseHandler ph = game.getPhaseHandler();
         final String logic = sa.getParamOrDefault("AILogic", "");
         final boolean alwaysActivatePWAbility = sa.isPwAbility()
                 && sa.getPayCosts().hasSpecificCostType(CostPutCounter.class)
@@ -290,10 +291,8 @@ public class AnimateAi extends SpellAbilityAi {
             types.addAll(Arrays.asList(sa.getParam("Types").split(",")));
         }
 
-        final Game game = ai.getGame();
         CardCollection list = CardLists.getTargetableCards(game.getCardsIn(ZoneType.Battlefield), sa);
 
-        // Filter AI-specific targets if provided
         list = ComputerUtil.filterAITgts(sa, ai, list, false);
 
         // list is empty, no possible targets
@@ -398,7 +397,8 @@ public class AnimateAi extends SpellAbilityAi {
         }
 
         if (logic.equals("SetPT")) {
-            // TODO: 1. Teach the AI to use this to save the creature from direct damage; 2. Determine the best target in a smarter way?
+            // TODO: 1. Teach the AI to use this to save the creature from direct damage;
+            //  2. Determine the best target in a smarter way?
             Card worst = ComputerUtilCard.getWorstCreatureAI(ai.getCreaturesInPlay());
             Card buffed = becomeAnimated(worst, sa);
 
@@ -435,11 +435,9 @@ public class AnimateAi extends SpellAbilityAi {
         if (sa.hasParam("AITgts") && !list.isEmpty()) {
             //No logic, but we do have preferences. Pick the best among those?
             Card best = ComputerUtilCard.getBestAI(list);
-            if(best != null) {
-                sa.getTargets().add(best);
-                rememberAnimatedThisTurn(ai, best);
-                return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
-            }
+            sa.getTargets().add(best);
+            rememberAnimatedThisTurn(ai, best);
+            return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
         }
 
         // This is reasonable for now. Kamahl, Fist of Krosa and a sorcery or

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

@@ -988,6 +988,7 @@ public class AttachAi extends SpellAbilityAi {
             }
         } else if ("Remembered".equals(sa.getParam("Defined")) && sa.getParent() != null
             && sa.getParent().getApi() == ApiType.Token && sa.getParent().hasParam("RememberTokens")) {
+            // Living Weapon or similar
             return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
         }
         return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);

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

@@ -101,11 +101,7 @@ public class ChangeZoneAi extends SpellAbilityAi {
             sa.getHostCard().removeSVar("AIPreferenceOverride");
         }
 
-        if (aiLogic.equals("BeforeCombat")) {
-            if (ai.getGame().getPhaseHandler().getPhase().isAfter(PhaseType.COMBAT_BEGIN)) {
-                return false;
-            }
-        } else if (aiLogic.equals("SurpriseBlock")) {
+        if (aiLogic.equals("SurpriseBlock")) {
             if (ai.getGame().getPhaseHandler().getPhase().isBefore(PhaseType.COMBAT_DECLARE_ATTACKERS)) {
                 return false;
             }
@@ -289,9 +285,7 @@ public class ChangeZoneAi extends SpellAbilityAi {
      * @return a boolean.
      */
     private static AiAbilityDecision hiddenOriginCanPlayAI(final Player ai, final SpellAbility sa) {
-        // Fetching should occur fairly often as it helps cast more spells, and
-        // have access to more mana
-        final Cost abCost = sa.getPayCosts();
+        // Fetching should occur fairly often as it helps cast more spells, and have access to more mana
         final Card source = sa.getHostCard();
         final String sourceName = ComputerUtilAbility.getAbilitySourceName(sa);
         final String aiLogic = sa.getParamOrDefault("AILogic", "");
@@ -300,13 +294,7 @@ public class ChangeZoneAi extends SpellAbilityAi {
         boolean activateForCost = ComputerUtil.activateForCost(sa, ai);
 
         if (sa.hasParam("Origin")) {
-            try {
-                origin = ZoneType.listValueOf(sa.getParam("Origin"));
-            } catch (IllegalArgumentException ex) {
-                // This happens when Origin is something like
-                // "Graveyard,Library" (Doomsday)
-                return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
-            }
+            origin = ZoneType.listValueOf(sa.getParam("Origin"));
         }
         final String destination = sa.getParam("Destination");
 
@@ -455,12 +443,7 @@ public class ChangeZoneAi extends SpellAbilityAi {
             return new AiAbilityDecision(0, AiPlayDecision.WaitForCombat);
         }
 
-        final AbilitySub subAb = sa.getSubAbility();
-        if (subAb == null) {
-            return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
-        }
-
-        return SpellApiToAi.Converter.get(subAb).chkDrawbackWithSubs(ai, subAb);
+        return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
     }
 
     /**
@@ -506,19 +489,6 @@ public class ChangeZoneAi extends SpellAbilityAi {
         // Fetching should occur fairly often as it helps cast more spells, and
         // have access to more mana
 
-        if (sa.hasParam("AILogic")) {
-            if (sa.getParam("AILogic").equals("Never")) {
-                /*
-                 * Hack to stop AI from using Aviary Mechanic's "may bounce" trigger.
-                 * Ideally it should look for a good bounce target like "Pacifism"-victims
-                 * but there is no simple way to check that. It is preferable for the AI
-                 * to make sub-optimal choices (waste bounce) than to make obvious mistakes
-                 * (bounce useful permanent).
-                 */
-                return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
-            }
-        }
-
         List<ZoneType> origin = new ArrayList<>();
         if (sa.hasParam("Origin")) {
             origin = ZoneType.listValueOf(sa.getParam("Origin"));
@@ -773,12 +743,7 @@ public class ChangeZoneAi extends SpellAbilityAi {
             }
         }
 
-        final AbilitySub subAb = sa.getSubAbility();
-        if (subAb == null) {
-            return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
-        }
-
-        return SpellApiToAi.Converter.get(subAb).chkDrawbackWithSubs(ai, subAb);
+        return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
     }
 
     /*
@@ -796,6 +761,8 @@ public class ChangeZoneAi extends SpellAbilityAi {
             return ph.getNextTurn().equals(ai) && ph.is(PhaseType.END_OF_TURN);
         } else if (aiLogic.equals("Main1") && ph.is(PhaseType.MAIN1, ai)) {
             return true;
+        } else if (aiLogic.equals("BeforeCombat")) {
+            return !ai.getGame().getPhaseHandler().getPhase().isAfter(PhaseType.COMBAT_BEGIN);
         }
 
         if (sa.isHidden()) {
@@ -922,9 +889,6 @@ public class ChangeZoneAi extends SpellAbilityAi {
         CardCollection list = CardLists.getTargetableCards(game.getCardsIn(origin), sa);
 
         list = ComputerUtil.filterAITgts(sa, ai, list, true);
-        if (sa.hasParam("AITgtsOnlyBetterThanSelf")) {
-            list = CardLists.filter(list, card -> ComputerUtilCard.evaluateCreature(card) > ComputerUtilCard.evaluateCreature(source) + 30);
-        }
 
         if (source.isInZone(ZoneType.Hand)) {
             list = CardLists.filter(list, CardPredicates.nameNotEquals(source.getName())); // Don't get the same card back.
@@ -933,8 +897,6 @@ public class ChangeZoneAi extends SpellAbilityAi {
             list.remove(source); // spells can't target their own source, because it's actually in the stack zone
         }
 
-        // list = CardLists.canSubsequentlyTarget(list, sa);
-
         if (sa.hasParam("AttachedTo")) {
             list = CardLists.filter(list, c -> {
                 for (Card card : game.getCardsIn(ZoneType.Battlefield)) {
@@ -1277,53 +1239,12 @@ public class ChangeZoneAi extends SpellAbilityAi {
                 }
             }
 
-            // if max CMC exceeded, do not choose this card (but keep looking for other options)
-            if (sa.hasParam("MaxTotalTargetCMC")) {
-                if (choice.getCMC() > sa.getTargetRestrictions().getMaxTotalCMC(choice, sa) - sa.getTargets().getTotalTargetedCMC()) {
-                    list.remove(choice);
-                    continue;
-                }
-            }
-
-            // if max power exceeded, do not choose this card (but keep looking for other options)
-            if (sa.hasParam("MaxTotalTargetPower")) {
-                if (choice.getNetPower() > sa.getTargetRestrictions().getMaxTotalPower(choice, sa) -sa.getTargets().getTotalTargetedPower()) {
-                    list.remove(choice);
-                    continue;
-                }
-            }
-
-            // honor the Same Creature Type restriction
-            if (sa.getTargetRestrictions().isWithSameCreatureType()) {
-                Card firstTarget = sa.getTargetCard();
-                if (firstTarget != null && !choice.sharesCreatureTypeWith(firstTarget)) {
-                    list.remove(choice);
-                    continue;
-                }
-            }
-
             list.remove(choice);
             if (sa.canTarget(choice)) {
                 sa.getTargets().add(choice);
             }
         }
 
-        // Honor the Single Zone restriction. For now, simply remove targets that do not belong to the same zone as the first targeted card.
-        // TODO: ideally the AI should consider at this point which targets exactly to pick (e.g. one card in the first player's graveyard
-        // vs. two cards in the second player's graveyard, which cards are more relevant to be targeted, etc.). Consider improving.
-        if (sa.getTargetRestrictions().isSingleZone()) {
-            Card firstTgt = sa.getTargetCard();
-            CardCollection toRemove = new CardCollection();
-            if (firstTgt != null) {
-                for (Card t : sa.getTargets().getTargetCards()) {
-                    if (!t.getController().equals(firstTgt.getController())) {
-                        toRemove.add(t);
-                    }
-                }
-                sa.getTargets().removeAll(toRemove);
-            }
-        }
-
         return true;
     }
 
@@ -1619,7 +1540,7 @@ public class ChangeZoneAi extends SpellAbilityAi {
             } else if (logic.startsWith("ExilePreference")) {
                 return doExilePreferenceLogic(decider, sa, fetchList);
             } else if (logic.equals("BounceOwnTrigger")) {
-                return doBounceOwnTriggerLogic(decider, fetchList);
+                return doBounceOwnTriggerLogic(decider, sa, fetchList);
             }
         }
         if (fetchList.isEmpty()) {
@@ -2183,16 +2104,18 @@ public class ChangeZoneAi extends SpellAbilityAi {
         return AiCardMemory.isRememberedCard(ai, c, AiCardMemory.MemorySet.BOUNCED_THIS_TURN);
     }
 
-    private static Card doBounceOwnTriggerLogic(Player ai, CardCollection choices) {
+    private static Card doBounceOwnTriggerLogic(Player ai, SpellAbility sa, CardCollection choices) {
         CardCollection unprefChoices = CardLists.filter(choices, c -> !c.isToken() && c.getOwner().equals(ai));
+        // TODO check for threatened cards
         CardCollection prefChoices = CardLists.filter(unprefChoices, c -> c.hasETBTrigger(false));
         if (!prefChoices.isEmpty()) {
             return ComputerUtilCard.getBestAI(prefChoices);
-        } else if (!unprefChoices.isEmpty()) {
-            return ComputerUtilCard.getWorstAI(unprefChoices);
-        } else {
-            return null;
         }
+        if (!unprefChoices.isEmpty() && sa.getSubAbility() != null) {
+            // some extra benefit like First Responder
+            return ComputerUtilCard.getWorstAI(unprefChoices);
+        }
+        return null;
     }
 
     @Override

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

@@ -286,8 +286,6 @@ public class ChangeZoneAllAi extends SpellAbilityAi {
 
     @Override
     protected AiAbilityDecision doTriggerNoCost(Player ai, final SpellAbility sa, boolean mandatory) {
-        // Change Zone All, can be any type moving from one zone to another
-
         final ZoneType destination = ZoneType.smartValueOf(sa.getParam("Destination"));
         final ZoneType origin = ZoneType.listValueOf(sa.getParam("Origin")).get(0);
 

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

@@ -9,7 +9,6 @@ import forge.game.player.Player;
 import forge.game.spellability.AbilitySub;
 import forge.game.spellability.SpellAbility;
 import forge.util.Aggregates;
-import forge.util.MyRandom;
 import forge.util.collect.FCollection;
 
 import java.util.Collections;
@@ -89,12 +88,7 @@ public class CharmAi extends SpellAbilityAi {
             CharmEffect.chainAbilities(sa, chosenList);
         }
 
-        // prevent run-away activations - first time will always return true
-        if (MyRandom.getRandom().nextFloat() <= Math.pow(.6667, sa.getActivationsThisTurn())) {
-            return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
-        }
-
-        return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+        return super.checkApiLogic(ai, sa);
     }
 
     private List<AbilitySub> chooseOptionsAi(SpellAbility sa, List<AbilitySub> choices, final Player ai, boolean isTrigger, int num, int min) {

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

@@ -78,10 +78,8 @@ public class ChooseCardNameAi extends SpellAbilityAi {
         }
 
         if (mandatory) {
-            // If mandatory, then we will play it.
             return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
         } else {
-            // If not mandatory, then we won't play it.
             return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
         }
     }

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

@@ -63,8 +63,7 @@ public class ChooseNumberAi extends SpellAbilityAi {
     protected AiAbilityDecision doTriggerNoCost(Player ai, SpellAbility sa, boolean mandatory) {
         if (mandatory) {
             return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
-        } {
-            return canPlay(ai, sa);
         }
+        return canPlay(ai, sa);
     }
 }

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

@@ -20,7 +20,7 @@ import java.util.Map;
 public class CloneAi extends SpellAbilityAi {
 
     @Override
-    protected AiAbilityDecision canPlay(Player ai, SpellAbility sa) {
+    protected AiAbilityDecision checkApiLogic(Player ai, SpellAbility sa) {
         final Card source = sa.getHostCard();
         final Game game = source.getGame();
 
@@ -38,10 +38,6 @@ public class CloneAi extends SpellAbilityAi {
         // TODO - add some kind of check for during human turn to answer
         // "Can I use this to block something?"
 
-        if (!checkPhaseRestrictions(ai, sa, game.getPhaseHandler())) {
-            return new AiAbilityDecision(0, AiPlayDecision.MissingPhaseRestrictions);
-        }
-
         PhaseHandler phase = game.getPhaseHandler();
 
         if (!sa.usesTargeting()) {
@@ -77,7 +73,7 @@ public class CloneAi extends SpellAbilityAi {
 
         return useAbility ? new AiAbilityDecision(100, AiPlayDecision.WillPlay)
                 : new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
-    } // end cloneCanPlayAI()
+    }
 
     @Override
     public AiAbilityDecision chkDrawback(SpellAbility sa, Player aiPlayer) {
@@ -100,6 +96,10 @@ public class CloneAi extends SpellAbilityAi {
         if (sa.usesTargeting()) {
             chance = cloneTgtAI(sa);
         } else {
+            if (sa.isReplacementAbility() && host.isCloned()) {
+                // prevent StackOverflow from infinite loop copying another ETB RE
+                return new AiAbilityDecision(0, AiPlayDecision.StopRunawayActivations);
+            }
             if (sa.hasParam("Choices")) {
                 CardCollectionView choices = CardLists.getValidCards(host.getGame().getCardsIn(ZoneType.Battlefield),
                         sa.getParam("Choices"), host.getController(), host, sa);
@@ -192,7 +192,7 @@ public class CloneAi extends SpellAbilityAi {
         final boolean canCloneLegendary = "True".equalsIgnoreCase(sa.getParam("NonLegendary"));
 
         String filter = !isVesuva ? "Permanent.YouDontCtrl,Permanent.nonLegendary"
-                : "Permanent.YouDontCtrl+notnamed" + name + ",Permanent.nonLegendary+notnamed" + name;
+                : "Permanent.YouDontCtrl+!named" + name + ",Permanent.nonLegendary+!named" + name;
 
         // TODO: rewrite this block so that this is done somehow more elegantly
         if (canCloneLegendary) {

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

@@ -119,7 +119,7 @@ public class ConniveAi extends SpellAbilityAi {
             }
         }
         return new AiAbilityDecision(
-                sa.isTargetNumberValid() && !sa.getTargets().isEmpty() ? 100 : 0,
+                sa.isTargetNumberValid() ? 100 : 0,
                 sa.isTargetNumberValid() ? AiPlayDecision.WillPlay : AiPlayDecision.TargetingFailed
         );
     }

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

@@ -53,17 +53,15 @@ public class ControlExchangeAi extends SpellAbilityAi {
             if (mandatory) {
                 return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
             }
-        } else {
-            if (mandatory) {
-                AiAbilityDecision decision = chkDrawback(sa, aiPlayer);
-                if (sa.isTargetNumberValid()) {
-                    return  new AiAbilityDecision(100, AiPlayDecision.WillPlay);
-                }
-
-                return decision;
-            } else {
-                return canPlay(aiPlayer, sa);
+        } else if (mandatory) {
+            AiAbilityDecision decision = chkDrawback(sa, aiPlayer);
+            if (sa.isTargetNumberValid()) {
+                return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
             }
+
+            return decision;
+        } else {
+            return canPlay(aiPlayer, sa);
         }
         return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
     }

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

@@ -44,7 +44,7 @@ public class CopyPermanentAi extends SpellAbilityAi {
                 // Not at EOT phase
                 return new AiAbilityDecision(0, AiPlayDecision.WaitForEndOfTurn);
             }
-        } if ("DuplicatePerms".equals(aiLogic)) {
+        } else if ("DuplicatePerms".equals(aiLogic)) {
             final List<Card> valid = AbilityUtils.getDefinedCards(source, sa.getParam("Defined"), sa);
             if (valid.size() < 2) {
                 return new AiAbilityDecision(0, AiPlayDecision.MissingNeededCards);
@@ -212,7 +212,7 @@ public class CopyPermanentAi extends SpellAbilityAi {
                 if (mandatory) {
                     return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
                 } else {
-                    return new AiAbilityDecision(0, AiPlayDecision.TargetingFailed);
+                    return new AiAbilityDecision(0, AiPlayDecision.MissingNeededCards);
                 }
             }
         }

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

@@ -42,7 +42,7 @@ public class CopySpellAbilityAi extends SpellAbilityAi {
         }
 
         if (!MyRandom.percentTrue(chance)
-                && !"AlwaysIfViable".equals(logic)
+                && !"Always".equals(logic)
                 && !"AlwaysCopyActivatedAbilities".equals(logic)) {
             return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
         }
@@ -93,7 +93,6 @@ public class CopySpellAbilityAi extends SpellAbilityAi {
                 }
                 if (decision == AiPlayDecision.WillPlay) {
                     sa.getTargets().add(top);
-                    AiCardMemory.rememberCard(aiPlayer, sa.getHostCard(), AiCardMemory.MemorySet.ACTIVATED_THIS_TURN);
                     return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
                 }
                 return new AiAbilityDecision(0, decision);
@@ -115,7 +114,6 @@ public class CopySpellAbilityAi extends SpellAbilityAi {
         }
 
         if (logic.contains("Always")) {
-            // If the logic is "Always" or "AlwaysIfViable", we will always play this ability
             return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
         }
 
@@ -126,10 +124,11 @@ public class CopySpellAbilityAi extends SpellAbilityAi {
     public AiAbilityDecision chkDrawback(final SpellAbility sa, final Player aiPlayer) {
         if ("ChainOfSmog".equals(sa.getParam("AILogic"))) {
             return SpecialCardAi.ChainOfSmog.consider(aiPlayer, sa);
-        } else if ("ChainOfAcid".equals(sa.getParam("AILogic"))) {
-            return SpecialCardAi.ChainOfAcid.consider(aiPlayer, sa);
-
         }
+        if ("ChainOfAcid".equals(sa.getParam("AILogic"))) {
+            return SpecialCardAi.ChainOfAcid.consider(aiPlayer, sa);
+        }
+
         AiAbilityDecision decision = canPlay(aiPlayer, sa);
         if (!decision.willingToPlay()) {
             if (sa.isMandatory()) {

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

@@ -102,7 +102,7 @@ public abstract class CountersAi extends SpellAbilityAi {
         } else if (type.equals("DIVINITY")) {
             final CardCollection boon = CardLists.filter(list, c -> c.getCounters(CounterEnumType.DIVINITY) == 0);
             choice = ComputerUtilCard.getMostExpensivePermanentAI(boon);
-        } else if (CounterType.get(type).isKeywordCounter()) {
+        } else if (CounterType.getType(type).isKeywordCounter()) {
             choice = ComputerUtilCard.getBestCreatureAI(CardLists.getNotKeyword(list, type));
         } else {
             // The AI really should put counters on cards that can use it.

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

@@ -20,41 +20,40 @@ public class CountersMultiplyAi extends SpellAbilityAi {
 
     @Override
     protected AiAbilityDecision checkApiLogic(Player ai, SpellAbility sa) {
+        if (sa.usesTargeting()) {
+            return setTargets(ai, sa);
+        }
+
         final CounterType counterType = getCounterType(sa);
+        // defined are mostly Self or Creatures you control
+        CardCollection list = AbilityUtils.getDefinedCards(sa.getHostCard(), sa.getParam("Defined"), sa);
 
-        if (!sa.usesTargeting()) {
-            // defined are mostly Self or Creatures you control
-            CardCollection list = AbilityUtils.getDefinedCards(sa.getHostCard(), sa.getParam("Defined"), sa);
+        list = CardLists.filter(list, c -> {
+            if (!c.hasCounters()) {
+                return false;
+            }
 
-            list = CardLists.filter(list, c -> {
-                if (!c.hasCounters()) {
+            if (counterType != null) {
+                if (c.getCounters(counterType) <= 0) {
                     return false;
                 }
-
-                if (counterType != null) {
-                    if (c.getCounters(counterType) <= 0) {
+                if (!c.canReceiveCounters(counterType)) {
+                    return false;
+                }
+            } else {
+                for (Map.Entry<CounterType, Integer> e : c.getCounters().entrySet()) {
+                    // has negative counter it would double
+                    if (ComputerUtil.isNegativeCounter(e.getKey(), c)) {
                         return false;
                     }
-                    if (!c.canReceiveCounters(counterType)) {
-                        return false;
-                    }
-                } else {
-                    for (Map.Entry<CounterType, Integer> e : c.getCounters().entrySet()) {
-                        // has negative counter it would double
-                        if (ComputerUtil.isNegativeCounter(e.getKey(), c)) {
-                            return false;
-                        }
-                    }
                 }
-
-                return true;
-            });
-
-            if (list.isEmpty()) {
-                return new AiAbilityDecision(0, AiPlayDecision.MissingNeededCards);
             }
-        } else {
-            return setTargets(ai, sa);
+
+            return true;
+        });
+
+        if (list.isEmpty()) {
+            return new AiAbilityDecision(0, AiPlayDecision.MissingNeededCards);
         }
 
         return super.checkApiLogic(ai, sa);
@@ -155,7 +154,7 @@ public class CountersMultiplyAi extends SpellAbilityAi {
                 }
 
                 if (counterType == null || counterType.is(type)) {
-                    addTargetsByCounterType(ai, sa, aiList, CounterType.get(type));
+                    addTargetsByCounterType(ai, sa, aiList, type);
                 }
             }
         }
@@ -164,7 +163,7 @@ public class CountersMultiplyAi extends SpellAbilityAi {
         if (!oppList.isEmpty()) {
             // not enough targets
             if (sa.canAddMoreTarget()) {
-                final CounterType type = CounterType.get(CounterEnumType.M1M1);
+                final CounterType type = CounterEnumType.M1M1;
                 if (counterType == null || counterType == type) {
                     addTargetsByCounterType(ai, sa, oppList, type);
                 }

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

@@ -110,7 +110,7 @@ public class CountersProliferateAi extends SpellAbilityAi {
     public <T extends GameEntity> T chooseSingleEntity(Player ai, SpellAbility sa, Collection<T> options, boolean isOptional, Player targetedPlayer, Map<String, Object> params) {
         // Proliferate is always optional for all, no need to select best
 
-        final CounterType poison = CounterType.get(CounterEnumType.POISON);
+        final CounterType poison = CounterEnumType.POISON;
 
         boolean aggroAI = (((PlayerControllerAi) ai.getController()).getAi()).getBooleanProperty(AiProps.PLAY_AGGRO);
         // because countertype can't be chosen anymore, only look for poison counters

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

@@ -92,9 +92,8 @@ public class CountersPutAi extends CountersAi {
                     return false;
                 }
                 return chance > MyRandom.getRandom().nextFloat();
-            } else {
-                return false;
             }
+            return false;
         }
 
         if (sa.isKeyword(Keyword.LEVEL_UP)) {
@@ -124,7 +123,6 @@ public class CountersPutAi extends CountersAi {
         final Cost abCost = sa.getPayCosts();
         final Card source = sa.getHostCard();
         final String sourceName = ComputerUtilAbility.getAbilitySourceName(sa);
-        CardCollection list;
         Card choice = null;
         final String amountStr = sa.getParamOrDefault("CounterNum", "1");
         final boolean divided = sa.isDividedAsYouChoose();
@@ -170,7 +168,7 @@ public class CountersPutAi extends CountersAi {
                     CardCollection oppCreatM1 = CardLists.filter(oppCreat, CardPredicates.hasCounter(CounterEnumType.M1M1));
                     oppCreatM1 = CardLists.getNotKeyword(oppCreatM1, Keyword.UNDYING);
 
-                    oppCreatM1 = CardLists.filter(oppCreatM1, input -> input.getNetToughness() <= 1 && input.canReceiveCounters(CounterType.get(CounterEnumType.M1M1)));
+                    oppCreatM1 = CardLists.filter(oppCreatM1, input -> input.getNetToughness() <= 1 && input.canReceiveCounters(CounterEnumType.M1M1));
 
                     Card best = ComputerUtilCard.getBestAI(oppCreatM1);
                     if (best != null) {
@@ -247,10 +245,9 @@ public class CountersPutAi extends CountersAi {
             } else if (sa.getSubAbility() != null
                         && "Self".equals(sa.getSubAbility().getParam("Defined"))
                         && sa.getSubAbility().getParamOrDefault("KW", "").contains("Hexproof")
-                        && !AiCardMemory.isRememberedCard(ai, source, AiCardMemory.MemorySet.ACTIVATED_THIS_TURN)) {
+                        && !source.getAbilityActivatedThisTurn().getActivators(sa).contains(ai)) {
                     // Bristling Hydra: save from death using a ping activation
                     if (ComputerUtil.predictThreatenedObjects(sa.getActivatingPlayer(), sa).contains(source)) {
-                        AiCardMemory.rememberCard(ai, source, AiCardMemory.MemorySet.ACTIVATED_THIS_TURN);
                         return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
                     }
             } else if (ai.getCounters(CounterEnumType.ENERGY) > ComputerUtilCard.getMaxSAEnergyCostOnBattlefield(ai) + sa.getPayCosts().getCostEnergy().convertAmount()) {
@@ -293,10 +290,8 @@ public class CountersPutAi extends CountersAi {
 
             if (willActivate) {
                 return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
-            } else {
-                return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
             }
-
+            return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
         } else if (logic.equals("ChargeToBestCMC")) {
             return doChargeToCMCLogic(ai, sa);
         } else if (logic.equals("ChargeToBestOppControlledCMC")) {
@@ -337,7 +332,7 @@ public class CountersPutAi extends CountersAi {
             Game game = ai.getGame();
             Combat combat = game.getCombat();
 
-            if (!source.canReceiveCounters(CounterType.get(CounterEnumType.P1P1)) || source.getCounters(CounterEnumType.P1P1) > 0) {
+            if (!source.canReceiveCounters(CounterEnumType.P1P1) || source.getCounters(CounterEnumType.P1P1) > 0) {
                 return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
             } else if (combat != null && ph.is(PhaseType.COMBAT_DECLARE_BLOCKERS)) {
                 return doCombatAdaptLogic(source, amount, combat);
@@ -349,7 +344,7 @@ public class CountersPutAi extends CountersAi {
             if (type.equals("P1P1")) {
                 nPump = amount;
             }
-            return FightAi.canFightAi(ai, sa, nPump, nPump);
+            return FightAi.canFight(ai, sa, nPump, nPump);
         }
 
         if (amountStr.equals("X")) {
@@ -443,17 +438,16 @@ public class CountersPutAi extends CountersAi {
                         }
                         sa.addDividedAllocation(c, amount);
                         return decision;
-                    } else {
-                        if (!hasSacCost) {
-                            // for Sacrifice costs, evaluate further to see if it's worth using the ability before the card dies
-                            return decision;
-                        }
+                    } else if (!hasSacCost) {
+                        // for Sacrifice costs, evaluate further to see if it's worth using the ability before the card dies
+                        return decision;
                     }
                 }
             }
 
             sa.resetTargets();
 
+            CardCollection list;
             if (sa.isCurse()) {
                 list = ai.getOpponents().getCardsIn(ZoneType.Battlefield);
             } else {
@@ -609,7 +603,21 @@ public class CountersPutAi extends CountersAi {
                 return new AiAbilityDecision(0, AiPlayDecision.MissingNeededCards);
             }
 
-            final int currCounters = cards.get(0).getCounters(CounterType.get(type));
+            final int currCounters = cards.get(0).getCounters(CounterType.getType(type));
+
+            // adding counters would cause counter amount to overflow
+            if (Integer.MAX_VALUE - currCounters <= amount) {
+                return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+            }
+            if (type.equals("P1P1")) {
+                if (Integer.MAX_VALUE - cards.get(0).getNetPower() <= amount) {
+                    return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+                }
+                if (Integer.MAX_VALUE - cards.get(0).getNetToughness() <= amount) {
+                    return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+                }
+            }
+
             // each non +1/+1 counter on the card is a 10% chance of not
             // activating this ability.
 
@@ -624,7 +632,7 @@ public class CountersPutAi extends CountersAi {
             }
 
             // Useless since the card already has the keyword (or for another reason)
-            if (ComputerUtil.isUselessCounter(CounterType.get(type), cards.get(0))) {
+            if (ComputerUtil.isUselessCounter(CounterType.getType(type), cards.get(0))) {
                 return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
             }
         }
@@ -671,14 +679,12 @@ public class CountersPutAi extends CountersAi {
                 || (sa.getRootAbility().isTrigger() && !sa.getRootAbility().isOptionalTrigger());
 
         if (sa.usesTargeting()) {
-            CardCollection list = null;
-
+            CardCollection list;
             if (sa.isCurse()) {
                 list = ai.getOpponents().getCardsIn(ZoneType.Battlefield);
             } else {
                 list = new CardCollection(ai.getCardsIn(ZoneType.Battlefield));
             }
-
             list = CardLists.getTargetableCards(list, sa);
 
             if (list.isEmpty() && isMandatoryTrigger) {
@@ -694,9 +700,8 @@ public class CountersPutAi extends CountersAi {
                             || sa.getTargets().isEmpty()) {
                         sa.resetTargets();
                         return new AiAbilityDecision(0, AiPlayDecision.TargetingFailed);
-                    } else {
-                        break;
                     }
+                    break;
                 }
 
                 if (sa.isCurse()) {
@@ -738,10 +743,7 @@ public class CountersPutAi extends CountersAi {
     protected AiAbilityDecision doTriggerNoCost(Player ai, SpellAbility sa, boolean mandatory) {
         final SpellAbility root = sa.getRootAbility();
         final Card source = sa.getHostCard();
-        final String aiLogic = sa.getParamOrDefault("AILogic", "");
-        // boolean chance = true;
-        boolean preferred = true;
-        CardCollection list;
+        final String aiLogic = sa.getParam("AILogic");
         final String amountStr = sa.getParamOrDefault("CounterNum", "1");
         final boolean divided = sa.isDividedAsYouChoose();
         final int amount = AbilityUtils.calculateAmount(source, amountStr, sa);
@@ -760,28 +762,10 @@ public class CountersPutAi extends CountersAi {
         }
 
         if ("ChargeToBestCMC".equals(aiLogic)) {
-            AiAbilityDecision decision = doChargeToCMCLogic(ai, sa);
-            if (decision.willingToPlay()) {
-                // If the AI logic is to charge to best CMC, we can return true
-                // if the logic was successfully applied or if it's mandatory.
-                return decision;
-            } else if (mandatory) {
-                // If the logic was not applied and it's mandatory, we return false.
+            if (mandatory) {
                 return new AiAbilityDecision(50, AiPlayDecision.MandatoryPlay);
-            } else {
-                // If the logic was not applied and it's not mandatory, we return false.
-                return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
-            }
-        } else if ("ChargeToBestOppControlledCMC".equals(aiLogic)) {
-            AiAbilityDecision decision = doChargeToOppCtrlCMCLogic(ai, sa);
-            if (decision.willingToPlay()) {
-                return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
-            } else if (mandatory) {
-                // If the logic was not applied and it's mandatory, we return false.
-                return new AiAbilityDecision(50, AiPlayDecision.MandatoryPlay);
-            } else {
-                return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
             }
+            return doChargeToCMCLogic(ai, sa);
         }
 
         if (!sa.usesTargeting()) {
@@ -805,7 +789,6 @@ public class CountersPutAi extends CountersAi {
                 // things like Powder Keg, which are way too complex for the AI
             }
         } else if (sa.getTargetRestrictions().canOnlyTgtOpponent() && !sa.getTargetRestrictions().canTgtCreature()) {
-            // can only target opponent
             PlayerCollection playerList = new PlayerCollection(IterableUtil.filter(
                     sa.getTargetRestrictions().getAllCandidates(sa, true, true), Player.class));
 
@@ -820,34 +803,32 @@ public class CountersPutAi extends CountersAi {
                 sa.getTargets().add(choice);
             }
         } else {
-            String logic = sa.getParam("AILogic");
-            if ("Fight".equals(logic) || "PowerDmg".equals(logic)) {
+            if ("Fight".equals(aiLogic) || "PowerDmg".equals(aiLogic)) {
                 int nPump = 0;
                 if (type.equals("P1P1")) {
                     nPump = amount;
                 }
-                AiAbilityDecision decision = FightAi.canFightAi(ai, sa, nPump, nPump);
+                AiAbilityDecision decision = FightAi.canFight(ai, sa, nPump, nPump);
                 if (decision.willingToPlay()) {
                     return decision;
                 }
             }
 
-            if (sa.isCurse()) {
-                list = ai.getOpponents().getCardsIn(ZoneType.Battlefield);
-            } else {
-                list = new CardCollection(ai.getCardsIn(ZoneType.Battlefield));
-            }
-            list = CardLists.getTargetableCards(list, sa);
-
-            // Filter AI-specific targets if provided
-            list = ComputerUtil.filterAITgts(sa, ai, list, false);
-
-            int totalTargets = list.size();
-
             sa.resetTargets();
+
+            Iterable<Card> filteredField;
+            if (sa.isCurse()) {
+                filteredField = ai.getOpponents().getCardsIn(ZoneType.Battlefield);
+            } else {
+                filteredField = ai.getCardsIn(ZoneType.Battlefield);
+            }
+            CardCollection list = CardLists.getTargetableCards(filteredField, sa);
+            list = ComputerUtil.filterAITgts(sa, ai, list, false);
+            int totalTargets = list.size();
+            boolean preferred = true;
+
             while (sa.canAddMoreTarget()) {
                 if (mandatory) {
-                    // When things are mandatory, gotta handle a little differently
                     if ((list.isEmpty() || !preferred) && sa.isTargetNumberValid()) {
                         return new AiAbilityDecision(0, AiPlayDecision.TargetingFailed);
                     }
@@ -869,12 +850,10 @@ public class CountersPutAi extends CountersAi {
                 if (list.isEmpty()) {
                     // Not mandatory, or the the list was regenerated and is still empty,
                     // so return whether or not we found enough targets
-                    if (sa.isTargetNumberValid()) {
-                        return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
-                    }
+                    return new AiAbilityDecision(sa.isTargetNumberValid() ? 100 : 0, sa.isTargetNumberValid() ? AiPlayDecision.WillPlay : AiPlayDecision.CantPlayAi);
                 }
 
-                Card choice = null;
+                Card choice;
 
                 // Choose targets here:
                 if (sa.isCurse()) {
@@ -883,33 +862,27 @@ public class CountersPutAi extends CountersAi {
                         if (choice == null && mandatory) {
                             choice = Aggregates.random(list);
                         }
+                    } else if (type.equals("M1M1")) {
+                        choice = ComputerUtilCard.getWorstCreatureAI(list);
                     } else {
-                        if (type.equals("M1M1")) {
-                            choice = ComputerUtilCard.getWorstCreatureAI(list);
-                        } else {
-                            choice = Aggregates.random(list);
-                        }
+                        choice = Aggregates.random(list);
                     }
+                } else if (preferred) {
+                    list = ComputerUtil.getSafeTargets(ai, sa, list);
+                    choice = chooseBoonTarget(list, type);
+                    if (choice == null && mandatory) {
+                        choice = Aggregates.random(list);
+                    }
+                } else if (type.equals("P1P1")) {
+                    choice = ComputerUtilCard.getWorstCreatureAI(list);
                 } else {
-                    if (preferred) {
-                        list = ComputerUtil.getSafeTargets(ai, sa, list);
-                        choice = chooseBoonTarget(list, type);
-                        if (choice == null && mandatory) {
-                            choice = Aggregates.random(list);
-                        }
-                    } else {
-                        if (type.equals("P1P1")) {
-                            choice = ComputerUtilCard.getWorstCreatureAI(list);
-                        } else {
-                            choice = Aggregates.random(list);
-                        }
-                    }
+                    choice = Aggregates.random(list);
                 }
                 if (choice != null && divided) {
-                    int alloc = Math.max(amount / totalTargets, 1);
                     if (sa.getTargets().size() == Math.min(totalTargets, sa.getMaxTargets()) - 1) {
                         sa.addDividedAllocation(choice, left);
                     } else {
+                        int alloc = Math.max(amount / totalTargets, 1);
                         sa.addDividedAllocation(choice, alloc);
                         left -= alloc;
                     }
@@ -979,8 +952,8 @@ public class CountersPutAi extends CountersAi {
     protected Card chooseSingleCard(final Player ai, SpellAbility sa, Iterable<Card> options, boolean isOptional, Player targetedPlayer, Map<String, Object> params) {
         // Bolster does use this
         // TODO need more or less logic there?
-        final CounterType m1m1 = CounterType.get(CounterEnumType.M1M1);
-        final CounterType p1p1 = CounterType.get(CounterEnumType.P1P1);
+        final CounterType m1m1 = CounterEnumType.M1M1;
+        final CounterType p1p1 = CounterEnumType.P1P1;
 
         // no logic if there is no options or no to choice
         if (!isOptional && Iterables.size(options) <= 1) {
@@ -999,9 +972,7 @@ public class CountersPutAi extends CountersAi {
         final String amountStr = sa.getParamOrDefault("CounterNum", "1");
         final int amount = AbilityUtils.calculateAmount(sa.getHostCard(), amountStr, sa);
 
-        final boolean isCurse = sa.isCurse();
-
-        if (isCurse) {
+        if (sa.isCurse()) {
             final CardCollection opponents = CardLists.filterControlledBy(options, ai.getOpponents());
 
             if (!opponents.isEmpty()) {
@@ -1098,11 +1069,10 @@ public class CountersPutAi extends CountersAi {
         Player ai = sa.getActivatingPlayer();
         GameEntity e = (GameEntity) params.get("Target");
         // for Card try to select not useless counter
-        if (e instanceof Card) {
-            Card c = (Card) e;
+        if (e instanceof Card c) {
             if (c.getController().isOpponentOf(ai)) {
-                if (options.contains(CounterType.get(CounterEnumType.M1M1)) && !c.hasKeyword(Keyword.UNDYING)) {
-                    return CounterType.get(CounterEnumType.M1M1);
+                if (options.contains(CounterEnumType.M1M1) && !c.hasKeyword(Keyword.UNDYING)) {
+                    return CounterEnumType.M1M1;
                 }
                 for (CounterType type : options) {
                     if (ComputerUtil.isNegativeCounter(type, c)) {
@@ -1116,15 +1086,14 @@ public class CountersPutAi extends CountersAi {
                     }
                 }
             }
-        } else if (e instanceof Player) {
-            Player p = (Player) e;
+        } else if (e instanceof Player p) {
             if (p.isOpponentOf(ai)) {
-                if (options.contains(CounterType.get(CounterEnumType.POISON))) {
-                    return CounterType.get(CounterEnumType.POISON);
+                if (options.contains(CounterEnumType.POISON)) {
+                    return CounterEnumType.POISON;
                 }
             } else {
-                if (options.contains(CounterType.get(CounterEnumType.EXPERIENCE))) {
-                    return CounterType.get(CounterEnumType.EXPERIENCE);
+                if (options.contains(CounterEnumType.EXPERIENCE)) {
+                    return CounterEnumType.EXPERIENCE;
                 }
             }
 
@@ -1228,12 +1197,9 @@ public class CountersPutAi extends CountersAi {
             }
         }
         if (numCtrs < optimalCMC) {
-            // If the AI has less counters than the optimal CMC, it should play the ability.
             return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
-        } else {
-            // If the AI has enough counters or more than the optimal CMC, it should not play the ability.
-            return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
         }
+        return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
     }
 
     private AiAbilityDecision doChargeToOppCtrlCMCLogic(Player ai, SpellAbility sa) {
@@ -1253,9 +1219,8 @@ public class CountersPutAi extends CountersAi {
         if (numCtrs < optimalCMC) {
             // If the AI has less counters than the optimal CMC, it should play the ability.
             return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
-        } else {
-            // If the AI has enough counters or more than the optimal CMC, it should not play the ability.
-            return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
         }
+        // If the AI has enough counters or more than the optimal CMC, it should not play the ability.
+        return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
     }
 }

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

@@ -218,18 +218,18 @@ public class CountersPutOrRemoveAi extends SpellAbilityAi {
         Card tgt = (Card) params.get("Target");
 
         // planeswalker has high priority for loyalty counters
-        if (tgt.isPlaneswalker() && options.contains(CounterType.get(CounterEnumType.LOYALTY))) {
-            return CounterType.get(CounterEnumType.LOYALTY);
+        if (tgt.isPlaneswalker() && options.contains(CounterEnumType.LOYALTY)) {
+            return CounterEnumType.LOYALTY;
         }
 
         if (tgt.getController().isOpponentOf(ai)) {
             // creatures with BaseToughness below or equal zero might be
             // killed if their counters are removed
             if (tgt.isCreature() && tgt.getBaseToughness() <= 0) {
-                if (options.contains(CounterType.get(CounterEnumType.P1P1))) {
-                    return CounterType.get(CounterEnumType.P1P1);
-                } else if (options.contains(CounterType.get(CounterEnumType.M1M1))) {
-                    return CounterType.get(CounterEnumType.M1M1);
+                if (options.contains(CounterEnumType.P1P1)) {
+                    return CounterEnumType.P1P1;
+                } else if (options.contains(CounterEnumType.M1M1)) {
+                    return CounterEnumType.M1M1;
                 }
             }
 
@@ -241,17 +241,17 @@ public class CountersPutOrRemoveAi extends SpellAbilityAi {
             }
         } else {
             // this counters are treat first to be removed
-            if ("Dark Depths".equals(tgt.getName()) && options.contains(CounterType.get(CounterEnumType.ICE))) {
+            if ("Dark Depths".equals(tgt.getName()) && options.contains(CounterEnumType.ICE)) {
                 CardCollectionView marit = ai.getCardsIn(ZoneType.Battlefield, "Marit Lage");
                 boolean maritEmpty = marit.isEmpty() || Iterables.contains(marit, (Predicate<Card>) Card::ignoreLegendRule);
 
                 if (maritEmpty) {
-                    return CounterType.get(CounterEnumType.ICE);
+                    return CounterEnumType.ICE;
                 }
-            } else if (tgt.hasKeyword(Keyword.UNDYING) && options.contains(CounterType.get(CounterEnumType.P1P1))) {
-                return CounterType.get(CounterEnumType.P1P1);
-            } else if (tgt.hasKeyword(Keyword.PERSIST) && options.contains(CounterType.get(CounterEnumType.M1M1))) {
-                return CounterType.get(CounterEnumType.M1M1);
+            } else if (tgt.hasKeyword(Keyword.UNDYING) && options.contains(CounterEnumType.P1P1)) {
+                return CounterEnumType.P1P1;
+            } else if (tgt.hasKeyword(Keyword.PERSIST) && options.contains(CounterEnumType.M1M1)) {
+                return CounterEnumType.M1M1;
             }
 
             // fallback logic, select positive counter to add more

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

@@ -384,7 +384,7 @@ public class CountersRemoveAi extends SpellAbilityAi {
             if (targetCard.getController().isOpponentOf(ai)) {
                 // if its a Planeswalker try to remove Loyality first
                 if (targetCard.isPlaneswalker()) {
-                    return CounterType.get(CounterEnumType.LOYALTY);
+                    return CounterEnumType.LOYALTY;
                 }
                 for (CounterType type : options) {
                     if (!ComputerUtil.isNegativeCounter(type, targetCard)) {
@@ -392,10 +392,10 @@ public class CountersRemoveAi extends SpellAbilityAi {
                     }
                 }
             } else {
-                if (options.contains(CounterType.get(CounterEnumType.M1M1)) && targetCard.hasKeyword(Keyword.PERSIST)) {
-                    return CounterType.get(CounterEnumType.M1M1);
-                } else if (options.contains(CounterType.get(CounterEnumType.P1P1)) && targetCard.hasKeyword(Keyword.UNDYING)) {
-                    return CounterType.get(CounterEnumType.P1P1);
+                if (options.contains(CounterEnumType.M1M1) && targetCard.hasKeyword(Keyword.PERSIST)) {
+                    return CounterEnumType.M1M1;
+                } else if (options.contains(CounterEnumType.P1P1) && targetCard.hasKeyword(Keyword.UNDYING)) {
+                    return CounterEnumType.P1P1;
                 }
                 for (CounterType type : options) {
                     if (ComputerUtil.isNegativeCounter(type, targetCard)) {

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

@@ -5,7 +5,6 @@ import forge.game.ability.AbilityUtils;
 import forge.game.card.Card;
 import forge.game.card.CardCollection;
 import forge.game.card.CardLists;
-import forge.game.cost.Cost;
 import forge.game.keyword.Keyword;
 import forge.game.phase.PhaseType;
 import forge.game.player.Player;
@@ -21,14 +20,6 @@ public class  DamageAllAi extends SpellAbilityAi {
         // based on what the expected targets could be
         final Card source = sa.getHostCard();
 
-        // abCost stuff that should probably be centralized...
-        final Cost abCost = sa.getPayCosts();
-        if (abCost != null) {
-            // AI currently disabled for some costs
-            if (!ComputerUtilCost.checkLifeCost(ai, abCost, source, 4, sa)) {
-                return new AiAbilityDecision(0, AiPlayDecision.CantAfford);
-            }
-        }
         // wait until stack is empty (prevents duplicate kills)
         if (!ai.getGame().getStack().isEmpty()) {
             return new AiAbilityDecision(0, AiPlayDecision.StackNotEmpty);
@@ -142,9 +133,9 @@ public class  DamageAllAi extends SpellAbilityAi {
                     if (ComputerUtilCombat.predictDamageTo(opp, dmg, source, false) > 0) {
                         // When using Pestilence to hurt players, do it at
                         // the end of the opponent's turn only
-                        if ((!"DmgAllCreaturesAndPlayers".equals(sa.getParam("AILogic")))
-                                || ((ai.getGame().getPhaseHandler().is(PhaseType.END_OF_TURN)
-                                && (ai.getGame().getNonactivePlayers().contains(ai)))))
+                        if (!"DmgAllCreaturesAndPlayers".equals(sa.getParam("AILogic"))
+                                || (ai.getGame().getPhaseHandler().is(PhaseType.END_OF_TURN)
+                                && !ai.getGame().getPhaseHandler().isPlayerTurn(ai)))
                         // Need further improvement : if able to kill immediately with repeated activations, do not wait
                         // for phases! Will also need to implement considering repeated activations for killed creatures!
                         // || (ai.sa.getPayCosts(). ??? )

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

@@ -110,15 +110,7 @@ public class DestroyAi extends SpellAbilityAi {
 
         CardCollection list;
 
-        // Targeting
         if (sa.usesTargeting()) {
-            // If there's X in payment costs and it's tied to targeting, make sure we set the XManaCostPaid first
-            // (e.g. Heliod's Intervention)
-            if ("X".equals(sa.getTargetRestrictions().getMinTargets()) && sa.getSVar("X").equals("Count$xPaid")) {
-                int xPay = ComputerUtilCost.getMaxXValue(sa, ai, sa.isTrigger());
-                sa.getRootAbility().setXManaCostPaid(xPay);
-            }
-
             // Assume there where already enough targets chosen by AI Logic Above
             if (sa.hasParam("AILogic") && !sa.canAddMoreTarget() && sa.isTargetNumberValid()) {
                 return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
@@ -128,7 +120,10 @@ public class DestroyAi extends SpellAbilityAi {
             sa.resetTargets();
             int maxTargets;
 
-            if (sa.getRootAbility().costHasManaX()) {
+            // If there's X in payment costs and it's tied to targeting, make sure we set the XManaCostPaid first
+            // (e.g. Heliod's Intervention)
+            if (sa.getRootAbility().costHasManaX() ||
+                    ("X".equals(sa.getTargetRestrictions().getMinTargets()) && sa.getSVar("X").equals("Count$xPaid"))) {
                 // TODO: currently the AI will maximize mana spent on X, trying to maximize damage. This may need improvement.
                 maxTargets = ComputerUtilCost.getMaxXValue(sa, ai, sa.isTrigger());
                 // need to set XPaid to get the right number for

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

@@ -1,119 +0,0 @@
-package forge.ai.ability;
-
-import java.util.List;
-import java.util.function.Predicate;
-
-import forge.ai.AiAttackController;
-import forge.ai.ComputerUtil;
-import forge.ai.ComputerUtilCard;
-import forge.ai.SpellAbilityAi;
-import forge.game.Game;
-import forge.game.card.Card;
-import forge.game.card.CardCollection;
-import forge.game.card.CardLists;
-import forge.game.card.CardPredicates;
-import forge.game.combat.CombatUtil;
-import forge.game.phase.PhaseHandler;
-import forge.game.phase.PhaseType;
-import forge.game.player.Player;
-import forge.game.spellability.SpellAbility;
-import forge.game.zone.ZoneType;
-
-public class DetainAi extends SpellAbilityAi {
-
-    Predicate<Card> CREATURE_OR_TAP_ABILITY = c -> {
-        if (c.isCreature()) {
-            return true;
-        }
-
-        for (final SpellAbility sa : c.getSpellAbilities()) {
-            if (sa.isAbility() && sa.getPayCosts().hasTapCost()) {
-                return true;
-            }
-        }
-        return false;
-    };
-
-    protected boolean prefTargeting(final Player ai, final Card source, final SpellAbility sa, final boolean mandatory) {
-        final Game game = ai.getGame();
-        CardCollection list = CardLists.getTargetableCards(ai.getOpponents().getCardsIn(ZoneType.Battlefield), sa);
-        list = CardLists.filter(list, CREATURE_OR_TAP_ABILITY);
-
-        // Filter AI-specific targets if provided
-        list = ComputerUtil.filterAITgts(sa, ai, list, true);
-
-
-        if (list.isEmpty()) {
-            return false;
-        }
-
-        while (sa.canAddMoreTarget()) {
-            Card choice = null;
-            if (list.isEmpty()) {
-                if (!sa.isMinTargetChosen() || sa.isZeroTargets()) {
-                    if (!mandatory) {
-                        sa.resetTargets();
-                    }
-                    return false;
-
-                }
-            }
-
-            PhaseHandler phase = game.getPhaseHandler();
-            final Player opp = AiAttackController.choosePreferredDefenderPlayer(ai);
-            Card primeTarget = ComputerUtil.getKilledByTargeting(sa, list);
-            if (primeTarget != null) {
-                choice = primeTarget;
-            } else if (phase.isPlayerTurn(ai) && phase.getPhase().isBefore(PhaseType.COMBAT_DECLARE_BLOCKERS)) {
-                // Tap creatures possible blockers before combat during AI's turn.
-                List<Card> attackers;
-                if (phase.getPhase().isAfter(PhaseType.COMBAT_DECLARE_ATTACKERS)) {
-                    //Combat has already started
-                    attackers = game.getCombat().getAttackers();
-                } else {
-                    attackers = CardLists.filter(ai.getCreaturesInPlay(), c -> CombatUtil.canAttack(c, opp));
-                    attackers.remove(source);
-                }
-                List<Card> creatureList = CardLists.filter(list, CardPredicates.possibleBlockerForAtLeastOne(attackers));
-
-                // TODO check if own creature would be forced to attack and we want to keep it alive
-
-                if (!attackers.isEmpty() && !creatureList.isEmpty()) {
-                    choice = ComputerUtilCard.getBestCreatureAI(creatureList);
-                } else if (sa.isTrigger() || ComputerUtil.castSpellInMain1(ai, sa)) {
-                    choice = ComputerUtilCard.getMostExpensivePermanentAI(list);
-                }
-            } else if (phase.isPlayerTurn(opp)
-                    && phase.getPhase().isBefore(PhaseType.COMBAT_DECLARE_ATTACKERS)) {
-                // Tap creatures possible blockers before combat during AI's turn.
-                if (list.anyMatch(CardPredicates.CREATURES)) {
-                    List<Card> creatureList = CardLists.filter(list, c -> c.isCreature() && CombatUtil.canAttack(c, opp));
-                    choice = ComputerUtilCard.getBestCreatureAI(creatureList);
-                } else { // no creatures available
-                    choice = ComputerUtilCard.getMostExpensivePermanentAI(list);
-                }
-            } else {
-                choice = ComputerUtilCard.getMostExpensivePermanentAI(list);
-            }
-
-            if (choice == null) { // can't find anything left
-                if (!sa.isMinTargetChosen() || sa.isZeroTargets()) {
-                    if (!mandatory) {
-                        sa.resetTargets();
-                    }
-                    return false;
-                } else {
-                    if (!ComputerUtil.shouldCastLessThanMax(ai, source)) {
-                        return false;
-                    }
-                    break;
-                }
-            }
-
-            list.remove(choice);
-            sa.getTargets().add(choice);
-        }
-
-        return true;
-    }
-}

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

@@ -26,7 +26,6 @@ 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.phase.PhaseHandler;
 import forge.game.phase.PhaseType;
@@ -370,7 +369,7 @@ public class DrawAi extends SpellAbilityAi {
 
                 // try to make opponent lose to poison
                 // currently only Caress of Phyrexia
-                if (getPoison != null && oppA.canReceiveCounters(CounterType.get(CounterEnumType.POISON))) {
+                if (getPoison != null && oppA.canReceiveCounters(CounterEnumType.POISON)) {
                     if (oppA.getPoisonCounters() + numCards > 9) {
                         sa.getTargets().add(oppA);
                         return true;
@@ -414,7 +413,7 @@ public class DrawAi extends SpellAbilityAi {
                     }
                 }
 
-                if (getPoison != null && ai.canReceiveCounters(CounterType.get(CounterEnumType.POISON))) {
+                if (getPoison != null && ai.canReceiveCounters(CounterEnumType.POISON)) {
                     if (numCards + ai.getPoisonCounters() >= 8) {
                         aiTarget = false;
                     }
@@ -472,7 +471,7 @@ public class DrawAi extends SpellAbilityAi {
                 }
 
                 // ally would lose because of poison
-                if (getPoison != null && ally.canReceiveCounters(CounterType.get(CounterEnumType.POISON)) && ally.getPoisonCounters() + numCards > 9) {
+                if (getPoison != null && ally.canReceiveCounters(CounterEnumType.POISON) && ally.getPoisonCounters() + numCards > 9) {
                         continue;
                 }
 

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

@@ -23,10 +23,8 @@ import forge.game.replacement.ReplacementType;
 import forge.game.spellability.SpellAbility;
 import forge.game.spellability.SpellAbilityStackInstance;
 import forge.game.spellability.TargetRestrictions;
-import forge.game.staticability.StaticAbilityMode;
 import forge.game.zone.MagicStack;
 import forge.game.zone.ZoneType;
-import forge.util.FileSection;
 import forge.util.MyRandom;
 import forge.util.TextUtil;
 import forge.util.collect.FCollectionView;
@@ -39,22 +37,17 @@ public class EffectAi extends SpellAbilityAi {
     @Override
     protected AiAbilityDecision checkApiLogic(final Player ai, final SpellAbility sa) {
         final Game game = ai.getGame();
-        final PhaseHandler phase = game.getPhaseHandler();
         boolean randomReturn = MyRandom.getRandom().nextFloat() <= .6667;
         String logic = "";
 
         if (sa.hasParam("AILogic")) {
             logic = sa.getParam("AILogic");
+            final PhaseHandler phase = game.getPhaseHandler();
             if (logic.equals("BeginningOfOppTurn")) {
                 if (!phase.getPlayerTurn().isOpponentOf(ai) || phase.getPhase().isAfter(PhaseType.DRAW)) {
                     return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
                 }
                 randomReturn = true;
-            } else if (logic.equals("EndOfOppTurn")) {
-                if (!phase.getPlayerTurn().isOpponentOf(ai) || phase.getPhase().isBefore(PhaseType.END_OF_TURN)) {
-                    return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
-                }
-                randomReturn = true;
             } else if (logic.equals("KeepOppCreatsLandsTapped")) {
                 for (Player opp : ai.getOpponents()) {
                     boolean worthHolding = false;
@@ -277,7 +270,7 @@ public class EffectAi extends SpellAbilityAi {
                 }
                 return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
             } else if (logic.equals("Fight")) {
-                return FightAi.canFightAi(ai, sa, 0,0);
+                return FightAi.canFight(ai, sa, 0,0);
             } else if (logic.equals("Pump")) {
                 sa.resetTargets();
                 List<Card> options = CardUtil.getValidCardsToTarget(sa);
@@ -296,6 +289,7 @@ public class EffectAi extends SpellAbilityAi {
             } else if (logic.equals("YawgmothsWill")) {
                 return SpecialCardAi.YawgmothsWill.consider(ai, sa) ? new AiAbilityDecision(100, AiPlayDecision.WillPlay) : new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
             } else if (logic.startsWith("NeedCreatures")) {
+                // TODO convert to AiCheckSVar
                 if (ai.getCreaturesInPlay().isEmpty()) {
                     return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
                 }
@@ -330,8 +324,8 @@ public class EffectAi extends SpellAbilityAi {
                 Combat combat = game.getCombat();
                 if (combat != null && combat.isAttacking(host, ai) && !combat.isBlocked(host)
                         && phase.is(PhaseType.COMBAT_DECLARE_BLOCKERS)
-                        && !AiCardMemory.isRememberedCard(ai, host, AiCardMemory.MemorySet.ACTIVATED_THIS_TURN)) {
-                    AiCardMemory.rememberCard(ai, host, AiCardMemory.MemorySet.ACTIVATED_THIS_TURN); // ideally needs once per combat or something
+                        && !host.getAbilityActivatedThisTurn().getActivators(sa).contains(ai)) {
+                    // ideally needs once per combat or something
                     return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
                 }
                 return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
@@ -385,118 +379,6 @@ public class EffectAi extends SpellAbilityAi {
                     return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
                 }
             }
-        } else if (sa.hasParam("RememberObjects")) { //generic
-            boolean cantAttack = false;
-            boolean cantBlock = false;
-            boolean cantActivate = false;
-
-            String duraction = sa.getParam("Duration");
-
-            String matchStr = "Card.IsRemembered";
-
-            for (String st : sa.getParam("StaticAbilities").split(",")) {
-                Map<String, String> params = FileSection.parseToMap(sa.getSVar(st), FileSection.DOLLAR_SIGN_KV_SEPARATOR);
-                List<StaticAbilityMode> modes = StaticAbilityMode.listValueOf(params.get("Mode"));
-
-                if (modes.contains(StaticAbilityMode.CantAttack) && matchStr.equals(params.get("ValidCard"))) {
-                    cantAttack = true;
-                }
-                if (modes.contains(StaticAbilityMode.CantBlock) && matchStr.equals(params.get("ValidCard"))) {
-                    cantBlock = true;
-                }
-                if (modes.contains(StaticAbilityMode.CantBlockBy) && matchStr.equals(params.get("ValidBlocker"))) {
-                    cantBlock = true;
-                }
-                if (modes.contains(StaticAbilityMode.CantBeActivated) && matchStr.equals(params.get("ValidCard"))) {
-                    cantActivate = true;
-                }
-            }
-
-            // TODO add more cases later
-            if (!cantAttack && !cantBlock && !cantActivate) {
-                return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
-            }
-
-            if (cantBlock && duraction == null && phase.isPlayerTurn(ai) && !phase.getPhase().isBefore(PhaseType.COMBAT_DECLARE_BLOCKERS)) {
-                return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
-            }
-
-            if (sa.usesTargeting()) {
-                final Player opp = AiAttackController.choosePreferredDefenderPlayer(ai);
-
-                CardCollection list = new CardCollection(CardUtil.getValidCardsToTarget(sa));
-
-                list = ComputerUtil.filterAITgts(sa, ai, list, true);
-
-                if (list.isEmpty()) {
-                    return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
-                }
-
-                List<Card> oppCreatures = CardLists.filterAsList(list, c -> {
-                    return c.isCreature() && c.getController().isOpponentOf(ai);
-                });
-
-                List<Card> oppWithAbilities = CardLists.filterAsList(list, c -> {
-                    return !c.isCreature() && c.getController().isOpponentOf(ai) && c.getSpellAbilities().anyMatch(SpellAbility::isActivatedAbility);
-                });
-
-                if (cantAttack || cantBlock) {
-                    if (oppCreatures.isEmpty()) {
-                        if (!cantActivate || oppWithAbilities.isEmpty()) {
-                            return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
-                        }
-                    }
-                }
-
-
-
-                while (sa.canAddMoreTarget()) {
-                    Card choice = null;
-                    if (cantAttack && cantBlock && !oppCreatures.isEmpty()) {
-                        Card primeTarget = ComputerUtil.getKilledByTargeting(sa, oppCreatures);
-                        if (primeTarget != null) {
-                            choice = primeTarget;
-                        } else if (phase.isPlayerTurn(ai) && phase.getPhase().isBefore(PhaseType.COMBAT_DECLARE_BLOCKERS)) {
-                            // Tap creatures possible blockers before combat during AI's turn.
-                            List<Card> attackers;
-                            if (phase.getPhase().isAfter(PhaseType.COMBAT_DECLARE_ATTACKERS)) {
-                                //Combat has already started
-                                attackers = game.getCombat().getAttackers();
-                            } else {
-                                attackers = CardLists.filter(ai.getCreaturesInPlay(), c -> CombatUtil.canAttack(c, opp));
-                            }
-                            List<Card> creatureList = CardLists.filter(list, CardPredicates.possibleBlockerForAtLeastOne(attackers));
-
-                            // TODO check if own creature would be forced to attack and we want to keep it alive
-
-                            if (!attackers.isEmpty() && !creatureList.isEmpty()) {
-                                choice = ComputerUtilCard.getBestCreatureAI(creatureList);
-                            } else if (sa.isTrigger() || ComputerUtil.castSpellInMain1(ai, sa)) {
-                                choice = ComputerUtilCard.getMostExpensivePermanentAI(list);
-                            }
-                        }
-                    } // TODO add logic to tap non creatures with activated abilities if cantActivate is true
-
-                    if (choice == null) { // can't find anything left
-                        if (!sa.isMinTargetChosen() || sa.isZeroTargets()) {
-                            sa.resetTargets();
-                            return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
-                        } else {
-                            if (!ComputerUtil.shouldCastLessThanMax(ai, sa.getHostCard())) {
-                                return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
-                            }
-                            break;
-                        }
-                    }
-
-                    list.remove(choice);
-                    oppCreatures.remove(choice);
-                    sa.getTargets().add(choice);
-                }
-                return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
-            }
-
-            return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
         } else { //no AILogic
             return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
         }

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

@@ -1,17 +1,15 @@
 package forge.ai.ability;
 
 import com.google.common.collect.Sets;
-
-import forge.ai.AiAbilityDecision;
-import forge.ai.AiPlayDecision;
-import forge.ai.ComputerUtilCard;
-import forge.ai.SpellAbilityAi;
-import forge.game.ability.AbilityUtils;
+import forge.ai.*;
 import forge.game.Game;
+import forge.game.ability.AbilityUtils;
 import forge.game.card.*;
 import forge.game.card.token.TokenInfo;
 import forge.game.combat.Combat;
 import forge.game.combat.CombatUtil;
+import forge.game.cost.CostPayLife;
+import forge.game.phase.PhaseType;
 import forge.game.player.Player;
 import forge.game.player.PlayerActionConfirmMode;
 import forge.game.spellability.SpellAbility;
@@ -36,6 +34,26 @@ public class EndureAi extends SpellAbilityAi {
             sa.getTargets().add(bestCreature);
         }
 
+        // Card-specific logic
+        final String num = sa.getParamOrDefault("Num", "1");
+        if ("X".equals(num) && sa.getPayCosts().hasSpecificCostType(CostPayLife.class)) {
+            if (!aiPlayer.getGame().getPhaseHandler().is(PhaseType.MAIN2)) {
+                return new AiAbilityDecision(0, AiPlayDecision.AnotherTime);
+            }
+            int curLife = aiPlayer.getLife();
+            int dangerLife = (((PlayerControllerAi) aiPlayer.getController()).getAi().getIntProperty(AiProps.AI_IN_DANGER_THRESHOLD));
+            if (curLife <= dangerLife) {
+                return new AiAbilityDecision(0, AiPlayDecision.CantAffordX);
+            }
+            int availableMana = ComputerUtilMana.getAvailableManaEstimate(aiPlayer) - 1;
+            int maxEndureX = Math.min(availableMana, curLife - dangerLife);
+            if (maxEndureX > 0) {
+                sa.setXManaCostPaid(maxEndureX);
+            } else {
+                return new AiAbilityDecision(0, AiPlayDecision.CantAffordX);
+            }
+        }
+
         return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
     }
 

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

@@ -177,7 +177,7 @@ public class FightAi extends SpellAbilityAi {
      * @param power	bonus to power
      * @return true if fight effect should be played, false otherwise
      */
-    public static AiAbilityDecision canFightAi(final Player ai, final SpellAbility sa, int power, int toughness) {
+    public static AiAbilityDecision canFight(final Player ai, final SpellAbility sa, int power, int toughness) {
     	final Card source = sa.getHostCard();
         final String sourceName = ComputerUtilAbility.getAbilitySourceName(sa);
         AbilitySub tgtFight = sa.getSubAbility();

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

@@ -12,15 +12,13 @@ import forge.game.spellability.SpellAbility;
 public class FlipACoinAi extends SpellAbilityAi {
 
     /* (non-Javadoc)
-     * @see forge.card.abilityfactory.SpellAiLogic#canPlayAI(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility)
+     * @see forge.card.abilityfactory.SpellAiLogic#checkApiLogic(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility)
      */
     @Override
-    protected AiAbilityDecision canPlay(Player ai, SpellAbility sa) {
+    protected AiAbilityDecision checkApiLogic(Player ai, SpellAbility sa) {
         if (sa.hasParam("AILogic")) {
             String ailogic = sa.getParam("AILogic");
-            if (ailogic.equals("Never")) {
-                return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
-            } else if (ailogic.equals("PhaseOut")) {
+            if (ailogic.equals("PhaseOut")) {
                 if (!ComputerUtil.predictThreatenedObjects(sa.getActivatingPlayer(), sa).contains(sa.getHostCard())) {
                     return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
                 }

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

@@ -1,6 +1,5 @@
 package forge.ai.ability;
 
-
 import forge.ai.AiAbilityDecision;
 import forge.ai.AiPlayDecision;
 import forge.ai.SpellAbilityAi;

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

@@ -76,7 +76,8 @@ public class ManaAi extends SpellAbilityAi {
              return ph.is(PhaseType.MAIN2, ai) || ph.is(PhaseType.MAIN1, ai);
         }
         if ("AtOppEOT".equals(logic)) {
-            return (!ai.getManaPool().hasBurn() || !ai.canLoseLife() || ai.cantLoseForZeroOrLessLife()) && ph.is(PhaseType.END_OF_TURN) && ph.getNextTurn() == ai;
+            return ph.is(PhaseType.END_OF_TURN) && ph.getNextTurn() == ai
+                    && (!ai.getManaPool().hasBurn() || !ai.canLoseLife() || ai.cantLoseForZeroOrLessLife());
         }
         return super.checkPhaseRestrictions(ai, sa, ph, logic);
     }
@@ -158,7 +159,7 @@ public class ManaAi extends SpellAbilityAi {
         int numCounters = 0;
         int manaSurplus = 0;
         if ("Count$xPaid".equals(host.getSVar("X")) && sa.getPayCosts().hasSpecificCostType(CostRemoveCounter.class)) {
-            CounterType ctrType = CounterType.get(CounterEnumType.KI); // Petalmane Baku
+            CounterType ctrType = CounterEnumType.KI; // Petalmane Baku
             for (CostPart part : sa.getPayCosts().getCostParts()) {
                 if (part instanceof CostRemoveCounter) {
                     ctrType = ((CostRemoveCounter)part).counter;
@@ -277,10 +278,4 @@ public class ManaAi extends SpellAbilityAi {
         }
         return !lose;
     }
-
-    @Override
-    protected AiAbilityDecision canPlay(Player ai, SpellAbility sa) {
-        final String logic = sa.getParamOrDefault("AILogic", "");
-        return checkApiLogic(ai, sa);
-    }
 }

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

@@ -23,10 +23,8 @@ public class MeldAi extends SpellAbilityAi {
         boolean hasPrimaryMeld = cardsOTB.anyMatch(CardPredicates.nameEquals(primaryMeld).and(CardPredicates.isOwner(aiPlayer)));
         boolean hasSecondaryMeld = cardsOTB.anyMatch(CardPredicates.nameEquals(secondaryMeld).and(CardPredicates.isOwner(aiPlayer)));
         if (hasPrimaryMeld && hasSecondaryMeld && sa.getHostCard().getName().equals(primaryMeld)) {
-            // If the primary meld card is on the battlefield and both meld cards are owned by the AI, play the ability
             return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
         } else {
-            // If the secondary meld card is on the battlefield and it is the one being activated, play the ability
             return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
         }
     }

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

@@ -24,14 +24,8 @@ public class MillAi extends SpellAbilityAi {
 
     @Override
     protected boolean checkAiLogic(final Player ai, final SpellAbility sa, final String aiLogic) {
-        PhaseHandler ph = ai.getGame().getPhaseHandler();
-
-        if (aiLogic.equals("Main1")) {
-            return !ph.getPhase().isBefore(PhaseType.MAIN2) || sa.hasParam("ActivationPhases")
-                    || ComputerUtil.castSpellInMain1(ai, sa);
-        } else if (aiLogic.equals("EndOfOppTurn")) {
-            return ph.is(PhaseType.END_OF_TURN) && ph.getNextTurn().equals(ai);
-        } else if (aiLogic.equals("LilianaMill")) {
+        if (aiLogic.equals("LilianaMill")) {
+            // TODO convert to AICheckSVar
             // Only mill if a "Raise Dead" target is available, in case of control decks with few creatures
             return CardLists.filter(ai.getCardsIn(ZoneType.Graveyard), CardPredicates.CREATURES).size() >= 1;
         }
@@ -56,9 +50,10 @@ public class MillAi extends SpellAbilityAi {
             // because they are also potentially useful for combat
             return ph.is(PhaseType.END_OF_TURN) && ph.getNextTurn().equals(ai);
         }
-        return true;
+        return !ph.getPhase().isBefore(PhaseType.MAIN2) || sa.hasParam("ActivationPhases")
+                || ComputerUtil.castSpellInMain1(ai, sa);
     }
-    
+
     @Override
     protected AiAbilityDecision checkApiLogic(final Player ai, final SpellAbility sa) {
         /*

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

@@ -6,10 +6,10 @@ import forge.game.Game;
 import forge.game.ability.AbilityUtils;
 import forge.game.card.Card;
 import forge.game.card.CardLists;
+import forge.game.card.CardUtil;
 import forge.game.combat.Combat;
 import forge.game.combat.CombatUtil;
 import forge.game.keyword.Keyword;
-import forge.game.phase.PhaseType;
 import forge.game.player.Player;
 import forge.game.spellability.SpellAbility;
 
@@ -27,7 +27,8 @@ public class MustBlockAi extends SpellAbilityAi {
 
         if (combat == null || !combat.isAttacking(source)) {
             return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
-        } else if (AiCardMemory.isRememberedCard(aiPlayer, source, AiCardMemory.MemorySet.ACTIVATED_THIS_TURN)) {
+        }
+        if (source.getAbilityActivatedThisTurn().getActivators(sa).contains(aiPlayer)) {
             // The AI can meaningfully do it only to one creature per card yet, trying to do it to multiple cards
             // may result in overextending and losing the attacker
             return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
@@ -37,11 +38,7 @@ public class MustBlockAi extends SpellAbilityAi {
 
         if (!list.isEmpty()) {
             final Card blocker = ComputerUtilCard.getBestCreatureAI(list);
-            if (blocker == null) {
-                return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
-            }
             sa.getTargets().add(blocker);
-            AiCardMemory.rememberCard(aiPlayer, source, AiCardMemory.MemorySet.ACTIVATED_THIS_TURN);
             return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
         }
 
@@ -63,11 +60,6 @@ public class MustBlockAi extends SpellAbilityAi {
     protected AiAbilityDecision doTriggerNoCost(final Player ai, SpellAbility sa, boolean mandatory) {
         final Card source = sa.getHostCard();
 
-        // only use on creatures that can attack
-        if (!ai.getGame().getPhaseHandler().getPhase().isBefore(PhaseType.MAIN2)) {
-            return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
-        }
-
         Card attacker = source;
         if (sa.hasParam("DefinedAttacker")) {
             final List<Card> cards = AbilityUtils.getDefinedCards(source, sa.getParam("DefinedAttacker"), sa);
@@ -81,13 +73,9 @@ public class MustBlockAi extends SpellAbilityAi {
         boolean chance = false;
 
         if (sa.usesTargeting()) {
-            final List<Card> list = determineGoodBlockers(attacker, ai, ai.getWeakestOpponent(), sa, true, true);
-            if (list.isEmpty()) {
-                if (sa.isTargetNumberValid()) {
-                    return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
-                } else {
-                    return new AiAbilityDecision(0, AiPlayDecision.TargetingFailed);
-                }
+            List<Card> list = determineGoodBlockers(attacker, ai, ai.getWeakestOpponent(), sa, true, true);
+            if (list.isEmpty() && mandatory) {
+                list = CardUtil.getValidCardsToTarget(sa);
             }
             final Card blocker = ComputerUtilCard.getBestCreatureAI(list);
             if (blocker == null) {

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

@@ -3,7 +3,6 @@ package forge.ai.ability;
 import forge.ai.*;
 import forge.game.card.Card;
 import forge.game.card.CardCollection;
-import forge.game.phase.PhaseHandler;
 import forge.game.phase.PhaseType;
 import forge.game.player.Player;
 import forge.game.player.PlayerActionConfirmMode;
@@ -29,11 +28,6 @@ public class PeekAndRevealAi extends SpellAbilityAi {
             if (aiPlayer.getGame().getPhaseHandler().getPhase().isBefore(PhaseType.MAIN2)) {
                 return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
             }
-        } else if ("EndOfOppTurn".equals(logic)) {
-            PhaseHandler ph = aiPlayer.getGame().getPhaseHandler();
-            if (!(ph.getNextTurn() == aiPlayer && ph.is(PhaseType.END_OF_TURN))) {
-                return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
-            }
         }
         // So far this only appears on Triggers, but will expand
         // once things get converted from Dig + NoMove

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

@@ -78,7 +78,7 @@ public class PermanentCreatureAi extends PermanentAi {
                         || ph.getPhase().isBefore(PhaseType.END_OF_TURN))
                         && ai.getManaPool().totalMana() <= 0
                         && (ph.isPlayerTurn(ai) || ph.getPhase().isBefore(PhaseType.COMBAT_DECLARE_ATTACKERS))
-                        && (!card.hasETBTrigger(true) && !card.hasSVar("AmbushAI"))
+                        && !card.hasETBTrigger(true) && !card.hasSVar("AmbushAI")
                         && game.getStack().isEmpty()
                         && !ComputerUtil.castPermanentInMain1(ai, sa)) {
                     // AiPlayDecision.AnotherTime;

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

@@ -33,10 +33,8 @@ public class PhasesAi extends SpellAbilityAi {
                 final boolean isThreatened = ComputerUtil.predictThreatenedObjects(aiPlayer, null, true).contains(source);
                 if (isThreatened) {
                     return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
-                } else {
-                    return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
-
                 }
+                return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
             }
 
             return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);

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

@@ -153,8 +153,8 @@ public class PlayAi extends SpellAbilityAi {
             final boolean isOptional, Player targetedPlayer, Map<String, Object> params) {
         final CardStateName state;
         if (sa.hasParam("CastTransformed")) {
-            state = CardStateName.Transformed;
-            options.forEach(c -> c.changeToState(CardStateName.Transformed));
+            state = CardStateName.Backside;
+            options.forEach(c -> c.changeToState(CardStateName.Backside));
         } else {
             state = CardStateName.Original; 
         }

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

@@ -6,7 +6,6 @@ import forge.ai.ComputerUtil;
 import forge.ai.SpellAbilityAi;
 import forge.game.ability.AbilityUtils;
 import forge.game.card.CounterEnumType;
-import forge.game.card.CounterType;
 import forge.game.phase.PhaseHandler;
 import forge.game.phase.PhaseType;
 import forge.game.player.GameLossReason;
@@ -65,7 +64,7 @@ public class PoisonAi extends SpellAbilityAi {
         boolean result;
         if (sa.usesTargeting()) {
             result = tgtPlayer(ai, sa, mandatory);
-        } else if (mandatory || !ai.canReceiveCounters(CounterType.get(CounterEnumType.POISON))) {
+        } else if (mandatory || !ai.canReceiveCounters(CounterEnumType.POISON)) {
             // mandatory or ai is uneffected
             result = true;
         } else {
@@ -90,7 +89,7 @@ public class PoisonAi extends SpellAbilityAi {
             PlayerCollection betterTgts = tgts.filter(input -> {
                 if (input.cantLoseCheck(GameLossReason.Poisoned)) {
                     return false;
-                } else if (!input.canReceiveCounters(CounterType.get(CounterEnumType.POISON))) {
+                } else if (!input.canReceiveCounters(CounterEnumType.POISON)) {
                     return false;
                 }
                 return true;
@@ -109,7 +108,7 @@ public class PoisonAi extends SpellAbilityAi {
         if (tgts.isEmpty()) {
             if (mandatory) {
                 // AI is uneffected
-                if (ai.canBeTargetedBy(sa) && !ai.canReceiveCounters(CounterType.get(CounterEnumType.POISON))) {
+                if (ai.canBeTargetedBy(sa) && !ai.canReceiveCounters(CounterEnumType.POISON)) {
                     sa.getTargets().add(ai);
                     return true;
                 }
@@ -121,7 +120,7 @@ public class PoisonAi extends SpellAbilityAi {
                         if (input.cantLoseCheck(GameLossReason.Poisoned)) {
                             return true;
                         }
-                        return !input.canReceiveCounters(CounterType.get(CounterEnumType.POISON));
+                        return !input.canReceiveCounters(CounterEnumType.POISON);
                     });
                     if (!betterAllies.isEmpty()) {
                         allies = betterAllies;

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

@@ -7,8 +7,6 @@ import forge.game.Game;
 import forge.game.ability.AbilityUtils;
 import forge.game.ability.ApiType;
 import forge.game.card.*;
-import forge.game.cost.Cost;
-import forge.game.cost.CostTapType;
 import forge.game.keyword.Keyword;
 import forge.game.phase.PhaseHandler;
 import forge.game.phase.PhaseType;
@@ -23,13 +21,6 @@ import java.util.*;
 
 public class PumpAi extends PumpAiBase {
 
-    private static boolean hasTapCost(final Cost cost, final Card source) {
-        if (cost == null) {
-            return true;
-        }
-        return cost.hasSpecificCostType(CostTapType.class);
-    }
-
     @Override
     protected boolean checkAiLogic(final Player ai, final SpellAbility sa, final String aiLogic) {
         if ("MoveCounter".equals(aiLogic)) {
@@ -96,7 +87,7 @@ public class PumpAi extends PumpAiBase {
     protected boolean checkPhaseRestrictions(final Player ai, final SpellAbility sa, final PhaseHandler ph) {
         final Game game = ai.getGame();
         boolean main1Preferred = "Main1IfAble".equals(sa.getParam("AILogic")) && ph.is(PhaseType.MAIN1, ai);
-        if (game.getStack().isEmpty() && hasTapCost(sa.getPayCosts(), sa.getHostCard())) {
+        if (game.getStack().isEmpty() && sa.getPayCosts().hasTapCost()) {
             if (ph.getPhase().isBefore(PhaseType.COMBAT_DECLARE_ATTACKERS) && ph.isPlayerTurn(ai)) {
                 return false;
             }
@@ -347,13 +338,13 @@ public class PumpAi extends PumpAiBase {
             }
             return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
         }
-        //Targeted
+
         if (!pumpTgtAI(ai, sa, defense, attack, false, false)) {
             return new AiAbilityDecision(0, AiPlayDecision.TargetingFailed);
         }
 
         return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
-    } // pumpPlayAI()
+    }
 
     private boolean pumpTgtAI(final Player ai, final SpellAbility sa, final int defense, final int attack, final boolean mandatory,
     		boolean immediately) {
@@ -462,7 +453,7 @@ public class PumpAi extends PumpAiBase {
             }
 
             if (isFight) {
-                return FightAi.canFightAi(ai, sa, attack, defense).willingToPlay();
+                return FightAi.canFight(ai, sa, attack, defense).willingToPlay();
             }
         }
 
@@ -487,18 +478,28 @@ public class PumpAi extends PumpAiBase {
             }
         }
 
-        if (game.getStack().isEmpty()) {
-            // If the cost is tapping, don't activate before declare attack/block
-            if (sa.getPayCosts().hasTapCost()) {
-                if (game.getPhaseHandler().getPhase().isBefore(PhaseType.COMBAT_DECLARE_ATTACKERS)
-                        && game.getPhaseHandler().isPlayerTurn(ai)) {
-                    list.remove(sa.getHostCard());
-                }
-                if (game.getPhaseHandler().getPhase().isBefore(PhaseType.COMBAT_DECLARE_BLOCKERS)
-                        && game.getPhaseHandler().getPlayerTurn().isOpponentOf(ai)) {
-                    list.remove(sa.getHostCard());
-                }
+        if (game.getStack().isEmpty() && sa.getPayCosts().hasTapCost()) {
+            if (game.getPhaseHandler().getPhase().isBefore(PhaseType.COMBAT_DECLARE_ATTACKERS)
+                    && game.getPhaseHandler().isPlayerTurn(ai)) {
+                list.remove(source);
             }
+            if (game.getPhaseHandler().getPhase().isBefore(PhaseType.COMBAT_DECLARE_BLOCKERS)
+                    && game.getPhaseHandler().getPlayerTurn().isOpponentOf(ai)) {
+                list.remove(source);
+            }
+        }
+
+        // Detain target nonland permanent: don't target noncreature permanents that don't have
+        // any activated abilities.
+        if ("DetainNonLand".equals(sa.getParam("AILogic"))) {
+            list = CardLists.filter(list, CardPredicates.CREATURES.or(card -> {
+                for (SpellAbility sa1 : card.getSpellAbilities()) {
+                    if (sa1.isActivatedAbility()) {
+                        return true;
+                    }
+                }
+                return false;
+            }));
         }
 
         // Filter AI-specific targets if provided

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

@@ -147,7 +147,7 @@ public class PumpAllAi extends PumpAiBase {
 
         // important to call canPlay first so targets are added if needed
         AiAbilityDecision decision = canPlay(ai, sa);
-        if (mandatory && decision.decision().willingToPlay()) {
+        if (mandatory && !decision.decision().willingToPlay()) {
             return new AiAbilityDecision(50, AiPlayDecision.MandatoryPlay);
         }
         return decision;

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

@@ -37,13 +37,12 @@ public class RearrangeTopOfLibraryAi extends SpellAbilityAi {
             }
 
             // Do it once per turn, generally (may be improved later)
-            if (AiCardMemory.isRememberedCardByName(aiPlayer, source.getName(), AiCardMemory.MemorySet.ACTIVATED_THIS_TURN)) {
+            if (source.getAbilityActivatedThisTurn().getActivators(sa).contains(aiPlayer)) {
                 return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
             }
         }
 
         if (sa.usesTargeting()) {
-            // ability is targeted
             sa.resetTargets();
 
             PlayerCollection targetableOpps = aiPlayer.getOpponents().filter(PlayerPredicates.isTargetableBy(sa));
@@ -62,14 +61,6 @@ public class RearrangeTopOfLibraryAi extends SpellAbilityAi {
             } else {
                 return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi); // could not find a valid target
             }
-
-            if (!canTgtHuman || !canTgtAI) {
-                // can't target another player anyway, remember for no second activation this turn
-                AiCardMemory.rememberCard(aiPlayer, source, AiCardMemory.MemorySet.ACTIVATED_THIS_TURN);
-            }
-        } else {
-            // if it's just defined, no big deal
-            AiCardMemory.rememberCard(aiPlayer, source, AiCardMemory.MemorySet.ACTIVATED_THIS_TURN);
         }
 
         return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
@@ -80,8 +71,6 @@ public class RearrangeTopOfLibraryAi extends SpellAbilityAi {
      */
     @Override
     protected AiAbilityDecision doTriggerNoCost(Player ai, SpellAbility sa, boolean mandatory) {
-        // Specific details of ordering cards are handled by PlayerControllerAi#orderMoveToZoneList
-
         AiAbilityDecision decision = canPlay(ai, sa);
         if (decision.willingToPlay()) {
             return decision;

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

@@ -88,9 +88,9 @@ public class ScryAi extends SpellAbilityAi {
         // and right before the beginning of AI's turn, if possible, to avoid mana locking the AI and also to
         // try to scry right before drawing a card. Also, avoid tapping creatures in the AI's turn, if possible,
         // even if there's no mana cost.
-        if (logic.equals("AtOppEOT") || (sa.getPayCosts().hasTapCost()
-                && (sa.getPayCosts().hasManaCost() || (sa.getHostCard() != null && sa.getHostCard().isCreature()))
-                && !isSorcerySpeed(sa, ai))) {
+        if (sa.getPayCosts().hasTapCost()
+                && (sa.getPayCosts().hasManaCost() || sa.getHostCard().isCreature())
+                && !isSorcerySpeed(sa, ai)) {
             return ph.getNextTurn() == ai && ph.is(PhaseType.END_OF_TURN);
         }
 

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

@@ -21,10 +21,6 @@ public class SurveilAi extends SpellAbilityAi {
      */
     @Override
     protected AiAbilityDecision doTriggerNoCost(Player ai, SpellAbility sa, boolean mandatory) {
-        if (sa.usesTargeting()) { // TODO: It doesn't appear that Surveil ever targets, is this necessary?
-            sa.resetTargets();
-            sa.getTargets().add(ai);
-        }
         return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
     }
 
@@ -92,7 +88,6 @@ public class SurveilAi extends SpellAbilityAi {
         }
 
         if (randomReturn) {
-            AiCardMemory.rememberCard(ai, sa.getHostCard(), AiCardMemory.MemorySet.ACTIVATED_THIS_TURN);
             return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
         }
 

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

@@ -20,19 +20,6 @@ import java.util.function.Predicate;
 
 public abstract class TapAiBase extends SpellAbilityAi {
 
-    Predicate<Card> CREATURE_OR_TAP_ABILITY = c -> {
-        if (c.isCreature()) {
-            return true;
-        }
-
-        for (final SpellAbility sa : c.getSpellAbilities()) {
-            if (sa.isAbility() && sa.getPayCosts().hasTapCost()) {
-                return true;
-            }
-        }
-        return false;
-    };
-
     /**
      * <p>
      * tapTargetList.
@@ -115,12 +102,34 @@ public abstract class TapAiBase extends SpellAbilityAi {
         final Game game = ai.getGame();
         CardCollection tapList = CardLists.getTargetableCards(ai.getOpponents().getCardsIn(ZoneType.Battlefield), sa);
         tapList = CardLists.filter(tapList, CardPredicates.CAN_TAP);
-        tapList = CardLists.filter(tapList, CREATURE_OR_TAP_ABILITY);
+        tapList = CardLists.filter(tapList, c -> {
+            if (c.isCreature()) {
+                return true;
+            }
+
+            for (final SpellAbility sa1 : c.getSpellAbilities()) {
+                if (sa1.isAbility() && sa1.getPayCosts().hasTapCost()) {
+                    return true;
+                }
+            }
+            return false;
+        });
 
         //use broader approach when the cost is a positive thing
         if (tapList.isEmpty() && ComputerUtil.activateForCost(sa, ai)) { 
             tapList = CardLists.getTargetableCards(ai.getOpponents().getCardsIn(ZoneType.Battlefield), sa);
-            tapList = CardLists.filter(tapList, CREATURE_OR_TAP_ABILITY);
+            tapList = CardLists.filter(tapList, c -> {
+                if (c.isCreature()) {
+                    return true;
+                }
+
+                for (final SpellAbility sa12 : c.getSpellAbilities()) {
+                    if (sa12.isAbility() && sa12.getPayCosts().hasTapCost()) {
+                        return true;
+                    }
+                }
+                return false;
+            });
         }
 
         //try to exclude things that will already be tapped due to something on stack or because something is

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

@@ -8,7 +8,6 @@ import forge.ai.SpellAbilityAi;
 import forge.game.card.Card;
 import forge.game.card.CardPredicates;
 import forge.game.card.CounterEnumType;
-import forge.game.card.CounterType;
 import forge.game.player.Player;
 import forge.game.player.PlayerActionConfirmMode;
 import forge.game.player.PlayerController;
@@ -40,7 +39,7 @@ public class TimeTravelAi extends SpellAbilityAi {
         // so removing them is good; stuff on the battlefield is usually stuff like Vanishing or As Foretold, which favors adding Time
         // counters for better effect, but exceptions should be added here).
         Card target = (Card)params.get("Target");
-        return !ComputerUtil.isNegativeCounter(CounterType.get(CounterEnumType.TIME), target);
+        return !ComputerUtil.isNegativeCounter(CounterEnumType.TIME, target);
     }
 
     @Override

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

@@ -26,7 +26,6 @@ import forge.game.player.Player;
 import forge.game.player.PlayerActionConfirmMode;
 import forge.game.player.PlayerCollection;
 import forge.game.player.PlayerPredicates;
-import forge.game.spellability.AbilitySub;
 import forge.game.spellability.SpellAbility;
 import forge.game.spellability.TargetRestrictions;
 import forge.game.zone.ZoneType;
@@ -67,17 +66,15 @@ public class TokenAi extends SpellAbilityAi {
                 }
             }
         }
-        String tokenAmount = sa.getParamOrDefault("TokenAmount", "1");
 
         Card actualToken = spawnToken(ai, sa);
 
         if (actualToken == null || (actualToken.isCreature() && actualToken.getNetToughness() < 1)) {
-            final AbilitySub sub = sa.getSubAbility();
-            // useful
-            // no token created
-            return pwPlus || (sub != null && SpellApiToAi.Converter.get(sub).chkDrawback(sub, ai).willingToPlay()); // planeswalker plus ability or sub-ability is
+            // planeswalker plus ability or sub-ability is useful
+            return pwPlus || sa.getSubAbility() != null;
         }
 
+        String tokenAmount = sa.getParamOrDefault("TokenAmount", "1");
         String tokenPower = sa.getParamOrDefault("TokenPower", actualToken.getBasePowerString());
         String tokenToughness = sa.getParamOrDefault("TokenToughness", actualToken.getBaseToughnessString());
 
@@ -134,9 +131,6 @@ public class TokenAi extends SpellAbilityAi {
 
     @Override
     protected AiAbilityDecision checkApiLogic(final Player ai, final SpellAbility sa) {
-        /*
-         * readParameters() is called in checkPhaseRestrictions
-         */
         final Game game = ai.getGame();
         final Player opp = ai.getWeakestOpponent();
 

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

@@ -31,6 +31,8 @@ public final class ImageKeys {
     public static final String MONARCH_IMAGE         = "monarch";
     public static final String THE_RING_IMAGE        = "the_ring";
     public static final String RADIATION_IMAGE       = "radiation";
+    public static final String SPEED_IMAGE           = "speed";
+    public static final String MAX_SPEED_IMAGE       = "max_speed";
 
     public static final String BACKFACE_POSTFIX  = "$alt";
     public static final String SPECFACE_W = "$wspec";

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

@@ -18,9 +18,9 @@ import java.util.*;
 import java.util.function.Predicate;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.ConcurrentLinkedQueue;
+import java.util.regex.Pattern;
 import java.util.stream.Collectors;
 
-
 /**
  * The class holding game invariants, such as cards, editions, game formats. All that data, which is not supposed to be changed by player
  *
@@ -29,8 +29,6 @@ import java.util.stream.Collectors;
 public class StaticData {
     private final CardStorageReader cardReader;
     private final CardStorageReader tokenReader;
-    private final CardStorageReader customCardReader;
-
     private final String blockDataFolder;
     private final CardDb commonCards;
     private final CardDb variantCards;
@@ -79,7 +77,6 @@ public class StaticData {
         this.tokenReader = tokenReader;
         this.editions = new CardEdition.Collection(new CardEdition.Reader(new File(editionFolder)));
         this.blockDataFolder = blockDataFolder;
-        this.customCardReader = customCardReader;
         this.allowCustomCardsInDecksConformance = allowCustomCardsInDecksConformance;
         this.enableSmartCardArtSelection = enableSmartCardArtSelection;
         this.loadNonLegalCards = loadNonLegalCards;
@@ -784,6 +781,7 @@ public class StaticData {
         Queue<String> TOKEN_Q = new ConcurrentLinkedQueue<>();
         boolean nifHeader = false;
         boolean cniHeader = false;
+        final Pattern funnyCardCollectorNumberPattern = Pattern.compile("^F\\d+");
         for (CardEdition e : editions) {
             if (CardEdition.Type.FUNNY.equals(e.getType()))
                 continue;
@@ -791,11 +789,13 @@ public class StaticData {
             Map<String, Pair<Boolean, Integer>> cardCount = new HashMap<>();
             List<CompletableFuture<?>> futures = new ArrayList<>();
             for (CardEdition.EditionEntry c : e.getObtainableCards()) {
+                int amount = 1;
+
                 if (cardCount.containsKey(c.name())) {
-                    cardCount.put(c.name(), Pair.of(c.collectorNumber() != null && c.collectorNumber().startsWith("F"), cardCount.get(c.name()).getRight() + 1));
-                } else {
-                    cardCount.put(c.name(), Pair.of(c.collectorNumber() != null && c.collectorNumber().startsWith("F"), 1));
+                    amount = cardCount.get(c.name()).getRight() + 1;
                 }
+
+                cardCount.put(c.name(), Pair.of(c.collectorNumber() != null && funnyCardCollectorNumberPattern.matcher(c.collectorNumber()).matches(), amount));
             }
 
             // loop through the cards in this edition, considering art variations...
@@ -878,7 +878,7 @@ public class StaticData {
                 }
             }
         }
-        // stream().toList() causes crash on Android, use Collectors.toList()
+        // stream().toList() causes crash on Android 8-13, use Collectors.toList()
         List<String> NIF = new ArrayList<>(NIF_Q).stream().sorted().collect(Collectors.toList());
         List<String> CNI = new ArrayList<>(CNI_Q).stream().sorted().collect(Collectors.toList());
         List<String> TOK = new ArrayList<>(TOKEN_Q).stream().sorted().collect(Collectors.toList());

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

@@ -21,6 +21,7 @@ import com.google.common.collect.ListMultimap;
 import com.google.common.collect.Lists;
 import com.google.common.collect.Maps;
 import com.google.common.collect.Multimaps;
+import forge.ImageKeys;
 import forge.StaticData;
 import forge.card.CardEdition.EditionEntry;
 import forge.card.CardEdition.Type;
@@ -44,8 +45,6 @@ public final class CardDb implements ICardDatabase, IDeckGenPool {
     public final static char NameSetSeparator = '|';
     public final static String FlagPrefix = "#";
     public static final String FlagSeparator = "\t";
-    private final String exlcudedCardName = "Concentrate";
-    private final String exlcudedCardSet = "DS0";
 
     // need this to obtain cardReference by name+set+artindex
     private final ListMultimap<String, PaperCard> allCardsByName = Multimaps.newListMultimap(new TreeMap<>(String.CASE_INSENSITIVE_ORDER), Lists::newArrayList);
@@ -200,7 +199,7 @@ public final class CardDb implements ICardDatabase, IDeckGenPool {
         }
 
         private static boolean isArtIndex(String s) {
-            return StringUtils.isNumeric(s) && s.length() <= 2 ; // only artIndex between 1-99
+            return StringUtils.isNumeric(s) && s.length() <= 2; // only artIndex between 1-99
         }
 
         private static boolean isSetCode(String s) {
@@ -241,8 +240,8 @@ public final class CardDb implements ICardDatabase, IDeckGenPool {
                 setCode = info[index];
                 index++;
             }
-            if(info.length > index && isArtIndex(info[index])) {
-                artIndex = Integer.parseInt(info[index]);
+            if(info.length > index && isArtIndex(info[index].replace(ImageKeys.BACKFACE_POSTFIX, ""))) {
+                artIndex = Integer.parseInt(info[index].replace(ImageKeys.BACKFACE_POSTFIX, ""));
                 index++;
             }
             if(info.length > index && isCollectorNumber(info[index])) {
@@ -302,7 +301,7 @@ public final class CardDb implements ICardDatabase, IDeckGenPool {
 
         // create faces list from rules
         for (final CardRules rule : rules.values()) {
-            if (filteredCards.contains(rule.getName()) && !exlcudedCardName.equalsIgnoreCase(rule.getName()))
+            if (filteredCards.contains(rule.getName()))
                 continue;
             for (ICardFace face : rule.getAllFaces()) {
                 addFaceToDbNames(face);
@@ -500,8 +499,9 @@ public final class CardDb implements ICardDatabase, IDeckGenPool {
     }
 
     public void addCard(PaperCard paperCard) {
-        if (excludeCard(paperCard.getName(), paperCard.getEdition()))
+        if (filtered.contains(paperCard.getName())) {
             return;
+        }
 
         allCardsByName.put(paperCard.getName(), paperCard);
 
@@ -522,17 +522,6 @@ public final class CardDb implements ICardDatabase, IDeckGenPool {
         }
     }
 
-    private boolean excludeCard(String cardName, String cardEdition) {
-        if (filtered.isEmpty())
-            return false;
-        if (filtered.contains(cardName)) {
-            if (exlcudedCardSet.equalsIgnoreCase(cardEdition) && exlcudedCardName.equalsIgnoreCase(cardName))
-                return true;
-            else return !exlcudedCardName.equalsIgnoreCase(cardName);
-        }
-        return false;
-    }
-
     private void reIndex() {
         uniqueCardsByName.clear();
         for (Entry<String, Collection<PaperCard>> kv : allCardsByName.asMap().entrySet()) {

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

@@ -52,6 +52,14 @@ import java.util.stream.Collectors;
  */
 public final class CardEdition implements Comparable<CardEdition> {
 
+    public DraftOptions getDraftOptions() {
+        return draftOptions;
+    }
+
+    public void setDraftOptions(DraftOptions draftOptions) {
+        this.draftOptions = draftOptions;
+    }
+
     // immutable
     public enum Type {
         UNKNOWN,
@@ -275,18 +283,22 @@ public final class CardEdition implements Comparable<CardEdition> {
     // Booster/draft info
     private List<BoosterSlot> boosterSlots = null;
     private boolean smallSetOverride = false;
-    private boolean foilAlwaysInCommonSlot = false;
+    private String additionalUnlockSet = "";
     private FoilType foilType = FoilType.NOT_SUPPORTED;
+
+    // Replace all of these things with booster slots
+    private boolean foilAlwaysInCommonSlot = false;
     private double foilChanceInBooster = 0;
     private double chanceReplaceCommonWith = 0;
     private String slotReplaceCommonWith = "Common";
     private String additionalSheetForFoils = "";
-    private String additionalUnlockSet = "";
     private String boosterMustContain = "";
     private String boosterReplaceSlotFromPrintSheet = "";
     private String sheetReplaceCardFromSheet = "";
     private String sheetReplaceCardFromSheet2 = "";
-    private String doublePickDuringDraft = "";
+
+    // Draft options
+    private DraftOptions draftOptions = null;
     private String[] chaosDraftThemes = new String[0];
 
     private final ListMultimap<String, EditionEntry> cardMap;
@@ -373,7 +385,6 @@ public final class CardEdition implements Comparable<CardEdition> {
     public String getSlotReplaceCommonWith() { return slotReplaceCommonWith; }
     public String getAdditionalSheetForFoils() { return additionalSheetForFoils; }
     public String getAdditionalUnlockSet() { return additionalUnlockSet; }
-    public String getDoublePickDuringDraft() { return doublePickDuringDraft; }
     public String getBoosterMustContain() { return boosterMustContain; }
     public String getBoosterReplaceSlotFromPrintSheet() { return boosterReplaceSlotFromPrintSheet; }
     public String getSheetReplaceCardFromSheet() { return sheetReplaceCardFromSheet; }
@@ -552,26 +563,16 @@ public final class CardEdition implements Comparable<CardEdition> {
 
     public List<PrintSheet> getPrintSheetsBySection() {
         final CardDb cardDb = StaticData.instance().getCommonCards();
-        Map<String, Integer> cardToIndex = new HashMap<>();
 
         List<PrintSheet> sheets = Lists.newArrayList();
-        for (String sectionName : cardMap.keySet()) {
-            if (sectionName.equals(EditionSectionWithCollectorNumbers.CONJURED.getName())) {
+        for (Map.Entry<String, java.util.Collection<EditionEntry>> section : cardMap.asMap().entrySet()) {
+            if (section.getKey().equals(EditionSectionWithCollectorNumbers.CONJURED.getName())) {
                 continue;
             }
-            PrintSheet sheet = new PrintSheet(String.format("%s %s", this.getCode(), sectionName));
+            PrintSheet sheet = new PrintSheet(String.format("%s %s", this.getCode(), section.getKey()));
 
-            List<EditionEntry> cards = cardMap.get(sectionName);
-            for (EditionEntry card : cards) {
-                int index = 1;
-                if (cardToIndex.containsKey(card.name)) {
-                    index = cardToIndex.get(card.name) + 1;
-                }
-
-                cardToIndex.put(card.name, index);
-
-                PaperCard pCard = cardDb.getCard(card.name, this.getCode(), index);
-                sheet.add(pCard);
+            for (EditionEntry card : section.getValue()) {
+                sheet.add(cardDb.getCard(card.name, this.getCode(), card.collectorNumber));
             }
 
             sheets.add(sheet);
@@ -629,7 +630,7 @@ public final class CardEdition implements Comparable<CardEdition> {
                     * functional variant name - grouping #9
              */
 //                "(^(.?[0-9A-Z]+.?))?(([SCURML]) )?(.*)$"
-                    "(^(.?[0-9A-Z-]+\\S?[A-Z]*)\\s)?(([SCURML])\\s)?([^@\\$]*)( @([^\\$]*))?( \\$(.+))?$"
+                    "(^(.?[0-9A-Z-]+\\S*[A-Z]*)\\s)?(([SCURML])\\s)?([^@\\$]*)( @([^\\$]*))?( \\$(.+))?$"
             );
 
             final Pattern tokenPattern = Pattern.compile(
@@ -638,7 +639,7 @@ public final class CardEdition implements Comparable<CardEdition> {
                      * name - grouping #3
                      * artist name - grouping #5
                      */
-                    "(^(.?[0-9A-Z]+\\S?[A-Z]*)\\s)?([^@]*)( @(.*))?$"
+                    "(^(.?[0-9A-Z-]+\\S?[A-Z☇]*)\\s)?([^@]*)( @(.*))?$"
             );
 
             ListMultimap<String, EditionEntry> cardMap = ArrayListMultimap.create();
@@ -659,31 +660,37 @@ public final class CardEdition implements Comparable<CardEdition> {
                     continue;
                 }
 
-                // parse sections of the format "<collector number> <rarity> <name>"
-                if (editionSectionsWithCollectorNumbers.contains(sectionName)) {
-                    for(String line : contents.get(sectionName)) {
-                        Matcher matcher = pattern.matcher(line);
-
-                        if (!matcher.matches()) {
-                            continue;
-                        }
-
-                        String collectorNumber = matcher.group(2);
-                        CardRarity r = CardRarity.smartValueOf(matcher.group(4));
-                        String cardName = matcher.group(5);
-                        String artistName = matcher.group(7);
-                        String functionalVariantName = matcher.group(9);
-                        EditionEntry cis = new EditionEntry(cardName, collectorNumber, r, artistName, functionalVariantName);
-
-                        cardMap.put(sectionName, cis);
-                    }
-                } else if (boosterSlotsToParse.contains(sectionName)) {
-                    // parse booster slots of the format "Base=N\n|Replace=<amount> <sheet>"
-                    boosterSlots.add(BoosterSlot.parseSlot(sectionName, contents.get(sectionName)));
+                if (sectionName.endsWith("Types")) {
+                    CardType.Helper.parseTypes(sectionName, contents.get(sectionName));
                 } else {
-                    // save custom print sheets of the format "<amount> <name>|<setcode>|<art index>"
-                    // to parse later when printsheets are loaded lazily (and the cardpool is already initialized)
-                    customPrintSheetsToParse.put(sectionName, contents.get(sectionName));
+                    // Parse cards
+
+                    // parse sections of the format "<collector number> <rarity> <name>"
+                    if (editionSectionsWithCollectorNumbers.contains(sectionName)) {
+                        for(String line : contents.get(sectionName)) {
+                            Matcher matcher = pattern.matcher(line);
+
+                            if (!matcher.matches()) {
+                                continue;
+                            }
+
+                            String collectorNumber = matcher.group(2);
+                            CardRarity r = CardRarity.smartValueOf(matcher.group(4));
+                            String cardName = matcher.group(5);
+                            String artistName = matcher.group(7);
+                            String functionalVariantName = matcher.group(9);
+                            EditionEntry cis = new EditionEntry(cardName, collectorNumber, r, artistName, functionalVariantName);
+
+                            cardMap.put(sectionName, cis);
+                        }
+                    } else if (boosterSlotsToParse.contains(sectionName)) {
+                        // parse booster slots of the format "Base=N\n|Replace=<amount> <sheet>"
+                        boosterSlots.add(BoosterSlot.parseSlot(sectionName, contents.get(sectionName)));
+                    } else {
+                        // save custom print sheets of the format "<amount> <name>|<setcode>|<art index>"
+                        // to parse later when printsheets are loaded lazily (and the cardpool is already initialized)
+                        customPrintSheetsToParse.put(sectionName, contents.get(sectionName));
+                    }
                 }
             }
 
@@ -812,7 +819,6 @@ public final class CardEdition implements Comparable<CardEdition> {
             res.additionalUnlockSet = metadata.get("AdditionalSetUnlockedInQuest", ""); // e.g. Time Spiral Timeshifted (TSB) for Time Spiral
 
             res.smallSetOverride = metadata.getBoolean("TreatAsSmallSet", false); // for "small" sets with over 200 cards (e.g. Eldritch Moon)
-            res.doublePickDuringDraft = metadata.get("DoublePick", ""); // "FirstPick" or "Always"
 
             res.boosterMustContain = metadata.get("BoosterMustContain", ""); // e.g. Dominaria guaranteed legendary creature
             res.boosterReplaceSlotFromPrintSheet = metadata.get("BoosterReplaceSlotFromPrintSheet", ""); // e.g. Zendikar Rising guaranteed double-faced card
@@ -820,6 +826,23 @@ public final class CardEdition implements Comparable<CardEdition> {
             res.sheetReplaceCardFromSheet2 = metadata.get("SheetReplaceCardFromSheet2", "");
             res.chaosDraftThemes = metadata.get("ChaosDraftThemes", "").split(";"); // semicolon separated list of theme names
 
+            // Draft options
+            String doublePick = metadata.get("DoublePick", "Never");
+            int maxPodSize = metadata.getInt("MaxPodSize", 8);
+            int recommendedPodSize = metadata.getInt("RecommendedPodSize", 8);
+            int maxMatchPlayers = metadata.getInt("MaxMatchPlayers", 2);
+            String deckType = metadata.get("DeckType", "Normal");
+            String freeCommander = metadata.get("FreeCommander", "");
+
+            res.draftOptions = new DraftOptions(
+                    doublePick,
+                    maxPodSize,
+                    recommendedPodSize,
+                    maxMatchPlayers,
+                    deckType,
+                    freeCommander
+            );
+
             return res;
         }
 
@@ -850,7 +873,7 @@ public final class CardEdition implements Comparable<CardEdition> {
         @Override
         public void add(CardEdition item) { //Even though we want it to be read only, make an exception for custom content.
             if(lock) throw new UnsupportedOperationException("This is a read-only storage");
-            else map.put(item.getName(), item);
+            else map.put(item.getCode(), item);
         }
         public void append(CardEdition.Collection C){ //Append custom editions
             if (lock) throw new UnsupportedOperationException("This is a read-only storage");
@@ -995,16 +1018,13 @@ public final class CardEdition implements Comparable<CardEdition> {
 
         public static final Predicate<CardEdition> HAS_BOOSTER_BOX = edition -> edition.getBoosterBoxCount() > 0;
 
+        @Deprecated //Use CardEdition::hasBasicLands and a nonnull test.
         public static final Predicate<CardEdition> hasBasicLands = ed -> {
             if (ed == null) {
                 // Happens for new sets with "???" code
                 return false;
             }
-            for(String landName : MagicColor.Constant.BASIC_LANDS) {
-                if (null == StaticData.instance().getCommonCards().getCard(landName, ed.getCode(), 0))
-                    return false;
-            }
-            return true;
+            return ed.hasBasicLands();
         };
     }
 
@@ -1025,7 +1045,7 @@ public final class CardEdition implements Comparable<CardEdition> {
 
     public boolean hasBasicLands() {
         for(String landName : MagicColor.Constant.BASIC_LANDS) {
-            if (null == StaticData.instance().getCommonCards().getCard(landName, this.getCode(), 0))
+            if (this.getCardInSet(landName).isEmpty())
                 return false;
         }
         return true;

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

@@ -53,6 +53,7 @@ public final class CardRules implements ICardCharacteristics {
     private boolean addsWildCardColor;
     private int setColorID;
     private boolean custom;
+    private boolean unsupported;
     private String path;
 
     public CardRules(ICardFace[] faces, CardSplitType altMode, CardAiHints cah) {
@@ -166,6 +167,10 @@ public final class CardRules implements ICardCharacteristics {
         return Iterables.concat(Arrays.asList(mainPart, otherPart), specializedParts.values());
     }
 
+    public boolean isTransformable() {
+        return CardSplitType.Transform == getSplitType() || CardSplitType.Modal == getSplitType();
+    }
+
     public ICardFace getWSpecialize() {
         return specializedParts.get(CardStateName.SpecializeW);
     }
@@ -202,7 +207,9 @@ public final class CardRules implements ICardCharacteristics {
     }
 
     public boolean isCustom() { return custom; }
-    public void setCustom() { custom = true;   }
+    public void setCustom() { custom = true; }
+
+    public boolean isUnsupported() { return unsupported; }
 
     @Override
     public CardType getType() {
@@ -317,6 +324,12 @@ public final class CardRules implements ICardCharacteristics {
         }
         if (hasKeyword("Friends forever") && b.hasKeyword("Friends forever")) {
             legal = true; // Stranger Things Secret Lair gimmick partner commander
+        }  
+        if (hasKeyword("Partner - Survivors") && b.hasKeyword("Partner - Survivors")) {
+            legal = true; // The Last of Us Secret Lair gimmick partner commander
+        }
+        if (hasKeyword("Partner - Father & Son") && b.hasKeyword("Partner - Father & Son")) {
+            legal = true; // God of War Secret Lair gimmick partner commander
         }
         if (hasKeyword("Choose a Background") && b.canBeBackground()
                 || b.hasKeyword("Choose a Background") && canBeBackground()) {
@@ -335,6 +348,7 @@ public final class CardRules implements ICardCharacteristics {
         }
         return canBeCommander() && (hasKeyword("Partner") || !this.partnerWith.isEmpty() ||
                 hasKeyword("Friends forever") || hasKeyword("Choose a Background") ||
+                hasKeyword("Partner - Father & Son") || hasKeyword("Partner - Survivors") ||
                 hasKeyword("Doctor's companion") || isDoctor());
     }
 
@@ -343,16 +357,21 @@ public final class CardRules implements ICardCharacteristics {
     }
 
     public boolean isDoctor() {
+        Set<String> subtypes = new HashSet<>();
         for (String type : mainPart.getType().getSubtypes()) {
-            if (!type.equals("Time Lord") && !type.equals("Doctor")) {
-                return false;
-            }
+            subtypes.add(type);
         }
-        return true;
+
+        return subtypes.size() == 2 &&
+                subtypes.contains("Time Lord") &&
+                subtypes.contains("Doctor");
     }
 
     public boolean canBeOathbreaker() {
         CardType type = mainPart.getType();
+        if (mainPart.getOracleText().contains("can be your commander")) {
+            return true;
+        }
         return type.isPlaneswalker();
     }
 
@@ -805,6 +824,8 @@ public final class CardRules implements ICardCharacteristics {
         faces[0].assignMissingFields();
         final CardRules result = new CardRules(faces, CardSplitType.None, cah);
 
+        result.unsupported = true;
+
         return result;
     }
 

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

@@ -189,6 +189,38 @@ public final class CardRulesPredicates {
         return card -> card.getType().hasSupertype(type);
     }
 
+    /**
+     * @return a Predicate that matches cards that are of the split type.
+     */
+    public static Predicate<CardRules> isSplitType(final CardSplitType type) {
+        return card -> card.getSplitType().equals(type);
+    }
+
+    /**
+     * @return a Predicate that matches cards that are vanilla.
+     */
+    public static Predicate<CardRules> isVanilla() {
+        return card -> {
+            if (!(card.getType().isCreature() || card.getType().isLand()) ||
+                card.getSplitType() != CardSplitType.None ||
+                card.hasFunctionalVariants()) {
+                return false;
+            }
+
+            ICardFace mainPart = card.getMainPart();
+
+            boolean hasAny =
+                mainPart.getKeywords().iterator().hasNext() ||
+                mainPart.getAbilities().iterator().hasNext() ||
+                mainPart.getStaticAbilities().iterator().hasNext() ||
+                mainPart.getTriggers().iterator().hasNext() ||
+                (mainPart.getDraftActions() != null && mainPart.getDraftActions().iterator().hasNext()) ||
+                mainPart.getReplacements().iterator().hasNext();
+
+            return !hasAny;
+        };
+    }
+
     /**
      * Checks for color.
      *

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

@@ -7,13 +7,13 @@ import java.util.EnumSet;
 public enum CardSplitType
 {
     None(FaceSelectionMethod.USE_PRIMARY_FACE, null),
-    Transform(FaceSelectionMethod.USE_ACTIVE_FACE, CardStateName.Transformed),
+    Transform(FaceSelectionMethod.USE_ACTIVE_FACE, CardStateName.Backside),
     Meld(FaceSelectionMethod.USE_ACTIVE_FACE, CardStateName.Meld),
     Split(FaceSelectionMethod.COMBINE, CardStateName.RightSplit),
     Flip(FaceSelectionMethod.USE_PRIMARY_FACE, CardStateName.Flipped),
     Adventure(FaceSelectionMethod.USE_PRIMARY_FACE, CardStateName.Secondary),
     Omen(FaceSelectionMethod.USE_PRIMARY_FACE, CardStateName.Secondary),
-    Modal(FaceSelectionMethod.USE_ACTIVE_FACE, CardStateName.Modal),
+    Modal(FaceSelectionMethod.USE_ACTIVE_FACE, CardStateName.Backside),
     Specialize(FaceSelectionMethod.USE_ACTIVE_FACE, null);
 
     public static final EnumSet<CardSplitType> DUAL_FACED_CARDS = EnumSet.of(

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

@@ -5,12 +5,11 @@ public enum CardStateName {
     Original,
     FaceDown,
     Flipped,
-    Transformed,
+    Backside,
     Meld,
     LeftSplit,
     RightSplit,
     Secondary,
-    Modal,
     EmptyRoom,
     SpecializeW,
     SpecializeU,
@@ -42,7 +41,7 @@ public enum CardStateName {
             return CardStateName.Flipped;
         }
         if ("DoubleFaced".equalsIgnoreCase(value)) {
-            return CardStateName.Transformed;
+            return CardStateName.Backside;
         }
 
         throw new IllegalArgumentException("No element named " + value + " in enum CardCharactersticName");

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

@@ -1066,4 +1066,74 @@ public final class CardType implements Comparable<CardType>, CardTypeView {
         return type;
     }
 
+    public static class Helper {
+        public static final void parseTypes(String sectionName, List<String> content) {
+            Set<String> addToSection = null;
+
+            switch (sectionName) {
+                case "BasicTypes":
+                    addToSection = CardType.Constant.BASIC_TYPES;
+                    break;
+                case "LandTypes":
+                    addToSection = CardType.Constant.LAND_TYPES;
+                    break;
+                case "CreatureTypes":
+                    addToSection = CardType.Constant.CREATURE_TYPES;
+                    break;
+                case "SpellTypes":
+                    addToSection = CardType.Constant.SPELL_TYPES;
+                    break;
+                case "EnchantmentTypes":
+                    addToSection = CardType.Constant.ENCHANTMENT_TYPES;
+                    break;
+                case "ArtifactTypes":
+                    addToSection = CardType.Constant.ARTIFACT_TYPES;
+                    break;
+                case "WalkerTypes":
+                    addToSection = CardType.Constant.WALKER_TYPES;
+                    break;
+                case "DungeonTypes":
+                    addToSection = CardType.Constant.DUNGEON_TYPES;
+                    break;
+                case "BattleTypes":
+                    addToSection = CardType.Constant.BATTLE_TYPES;
+                    break;
+                case "PlanarTypes":
+                    addToSection = CardType.Constant.PLANAR_TYPES;
+                    break;
+            }
+
+            if (addToSection == null) {
+                return;
+            }
+
+            for(String line : content) {
+                if (line.length() == 0) continue;
+
+                if (line.contains(":")) {
+                    String[] k = line.split(":");
+
+                    if (addToSection.contains(k[0])) {
+                        continue;
+                    }
+
+                    addToSection.add(k[0]);
+                    CardType.Constant.pluralTypes.put(k[0], k[1]);
+
+                    if (k[0].contains(" ")) {
+                        CardType.Constant.MultiwordTypes.add(k[0]);
+                    }
+                } else {
+                    if (addToSection.contains(line)) {
+                        continue;
+                    }
+
+                    addToSection.add(line);
+                    if (line.contains(" ")) {
+                        CardType.Constant.MultiwordTypes.add(line);
+                    }
+                }
+            }
+        }
+    }
 }

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

@@ -20,7 +20,6 @@ package forge.card;
 import com.google.common.collect.UnmodifiableIterator;
 import forge.card.MagicColor.Color;
 import forge.card.mana.ManaCost;
-import forge.card.mana.ManaCostShard;
 import forge.util.BinaryUtil;
 
 import java.io.Serializable;
@@ -41,27 +40,97 @@ import java.util.stream.Stream;
 public final class ColorSet implements Comparable<ColorSet>, Iterable<Byte>, Serializable {
     private static final long serialVersionUID = 794691267379929080L;
 
+    // needs to be before other static
+    private static final ColorSet[] cache = new ColorSet[MagicColor.ALL_COLORS + 1];
+    static {
+        byte COLORLESS = MagicColor.COLORLESS;
+        byte WHITE = MagicColor.WHITE;
+        byte BLUE = MagicColor.BLUE;
+        byte BLACK = MagicColor.BLACK;
+        byte RED = MagicColor.RED;
+        byte GREEN = MagicColor.GREEN;
+        Color C = Color.COLORLESS;
+        Color W = Color.WHITE;
+        Color U = Color.BLUE;
+        Color B = Color.BLACK;
+        Color R = Color.RED;
+        Color G = Color.GREEN;
+
+        //colorless
+        cache[COLORLESS] = new ColorSet(C);
+
+        //mono-color
+        cache[WHITE] = new ColorSet(W);
+        cache[BLUE] = new ColorSet(U);
+        cache[BLACK] = new ColorSet(B);
+        cache[RED] = new ColorSet(R);
+        cache[GREEN] = new ColorSet(G);
+
+        //two-color
+        cache[WHITE | BLUE] = new ColorSet(W, U);
+        cache[WHITE | BLACK] = new ColorSet(W, B);
+        cache[BLUE | BLACK] = new ColorSet(U, B);
+        cache[BLUE | RED] = new ColorSet(U, R);
+        cache[BLACK | RED] = new ColorSet(B, R);
+        cache[BLACK | GREEN] = new ColorSet(B, G);
+        cache[RED | GREEN] = new ColorSet(R, G);
+        cache[RED | WHITE] = new ColorSet(R, W);
+        cache[GREEN | WHITE] = new ColorSet(G, W);
+        cache[GREEN | BLUE] = new ColorSet(G, U);
+
+        //three-color
+        cache[WHITE | BLUE | BLACK] = new ColorSet(W, U, B);
+        cache[WHITE | BLACK | GREEN] = new ColorSet(W, B, G);
+        cache[BLUE | BLACK | RED] = new ColorSet(U, B, R);
+        cache[BLUE | RED | WHITE] = new ColorSet(U, R, W);
+        cache[BLACK | RED | GREEN] = new ColorSet(B, R, G);
+        cache[BLACK | GREEN | BLUE] = new ColorSet(B, G, U);
+        cache[RED | GREEN | WHITE] = new ColorSet(R, G, W);
+        cache[RED | WHITE | BLACK] = new ColorSet(R, W, B);
+        cache[GREEN | WHITE | BLUE] = new ColorSet(G, W, U);
+        cache[GREEN | BLUE | RED] = new ColorSet(G, U, R);
+
+        //four-color
+        cache[WHITE | BLUE | BLACK | RED] = new ColorSet(W, U, B, R);
+        cache[BLUE | BLACK | RED | GREEN] = new ColorSet(U, B, R, G);
+        cache[BLACK | RED | GREEN | WHITE] = new ColorSet(B, R, G, W);
+        cache[RED | GREEN | WHITE | BLUE] = new ColorSet(R, G, W, U);
+        cache[GREEN | WHITE | BLUE | BLACK] = new ColorSet(G, W, U, B);
+
+        //five-color
+        cache[WHITE | BLUE | BLACK | RED | GREEN] = new ColorSet(W, U, B, R, G);
+    }
+
+    private final Collection<Color> orderedShards;
     private final byte myColor;
     private final float orderWeight;
-
-    private static final ColorSet[] cache = new ColorSet[32];
+    private final Set<Color> enumSet;
+    private final String desc;
 
     public static final ColorSet ALL_COLORS = fromMask(MagicColor.ALL_COLORS);
-    private static final ColorSet NO_COLORS = fromMask(MagicColor.COLORLESS);
+    public static final ColorSet NO_COLORS = fromMask(MagicColor.COLORLESS);
 
-    private ColorSet(final byte mask) {
-        this.myColor = mask;
+    private ColorSet(final Color... ordered) {
+        this.orderedShards = Arrays.asList(ordered);
+        this.myColor = orderedShards.stream().map(Color::getColorMask).reduce((byte)0, (a, b) -> (byte)(a | b));
         this.orderWeight = this.getOrderWeight();
+        this.enumSet = EnumSet.copyOf(orderedShards);
+        this.desc = orderedShards.stream().map(Color::getShortName).collect(Collectors.joining());
     }
 
     public static ColorSet fromMask(final int mask) {
         final int mask32 = mask & MagicColor.ALL_COLORS;
-        if (cache[mask32] == null) {
-            cache[mask32] = new ColorSet((byte) mask32);
-        }
         return cache[mask32];
     }
 
+    public static ColorSet fromEnums(final Color... colors) {
+        byte mask = 0;
+        for (Color e : colors) {
+            mask |= e.getColorMask();
+        }
+        return fromMask(mask);
+    }
+
     public static ColorSet fromNames(final String... colors) {
         byte mask = 0;
         for (final String s : colors) {
@@ -293,17 +362,7 @@ public final class ColorSet implements Comparable<ColorSet>, Iterable<Byte>, Ser
      */
     @Override
     public String toString() {
-        final ManaCostShard[] orderedShards = getOrderedShards();
-        return Arrays.stream(orderedShards).map(ManaCostShard::toShortString).collect(Collectors.joining());
-    }
-
-    /**
-     * Gets the null color.
-     *
-     * @return the nullColor
-     */
-    public static ColorSet getNullColor() {
-        return NO_COLORS;
+        return desc;
     }
 
     /**
@@ -325,16 +384,7 @@ public final class ColorSet implements Comparable<ColorSet>, Iterable<Byte>, Ser
     }
 
     public Set<Color> toEnumSet() {
-        if (isColorless()) {
-            return EnumSet.of(Color.COLORLESS);
-        }
-        List<Color> list = new ArrayList<>();
-        for (Color c : Color.values()) {
-            if (hasAnyColor(c.getColormask())) {
-                list.add(c);
-            }
-        }
-        return EnumSet.copyOf(list);
+        return EnumSet.copyOf(enumSet);
     }
 
     @Override
@@ -372,72 +422,12 @@ public final class ColorSet implements Comparable<ColorSet>, Iterable<Byte>, Ser
         }
     }
 
-    public Stream<MagicColor.Color> stream() {
+    public Stream<Color> stream() {
         return this.toEnumSet().stream();
     }
 
     //Get array of mana cost shards for color set in the proper order
-    public ManaCostShard[] getOrderedShards() {
-        return shardOrderLookup[myColor];
-    }
-
-    private static final ManaCostShard[][] shardOrderLookup = new ManaCostShard[MagicColor.ALL_COLORS + 1][];
-    static {
-        byte COLORLESS = MagicColor.COLORLESS;
-        byte WHITE = MagicColor.WHITE;
-        byte BLUE = MagicColor.BLUE;
-        byte BLACK = MagicColor.BLACK;
-        byte RED = MagicColor.RED;
-        byte GREEN = MagicColor.GREEN;
-        ManaCostShard C = ManaCostShard.COLORLESS;
-        ManaCostShard W = ManaCostShard.WHITE;
-        ManaCostShard U = ManaCostShard.BLUE;
-        ManaCostShard B = ManaCostShard.BLACK;
-        ManaCostShard R = ManaCostShard.RED;
-        ManaCostShard G = ManaCostShard.GREEN;
-
-        //colorless
-        shardOrderLookup[COLORLESS] = new ManaCostShard[] { C };
-
-        //mono-color
-        shardOrderLookup[WHITE] = new ManaCostShard[] { W };
-        shardOrderLookup[BLUE] = new ManaCostShard[] { U };
-        shardOrderLookup[BLACK] = new ManaCostShard[] { B };
-        shardOrderLookup[RED] = new ManaCostShard[] { R };
-        shardOrderLookup[GREEN] = new ManaCostShard[] { G };
-
-        //two-color
-        shardOrderLookup[WHITE | BLUE] = new ManaCostShard[] { W, U };
-        shardOrderLookup[WHITE | BLACK] = new ManaCostShard[] { W, B };
-        shardOrderLookup[BLUE | BLACK] = new ManaCostShard[] { U, B };
-        shardOrderLookup[BLUE | RED] = new ManaCostShard[] { U, R };
-        shardOrderLookup[BLACK | RED] = new ManaCostShard[] { B, R };
-        shardOrderLookup[BLACK | GREEN] = new ManaCostShard[] { B, G };
-        shardOrderLookup[RED | GREEN] = new ManaCostShard[] { R, G };
-        shardOrderLookup[RED | WHITE] = new ManaCostShard[] { R, W };
-        shardOrderLookup[GREEN | WHITE] = new ManaCostShard[] { G, W };
-        shardOrderLookup[GREEN | BLUE] = new ManaCostShard[] { G, U };
-
-        //three-color
-        shardOrderLookup[WHITE | BLUE | BLACK] = new ManaCostShard[] { W, U, B };
-        shardOrderLookup[WHITE | BLACK | GREEN] = new ManaCostShard[] { W, B, G };
-        shardOrderLookup[BLUE | BLACK | RED] = new ManaCostShard[] { U, B, R };
-        shardOrderLookup[BLUE | RED | WHITE] = new ManaCostShard[] { U, R, W };
-        shardOrderLookup[BLACK | RED | GREEN] = new ManaCostShard[] { B, R, G };
-        shardOrderLookup[BLACK | GREEN | BLUE] = new ManaCostShard[] { B, G, U };
-        shardOrderLookup[RED | GREEN | WHITE] = new ManaCostShard[] { R, G, W };
-        shardOrderLookup[RED | WHITE | BLACK] = new ManaCostShard[] { R, W, B };
-        shardOrderLookup[GREEN | WHITE | BLUE] = new ManaCostShard[] { G, W, U };
-        shardOrderLookup[GREEN | BLUE | RED] = new ManaCostShard[] { G, U, R };
-
-        //four-color
-        shardOrderLookup[WHITE | BLUE | BLACK | RED] = new ManaCostShard[] { W, U, B, R };
-        shardOrderLookup[BLUE | BLACK | RED | GREEN] = new ManaCostShard[] { U, B, R, G };
-        shardOrderLookup[BLACK | RED | GREEN | WHITE] = new ManaCostShard[] { B, R, G, W };
-        shardOrderLookup[RED | GREEN | WHITE | BLUE] = new ManaCostShard[] { R, G, W, U };
-        shardOrderLookup[GREEN | WHITE | BLUE | BLACK] = new ManaCostShard[] { G, W, U, B };
-
-        //five-color
-        shardOrderLookup[WHITE | BLUE | BLACK | RED | GREEN] = new ManaCostShard[] { W, U, B, R, G };
+    public Collection<Color> getOrderedColors() {
+        return orderedShards;
     }
 }

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

@@ -0,0 +1,75 @@
+package forge.card;
+
+public class DraftOptions {
+    public enum DoublePick {
+        NEVER,
+        FIRST_PICK, // only first pick each pack
+        WHEN_POD_SIZE_IS_4, // only when pod size is 4, so you can pick two cards each time
+        ALWAYS // each time you receive a pack, you can pick two cards
+    };
+    public enum DeckType {
+        Normal, // Standard deck, usually 40 cards
+        Commander // Special deck type for Commander format. Important for selection/construction
+    }
+
+    private DoublePick doublePick = DoublePick.NEVER;
+    private final int maxPodSize; // Usually 8, but could be smaller for cubes. I guess it could be larger too
+    private final int recommendedPodSize; // Usually 8, but is 4 for new double pick
+    private final int maxMatchPlayers; // Usually 2, but 4 for things like Commander or Conspiracy
+    private final DeckType deckType; // Normal or Commander
+    private final String freeCommander;
+
+    public DraftOptions(String doublePickOption, int maxPodSize, int recommendedPodSize, int maxMatchPlayers, String deckType, String freeCommander) {
+        this.maxPodSize = maxPodSize;
+        this.recommendedPodSize = recommendedPodSize;
+        this.maxMatchPlayers = maxMatchPlayers;
+        this.deckType = DeckType.valueOf(deckType);
+        this.freeCommander = freeCommander;
+        if (doublePickOption != null) {
+            switch (doublePickOption.toLowerCase()) {
+                case "firstpick":
+                    doublePick = DoublePick.FIRST_PICK;
+                    break;
+                case "always":
+                    doublePick = DoublePick.ALWAYS;
+                    break;
+                case "whenpodsizeis4":
+                    doublePick = DoublePick.WHEN_POD_SIZE_IS_4;
+                    break;
+            }
+        }
+
+    }
+    public int getMaxPodSize() {
+        return maxPodSize;
+    }
+    public int getRecommendedPodSize() {
+        return recommendedPodSize;
+    }
+    public DoublePick getDoublePick() {
+        return doublePick;
+    }
+
+    public DoublePick isDoublePick(int podSize) {
+        if (doublePick == DoublePick.WHEN_POD_SIZE_IS_4) {
+            if (podSize != 4) {
+                return DoublePick.NEVER;
+            }
+            // only when pod size is 4, so you can pick two cards each time
+            return DoublePick.ALWAYS;
+        }
+
+        return doublePick;
+    }
+
+
+    public int getMaxMatchPlayers() {
+        return maxMatchPlayers;
+    }
+    public DeckType getDeckType() {
+        return deckType;
+    }
+    public String getFreeCommander() {
+        return freeCommander;
+    }
+}

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

@@ -1,7 +1,9 @@
 package forge.card;
 
 import com.google.common.collect.ImmutableList;
-import forge.deck.DeckRecognizer;
+
+import forge.util.ITranslatable;
+import forge.util.Localizer;
 
 /**
  * Holds byte values for each color magic has.
@@ -157,21 +159,24 @@ public final class MagicColor {
         }
     }
 
-    public enum Color {
-        WHITE(Constant.WHITE, MagicColor.WHITE, "{W}"),
-        BLUE(Constant.BLUE, MagicColor.BLUE, "{U}"),
-        BLACK(Constant.BLACK, MagicColor.BLACK, "{B}"),
-        RED(Constant.RED, MagicColor.RED, "{R}"),
-        GREEN(Constant.GREEN, MagicColor.GREEN, "{G}"),
-        COLORLESS(Constant.COLORLESS, MagicColor.COLORLESS, "{C}");
+    public enum Color implements ITranslatable {
+        WHITE(Constant.WHITE, MagicColor.WHITE, "W", "lblWhite"),
+        BLUE(Constant.BLUE, MagicColor.BLUE, "U", "lblBlue"),
+        BLACK(Constant.BLACK, MagicColor.BLACK, "B", "lblBlack"),
+        RED(Constant.RED, MagicColor.RED, "R", "lblRed"),
+        GREEN(Constant.GREEN, MagicColor.GREEN, "G", "lblGreen"),
+        COLORLESS(Constant.COLORLESS, MagicColor.COLORLESS, "C", "lblColorless");
 
-        private final String name, symbol;
+        private final String name, shortName, symbol;
+        private final String label;
         private final byte colormask;
 
-        Color(String name0, byte colormask0, String symbol0) {
+        Color(String name0, byte colormask0, String shortName, String label) {
             name = name0;
             colormask = colormask0;
-            symbol = symbol0;
+            this.shortName = shortName;
+            symbol = "{" + shortName + "}";
+            this.label = label;
         }
 
         public static Color fromByte(final byte color) {
@@ -185,25 +190,25 @@ public final class MagicColor {
             }
         }
 
+        @Override
         public String getName() {
             return name;
         }
-
-        public String getLocalizedName() {
-            //Should probably move some of this logic back here, or at least to a more general location.
-            return DeckRecognizer.getLocalisedMagicColorName(getName());
+        public String getShortName() {
+            return shortName;
         }
 
-        public byte getColormask() {
+        @Override
+        public String getTranslatedName() {
+            return Localizer.getInstance().getMessage(label);
+        }
+
+        public byte getColorMask() {
             return colormask;
         }
         public String getSymbol() {
             return symbol;
         }
-        @Override
-        public String toString() {
-            return name;
-        }
     }
 
 }

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

@@ -13,6 +13,7 @@ import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
 import java.util.Map.Entry;
+import java.util.function.Predicate;
 
 /**
  * TODO: Write javadoc for this type.
@@ -68,6 +69,13 @@ public class PrintSheet {
             cardsWithWeights.remove(card);
     }
 
+    public boolean contains(PaperCard pc) {
+        return cardsWithWeights.contains(pc);
+    }
+    public PaperCard find(Predicate<PaperCard> filter) {
+        return cardsWithWeights.find(filter);
+    }
+
     private PaperCard fetchRoulette(int start, int roulette, Collection<PaperCard> toSkip) {
         int sum = start;
         boolean isSecondRun = start > 0;
@@ -85,15 +93,6 @@ public class PrintSheet {
         return fetchRoulette(sum + 1, roulette, toSkip); // start over from beginning, in case last cards were to skip
     }
 
-    public List<PaperCard> all() {
-        List<PaperCard> result = new ArrayList<>();
-        for (Entry<PaperCard, Integer> kv : cardsWithWeights) {
-            for (int i = 0; i < kv.getValue(); i++) {
-                result.add(kv.getKey());
-            }
-        }
-        return result;
-    }
     public boolean containsCardNamed(String name,int atLeast) {
         int count=0;
         for (Entry<PaperCard, Integer> kv : cardsWithWeights) {
@@ -144,7 +143,7 @@ public class PrintSheet {
         return cardsWithWeights.isEmpty();
     }
 
-    public Iterable<PaperCard> toFlatList() {
+    public List<PaperCard> toFlatList() {
         return cardsWithWeights.toFlatList();
     }
 

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

@@ -37,7 +37,6 @@ import java.util.function.Predicate;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
-
 public class CardPool extends ItemPool<PaperCard> {
     private static final long serialVersionUID = -5379091255613968393L;
 
@@ -78,12 +77,20 @@ public class CardPool extends ItemPool<PaperCard> {
         Map<String, CardDb> dbs = StaticData.instance().getAvailableDatabases();
         for (Map.Entry<String, CardDb> entry: dbs.entrySet()){
             CardDb db = entry.getValue();
+
             PaperCard paperCard = db.getCard(cardName, setCode, collectorNumber, flags);
             if (paperCard != null) {
                 this.add(paperCard, amount);
                 return;
             }
         }
+
+        // Try to get non-Alchemy version if it cannot find it.
+        if (cardName.startsWith("A-")) {
+            System.out.println("Alchemy card not found for '" + cardName + "'. Trying to get its non-Alchemy equivalent.");
+            cardName = cardName.replaceFirst("A-", "");
+        }
+
         //Failed to find it. Fall back accordingly?
         this.add(cardName, setCode, IPaperCard.NO_ART_INDEX, amount, addAny, flags);
     }
@@ -419,6 +426,12 @@ public class CardPool extends ItemPool<PaperCard> {
         return pool;
     }
 
+    public static CardPool fromSingleCardRequest(String cardRequest) {
+        if(StringUtils.isBlank(cardRequest))
+            return new CardPool();
+        return fromCardList(List.of(cardRequest));
+    }
+
     public static List<Pair<String, Integer>> processCardList(final Iterable<String> lines) {
         List<Pair<String, Integer>> cardRequests = new ArrayList<>();
         if (lines == null)
@@ -468,6 +481,7 @@ public class CardPool extends ItemPool<PaperCard> {
      * @param predicate the Predicate to apply to this CardPool
      * @return a new CardPool made from this CardPool with only the cards that agree with the provided Predicate
      */
+    @Override
     public CardPool getFilteredPool(Predicate<PaperCard> predicate) {
         CardPool filteredPool = new CardPool();
         for (PaperCard c : this.items.keySet()) {

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

@@ -28,6 +28,8 @@ import forge.item.PaperCard;
 import org.apache.commons.lang3.StringUtils;
 import org.apache.commons.lang3.tuple.Pair;
 
+import java.io.ObjectStreamException;
+import java.io.Serial;
 import java.util.*;
 import java.util.Map.Entry;
 
@@ -113,6 +115,20 @@ public class Deck extends DeckBase implements Iterable<Entry<DeckSection, CardPo
         return parts.get(DeckSection.Main);
     }
 
+    public Pair<Deck, List<PaperCard>> getValid() {
+        List<PaperCard> unsupported = new ArrayList<>();
+        for (Entry<DeckSection, CardPool> kv : parts.entrySet()) {
+            CardPool pool = kv.getValue();
+            for (Entry<PaperCard, Integer> pc : pool) {
+                if (pc.getKey().getRules() != null && pc.getKey().getRules().isUnsupported()) {
+                    unsupported.add(pc.getKey());
+                    pool.remove(pc.getKey());
+                }
+            }
+        }
+        return Pair.of(this, unsupported);
+    }
+
     public List<PaperCard> getCommanders() {
         List<PaperCard> result = Lists.newArrayList();
         final CardPool cp = get(DeckSection.Commander);
@@ -208,14 +224,19 @@ public class Deck extends DeckBase implements Iterable<Entry<DeckSection, CardPo
         super.cloneFieldsTo(clone);
         final Deck result = (Deck) clone;
         loadDeferredSections();
-        for (Entry<DeckSection, CardPool> kv : parts.entrySet()) {
-            CardPool cp = new CardPool();
-            result.parts.put(kv.getKey(), cp);
-            cp.addAll(kv.getValue());
+        // parts shouldn't be null
+        if (parts != null) {
+            for (Entry<DeckSection, CardPool> kv : parts.entrySet()) {
+                CardPool cp = new CardPool();
+                result.parts.put(kv.getKey(), cp);
+                cp.addAll(kv.getValue());
+            }
         }
         result.setAiHints(StringUtils.join(aiHints, " | "));
         result.setDraftNotes(draftNotes);
-        tags.addAll(result.getTags());
+        //noinspection ConstantValue
+        if(tags != null) //Can happen deserializing old Decks.
+            result.tags.addAll(this.tags);
     }
 
     /*
@@ -521,6 +542,17 @@ public class Deck extends DeckBase implements Iterable<Entry<DeckSection, CardPo
         return sum;
     }
 
+    /**
+     * Counts the number of copies of this exact card print across all deck sections.
+     */
+    public int count(PaperCard card) {
+        int sum = 0;
+        for (Entry<DeckSection, CardPool> section : this) {
+            sum += section.getValue().count(card);
+        }
+        return sum;
+    }
+
     public void setAiHints(String aiHintsInfo) {
         if (aiHintsInfo == null || aiHintsInfo.trim().isEmpty()) {
             return;
@@ -614,6 +646,14 @@ public class Deck extends DeckBase implements Iterable<Entry<DeckSection, CardPo
         return this;
     }
 
+    @Serial
+    private Object readResolve() throws ObjectStreamException {
+        //If we deserialized an old deck that doesn't have tags, fix it here.
+        if(this.tags == null)
+            return new Deck(this, this.getName() == null ? "" : this.getName());
+        return this;
+    }
+
     /** {@inheritDoc} */
     @Override
     public boolean equals(final Object o) {
@@ -663,4 +703,4 @@ public class Deck extends DeckBase implements Iterable<Entry<DeckSection, CardPo
         }
         return totalCount == 0 ? 0 : Math.round(totalCMC / totalCount);
     }
-}
+}

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

@@ -32,11 +32,8 @@ import forge.util.TextUtil;
 import org.apache.commons.lang3.Range;
 import org.apache.commons.lang3.tuple.ImmutablePair;
 
-import java.util.ArrayList;
-import java.util.HashSet;
-import java.util.List;
+import java.util.*;
 import java.util.Map.Entry;
-import java.util.Set;
 import java.util.function.Predicate;
 
 /**
@@ -60,6 +57,13 @@ public enum DeckFormat {
             //Limited contraption decks have no restrictions.
             return null;
         }
+
+        @Override
+        public int getExtraSectionMaxCopies(DeckSection section) {
+            if(section == DeckSection.Attractions || section == DeckSection.Contraptions)
+                return Integer.MAX_VALUE;
+            return super.getExtraSectionMaxCopies(section);
+        }
     },
     Commander      ( Range.is(99),                         Range.of(0, 10), 1, null,
             card -> StaticData.instance().getCommanderPredicate().test(card)
@@ -108,7 +112,13 @@ public enum DeckFormat {
         }
     },
     PlanarConquest ( Range.of(40, Integer.MAX_VALUE), Range.is(0), 1),
-    Adventure      ( Range.of(40, Integer.MAX_VALUE), Range.of(0, 15), 4),
+    Adventure      ( Range.of(40, Integer.MAX_VALUE), Range.of(0, Integer.MAX_VALUE), 4) {
+        @Override
+        public boolean allowCustomCards() {
+            //If the player has them, may as well allow them.
+            return true;
+        }
+    },
     Vanguard       ( Range.of(60, Integer.MAX_VALUE), Range.is(0), 4),
     Planechase     ( Range.of(60, Integer.MAX_VALUE), Range.is(0), 4),
     Archenemy      ( Range.of(60, Integer.MAX_VALUE), Range.is(0), 4),
@@ -191,12 +201,57 @@ public enum DeckFormat {
     }
 
     /**
-     * @return the maxCardCopies
+     * @return the default maximum copies of a card in this format.
      */
     public int getMaxCardCopies() {
         return maxCardCopies;
     }
 
+    /**
+     * @return the maximum copies of the specified card allowed in this format. This does not include ban or restricted lists.
+     */
+    public int getMaxCardCopies(PaperCard card) {
+        if(canHaveSpecificNumberInDeck(card) != null)
+            return canHaveSpecificNumberInDeck(card);
+        else if (canHaveAnyNumberOf(card))
+            return Integer.MAX_VALUE;
+        else if (card.getRules().isVariant()) {
+            DeckSection section = DeckSection.matchingSection(card);
+            if(section == DeckSection.Planes && card.getRules().getType().isPhenomenon())
+                return 2; //These are two-of.
+            return getExtraSectionMaxCopies(section);
+        }
+        else
+            return this.getMaxCardCopies();
+    }
+
+    public int getExtraSectionMaxCopies(DeckSection section) {
+        return switch (section) {
+            case Avatar, Commander, Planes, Dungeon, Attractions, Contraptions -> 1;
+            case Schemes -> 2;
+            case Conspiracy -> Integer.MAX_VALUE;
+            default -> maxCardCopies;
+        };
+    }
+
+    /**
+     * @return the deck sections used by most decks in this format.
+     */
+    public EnumSet<DeckSection> getPrimaryDeckSections() {
+        if(this == Planechase)
+            return EnumSet.of(DeckSection.Planes);
+        if(this == Archenemy)
+            return EnumSet.of(DeckSection.Schemes);
+        if(this == Vanguard)
+            return EnumSet.of(DeckSection.Avatar);
+        EnumSet<DeckSection> out = EnumSet.of(DeckSection.Main);
+        if(sideRange == null || sideRange.getMaximum() > 0)
+            out.add(DeckSection.Sideboard);
+        if(hasCommander())
+            out.add(DeckSection.Commander);
+        return out;
+    }
+
     public String getDeckConformanceProblem(Deck deck) {
         if (deck == null) {
             return "is not selected";
@@ -353,7 +408,7 @@ public enum DeckFormat {
         // Should group all cards by name, so that different editions of same card are really counted as the same card
         for (final Entry<String, Integer> cp : Aggregates.groupSumBy(allCards, pc -> StaticData.instance().getCommonCards().getName(pc.getName(), true))) {
             IPaperCard simpleCard = StaticData.instance().getCommonCards().getCard(cp.getKey());
-            if (simpleCard != null && simpleCard.getRules().isCustom() && !StaticData.instance().allowCustomCardsInDecksConformance())
+            if (simpleCard != null && simpleCard.getRules().isCustom() && !allowCustomCards())
                 return TextUtil.concatWithSpace("contains a Custom Card:", cp.getKey(), "\nPlease Enable Custom Cards in Forge Preferences to use this deck.");
             // Might cause issues since it ignores "Special" Cards
             if (simpleCard == null) {
@@ -484,6 +539,10 @@ public enum DeckFormat {
         // Not needed by default
     }
 
+    public boolean allowCustomCards() {
+        return StaticData.instance().allowCustomCardsInDecksConformance();
+    }
+
     public boolean isLegalCard(PaperCard pc) {
         if (cardPoolFilter == null) {
             if (paperCardPoolFilter == null) {
@@ -498,13 +557,13 @@ public enum DeckFormat {
         if (cardPoolFilter != null && !cardPoolFilter.test(rules)) {
             return false;
         }
-        if (this.equals(DeckFormat.Oathbreaker)) {
+        if (this == DeckFormat.Oathbreaker) {
             return rules.canBeOathbreaker();
         }
-        if (this.equals(DeckFormat.Brawl)) {
+        if (this == DeckFormat.Brawl) {
             return rules.canBeBrawlCommander();
         }
-        if (this.equals(DeckFormat.TinyLeaders)) {
+        if (this == DeckFormat.TinyLeaders) {
             return rules.canBeTinyLeadersCommander();
         }
         return rules.canBeCommander();
@@ -553,6 +612,8 @@ public enum DeckFormat {
         for (final PaperCard p : commanders) {
             cmdCI |= p.getRules().getColorIdentity().getColor();
         }
+        if(cmdCI == MagicColor.ALL_COLORS)
+            return x -> true;
         Predicate<CardRules> predicate = CardRulesPredicates.hasColorIdentity(cmdCI);
         if (commanders.size() == 1 && commanders.get(0).getRules().canBePartnerCommander()) {
             // Also show available partners a commander can have a partner.

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

@@ -49,6 +49,16 @@ public class DeckRecognizer {
         LIMITED_CARD,
         CARD_FROM_NOT_ALLOWED_SET,
         CARD_FROM_INVALID_SET,
+        /**
+         * Valid card request, but can't be imported because the player does not have enough copies.
+         * Should be replaced with a different printing if possible.
+         */
+        CARD_NOT_IN_INVENTORY,
+        /**
+         * Valid card request for a card that isn't in the player's inventory, but new copies can be acquired freely.
+         * Usually used for basic lands. Should be supplied to the import controller by the editor.
+         */
+        FREE_CARD_NOT_IN_INVENTORY,
         // Warning messages
         WARNING_MESSAGE,
         UNKNOWN_CARD,
@@ -63,10 +73,14 @@ public class DeckRecognizer {
         CARD_TYPE,
         CARD_RARITY,
         CARD_CMC,
-        MANA_COLOUR
+        MANA_COLOUR;
+
+        public static final EnumSet<TokenType> CARD_TOKEN_TYPES = EnumSet.of(LEGAL_CARD, LIMITED_CARD, CARD_FROM_NOT_ALLOWED_SET, CARD_FROM_INVALID_SET, CARD_NOT_IN_INVENTORY, FREE_CARD_NOT_IN_INVENTORY);
+        public static final EnumSet<TokenType> IN_DECK_TOKEN_TYPES = EnumSet.of(LEGAL_CARD, LIMITED_CARD, DECK_NAME, FREE_CARD_NOT_IN_INVENTORY);
+        public static final EnumSet<TokenType> CARD_PLACEHOLDER_TOKEN_TYPES = EnumSet.of(CARD_TYPE, CARD_RARITY, CARD_CMC, MANA_COLOUR);
     }
 
-    public enum LimitedCardType{
+    public enum LimitedCardType {
         BANNED,
         RESTRICTED,
     }
@@ -108,6 +122,10 @@ public class DeckRecognizer {
             return new Token(TokenType.CARD_FROM_INVALID_SET, count, card, cardRequestHasSetCode);
         }
 
+        public static Token NotInInventoryFree(final PaperCard card, final int count, final DeckSection section) {
+            return new Token(TokenType.FREE_CARD_NOT_IN_INVENTORY, count, card, section, true);
+        }
+
         // WARNING MESSAGES
         // ================
         public static Token UnknownCard(final String cardName, final String setCode, final int count) {
@@ -126,6 +144,10 @@ public class DeckRecognizer {
            return new Token(TokenType.WARNING_MESSAGE, msg);
         }
 
+        public static Token NotInInventory(final PaperCard card, final int count, final DeckSection section) {
+            return new Token(TokenType.CARD_NOT_IN_INVENTORY, count, card, section, false);
+        }
+
         /* =================================
          * DECK SECTIONS
          * ================================= */
@@ -239,14 +261,11 @@ public class DeckRecognizer {
         /**
          * Filters all token types that have a PaperCard instance set (not null)
          * @return true for tokens of type:
-         * LEGAL_CARD, LIMITED_CARD, CARD_FROM_NOT_ALLOWED_SET and CARD_FROM_INVALID_SET.
+         * LEGAL_CARD, LIMITED_CARD, CARD_FROM_NOT_ALLOWED_SET and CARD_FROM_INVALID_SET, CARD_NOT_IN_INVENTORY, FREE_CARD_NOT_IN_INVENTORY.
          * False otherwise.
          */
         public boolean isCardToken() {
-            return (this.type == TokenType.LEGAL_CARD ||
-                    this.type == TokenType.LIMITED_CARD ||
-                    this.type == TokenType.CARD_FROM_NOT_ALLOWED_SET ||
-                    this.type == TokenType.CARD_FROM_INVALID_SET);
+            return TokenType.CARD_TOKEN_TYPES.contains(this.type);
         }
 
         /**
@@ -255,9 +274,7 @@ public class DeckRecognizer {
          * LEGAL_CARD, LIMITED_CARD, DECK_NAME; false otherwise.
          */
         public boolean isTokenForDeck() {
-            return (this.type == TokenType.LEGAL_CARD ||
-                    this.type == TokenType.LIMITED_CARD ||
-                    this.type == TokenType.DECK_NAME);
+            return TokenType.IN_DECK_TOKEN_TYPES.contains(this.type);
         }
 
         /**
@@ -266,7 +283,7 @@ public class DeckRecognizer {
          * False otherwise.
          */
         public boolean isCardTokenForDeck() {
-            return (this.type == TokenType.LEGAL_CARD || this.type == TokenType.LIMITED_CARD);
+            return isCardToken() && isTokenForDeck();
         }
 
         /**
@@ -276,10 +293,7 @@ public class DeckRecognizer {
          * CARD_RARITY, CARD_CMC, CARD_TYPE, MANA_COLOUR
          */
         public boolean isCardPlaceholder(){
-            return (this.type == TokenType.CARD_RARITY ||
-                    this.type == TokenType.CARD_CMC ||
-                    this.type == TokenType.MANA_COLOUR ||
-                    this.type == TokenType.CARD_TYPE);
+            return TokenType.CARD_PLACEHOLDER_TOKEN_TYPES.contains(this.type);
         }
 
         /** Determines if current token is a Deck Section token
@@ -536,7 +550,7 @@ public class DeckRecognizer {
             PaperCard tokenCard = token.getCard();
 
             if (isAllowed(tokenSection)) {
-                if (!tokenSection.equals(referenceDeckSectionInParsing)) {
+                if (tokenSection != referenceDeckSectionInParsing) {
                     Token sectionToken = Token.DeckSection(tokenSection.name(), this.allowedDeckSections);
                     // just check that last token is stack is a card placeholder.
                     // In that case, add the new section token before the placeholder
@@ -575,7 +589,7 @@ public class DeckRecognizer {
         refLine = purgeAllLinks(refLine);
 
         String line;
-        if (StringUtils.startsWith(refLine, LINE_COMMENT_DELIMITER_OR_MD_HEADER))
+        if (refLine.startsWith(LINE_COMMENT_DELIMITER_OR_MD_HEADER))
             line = refLine.replaceAll(LINE_COMMENT_DELIMITER_OR_MD_HEADER, "");
         else
             line = refLine.trim();  // Remove any trailing formatting
@@ -584,7 +598,7 @@ public class DeckRecognizer {
         // Final fantasy cards like Summon: Choco/Mog should be ommited to be recognized. TODO: fix maybe for future cards
         if (!line.contains("Summon:"))
             line = SEARCH_SINGLE_SLASH.matcher(line).replaceFirst(" // ");
-        if (StringUtils.startsWith(line, ASTERISK))  // markdown lists (tappedout md export)
+        if (line.startsWith(ASTERISK))  // Markdown lists (tappedout md export)
             line = line.substring(2);
 
         // == Patches to Corner Cases
@@ -600,8 +614,8 @@ public class DeckRecognizer {
         Token result = recogniseCardToken(line, referenceSection);
         if (result == null)
             result = recogniseNonCardToken(line);
-        return result != null ? result : StringUtils.startsWith(refLine, DOUBLE_SLASH) ||
-                StringUtils.startsWith(refLine, LINE_COMMENT_DELIMITER_OR_MD_HEADER) ?
+        return result != null ? result : refLine.startsWith(DOUBLE_SLASH) ||
+                refLine.startsWith(LINE_COMMENT_DELIMITER_OR_MD_HEADER) ?
                 new Token(TokenType.COMMENT, 0, refLine) : new Token(TokenType.UNKNOWN_TEXT, 0, refLine);
     }
 
@@ -613,7 +627,7 @@ public class DeckRecognizer {
         while (m.find()) {
             line = line.replaceAll(m.group(), "").trim();
         }
-        if (StringUtils.endsWith(line, "()"))
+        if (line.endsWith("()"))
             return line.substring(0, line.length()-2);
         return line;
     }
@@ -741,21 +755,12 @@ public class DeckRecognizer {
     // This would save tons of time in parsing Input + would also allow to return UnsupportedCardTokens beforehand
     private DeckSection getTokenSection(String deckSec, DeckSection currentDeckSection, PaperCard card){
         if (deckSec != null) {
-            DeckSection cardSection;
-            switch (deckSec.toUpperCase().trim()) {
-                case "MB":
-                    cardSection = DeckSection.Main;
-                    break;
-                case "SB":
-                    cardSection = DeckSection.Sideboard;
-                    break;
-                case "CM":
-                    cardSection = DeckSection.Commander;
-                    break;
-                default:
-                    cardSection = DeckSection.matchingSection(card);
-                    break;
-            }
+            DeckSection cardSection = switch (deckSec.toUpperCase().trim()) {
+                case "MB" -> DeckSection.Main;
+                case "SB" -> DeckSection.Sideboard;
+                case "CM" -> DeckSection.Commander;
+                default -> DeckSection.matchingSection(card);
+            };
             if (cardSection.validate(card))
                 return cardSection;
         }
@@ -989,7 +994,7 @@ public class DeckRecognizer {
     private static String getMagicColourLabel(MagicColor.Color magicColor) {
         if (magicColor == null) // Multicolour
             return String.format("%s {W}{U}{B}{R}{G}", getLocalisedMagicColorName("Multicolour"));
-        return String.format("%s %s", magicColor.getLocalizedName(), magicColor.getSymbol());
+        return String.format("%s %s", magicColor.getTranslatedName(), magicColor.getSymbol());
     }
 
     private static final HashMap<Integer, String> manaSymbolsMap = new HashMap<Integer, String>() {{
@@ -1008,60 +1013,30 @@ public class DeckRecognizer {
         if (magicColor2 == null || magicColor2 == MagicColor.Color.COLORLESS
                 || magicColor1 == MagicColor.Color.COLORLESS)
             return String.format("%s // %s", getMagicColourLabel(magicColor1), getMagicColourLabel(magicColor2));
-        String localisedName1 = magicColor1.getLocalizedName();
-        String localisedName2 = magicColor2.getLocalizedName();
-        String comboManaSymbol = manaSymbolsMap.get(magicColor1.getColormask() | magicColor2.getColormask());
+        String localisedName1 = magicColor1.getTranslatedName();
+        String localisedName2 = magicColor2.getTranslatedName();
+        String comboManaSymbol = manaSymbolsMap.get(magicColor1.getColorMask() | magicColor2.getColorMask());
         return String.format("%s/%s {%s}", localisedName1, localisedName2, comboManaSymbol);
     }
 
     private static MagicColor.Color getMagicColor(String colorName){
         if (colorName.toLowerCase().startsWith("multi") || colorName.equalsIgnoreCase("m"))
             return null;  // will be handled separately
-
-        byte color = MagicColor.fromName(colorName.toLowerCase());
-        switch (color) {
-            case MagicColor.WHITE:
-                return MagicColor.Color.WHITE;
-            case MagicColor.BLUE:
-                return MagicColor.Color.BLUE;
-            case MagicColor.BLACK:
-                return MagicColor.Color.BLACK;
-            case MagicColor.RED:
-                return MagicColor.Color.RED;
-            case MagicColor.GREEN:
-                return MagicColor.Color.GREEN;
-            default:
-                return MagicColor.Color.COLORLESS;
-
-        }
+        return MagicColor.Color.fromByte(MagicColor.fromName(colorName.toLowerCase()));
     }
 
     public static String getLocalisedMagicColorName(String colorName){
         Localizer localizer = Localizer.getInstance();
-        switch(colorName.toLowerCase()){
-            case MagicColor.Constant.WHITE:
-                return localizer.getMessage("lblWhite");
-
-            case MagicColor.Constant.BLUE:
-                return localizer.getMessage("lblBlue");
-
-            case MagicColor.Constant.BLACK:
-                return localizer.getMessage("lblBlack");
-
-            case MagicColor.Constant.RED:
-                return localizer.getMessage("lblRed");
-
-            case MagicColor.Constant.GREEN:
-                return localizer.getMessage("lblGreen");
-
-            case MagicColor.Constant.COLORLESS:
-                return localizer.getMessage("lblColorless");
-            case "multicolour":
-            case "multicolor":
-                return localizer.getMessage("lblMulticolor");
-            default:
-                return "";
-        }
+        return switch (colorName.toLowerCase()) {
+            case MagicColor.Constant.WHITE -> localizer.getMessage("lblWhite");
+            case MagicColor.Constant.BLUE -> localizer.getMessage("lblBlue");
+            case MagicColor.Constant.BLACK -> localizer.getMessage("lblBlack");
+            case MagicColor.Constant.RED -> localizer.getMessage("lblRed");
+            case MagicColor.Constant.GREEN -> localizer.getMessage("lblGreen");
+            case MagicColor.Constant.COLORLESS -> localizer.getMessage("lblColorless");
+            case "multicolour", "multicolor" -> localizer.getMessage("lblMulticolor");
+            default -> "";
+        };
     }
 
     /**
@@ -1080,37 +1055,6 @@ public class DeckRecognizer {
 
         return "";
     }
-
-
-    private static Pair<String, String> getManaNameAndSymbol(String matchedMana) {
-        if (matchedMana == null)
-            return null;
-
-        Localizer localizer = Localizer.getInstance();
-        switch (matchedMana.toLowerCase()) {
-            case MagicColor.Constant.WHITE:
-            case "w":
-                return Pair.of(localizer.getMessage("lblWhite"), MagicColor.Color.WHITE.getSymbol());
-            case MagicColor.Constant.BLUE:
-            case "u":
-                return Pair.of(localizer.getMessage("lblBlue"), MagicColor.Color.BLUE.getSymbol());
-            case MagicColor.Constant.BLACK:
-            case "b":
-                return Pair.of(localizer.getMessage("lblBlack"), MagicColor.Color.BLACK.getSymbol());
-            case MagicColor.Constant.RED:
-            case "r":
-                return Pair.of(localizer.getMessage("lblRed"), MagicColor.Color.RED.getSymbol());
-            case MagicColor.Constant.GREEN:
-            case "g":
-                return Pair.of(localizer.getMessage("lblGreen"), MagicColor.Color.GREEN.getSymbol());
-            case MagicColor.Constant.COLORLESS:
-            case "c":
-                return Pair.of(localizer.getMessage("lblColorless"), MagicColor.Color.COLORLESS.getSymbol());
-            default: // Multicolour
-                return Pair.of(localizer.getMessage("lblMulticolor"), "");
-        }
-    }
-
     public static boolean isDeckName(final String lineAsIs) {
         if (lineAsIs == null)
             return false;

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

@@ -52,9 +52,4 @@ public interface IPaperCard extends InventoryItem, Serializable {
     default String getUntranslatedType() {
         return getRules().getType().toString();
     }
-
-    @Override
-    default String getUntranslatedOracle() {
-        return getRules().getOracleText();
-    }
 }

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

@@ -46,7 +46,7 @@ public class PaperCard implements Comparable<IPaperCard>, InventoryItemFromSet,
 
     // These fields are kinda PK for PrintedCard
     private final String name;
-    private final String edition;
+    private String edition;
     /* [NEW] Attribute to store reference to CollectorNumber of each PaperCard.
        By default the attribute is marked as "unset" so that it could be retrieved and set.
        (see getCollectorNumber())
@@ -154,6 +154,31 @@ public class PaperCard implements Comparable<IPaperCard>, InventoryItemFromSet,
         return this.noSellVersion;
     }
 
+    public PaperCard getMeldBaseCard() {
+        if (getRules().getSplitType() != CardSplitType.Meld) {
+            return null;
+        }
+
+        // This is the base part of the meld duo
+        if (getRules().getOtherPart() == null) {
+            return this;
+        }
+
+        String meldWith = getRules().getMeldWith();
+        if (meldWith == null) {
+            return null;
+        }
+        
+        List<PrintSheet> sheets = StaticData.instance().getCardEdition(this.edition).getPrintSheetsBySection();
+        for (PrintSheet sheet : sheets) {
+            if (sheet.contains(this)) {
+                return sheet.find(PaperCardPredicates.name(meldWith));
+            }
+        }
+
+        return null;
+    }
+
     public PaperCard copyWithoutFlags() {
         if(this.flaglessVersion == null) {
             if(this.flags == PaperCardFlags.IDENTITY_FLAGS)
@@ -225,7 +250,7 @@ public class PaperCard implements Comparable<IPaperCard>, InventoryItemFromSet,
         this.artIndex = Math.max(artIndex, IPaperCard.DEFAULT_ART_INDEX);
         this.foil = foil;
         this.rarity = rarity;
-        this.artist = TextUtil.normalizeText(artist);
+        this.artist = artist;
         this.collectorNumber = (collectorNumber != null && !collectorNumber.isEmpty()) ? collectorNumber : IPaperCard.NO_COLLECTOR_NUMBER;
         // If the user changes the language this will make cards sort by the old language until they restart the game.
         // This is a good tradeoff
@@ -350,7 +375,8 @@ public class PaperCard implements Comparable<IPaperCard>, InventoryItemFromSet,
                 System.out.println("PaperCard: " + name + " not found with set and index " + edition + ", " + artIndex);
                 pc = readObjectAlternate(name, edition);
                 if (pc == null) {
-                    throw new IOException(TextUtil.concatWithSpace("Card", name, "not found with set and index", edition, Integer.toString(artIndex)));
+                    pc = StaticData.instance().getCommonCards().createUnsupportedCard(name);
+                    //throw new IOException(TextUtil.concatWithSpace("Card", name, "not found with set and index", edition, Integer.toString(artIndex)));
                 }
                 System.out.println("Alternate object found: " + pc.getName() + ", " + pc.getEdition() + ", " + pc.getArtIndex());
             }
@@ -567,7 +593,7 @@ public class PaperCard implements Comparable<IPaperCard>, InventoryItemFromSet,
 
         public PaperCardFlags withMarkedColors(ColorSet markedColors) {
             if(markedColors == null)
-                markedColors = ColorSet.getNullColor();
+                markedColors = ColorSet.NO_COLORS;
             return new PaperCardFlags(this, markedColors, null);
         }
 

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

@@ -50,6 +50,13 @@ public abstract class PaperCardPredicates {
         return new PredicateNames(what);
     }
 
+    /**
+     * Filters on a card foil status
+     */
+    public static Predicate<PaperCard> isFoil(final boolean isFoil) {
+        return new PredicateFoil(isFoil);
+    }
+
     private static final class PredicatePrintedWithRarity implements Predicate<PaperCard> {
         private final CardRarity matchingRarity;
 
@@ -93,6 +100,17 @@ public abstract class PaperCardPredicates {
         }
     }
 
+    private static final class PredicateFoil implements Predicate<PaperCard> {
+        private final boolean operand;
+
+        @Override
+        public boolean test(final PaperCard card) { return card.isFoil() == operand; }
+
+        private PredicateFoil(final boolean isFoil) {
+            this.operand = isFoil;
+        }
+    }
+
     private static final class PredicateRarity implements Predicate<PaperCard> {
         private final CardRarity operand;
 

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

@@ -156,7 +156,7 @@ public class PaperToken implements InventoryItemFromSet, IPaperCard {
             return false;
         CardSplitType cst = this.cardRules.getSplitType();
         //expand this on future for other tokens that has other backsides besides transform..
-        return cst == CardSplitType.Transform;
+        return cst == CardSplitType.Transform || cst == CardSplitType.Modal;
     }
 
     @Override

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

@@ -19,6 +19,11 @@ public class SealedTemplate {
             Pair.of(BoosterSlots.RARE_MYTHIC, 1), Pair.of(BoosterSlots.BASIC_LAND, 1)
     ));
 
+    // This is a generic cube booster. 15 cards, no rarity slots.
+    public final static SealedTemplate genericNoSlotBooster = new SealedTemplate(null, Lists.newArrayList(
+            Pair.of(BoosterSlots.ANY, 15)
+    ));
+
     protected final List<Pair<String, Integer>> slots;
 
     protected final String name;

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

@@ -254,7 +254,7 @@ public class BoosterGenerator {
 
             if (sheetKey.startsWith("wholeSheet")) {
                 PrintSheet ps = getPrintSheet(sheetKey);
-                result.addAll(ps.all());
+                result.addAll(ps.toFlatList());
                 continue;
             }
 
@@ -384,7 +384,7 @@ public class BoosterGenerator {
                 PrintSheet replaceThis = tryGetStaticSheet(split[0]);
                 List<PaperCard> candidates = Lists.newArrayList();
                 for (PaperCard p : result) {
-                    if (replaceThis.all().contains(p)) {
+                    if (replaceThis.contains(p)) {
                         candidates.add(candidates.size(), p);
                     }
                 }
@@ -398,7 +398,7 @@ public class BoosterGenerator {
                 PrintSheet replaceThis = tryGetStaticSheet(split[0]);
                 List<PaperCard> candidates = Lists.newArrayList();
                 for (PaperCard p : result) {
-                    if (replaceThis.all().contains(p)) {
+                    if (replaceThis.contains(p)) {
                         candidates.add(candidates.size(), p);
                     }
                 }
@@ -462,9 +462,8 @@ public class BoosterGenerator {
                 } else {
                     paperCards.addAll(ps.random(numCardsToGenerate, true));
                 }
-
-                result.addAll(paperCards);
             }
+            result.addAll(paperCards);
         }
 
         return result;
@@ -634,7 +633,10 @@ public class BoosterGenerator {
                 System.out.println("Parsing from main code: " + mainCode);
                 String sheetName = StringUtils.strip(mainCode.substring(10), "()\" ");
                 System.out.println("Attempting to lookup: " + sheetName);
-                src = tryGetStaticSheet(sheetName).toFlatList();
+                PrintSheet fromSheet = tryGetStaticSheet(sheetName);
+                if (fromSheet == null)
+                    throw new RuntimeException("PrintSheet Error: " + ps.getName() + " didn't find " + sheetName + " from " + mainCode);
+                src = fromSheet.toFlatList();
                 setPred = x -> true;
 
             } else if (mainCode.startsWith("promo") || mainCode.startsWith("name")) { // get exactly the named cards, that's a tiny inlined print sheet

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

@@ -10,13 +10,11 @@ public interface ITranslatable extends IHasName {
     default String getUntranslatedName() {
         return getName();
     }
+    default String getTranslatedName() {
+        return getName();
+    }
 
     default String getUntranslatedType() {
         return "";
     }
-
-    default String getUntranslatedOracle() {
-        return "";
-    }
-
 }

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

@@ -199,19 +199,14 @@ public class ImageUtil {
         return getImageRelativePath(cp, face, true, true);
     }
 
-    public static String getScryfallDownloadUrl(PaperCard cp, String face, String setCode, String langCode, boolean useArtCrop){
-        return getScryfallDownloadUrl(cp, face, setCode, langCode, useArtCrop, false);
-    }
 
-    public static String getScryfallDownloadUrl(PaperCard cp, String face, String setCode, String langCode, boolean useArtCrop, boolean hyphenateAlchemy){
+    public static String getScryfallDownloadUrl(PaperCard cp, String face, String setCode, String langCode, boolean useArtCrop){
         String editionCode;
         if (setCode != null && !setCode.isEmpty())
             editionCode = setCode;
         else
             editionCode = cp.getEdition().toLowerCase();
         String cardCollectorNumber = cp.getCollectorNumber();
-        // Hack to account for variations in Arabian Nights
-        cardCollectorNumber = cardCollectorNumber.replace("+", "†");
         // override old planechase sets from their modified id since scryfall move the planechase cards outside their original setcode
         if (cardCollectorNumber.startsWith("OHOP")) {
             editionCode = "ohop";
@@ -222,29 +217,42 @@ public class ImageUtil {
         } else if (cardCollectorNumber.startsWith("OPC2")) {
             editionCode = "opc2";
             cardCollectorNumber = cardCollectorNumber.substring("OPC2".length());
-        } else if (hyphenateAlchemy) {
-            if (!cardCollectorNumber.startsWith("A")) {
-                return null;
-            }
-
-            cardCollectorNumber = cardCollectorNumber.replace("A", "A-");
         }
         String versionParam = useArtCrop ? "art_crop" : "normal";
         String faceParam = "";
-        if (cp.getRules().getOtherPart() != null) {
-            faceParam = (face.equals("back") ? "&face=back" : "&face=front");
-        } else if (cp.getRules().getSplitType() == CardSplitType.Meld
-                    && !cardCollectorNumber.endsWith("a")
-                    && !cardCollectorNumber.endsWith("b")) {
 
-                // Only the bottom half of a meld card shares a collector number.
-                // Hanweir Garrison EMN already has a appended.
-                // Exception: The front facing card doesn't use a in FIN
-                if (face.equals("back")) {
-                    cardCollectorNumber += "b";
-                } else if (!editionCode.equals("fin")) {
-                    cardCollectorNumber += "a";
+        if (cp.getRules().getSplitType() == CardSplitType.Meld) {
+            if (face.equals("back")) {
+                PaperCard meldBasePc = cp.getMeldBaseCard();
+                cardCollectorNumber = meldBasePc.getCollectorNumber();
+                String collectorNumberSuffix = "";
+
+                if (cardCollectorNumber.endsWith("a")) {
+                    cardCollectorNumber = cardCollectorNumber.substring(0, cardCollectorNumber.length() - 1);
+                } else if (cardCollectorNumber.endsWith("as")) {
+                    cardCollectorNumber = cardCollectorNumber.substring(0, cardCollectorNumber.length() - 2);
+                    collectorNumberSuffix = "s";
+                } else if (cardCollectorNumber.endsWith("ap")) {
+                    cardCollectorNumber = cardCollectorNumber.substring(0, cardCollectorNumber.length() - 2);
+                    collectorNumberSuffix = "p";
+                } else if (cp.getCollectorNumber().endsWith("a")) {
+                    // SIR
+                    cardCollectorNumber = cp.getCollectorNumber().substring(0, cp.getCollectorNumber().length() - 1);
                 }
+
+                cardCollectorNumber += "b" + collectorNumberSuffix;
+            }
+
+            faceParam = "&face=front";
+        } else if (cp.getRules().getOtherPart() != null) {
+            faceParam = (face.equals("back") && cp.getRules().getSplitType() != CardSplitType.Flip
+                    ? "&face=back"
+                    : "&face=front");
+        }
+
+        if (cardCollectorNumber.endsWith("☇")) {
+            faceParam = "&face=back";
+            cardCollectorNumber = cardCollectorNumber.substring(0, cardCollectorNumber.length() - 1);
         }
 
         return String.format("%s/%s/%s?format=image&version=%s%s", editionCode, encodeUtf8(cardCollectorNumber),
@@ -256,6 +264,10 @@ public class ImageUtil {
         if (!faceParam.isEmpty()) {
             faceParam = (faceParam.equals("back") ? "&face=back" : "&face=front");
         }
+        if (collectorNumber.endsWith("☇")) {
+            faceParam = "&face=back";
+            collectorNumber = collectorNumber.substring(0, collectorNumber.length() - 1);
+        }
         return String.format("%s/%s/%s?format=image&version=%s%s", setCode, encodeUtf8(collectorNumber),
                 langCode, versionParam, faceParam);
     }
@@ -276,8 +288,7 @@ public class ImageUtil {
         char c;
         for (int i = 0; i < in.length(); i++) {
             c = in.charAt(i);
-            if ((c == '"') || (c == '/') || (c == ':') || (c == '?')) {
-            } else {
+            if ((c != '"') && (c != '/') && (c != ':') && (c != '?')) {
                 out.append(c);
             }
         }

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

@@ -269,11 +269,16 @@ public class ItemPool<T extends InventoryItem> implements Iterable<Entry<T, Inte
         // need not set out-of-sync: either remove did set, or nothing was removed
     }
 
-    public void removeIf(Predicate<T> test) {
-        for (final T item : items.keySet()) {
-            if (test.test(item))
-                remove(item);
-        }
+    public void removeIf(Predicate<T> filter) {
+        items.keySet().removeIf(filter);
+    }
+
+    public void retainIf(Predicate<T> filter) {
+        items.keySet().removeIf(filter.negate());
+    }
+
+    public T find(Predicate<T> filter) {
+        return items.keySet().stream().filter(filter).findFirst().orElse(null);
     }
 
     public void clear() {
@@ -285,4 +290,19 @@ public class ItemPool<T extends InventoryItem> implements Iterable<Entry<T, Inte
         return (obj instanceof ItemPool ip) &&
                 (this.items.equals(ip.items));
     }
+
+    /**
+     * Applies a predicate to this ItemPool's entries.
+     *
+     * @param predicate the Predicate to apply to this ItemPool
+     * @return a new ItemPool made from this ItemPool with only the items that agree with the provided Predicate
+     */
+    public ItemPool<T> getFilteredPool(Predicate<T> predicate) {
+        ItemPool<T> filteredPool = new ItemPool<>(myClass);
+        for (T c : this.items.keySet()) {
+            if (predicate.test(c))
+                filteredPool.add(c, this.items.get(c));
+        }
+        return filteredPool;
+    }
 }

forge-game/pom.xml

@@ -32,7 +32,7 @@
         <dependency>
             <groupId>io.sentry</groupId>
             <artifactId>sentry-logback</artifactId>
-            <version>7.15.0</version>
+            <version>8.21.1</version>
         </dependency>
         <dependency>
             <groupId>org.jgrapht</groupId>

forge-game/src/main/java/forge/game/CardTraitBase.java

@@ -62,7 +62,9 @@ public abstract class CardTraitBase extends GameObject implements IHasCardView,
 
     /** Keys of descriptive (text) parameters. */
     private static final ImmutableList<String> descriptiveKeys = ImmutableList.<String>builder()
-            .add("Description", "SpellDescription", "StackDescription", "TriggerDescription").build();
+            .add("Description", "SpellDescription", "StackDescription", "TriggerDescription")
+            .add("ChangeTypeDesc")
+            .build();
 
     /**
      * Keys that should not changed

forge-game/src/main/java/forge/game/ForgeScript.java

@@ -35,7 +35,7 @@ public class ForgeScript {
         boolean withSource = property.endsWith("Source");
         final ColorSet colors;
         if (withSource && StaticAbilityColorlessDamageSource.colorlessDamageSource(cardState)) {
-            colors = ColorSet.getNullColor();
+            colors = ColorSet.NO_COLORS;
         } else {
             colors = cardState.getCard().getColor(cardState);
         }
@@ -166,8 +166,6 @@ public class ForgeScript {
             Card source, CardTraitBase spellAbility) {
         if (property.equals("ManaAbility")) {
             return sa.isManaAbility();
-        } else if (property.equals("nonManaAbility")) {
-            return !sa.isManaAbility();
         } else if (property.equals("withoutXCost")) {
             return !sa.costHasManaX();
         } else if (property.startsWith("XCost")) {
@@ -195,7 +193,7 @@ public class ForgeScript {
             return sa.isKeyword(Keyword.SADDLE);
         } else if (property.equals("Station")) {
             return sa.isKeyword(Keyword.STATION);
-        }else if (property.equals("Cycling")) {
+        } else if (property.equals("Cycling")) {
             return sa.isCycling();
         } else if (property.equals("Dash")) {
             return sa.isDash();
@@ -237,6 +235,8 @@ public class ForgeScript {
             return sa.isBoast();
         } else if (property.equals("Exhaust")) {
             return sa.isExhaust();
+        } else if (property.equals("Mayhem")) {
+            return sa.isMayhem();
         } else if (property.equals("Mutate")) {
             return sa.isMutate();
         } else if (property.equals("Ninjutsu")) {
@@ -410,6 +410,8 @@ public class ForgeScript {
                 return !sa.isPwAbility() && !sa.getRestrictions().isSorcerySpeed();
             }
             return true;
+        } else if(property.startsWith("NamedAbility")) {
+            return sa.getName().equals(property.substring(12));
         } else if (sa.getHostCard() != null) {
             return sa.getHostCard().hasProperty(property, sourceController, source, spellAbility);
         }

forge-game/src/main/java/forge/game/Game.java

@@ -414,19 +414,6 @@ public class Game {
         return players;
     }
 
-    /**
-     * Gets the nonactive players who are still fighting to win, in turn order.
-     */
-    public final PlayerCollection getNonactivePlayers() {
-        // Don't use getPlayersInTurnOrder to prevent copying the player collection twice
-        final PlayerCollection players = new PlayerCollection(ingamePlayers);
-        players.remove(phaseHandler.getPlayerTurn());
-        if (!getTurnOrder().isDefaultDirection()) {
-            Collections.reverse(players);
-        }
-        return players;
-    }
-
     /**
      * Gets the players who participated in match (regardless of outcome).
      * <i>Use this in UI and after match calculations</i>
@@ -744,7 +731,7 @@ public class Game {
             if (!visitor.visitAll(player.getZone(ZoneType.Exile).getCards())) {
                 return;
             }
-            if (!visitor.visitAll(player.getZone(ZoneType.Command).getCards())) {
+            if (!visitor.visitAll(player.getCardsIn(ZoneType.PART_OF_COMMAND_ZONE))) {
                 return;
             }
             if (withSideboard && !visitor.visitAll(player.getZone(ZoneType.Sideboard).getCards())) {
@@ -858,6 +845,8 @@ public class Game {
             p.revealFaceDownCards();
         }
 
+        // TODO free any mindslaves
+
         for (Card c : cards) {
             // CR 800.4d if card is controlled by opponent, LTB should trigger
             if (c.getOwner().equals(p) && c.getController().equals(p)) {
@@ -893,8 +882,6 @@ public class Game {
                         }
                         triggerList.put(c.getZone().getZoneType(), null, c);
                         getAction().ceaseToExist(c, false);
-                        // CR 603.2f owner of trigger source lost game
-                        getTriggerHandler().clearDelayedTrigger(c);
                     }
                 } else {
                     // return stolen permanents

forge-game/src/main/java/forge/game/GameAction.java

@@ -57,6 +57,8 @@ import forge.item.PaperCard;
 import forge.util.*;
 import forge.util.collect.FCollection;
 import forge.util.collect.FCollectionView;
+import io.sentry.Breadcrumb;
+import io.sentry.Sentry;
 import org.apache.commons.lang3.tuple.ImmutablePair;
 import org.jgrapht.alg.cycle.SzwarcfiterLauerSimpleCycles;
 import org.jgrapht.graph.DefaultDirectedGraph;
@@ -220,10 +222,6 @@ public class GameAction {
                     //copied.setGamePieceType(GamePieceType.COPIED_SPELL);
                 }
 
-                if (c.isTransformed()) {
-                    copied.incrementTransformedTimestamp();
-                }
-
                 if (cause != null && cause.isSpell() && c.equals(cause.getHostCard())) {
                     copied.setCastSA(cause);
                     copied.setSplitStateToPlayAbility(cause);
@@ -753,26 +751,29 @@ public class GameAction {
 
     public final Card moveTo(final ZoneType name, final Card c, final int libPosition, SpellAbility cause, Map<AbilityKey, Object> params) {
         // Call specific functions to set PlayerZone, then move onto moveTo
-        switch(name) {
-            case Hand:          return moveToHand(c, cause, params);
-            case Library:       return moveToLibrary(c, libPosition, cause, params);
-            case Battlefield:   return moveToPlay(c, c.getController(), cause, params);
-            case Graveyard:     return moveToGraveyard(c, cause, params);
-            case Exile:
-                if (!c.canExiledBy(cause, true)) {
-                    return null;
-                }
-                return exile(c, cause, params);
-            case Stack:         return moveToStack(c, cause, params);
-            case PlanarDeck:
-            case SchemeDeck:
-            case AttractionDeck:
-            case ContraptionDeck:
-                return moveToVariantDeck(c, name, libPosition, cause, params);
-            case Junkyard:
-                return moveToJunkyard(c, cause, params);
-            default: // sideboard will also get there
-                return moveTo(c.getOwner().getZone(name), c, cause);
+        try {
+            return switch (name) {
+                case Hand -> moveToHand(c, cause, params);
+                case Library -> moveToLibrary(c, libPosition, cause, params);
+                case Battlefield -> moveToPlay(c, c.getController(), cause, params);
+                case Graveyard -> moveToGraveyard(c, cause, params);
+                case Exile -> !c.canExiledBy(cause, true) ? null : exile(c, cause, params);
+                case Stack -> moveToStack(c, cause, params);
+                case PlanarDeck, SchemeDeck, AttractionDeck, ContraptionDeck -> moveToVariantDeck(c, name, libPosition, cause, params);
+                case Junkyard -> moveToJunkyard(c, cause, params);
+                default -> moveTo(c.getOwner().getZone(name), c, cause); // sideboard will also get there
+            };
+        } catch (Exception e) {
+            String msg = "GameAction:moveTo: Exception occured";
+
+            Breadcrumb bread = new Breadcrumb(msg);
+            bread.setData("Card", c.getName());
+            bread.setData("SA", cause.toString());
+            bread.setData("ZoneType", name.name());
+            bread.setData("Player", c.getOwner());
+            Sentry.addBreadcrumb(bread);
+
+            throw new RuntimeException("Error in GameAction moveTo " + c.getName() + " to Player Zone " + name.name(), e);
         }
     }
 
@@ -974,6 +975,7 @@ public class GameAction {
         // in some corner cases there's no zone yet (copied spell that failed targeting)
         if (z != null) {
             z.remove(c);
+            c.setZone(c.getOwner().getZone(ZoneType.None));
             if (z.is(ZoneType.Battlefield)) {
                 c.runLeavesPlayCommands();
             }
@@ -1600,9 +1602,7 @@ public class GameAction {
         }
 
         // recheck the game over condition at this point to make sure no other win conditions apply now.
-        if (!game.isGameOver()) {
-            checkGameOverCondition();
-        }
+        checkGameOverCondition();
 
         if (game.getAge() != GameStage.Play) {
             return false;
@@ -1822,8 +1822,8 @@ public class GameAction {
 
     private boolean stateBasedAction704_5q(Card c) {
         boolean checkAgain = false;
-        final CounterType p1p1 = CounterType.get(CounterEnumType.P1P1);
-        final CounterType m1m1 = CounterType.get(CounterEnumType.M1M1);
+        final CounterType p1p1 = CounterEnumType.P1P1;
+        final CounterType m1m1 = CounterEnumType.M1M1;
         int plusOneCounters = c.getCounters(p1p1);
         int minusOneCounters = c.getCounters(m1m1);
         if (plusOneCounters > 0 && minusOneCounters > 0) {
@@ -1843,7 +1843,7 @@ public class GameAction {
         return checkAgain;
     }
     private boolean stateBasedAction704_5r(Card c) {
-        final CounterType dreamType = CounterType.get(CounterEnumType.DREAM);
+        final CounterType dreamType = CounterEnumType.DREAM;
 
         int old = c.getCounters(dreamType);
         if (old <= 0) {
@@ -1883,6 +1883,10 @@ public class GameAction {
     }
 
     public void checkGameOverCondition() {
+        if (game.isGameOver()) {
+            return;
+        }
+
         // award loses as SBE
         GameEndReason reason = null;
         List<Player> losers = null;
@@ -2222,6 +2226,13 @@ public class GameAction {
         }
     }
 
+    public void revealUnsupported(Map<Player, List<PaperCard>> unsupported) {
+        // Notify players
+        for (Player p : game.getPlayers()) {
+            p.getController().revealUnsupported(unsupported);
+        }
+    }
+
     /** Delivers a message to all players. (use reveal to show Cards) */
     public void notifyOfValue(SpellAbility saSource, GameObject relatedTarget, String value, Player playerExcept) {
         if (saSource != null) {

forge-game/src/main/java/forge/game/GameActionUtil.java

@@ -125,10 +125,22 @@ public final class GameActionUtil {
 
             // need to be done there before static abilities does reset the card
             // These Keywords depend on the Mana Cost of for Split Cards
-            if (sa.isBasicSpell() && !sa.isLandAbility()) {
+            if (sa.isBasicSpell()) {
                 for (final KeywordInterface inst : source.getKeywords()) {
                     final String keyword = inst.getOriginal();
 
+                    if (keyword.startsWith("Mayhem")) {
+                        if (!source.isInZone(ZoneType.Graveyard) || !source.wasDiscarded() || !source.enteredThisTurn()) {
+                            continue;
+                        }
+
+                        alternatives.add(getGraveyardSpellByKeyword(inst, sa, activator, AlternativeCost.Mayhem));
+                    }
+
+                    if (sa.isLandAbility()) {
+                        continue;
+                    }
+
                     if (keyword.startsWith("Escape")) {
                         if (!source.isInZone(ZoneType.Graveyard)) {
                             continue;
@@ -165,26 +177,7 @@ public final class GameActionUtil {
                             continue;
                         }
 
-                        SpellAbility flashback = null;
-
-                        // there is a flashback cost (and not the cards cost)
-                        if (keyword.contains(":")) { // K:Flashback:Cost:ExtraParams:ExtraDescription
-                            final String[] k = keyword.split(":");
-                            flashback = sa.copyWithManaCostReplaced(activator, new Cost(k[1], false));
-                            String extraParams =  k.length > 2 ? k[2] : "";
-                            if (!extraParams.isEmpty()) {
-                                for (Map.Entry<String, String> param : AbilityFactory.getMapParams(extraParams).entrySet()) {
-                                    flashback.putParam(param.getKey(), param.getValue());
-                                }
-                            }
-                        } else { // same cost as original (e.g. Otaria plane)
-                            flashback = sa.copy(activator);
-                        }
-                        flashback.setAlternativeCost(AlternativeCost.Flashback);
-                        flashback.getRestrictions().setZone(ZoneType.Graveyard);
-                        flashback.setKeyword(inst);
-                        flashback.setIntrinsic(inst.isIntrinsic());
-                        alternatives.add(flashback);
+                        alternatives.add(getGraveyardSpellByKeyword(inst, sa, activator, AlternativeCost.Flashback));
                     } else if (keyword.startsWith("Harmonize")) {
                         if (!source.isInZone(ZoneType.Graveyard)) {
                             continue;
@@ -194,25 +187,7 @@ public final class GameActionUtil {
                             continue;
                         }
 
-                        SpellAbility harmonize = null;
-
-                        if (keyword.contains(":")) {
-                            final String[] k = keyword.split(":");
-                            harmonize = sa.copyWithManaCostReplaced(activator, new Cost(k[1], false));
-                            String extraParams =  k.length > 2 ? k[2] : "";
-                            if (!extraParams.isEmpty()) {
-                                for (Map.Entry<String, String> param : AbilityFactory.getMapParams(extraParams).entrySet()) {
-                                    harmonize.putParam(param.getKey(), param.getValue());
-                                }
-                            }
-                        } else {
-                            harmonize = sa.copy(activator);
-                        }
-                        harmonize.setAlternativeCost(AlternativeCost.Harmonize);
-                        harmonize.getRestrictions().setZone(ZoneType.Graveyard);
-                        harmonize.setKeyword(inst);
-                        harmonize.setIntrinsic(inst.isIntrinsic());
-                        alternatives.add(harmonize);
+                        alternatives.add(getGraveyardSpellByKeyword(inst, sa, activator, AlternativeCost.Harmonize));
                     } else if (keyword.startsWith("Foretell")) {
                         // Foretell cast only from Exile
                         if (!source.isInZone(ZoneType.Exile) || !source.isForetold() || source.enteredThisTurn() ||
@@ -267,6 +242,7 @@ public final class GameActionUtil {
                     }
                     stackCopy.setLastKnownZone(game.getStackZone());
                     stackCopy.setCastFrom(oldZone);
+                    stackCopy.setCastSA(sa);
                     lkicheck = true;
 
                     stackCopy.clearStaticChangedCardKeywords(false);
@@ -317,6 +293,30 @@ public final class GameActionUtil {
         return alternatives;
     }
 
+    public static SpellAbility getGraveyardSpellByKeyword(KeywordInterface inst, SpellAbility sa, Player activator, AlternativeCost altCost) {
+        String keyword = inst.getOriginal();
+        SpellAbility newSA = null;
+
+        // there is a flashback cost (and not the cards cost)
+        if (keyword.contains(":")) { // K:Flashback:Cost:ExtraParams:ExtraDescription
+            final String[] k = keyword.split(":");
+            newSA = sa.copyWithManaCostReplaced(activator, new Cost(k[1], false));
+            String extraParams =  k.length > 2 ? k[2] : "";
+            if (!extraParams.isEmpty()) {
+                for (Map.Entry<String, String> param : AbilityFactory.getMapParams(extraParams).entrySet()) {
+                    newSA.putParam(param.getKey(), param.getValue());
+                }
+            }
+        } else { // same cost as original (e.g. Otaria plane)
+            newSA = sa.copy(activator);
+        }
+        newSA.setAlternativeCost(altCost);
+        newSA.getRestrictions().setZone(ZoneType.Graveyard);
+        newSA.setKeyword(inst);
+        newSA.setIntrinsic(inst.isIntrinsic());
+        return newSA;
+    }
+
     public static List<SpellAbility> getMayPlaySpellOptions(final SpellAbility sa, final Card source, final Player activator, boolean altCostOnly) {
         final List<SpellAbility> alternatives = Lists.newArrayList();
 
@@ -993,9 +993,6 @@ public final class GameActionUtil {
             oldCard.setBackSide(false);
             oldCard.setState(oldCard.getFaceupCardStateName(), true);
             oldCard.unanimateBestow();
-            if (ability.isDisturb() || ability.hasParam("CastTransformed")) {
-                oldCard.undoIncrementTransformedTimestamp();
-            }
 
             if (ability.hasParam("Prototype")) {
                 oldCard.removeCloneState(oldCard.getPrototypeTimestamp());

forge-game/src/main/java/forge/game/GameEntity.java

@@ -33,17 +33,18 @@ 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.event.GameEventCardAttachment;
 import forge.game.keyword.Keyword;
 import forge.game.keyword.KeywordInterface;
+import forge.game.keyword.KeywordWithType;
 import forge.game.player.Player;
 import forge.game.replacement.ReplacementEffect;
 import forge.game.replacement.ReplacementType;
 import forge.game.spellability.SpellAbility;
+import forge.game.staticability.StaticAbility;
 import forge.game.staticability.StaticAbilityCantAttach;
 import forge.game.zone.ZoneType;
+import forge.util.Lang;
 
 public abstract class GameEntity extends GameObject implements IIdentifiable {
     protected int id;
@@ -197,14 +198,12 @@ public abstract class GameEntity extends GameObject implements IIdentifiable {
     public final void addAttachedCard(final Card c) {
         if (attachedCards.add(c)) {
             updateAttachedCards();
-            getGame().fireEvent(new GameEventCardAttachment(c, null, this));
         }
     }
 
     public final void removeAttachedCard(final Card c) {
         if (attachedCards.remove(c)) {
             updateAttachedCards();
-            getGame().fireEvent(new GameEventCardAttachment(c, this, null));
         }
     }
 
@@ -222,63 +221,83 @@ public abstract class GameEntity extends GameObject implements IIdentifiable {
         return canBeAttached(attach, sa, false);
     }
     public boolean canBeAttached(final Card attach, SpellAbility sa, boolean checkSBA) {
-        // master mode
-        if (!attach.isAttachment() || (attach.isCreature() && !attach.hasKeyword(Keyword.RECONFIGURE))
-                || equals(attach)) {
-            return false;
+        return cantBeAttachedMsg(attach, sa, checkSBA) == null;
+    }
+
+    public String cantBeAttachedMsg(final Card attach, SpellAbility sa) {
+        return cantBeAttachedMsg(attach, sa, false);
+    }
+    public String cantBeAttachedMsg(final Card attach, SpellAbility sa, boolean checkSBA) {
+        if (!attach.isAttachment()) {
+            return attach.getName() + " is not an attachment";
+        }
+        if (equals(attach)) {
+            return attach.getName() + " can't attach to itself";
+        }
+
+        if (attach.isCreature() && !attach.hasKeyword(Keyword.RECONFIGURE)) {
+            return attach.getName() + " is a creature without reconfigure";
         }
 
         if (attach.isPhasedOut()) {
-            return false;
+            return attach.getName() + " is phased out";
         }
 
-        // check for rules
-        if (attach.isAura() && !canBeEnchantedBy(attach)) {
-            return false;
+        if (attach.isAura()) {
+            String msg = cantBeEnchantedByMsg(attach);
+            if (msg != null) {
+                return msg;
+            }
         }
-        if (attach.isEquipment() && !canBeEquippedBy(attach, sa)) {
-            return false;
+        if (attach.isEquipment()) {
+            String msg = cantBeEquippedByMsg(attach, sa);
+            if (msg != null) {
+                return msg;
+            }
         }
-        if (attach.isFortification() && !canBeFortifiedBy(attach)) {
-            return false;
+        if (attach.isFortification()) {
+            String msg = cantBeFortifiedByMsg(attach);
+            if (msg != null) {
+                return msg;
+            }
         }
 
-        // check for can't attach static
-        if (StaticAbilityCantAttach.cantAttach(this, attach, checkSBA)) {
-            return false;
+        StaticAbility stAb = StaticAbilityCantAttach.cantAttach(this, attach, checkSBA);
+        if (stAb != null) {
+            return stAb.toString();
         }
 
-        // true for all
-        return true;
+        return null;
     }
 
-    protected boolean canBeEquippedBy(final Card aura, SpellAbility sa) {
-        /**
-         * Equip only to Creatures which are cards
-         */
-        return false;
-    }
-
-    protected boolean canBeFortifiedBy(final Card aura) {
+    protected String cantBeEquippedByMsg(final Card aura, SpellAbility sa) {
         /**
          * Equip only to Lands which are cards
          */
-        return false;
+        return getName() + " is not a Creature";
     }
 
-    protected boolean canBeEnchantedBy(final Card aura) {
+    protected String cantBeFortifiedByMsg(final Card fort) {
+        /**
+         * Equip only to Lands which are cards
+         */
+        return getName() + " is not a Land";
+    }
+
+    protected String cantBeEnchantedByMsg(final Card aura) {
         if (!aura.hasKeyword(Keyword.ENCHANT)) {
-            return false;
+            return "No Enchant Keyword";
         }
         for (KeywordInterface ki : aura.getKeywords(Keyword.ENCHANT)) {
-            String k = ki.getOriginal();
-            String m[] = k.split(":");
-            String v = m[1];
-            if (!isValid(v.split(","), aura.getController(), aura, null)) {
-                return false;
+            if (ki instanceof KeywordWithType kwt) {
+                String v = kwt.getValidType();
+                String desc = kwt.getTypeDescription();
+                if (!isValid(v.split(","), aura.getController(), aura, null)) {
+                    return getName() + " is not " + Lang.nounWithAmount(1, desc);
+                }
             }
         }
-        return true;
+        return null;
     }
 
     public boolean hasCounters() {
@@ -305,9 +324,6 @@ public abstract class GameEntity extends GameObject implements IIdentifiable {
         Integer value = counters.get(counterName);
         return value == null ? 0 : value;
     }
-    public final int getCounters(final CounterEnumType counterType) {
-        return getCounters(CounterType.get(counterType));
-    }
 
     public void setCounters(final CounterType counterType, final Integer num) {
         if (num <= 0) {
@@ -316,9 +332,6 @@ public abstract class GameEntity extends GameObject implements IIdentifiable {
             counters.put(counterType, num);
         }
     }
-    public void setCounters(final CounterEnumType counterType, final Integer num) {
-        setCounters(CounterType.get(counterType), num);
-    }
 
     abstract public void setCounters(final Map<CounterType, Integer> allCounters);
 
@@ -328,10 +341,6 @@ public abstract class GameEntity extends GameObject implements IIdentifiable {
     abstract public int subtractCounter(final CounterType counterName, final int n, final Player remover);
     abstract public void clearCounters();
 
-    public boolean canReceiveCounters(final CounterEnumType type) {
-        return canReceiveCounters(CounterType.get(type));
-    }
-
     public final void addCounter(final CounterType counterType, int n, final Player source, GameEntityCounterTable table) {
         if (n <= 0 || !canReceiveCounters(counterType)) {
             // As per rule 107.1b
@@ -351,18 +360,7 @@ public abstract class GameEntity extends GameObject implements IIdentifiable {
         table.put(source, this, counterType, n);
     }
 
-    public final void addCounter(final CounterEnumType counterType, final int n, final Player source, GameEntityCounterTable table) {
-        addCounter(CounterType.get(counterType), n, source, table);
-    }
-
-    public int subtractCounter(final CounterEnumType counterName, final int n, final Player remover) {
-        return subtractCounter(CounterType.get(counterName), n, remover);
-    }
-
     abstract public void addCounterInternal(final CounterType counterType, final int n, final Player source, final boolean fireEvents, GameEntityCounterTable table, Map<AbilityKey, Object> params);
-    public void addCounterInternal(final CounterEnumType counterType, final int n, final Player source, final boolean fireEvents, GameEntityCounterTable table, Map<AbilityKey, Object> params) {
-        addCounterInternal(CounterType.get(counterType), n, source, fireEvents, table, params);
-    }
     public Integer getCounterMax(final CounterType counterType) {
         return null;
     }

forge-game/src/main/java/forge/game/GameLogEntryType.java

@@ -6,6 +6,7 @@ public enum GameLogEntryType {
     TURN("Turn"),
     MULLIGAN("Mulligan"),
     ANTE("Ante"),
+    DRAFT("Draft"),
     ZONE_CHANGE("Zone Change"),
     PLAYER_CONTROL("Player control"),
     COMBAT("Combat"),

forge-game/src/main/java/forge/game/GameLogFormatter.java

@@ -29,25 +29,25 @@ public class GameLogFormatter extends IGameEventVisitor.Base<GameLogEntry> {
     @Override
     public GameLogEntry visit(GameEventGameOutcome ev) {
         // Turn number counted from the starting player
-        int lastTurn = (int)Math.ceil((float)ev.result.getLastTurnNumber() / 2.0);
+        int lastTurn = (int)Math.ceil((float)ev.result().getLastTurnNumber() / 2.0);
         log.add(GameLogEntryType.GAME_OUTCOME, localizer.getMessage("lblTurn") + " " + lastTurn);
 
-        for (String outcome : ev.result.getOutcomeStrings()) {
+        for (String outcome : ev.result().getOutcomeStrings()) {
             log.add(GameLogEntryType.GAME_OUTCOME, outcome);
         }
-        return generateSummary(ev.history);
+        return generateSummary(ev.history());
     }
 
     @Override
     public GameLogEntry visit(GameEventScry ev) {
         String scryOutcome = "";
 
-        if (ev.toTop > 0 && ev.toBottom > 0) {
-            scryOutcome = localizer.getMessage("lblLogScryTopBottomLibrary").replace("%s", ev.player.toString()).replace("%top", String.valueOf(ev.toTop)).replace("%bottom", String.valueOf(ev.toBottom));
-        } else if (ev.toBottom == 0) {
-            scryOutcome = localizer.getMessage("lblLogScryTopLibrary").replace("%s", ev.player.toString()).replace("%top", String.valueOf(ev.toTop));
+        if (ev.toTop() > 0 && ev.toBottom() > 0) {
+            scryOutcome = localizer.getMessage("lblLogScryTopBottomLibrary").replace("%s", ev.player().toString()).replace("%top", String.valueOf(ev.toTop())).replace("%bottom", String.valueOf(ev.toBottom()));
+        } else if (ev.toBottom() == 0) {
+            scryOutcome = localizer.getMessage("lblLogScryTopLibrary").replace("%s", ev.player().toString()).replace("%top", String.valueOf(ev.toTop()));
         } else {
-            scryOutcome = localizer.getMessage("lblLogScryBottomLibrary").replace("%s", ev.player.toString()).replace("%bottom", String.valueOf(ev.toBottom));
+            scryOutcome = localizer.getMessage("lblLogScryBottomLibrary").replace("%s", ev.player().toString()).replace("%bottom", String.valueOf(ev.toBottom()));
         }
 
         return new GameLogEntry(GameLogEntryType.STACK_RESOLVE, scryOutcome);
@@ -57,12 +57,12 @@ public class GameLogFormatter extends IGameEventVisitor.Base<GameLogEntry> {
     public GameLogEntry visit(GameEventSurveil ev) {
         String surveilOutcome = "";
 
-        if (ev.toLibrary > 0 && ev.toGraveyard > 0) {
-            surveilOutcome = localizer.getMessage("lblLogSurveiledToLibraryGraveyard", ev.player.toString(), String.valueOf(ev.toLibrary), String.valueOf(ev.toGraveyard));
-        } else if (ev.toGraveyard == 0) {
-            surveilOutcome = localizer.getMessage("lblLogSurveiledToLibrary", ev.player.toString(), String.valueOf(ev.toLibrary));
+        if (ev.toLibrary() > 0 && ev.toGraveyard() > 0) {
+            surveilOutcome = localizer.getMessage("lblLogSurveiledToLibraryGraveyard", ev.player().toString(), String.valueOf(ev.toLibrary()), String.valueOf(ev.toGraveyard()));
+        } else if (ev.toGraveyard() == 0) {
+            surveilOutcome = localizer.getMessage("lblLogSurveiledToLibrary", ev.player().toString(), String.valueOf(ev.toLibrary()));
         } else {
-            surveilOutcome = localizer.getMessage("lblLogSurveiledToGraveyard", ev.player.toString(), String.valueOf(ev.toGraveyard));
+            surveilOutcome = localizer.getMessage("lblLogSurveiledToGraveyard", ev.player().toString(), String.valueOf(ev.toGraveyard()));
         }
 
         return new GameLogEntry(GameLogEntryType.STACK_RESOLVE, surveilOutcome);
@@ -70,26 +70,26 @@ public class GameLogFormatter extends IGameEventVisitor.Base<GameLogEntry> {
 
     @Override
     public GameLogEntry visit(GameEventSpellResolved ev) {
-        String messageForLog = ev.hasFizzled ? localizer.getMessage("lblLogCardAbilityFizzles", ev.spell.getHostCard().toString()) : ev.spell.getStackDescription();
+        String messageForLog = ev.hasFizzled() ? localizer.getMessage("lblLogCardAbilityFizzles", ev.spell().getHostCard().toString()) : ev.spell().getStackDescription();
         return new GameLogEntry(GameLogEntryType.STACK_RESOLVE, messageForLog);
     }
 
     @Override
     public GameLogEntry visit(GameEventSpellAbilityCast event) {
-        String player = event.sa.getActivatingPlayer().getName();
-        String action = event.sa.isSpell() ? localizer.getMessage("lblCast")
-                : event.sa.isTrigger() ? localizer.getMessage("lblTriggered")
+        String player = event.sa().getActivatingPlayer().getName();
+        String action = event.sa().isSpell() ? localizer.getMessage("lblCast")
+                : event.sa().isTrigger() ? localizer.getMessage("lblTriggered")
                         : localizer.getMessage("lblActivated");
-        String object = event.si.getStackDescription().startsWith("Morph ")
+        String object = event.si().getStackDescription().startsWith("Morph ")
                 ? localizer.getMessage("lblMorph")
-                : event.sa.getHostCard().toString();
+                : event.sa().getHostCard().toString();
 
         String messageForLog = "";
 
-        if (event.sa.getTargetRestrictions() != null) {
+        if (event.sa().getTargetRestrictions() != null) {
             StringBuilder sb = new StringBuilder();
 
-            for (TargetChoices ch : event.sa.getAllTargetChoices()) {
+            for (TargetChoices ch : event.sa().getAllTargetChoices()) {
                 if (null != ch) {
                     sb.append(ch);
                 }
@@ -104,18 +104,18 @@ public class GameLogFormatter extends IGameEventVisitor.Base<GameLogEntry> {
 
     @Override
     public GameLogEntry visit(GameEventCardModeChosen ev) {
-        if (!ev.log) {
+        if (!ev.log()) {
             return null;
         }
 
         String modeChoiceOutcome;
-        if (ev.random) {
-            modeChoiceOutcome = localizer.getMessage("lblLogRandomMode", ev.cardName, ev.mode);
+        if (ev.random()) {
+            modeChoiceOutcome = localizer.getMessage("lblLogRandomMode", ev.cardName(), ev.mode());
         } else {
             modeChoiceOutcome = localizer.getMessage("lblLogPlayerChosenModeForCard",
-                    ev.player.toString(), ev.mode, ev.cardName);
+                    ev.player().toString(), ev.mode(), ev.cardName());
         }
-        String name = CardTranslation.getTranslatedName(ev.cardName);
+        String name = CardTranslation.getTranslatedName(ev.cardName());
         modeChoiceOutcome = TextUtil.fastReplace(modeChoiceOutcome, "CARDNAME", name);
         modeChoiceOutcome = TextUtil.fastReplace(modeChoiceOutcome, "NICKNAME",
                 Lang.getInstance().getNickName(name));
@@ -124,7 +124,7 @@ public class GameLogFormatter extends IGameEventVisitor.Base<GameLogEntry> {
 
     @Override
     public GameLogEntry visit(GameEventRandomLog ev) {
-        return new GameLogEntry(GameLogEntryType.STACK_RESOLVE, ev.message);
+        return new GameLogEntry(GameLogEntryType.STACK_RESOLVE, ev.message());
     }
 
     private static GameLogEntry generateSummary(final Collection<GameOutcome> gamesPlayed) {
@@ -152,8 +152,8 @@ public class GameLogFormatter extends IGameEventVisitor.Base<GameLogEntry> {
 
     @Override
     public GameLogEntry visit(final GameEventPlayerControl event) {
-        final LobbyPlayer newLobbyPlayer = event.newLobbyPlayer;
-        final Player p = event.player;
+        final LobbyPlayer newLobbyPlayer = event.newLobbyPlayer();
+        final Player p = event.player();
 
         final String message;
         if (newLobbyPlayer == null) {
@@ -166,23 +166,23 @@ public class GameLogFormatter extends IGameEventVisitor.Base<GameLogEntry> {
 
     @Override
     public GameLogEntry visit(GameEventTurnPhase ev) {
-        Player p = ev.playerTurn;
-        return new GameLogEntry(GameLogEntryType.PHASE, ev.phaseDesc + Lang.getInstance().getPossessedObject(p.getName(), ev.phase.nameForUi));
+        Player p = ev.playerTurn();
+        return new GameLogEntry(GameLogEntryType.PHASE, ev.phaseDesc() + Lang.getInstance().getPossessedObject(p.getName(), ev.phase().nameForUi));
     }
 
     @Override
     public GameLogEntry visit(GameEventCardDamaged event) {
         String additionalLog = "";
-        if (event.type == DamageType.Deathtouch) {
+        if (event.type() == DamageType.Deathtouch) {
             additionalLog = localizer.getMessage("lblDeathtouch");
         }
-        if (event.type == DamageType.M1M1Counters) {
+        if (event.type() == DamageType.M1M1Counters) {
             additionalLog = localizer.getMessage("lblAsM1M1Counters");
         }
-        if (event.type == DamageType.LoyaltyLoss) {
-            additionalLog = localizer.getMessage("lblRemovingNLoyaltyCounter", String.valueOf(event.amount));
+        if (event.type() == DamageType.LoyaltyLoss) {
+            additionalLog = localizer.getMessage("lblRemovingNLoyaltyCounter", String.valueOf(event.amount()));
         }
-        String message = localizer.getMessage("lblSourceDealsNDamageToDest", event.source.toString(), String.valueOf(event.amount), additionalLog, event.card.toString());
+        String message = localizer.getMessage("lblSourceDealsNDamageToDest", event.source().toString(), String.valueOf(event.amount()), additionalLog, event.card().toString());
         return new GameLogEntry(GameLogEntryType.DAMAGE, message);
     }
 
@@ -191,43 +191,43 @@ public class GameLogFormatter extends IGameEventVisitor.Base<GameLogEntry> {
      */
     @Override
     public GameLogEntry visit(GameEventLandPlayed ev) {
-        String message = localizer.getMessage("lblLogPlayerPlayedLand", ev.player.toString(), ev.land.toString());
+        String message = localizer.getMessage("lblLogPlayerPlayedLand", ev.player().toString(), ev.land().toString());
         return new GameLogEntry(GameLogEntryType.LAND, message);
     }
 
     @Override
     public GameLogEntry visit(GameEventTurnBegan event) {
-        String message = localizer.getMessage("lblLogTurnNOwnerByPlayer", String.valueOf(event.turnNumber), event.turnOwner.toString());
+        String message = localizer.getMessage("lblLogTurnNOwnerByPlayer", String.valueOf(event.turnNumber()), event.turnOwner().toString());
         return new GameLogEntry(GameLogEntryType.TURN, message);
     }
 
     @Override
     public GameLogEntry visit(GameEventPlayerDamaged ev) {
-        String extra = ev.infect ? localizer.getMessage("lblLogAsPoisonCounters") : "";
-        String damageType = ev.combat ? localizer.getMessage("lblCombat") : localizer.getMessage("lblNonCombat");
-        String message = localizer.getMessage("lblLogSourceDealsNDamageOfTypeToDest", ev.source.toString(),
-                            String.valueOf(ev.amount), damageType, ev.target.toString(), extra);
+        String extra = ev.infect() ? localizer.getMessage("lblLogAsPoisonCounters") : "";
+        String damageType = ev.combat() ? localizer.getMessage("lblCombat") : localizer.getMessage("lblNonCombat");
+        String message = localizer.getMessage("lblLogSourceDealsNDamageOfTypeToDest", ev.source().toString(),
+                            String.valueOf(ev.amount()), damageType, ev.target().toString(), extra);
         return new GameLogEntry(GameLogEntryType.DAMAGE, message);
     }
 
     @Override
     public GameLogEntry visit(GameEventPlayerPoisoned ev) {
         String message = localizer.getMessage("lblLogPlayerReceivesNPosionCounterFrom",
-                            ev.receiver.toString(), String.valueOf(ev.amount), ev.source.toString());
+                            ev.receiver().toString(), String.valueOf(ev.amount()), ev.source().toString());
         return new GameLogEntry(GameLogEntryType.DAMAGE, message);
     }
 
     @Override
     public GameLogEntry visit(GameEventPlayerRadiation ev) {
         String message;
-        final int change = ev.change;
+        final int change = ev.change();
         String radCtr = CounterEnumType.RAD.getName().toLowerCase() + " " +
                 Localizer.getInstance().getMessage("lblCounter").toLowerCase();
         if (change >= 0) message = localizer.getMessage("lblLogPlayerRadiation",
-                ev.receiver.toString(), Lang.nounWithNumeralExceptOne(String.valueOf(change), radCtr),
-                ev.source.toString());
+                ev.receiver().toString(), Lang.nounWithNumeralExceptOne(String.valueOf(change), radCtr),
+                ev.source().toString());
         else message = localizer.getMessage("lblLogPlayerRadRemove",
-                ev.receiver.toString(), Lang.nounWithNumeralExceptOne(String.valueOf(Math.abs(change)), radCtr));
+                ev.receiver().toString(), Lang.nounWithNumeralExceptOne(String.valueOf(Math.abs(change)), radCtr));
         return new GameLogEntry(GameLogEntryType.DAMAGE, message);
     }
 
@@ -239,16 +239,16 @@ public class GameLogFormatter extends IGameEventVisitor.Base<GameLogEntry> {
         // Append Defending Player/Planeswalker
 
         // Not a big fan of the triple nested loop here
-        for (GameEntity k : ev.attackersMap.keySet()) {
-            Collection<Card> attackers = ev.attackersMap.get(k);
+        for (GameEntity k : ev.attackersMap().keySet()) {
+            Collection<Card> attackers = ev.attackersMap().get(k);
             if (attackers == null || attackers.isEmpty()) {
                 continue;
             }
             if (sb.length() > 0) sb.append("\n");
-            sb.append(localizer.getMessage("lblLogPlayerAssignedAttackerToAttackTarget", ev.player, Lang.joinHomogenous(attackers), k));
+            sb.append(localizer.getMessage("lblLogPlayerAssignedAttackerToAttackTarget", ev.player(), Lang.joinHomogenous(attackers), k));
         }
         if (sb.length() == 0) {
-            sb.append(localizer.getMessage("lblPlayerDidntAttackThisTurn").replace("%s", ev.player.toString()));
+            sb.append(localizer.getMessage("lblPlayerDidntAttackThisTurn").replace("%s", ev.player().toString()));
         }
         return new GameLogEntry(GameLogEntryType.COMBAT, sb.toString());
     }
@@ -262,7 +262,7 @@ public class GameLogFormatter extends IGameEventVisitor.Base<GameLogEntry> {
 
         Collection<Card> blockers = null;
 
-        for (Entry<GameEntity, MapOfLists<Card, Card>> kv : ev.blockers.entrySet()) {
+        for (Entry<GameEntity, MapOfLists<Card, Card>> kv : ev.blockers().entrySet()) {
             GameEntity defender = kv.getKey();
             MapOfLists<Card, Card> attackers = kv.getValue();
             if (attackers == null || attackers.isEmpty()) {
@@ -298,7 +298,7 @@ public class GameLogFormatter extends IGameEventVisitor.Base<GameLogEntry> {
 
     @Override
     public GameLogEntry visit(GameEventMulligan ev) {
-        String message = localizer.getMessage("lblPlayerHasMulliganedDownToNCards").replace("%d", String.valueOf(ev.player.getZone(ZoneType.Hand).size())).replace("%s", ev.player.toString());
+        String message = localizer.getMessage("lblPlayerHasMulliganedDownToNCards").replace("%d", String.valueOf(ev.player().getZone(ZoneType.Hand).size())).replace("%s", ev.player().toString());
         return new GameLogEntry(GameLogEntryType.MULLIGAN, message);
     }
 

forge-game/src/main/java/forge/game/GameRules.java

@@ -15,6 +15,7 @@ public class GameRules {
     private boolean AISideboardingEnabled = false;
     private boolean sideboardForAI = false;
     private final Set<GameType> appliedVariants = EnumSet.noneOf(GameType.class);
+    private int simTimeout = 120;
 
     // it's a preference, not rule... but I could hardly find a better place for it
     private boolean useGrayText;
@@ -124,4 +125,12 @@ public class GameRules {
     public void setWarnAboutAICards(final boolean warnAboutAICards) {
         this.warnAboutAICards = warnAboutAICards;
     }
+
+    public int getSimTimeout() {
+        return this.simTimeout;
+    }
+
+    public void setSimTimeout(final int duration) {
+        this.simTimeout = duration;
+    }
 }